标签: parallel-processing

我只是在研究新的.NET 4.0功能.有了这个,我正在尝试使用Parallel.For和正常for(x;x;x)循环进行简单的计算.

但是,我有50%的时间得到不同的结果.

long sum = 0;

Parallel.For(1, 10000, y =>
    {
        sum += y;
    }
);

Console.WriteLine(sum.ToString());

sum = 0;

for (int y = 1; y < 10000; y++)
{
   sum += y;
}
Console.WriteLine(sum.ToString());

我的猜测是线程正在尝试同时更新"sum".
有明显的方法吗？

在Lua中编码,我有一个三次嵌套循环,经历了6000次迭代.所有6000次迭代都是独立的,可以很容易地并行化.Lua的哪些线程包开箱即用,并在四个或更多内核上获得了不错的并行加速？

这是我目前所知道的:

• luaproc来自核心Lua团队,但luaforge上的软件包很旧,邮件列表中有关于segfaulting的报告.此外,对我来说,如何使用标量消息传递模型将结果最终导入父线程并不明显.

• Lua Lanes提出了有趣的说法,但似乎是一个重量级,复杂的解决方案.邮件列表上的许多消息都表示无法让Lua Lanes为他们构建或工作.我自己很难让潜在的"Lua rock"分发机制为我工作.

• LuaThread需要显式锁定,并要求线程之间的通信由受锁保护的全局变量调解.我可以想象更糟糕,但我对更高层次的抽象感到更高兴.

• Concurrent Lua提供了一个类似于Erlang的有吸引力的消息传递模型,但它表示进程不共享内存.目前尚不清楚是否spawn实际使用任何 Lua函数或是否存在限制.

• Russ Cox提出了一种偶尔的线程模型,它只适用于C线程.对我没用.

我将通过这些或任何其他多线程包或任何提供新信息的答案来报告所有报告实际经验的答案.

作为参考,这是我想要并行化的循环:

for tid, tests in pairs(tests) do
  local results = { }
  matrix[tid] = results
  for i, test in pairs(tests) do
    if test.valid then
      results[i] = { }
      local results = results[i]
      for sid, bin in pairs(binaries) do
        local outcome, witness = run_test(test, bin)
        results[sid] = { outcome = outcome, witness …

从程序员的角度来看,GPGPU与常规多核/多线程CPU编程之间的关键实际区别是什么？特别:

• 什么类型的问题更适合常规多核以及哪种类型更适合GPGPU？

• 编程模型的主要区别是什么？

• 什么是关键的底层硬件差异,需要编程模型的任何差异？

• 哪一个通常更容易使用,多少？

• 从长远来看,为GPU实现高级并行库是否切实可行,例如Microsoft的任务并行库或D的std.parallelism？

• 如果GPU计算效率非常高,为什么CPU的设计更像GPU？

我知道Scala中的并行集合.它们很方便!但是,我想迭代一个文件的行,这个文件对于并行的内存来说太大了.例如,我可以创建线程并在扫描仪上设置锁定,但如果我可以运行以下代码,那将会很棒:

Source.fromFile(path).getLines.par foreach { line =>

然而不幸的是

error: value par is not a member of Iterator[String]

在这里完成一些并行性的最简单方法是什么？现在,我将阅读一些行并且并行处理它们.

在我的应用程序中,我从几十个执行到几百个并行操作(没有操作的返回值).

哪种方法最优:

1. Task.Factory.StartNew在foreach循环中使用迭代遍历Action数组(Action[])

   Task.Factory.StartNew(() => someAction());

2. 使用Parallel类其中actions是Action阵列(Action[])

   Parallel.Invoke(actions);

这两种方法是否相同？是否有任何性能影响？

编辑

我已经执行了一些性能测试,并且在我的机器上(每个2个CPU 2核心)结果似乎非常相似.我不确定它在1 CPU等其他机器上会是什么样子.另外我不确定(不知道如何以非常准确的方式测试它)什么是内存消耗.

根据维基百科的说法,一个"令人尴尬的并行"问题是很难或根本不需要将问题分成许多并行任务.通常引用光线追踪作为示例,因为原则上每条光线可以并行处理.

显然,一些问题要难以并行化.有些甚至可能是不可能的.我想知道使用什么术语以及这些更难的案例的标准示例是什么.

我可以提出"令人讨厌的顺序"作为可能的名称吗？

我正在尝试使用IPython的并行环境,到目前为止,它看起来很棒,但我遇到了问题.让我们说我有一个在库中定义的函数

def func(a,b):
   ...

当我想要评估a的一个值和b的一堆值时,我使用的.

[func(myA, b) for b in myLongList]

显然,真正的功能更复杂,但问题的实质是它需要多个参数,我只想映射其中一个.问题是map,@ dview.parallel等映射了所有参数.

所以我想说我想得到func(myA,myLongList)的答案.这样做的显而易见的方法是咖喱,或者是functools.partial,或者是

dview.map_sync(lambda b: func(myA, b),   myLongList)

但是,这在远程计算机上无法正常工作.原因是当lambda表达式被pickle时,myA的值不包括在内,而是使用远程机器上本地作用域的myA值.当闭包被腌制时,它们关闭的变量不会.

我能想到的两种实际工作方式是为每个参数手动构建列表,并对所有参数进行映射工作,

dview.map_sync(func, [myA]*len(myLongList), myLongList)   

或者以恐怖的方式将数据用作函数的默认参数,强制它被腌制:

# Can't use a lambda here b/c lambdas don't use default arguments :(
def parallelFunc(b, myA = myA):
    return func(myA, b)

dview.map_sync(parallelFunc, myLongList)

真的,当真正的函数需要很多参数并且更复杂时,这一切似乎都非常扭曲.是否有一些惯用的方法呢？就像是

@parallel(mapOver='b')
def  bigLongFn(a, b):
   ...

但据我所知,没有像'mapOver'这样的东西存在.我可能已经知道如何实现它...这只是一个非常基本的操作,应该存在支持,所以我想检查我是否遗漏了一些东西.

我一直在谷歌做一些研究,并且无法理解java中并发和并行程序之间的差异(如果有的话).我所看到的一些信息表明两者之间没有差异.是这样的吗？

我正在尝试了解使用多处理池的apply_sync方法时幕后发生的一些事情.

谁运行回调方法？它是调用apply_async的主要进程吗？

假设我发送了一大堆带回调的apply_async命令,然后继续我的程序.当apply_async开始完成时,我的程序仍在执行操作.当主进程仍然忙于脚本时,回调是如何运行我的"主进程"的？

这是一个例子.

import multiprocessing
import time

def callback(x):
    print '{} running callback with arg {}'.format(multiprocessing.current_process().name, x)

def func(x):
    print '{} running func with arg {}'.format(multiprocessing.current_process().name, x)
    return x

pool = multiprocessing.Pool()

args = range(20)

for a in args:
    pool.apply_async(func, (a,), callback=callback)

print '{} going to sleep for a minute'.format(multiprocessing.current_process().name)

t0 = time.time()
while time.time() - t0 < 60:
    pass

print 'Finished with the script'

输出就像是

使用arg 0运行func的PoolWorker-1

PoolWorker-2使用arg 1运行func

PoolWorker-3使用arg 2运行func

MainProcess进入休眠状态< - 主进程正忙

PoolWorker-4使用arg 3运行func

使用arg …

我正在用Python做一个机器学习项目,所以我必须做并行预测功能,我在我的程序中使用它.

from multiprocessing.dummy import Pool
from multiprocessing import cpu_count


def multi_predict(X, predict, *args, **kwargs):
    pool = Pool(cpu_count())
    results = pool.map(predict, X)
    pool.close()
    pool.join()
    return results

问题是我所有的CPU只加载了20-40%(总计为100%).我使用multiprocessing.dummy,因为我在pickling函数中遇到了多处理模块的问题.