我正在编写自己的图形库(是的,它的作业:)并使用cuda快速完成所有渲染和计算.

我有绘制填充三角形的问题.我这样编写了一个进程绘制一个三角形.当场景中有很多小三角形时它工作得很好,但是当三角形很大时它会完全破坏性能.

我的想法是做两次通过.首先计算仅包含扫描线信息的选项卡(从此处绘制到此处).这将是每个过程计算的三角形,就像当前算法一样.在第二遍中,确实绘制了每个三角形有多个进程的扫描线.

但它会足够快吗？也许有更好的解决方案？

我正在研究一个简单的工作线程框架,它与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);
}

？

假设我们需要对5 000 000个数字进行排序.假设,这些数字存储在一个文件中.解决此问题的最有效算法是什么？并行排序算法......

怎么做？也许有用的链接)

我不能使用标准算法

好的..我读过有关并行合并的内容......但对我来说并不清楚.

解决方案,第一个版本

代码位于此处

我用parSapply()从parallel包河,我需要对大量的数据进行计算.即使并行执行也需要数小时,因此我决定定期将结果写入集群中的文件write.table(),因为当内存不足或其他一些随机原因导致进程崩溃时,我想继续计算把它停下来.我注意到我得到的一些csv文件行只是在中间切割,可能是由于多个进程同时写入文件.有没有办法在write.table()执行时暂时锁定文件,因此其他集群无法访问它,或者唯一的出路是从每个集群写入单独的文件然后合并结果？

我有一个python函数,它从文本文件中读取一行并将其写入另一个文本文件.它会对文件中的每一行重复此操作.实质上:

Read line 1 -> Write line 1 -> Read line 2 -> Write line 2...

等等.

我可以使用队列来传递数据来并行化这个过程,所以它更像是:

Read line 1 -> Read line 2 -> Read line 3...

              Write line 1 -> Write line 2....

我的问题是 - 为什么这样做(因为我为什么加快速度？).听起来像是一个愚蠢的问题,但我在想 - 当然我的硬盘一次只能做一件事吗？那么为什么没有一个过程被搁置直到另一个过程完成？

当用高级语言写作时,这样的事情对用户是隐藏的.我想知道什么是低级别的？

我有一个任务来计算数组中的xor-sum字节:

X = char1 XOR char2 XOR char3 ... charN;

我正在尝试并行化它,而是使用__m128.这应该加速因子4.另外,要重新检查算法,我使用int.这应该加速因子4.测试程序是100行,我不能让它更短,但它很简单:

#include "xmmintrin.h" // simulation of the SSE instruction
#include <ctime>

#include <iostream>
using namespace std;

#include <stdlib.h> // rand

const int NIter = 100;

const int N = 40000000; // matrix size. Has to be dividable by 4.
unsigned char str[N] __attribute__ ((aligned(16)));

template< typename T >
T Sum(const T* data, const int N)
{
    T sum = 0;
    for ( int i = 0; i < N; ++i …