标签: parallel-processing

一直在研究 Java 语言中的隐式和显式并发，经过大量研究后想澄清一些事情。

• Java 语言中的隐式并行性是否仅通过使用 Java 8 流来实现？
• 我是否认为 Java 中的显式并行性是通过使用程序员编写的线程来实现的。（区别在于隐式并行应该通过编译器而不是程序员编写的代码发生）？

谢谢

在运行 Linux 的共享内存系统上，假设它有 4 个 Intel Xeon-E5 CPU，每个 CPU 有 10 个内核。安装了 PBS Pro。例如qsub -l select=1:ncpu=30，如果用户想要在 30 个内核上运行，他们通常会运行软件程序。或者会setenv OMP_NUM_THREADS 30为其他软件做。

我的问题主要与基于 MPI 的商业软件包有关。暂时忽略 PBS 和 qsub，运行这些程序所做的只是在启动后从下拉菜单中选择要运行的内核数，或者在启动时从提示中./cfd.exe -np 30选择使用 30 个内核。

系统有 4 个物理插槽 = 4 个 CPU；每个 CPU 有 10 个内核 = 总共 40 个物理内核；每个内核都有超线程，因此cat /proc/cpuinfo将返回 80 个CPU或编号从 0 到 79 的内核。

Q1：我对超线程何时以及如何发生感到困惑，如果它在幕后自动发生，或者我是否必须以某种方式手动调用它来发生。

对于具有许多内核的系统，但为了简单起见，我将继续使用上述数字，现在当使用 PBS Pro 和 qsub 并且用户是否qsub -l select=1:ncpu=20分配了 10 个物理内核，例如 10..19，并且还分配了 10 …

这个问题的答案的底部（使用 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 …

我用一些用 JNI 包装的 C++ 代码为 android 编写了一个图像处理应用程序（https://play.google.com/store/apps/details?id=cv.cvExperiments）。为了在多核处理器上获得一些加速，我用 openmp “parallel for” 指令注释了昂贵的循环。

问题是在 x86 上，我在 4cores proc 上获得了从 x3 到 x5 的一些加速，但是在 Android 上，激活 OpenMP（使用 -fopenmp）在 ARM 32 位上没有任何加速，甚至在 64 位 armv8 上减慢代码骁龙810。

我错过了什么 ？有没有人可以观察到与 x86 cpu 相当的 android+arm 加速？

互联网上有很多关于如何激活 OpenMP 的教程，但没有显示加速的基准。任何指针？

我发现的唯一相关信息是 armv8 上 OpenMP 开销的基准测试，他们还注意到一些相当高的开销：https ://wiki.linaro.org/WorkingGroups/Middleware/Graphics/GPGPU/Docs/OpenMPforARMv8PortAnalysis

谢谢，马修

我正在尝试将我的一些 R 代码移植到 Julia；基本上我已经在 J​​ulia 中重写了以下 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 …

我正在使用parallelR中的库来处理我正在应用复杂操作的大型数据集.

为了提供可重现的代码,您可以在下面找到一个更简单的示例:

#data generation
dir <- "C:/Users/things_to_process/"

setwd(dir)
for(i in 1:800)
{
    my.matrix <- matrix(runif(100),ncol=10,nrow=10)

    saveRDS(my.matrix,file=paste0(dir,"/matrix",i))
}

#worker function
worker.function <- function(files)
{
    files.length <- length(files)
    partial.results <- vector('list',files.length)

    for(i in 1:files.length)
    {
        matrix <- readRDS(files[i])
        partial.results[[i]] <- sum(diag(matrix))
    }

    Reduce('+',partial.results) 
}


#master part
cl <- makeCluster(detectCores(), type = "PSOCK")

file_list <- list.files(path=dir,recursive=FALSE,full.names=TRUE)

part <- clusterSplit(cl,seq_along(file_list))
files.partitioned <- lapply(part,function(p) file_list[p])

results <- clusterApply(cl,files.partitioned,worker.function)

result <- Reduce('+',results)

本质上,我想知道是否尝试并行读取文件将以交错方式完成.结果,如果这个瓶颈会降低并行运行任务的预期性能？

如果我首先在列表中一次读取所有矩阵然后将此列表的块发送到每个核心以便进行处理,那会更好吗？如果这些矩阵更大,我能够立即将它们全部加载到列表中吗？

我正在阅读 Mark Harris 的关于优化 CUDA 中的并行缩减的演示文稿。这是一张我有问题的幻灯片：

它说这种方法存在银行冲突问题。但为什么？所有线程都在访问位于不同库中的两个连续内存单元。它们都不会同时访问特定的存储单元。

从MSDN， Volatile.Read()：

读取字段的值。在需要它的系统上，插入一个内存屏障，以防止处理器重新排序内存操作，如下所示：如果读取或写入出现在代码中此方法之后，则处理器无法将其移动到此方法之前。

和Volatile.Write()：

将值写入字段。在需要它的系统上，插入一个内存屏障，以防止处理器重新排序内存操作，如下所示：如果读取或写入出现在代码中的此方法之前，则处理器无法在此方法之后移动它。

我想我能理解Volatile.Read()and的使用场景Volatile.Write()，并且看到很多例子解释为什么这两种方法有助于确保程序的正确性。

但我还是想知道，这些规则背后的逻辑是什么？

以Volatile.Read()为例，为什么它要求操作后，它不能移动之前，但不需要来自任何操作之前呢？

还有为什么它与Volatile.Write()?

谢谢！

我想尝试 C++17 的并行 STL。但是，我在 libc++ 中找不到experimental/execution_policy。我怎样才能试试这个？

我正在尝试http://en.cppreference.com/w/cpp/experimental/reduce，它说我应该包含这些文件，但我找不到 execution_policy。

#include <experimental/execution_policy>

安装 libc++ 后（我遵循了http://libcxx.llvm.org/docs/BuildingLibcxx.html），我尝试了以下命令，但徒劳无功。

$ clang++-3.5 -std=c++1z test.cpp -lc++experimental
test.cpp:5:10: fatal error: 'experimental/execution_policy' file not found
#include <experimental/execution_policy>
         ^
1 error generated.

这还没有实施吗？

感觉需要学习如何使用asyncio，但想不出可以帮助我学习这项新技术的适用问题（或问题集）。

你能提出一个可以帮助我在实践中理解和学习 asyncio 用法的问题吗？

换句话说：你能给我推荐一些抽象问题或应用程序的例子，在编码时，这将帮助我学习如何在实践中使用 asyncio。

谢谢