标签: parallel-processing

不确定单独在一个Makefile中是否可以这样做,但是我希望以这样的方式编写Makefile,以便尝试在文件中构建任何目标,自动神奇地检测当前系统上的处理器数量并并行构建目标对于处理器的数量.

像下面的"伪代码"示例,但更干净？

all:
    @make -j$(NUM_PROCESSORS) all

要么:

all: .inparallel
    ... build all here ...

.inparallel:
    @make -j$(NUM_PROCESSORS) $(ORIGINAL_TARGET)

在这两种情况下,您只需输入以下内容:

% make all

希望这是有道理的.

更新:仍然希望上面的Makefile示例.对找到进程数并不感兴趣,但对如何在没有-j命令行选项的情况下编写并行构建的makefile感兴趣.

我有异常处理和并行任务的问题.

下面显示的代码启动2个任务并等待它们完成.我的问题是,如果任务抛出异常,则永远不会到达catch处理程序.

        List<Task> tasks = new List<Task>();
        try
        {                
            tasks.Add(Task.Factory.StartNew(TaskMethod1));
            tasks.Add(Task.Factory.StartNew(TaskMethod2));

            var arr = tasks.ToArray();                
            Task.WaitAll(arr);
        }
        catch (AggregateException e)
        {
            // do something
        }

但是,当我使用以下代码等待超时的任务时,会捕获异常.

 while(!Task.WaitAll(arr,100));

我似乎错过了一些东西,因为文档WaitAll描述了我的第一次尝试是正确的.请帮助我理解它为什么不起作用.

我已经在各种机器上运行了一些代码测试代码,总是得到相同的结果.我认为各种do ...包背后的哲学是它们可以互换地用作foreach的%dopar%的后端.为什么不是这样？

例如,此代码段有效:

library(plyr)
library(doMC)
registerDoMC()
x <- data.frame(V= c("X", "Y", "X", "Y", "Z" ), Z = 1:5)
ddply(x, .(V), function(df) sum(df$Z),.parallel=TRUE)

虽然这些代码段中的每一个都失败了:

library(plyr)
library(doSMP)
workers <- startWorkers(2)
registerDoSMP(workers)
x <- data.frame(V= c("X", "Y", "X", "Y", "Z" ), Z = 1:5)
ddply(x, .(V), function(df) sum(df$Z),.parallel=TRUE) 
stopWorkers(workers)

library(plyr)
library(snow)
library(doSNOW)
cl <- makeCluster(2, type = "SOCK")
registerDoSNOW(cl)
x <- data.frame(V= c("X", "Y", "X", "Y", "Z" ), Z = 1:5)
ddply(x, .(V), function(df) sum(df$Z),.parallel=TRUE) 
stopCluster(cl)

library(plyr)
library(doMPI)
cl <- startMPIcluster(count = 2) …

如果使用Haskell作为从我的C程序调用的库,那么调用它会对性能产生什么影响？例如,如果我有一个20kB数据的问题世界数据集,我想运行如下:

// Go through my 1000 actors and have them make a decision based on
// HaskellCode() function, which is compiled Haskell I'm accessing through
// the FFI.  As an argument, send in the SAME 20kB of data to EACH of these
// function calls, and some actor specific data
// The 20kB constant data defines the environment and the actor specific
// data could be their personality or state
for(i = 0; i < 1000; …

Scala 2.9引入了并行集合.对于某些任务来说,它们是非常棒的工具.但是,它们如何在内部工作,我是否能够影响行为/配置？

他们使用什么方法来确定最佳线程数？如果我对结果不满意,是否有任何配置参数需要调整？

我不仅对实际创建了多少线程感兴趣,我还对实际工作如何在它们之间分配感兴趣.如何收集结果以及幕后有多少魔法.Scala是否会以某种方式测试集合是否足够大以便从并行处理中受益？

我打算开始为一个跨平台项目"玩"基于任务的并行性.我想使用英特尔线程构建模块.我从Windows和Visual Studio开始.

因为我只是想要原型,我正在考虑只在Windows上"玩",然后有足够的知识在所有兼容平台上使用该库.

我了解到,自VS2010以来,Microsoft提供了一个类似的库,并行处理库,它具有(几乎)与英特尔TBB相同的接口.

一些消息来源建议,包括TBB的团队博客,他们一起构建它,并且它是相同的库.

然而,它并不是真正明确的,因为它经常表明两个库之间存在细微差别.

那么,如果有的话,这些差异是什么？我应该直接与去年稳定该局启动或者是低风险的原型与微软PPL只是玩,跨平台的"真实"的项目上使用该局？

我在R中并行运行随机森林

library(doMC)
registerDoMC()
x <- matrix(runif(500), 100)
y <- gl(2, 50)

并行执行(耗时73秒)

rf <- foreach(ntree=rep(25000, 6), .combine=combine, .packages='randomForest') %dopar%
randomForest(x, y, ntree=ntree) 

顺序执行(耗时82秒)

rf <- foreach(ntree=rep(25000, 6), .combine=combine) %do%
randomForest(x, y, ntree=ntree) 

在并行执行中,树生成非常快,如3-7秒,但其余时间用于组合结果(组合选项).因此,它唯一值得运行并行执行的是树的数量真的很高.有什么方法可以调整"组合"选项,以避免在我不需要的每个节点上的任何计算,并使其更快

PS.以上只是数据的一个例子.实际上,对于大约100个观察,我有大约10万个特征.

我正在以顺序方式运行.cpp代码(i)和(ii)使用OpenMP语句.我想看看时差.为了计算时间,我用这个:

#include <time.h>
.....
main()
{

  clock_t start, finish;
  start = clock();
  .
  .
  .
  finish = clock();

  processing time = (double(finish-start)/CLOCKS_PER_SEC);

 }

在代码的顺序(上面)运行中,时间非常准确.运行它需要大约8秒钟.当我在代码中插入OpenMP语句然后计算时间缩短时,但是在控制台上显示的时间大约为8-9秒,实际上它实际上只有3-4秒!

以下是我的代码抽象的样子:

#include <time.h>
.....
main()
{

  clock_t start, finish;
  start = clock();
  .
  .
  #pragma omp parallel for
  for( ... )
     for( ... )
       for (...)
    {           
      ...;      
    }
  .
  .
  finish = clock();

  processing time = (double(finish-start)/CLOCKS_PER_SEC);

 }

当我运行上面的代码时,我得到了减少的时间,但显示的时间在实时方面并不准确.在我看来,似乎clock()函数正在计算每个线程的个别时间并将它们相加并显示它们.

有人能说出这个的原因或建议我使用任何其他计时功能来衡量OpenMP程序的时间吗？

谢谢.

我有示例代码来比较Parallel方法和Task方法的处理时间.这个实验的目标是了解它们是如何工作的.

所以我的问题是:

1. 为什么Parallel工作得比Task快？
2. 我的结果是否意味着我应该使用Parallel而不是Task？
3. 我应该在哪里使用Task和Parallel？
4. 使用Task与Parallel相比有什么好处？

5. Task只是ThreadPool.QueueUserWorkItem方法的包装吗？

       public Task SomeLongOperation()
       {
           return Task.Delay(3000);
       }
   
       static void Main(string[] args)
       {
           Program p = new Program();
           List<Task> tasks = new List<Task>();
   
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
           tasks.Add(Task.Factory.StartNew(() => p.SomeLongOperation()));
   
           var arr = tasks.ToArray();
   
           Stopwatch sw = Stopwatch.StartNew();
           Task.WaitAll(arr);
           Console.WriteLine("Task wait all results: " + sw.Elapsed);
           sw.Stop();
   
           sw = Stopwatch.StartNew();
           Parallel.Invoke(() => p.SomeLongOperation(), () => p.SomeLongOperation());
           Console.WriteLine("Parallel invoke results: " + sw.Elapsed);
           sw.Stop();
   
           Console.ReadKey();
       }
   

   Run Code Online (Sandbox Code Playgroud)

这是我的处理结果:

编辑:

将代码更改为如下所示:

    Program p = new Program();
    Task[] tasks …

我希望并行运行一堆作业,然后在所有作业完成后继续.我有类似的东西

# based on example code from https://pymotw.com/2/multiprocessing/basics.html
import multiprocessing
import random
import time

def worker(num):
    """A job that runs for a random amount of time between 5 and 10 seconds."""
    time.sleep(random.randrange(5,11))
    print('Worker:' + str(num) + ' finished')
    return

if __name__ == '__main__':
    jobs = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        jobs.append(p)
        p.start()

    # Iterate through the list of jobs and remove one that are finished, checking every second.
    while len(jobs) > 0:
        jobs = [job for …