我用par和编写了一个简单的并行矩阵乘法pseq.
运行此程序后,没有任何火花转换(火花:20(0转换,0修剪)).
我想听听你关于改进这个计划的意见.
还有关于在Haskell中学习并行编程的方法.
import Data.List
import Control.Parallel
parHelp :: ( Num a ) => [ a ] -> [ a ] -> a
parHelp [] [] = 0
parHelp ( x : xs ) ( y : ys ) = ret where
ret = par a ( pseq b ( a + b ) ) where
a = x * y
b = parHelp xs ys
helpMult :: ( Num a ) => [ a …我有很多行,每行都计算出非线性函数的uniroot.我有一个四核Ubuntu机器,它已经两天没有停止运行我的代码了.毫不奇怪,我正在寻找加快速度的方法;-)
经过一些研究,我注意到目前只使用了一个核心,并且可以进行并行化.深入挖掘,我得出的结论(可能是错误的？)包装foreach并不是真正意义上的问题,因为产生了太多的开销(例如,参见SO).multicore对于Unix机器来说,一个很好的替代方案.特别是,在pvec检查帮助页面后,该功能似乎是最有效的功能.
但是,如果我理解正确,此函数只需要一个向量并相应地将其拆分.我需要一个可以并行化的函数,但需要多个向量(或者data.frame代替),就像mapply函数一样.我错过了什么吗？
这是我想要做的一个小例子:(请注意,我plyr在这里包含一个示例,因为它可以替代基本mapply函数,并且它有一个并行化选项.但是,它在我的实现和内部调用较慢,它调用foreach并行化,所以我认为它无济于事.这是正确的吗？)
library(plyr)
library(foreach)
n <- 10000
df <- data.frame(P = rnorm(n, mean=100, sd=10),
B0 = rnorm(n, mean=40, sd=5),
CF1 = rnorm(n, mean=30, sd=10),
CF2 = rnorm(n, mean=30, sd=5),
CF3 = rnorm(n, mean=90, sd=8))
get_uniroot <- function(P, B0, CF1, CF2, CF3) {
uniroot(function(x) {-P + B0 + CF1/x + CF2/x^2 + CF3/x^3},
lower = 1,
upper …我在我的python代码中有一个嵌套的for循环,看起来像这样:
results = []
for azimuth in azimuths:
for zenith in zeniths:
# Do various bits of stuff
# Eventually get a result
results.append(result)
我想在我的4核机器上并行化这个循环来加速它.看一下IPython并行编程文档(http://ipython.org/ipython-doc/dev/parallel/parallel_multiengine.html#quick-and-easy-parallelism),似乎有一种简单的方法可用于map并行化迭代操作.
但是,要做到这一点,我需要将循环中的代码作为一个函数(这很容易),然后映射到这个函数.我遇到的问题是我无法获得一个数组来映射这个函数.itertools.product()生成一个迭代器,我似乎无法使用map函数.
我试图在这里使用地图咆哮错误的树吗？有没有更好的方法呢？或者是否有某种方法可以使用itertools.product,然后使用映射在结果中的函数执行并行执行？
我想向接收带有特定标签的消息的一个等级发送消息.如果收到任何排名,则消息被消耗.在MPI_Recv()中,我们可以使用MPI_ANY_SOURCE/MPI_ANY_TAG接收消息,但MPI_Send()不能执行此操作.如何发送目的地未知的邮件？MPI_Bcast()无法做到,因为收到后,我必须回复源进程.谢谢.
在并行计算中需要解决哪些有趣的问题？我正在考虑众所周知的问题,这些问题不是太复杂,但在使用多个流程时会显示线性改进.有任何想法吗？
谢谢
嗨,我想在包中使用R ddply中的plyr库MC.它似乎没有加快计算速度.这是我运行的代码:
require(doMC)
registerDoMC(4)
getDoParWorkers()
##> 4
test <- data.frame(x=1:10000, y=rep(c(1:20), 500))
system.time(ddply(test, "y", mean))
# user system elapsed
# 0.015 0.000 0.015
system.time(ddply(test, "y", mean, .parallel=TRUE))
# user system elapsed
# 223.062 2.825 1.093
有任何想法吗？
我编写了一个Scala(2.9.1-1)应用程序,需要处理来自数据库查询的数百万行.我正在使用前面一个问题的答案中显示的技术转换ResultSet为a :Stream
class Record(...)
val resultSet = statement.executeQuery(...)
new Iterator[Record] {
def hasNext = resultSet.next()
def next = new Record(resultSet.getString(1), resultSet.getInt(2), ...)
}.toStream.foreach { record => ... }
这非常有效.
由于foreach闭包的主体非常占用CPU,并且作为函数式编程的实用性的证明,如果我在.par之前添加一个foreach,则闭包并行运行而不需要其他工作,除了确保闭合的主体是线程安全的(它是以函数样式编写的,除了打印到线程安全日志之外没有可变数据).
但是,我担心内存消耗.是.par导致整个结果集在RAM中加载,或做并联运行负荷只有尽可能多的行,因为它有活动线程？我已经将4G分配给了JVM(64位-Xmx4g)但是将来我会在更多的行上运行它,并担心我最终会得到一个内存不足.
是否有更好的模式以功能方式进行这种并行处理？我一直在向同事们展示这个应用程序,作为函数式编程和多核机器价值的一个例子.
我正在做一些像这样的分析:
library(plyr)
input.files <- c("file1.txt", "file2.txt", "file3.txt")
input.data <- llply(input.files, load.file, .parallel=TRUE)
step.one.results <- llply(input.data, step.one, .parallel=TRUE)
step.two.results <- llply(step.one.results, step.two, .parallel=TRUE)
...
step.N.results <- llply(`step.N-1.results`, step.N, .parallel=TRUE)
...
是否有任何方法可以使所有plyr函数默认并行,所以我不必总是.parallel=TRUE为每一步指定？
我正在尝试将我的C项目从顺序编程转换为并行编程.尽管为此目的,大多数代码现在已经从头开始重新设计,但随机数的生成仍然是其核心.因此,随机数发生器(RNG)的不良性能会严重影响程序的整体性能.
我写了一些代码行(见下文),以显示我面临的问题而没有太多冗长.
问题如下:每次线程数增加时,性能都会明显变差.在这个工作站(linux内核2.6.33.4; gcc 4.4.4; intel四核CPU)中,无论迭代次数n多少,并行for循环使用nt = 4比使用nt = 1大约长10倍.
这种情况似乎在这里有所描述,但焦点主要集中在fortran,这是一种我对此知之甚少的语言,所以我非常感谢一些帮助.
我试图按照他们的想法创建不同的RNG(使用不同的种子)来访问每个线程,但性能仍然很差.实际上,每个线程的这个不同的播种点也让我感到困惑,因为我无法看到最终如何保证生成的数字的质量(缺乏相关性等).
我已经考虑过完全放弃GSL并自己实现一个随机生成器算法(例如Mersenne-Twister),但我怀疑我稍后会遇到同样的问题.
非常感谢您提供的答案和建议.请问我可能忘记提及的任何重要事项.
编辑:由lucas1024(pragma for-loop声明)和JonathanDursi(播种;将"a"设置为私有变量)建议的更正.多线程模式下的性能仍然非常低迷.
编辑2:实施Jonathan Dursi建议的解决方案(见评论).
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <gsl/gsl_rng.h>
#include <omp.h>
double d_t (struct timespec t1, struct timespec t2){
return (t2.tv_sec-t1.tv_sec)+(double)(t2.tv_nsec-t1.tv_nsec)/1000000000.0;
}
int main (int argc, char *argv[]){
double a, b;
int i,j,k;
int n=atoi(argv[1]), seed=atoi(argv[2]), nt=atoi(argv[3]);
printf("\nn\t= %d", n);
printf("\nseed\t= %d", seed);
printf("\nnt\t= %d", nt);
struct timespec t1, t2, t3, t4;
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &t1);
//initialize gsl random …并行集合是否打算进行副作用操作？如果是这样,你怎么能避免竞争条件？例如:
var sum=0
(1 to 10000).foreach(n=>sum+=n); println(sum)
50005000
没问题.但如果尝试并行化,竞争条件就会发生:
var sum=0
(1 to 10000).par.foreach(n=>sum+=n);println(sum)
49980037