我有一个由OpenMP并行化的循环,但由于任务的性质,有4个critical子句.
什么是最好的方式来分析加速,找出哪些关键条款(或可能非关键(!))占用循环内的最多时间？
我使用Ubuntu 10.04和g ++ 4.4.3
就像标题所说的那样.我有一段代码如下:
pid_t = p;
p = fork();
if (p == 0) {
childfn();
} else if (p > 0) {
parentfn();
} else {
// error
}
我想确保父或子在另一个之前执行(但不返回)各自的功能.
像sleep()这样的调用可能会起作用,但是不能通过任何标准来保证,并且只是利用操作系统调度程序的实现细节......这可能吗？vfork会工作吗？
编辑:两个函数都找到了一个system()调用,其中一个函数在另一个函数启动之前不会返回.所以要重新迭代:我需要确保父或子只调用它们各自的函数(但不返回,因为它们不会,这是下面提供的所有基于互斥锁的解决方案提供的).有任何想法吗？抱歉缺乏清晰度.
edit2:有一个进程调用sched_yield和sleep,我似乎得到了非常可靠的结果.vfork确实提供了我正在寻找的语义,但是对于我在子进程中可以做的事情有很多限制(我几乎只能调用exec).所以,我发现了一些足够好的解决方案,但没有真正的解决方案.vfork可能是我所寻找的最接近的东西,但下面提出的所有解决方案都会或多或少地起作用.
我正在重构前一段时间编写的代码,当linq和delegates不存在时,很多代码都是令人尴尬的并行化,所以AsParallel我随时都可以使用但是我不太确定当涉及到有序列表时会发生什么在这样的查询中.例如,
/* suppose we have the following list
SortedList<DateTime, SomeClass> list1
*/
var projection = list1.AsParallel().Select(t => t.Key);
var skippedProjection = list1.AsParallel().Select(t => t.Key).Skip(1);
var zipped = projection.AsParallel().Zip(skippedProjection, someComputation);
我的问题如下:并行查询中是否保留了排序？换句话说,上面的示例是否会按照我的预期工作,或者Select后续查询会AsParallel以随机顺序返回事物,具体取决于幕后使用的策略？
我最近偶然发现了一篇关于Pollard的Rho算法并行化的论文,并且根据我的具体应用,除了我没有达到所需的数学水平之外,我想知道这种特殊的并行化方法是否有助于我的特定情况.
我试图找到两个因素 - 半数 - 一个非常大的数字.基于我对本文的理解很少,我的假设是,这种并行化在具有许多较小因子的数字上运行良好,而不是在两个非常大的因素上.
这是真的？我应该使用此并行化还是使用其他东西？我是否应该使用Pollard的Rho,还是更好地并行化不同的分解算法？
假设我有一个N个元素的向量(数组,列表,等等......)V,假设V 0到V (N-1).对于每个元素V i,需要针对每个索引j计算函数f(V i,V j)(包括情况i = j).该函数是对称的,因此一旦计算出f(V i,V j),就不需要重新计算f(V j,V i).然后我们对函数进行N(N + 1)/ 2次总评估,使其成为O(N 2)算法.让我们假设计算f所花费的时间相对较长但是一致.
现在,我想并行执行算法.我需要确定(某些M个)工作线程的调度,以便两个线程不会同时使用相同的内存部分(即相同的元素).例如,f(V 1,V 2)可以与f(V 3,V 4)平行评估,但不与f(V 2,V 3)平行.工作流程分为几个步骤,每个步骤,每个工作线程执行一次f的评估.然后线程被同步,之后它们继续进行下一步,依此类推.
问题是,我如何确定(最好是最佳)每个线程的时间表作为一系列索引对(i,j),以便解决完整的问题(即考虑到对称性,每个索引对只访问一次)？虽然直接答案当然是好的,但我也很欣赏指向算法甚至相关网站/文献的指针.
我试图通过重复平方对具有非常大模数的整数进行模幂运算(在我的情况下,功率总是2的幂,所以我相信这是最有效的方法).由于我的模数很好的属性,计算余数很便宜; 困难的部分是乘法.
目前我在Intel Core 2 Quad上运行GMP.我想有效地使用处理器的四个核心,但GMP不能在SMP环境中扩展,所以我正在寻找替代的任意精度算术库.我找到了一些用于矩阵并行计算的库,但我真正需要的是一个整数库.
我正在寻找的是什么？
我正在使用doSMP包中的嵌套foreach来根据我开发的函数生成结果.通常问题是使用三个嵌套循环,但是由于生成结果的大小(每个i大约80,000),当最终结果矩阵超过指定行数时,我不得不暂停编译并将结果写入文件.
i = 1
write.off = 1
while(i <= length(i.vector)){
results.frame = as.data.frame(matrix(NA, ncol = 3, nrow = 1))
while(nrow(results.frame) < 500000 & i <= length(i.vector)){
results = foreach(j = 1:length(j.vector), .combine = "rbind", .inorder = TRUE) %:%
foreach(k = 1:length(k.vector), .combine = "rbind", .inorder = TRUE) %dopar%{
ith.value = i.vector[i]
jth.value = j.vector[j]
kth.value = k.vector[k]
my.function(ith.value, jth.value, kth.value)
}
results.frame = rbind(results.frame, results)
i = i + 1
}
results.frame = results.frame[-1,]
write.table(results.frame, paste("part_",write.off, sep = ""))
write.off …在并行计算中需要解决哪些有趣的问题？我正在考虑众所周知的问题,这些问题不是太复杂,但在使用多个流程时会显示线性改进.有任何想法吗？
谢谢
嗨,我想在包中使用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)但是将来我会在更多的行上运行它,并担心我最终会得到一个内存不足.
是否有更好的模式以功能方式进行这种并行处理？我一直在向同事们展示这个应用程序,作为函数式编程和多核机器价值的一个例子.