我正在尝试使用C中的MPI转置矩阵.每个进程都有一个方形子矩阵,我想将它发送到正确的进程(网格上的"对面"),将其转换为通信的一部分.
我正在使用MPI_Type_create_subarray哪个有订单的参数,MPI_ORDER_C或者分别MPI_ORDER_FORTRAN用于行主要和列主要.我认为,如果我作为其中一个发送,并作为另一个接收,那么我的矩阵将被转换为通信的一部分.然而,这似乎并没有发生 - 它只是保持非转置.
下面是代码的重要部分,整个代码文件都可以在这个要点中找到.有没有人有任何想法为什么这不起作用？这种方法是否应该进行转置工作？我还以为它会,看过的描述MPI_ORDER_C和MPI_ORDER_FORTRAN,但也许不是.
/* ----------- DO TRANSPOSE ----------- */
/* Find the opposite co-ordinates (as we know it's a square) */
coords2[0] = coords[1];
coords2[1] = coords[0];
/* Get the rank for this process */
MPI_Cart_rank(cart_comm, coords2, &rank2);
/* Send to these new coordinates */
tag = (coords[0] + 1) * (coords[1] + 1);
/* Create new derived type to receive as */
/* MPI_Type_vector(rows_in_core, cols_in_core, …我有一个循环,我在某些点添加噪音; 这些后来被用作一些统计测试的基础.
涉及的数据集非常大,所以我想使用openMP将其并行化以加快速度.当我想拥有多个PRNG时,问题出现了.我有自己的PRNG类基于NR的模数方法(我认为是rand4),但我不确定如何正确播种PRNG以确保适当的熵
Normalliy我会做这样的事情
prng.initTimer();
但是如果我有一个prng数组,每个工作线程一个,那么我不能简单地在每个实例上调用initTimer - 定时器可能不会改变,并且定时器关闭可能会引入相关性.
我需要防止自然关联,而不是针对恶意攻击者(这是实验数据),所以我需要有一种安全的方式来播种rng数组.
我想过简单地使用
prng[0].initTimer()
for(int i=1; i<numRNGs; i++)
prng[i].init(prng[0].getRandNum());
然后调用我的循环,但不确定这是否会在模数方法中引入相关性.
编辑其他选项和下面稍微扩展的问题.
考虑一个类体的这个人为的抽象例子.它演示了执行"for"迭代的四种不同方法.
private abstract class SomeClass
{
public void someAction();
}
void Examples()
{
List<SomeClass> someList = new List<SomeClass>();
//A. for
for (int i = 0; i < someList.Count(); i++)
{
someList[i].someAction();
}
//B. foreach
foreach (SomeClass o in someList)
{
o.someAction();
}
//C. foreach extension
someList.ForEach(o => o.someAction());
//D. plinq
someList.AsParallel().ForAll(o => o.someAction());
编辑:从答案和研究中添加一些选项.
//E. ParallelEnumerable
ParallelEnumerable.Range(0, someList.Count - 1)
.ForAll(i => someList[i].someAction());
//F. ForEach Parallel Extension
Parallel.ForEach(someList, o => o.someAction());
//G. For Parallel Extension
Parallel.For(0, someList.Count …有人可以提供一些建议,说明如何通过多线程减少循环运行时的以下内容？假设我还有两个名为'a'和'b'的向量.
for (int j = 0; j < 8000; j++){
// Perform an operation and store in the vector 'a'
// Add 'a' to 'b' coefficient wise
}
这个for循环在我的程序中执行了很多次.上面for循环中的两个操作已经过优化,但它们只在一个核心上运行.但是,我有16个核心,并且想要使用它们.
我试过按如下方式修改循环.我没有向量'a',而是有16个向量,并假设第i个被称为a [i].我的for循环现在看起来像
for (int j = 0; j < 500; j++){
for (int i = 0; i < 16; i++){
// Perform an operation and store in the vector 'a[i]'
}
for (int i = 0; i < 16; i++){
// Add 'a[i]' to 'b' coefficient wise
}
}
我在每个for循环中使用OpenMp,在每个内循环之前添加'#pragma omp …
我有一个data.frame的单元格,值和坐标.它驻留在全球环境中.
> head(cont.values)
cell value x y
1 11117 NA -34 322
2 11118 NA -30 322
3 11119 NA -26 322
4 11120 NA -22 322
5 11121 NA -18 322
6 11122 NA -14 322
因为我的自定义函数花了将近一秒来计算单个单元格(我需要计算数万个单元格),我不想复制已经有值的单元格的计算.以下解决方案试图避免这种情况.每个单元格可以独立计算,尖叫为并行执行.
我的函数实际上做的是检查是否有指定单元格编号的值,如果它是NA,则计算它并将其插入代替NA.
我可以使用apply函数系列来运行我的魔术函数(结果是value相应的cell),从内部apply,我可以读写cont.values没有问题(它在全局环境中).
现在,我想并行运行(使用snowfall),我无法从单个核心读取或写入此变量.
问题:在并行执行函数时,从工作者(核心)内部驻留在全局环境中的动态变量可以读取/写入什么解决方案.这样做有更好的方法吗？
我有以下要求:
我可以将perl代码整合在一起,大致可以做到这一点,但我想要一个更优雅的解决方案.
我需要一些帮助来试图弄清楚我做错了什么.我正在尝试从单独的线程中获取系统日志中的项集合,以防止表单在收集过程中被冻结.我可以让后台工作者抓住它们,但我有一些问题将它们添加到ListBox表单上.
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
foreach (System.Diagnostics.EventLogEntry entry in eventLog1.Entries)
{
listBox1.Items.Add(
entry.EntryType.ToString() + " - " +
entry.TimeWritten + " - " +
entry.Source);
}
}
显然这不会按预期工作,因为有2个单独的线程,你不能像我发现的那样更改不同线程上的对象.所以,如果有人能指导我朝着正确的方向前进,我会感激不尽.
MapReduce抽象是否适用于处理即使在单个机器中的问题？例如,我有一个12核的机器,我必须计算数千个文件中的单词(经典的MapReduce示例).
考虑到我们正在使用单个硬盘驱动器的单台机器上工作,在多线程中使用Mapper和Reducers的MapReduce实现是解决此问题的好方法吗？
我想我的问题归结为:MapReduce范例仅适用于在一组机器中工作吗？
这个问题的答案的底部（使用 R 中的约束计算固定效应的 CI）建议人们应该看到user时间 >elapsed并行工作时的时间。尽管parallel = "multicore", ncpus = 4在运行时指定了boot.ci我没有看到那个结果。此外，我在 Mac 的活动监视器运行时只看到大约 30% 的 CPU 负载。这是否意味着我不能与我的 4 核 iMac 进行并行处理？如果没有，关于让它工作的任何建议？
下面是一个例子：
library(car)
library(boot)
set.seed(47)
y <- rgamma(2000, 2)
x1 <- 3 * y + rnorm(2000)
x2 <- y^2 + rnorm(2000)
x3 <- rnorm(2000)
MyData <- data.frame(c(y, x1, x2, x3))
MyModel <- lm(y ~ x1 + x2 + x3, data = MyData)
# Boot doesn't have a parallel option that I …我正在尝试将我的一些 R 代码移植到 Julia；基本上我已经在 Julia 中重写了以下 R 代码：
library(parallel)
eps_1<-rnorm(1000000)
eps_2<-rnorm(1000000)
large_matrix<-ifelse(cbind(eps_1,eps_2)>0,1,0)
matrix_to_compare = expand.grid(c(0,1),c(0,1))
indices<-seq(1,1000000,4)
large_matrix<-lapply(indices,function(i)(large_matrix[i:(i+3),]))
function_compare<-function(x){
which((rowSums(x==matrix_to_compare)==2) %in% TRUE)
}
> system.time(lapply(large_matrix,function_compare))
user system elapsed
38.812 0.024 38.828
> system.time(mclapply(large_matrix,function_compare,mc.cores=11))
user system elapsed
63.128 1.648 6.108
正如人们所注意到的，当从 1 个内核变为 11 个内核时，我获得了显着的加速。现在我正尝试在 Julia 中做同样的事情：
#Define cluster:
addprocs(11);
using Distributions;
@everywhere using Iterators;
d = Normal();
eps_1 = rand(d,1000000);
eps_2 = rand(d,1000000);
#Create a large matrix:
large_matrix = hcat(eps_1,eps_2).>=0;
indices = collect(1:4:1000000)
#Split large matrix:
large_matrix = [large_matrix[i:(i+3),:] for i …