我一直试图在我的大学集群上运行Rmpi,snowfall但出于某种原因,无论我分配了多少计算节点,我的snowfall初始化仍然只在一个节点上运行.

这是我如何初始化它:

sfInit(parallel=TRUE, cpus=10, type="MPI")

有任何想法吗？我会根据需要提供澄清.

我想使用子进程让20个写入脚本实例并行运行.假设我有一个大的网址列表,其中包含100,000个条目,我的程序应该控制我的脚本的20个实例始终在该列表上工作.我想按如下方式编写代码:

urllist = [url1, url2, url3, .. , url100000]
i=0
while number_of_subproccesses < 20 and i<100000:
    subprocess.Popen(['python', 'script.py', urllist[i]]
    i = i+1

我的脚本只是将内容写入数据库或文本文件.它不输出任何东西,不需要比网址更多的输入.

我的问题是我找不到如何获得活动子进程数的东西.我是一个新手程序员,所以每个提示和建议都是受欢迎的.我还想知道如果加载了20个子进程,while循环再次检查条件,我怎么能管理它？我想过可能会在它上面放一个while循环,比如说

while i<100000
   while number_of_subproccesses < 20:
       subprocess.Popen(['python', 'script.py', urllist[i]]
       i = i+1
       if number_of_subprocesses == 20:
           sleep() # wait to some time until check again

或者也许还有一种可能性,即while循环总是检查子进程的数量？

我还考虑过使用模块多处理,但我发现只使用子处理调用script.py而不是多处理函数非常方便.

也许有人可以帮助我并引导我走向正确的方向.非常感谢!

我有一个java方法,它包含5种不同的内部方法.为了提高性能,我想平行地调用这些方法.

例如,使用线程运行method1,method2,... method5并行.

private void getInformation() throws SQLException,
            ClassNotFoundException, NamingException {
    method1();
    method2();
    method3();
    method4();
    method5();
}

但所有这5种方法都有不同的业务逻辑.

我有一个程序,我需要编译几千个大型正则表达式,所有这些都将被使用多次.问题是,它们需要太长时间(根据cProfiler,113秒)re.compile().(顺便说一句,实际上使用所有这些正则表达式进行搜索,一旦编译就会<1.3秒.)

如果我不预编译,它只是将问题推迟到我实际搜索时,因为re.search(expr, text)隐式编译expr.实际上,它更糟糕,因为re每次我使用它们都会重新编译整个正则表达式列表.

我尝试过使用multiprocessing,但这实际上减慢了速度.这是一个小测试来证明:

## rgxparallel.py ##
import re
import multiprocessing as mp

def serial_compile(strings):
    return [re.compile(s) for s in strings]

def parallel_compile(strings):
    print("Using {} processors.".format(mp.cpu_count()))
    pool = mp.Pool()
    result = pool.map(re.compile, strings)
    pool.close()
    return result

l = map(str, xrange(100000))

我的测试脚本:

#!/bin/sh
python -m timeit -n 1 -s "import rgxparallel as r" "r.serial_compile(r.l)"
python -m timeit -n 1 -s "import rgxparallel as r" "r.parallel_compile(r.l)"
# Output:
#   1 …

题

在设备全局内存中移动许多随机(非合并)值时,这是最有效的方法吗？

注意:许多值大于500.

上下文

我已经在GPU的遗传算法实现中工作了一段时间,我一直在努力在我的框架的灵活性和GPU架构的微优化之间挣扎.GA数据始终驻留在GPU中.只有最佳世代解决方案才会复制到主机内存中.

详细方案

我正在优化迁移功能.这里基本上很少有数据在设备全局存储器中进行混洗.但我有在这样的方式我的数据以便它合并为GA运营商的内核线程的内存访问计划,这使得洗牌一对'的基因组 ’,迈进了单精度浮点数值,并与另一交换他们的事基因组中同样的跨越时尚.

已知的解决方案

问题不在于内存带宽,而在于调用延迟和线程阻塞使进程停滞.

1. 我写了几个设备内核,其功能仅仅是在地址之间移动值.这将启动一个内核(具有非常低的占用率,不同的代码和随机内存访问...因此它运行的小代码,将被序列化),但只能对设备进行两次内核调用.

   • 1st Kernel将值复制到缓冲区数组.
   • 第二个内核交换值.

2. 我知道我可以为每个值使用cudaMemcpy,但这需要多次调用cudaMemCpy,我认为这是同步调用.

简化的代码示例:

int needed_genome_idx = 0; // Some random index.
for(int nth_gene = 0; nth_gene < num_genes; ++nthgene)
{
  cudaMemcpy(genomes_buffer + nth_gene,
             src + needed_genome_idx + nth_gene * stride_size, // stride_size being a big number, usually equal to the size of the GA population.
             sizeof(float),
             cudaMemCpyDeviceToDevice);
}

这是一个可行的解决方案？使用cudaMemCpyAsync会 …

是否有任何算法使其链接列表的并行排序值得？

众所周知,Merge Sort是用于排序链表的最佳算法.

大多数合并排序都是根据数组来解释的,每一半都是递归排序的.这将使并行化变得微不足道:独立地对每一半进行排序然后合并两半.

但链表没有"中途"点; 链表一直持续到结束:

头→[a]→[b]→[c]→[d]→[e]→[f]→[g]→[h]→[i]→[j]→...

我现在已经执行了一次实现以获得计数,然后递归地分割计数,直到我们将节点与它进行比较NextNode.递归负责记住两半的位置.

这意味着链表的MergeSort在列表中线性前进.由于它似乎要求通过列表线性进展,我认为它不能并行化.我能想象的唯一方法是:

• 走一下列表来统计 O(n)
• 走到列表的一半,到达中途点 O(n/2)
• 然后排序每一半 O(n log n)

但即使我们在单独的线程中并行排序(a,b)和(c,d),我也会认为NextNode重新排序期间的错误共享会破坏任何并行化的优点.

有没有用于排序链表的并行算法？

数组合并排序算法

以下是对数组执行合并排序的标准算法:

algorithm Merge-Sort
    input:
        an array, A (the values to be sorted)
        an integer, p (the lower bound of the values to be sorted)
        an integer, r (the upper bound of the values to be sorted)

    define variables:
        an integer, q (the midpoint of the values to be sorted)

    q …

我目前正在使用OpenMP进行矩阵计算.我的代码中有几个循环,而是调用每个循环#pragma omp parallel for [...](创建所有线程并在之后销毁它们)我想在开头创建所有这些,并且在程序结束时删除它们以避免开销.我想要的东西:

#pragma omp parallel
{
    #pragma omp for[...]
    for(...)

    #pragma omp for[...]
    for(...)
}

问题是我有一些部分必须只由一个线程执行,但是在一个循环中,它包含那些必须并行执行的循环......这就是它的样子:

//have to be execute by only one thread
int a=0,b=0,c=0;
for(a ; a<5 ; a++)
{

    //some stuff

    //loops which have to be parallelize
    #pragma omp parallel for private(b,c) schedule(static) collapse(2)
    for (b=0 ; b<8 ; b++);
        for(c=0 ; c<10 ; c++)
        {
            //some other stuff
        }

    //end of the parallel zone
    //stuff to be execute by only one thread

} …

我使用aync.parallel并行运行两个函数.这些函数请求RSS提要.然后解析RSS提要并将其添加到我的网页.

但由于某种原因async.parallel运行回调方法而不等到两个函数完成

文件说:

任务完成后,结果将作为数组传递给最终回调.

我的代码.

require('async').parallel([ function(callback) {
        fetchRss(res, bbcOpts); // Needs time to request and parse
        callback();
    }, function(callback) {
        // Very fast.
        callback();
    } ], function done(err, results) {
        if (err) {
            throw err;
        }
        res.end("Done!");
    });

事实上我只有"完成!" 在我的网页上.为什么？

我为什么需要打电话res.end()？

在Node.js的文件说:

必须在每个响应上调用方法response.end().

如果我不打电话,我的网页将被"下载"(我的意思是我的浏览器地址栏中的进度条).

我有一个相当大的对象列表,我想并行应用一个复杂的函数,但我当前的方法使用了太多的内存.我认为引用类可能会有所帮助,但使用mcapply它们来修改它们似乎不起作用.

该函数修改了对象本身,因此我用新的对象覆盖原始对象.由于该对象是一个列表,我只修改了它的一小部分,我希望R的复制修改语义可以避免生成多个副本; 然而,在运行它时,似乎并不是我正在做的事情.这是我一直使用的基本R方法的一个小例子.它正确地将余额重置为零.

## make a list of accounts, each with a balance
## and a function to reset the balance
foo <- lapply(1:5, function(x) list(balance=x))
reset1 <- function(x) {x$balance <- 0; x}
foo[[4]]$balance
## 4 ## BEFORE reset
foo <- mclapply(foo, reset1)
foo[[4]]$balance
## 0 ## AFTER reset

似乎使用引用类可能会有所帮助,因为它们是可变的,并且在使用lapply它时确实按照我的预期进行; 余额重置为零.

Account <- setRefClass("Account", fields=list(balance="numeric"),
                       methods=list(reset=function() {balance <<- 0}))

foo <- lapply(1:5, function(x) Account$new(balance=x))
foo[[4]]$balance
## 4
invisible(lapply(foo, function(x) x$reset()))
foo[[4]]$balance
## 0

但是当我使用时mclapply,它没有正确重置.请注意,如果您使用的是Windows …

我有一项服务,我必须在从API获取后将大量记录保存到数据库.同时我必须将这些记录从服务返回给调用者.但问题是我在DB中保存记录需要很长时间,因此服务变慢.我搜索了这个并发现了一些并行任务或异步等待的概念.

我是这个概念的新手,对它的用法感到困惑

我调查了一下:

运行多个C#任务异步 http://msdn.microsoft.com/en-us/library/hh191443.aspx

但我不知道该怎么办.请帮助我:

下面是代码:

public List<SearchedItems> SearchItems(string ItemToSearch, string AuthenticationToken)
{
    var _list= getRecords from Api //100 records    

     //Task<int>.Factory.StartNew(() => _objBLLNutritionLog.FillNutritionTable(_tempList)); // also tried this

    saveToDb(_list); // need to run this asynchronously Or parallel (Taking long time)

    return _list;

}

我想将结果返回给调用者,另一方面想要填充db.请建议.

谢谢