标签: parallel-processing

该应用程序具有CPU密集型长进程,当客户端请求时,该进程当前在一个服务器(EJB方法)上串行运行.

理论上可以(从概念的角度)将该进程拆分为N个块并并行执行它们,只要可以收集并连接所有并行作业的输出,然后再将其发送回发起进程的客户端.我想使用这种并行化来优化性能.

如何使用EJB实现此并行化？我知道我们不应该在EJB方法中创建线程.相反,我们应该发布消息驱动bean(MDB)消息(每个作业一个).但那时它不再是同步通话了.在这种情况下,同步似乎是一个要求,因为我需要在将所有作业的输出发送回客户端之前收集它们的输出.

这有解决方案吗？

我对英特尔线程构建模块商业版与开源许可证感到困惑.开源版本在GPLv2下获得了运行时异常的许可,但是这用普通英语意味着什么呢？它是否可以用于商业的闭源应用程序,只要它只与未修改的.dll链接？

我有一个关于CUDA同步的问题.特别是,我需要对if语句中的同步进行一些澄清.我的意思是,如果我将__syncthreads()放在if语句的范围内,该块语句被块内的一小部分线程击中,会发生什么？我认为有些线程将"永远"等待其他不会达到同步点的线程.所以,我编写并执行了一些示例代码来检查:

__global__ void kernel(float* vett, int n)
{
    int index = blockIdx.x*blockDim.x + threadIdx.x;
    int gridSize = blockDim.x*gridDim.x;

    while( index < n )
    {   
        vett[index] = 2;
        if(threadIdx.x < 10)
        {
            vett[index] = 100;
            __syncthreads();
        }
        __syncthreads();

        index += gridSize;
    }
}

令人惊讶的是,我观察到输出非常"正常"(64个元素,块大小为32):

100 100 100 100 100 100 100 100 100 100 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
100 100 100 100 100 …

我使用多处理模块在Python中编写了简单的monte-carloπ计算程序.它工作正常,但是当我为每个工作者传递1E + 10次迭代时,会出现一些问题,结果是错误的.我无法理解问题是什么,因为1E + 9迭代的一切都很好!

import sys
from multiprocessing import Pool
from random import random


def calculate_pi(iters):
    """ Worker function """

    points = 0  # points inside circle

    for i in iters:
        x = random()
        y = random()

        if x ** 2 + y ** 2 <= 1:
            points += 1

    return points


if __name__ == "__main__":

    if len(sys.argv) != 3:
        print "Usage: python pi.py workers_number iterations_per_worker"
        exit()

    procs = int(sys.argv[1])
    iters = float(sys.argv[2])  # 1E+8 is cool …

我有一些非常简单的案例,可以将工作分解并分配给工人.我从这里尝试了一个非常简单的多处理示例:

import multiprocessing
import numpy as np
import time

def do_calculation(data):
    rand=np.random.randint(10)
    print data, rand
    time.sleep(rand)
    return data * 2

if __name__ == '__main__':
    pool_size = multiprocessing.cpu_count() * 2
    pool = multiprocessing.Pool(processes=pool_size)

    inputs = list(range(10))
    print 'Input   :', inputs

    pool_outputs = pool.map(do_calculation, inputs)
    print 'Pool    :', pool_outputs

上面的程序产生以下输出:

Input   : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
0 7
1 7
2 7
5 7
3 7
4 7
6 7
7 7
8 6 …

我是Go语言的新手,所以如果我的问题非常基本,请原谅.我写了一个非常简单的代码:

func main(){
    var count int // Default 0

    cptr := &count

    go incr(cptr)

    time.Sleep(100)

    fmt.Println(*cptr)
}

// Increments the value of count through pointer var
func incr(cptr *int) {
    for i := 0; i < 1000; i++ {
            go func() {
                    fmt.Println(*cptr)
                    *cptr = *cptr + 1
            }()
      }
    }

count的值应该增加一个循环运行的次数.考虑案例:

循环运行100次 - >计数值为100(循环运行100次时这是正确的).

循环运行> 510次 - >计数值为508或510.即使它是100000也会发生.

我在8核处理器机器上运行它.

我有一个用于解决快速傅里叶变换的haskell代码,我想在其上应用数据并行性.但是,我使用的每个策略都会产生太多的火花,而且大多数都会溢出.

有没有人知道如何在以下算法上应用良好的数据并行策略:

-- radix 2 Cooley-Tukey FFT

fft::[Complex Float] -> [Complex Float]
fft [a] = [a]
fft as = interleave ls rs
  where
    (cs,ds) = bflyS as
    ls = fft cs
    rs = fft ds

interleave [] bs = bs
interleave (a:as) bs = a : interleave bs as

bflyS :: [Complex Float] -> ([Complex Float], [Complex Float])
bflyS as = (los,rts)
  where
    (ls,rs) = halve as
    los = zipWith (+) ls rs
    ros = zipWith (-) ls rs
    rts …

请解释一下这两个课程有什么区别？

• concurrent.futures.ProcessPoolExecutor
• multiprocessing.pool.Pool

我注意到multiprocessingPython 2中存在模块但功能上呢？

我想分类很多东西.

Julia的标准库排序是单线程的.如何利用我的多核机器更快地对事物进行排序？

我在学习的过程中认识到这Parallelism是一个主要优势Spliterator.

这可能是一个基本的问题,但任何人都可以解释我的主要差异Iterator,并Spliterator和举一些例子？