标签: parallel-processing

我试图找出MPI通信器中实际进程通信是如何发生的.我有8个节点,每个节点有12个核心(96个实例正在运行).每个进程都分配了唯一的级别,并且进程之间能够相互通信.那么流程如何获得独特的排名并管理发送实际的消息？根据一些幻灯片,有一个开放运行时环境(ORTE),它"驻留在该单​​元上启动进程的机器上.(例如,集群的前端).负责在单元上启动进程.监视单元健康状况(节点,进程).将单元状态报告给Universe的其余部分.在单元之间路由通信." 我还没有找到任何MPI实现的开发者文档和/或体系结构文章.任何人都有想法如何实现MPI流程之间的实际沟通,即他们如何设法找到自己并获得指定的排名？是否有中央或多个中央MPI内部流程进行路由(例如,每个节点)？

谢谢,大卫

我在一个ruby脚本中有4个测试,我使用命令运行

ruby test.rb

外观看起来像

Loaded suite test
Started
....

Finished in 50.326546 seconds.

4 tests, 5 assertions, 0 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
100% passed

我想要实现的是,并行运行所有4个测试而不是顺序测试.像4个线程一样运行一个测试,有效地将执行时间减少到4个测试中最慢的时间+并行执行的时间很少.

我遇到了这个,但这似乎并行运行多个ruby测试文件 - 比如说我有test1.rb,test2.rb test3.rb,然后所有这三个文件将并行运行.

任何帮助将不胜感激.

问题:鉴于詹金斯/哈德森的一些工作,每个工作都分配了一个我们可以调用的数字.此数字的范围从1到n,多个作业可以具有相同的级别.现在,我想定义那些(否则是独立的)作业运行,使得级别1必须在级别2之前构建,并且我希望Jenkins/Hudson并行启动多个作业,如果作业的从属执行者定义是免费的.

这个级别的数字并不重要,它只是用于解释问题.

重要提示:我希望能够自动生成这些作业,因为我知道哪些作业取决于哪些作业,哪些作业可以并行运行,所以如果解决方案是config.xml中的某些配置,那么听到这个就很好了,这样我就可以自动生成那些配置文件的脚本.

谢谢你的时间.

编辑:还有一个我想知道的,如果有一些优雅的解决方案:假设作业X由Build Flow Plugin触发,它就失败了.如果我希望Build Flow Plugin再次触发相同的作业(在我修复它之后),并且正常继续通过插件定义的作业,有什么办法吗？

我开始使用PETSc库来并行求解线性方程组.我已经安装了所有软件包,构建并成功运行了petsc/src/ksp/ksp/examples/tutorials /文件夹中的示例,例如ex.c

但我无法理解如何通过从文件中读取矩阵来填充矩阵A,X和B.

这里我提供了ex2.c文件中的代码:

/* Program usage:  mpiexec -n <procs> ex2 [-help] [all PETSc options] */ 

static char help[] = "Solves a linear system in parallel with KSP.\n\
Input parameters include:\n\
  -random_exact_sol : use a random exact solution vector\n\
  -view_exact_sol   : write exact solution vector to stdout\n\
  -m <mesh_x>       : number of mesh points in x-direction\n\
  -n <mesh_n>       : number of mesh points in y-direction\n\n";

/*T
   Concepts: KSP^basic parallel example;
   Concepts: KSP^Laplacian, 2d
   Concepts: Laplacian, 2d
   Processors: n
T*/

/* …

为什么

 List.range(0,100).contains(2)

工作,而

 List.range(0,100).par.contains(2)

才不是？

这计划在未来？

如果我使用共享变量,让我们说一个double,来计算程序执行时的某种总和.无论如何,这是否容易受到非稳定运营的影响？我的意思是,多个核心是否有可能以异步方式访问此变量并导致不稳定的结果？

例如:这是一个全局变量:

double totalTime = 0;

并在每个核心中调用一个命令:

totalTime += elapsedTime;

最后一个操作/语句是通过获取totalTime的值,将其作为CPU寄存器,然后执行添加来执行的.我可以想象,不止一个核心会在同一时刻获取相同的值,然后添加新的elapsedTime,然后由于延迟,存储在totalTime中的值将被错误的值覆盖.那可能吗？我该如何解决这个问题？

谢谢.

我multiprocessing正在使用模块,我正在使用UpdateMessage对象(我自己的类),通过multiprocessing.Queue对象发送,在进程之间进行通信.这是类:

class UpdateMessage:
    def __init__(self, arrayref, rowslice, colslice, newval):
        self.arrayref = arrayref
        self.rowslice = rowslice
        self.colslice = colslice
        self.newval = newval
    def do_update(self):
        if self.arrayref == 'uL':
            arr = uL
        elif self.arrayref == 'uR':
            arr = uR
        else:
            raise Exception('UpdateMessage.arrayref neither uL nor uR')
        arr[self.rowslice, self.colslice] = self.newval

当我运行脚本时,它完全正常.但是,当我使用cProfile或运行它时profile,它会出现以下错误:

_pickle.PicklingError: Can't pickle <class '__main__.UpdateMessage'>: attribute lookup __main__.UpdateMessage failed

它似乎试图挑选课程,但我不明白为什么会发生这种情况.我的代码没有这样做,没有它就可以正常工作,所以它可能就是multiprocessing模块.但为什么需要腌制UpdateMessage,我该如何修复错误呢？

编辑:这是发送的代码的一部分UpdateMessage(脚本的多个部分执行此操作,但所有都以相同的方式):

msg = UpdateMessage(uLref, refer[0] …

C#和Scala都采用了框架来简化异步/并行计算,但方式不同.最新的C#(5.0,仍然处于测试阶段)已决定使用async/await框架(使用延续传递,但使用方式更简单),而Scala则使用"actors"的概念,最近在Akka中采用了演员实现并将其合并到基础库中.

这是一个需要考虑的任务:我们收到一系列请求来执行各种操作 - 例如,从用户输入,到服务器的请求等.某些操作很快,但有些操作需要一段时间.对于慢速的,我们想异步地执行操作(在另一个线程中)并在线程完成时处理它,同时仍然可以自由地处理新请求.

一个简单的同步循环可能是(伪代码):

while (1) {
  val request = waitForAnything(user_request, server_request)
  val result = do_request(request)
  if (result needs to be sent back)
    send_back_result(result)
}

在基本的fork/join框架中,您可能会执行以下操作(伪代码):

val threads: Set[Thread]

while (1) {
  val request = waitForAnything(user_request, server_request, termination of thread)
  if (request is thread_terminate) {
    threads.delete(request.terminated_thread)
    val result = request.thread_result
    if (result needs to be sent back)
      send_back_result(result)
  } else if (request is slow) {
    val thread = new Thread(() => do_request(request))
    Threads.add(thread)
    thread.start()
  } else {
    val result …

我有一个句柄类:

classdef A<handle


    properties
        a;
    end

    methods
        function obj = A(a)
            obj.a=a;
        end
    end
end

我有一个A对象的单元格数组:

arr={};
for i=1:3
    arr{i}=A(i);
end

我想做的是将该单元格数组传递给parfor循环,以便每个对象的值都会改变:

parfor i=1:3
    arr{i}.a=i*5;
end

但是,此代码根本不会更改arr.的确,这里说明了这一点

在循环迭代期间对worker处理类所做的更改不会自动传播到客户端.

我怎么能克服这个？

我目前正在调查计算机科学研究生课程的主题,我发现了一个相对较大的兴趣领域,分布式计算,我想获得更多信息.还有其他问题[屈指可数1,2,3 StackOverflow上]涉及类似问题,但不一定是我要问的问题,特别是涉及到我正在寻找的语言.

我在网上搜索过,发现了很多论文,文章,甚至是罗格斯的这门课程,描述了分布式计算背后的理论和机制.不幸的是,我发现的大多数论文和课程在描述代码中的分布式计算的实际概念方面相当有限.我正在寻找可以向我介绍分布式计算的编程部分的网站.(最好是C或Python.)

作为旁注,我想提一下,这甚至可能更具体地说明并行计算如何适应分布式计算领域.(我还没有上过课程!)