在ray.remote中同步循环
是指使用Ray框架中的ray.remote装饰器来创建一个远程函数，并在该函数内部使用循环进行同步操作。
具体来说，Ray是一个用于构建分布式应用程序的开源框架，它提供了一种简单且高效的方式来编写并行和分布式代码。ray.remote装饰器用于将一个函数标记为远程函数，使其可以在分布式环境中执行。
在ray.remote中使用同步循环可以实现以下功能：
- 并行计算：通过将循环体内的计算任务分配给不同的计算资源，可以实现并行计算，提高计算效率。
- 数据共享：循环体内的变量可以在不同的远程任务之间进行共享，从而实现数据的共享和传递。
- 同步操作：通过循环的方式，可以确保每个远程任务按照一定的顺序执行，从而实现同步操作。
在应用场景上，使用ray.remote中的同步循环可以适用于以下情况：
- 数据处理：当需要对大量数据进行处理时，可以将数据分成多个部分，使用同步循环将处理任务分配给不同的计算资源进行并行处理。
- 模型训练：在机器学习和深度学习中，循环可以用于迭代训练过程，将训练任务分配给不同的计算资源进行并行训练。
- 批量任务处理：当需要处理大量的任务时，可以使用同步循环将任务分配给不同的计算资源进行并行处理，提高任务处理速度。
在腾讯云中，可以使用Ray框架来实现同步循环。腾讯云提供了弹性计算服务，如云服务器、容器服务等，可以用于部署和运行Ray框架。此外，腾讯云还提供了云函数、云批量计算等服务，可以用于实现更灵活和高效的任务调度和执行。
更多关于Ray框架的信息和使用方法，可以参考腾讯云的官方文档：
- Ray官方文档：https://docs.ray.io/
- 腾讯云弹性计算服务：https://cloud.tencent.com/product/cvm
- 腾讯云云函数：https://cloud.tencent.com/product/scf
- 腾讯云云批量计算：https://cloud.tencent.com/product/batch
相关·内容
1回答
我有一个庞大的远程函数，它与ray并行化，但在它里面，有一个循环我真的需要串行执行-每个迭代都要全局执行一次，而且只执行一次。因此，我的想法是使用一个互斥锁来同步正在执行的线程 import ray
ray.init ()
@ray.remote
def remote_function ():
# misc calculation
# loop to be synchronized
lock (mutex)
for i in range (gazillion):
# do some prep work
unlock
浏览 53提问于2020-08-12得票数 0
我尝试使用导入的函数作为ray远程函数，但是声明远程函数的常用语法似乎不起作用。在stackoverflow上还有其他几个相关的问题没有完全回答我的问题，请参阅：here和here。链接1“似乎”解决了这个问题，但看起来非常笨拙，看起来并不像我期望的ray开发人员打算使用的方式。引用2解决了一个类似的问题‘除了’如果你需要给修饰函数提供参数(就像我在我的例子中做的那样)，那么它会返回以下错误： AssertionError: The @ray.remote decorator must be applied either with no arguments and no parenthese
浏览 26提问于2021-08-20得票数 0
下面的代码执行所需的行为。是否有可能传递前两个函数的第二个参数而不必过早调用ray.get？
@ray.remote
def color():
image=cv2.imread("frame30.png", flags=0)
argument= "Hello"
return image,argument
@ray.remote
def black():
image=cv2.imread("frame30.png", flags=0)
argument= "world"
return
浏览 3提问于2021-02-23得票数 3
回答已采纳
我可以在ray仪表板上看到哪些函数分配给了哪个worker。有没有可能打印出哪个函数是由哪个worker执行的，而不是在仪表板上查找它？ 代码示例： @ray.remote
def mul1(x):
return x*x
@ray.remote
def mul2(y):
return y*y
@ray.remote
def add(x,y):
return x+y
futures = add.remote(mul1.remote(2), mul2.remote(3))
ray.get(futures) ? ? 期望输出 PID: 2838 - mul2()
浏览 20提问于2021-02-25得票数 0
回答已采纳
1回答
我使用一个名为的Python包并行运行下面的示例。代码运行在一台有80个CPU核和4个GPU的机器上。
import ray
import time
ray.init()
@ray.remote
def squared(x):
time.sleep(1)
y = x**2
return y
tic = time.perf_counter()
lazy_values = [squared.remote(x) for x in range(1000)]
values = ray.get(lazy_values)
toc = time.perf_counter()
浏览 10提问于2022-01-25得票数 1
回答已采纳
我试着在没有def的情况下做这件事，这是我真的不知道该怎么做的代码，我也试着给出正确的缩进 但是，当我运行它时，它抛出错误:无效语法 import ray
ray.init()
@ray.remote
try:
Func1()
except:
pass
ray.get([func1.remote()])
def func1():
for i in range (99999):
print("h")```
The error is invalid syntax at try:
This is the code t
浏览 3提问于2019-05-27得票数 1
回答已采纳
我有一个看起来像这样的脚本： my_dict = {}
@ray.remote
def f(n):
# adds to my_dict after parsing through a
# large file that was split up into 8 sections;
# each section is parsed in parallel using ray
tasks = [f.remote(i) for i in range(1,9)]
ray.get(tasks)
with open('my_csv.csv', 'w
浏览 36提问于2020-07-18得票数 0
1回答
我有三个文件，如下 """ main.py """
import time
import ray
class LocalBuffer(dict):
def __call__(self):
return self
@ray.remote
class Worker():
def __init__(self, learner):
self.local = LocalBuffer()
self.learner = learner
def sample(self):
浏览 12提问于2019-03-03得票数 0
很基本的问题，但我在文档里找不到答案。我正在用Python开发一个计算密集型的应用程序，我使用Ray来并行化计算。我只使用远程函数(因此没有Actor)，我有40个可用的内核。
当主脚本发送一些高于40的任务时，会发生什么情况？Ray能够处理它吗?还是应该始终控制任务的数量，以便将其保持在可用内核的数量之下？
浏览 1提问于2022-02-16得票数 0
1回答
我试图增加一个计数器变量，它保持了总操作数，并且应该在并行进程之间共享来增加它，为此，我得到的解决方案是Ray中的"Actor“，但它也不起作用。a的值并没有增加，它只是增加了1并保持不变。
似乎每个进程都在创建自己的计数器对象副本。我怎样才能只对面向对象的方法做同样的事情呢？
当我使用Python多处理multiprocessing.Pool().apply_async(A.task1,callback=self.task2())时，同样的方法也在起作用。我怎么能在雷中做同样的事情，或者如果在达斯克是可能的话？
import ray, time
@ray.remote
class
浏览 11提问于2022-10-14得票数 0
具体地说，我希望我的参数store worker总是在HEAD节点上调用，而不是在任何worker上调用。这样我就可以优化资源配置。目前，参数存储任务似乎是在随机服务器上启动的，即使它是首先调用的，即使它后面跟着一个ray.get() 也许可以这样做：ps = ParameterStore.remote(onHead=True)
浏览 21提问于2019-06-10得票数 1
回答已采纳
1回答
我必须编写一个伪函数来让我的代码在不同的系统上运行，其中一些系统没有所需的包。该函数被包装起来，然后像class-function一样被调用。我正在努力解决这个问题，有什么办法吗？ 这里我得到了一个简短的代码片段，我导入了一个应该包含这个remote()函数的python脚本ray.py。remote函数必须接受两个参数，没有任何用法。 编辑：@ray.remote()将run()函数包装为并行可执行的。它不会改变run()的返回。在一些系统上不支持ray，我希望相同的脚本顺序执行，而不做任何更改。因此，我import一个ray-dummy，而不是真正的。现在，我想编写ray.remote(
浏览 38提问于2020-12-29得票数 1
1回答
我定义了learner和worker。我希望learner在后台运行它的成员函数learn，并且偶尔worker会发送一些信息给learner打印。
下面的代码是一个示例
import ray
@ray.remote
class Learner():
def __init__(self):
pass
def learn(self):
while True:
pass # do something, such as updating network
def log_score(self, score):
浏览 2提问于2019-03-01得票数 2
回答已采纳
2回答
我开始使用ray进行分布式机器学习，但我已经遇到了一些问题。内存使用量一直在增长，直到程序崩溃。尽管我不断地清除列表，但内存还是以某种方式泄漏了。知道为什么吗？
我的规格:操作系统平台和发行版: Ubuntu 16.04 Ray安装者: binary Ray版本: 0.6.5 Python版本:3.6.8
我已经尝试使用实验性队列而不是DataServer类，但问题仍然存在。
import numpy as np
import ray
import time
ray.init(redis_max_memory=100000000)
@ray.remote
class Runner():
浏览 3提问于2019-04-18得票数 11
我在Cython身上涂了射线。它显示了一个错误: TypeError:必须将@ray.remote装饰器应用于函数或类。
如何解决这个问题？谢谢。
setup.py:
from distutils.core import setup, Extension
from Cython.Build import cythonize
import numpy
setup(
ext_modules=cythonize("ray_cython.pyx"),
include_dirs=[numpy.get_include()]
)
setup(
ext_modul
浏览 11提问于2022-06-07得票数 0
回答已采纳
sudo pip3 install ray后
我创建了一个在射线装饰器中定义的函数foo()，：
import ray
ray.init()
@ray.remote
def foo(x):
print(x)
我希望能够在并行模式和常规模式(忽略修饰器)中使用foo。
如果我想使用没有foo的.remote( blabla_variable )，它将返回一个错误。
当我不需要的时候，请建议如何“忽略”装饰师。
浏览 5提问于2020-06-10得票数 2
回答已采纳
我试图使用process包，从类中并行化卷积过程。
这意味着我使用@ray.remote装饰器将函数设置为类函数。
但是，当我这样做时，就会出现一个与参数默认值有关的错误。
我刚开始使用射线和装饰器，所以我想知道是否有人对我出错的地方有一些建议，因为我认为这并不像为类函数提供一个可选的默认参数(例如None )那样简单。
下面是代码的简化版本：
import numpy as np
import psutil
import ray
from astropy.convolution import convolve
class test_class:
def __init__(sel
浏览 0提问于2020-01-10得票数 1
5回答
Python中的并行性
、、、
在Python中实现并行性的选择是什么？我想在一些非常大的栅格上执行一些CPU绑定计算，并希望并行化它们。来自C背景，我熟悉三种并行处理方法：
消息传递过程，可能分布在集群中，例如MPI。
显式共享内存并行性，使用p线程或叉()、管道()、et。阿尔
隐式共享内存并行，使用OpenMP。
决定一种使用方法是一种权衡的做法。
在Python中，有哪些方法可用，它们的特点是什么？有一个可集群的MPI克隆吗？实现共享内存并行的首选方法是什么？我听过有人提到GIL的问题，也有关于工作任务的说法。
简而言之，在选择Python中的不同并行化策略之前，我需要了解它们的哪些方面？
浏览 11提问于2010-06-07得票数 26
回答已采纳
根据this document的说法，我必须插入os.environ["MKL_NUM_THREADS"] = "1"以防止numpy使用多个内核。但是我应该把这个插入到哪里呢？在numpy之前还是在每个参与者的构造中？是否应该在Learner中使用它 例如，如果我有以下三个文件，我应该将其插入到哪里？ """ learner.py """
import numpy as np
import ray
@ray.remote
class Learner:
def __init__(self):
浏览 236提问于2019-06-04得票数 0
回答已采纳
2回答
我在主函数/进程中使用了日志记录模块，它工作得很好，但它似乎不能在Actor进程/子进程中工作。如何让它工作？在下面的示例代码中，logging.info在主进程中工作，但在辅助进程中失败。谢谢。
import logging
import ray
@ray.remote
class Worker(object):
...
def train(self):
logging.info("fail print")
...
worker = Worker.remote()
ray.get(worker.train.remote())
loggi
浏览 1提问于2019-03-21得票数 7
1回答
我只有一个gpu，我想在这个gpu上运行很多演员。下面是我使用ray所做的工作，下面是
首先定义gpu上的网络
class Network():
def __init__(self, ***some args here***):
self._graph = tf.Graph()
os.environ['CUDA_VISIBLE_DIVICES'] = ','.join([str(i) for i in ray.get_gpu_ids()])
with self._graph.as_default
浏览 0提问于2019-02-02得票数 3
回答已采纳
假设我有三个模块：
mod1 mod2 mod3
其中，只要调用mod.launch()，它们中的每一个都会无限地运行。
有哪些优雅的方法可以一次启动所有这些无限循环，而不需要等待一个循环完成后再调用另一个循环？
假设我有一种launcher.py，我会尝试：
import mod1
import mod2
import mod3
if __name__ == "__main__":
mod1.launch()
mod2.launch()
mod3.launch()
这显然不起作用，因为它将等待mod1.launch()完成，然后再启动mod2.lau
浏览 0提问于2019-02-08得票数 0
1回答
我对ray很陌生，我正在尝试并行化我开发的模拟器。这里有一个我的模拟器的例子，它显然更复杂。
import some_library
import sim_library_with_global_object
class Model(object):
def __init__(self,init_vals):
#initialize object using some of the global_object from sim_library.
#the Model object have it's own variables not glob
浏览 3提问于2020-11-08得票数 2
请考虑以下示例：
import numpy as np
import ray
import time
A = np.array([42] * 4200)
@ray.remote
def foo1(x):
x[5]**2
@ray.remote
def foo2(j):
A[j]**2
ray.init()
#
# some warmup for ray
#
start = time.perf_counter()
for _ in range(1000):
ray.get(foo1.remote(A))
time_foo1 = time.perf_cou
浏览 1提问于2020-09-03得票数 1
回答已采纳
当我使用Raywithpy手电筒时，我不会为远程类设置任何num_gpus标志。
我得到以下错误：
RuntimeError: Attempting to deserialize object on a CUDA device but torch.cuda.is_available() is False.
主要过程是:我创建了一个远程类，并将一个pytorch模型state_dict()(created in main function)传递给它。在主函数中，torch.cuda.is_available()是True，而在远程函数中，torch.cuda.is_available()是Fa
浏览 0提问于2019-01-30得票数 4
我正在学习如何使用python包并行我的代码。我遇到了一个类的问题，它的方法是用@ray.remote修饰的。
我可以导入中的类、相同的文件夹并在类中执行该方法。但是，在将类导入到另一个目录之后，当调用该方法时，它将引发ModuleNotFoundError。
根据错误的跟踪，当程序找不到所需的模块时，问题似乎是反序列化过程。
下面是我的问题的一个最小的工作例子。
Structure of the directory.
folder/
main/
a_class.py
process_in_main.py
processing/
浏览 1提问于2020-01-19得票数 0
我有一个远程类，比如(使用ray应用程序接口)
@ray.remote
class className
....
我想启动这个类的60个或更多的实例，让它们同时做一些工作。
但是，我不能同时启动超过50个这个类的实例。
如何更改最大值。在任何给定时间，python脚本内部允许的线程数是多少？
浏览 0提问于2020-08-25得票数 1
我有一个远程函数，它“拆分”输入并返回一个迭代器。 然后，我想将一个远程函数映射到这个返回的可迭代对象(这是构造图形时的一个ObjectID )。如下所示： import ray
@ray.remote
def split(string):
return string.split('-')
@ray.remote
def process(substring):
print('Working on', substring)
ray.init()
substrings = split.remote('some-variable-len
浏览 13提问于2020-07-05得票数 1
2回答
我希望使用射线任务方法，而不是射线参与者方法来并行化类中的方法。原因是后者似乎需要更改类实例化的方式(如所示)。下面是一个玩具代码示例，以及错误
import numpy as np
import ray
class MyClass(object):
def __init__(self):
ray.init(num_cpus=4)
@ray.remote
def func(self, x, y):
return x * y
def my_func(self):
a = [1, 2,
浏览 6提问于2020-10-12得票数 4
我使用ray ()运行一个任务，将图像输入到从tensorflow.keras加载的盗梦空间v3网。我的任务如下(简化)：
from tensorflow.keras.applications import InceptionV3
@ray.remote
def predict(image):
model = InceptionV3(include_top=False, pooling='avg', input_shape=(1920, 1080, 3))
return model.predict(image)
我的机器有8个GPU，但我没有光线分配任务给所有
浏览 0提问于2019-11-07得票数 1
回答已采纳
1回答
我正在做一个项目，我需要收集卷展栏来填充数据集，然后在数据集上训练模型。我想并行收集这些卷展栏，以加快处理速度，因此我尝试使用ray库提供的多处理： import time
import ray
ray.init()
@ray.remote
class MainActor:
def __init__(self):
self.data_set = []
def process_item(self, item):
# process incoming item
item+=1
return item
浏览 22提问于2021-07-28得票数 0
回答已采纳
1回答
假设参与者定义如下
@ray.remote
class Buffer:
def __init__(self):
self.memory = np.zeros(10)
def modify_data(self, indices, values):
self.memory[indices] = values
def sample(self, size):
indices = np.random.randint(0, 10, size)
return self.memory[indices]
让其他参与者在没
浏览 1提问于2019-12-24得票数 8
回答已采纳
1回答
异常时中断射线执行
、、、
我最近开始使用ray进行并行执行。在我的串行用例中，我有一个“超时”来停止我的循环的执行。我想知道如何使用ray来做同样的事情。
ray目前处理异常的方式是执行所有的运行，收集在执行过程中发生的错误，并在最后显示消息。
start_time = time.time()
@ray.remote
class Test(object):
def __init__(self):
self.res = None
def run(self, c):
time.sleep(0.25)
print(c)
self.res =
浏览 5提问于2019-08-05得票数 2
1回答
实现光线执行器函数的缓存
、、、、
我的目标是让下面的代码在大约0.3秒内执行，而不是0.5秒。我尝试过在foo上使用来自functools.lru_cache、toolz.functoolz.memoize和kids.cache.cache的装饰器，但是这些装饰器都不起作用(要么是错误消息，要么是没有正确执行)。我能做些什么来让它工作呢？ import ray
@ray.remote
class Foo:
def foo(self, x):
print("executing foo with {}".format(x))
time.sleep(0.1)
ray.
浏览 18提问于2020-08-12得票数 1
回答已采纳
我想了解remote functions和remote actors是如何以分布式方式在库中以分布式方式运行的。到目前为止，我已经跟踪了从ray.remote开始的代码到以下几行：
功能：
班级：
除此之外，您能否提供简单直观的逐步解释，说明function和class是如何以分布式方式转换和运行的？
谢谢你的帮助。
浏览 5提问于2020-10-20得票数 2
1回答
我在一台机器上运行了一个ray集群，如下所示： ray start --head --redis-port=6379 我有两个文件需要在集群上运行。生产者p_ray.py： import ray
ray.init(address='auto', redis_password='5241590000000000')
@ray.remote
class Counter(object):
def __init__(self):
self.n = 0
def increment(self):
self.n += 1
浏览 19提问于2020-04-02得票数 0
我使用ray.put(large_2d_array)存储一个大的numpy 2D布尔数组，然后在工作过程中，我从这个共享的numpy数组中获取一个列，并将它传递给cython函数，然后通过cdef cnp.npy_bool view = &sliced_array[0]创建一个平面缓冲区视图。使用此视图，我可以修改基础缓冲区(将一些索引设置为True)。
由于等离子存储对象是不可变的，因此我可能面临哪些未知的问题？
如果有人能对此有所了解，我会很高兴的。
代码模板：
import numpy as np
# ray init code
......
large_2d_array =
浏览 2提问于2021-04-26得票数 0
1回答
脚本在发送几个数据包后中断功能
、、、、
我正在编写一个python程序，它在指定的时间内发送数据包。 发送脚本： import socket
import time
import networkparam
import ray
ray.init()
transformer_sending_time = 0
final_message_sent = False
@ray.remote
def send_message():
"""
Sends an abnormal measurement to the specified ip address or port number given b
浏览 18提问于2020-08-23得票数 0
定义列表
g = [1, 2, 3, 4]
版本1
@ray.remote
def f(*g):
return np.mean(g, axis=0)
f_ids = [f.remote(*g) for _ in range(10)]
print(ray.get(f.remote(*f_ids)))
第2版
@ray.remote
def f(g): # g is object ID list
return np.mean(g, axis=0)
f_ids = [f.remote(g) for _ in range(10)]
print(ray.get(f.rem
浏览 0提问于2019-01-21得票数 1
回答已采纳
在我问你让我读文档之前。但我仍然是一个初学者，我并不是那么容易处理文档。我的问题是，SynchronizedList中的迭代器是阻止‘整个迭代过程(循环)’还是只是它的方法？
意思:当迭代“正在进行”时，另一个线程能在synchronizedList 实例上做一些工作吗？或者，它可以在名为next()的线程之后执行一些工作，正如我注意到的那样，next()也是同步的。
如有任何帮助，我将不胜感激：
浏览 4提问于2020-08-21得票数 0
1回答
我正在尝试用Ray做最简单的事情，但无论我做什么，它都不会释放内存，也不会失败。 用例只是将拼图文件读取到DF，将->传递给->池，对DF ->进行更改，返回DF class Main_func:
def calculate(self,data):
#do some things with the DF
return df.copy(deep=True) <- one of many attempts to fix the problem, but didnt work
cpus = 24
actors = []
for _ in ra
浏览 19提问于2020-08-17得票数 1
与我的同事就这个问题进行了辩论，因为我们必须处理一些异步/同步问题。然而，它提出了另一个问题，我想不出一个确切的答案。
假设有一个简单的for-each循环($.each)，在这里，每次迭代我都在全局范围内调用一个函数集。该函数是同步运行还是异步运行？假设没有Ajax，那么函数所做的是完全同步的，尽管只是执行。换句话说，我不知道函数调用本身是否在迭代中阻塞。
谢谢!
浏览 4提问于2015-07-23得票数 10
回答已采纳
1回答
我试图在python中运行一个并行进程，其中我必须根据某些条件从一个大数组中提取某些多边形。大数组有被索引的10k+多边形。
在extract_polygon函数中，我传递(数组、索引)。基于索引，函数必须根据定义的条件返回对应于该索引的多边形。数组从不更改，只用于根据所提供的索引读取多边形。
由于数组非常大，所以在并行处理过程中会遇到内存不足的错误。我怎么才能避免呢？(在某种程度上，如何在多处理中有效地使用共享数组？)
下面是我的示例代码：
def extract_polygon(array, index):
try:
islays = ndimage.find_o
浏览 2提问于2019-05-23得票数 1
1回答
在中，它声明：
在Meteor中，服务器代码在每个请求中运行一个线程，而不是以Node典型的异步回调样式运行。我们发现线性执行模型更适合Meteor应用程序中典型的服务器代码。
与Node相比，这个线性执行模型是什么？
浏览 3提问于2014-12-29得票数 2
回答已采纳
1回答
我有这样一条很小的射线管道：
import ray
import numpy as np
import time
@ray.remote
class PersonDetector:
def __init__(self) -> None:
self.model = self._init_model()
def _init_model(self):
s = np.random.random([100, 4])
return s
def infer(self, img):
b = s
浏览 6提问于2022-08-26得票数 3
回答已采纳
在阅读Ray 时，我发现它本身就支持dicts的序列化(“直接序列化”)，但我不明白这是什么意思，或者我应该如何使用这些序列化的对象。
假设我有以下流程：
import ray
ray.init()
dict_1 = {}
dict_2 = {}
@ray.remote
def f(x):
dict_1[x] = x*x
dict_2[x] = x*x*x
return x
futures = [f.remote(i) for i in range(4)]
print(ray.get(futures))
我应该做些什么来保护线程安全的行为吗？
浏览 0提问于2020-04-22得票数 0
2回答
据我所知，调用TThread的同步将执行同步代码，就像它在主线程中运行一样。假设在我的主线程中，我有一个按钮：
procedure TForm3.Button1Click(Sender: TObject);
var
A, B, C : String;
begin
A := 'test1';
B := 'test2';
C := 'test3';
Button1.Enabled := false;
end;
在第二个线程中，我有以下代码：
procedure TestThread.ChangeButton1;
begin
Form3.B
浏览 5提问于2014-02-23得票数 4
回答已采纳
4回答
我正在尝试将python程序的执行分到两台不同的机器上。我想知道有没有办法从一台机器上调用另一台机器上的python解释器。不在另一台机器上运行脚本，而是将执行任务拆分到两台机器上。
在接下来的几个月里，我将教授我的自我分布式编程，我认为这将是一个很好的开始。
我认为第一步是使用一台机器调用另一台机器，并将程序的一部分发送给它。然后，下一步将是两台机器一起执行相同的程序，并进行通信以避免问题。第三步是三台机器，等等。
建议、建议和想法都是受欢迎的。
浏览 2提问于2012-09-02得票数 3
回答已采纳
当使用大参数调用多个function.remote()时，似乎存在内存问题。
@ray.remote
def function(args):
# do something
args={} # big dictionary
args=ray.put(args)
[function.remote(args) for _ in range(1000)]
当我运行上述代码时，内存使用量不断增加，内存泄漏问题也随之发生。据我所知，"ray.put“方法将"args”写入共享内存。因此，每个消耗函数的进程都访问共享内存中的" args“，而不是将args复制到每个进
浏览 3提问于2022-09-23得票数 1
回答已采纳
我在各种情况下运行了我的代码，这导致了我认为奇怪的行为。我的测试是在一个带有HT的双核英特尔xeon处理器上进行的。
No OpenMP‘#务实’语句，总运行时= 507秒
，OpenMP‘#杂注’语句指定1核心，总运行时= 117秒
使用OpenMP‘#杂注’语句指定2核，总运行时= 150秒
使用OpenMP‘#杂注’语句指定3个核心，总运行时= 157秒
使用OpenMP‘#杂注’语句指定4个核心，总运行时= 144秒
我想我不明白为什么注释掉我的openmp行会使程序在一个没有openmp的线程和一个带有openmp的线程之间慢很多。
我所改变的只是：
//#pragma omp pa
浏览 0提问于2010-05-26得票数 11
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
