标签: parallel-processing

假设我们有一个像这样的工人列表:

List<Worker> workers = new ArrayList<>();
workers.add(new Worker(1));
workers.add(new Worker(2));
workers.add(new Worker(3));
workers.add(new Worker(4));
workers.add(new Worker(5));

我想找到第一个完成工作的工人,所以:

Worker first = workers.parallelStream().filter(Worker::finish).findFirst().orElse(null);

但是有一个问题,我不想等待所有工人完成他们的工作然后找到第一个,但第一个工人一完成他的工作!

public class Test {

    public static void main(String[] args) {
        List<Worker> workers = new ArrayList<>();
        workers.add(new Worker(1));
        workers.add(new Worker(2));
        workers.add(new Worker(3));
        workers.add(new Worker(4));
        workers.add(new Worker(5));
        Worker first = workers.parallelStream().filter(Worker::finish).findFirst().orElse(null);
        if (first != null) {
            System.out.println("id : " + first.id);
        }
    }

    static class Worker {

        int id;

        Worker(int id) {
            this.id = id;
        }

        boolean finish() …

我想运行并行for循环.我需要我的每一个过程,以有机会获得2个大词典,gene_dict和transcript_dict.这是我先试过的

@everywhere( function EM ... end )

generefs  = [ @spawnat i genes for i in 2:nprocs()]
dict1refs = [ @spawnat i gene_dict for i in 2:nprocs()]
dict2refs = [ @spawnat i transcript_dict for i in 2:nprocs()]

result = @parallel (vcat) for i in 1:length(genes)
  EM(genes[i], gene_dict, transcript_dict)
end

但我在所有进程(不仅仅是5)上得到以下错误:

exception on 5: ERROR: genes not defined
 in anonymous at no file:1514
 in anonymous at multi.jl:1364
 in anonymous at multi.jl:820
 in run_work_thunk at multi.jl:593
 in run_work_thunk …

我正在从Udacity的并行编程课程中学习CUDA .在测验中,他们有一个排序预先排序的变量(玩家的身高)的问题.因为,它是输入和输出数组之间的一对一对应,它不应该是一个Map通信模式而不是一个Scatter？

我从一个更大的2D程序中提取了这个简单的成员函数,它所做的只是一个for循环访问三个不同的数组并进行数学运算(1D卷积).我一直在测试使用OpenMP来加快这个特定的功能:

void Image::convolve_lines()
{
  const int *ptr0 = tmp_bufs[0];
  const int *ptr1 = tmp_bufs[1];
  const int *ptr2 = tmp_bufs[2];
  const int width = Width;
#pragma omp parallel for
  for ( int x = 0; x < width; ++x )
    {
    const int sum = 0
      + 1 * ptr0[x]
      + 2 * ptr1[x]
      + 1 * ptr2[x];
    output[x] = sum;
    }
}

如果我在debian/wheezy amd64上使用gcc 4.7,整个程序在8 CPU机器上执行速度要慢很多.如果我在debian/jessie amd64上使用gcc 4.9(在这台机器上只有4个CPU),整个程序执行的差别很小.

使用time比较:单核运行:

$ ./test black.pgm out.pgm  94.28s user 6.20s system 84% …

我的目标是在一个集群上并行运行10,000个左右的Julia编码模拟(每个模拟独立于所有其他模拟).每个模拟都有一个数字输出(以及有关哪个模拟产生此数字的3列信息).因此,强制每个模拟在单独的文件上打印对我来说听起来有点愚蠢.

我可以安全地要求所有这些模拟在同一个文件上写入,或者如果两个模拟恰好在同一时间写入文件,这可能会导致错误吗？什么是最好的解决方案？

我有一个使用SpecFlow和NUnit 2.6.3作为我的测试提供者的项目.目前它工作正常,但现在需要并行运行测试,因为它们变得越来越重.

通过阅读,我可以看到NUnit版本3将支持开箱即用的并行性,但它仍处于alpha状态.并且我无法使用Nunit 3运行SpecFlow生成的测试..

是否有人知道此时是否可以使用SpecFlow和NUnit版本3？或者其他一些方法,仍然使用NUnit版本2.6.3和SpecFlow来实现并行性？

谢谢!

我有兴趣将Julia SharedArray用于科学计算项目.我目前的实现对BLAS的所有矩阵向量操作都很有吸引力,但我认为也许SharedArray可以在多核机器上提供一些加速.我的想法是简单地逐个索引更新输出向量,将索引更新耕种到工作进程.

前面的讨论在这里关于SharedArrayS和这里有关共享内存对象并没有对这个问题提供明确的指导.它看起来非常简单,但经过测试后,我有点困惑为什么这种方法效果很差(见下面的代码).对于初学者来说,似乎@parallel for分配了大量的内存.如果我在循环前加上@sync,如果以后需要整个输出向量,这似乎是一件很聪明的事情,那么并行循环要慢得多(尽管没有@sync,循环很快).

我是否错误地解释了SharedArray对象的正确使用？或者我可能无效地分配计算？

### test for speed gain w/ SharedArray vs. Array ###

# problem dimensions
n = 10000; p = 25000

# set BLAS threads; 64 seems reasonable in testing
blas_set_num_threads(64)

# make normal Arrays
x = randn(n,p)
y = ones(p)
z = zeros(n)

# make SharedArrays
X = convert(SharedArray{Float64,2}, x)  
Y = convert(SharedArray{Float64,1}, y)  
Z = convert(SharedArray{Float64,1}, z)  

# …

我有一些场景,我需要一次处理数千条记录.有时,它可能是数百,可能高达30000条记录.我在考虑使用scala的并行集合.所以只是为了理解差异,我写了一个简单的pgm,如下所示:

object Test extends App{
  val list = (1 to 100000).toList
  Util.seqMap(list)
  Util.parMap(list)
}

object Util{
  def seqMap(list:List[Int]) = {
    val start = System.currentTimeMillis
    list.map(x => x + 1).toList.sum
    val end = System.currentTimeMillis
    println("time taken =" + (end - start))
    end - start
  }
  def parMap(list:List[Int]) = {
    val start = System.currentTimeMillis
    list.par.map(x => x + 1).toList.sum
    val end = System.currentTimeMillis
    println("time taken=" + (end - start))
    end - start
  }
}

我预计并行运行会更快.但是,我得到的输出是

time taken =32
time taken=127

机器配置: …

我需要对存储在结构数组中的数据块进行排序.结构没有指针.每个块都有一个计数器编号和一个数组中等于结构块的数组的位置坐标.例如,如果我们有一个数据数组,我们可以划分为4个NxN块,我们在结构块的索引数组中有4个结构块,每个结构块在数据数组中有自己的数字和位置,借助我们可以计算使用索引块的数据数组中块的指针.应该使用比较器来进行排序,该比较器以这样的方式比较两个块,使得两个块中的至少两个具有最少的第i个数据.例如比较器:

for( i = 0; i < N * N; ++i )
{
    if( a[i] < b[i] ) return -1;
    if( a[i] > b[i] ) return 1;
}

where a和b是指向数据数组的指针,由于索引数组和数据数组开始的指针,我们可以得到它们.排序不应该排序数据数组而是排序索引数组.所以问题是:我可以使用哪种并行算法(除了框架,库,我需要完全算法或标准语言工具包,如pthread或qt libs,或c/c ++标准库)以避免同步错误？代码或伪代码也会有所帮助.

采样数据文件（SAM文件）中的记录：

M01383  0  chr4  66439384  255  31M  *  0  0  AAGAGGA GFAFHGD  MD:Z:31 NM:i:0
M01382  0  chr1  241995435  255 31M  *  0  0  ATCCAAG AFHTTAG  MD:Z:31 NM:i:0
......

• 数据文件是逐行的
• 数据文件的大小从1G​​-5G不等。

我需要逐行浏览数据文件中的记录，从每一行获取一个特定值（例如，第四值，66439384），然后将此值传递给另一个函数进行处理。然后将更新一些结果计数器。

基本的工作流程是这样的：

# global variable, counters will be updated in search function according to the value passed. 
counter_a = 0    
counter_b = 0
counter_c = 0

open textfile:
    for line in textfile:
        value = line.split()[3]
        search_function(value)    # this function takes abit long time to process

def search_function (value):
    some conditions …