标签: parallel-processing

当串行执行随机森林时,它在我的系统上使用8GB的RAM,当并行执行它时,它使用超过两倍的RAM(18GB).如果并行执行此操作,如何将其保持在8GB？这是代码:

install.packages('foreach')
install.packages('doSMP')
install.packages('randomForest')

library('foreach')
library('doSMP')
library('randomForest')

NbrOfCores <- 8 
workers <- startWorkers(NbrOfCores) # number of cores
registerDoSMP(workers)
getDoParName() # check name of parallel backend
getDoParVersion() # check version of parallel backend
getDoParWorkers() # check number of workers


#creating data and setting options for random forests
#if your run this please adapt it so it won't crash your system! This amount of data  uses up to 18GB of RAM.
x <- matrix(runif(500000), 100000)
y <- gl(2, 50000)
#options
set.seed(1)
ntree=1000 …

我希望运行我的并行程序

$ myprogram <args> -n 4 <args>

代替

$ myprogram <args> +RTS -N4 -RTS <args>

主要原因是规范我的程序的参数格式.

我知道它可以做到

$ myprogramwrapper <args> -n 4 <args>
$ cat myprogramwrapper
#!/bin/bash
ARG1=parse args
ARG2=...
NCORES=....
myprogram $ARG1 ... +RTS -N$NCORES

但它很难看.

非常感谢!:)

我有一个句柄类:

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.)

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

我正在编写一个OpenCL内核,它在循环中涉及一些障碍.我已经在CPU(8核FX8150)上测试了内核,结果显示这些障碍将运行速度降低了50到100倍(我通过使用多线程+ CyclicBarrier在Java上重新实现内核进一步验证了这一点) .我怀疑原因是屏障基本上阻止了CPU利用无序执行,所以如果我在GPU上观察到相同幅度的速度降低,我有点担心.我检查了一些官方文档并搜索了一下,但是关于这个主题的信息很少.

我是关于matlab并行计算的新手.我有一个创建分类器(SVM)的函数,我想用几个数据集测试它.我有一个2核工作站,所以我想并行运行测试.有人可以解释我之间的区别:

 dataset_array={dataset1, dataset2}
 matlabpool open 2
 spmd
      my_function(dataset(labindex));
 end

和

 dataset_array={dataset1, dataset2}
 matlabpool open 2
 parfor i:1=2
      my_function(dataset(i));
 end

是否可以使用SSE4在一条指令中比较一对以上的数字？

英特尔参考咨询有关PCMPGTQ的内容如下

PCMPGTQ - 比较大于的打包数据

对目标操作数(第一个操作数)和源操作数(第二个操作数)中的压缩四字进行SIMD比较.如果第一个(目标)操作数中的数据元素大于第二个(源)操作数中的相应元素,则目标中的相应数据元素将设置为全1; 否则,它被设置为0.

这不是我想要的,因为我希望能够决定哪些整数更大,哪些整数更小.

例如,如果我需要比较

32 with 45
13 with 78
44 with 12
99 with 66

我打算在一个指令中放入[32, 13, 44, 99]一个向量和[45, 78, 12, 66]另一个向量并使用SSE4进行比较,[0, 0, 1, 1]结果为(0 - 更少,1 - 更大)

但似乎这不是PCMPGTQ所做的.有关如何在此级别使用并行性来加速此比较的任何建议？

我正在尝试使用MPI和opemMP一起制作并行版本的"Harmonic Progression Sum"问题.但输出是彼此不同的过程.

有人可以帮我完成这个问题吗？

并行程序:(MPI和OpenMP)

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>
#include <time.h>
#include <omp.h>
#include <mpi.h>

#define d 10    //Numbers of Digits (Example: 5 => 0,xxxxx)
#define n 1000  //Value of N (Example: 5 => 1/1 + 1/2 + 1/3 + 1/4 + 1/5)

using namespace std;

double t_ini, t_fim, t_tot;

int getProcessId(){
    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    return rank;
}

int numberProcess(){
    int numProc;
    MPI_Comm_size(MPI_COMM_WORLD, &numProc);
    return numProc;
}

void reduce(long unsigned int digits1 [])
{ …

在尝试在Haskell程序中添加多线程功能后,我注意到性能根本没有改善.追逐它,我从threadscope获得了以下数据:

绿色表示正在运行,橙色表示垃圾收集. 这里垂直的绿色条表示火花创建,蓝色条表示并行GC请求,浅蓝色条表示创建线程. 标签是:创建spark,请求并行GC,创建线程n,以及从第2章窃取火花.

平均而言,我只能在4个内核上获得大约25%的活动,这与单线程程序相比没有任何改进.

当然,如果没有实际程序的描述,这个问题就会无效.本质上,我创建了一个可遍历的数据结构(例如树),然后在它上面映射一个函数,然后将其提供给一个图像编写例程(在程序运行结束时解释明确的单线程段,超过15秒) .函数的构造和fmapping都需要花费大量的时间来运行,尽管第二个稍微多一点.

上图是通过在图像写入消耗之前为该数据结构添加parTraversable策略来完成的.我也尝试在数据结构上使用toList,然后使用各种并行列表策略(parList,parListChunk,parBuffer),但每次对于各种参数(甚至使用大块)的结果都相似.
我还试图在将函数映射到它之前完全评估可遍历的数据结构,但是出现了完全相同的问题.

以下是一些其他统计信息(针对同一程序的不同运行):

   5,702,829,756 bytes allocated in the heap
     385,998,024 bytes copied during GC
      55,819,120 bytes maximum residency (8 sample(s))
       1,392,044 bytes maximum slop
             133 MB total memory in use (0 MB lost due to fragmentation)

                                    Tot time (elapsed)  Avg pause  Max pause 
  Gen  0     10379 colls, 10378 par    5.20s    1.40s     0.0001s    0.0327s
  Gen  1         8 colls,     8 par    1.01s    0.25s     0.0319s    0.0509s

  Parallel GC work balance: 1.24 (96361163 / 77659897, ideal 4) …

是否可以在与R并行的单个多核机器上迭代单个文本文件？对于上下文,文本文件介于250-400MB的JSON输出之间.

编辑:

以下是我一直在玩的一些代码示例.令我惊讶的是,并行处理没有赢 - 只是基本的lapply - 但这可能是由于我的用户错误.另外,当试图读取一些大文件时,我的机器窒息了.

## test on first 100 rows of 1 twitter file
library(rjson)
library(parallel)
library(foreach)
library(plyr)
N = 100
library(rbenchmark)
mc.cores <- detectCores()
benchmark(lapply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          llply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          mclapply(readLines(FILE, n=N, warn=FALSE), fromJSON),
          mclapply(readLines(FILE, n=N, warn=FALSE), fromJSON, 
                   mc.cores=mc.cores),
          foreach(x=readLines(FILE, n=N, warn=FALSE)) %do% fromJSON(x),
          replications=100)

这是第二个代码示例

parseData <- function(x) {
  x <- tryCatch(fromJSON(x), 
                error=function(e) return(list())
                )
  ## need to do a test to see if valid data, if so ,save out the files
  if …