标签: parallel-processing

我最近写了很多关于并行计算和编程的文章,我注意到在并行计算方面有很多模式出现.注意到Microsoft已经发布了一个库以及Microsoft Visual C++ 2010社区技术预览版(名为Parallel Patterns Library),我想知道你一直在使用和遇到的常见并行编程模式有哪些值得记住？当你用C++编写并行程序时,你是否有任何习惯用法和你似乎不断弹出的模式？

我目前的任务是优化蒙特卡罗模拟,该模拟根据一组Obligors计算资本充足率数据.

它运行大约10倍太慢,无法生产,需要数量或每日运行.此外,结果数字的粒度需要在某个阶段提升到桌面可能的书本水平,我给出的代码基本上是一个原型,由半生产能力的业务部门使用.

该应用程序目前是单线程的,所以我需要使它多线程,可能看看System.Threading.ThreadPool或Microsoft Parallel Extensions库但我在这家银行的服务器上受限于.NET 2所以我可能不得不考虑这个人的端口,http://www.codeproject.com/KB/cs/aforge_parallel.aspx.

我正在尽力让他们升级到.NET 3.5 SP1,但这是在这种规模的组织中的一项重要练习,在合同时间框架内可能无法实现.

我使用dotTrace的试用版(http://www.jetbrains.com/profiler)描述了该应用程序.还有哪些好的剖析器？免费的？

大量的执行时间用于生成均匀的随机数,然后将其转换为正态分布的随机数.他们正在使用C#Mersenne twister实现.我不确定他们在哪里获得它,或者它是最好的方法来实现这个(或最佳实现)来生成统一的随机数.然后将其转换为正态分布版本以供计算使用(我还没有深入研究过翻译代码).

使用以下内容的经验是什么？

• http://quantlib.org

• http://www.qlnet.org(Quantlib的C#端口)或

• http://www.boost.org

您知道的任何替代方案？我是C#开发人员,所以更喜欢C#,但C++的包装应该不是问题,是吗？

也许更快地利用C++实现.我认为这些库中的一些库将具有最快的方法来直接生成正态分布的随机数,而无需转换步骤.此外,他们可能还有一些其他功能,将有助于后续计算.

此外,它所使用的计算机是四核Opteron 275,8 GB内存,但Windows Server 2003 Enterprise 32位.我应该建议他们升级到64位操作系统吗？任何支持这一决定的文章的链接都将非常感激.

无论如何,任何建议和帮助你都非常感激.

我在.NET应用程序中遇到了一种奇怪的行为,它对一组内存数据执行一些高度并行的处理.

当在多核处理器(IntelCore2 Quad Q6600 2.4GHz)上运行时,它会展示非线性缩放,因为多个线程被启动以处理数据.

当作为单核上的非多线程循环运行时,该过程能够每秒完成大约240万次计算.当作为四个线程运行时,您可以预期吞吐量的四倍 - 在每秒900万次计算的某个地方 - 但是,唉,没有.在实践中,它每秒仅完成约4.1百万......与预期的吞吐量相当短.

此外,无论我使用PLINQ,线程池还是四个显式创建的线程,都会发生这种情况.很奇怪...

使用CPU时间没有其他任何东西在机器上运行,计算中也没有任何锁或其他同步对象......它应该只是在数据中前进.我已经通过在进程运行时查看perfmon数据来确认这一点(尽可能)...并且没有报告的线程争用或垃圾收集活动.

我的理论目前:

1. 所有技术(线程上下文切换等)的开销都压倒了计算
2. 线程没有被分配到四个核心中的每一个并且花费一些时间在同一个处理器核心上等待...不确定如何测试这个理论......
3. .NET CLR线程未按预期优先级运行或具有一些隐藏的内部开销.

以下是代码中应该表现出相同行为的代表性摘录:

    var evaluator = new LookupBasedEvaluator();

    // find all ten-vertex polygons that are a subset of the set of points
    var ssg = new SubsetGenerator<PolygonData>(Points.All, 10);

    const int TEST_SIZE = 10000000;  // evaluate the first 10 million records

    // materialize the data into memory...
    var polygons = ssg.AsParallel()
                      .Take(TEST_SIZE)
                      .Cast<PolygonData>()
                      .ToArray();

    var sw1 = Stopwatch.StartNew();
    // for loop completes in about 4.02 seconds... …

我正在写一个分布式的Go/Gomoku机器人.

基本上,重点是将树搜索分发到许多计算机上.使用像DFS这样的基本树搜索算法,这将非常简单,因为我可以将搜索空间划分为子树.虽然我宁愿拥有更高效的东西,比如使用alpha-beta修剪的mini-max - 但是根据我的理解,没有任何共享内存它是毫无意义的.所以我有点卡住了.

任何想法我可以使用哪种算法高效且易于分发？更重要的是,我在哪里可以找到一些(伪)代码或者可能实现？

谢谢,

让我们在网站上有2页成像:快速和慢速.慢速页面请求执行1分钟,请求快速5秒.

整个我的开发生涯我认为如果第一次启动请求很慢:他将对DB进行(同步)调用...等待回答...如果在此期间请求快速页面将完成,此请求将被处理系统正在等待DB的响应.

但今天我发现:http: //msdn.microsoft.com/en-us/library/system.web.httpapplication.aspx

HttpApplication类的一个实例用于在其生命周期中处理许多请求.但是,它一次只能处理一个请求.因此,成员变量可用于存储每个请求数据.

这是否意味着我原来的想法是错的？

你能澄清一下他们的意思吗？我很确定这件事是我所期待的......

在仔细阅读了Rx.NET的样本后,我对于Reactive Extensions的概念和实现有多么精彩.它似乎为开发人员提供了一种更易于维护的模式,用于实现.NET 4.0的任务并行库提供的相同类型的多线程并行编码.

Rx.NET会取代TPL吗？应该是？

在TPL(任务 - 并行 - 库)中是否有内置支持用于批处理操作？

我最近玩了一个例程,使用查找表即音译在字符数组上进行字符替换:

for (int i = 0; i < chars.Length; i++)
{
    char replaceChar;

    if (lookup.TryGetValue(chars[i], out replaceChar))
    {
        chars[i] = replaceChar;
    }
}

我可以看到这可能是平凡的并行化,所以跳进了第一次刺,我知道会因为任务太细粒度而表现更差:

Parallel.For(0, chars.Length, i =>
{
    char replaceChar;

    if (lookup.TryGetValue(chars[i], out replaceChar))
    {
        chars[i] = replaceChar;
    }
});

然后我重新编写算法以使用批处理,这样就可以将工作分成不同细粒度的不同线程.这使得线程按预期使用,并且我得到了一些接近线性的加速.

我确信必须内置支持TPL中的批处理.什么是语法,我该如何使用它？

const int CharBatch = 100;
int charLen = chars.Length;

Parallel.For(0, ((charLen / CharBatch) + 1), i =>
{
    int batchUpper = ((i + 1) * CharBatch);

    for (int j = i * …

我有OpenMP的问题.MSVS编译器抛出"pragma omp atomic有不正确的形式".我不知道为什么.代码:(程序使用积分方法指定PI编号)

#include <stdio.h>
#include <time.h>
#include <omp.h>

long long num_steps = 1000000000;
double step;

int main(int argc, char* argv[])
{
    clock_t start, stop;
    double x, pi, sum=0.0;
    int i;
    step = 1./(double)num_steps;
    start = clock();

    #pragma omp parallel for
    for (i=0; i<num_steps; i++)
    { 
        x = (i + .5)*step;
        #pragma omp atomic //this part contains error
        sum = sum + 4.0/(1.+ x*x);  
    }

    pi = sum*step;
    stop = clock();

    // some printf to show results
return …

我是IPython的新手,想在运行IPython并行集群功能时将中间结果打印到stdout.(我知道有多个进程,这可能会破坏输出,但这很好 - 它只是用于测试/调试,而我正在运行的进程足够长,以至于不太可能发生此类冲突.)我检查了IPython的文档,但找不到并行化函数打印的示例.基本上,我正在寻找一种方法将子进程的打印输出重定向到主stdout,IPython相当于

subprocess.Popen( ... , stdout=...)

在流程内打印不起作用:

rc = Client()
dview = rc()
def ff(x):
    print(x)
    return x**2
sync = dview.map_sync(ff,[1,2,3,4])
print('sync res=%s'%repr(sync))
async = dview.map_async(ff,[1,2,3,4])
print('async res=%s'%repr(async))
print(async.display_outputs())

回报

sync res=[1, 4, 9, 16]
async res=[1, 4, 9, 16]

因此计算正确执行,但函数ff中的print语句永远不会打印,即使返回所有进程也是如此.我究竟做错了什么？如何让"打印"工作？

我有一个简单的问题来解决(或多或少)
,如果我看蟒蛇多的教程,我看到的是一个过程,应开始或多或少是这样的:

from multiprocessing import *

def u(m):
    print(m)
    return

A=Process(target=u,args=(0,))
A.start()
A.join()

它应该打印0但没有打印.相反,它永远挂在了A.join().

如果我手动启动你这样做的功能

A.run()

它实际上在shell上打印0但它不能同时工作
,例如以下代码的输出:

from multiprocessing import *
from time import sleep

def u(m):
    sleep(1)
    print(m)
    return

A=Process(target=u,args=(1,))
A.start()
print(0)

应该是
0
1

但实际上是
0

如果我在最后一行之前添加

A.run()

然后输出变为
1
0

这对我来说似乎有点困惑......

如果我尝试加入这个过程,它会永远等待.

但是,如果它可以帮助给我一个答案
我的操作系统为Mac OS X 10.6.8
使用Python版本是3.1和3.3
我的电脑有1个英特尔酷睿i3处理器

--Update--
我注意到这种奇怪的行为只有在从IDLE启动程序时才会出现,如果我从终端运行程序一切正常,那么这个问题必须连接到一些IDLE错误.
但是来自终端的runnung程序甚至更奇怪:使用范围(100000000)之类的东西激活我所有计算机的内存,直到程序结束; 如果我记得很清楚这不应该发生在python 3中,只有在较旧的python版本中.我希望这些新信息可以帮助你给出答案

- 更新2--
即使我不从我的进程执行输出,也会发生错误,因为设置此:

def u():
    return

作为进程的目标,然后启动它,如果我尝试加入进程,空闲等待永远