标签: parallel-processing

最近关于多核编程的讨论是否有人在探索使用MPI的可能性？

在Python GUI(PyGTK)中,我启动一个进程(使用多处理).这个过程需要很长时间(约20分钟)才能完成.当过程完成后,我想清理它(提取结果并加入过程).我怎么知道这个过程何时完成？

我的同事在父进程中建议了一个繁忙的循环,它检查子进程是否已经完成.当然有更好的方法.

在Unix中,当分叉进程时,在子进程完成时从父进程内调用信号处理程序.但我在Python中看不到类似的东西.我错过了什么吗？

如何从父进程中观察到子进程的结束？(当然,我不想调用Process.join(),因为它会冻结GUI界面.)

这个问题不仅限于多处理:我对多线程有完全相同的问题.

我有一大堆文件,需要进行一些繁重的处理.这种单线程处理,使用几百MiB的RAM(在用于启动作业的机器上),需要几分钟才能运行.我目前的用例是在输入数据上启动一个hadoop作业,但在之前的其他情况下我遇到了同样的问题.

为了充分利用可用的CPU功率,我希望能够在并行中运行多个这些任务.

但是,像这样的非常简单的示例shell脚本会因过度负载和交换而导致系统性能下降:

find . -type f | while read name ; 
do 
   some_heavy_processing_command ${name} &
done

所以我想要的基本上类似于"gmake -j4"的作用.

我知道bash支持"wait"命令,但只等待直到所有子进程都已完成.在过去,我创建了执行'ps'命令的脚本,然后按名称grep子进程(是的,我知道......丑陋).

做我想要的最简单/最干净/最好的解决方案是什么？

编辑:感谢Frederik:是的,这确实是如何限制bash中函数中使用的线程/子进程数量的副本 "xargs --max-procs = 4"就像一个魅力.(所以我投票结束了我自己的问题)

我需要了解多核机器中的内存屏障.说我有这个代码

核心1

mov [_x], 1; mov r1, [_y]    

核心2

mov [_y], 1; mov r2, [_x]

现在没有内存栅栏的意外结果是r1和r2在执行后都可以为0.在我看来,为了解决这个问题,我们应该在两个代码中都放置内存栅栏,因为将它放到一个代码中仍然无法解决问题.如下......

核心1

mov [_x], 1; memory_fence; mov r1, [_y]  

核心2

mov [_y], 1; memory_fence; mov r2, [_x]

我的理解是正确的还是我仍然缺少某些东西？假设架构是x86.另外,有人可以告诉我如何在C++代码中放置内存栅栏吗？

我使用的是python 2.7,我有一些看起来像这样的代码:

task1()
task2()
task3()
dependent1()

task4()
task5()
task6()
dependent2()

dependent3()

这里唯一的依赖关系如下:dependent1需要等待tasks1-3,dependent2需要等待任务4-6,dependent3需要等待dependents1-2 ......以下就可以了:先运行整个6个任务并行,然后前两个家属并行..然后最终依赖

我喜欢尽可能多地并行运行任务,我已经搜索了一些模块,但我希望避免使用外部库,并且不确定Queue-Thread技术如何解决我的问题(也许有人可以推荐一个好资源) ？)

我有两个for循环.在完成第一个循环后必须启动第二个循环.

那么,如果我使用两个Parallel.For()循环,第二个循环将在完成第一个循环后运行吗？

我想知道一个程序是否可以同时运行两个线程(基本上它是用于正确的？).但是,如果我在一个函数中进行系统调用,它在线程A上运行,并且在另一个函数中运行一些其他任务,它在线程B上运行,它们是否能够同时运行或者我的第二个运行功能等到系统调用完成？

我的原始问题的附加组件:现在,当系统调用正在进行时,此过程仍然是一个不间断的过程吗？我在谈论在UNIX/LINUX上使用任何系统调用.

我想知道是否/如何作为foreach dopar循环的一部分返回多个输出.

我们来看一个非常简单的例子.假设我想将2个操作作为foreach循环的一部分,并且希望为每个值返回或保存两个操作的结果i.

对于只返回一个输出,它将如下所示:

library(foreach)
library(doParallel)
cl <- makeCluster(3)
registerDoParallel(cl)

oper1 <- foreach(i=1:100000) %dopar% {
    i+2
}

oper1将是一个包含100000个元素的列表,每个元素都是i+2i的每个值的操作结果.

假设现在我想分别返回或保存两个不同操作的结果,例如i+2和i+3.我尝试了以下方法:

oper1 = list()
oper2 <- foreach(i=1:100000) %dopar% {
    oper1[[i]] = i+2
    return(i+3)
}

希望结果i+2将保存在列表中oper1,并且i+3将返回第二个操作的结果foreach.但是,列表中没有任何内容oper1!在这种情况下,只有i+3从循环返回的结果.

有没有办法在两个单独的列表中返回或保存两个输出？

我刚刚开始使用Joblib模块,我正在尝试理解Parallel函数的工作原理.下面是并行化导致运行时间更长的示例,但我不明白为什么.我在1 cpu上的运行时间为51秒,而在2 cpu上为217秒.

我的假设是并行运行循环会将列表a和b复制到每个处理器.然后将item_n分配给一个cpu,将item_n + 1分配给另一个cpu,执行该函数,然后将结果写回列表(按顺序).然后抓住接下来的两个项目,依此类推.我显然错过了一些东西.

这是一个糟糕的例子还是使用joblib？我只是简单地构造了错误的代码吗？

这是一个例子:

import numpy as np
from matplotlib.path import Path
from joblib import Parallel, delayed

## Create pairs of points for line segments
a = zip(np.random.rand(5000,2),np.random.rand(5000,2))

b = zip(np.random.rand(300,2),np.random.rand(300,2))

## Check if one line segment contains another. 
def check_paths(path, paths):
    for other_path in paths:
        res='no cross'
        chck = Path(other_path)
        if chck.contains_path(path)==1:
            res= 'cross'
            break
    return res

res = Parallel(n_jobs=2) (delayed(check_paths) (Path(points), a) for points in b)

这篇文章的另一个潜在标题可能是"当r中的并行处理时,核心数量,循环块大小和对象大小之间的比例是否重要？"

我有一个语料库我正在运行一些使用tm包的转换.由于语料库很大,我使用多路并行包进行并行处理.

有时转换完成任务,但有时它们不会.例如,tm::removeNumbers().语料库中的第一个文档的内容值为"n417".因此,如果预处理成功,那么此doc将转换为"n".

下面的样本语料库用于复制.这是代码块:

library(tidyverse)
library(qdap)
library(stringr)
library(tm)
library(textstem)
library(stringi)
library(foreach)
library(doParallel)
library(SnowballC)

  corpus <- (see below)
  n <- 100 # this is the size of each chunk in the loop

  # split the corpus into pieces for looping to get around memory issues with transformation
  nr <- length(corpus)
  pieces <- split(corpus, rep(1:ceiling(nr/n), each=n, length.out=nr))
  lenp <- length(pieces)

  rm(corpus) # save memory

  # save pieces to rds files since not enough RAM
  tmpfile <- tempfile() 
  for (i in …