标签: parallel-processing

我认为它们基本上是相同的 - 编写在处理器之间分割任务的程序(在具有2个以上处理器的机器上).然后我正在阅读https://msdn.microsoft.com/en-us/library/hh191443.aspx,其中说

异步方法旨在实现非阻塞操作.异步方法中的await表达式在等待的任务运行时不会阻止当前线程.相反,表达式将方法的其余部分作为延续进行注册,并将控制权返回给异步方法的调用者.

async和await关键字不会导致创建其他线程.异步方法不需要多线程,因为异步方法不能在自己的线程上运行.该方法在当前同步上下文上运行,并仅在方法处于活动状态时在线程上使用时间.您可以使用Task.Run将CPU绑定的工作移动到后台线程,但后台线程无助于正在等待结果可用的进程.

我想知道是否有人可以为我翻译成英文.它似乎区分了异步性(是一个单词？)和线程,并暗示你可以拥有一个具有异步任务但没有多线程的程序.

现在我理解异步任务的想法,例如pg上的示例.Jon Skeet的C#In Depth,第三版中的 467

async void DisplayWebsiteLength ( object sender, EventArgs e )
{
    label.Text = "Fetching ...";
    using ( HttpClient client = new HttpClient() )
    {
        Task<string> task = client.GetStringAsync("http://csharpindepth.com");
        string text = await task;
        label.Text = text.Length.ToString();
    }
}

该async关键字的意思是" 这个功能,无论何时它被调用时,不会在这是需要的一切它的完成被称为它的呼叫后,上下文调用."

换句话说,将它写在某个任务的中间

int x = 5; 
DisplayWebsiteLength();
double y = Math.Pow((double)x,2000.0);

,因为DisplayWebsiteLength()与"无关" x或y将导致DisplayWebsiteLength()"在后台"执行,如

                processor 1                |      processor 2
-------------------------------------------------------------------
int …

Haskell中多核编程的现状如何？现在有哪些项目,工具和库？有什么经验报告？

Erg,我正在尝试使用Reflector在BCL中找到这两个方法,但找不到它们.这两个片段之间的区别是什么？

A:

IEnumerable<string> items = ...

Parallel.ForEach(items, item => {
   ...
});

B:

IEnumerable<string> items = ...

foreach (var item in items.AsParallel())
{
   ...
}

使用一个比另一个有不同的后果吗？(假设我在两个示例的括号内部所做的事情都是线程安全的.)

许多平台都提倡异步和并行作为提高响应能力的手段.我一般都了解这种差异,但经常发现很难在我自己的心中以及其他人中表达出来.

我是一名工作日程序员,经常使用异步和回调.并行感觉异国情调.

但我觉得他们很容易混淆,特别是在语言设计层面.希望能够清楚地描述它们之间的关系(或不关联),以及各自最佳应用的程序类别.

对于C++,我们可以使用OpenMP进行并行编程; 但是,OpenMP不适用于Python.如果我想并行我的python程序的某些部分,我该怎么办？

代码的结构可以被认为是:

 solve1(A)
 solve2(B)

哪里solve1和solve2是两个独立的功能.如何并行运行这种代码而不是按顺序运行以减少运行时间？希望可以有人帮帮我.首先十分感谢.代码是:

def solve(Q, G, n):
    i = 0
    tol = 10 ** -4

    while i < 1000:
        inneropt, partition, x = setinner(Q, G, n)
        outeropt = setouter(Q, G, n)

        if (outeropt - inneropt) / (1 + abs(outeropt) + abs(inneropt)) < tol:
            break

        node1 = partition[0]
        node2 = partition[1]

        G = updateGraph(G, node1, node2)

        if i == 999:
            print "Maximum iteration reaches"
    print inneropt

setinner和setouter是两个独立的函数.这就是我要平行的地方......

我有一个powershell脚本对一堆图像进行一些批处理,我想做一些并行处理.Powershell似乎有一些后台处理选项,如启动作业,等待作业等,但我找到的并行工作的唯一好资源是编写脚本文本并运行它们(PowerShell多线程)

理想情况下,我喜欢类似于.net 4中的并行foreach的东西.

有点像:

foreach-parallel -threads 4 ($file in (Get-ChildItem $dir))
{
   .. Do Work
}

也许我会更好的只是下降到c#...

我正在学习如何使用Python中threading的multiprocessing模块和并行运行某些操作并加快我的代码.

我发现这很难(可能因为我没有任何理论背景)来理解一个threading.Thread()对象和一个对象之间的区别multiprocessing.Process().

此外,我并不完全清楚如何实例化一个作业队列,并且只有4个(例如)它们并行运行,而另一个则在执行之前等待资源释放.

我发现文档中的示例清晰,但不是很详尽; 一旦我尝试使事情复杂化,我就会收到许多奇怪的错误(比如一种无法腌制的方法,等等).

那么,我什么时候应该使用threading和multiprocessing模块？

您能否将我链接到一些资源,解释这两个模块背后的概念以及如何正确使用它们来完成复杂的任务？

我正在尝试并行化光线跟踪器.这意味着我有一个很长的小计算列表.vanilla程序在67.98秒内在特定场景上运行,总内存使用量为13 MB,生产率为99.2%.

在我的第一次尝试中,我使用parBuffer了缓冲区大小为50 的并行策略.我之所以选择parBuffer它是因为它只是在消耗火花的情况下遍历列表,并且不会强制列表的主干parList,这会占用大量内存因为清单很长.有了-N2它,它运行时间为100.46秒,总内存使用量为14 MB,生产率为97.8%.火花信息是:SPARKS: 480000 (476469 converted, 0 overflowed, 0 dud, 161 GC'd, 3370 fizzled)

大部分失败的火花表明火花的粒度太小,所以接下来我尝试使用策略parListChunk,将列表分成块并为每个块创建一个火花.我得到了最好的结果,大小为0.25 * imageWidth.该程序运行时间为93.43秒,总内存使用量为236 MB,生产率为97.3%.火花信息是:SPARKS: 2400 (2400 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled).我相信更大的内存使用是因为parListChunk强制列表的主干.

然后我试着编写自己的策略,懒洋洋地将列表分成块,然后传递块parBuffer并连接结果.

 concat $ withStrategy (parBuffer 40 rdeepseq) (chunksOf 100 (map colorPixel pixels))

这运行时间为95.99秒,总内存使用量为22MB,生产率为98.8%.在所有火花都被转换并且内存使用率低得多的意义上,这是成功的,但速度没有提高.以下是事件日志配置文件的一部分图像.

正如您所看到的,由于堆溢出,线程正在停止.我尝试添加+RTS -M1G,它将默认堆大小一直增加到1Gb.结果没有改变.我读到如果堆栈溢出,Haskell主线程将使用堆中的内存,所以我也尝试增加默认堆栈大小,+RTS -M1G -K1G但这也没有影响.

还有什么我可以尝试的吗？如果需要,我可以发布更详细的内存使用情况或事件日志的分析信息,我没有全部包含它,因为它是很多信息,我不认为所有这些都是必要的.

编辑:我正在阅读有关Haskell RTS多核支持的内容,并且它讨论了每个内核都有一个HEC(Haskell执行上下文).除了别的以外,每个HEC都包含一个分配区域(它是单个共享堆的一部分).每当HEC的分配区域耗尽时,必须执行垃圾收集.似乎是一个控制它的RTS选项,-A.我试过-A32M,但没有看到任何区别.

EDIT2: 这是一个专门针对这个问题的github仓库的链接 …

假设我有一个大内存numpy数组,我有一个函数func,它接受这个巨大的数组作为输入(连同一些其他参数).func具有不同参数可以并行运行.例如:

def func(arr, param):
    # do stuff to arr, param

# build array arr

pool = Pool(processes = 6)
results = [pool.apply_async(func, [arr, param]) for param in all_params]
output = [res.get() for res in results]

如果我使用多处理库,那么这个巨型数组将被多次复制到不同的进程中.

有没有办法让不同的进程共享同一个数组？此数组对象是只读的,永远不会被修改.

更复杂的是,如果arr不是一个数组,而是一个任意的python对象,有没有办法分享它？

[EDITED]

我读了答案,但我仍然有点困惑.由于fork()是copy-on-write,因此在python多处理库中生成新进程时不应调用任何额外的成本.但是下面的代码表明存在巨大的开销:

from multiprocessing import Pool, Manager
import numpy as np; 
import time

def f(arr):
    return len(arr)

t = time.time()
arr = np.arange(10000000)
print "construct array = ", time.time() - t;


pool = Pool(processes = 6)

t = …

如果我不关心任务完成的顺序,只需要完成它们,我还应该使用await Task.WhenAll而不是多个await吗？例如,DoWork2低于优选的方法DoWork1(以及为什么？):

using System;
using System.Threading.Tasks;

namespace ConsoleApp
{
    class Program
    {
        static async Task<string> DoTaskAsync(string name, int timeout)
        {
            var start = DateTime.Now;
            Console.WriteLine("Enter {0}, {1}", name, timeout);
            await Task.Delay(timeout);
            Console.WriteLine("Exit {0}, {1}", name, (DateTime.Now - start).TotalMilliseconds);
            return name;
        }

        static async Task DoWork1()
        {
            var t1 = DoTaskAsync("t1.1", 3000);
            var t2 = DoTaskAsync("t1.2", 2000);
            var t3 = DoTaskAsync("t1.3", 1000);

            await t1; await t2; await t3;

            Console.WriteLine("DoWork1 results: {0}", String.Join(", ", …