标签: parallel-processing

我只是设置了一个特大型重型计算EC2实例,将其抛给我的遗传算法问题,希望加快速度.

这个实例有8个Intel Xeon处理器(每个大约2.4Ghz)和7 GAG RAM.

在我的机器上,我有一个英特尔酷睿双核处理器,并且matlab能够通过runinng使用我的两个核心:

matlabpool open 2

但是在EC2实例上,matlab只能检测到8个处理器中的1个,如果我尝试运行:

matlabpool open 8

我得到一个错误,说ClusterSize是1,因为我的CPU上只有1个核心.没错,每个CPU上只有1个核心,但我在给定的EC2实例上有8个CPU!

因此,与我的机器和ec2实例的不同之处在于,我在本地单个处理器上拥有2个内核,而EC2实例有8个不同的处理器.

我的问题是,如何让matlab与这8个处理器一起工作？

我找到了这篇论文,但似乎与使用多个EC2实例设置matlab(与同一个实例上的多个处理器无关,EC2与否),这不是我的问题.

任何帮助赞赏!

注意:关键点不是EC2,我正在远程操作并在其上运行matlab,就好像它是任何其他机器一样.关键是我无法让matlab看到8个处理器!

我使用parallel和doParallel包运行ubuntu 12.04和R 2.15.1.当我并行运行任何东西时,我限制在100%的核心,当我应该有高达800%,因为我运行8核心.系统监视器上显示的是每个子进程只获得12%.

是怎么回事限制了我的执行速度？

我正在做项目欧拉问题21的家庭作业,我有这个列表理解:

amicableNumberSums = [ x+y | x<-[1..10000], y <-[1..10000], (amicable x y)]

这需要很长时间才能执行(可以理解,因为它测试10000 ^ 2对数字)并查看我的cpu使用情况,它表明只使用了1个核心.

由于列表理解没有副作用,因此同时测试多对数字没有危险.有没有办法让Haskell自动执行此操作,或者如果不能如何修改我的代码来执行此操作？

(编辑)运行print时出错(usingamicableNumberSums parList):

Couldn't match type `a0 -> Eval a0' with `[Int]'
Expected type: Strategy [Int]
  Actual type: Strategy a0 -> Strategy [a0]
In the second argument of `using', namely `parList'
In the first argument of `print', namely
  `(amicableNumberSums `using` parList)'
In the expression: print (amicableNumberSums `using` parList)

(编辑)两种建议方法的表现:

Ørjan Johansen's method: 218.79s elapsed parallel (4 cores + 4 hyperthreading)
                         279.37s elapsed sequential …

我有一个很大的csv文件,阅读需要很长时间.我可以使用"并行"或相关的包在R中并行阅读吗？我尝试过使用mclapply,但它没有用.

我需要在一些工人上并行完成某项任务.为此,我需要所有工人都能访问存储数据的矩阵.

我认为数据矩阵可以实现为共享阵列,以最大限度地减少数据移动.

为了让我开始使用共享阵列,我正在尝试以下非常简单的示例,它给出了我认为的意外行为:

julia -p 2

# the data matrix
D = SharedArray(Float64, 2, 3)

# initialise the data matrix with dummy values
for ii=1:length(D)
   D[ii] = rand()
end

# Define some kind of dummy computation involving the shared array 
f = x -> x + sum(D)

# call function on worker
@time fetch(@spawnat 2 f(1.0))

最后一个命令给出了以下错误:

 ERROR: On worker 2:
 UndefVarError: D not defined
 in anonymous at none:1
 in anonymous at multi.jl:1358
 in anonymous at multi.jl:904
 in run_work_thunk at …

最近,我从" 多处理器编程的艺术 "第8章中读到了一些关于" 监视器和阻塞同步 "的例子,这些例子使用了signalAll()一个Condition对象,而没有获得与之相关的锁Condition.

令人惊讶的是,我没有在本书的勘误表中找到任何修复这些例子的方法.此外,他们建议对a的图8.12的例子进行修正FifoReadWriteLock,但他们继续使用signalAll()没有锁定的情况.这扰乱了我,我试图找到关于这些示例的其他注意事项,以了解这些Java示例以这种方式编写的原因.

例如,问题的答案 " 读写互斥锁如何工作？"显示了a的实现的相同示例FifoReadWriteLock,它实现了writeUnlock():

void writeUnlock() {
    writer = false;
    condition.signalAll();
}

关于没有锁定获取,您可以阅读两个不同的原因:

1. 仅将其用作伪代码
2. 条件变量的某些实现不要求锁定信号.

由于本书使用了Java中的示例并明确说明了以下内容,因此很难接受第一个参数:

本书使用Java编程语言.

关于第二点,我知道方法的java.util.concurrent.locks.Condition状态中的Java API signal():

当调用此方法时,实现可能(并且通常确实)要求当前线程保持与此关联的锁Condition.

如果仅" 实施可能 ",则意味着它不是强制性的.然而,据我所知,我发现任何不符合此要求的实施方案.所以我想知道哪些Java Condition实现不需要当前线程来保存锁？

在我的项目中,我有几个QuickCheck属性,其中大部分是我使用forAllProperties收集的,在Test.QuickCheck.All中定义.我试图并行运行我的所有属性,这很麻烦:在运行结束时,我得到了在终端中打印的输出,并且反例和属性名称经常被分散,以致难以将属性与其计数器匹配例子.

我看到库pqc的目的是并行运行属性,但它不提供forAllProperties的替代,也没有提供将forAllProperties与并行测试驱动程序组合的方法.

感觉就像我需要的是forAllProperties将属性名称传递给它作为参数获取的函数.

我还研究了在线程基础上重定向stdout,首先使用system-posix-redirect(这不是线程安全的),然后研究Test.QuickCheck.State,尤其是终端字段.后者没有成功,因为我没有找到重写终端字段的方法.

有没有办法让我以某种方式输出反例和属性名称,而无需复制/粘贴Test.QuickCheck.All模块并进行我需要的更改？

我使用类似于以下内容的东西来并行化两个矩阵的for循环

from joblib import Parallel, delayed
import numpy

def processInput(i,j):
    for k in range(len(i)):
        i[k] = 1
    for t in range(len(b)):
        j[t] = 0
return i,j

a = numpy.eye(3)
b = numpy.eye(3)

num_cores = 2
(a,b) = Parallel(n_jobs=num_cores)(delayed(processInput)(i,j) for i,j in zip(a,b))

但我收到以下错误:解压缩的值太多(预期2)

有没有办法返回延迟的2个值？或者你会提出什么解决方案？

另外,有点OP,是否有更紧凑的方式,如下(实际上没有修改任何东西)来处理矩阵？

from joblib import Parallel, delayed
def processInput(i,j):
    for k in i:
        k = 1
    for t in b:
        t = 0
return i,j

我想避免使用has_shareable_memory,以避免在实际脚本中出现可能的错误交互并降低性能(？)

当reduce()在并行流上使用该操作时,OCP考试书指出reduce()参数必须遵守某些原则.这些论点如下:

1. 必须定义标识,使得对于流u中的所有元素,combiner.apply(identity,u)等于u.
2. 累加器运算符op必须是关联的和无状态的,(a op b) op c等于a op (b op c).
3. 组合器运算符还必须是关联的和无状态的并且与标识兼容,以便对于所有u和t combiner.apply(u, accumulator.apply(identity, t))等于accumulator.apply(u,t).

考试书提供了两个例子来说明这些原则,请参阅下面的代码:

关联的示例:

System.out.println(Arrays,asList(1,2,3,4,5,6))
.parallelStream()
.reduce(0,(a,b) -> (a-b))); //NOT AN ASSOCIATIVE ACCUMULATOR

OCP书中对此有何说法:

它可能会输出-21,3或其他一些值,因为累加器函数违反了associativity属性.

身份要求的示例:

System.out.println(Arrays.asList("w","o","l","f"))
.parallelStream()
.reduce("X", String::concat));

OCP书中对此有何说法:

如果我们使用的身份参数不是真正的身份值,您可以看到其他问题.它可以输出XwXoXlXf.作为并行过程的一部分,标识将应用于流中的多个元素,从而导致非常意外的数据.

我不明白这些例子.使用累加器示例,累加器以0 -1 = -1然后-1 -2开始,其中= -3然后-6等等一直到-21.我明白,因为生成的arraylist不同步,结果可能是不可预测的,因为竞争条件等的可能性,但为什么累加器不关联？Woulden也不会(a+b)导致不可预测的结果？我真的没有看到示例中使用的累加器有什么问题,以及为什么它不是关联的,但是我仍然不能完全理解关联原则是什么.

我也不了解身份的例子.据我所知,如果4个独立的线程同时开始与身份一起累积,那么结果确实可能是XwXoXlXf,但这与身份参数本身有什么关系呢？究竟什么是适当的身份才能使用呢？

我想知道是否有人可以更多地了解这些原则.

谢谢

有没有办法让J使用多个核心？我认为APL/J的部分好处是语言结构很好地适用于并行解决方案.

看看我的CPU使用情况(我在OSX上),显然只有一个处理器在使用中.

我有一个重要的功能f作用于列表,我不明白为什么它不能将列表分成4个部分,并重新组合结果？