标签: parallel-processing

这是一个开放式问题.我应该考虑哪些方法？

我正在分配许多进程,我想测量完成整个任务所需的时间,即分叉完成所有进程的时间.请告知如何让父进程等到所有子进程终止？我想确保在合适的时刻停止计时器.

这是我使用的代码:

#include <iostream>
#include <string>
#include <fstream>
#include <sys/time.h>
#include <sys/wait.h>

using namespace std;

struct timeval first,  second,  lapsed;
struct timezone tzp; 

int main(int argc, char* argv[])// query, file, num. of processes.
{

    int pCount = 5; // process count

    gettimeofday (&first, &tzp); //start time

    pid_t* pID = new pid_t[pCount];

    for(int indexOfProcess=0; indexOfProcess<pCount; indexOfProcess++)
    {
        pID[indexOfProcess]= fork();

        if (pID[indexOfProcess] == 0)                // child
        {
            // code only executed by child process

            // magic here

            // The End
            exit(0);
        } …

如何在parallel.foreach循环范围之外增加一个整数值？什么是同步访问并行循环外的对象的最轻的方法？

var count = 0;
Parallel.ForEach(collection, item =>
{
  action(item);
  // increment count??
}

我编写了一个多线程Java程序来解决一个令人尴尬的并行问题,它利用了多核CPU上的所有空闲CPU周期.我想重构我的解决方案,以便它可以在多个节点上运行,同时仍然保留我已编写的大部分代码.

我过去曾使用过MP的MPI,并且被告知这是解决CPU周期最大化问题的"正确"方法,但我也知道Java中的其他并发框架,如RMI,并想知道它们是否同样如此好.

有没有一种很好的方法来处理Java中的多节点和多核并发,其主要目标是尽可能地利用群集中最多的CPU周期？

编辑:我得到的印象是没有简单的方法来处理这些东西.我并不感到惊讶,但我希望.:)

我试图使用新的C#4.0 Parallel.ForEach函数在对象列表上执行并行函数.这是一个非常漫长的维护过程.我想让它按列表的顺序执行,以便我可以在前一点停止并继续执行.我该怎么做呢？

这是一个例子.我有一个对象列表:a1 to a100.这是当前的订单:

a1, a51, a2, a52, a3, a53...

我想要这个订单:

a1, a2, a3, a4...

我可以将一些对象无序运行,但只要我能在列表中找到一个点,我可以说在此之前所有对象都已运行.我阅读了并行编程csharp白皮书,但没有看到任何相关内容.ParallelOptions课堂上没有这个设置.

英特尔TBB如何选择用于并行部分的线程数？

有某种规格吗？

为什么我们需要Task.ContinueWith()方法.我们不能只在Task体内写下"延续代码"吗？

最近在R2.14中增加了对并行计算的直接支持,这引发了一个问题.在R中创建集群有很多选项.我snow定期使用SOCK集群,但我知道还有其他方法,如MPI.我使用SOCK snow集群因为我不需要安装任何其他软件(我使用Fedora 13).

那么,我的具体问题:

1. 使用非SOCK群集时性能是否有所提升？
2. 使用非SOCK群集在多台计算机上创建群集更容易吗？

我正在尝试使用Python进行多处理器编程.Fibonacci例如,采用分治算法.程序流程的执行将像树一样分支并并行执行.换句话说,我们有一个嵌套并行性的例子.

从Java开始,我使用线程池模式来管理资源,因为程序可以非常快速地扩展并创建太多短期线程.可以通过实例化单个静态(共享)线程池 ExecutorService.

我希望Pool也一样,但看起来Pool对象不是全局共享的.例如,使用共享池multiprocessing.Manager.Namespace()将导致错误.

池对象不能在进程之间传递或被pickle

我有一个由两部分组成的问题:

1. 我在这里想念的是什么; 为什么不应该在进程之间共享池？
2. 在Python中实现嵌套并行性的模式是什么？ 如果可能的话,维护一个递归结构,而不是交换迭代.

from concurrent.futures import ThreadPoolExecutor

def fibonacci(n):
    if n < 2:
        return n
    a = pool.submit(fibonacci, n - 1)
    b = pool.submit(fibonacci, n - 2)
    return a.result() + b.result()

def main():
    global pool

    N = int(10)
    with ThreadPoolExecutor(2**N) as pool:
        print(fibonacci(N))

main()

Java的

public class FibTask implements Callable<Integer> {

    public static ExecutorService pool = Executors.newCachedThreadPool();
    int …

来自Stream javadoc:

流管道可以顺序执行或并行执行.此执行模式是流的属性.通过初始选择的顺序或并行执行来创建流.

我的假设:

1. 顺序/并行流之间没有功能差异.输出永远不会受执行模式的影响.
2. 由于性能的提高,在给定适当数量的内核和问题大小以证明开销合理的情况下,并行流总是更可取的.
3. 我们想编写一次代码并在任何地方运行而不必关心硬件(毕竟这是Java).

假设这些假设是有效的(对于一些元假设没有错误),在api中暴露执行模式的价值是什么？

看起来您应该只能声明一个Stream,并且顺序/并行执行的选择应该在下面的层中自动处理,可以通过库代码或JVM本身作为运行时可用核心的函数来处理,大小问题等

当然,假设并行流也可以在单个核心机器上运行,也许只是总是使用并行流来实现这一点.但这真的很难看 - 为什么我的代码中的并行流显式引用它是默认选项？

即使存在您故意想要对顺序流进行硬编码的情况 - 为什么不仅仅是SequentialStream为此目的的子接口,而不是Stream使用执行模式切换进行污染？