标签: parallel-processing

Erlang因能够支持许多轻量级进程而闻名.它可以做到这一点,因为它们不是传统意义上的进程,甚至不是P线程中的线程,而是完全在用户空间中的线程.

这很好(实际上太棒了).但是,如何在多核/多处理器环境中并行执行Erlang线程？当然它们必须以某种方式映射到内核线程才能在不同的内核上执行？

假设情况就是这样,这是怎么做到的？许多轻量级进程是否映射到单个内核线程？

或者还有另一种解决这个问题的方法吗？

我有一个bash脚本,其中包含串行运行的其他脚本.但是,运行它们需要相当长的时间.有没有办法并行运行这些脚本以提高整体性能？它们彼此独立.

它看起来类似于:

#!/bin/bash

#some code here
cppcheck.sh
churn.sh
run.sh

更新:

**git log --pretty=format: --numstat | perl -ane'$c{$F[2]} += abs($F[0]+$F[1]) 
if $F[2];END {print "$_\t$c{$_}\n" for sort keys %c}' > ${OUTPUT_DIR}/churn.txt**
sed -i -e '/deps/d;/build/d;/translations/d;/tests/d' -e 30q ${OUTPUT_DIR}/churn.txt
sort -r -n -t$'\t' -k2 ${OUTPUT_DIR}/churn.txt -o ${OUTPUT_DIR}/churn.txt
echo "set term canvas size 1200, 800; set output '${OUTPUT_DIR}/output.html'; 
unset key; set bmargin at screen 0.4; set xtics rotate by -90 scale 0,0; 
set ylabel 'Number of lines changed (total)'; set title 'Files with high …

我对"火花"的概念感到困惑

它是Haskell中的一个线程吗？或者是产生新线程的行为？

谢谢大家:

总而言之,spark不是线程,而是更多的计算单元(将它放在C#/ Java术语中的任务).所以这是实现任务并行性的Haskell方式.

我正在寻找一个确定的答案MATLAB的parfor for Python(Scipy,Numpy).

有没有类似于parfor的解决方案？如果没有,创建一个的复杂性是什么？

更新:这是我需要加速的典型数值计算代码

import numpy as np

N = 2000
output = np.zeros([N,N])
for i in range(N):
    for j in range(N):
        output[i,j] = HeavyComputationThatIsThreadSafe(i,j)

重计算函数的一个例子是:

import scipy.optimize

def HeavyComputationThatIsThreadSafe(i,j):
    n = i * j

    return scipy.optimize.anneal(lambda x: np.sum((x-np.arange(n)**2)), np.random.random((n,1)))[0][0,0]

.net函数Parallel.ForEach是否会阻塞调用线程？我对行为的猜测是以下之一:

1. 是的,它会阻塞,直到最慢的项目执行返回.
2. 不,它不会阻止并立即返回控制.并行运行的项目在后台线程上完成.

或许其他事情正在发生,任何人都知道吗？

在日志记录类中实现此问题时出现了这个问题:

public class MultipleLoggingService : LoggingServiceBase
{
    private readonly List<LoggingServiceBase> loggingServices;

    public MultipleLoggingService(List<LoggingServiceBase> loggingServices)
    {
        this.loggingServices = loggingServices;
        LogLevelChanged += OnLogLevelChanged;
    }

    private void OnLogLevelChanged(object sender, LogLevelChangedArgs args)
    {
        loggingServices.ForEach(l => l.LogLevel = LogLevel);
    }

    public override LogMessageResponse LogMessage(LogMessageRequest request)
    {
        if (request.LogMessage)
            Parallel.ForEach(loggingServices, l => l.LogMessage(request));

        return new LogMessageResponse{MessageLogged = request.LogMessage};
    }
}

请注意,该LogMessage方法调用其他一些日志服务.我需要该部分立即返回,因此它不会阻止调用线程.

更新:根据其他人的评论(我们已确认行为是#1).所以我已经建议使用Task库并重写循环,如下所示:

          if (request.LogMessage)
            foreach (var loggingService in loggingServices)
                Task.Factory.StartNew(() => loggingService.LogMessage(request));

我已经使用rosetta.parallel.pandas_easy并行分组后应用,例如:

from rosetta.parallel.pandas_easy import groupby_to_series_to_frame
df = pd.DataFrame({'a': [6, 2, 2], 'b': [4, 5, 6]},index= ['g1', 'g1', 'g2'])
groupby_to_series_to_frame(df, np.mean, n_jobs=8, use_apply=True, by=df.index)

但是,有没有人想出如何并行化返回数据帧的函数？正如预期的那样,此代码对于rosetta失败.

def tmpFunc(df):
    df['c'] = df.a + df.b
    return df

df.groupby(df.index).apply(tmpFunc)
groupby_to_series_to_frame(df, tmpFunc, n_jobs=1, use_apply=True, by=df.index)

哪些因素决定了chunksize方法的最佳参数multiprocessing.Pool.map()？该.map()方法似乎使用任意启发式作为其默认的chunksize(如下所述); 是什么推动了这种选择,是否有基于某些特定情况/设置的更周到的方法？

示例 - 说我是:

• 传递iterable到.map()拥有约1500万个元素的元素;
• 24个核的机器上工作,使用默认processes = os.cpu_count()内multiprocessing.Pool().

我天真的想法是给每24个工人一个同样大小的块,即15_000_000 / 24625,000.大块应该在充分利用所有工人的同时减少营业额/管理费用.但似乎缺少给每个工人提供大批量的一些潜在缺点.这是不完整的图片,我错过了什么？

我的部分问题源于if chunksize=None:both .map()和.starmap()call 的默认逻辑,.map_async()如下所示:

def _map_async(self, func, iterable, mapper, chunksize=None, callback=None,
               error_callback=None):
    # ... (materialize `iterable` to list if it's an iterator)
    if chunksize is None:
        chunksize, extra = divmod(len(iterable), len(self._pool) * 4)  # ????
        if extra:
            chunksize += 1
    if len(iterable) == 0:
        chunksize = …

如果您今天从头开始编写一个新的应用程序,并希望它可以扩展到明天可以使用的所有内核,您会选择哪种并行编程模型/系统/语言/库？为什么？

我对这些轴的答案特别感兴趣:

1. 程序员的生产力/易用性(凡人能成功使用它吗？)
2. 目标应用程序域(它(不)擅长什么问题？)
3. 并发风格(它是否支持任务,管道,数据并行,消息......？)
4. 可维护性/面向未来(任何人都会在20年内使用它吗？)
5. 性能(它如何在什么类型的硬件上扩展？)

我故意对应用程序的性质含糊不清,以期获得对各种应用程序有用的良好通用答案.

我正在阅读并发性.对于那些含有令人困惑的类似定义的术语,我有点过头了.即:

• 流程
• 主题
• "绿线"
• Protothreads
• 纤维
• 协同程序
• Go语言中的"Goroutines"

我的印象是,区别在于(1)是真正的并行还是多路复用; (2)是在CPU,OS还是在程序中管理; 和(3..5)我无法辨认的其他一些事情.

这些并行方法之间的差异是否有简明扼要的指导？

我想通过下面的大文章,了解Twitter的风暴" 了解风暴的拓扑结构的并行 "

但是我对"任务"的概念感到有些困惑.任务是组件的运行实例(spout还是bolt)？具有多个任务的执行程序实际上是说执行程序多次执行相同的组件,我是否正确？

此外,在一般的并行意义上,Storm会为spout或bolt生成一个专用线程(执行程序),但是由具有多个任务的执行程序(线程)对并行性做出了什么贡献？我认为在一个线程中有多个任务,因为一个线程按顺序执行,只会使该线程成为一种"缓存"资源,从而避免为下一个任务运行产生新线程.我对么？

我可以在花更多时间调查之后自己清除那些困惑,但是你知道,我们都喜欢stackoverflow ;-)

提前致谢.