标签: parallel-processing

from joblib import Parallel, delayed

def func(v):
    temp.append(v)
    return

temp = []
Parallel(n_jobs=4)(delayed(func)(v) for v in range(10))
print temp

我想让共享内存变量。但是temp的值为空[]。我该怎么做？

对于其他方法，我尝试了 pickle.dump 和 load。但是有一个锁定问题。请给我建议！

我正在尝试使用 Python 的多处理包来测量我“并行化”的一段代码，特别是使用 Process 函数。

我有两个要并行运行的函数：function1和function2. function1不返回值，并且function2确实。function2 的返回值是一个相当大的类实例。

这是我使用队列并行化和获取返回值的现有代码：

import multiprocessing as mpc
...
def Wrapper(self,...):
  jobs = []
  q = mpc.Queue()
  p1 = mpc.Process(target=self.function1,args=(timestep,))
  jobs.append(p1)

  p2 = mpc.Process(target=self.function2,args=(timestep,arg1,arg2,arg3,...,q))
  jobs.append(p2)

  for j in jobs:
    j.start()
  result = q.get()

  for j in jobs:
    j.join()

所以，这是我看到的问题。如果我删除对 的调用result = q.get()，则执行 Wrapper 函数所需的时间会显着减少，因为它不会从 返回类function2，但是我显然没有从函数中获取我需要的数据。如果我把它放回去，运行时间会显着增加，从而表明并行化实际上比顺序执行这两个函数花费的时间更长。

以下是 Wrapper 的一些平均执行时间，以供参考：

• 顺序代码（即function1(timestep)，，res = function2(timestep,a1,a2,a3,...,None)）：10 秒

• 不使用队列的并行代码：8 秒

• 队列的并行代码：60 秒

我对这段代码的目标是展示并行化一段代码如何缩短在不必要的并行函数中执行所需的时间。作为参考，我正在使用 cProfile 包，生成我的代码的配置文件，并查看 Wrapper …

我正在从事一个项目，该项目要求我使用 Tesseract 加快文本识别过程。我看到一篇文章说 Tesseract 正在与 OpenCL 一起工作，以将一些计算密集型任务卸载到可用的 CPU 或 GPU 上。
是否有关于“Tesseract 如何利用 OpenCL 将计算密集型任务卸载到并行 CPU 内核或 GPU”的定性解释？

Tesseract 源的链接在这里https://code.google.com/p/tesseract-ocr/source/browse/#git%2Fopencl

我需要提升我的 python 应用程序。解决方案应该是微不足道的：

import time
from multiprocessing import Pool


class A:
    def method1(self):
        time.sleep(1)
        print('method1')
        return 'method1'

    def method2(self):
        time.sleep(1)
        print('method2')
        return 'method2'

    def method3(self):
        pool = Pool()
        time1 = time.time()
        res1 = pool.apply_async(self.method1, [])
        res2 = pool.apply_async(self.method2, [])
        res1 = res1.get()
        res2 = res2.get()
        time2 = time.time()
        print('res1 = {0}'.format(res1))
        print('res2 = {0}'.format(res2))
        print('time = {0}'.format(time2 - time1))



a = A()
a.method3()

但是每次我启动这个简单的程序时，我都会遇到一个异常：

Exception in thread Thread-2:
Traceback (most recent call last):
  File "/usr/lib/python3.2/threading.py", line 740, in _bootstrap_inner
    self.run() …

我有一个关于线程安全和互斥锁的问题。我有两个可能无法同时执行的函数，因为这可能会导致问题：

std::mutex mutex;

void A() {
    std::lock_guard<std::mutex> lock(mutex);
    //do something (should't be done while function B is executing)
}

T B() {
    std::lock_guard<std::mutex> lock(mutex);
    //do something (should't be done while function A is executing)
    return something;
}

现在的问题是，函数 A 和 B 不应该同时执行。这就是我使用互斥锁的原因。但是，如果从多个线程同时调用函数 B 是完全没问题的。但是，这也被互斥锁阻止了（我不想要这个）。现在，有没有办法确保 A 和 B 不会同时执行，同时仍然让函数 B 并行执行多次？

在Spring Batch的分区之间的关系gridSize的的PartitionHandler和数量的ExecutionContext通过传回的分区程序是有点混乱。例如，MultiResourcePartitioner声明它忽略 gridSize，但Partitioner文档没有解释何时/为什么可以接受。

例如，假设我有一个taskExecutor我想在不同的并行步骤中重复使用的对象，并且我将其大小设置为 20。如果我使用网格大小为 5的TaskExecutorPartitionerHandler，并且一个MultiResourcePartitioner返回任意数量的分区（每个文件一个），并行性实际上会如何表现？

假设MultiResourcePartitioner为特定运行返回 10 个分区。这是否意味着一次只执行其中的 5 个，直到所有 10 个都完成，并且这 20 个线程中不会有超过 5 个用于此步骤？

如果是这种情况，何时/为什么可以在Parititioner使用自定义实现覆盖时忽略 'gridSize' 参数？我认为如果在文档中对此进行了描述会有所帮助。

如果不是这种情况，我该如何实现？也就是说，我如何重新使用任务执行器并分别定义可以为该步骤并行运行的分区数量以及实际创建的分区数量？

好的，让我们开始吧，我脑子里有点混乱。

SEND：它正在阻塞。发送方将等待，直到接收方发布相应的 RECV。

SSEND：它是阻塞的，发送方不仅会等待接收方发布相应的 RECV，还会等待 RECV 的确认。这意味着 RECV 运行良好。

BSEND：它是非阻塞的。该进程可以继续执行其部分代码。数据存储在之前正确分配的缓冲区中。

ISEND：它是非阻塞的。该进程可以继续执行其部分代码。数据未存储在缓冲区中：在确定 ISEND 运行良好（WAIT/TEST）之前，您不得覆盖正在发送的数据。

那么.. ISEND 和 BSEND 仅在缓冲区上有所不同吗？

我想使用 Pandas 并行读取一个大的 .xls 文件。目前我正在使用这个：

LARGE_FILE = "LARGEFILE.xlsx"
CHUNKSIZE = 100000 # processing 100,000 rows at a time

def process_frame(df):
      # process data frame
      return len(df)

if __name__ == '__main__':
      reader = pd.read_excel(LARGE_FILE, chunksize=CHUNKSIZE)
      pool = mp.Pool(4) # use 4 processes

      funclist = []
      for df in reader:
              # process each data frame
              f = pool.apply_async(process_frame,[df])
              funclist.append(f)

      result = 0
      for f in funclist:
              result += f.get(timeout=10) # timeout in 10 seconds

虽然这会运行，但我认为它实际上并没有加快读取文件的过程。有没有更有效的方法来实现这一目标？

我有 2 个测试套件。一个可以并行运行，另一个必须顺序运行。参见下面的定义。

我看到的是只有第二个运行。

我试图定义 2 个插件。没用。

我试图给他们不同的执行 ID。没用。

我试图将配置置于执行之下，但得到一个错误，该配置下的元素不被允许，例如failIfNoSpecifiedTests.

知道如何运行具有不同配置的套件 - 一个并行，另一个顺序？

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <executions>
        <execution>
            <id>SequentialTests</id>
        </execution>
    </executions>
    <configuration>
        <includes>
            <include>**/SequentialTests.java</include>
        </includes>
    </configuration>
</plugin>
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.18.1</version>
    <executions>
        <execution>
            <id>ParallelTests</id>
        </execution>
    </executions>
    <configuration>
        <includes>
            <include>**/ParallelTests.java</include>
        </includes>
        <threadCount>10</threadCount>
        <parallel>classes</parallel>
    </configuration>
</plugin>

在哪些情况下哪个更有效？在某些情况下，哪一个根本无法工作？

我试图使一些通用代码更有效，并且很好奇哪个更好，因为据我所知，它们不能结合使用。

以供参考：

library(doParallel)
library(foreach)

foreach (i = list) %dopar% {
...
}

对比

library(parallel)

parLapply(cl, X = list, fun = function)