标签: parallel-processing

我在Linux机器上使用gcc使用openMP在C中工作.在openmp并行for循环中,我可以将静态分配的数组声明为private.考虑代码片段:

int a[10];
#pragma omp parallel for shared(none) firstprivate(a)
for(i=0;i<4;i++){

一切都按预期工作.但如果相反我动态分配,

int * a = (int *) malloc(10*sizeof(int));
#pragma omp parallel for shared(none) firstprivate(a)

a(至少a [1 ... 9])的值不受保护,但就好像它们是共享的一样.这是可以理解的,因为pragma命令中的任何内容似乎都没有告诉omp需要私有的数组a有多大.我怎样才能将这些信息传递给openmp？如何将整个动态分配的数组声明为私有？

我一直在研究.Net 4.0中一些新的并行功能的实用性.

说我有这样的代码:

foreach (var item in myEnumerable)
    myDatabase.Insert(item.ConvertToDatabase());

想象一下myDatabase.Insert正在执行一些工作来插入SQL数据库.

从理论上讲,你可以写:

Parallel.ForEach(myEnumerable, item => myDatabase.Insert(item.ConvertToDatabase()));

并自动获得利用多个内核的代码.

但是如果myEnumerable只能通过一个线程进行交互呢？Parallel类是否会通过单个线程进行枚举,并仅将结果分派给循环中的工作线程？

如果myDatabase只能由一个线程进行交互怎么办？在循环的每次迭代中建立数据库连接肯定不会更好.

最后,如果我的"var item"碰巧是UserControl或者必须在UI线程上与之交互的东西呢？

我应该采用什么设计模式来解决这些问题？

在我处理真实世界的应用程序时,切换到Parallel/PLinq/etc并不容易.

我正在使用Python多处理为每个进程生成一个临时输出文件.它们的大小可以是几GB,我可以制作几十个.这些临时文件需要合并以形成所需的输出,这是证明是瓶颈(和并行杀手)的步骤.是否有一个Linux工具可以通过修改文件系统元数据而不是实际复制内容来创建连接文件？只要它适用于我可以接受的任何Linux系统.但是文件系统特定的解决方案不会有太大帮助.

我不是OS或CS的训练,但在理论上似乎应该有可能创造一个新的inode并复制了从我想从复制文件的inode的inode的指针结构,然后取消与这些索引节点.是否有任何实用程序可以做到这一点？考虑到经过深思熟虑的unix实用程序的过多,我完全可以预料到它,但找不到任何东西.因此我的问题是关于SO的.文件系统位于块设备上,实际上是硬盘,以防这些信息很重要.我没有信心自己编写这个,因为我以前从未做过任何系统级编程,所以任何指针(对C/Python代码的反转)都会非常有用.

我最近一直在学习各种Java并发库,ConcurrentHashMap以及来自Cliff Click的可爱非阻塞库

我对Scala了解不多,但我听说过最近的并行集合库.

我想知道这个库对基于Java的库有哪些主要优点？

我经常最终得到几个嵌套foreach循环,有时候在编写一般函数时(例如对于一个包),没有明显的并行化级别.有没有办法完成下面的模型描述？

foreach(i = 1:I) %if(I < J) `do` else `dopar`% {
    foreach(j = 1:J) %if(I >= J) `do` else `dopar`% {
        # Do stuff
    }
}

此外,有没有办法检测并行后端是否已注册,以便我可以避免收到不必要的警告消息？在CRAN提交之前检查包并且不打扰在单核计算机上运行R的用户时,这将非常有用.

foreach(i=1:I) %if(is.parallel.backend.registered()) `dopar` else `do`% {
    # Do stuff
}

谢谢你的时间.

编辑:非常感谢您对核心和工作人员的所有反馈,并且你是对的,处理上述示例的最佳方法是重新考虑整个设置.我更喜欢下面这个triu想法,但它基本上是相同的.它当然也可以tapply像Joris建议的那样平行完成.

ij <- expand.grid(i=1:I, j=1:J)
foreach(i=ij$I, j=ij$J) %dopar% {
    myFuction(i, j)
}

然而,在我试图简化引起这个线程的情况时,我遗漏了一些关键的细节.想象一下,我有两个功能analyse,并batch.analyse和最好的水平,在并行依据的值可能是不同的n.replicates和n.time.points.

analyse <- function(x, y, n.replicates=1000){
    foreach(r = 1:n.replicates) %do% {
        # Do stuff with …

Haskell提供了一个par组合器,它将一个"火花"排队,以便与当前线程并行进行可能的评估.它还提供了一个pseq组合器,它强制评估纯代码以特定顺序发生.

Haskell似乎没有提供的是产生几个火花的方法,然后等待它们全部完成.使用显式并发实现这一点非常简单,但纯粹的火花似乎是不可能的.

在某种程度上,这可能是因为火花的预期用例.它们似乎是为投机评估而设计的.也就是说,做可能需要但可能不需要的工作.因此,火花仅在核心上运行,否则它们是空闲的.

但是,这不是我的用例.我知道很多结果,事实上很快就会需要.如果我在火花爆发之前开始尝试处理结果,我将再次以一堆失败的火花结束单线程.

当然,par 等待火花完成,它不会达到任何并行性!但如果有某种方法可以产生几个火花然后等待它们全部完成,那将是非常有用的.我找不到任何方法可以做到这一点.

有没有人有任何有用的建议？(显然,除了"使用显式并发"之外).

我的训练数据集有大约200,000条记录,我有500个功能.(这些是来自零售组织的销售数据).大多数功能都是0/1,并存储为稀疏矩阵.

目标是预测约200种产品的购买概率.因此,我需要使用相同的500个功能来预测200种产品的购买概率.由于glmnet是模型创建的自然选择,我想到了为200个产品并行实现glmnet.(因为所有200个型号都是独立的)但是我被困在使用foreach.我执行的代码是:

foreach(i = 1:ncol(target)) %dopar%
{
assign(model[i],cv.glmnet(x,target[,i],family="binomial",alpha=0,type.measure="auc",grouped=FALSE,standardize=FALSE,parallel=TRUE))
}

model是一个列表 - 包含200个模型名称的列表,我想在其中存储各自的模型.

以下代码有效.但它没有利用并行结构,需要大约一天才能完成!

for(i in 1:ncol(target))
{ assign(model[i],cv.glmnet(x,target[,i],family="binomial",alpha=0,type.measure="auc",grouped=FALSE,standardize=FALSE,parallel=TRUE))
}

在这种情况下,有人能指出如何利用并行结构吗？

"并行和并发编程"中的这个图表:http://chimera.labs.oreilly.com/books/1230000000929/ch03.html#fig_kmeans-granularity起初似乎表明存在严重的开销,引发太多.但是如果仔细观察y轴,你会发现它已被放大到有趣的部分.事实上,最佳和最差案例表现之间的比例约为80%,这也不算太糟糕.

一般来说,确定块的方式和数量是困难的,容易出错,极其特定于应用程序,并且明年当您购买具有更强处理能力的新计算机时可能会发生变化.我更倾向于总是使用rpar来获得最细粒度的物品并以25%的开销生活.

引发的开销通常会产生比此图所示更糟糕的成本吗？(特别是如果我总是折叠二叉树而不是列表,那么关于"顺序工作量"的第二个要点不适用)

针对Don Stewart的回答更新了问题:

火花池是否只包含一个所有处理器都难以访问的队列？还是有很多？

例如,如果我有一台具有无限处理器和二叉树的计算机,我想在所有叶子上取总和,如:

data Node = Leaf Int | Branch Node Node

sumL (Leaf x) = x
sumL (Branch n1 n2) = let (x,y) = (sumL n1, sumL n2) in (x `par` y) `seq` (x + y) 

这个程序会在O(#leaves)时间运行吗？或O(深度)时间？有没有更好的方法来写这个？

如果我抽出太多东西以获得满意的答案,请告诉我.我对haskell并行性如何工作的心理模型仍然非常模糊.

我有一个大型数组,我想通过将它的片段交给几个异步任务来处理.作为概念证明,我编写了以下代码:

class TestParallelArrayProcessing {
    let array: [Int]
    var summary: [Int]

    init() {
        array = Array<Int>(count: 500000, repeatedValue: 0)
        for i in 0 ..< 500000 {
            array[i] = Int(arc4random_uniform(10))
        }
        summary = Array<Int>(count: 10, repeatedValue: 0)
    }

    func calcSummary() {
        let group = dispatch_group_create()
        let queue = dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0)

        for i in 0 ..< 10 {
            dispatch_group_async(group, queue, {
                let base = i * 50000
                for x in base ..< base + 50000 {
                    self.summary[i] += self.array[x]
                }
            })
        }
        dispatch_group_notify(group, …

我试图了解Haskell的并行化性能.

我有一个长列表(长度> 1000),我正在使用parallel并行评估parMap.

以下是+RTS -s用于单个线程的完整统计信息输出(编辑:完整统计输出):

        54,248,802,288 bytes allocated in the heap
           324,451,424 bytes copied during GC
             2,970,272 bytes maximum residency (4 sample(s))
                52,064 bytes maximum slop
                   217 MB total memory in use (1 MB lost due to fragmentation)

                                          Tot time (elapsed)  Avg pause  Max pause
        Gen  0       251 colls,     0 par    1.45s    1.49s     0.0059s    0.0290s
        Gen  1         4 colls,     0 par    0.03s    0.05s     0.0125s    0.0319s

        TASKS: 4 (1 bound, 3 peak workers (3 total), using -N1) …