标签: parallel-processing

我正在研究一个简单的工作线程框架,它与id Tech 5 Challenges中描述的框架非常相似.在最基本的层面上,我有一组作业列表,我想在一堆CPU线程中安排这些列表(使用标准线程池进行实际调度.)但是,我想知道这个信号/等待的东西是怎么回事在等待列表中可以有效地实现.据我了解,如果信号令牌尚未执行,则等待令牌会阻止列表执行.这隐含地意味着信号之前的所有内容必须在信号可以被提升之前完成.所以我们假设我们有一个这样的列表:

J1, J2, S, J3, W, J4

然后调度可以像这样:

#1: J1, J2, J3
<wait for J1, J2, run other lists if possible>
#2: J4

然而,这并不像它看起来那么容易,因为给定一组名单,我将不得不将部分之间ready和waiting,也有特殊代码的信号和标签的东西在他们之前收集的所有作业,让他们可以触发信号,当且仅当他们都完成的(意为实例,它是不再可能的工作添加到列表中,同时执行它,如下面的信号访问先前插入作业).

是否有任何"标准"的方式有效地实现这一点？我也想知道如何最好地安排作业列表执行,现在,每个核心抓取一个作业列表,并安排其中的所有作业,这提供了非常好的扩展(对于32k作业,0.7毫秒,我得到101%,我猜部分原因是单线程版本有时被安排到不同的核心上.)

我刚开始学习如何使用OpenMP.我试图弄清楚为什么下面的代码不能与Visual Studio 2008并行运行.它编译并运行正常.但是它在我的四核机器上只使用一个核心.这是我试图移植到MATLAB mex函数的代码的一部分.任何指针都很受欢迎.

#pragma omp parallel for default(shared) private(dz, t, v, ts_count) reduction(+: sum_v)
for(t = 0; t<T; t++)
{
    dz = aRNG->randn();
    v += mrdt* (tv - v) +
         vv_v_sqrt_dt * dz +
         vv_vv_v_dt*(dz*dz - 1.);

    sum_v += v;
    if(t == ts_count-1)
    {
        int_v->at_w(k++) = sum_v/(double)(t+1);
        ts_count += ts;
    }
}

seq在Clojure中是否有一个很好的算法来同时计算三个笛卡尔积？

我正在Clojure开展一个小型业余爱好项目,主要是作为学习语言及其并发功能的一种手段.在我的项目中,我需要计算三个笛卡尔乘积seq(并对结果做一些事情).

我找到了cartesian-product函数clojure.contrib.combinatorics,效果很好.然而,笛卡尔积的计算结果证明是该程序的瓶颈.因此,我想同时进行计算.

现在,对于该map功能,有一个方便的pmap替代方案,神奇地使事物并发.哪个很酷:).不幸的是,这样的事情不存在cartesian-product.我查看了源代码,但我找不到一个简单的方法来让它自己并发.

此外,我尝试使用自己实现的算法map,但我想我的算法技能不再像过去那样.我设法拿出了两个丑陋的东西seq,但是三个绝对是一座太过分的桥梁.

那么,有没有人知道一个已经并发的算法,或者我可以自己并行化的算法？

编辑

换句话说,我真正想要实现的是实现与此Java代码类似的东西:

for (ClassA a : someExpensiveComputation()) {
    for (ClassB b : someOtherExpensiveComputation()) {
        for (ClassC c : andAnotherOne()) {
            // Do something interesting with a, b and c
        }
    }
}

我正在寻找一个C类的并行编程项目(可能使用pthreads或OpenMP).它将由一组约四名学生完成,大约需要4周.我认为使用更复杂的算法(如模拟退火的遗传算法)攻击一些NP完全问题会很有趣,但我不确定它是否足够大.

有人知道任何可以从并行方法中受益的很酷的问题吗？

在.NET 4和多核环境中,如果我们使用DataLoadOptions.LoadWith,linq to sql datacontext对象是否会利用新的并行？

编辑

我知道linq to sql没有并行化普通查询.我想知道的是,当我们指定DataLoadOption.LoadWith时,它是否使用并行化来执行每个实体及其子实体之间的匹配？

例:

using(MyDataContext context = new MyDataContext())
{
     DataLaodOptions options =new DataLoadOptions();
     options.LoadWith<Product>(p=>p.Category);
     return this.DataContext.Products.Where(p=>p.SomeCondition);
}

生成以下sql:

Select Id,Name from Categories
Select Id,Name, CategoryId from Products where p.SomeCondition

当所有产品都被创建时,我们会有一个

categories.ToArray();
Parallel.Foreach(products, p =>
{
    p.Category == categories.FirstOrDefault(c => c.Id == p.CategoryId);
});

要么

categories.ToArray();
foreach(Product product in products)
{
    product.Category = categories.FirstOrDefault(c => c.Id == product.CategoryId);
}

？

erlang中的消息循环如何工作,它们在处理消息时是否同步？

据我所知,循环将从"接收"消息开始,然后执行某些操作并点击循环的另一次迭代.

那必须同步吗？对？

如果多个客户端将消息发送到同一个消息循环,那么所有这些消息都会排队并一个接一个地执行,或者？

要在并行处理多个消息,您必须在不同的进程中生成多个消息循环,对吧？

还是我误解了所有这些？

我有一个对象列表,每个对象都有一个bool ShouldRun()方法.

我正在迭代对象列表,并检查每个对象上的ShouldRun(),并在第一个上调用Run()返回true

foreach (child in Children)
{
   if (child.ShouldRun())
   {
      child.Run();
      break;
    }
 }

我想并行执行此操作,因为评估shouldRun可能需要相当长的时间,并且让集合中的后续元素尽早开始评估是有利的.

但是,我无法想到一种满足这些条件的方法:

1只运行一个项目

2如果之前的项目为true,或者尚未完成评估,请不要运行以后的项目

3如果所有"早期"项目都返回false,并且中间项目返回true,则不要等待后面的项目完成评估,因为您知道它不能提前覆盖任何内容.

我想做一个并行的"where"linq查询来检索所有的项目,然后运行shouldRun()然后排序,但这会违反条件#3

想法？

背景资料:

该系统用于通用机器人AI系统.

一些较高优先级的任务可以由立即已知的传感器变量触发,例如:我摔倒,修复它!

其他任务可能是计算密集型的(从相机进行图像识别,并接近可见目标)

其他任务可能是数据库或远程驱动(从数据库中查找可能的目标位置列表,然后在那里导航以查看是否可以进入其中一个的可见范围)

一些任务本身具有子任务,这本质上是在一个任务的子集上递归地开始这个过程,并且孙子任务将通过链传递

假设我用以下方式定义所有自然数的序列:

(def naturals (iterate inc 0))

我还定义了一个将自然映射到nil的函数,需要一段时间来计算,如下所示:

(defn hard-comp [_] (Thread/sleep 500))

请注意计算时间以按照度量来评估以下s表达式clojure.core/time.

(dorun (map hard-comp (range 30))) ; 15010.367496毫秒

(dorun (pmap hard-comp (range 30))) ; 537.044554 msecs

(dorun (map hard-comp (doall (take 30 naturals))))) ; 15009.488499 msecs

(dorun (pmap hard-comp (doall (take 30 naturals)))) ; 3004.499013毫秒

(doall (take 30 naturals)) ; 0.385724毫秒

(range 30) ; 0.159374毫秒

pmap 使用显式范围调用时比使用自然部分快6倍.

由于(= (range 30) (take 30 naturals))返回true并且两个对象都是类型clojure.lang.LazySeq,并且clojure在调用函数之前调用函数的所有参数,如何解释上述时序细节？

假设你有一个1000个随机整数的数组,你需要循环它以找到数字68,例如.

在四核CPU上使用新的Parallel.For可以大大提高速度,使每个核心只能工作250个数组项.

问题是:当满足以下条件时,是否可以中断Parallel.For循环？

if (integerArray[i] == 68)

   break;

谢谢.

如何在Delphi(Delphi 200X,Delphi XE)中实现并行循环？怎么做这个最好的方法？有没有通用的解决方案？

请举例说明.