Parallel processing 为什么pmap比map慢？

我试图通过以下代码使用pmap并行求解各种方程组：

#A function that returns an invertible matrix.
function invertible_matrix(n)
  A=zeros(n,n)
  while true
    A=rand(-10:10,n,n)#ones(Float64,n,n)
    try
      Ai=inv(A)
      break
    end
  end
  return A
end
################################################################################
parallel=true#; parallel=false
N=100 # The number of systems of equations that need to be solved.
n=1000# The number of variables and equations.
A=invertible_matrix(n)

A=[A for i in 1:N]#We transform A into a list of copies of the matrix A
# We generate the solutions of the systems before hand.
x0=[[float(i) for j in 1:n] for i in 1:N]

# We generate the right hand sides of the systems.
b=[ A[i]*x0[i] for i in 1:N]

#We solve all systems either in parallel or in series.
if parallel
  x=pmap(\,A,b)
else
  x=map(\,A,b)
end

s=sum(x)[1]
#This should print 5050.
println(s)

这将解决100个方程组和1000个并行变量。如果我使用htop监控内核的使用情况，我可以验证运行

$julia-p8 test.jl

确实使用了我的所有处理器，但是这比只使用一个内核和

$julia test.jl

要花更多的时间！这是我的考验

$ time julia test.jl 
5049.999977945663

real    0m27.934s
user    0m28.268s
sys 0m1.776s
$ time julia -p 8 test.jl 
5050.000001198174

real    0m39.169s
user    4m22.088s
sys 0m3.308s

如果我通过设置

parallel=false来使用map而不是pmap，我会得到同样更快的结果：

$ time julia test.jl 5049.999999852108

real    0m26.691s
user    0m27.140s
sys 0m1.612s
$ time julia -p     8 test.jl 
5050.000000001826

real    0m32.142s
user    0m49.284s
sys 0m2.064s

为什么会这样？
我不认为这和你认为的一样。我相信它会在每个核心上解决相同的线性系统。还有，你应该在朱莉娅体内计时，而不是在全局范围内。它是用来求解由同一个矩阵
A
给出的方程组，但不同的右侧
b
，因此相应的
x
是向量，其所有元素对于每个解出的系统都等于1到100之间的数字。就像@DavidP.Sanders说的，在Julia中进行计时，例如，使用
@time
宏。否则，您也在测量初始化所有工作程序的时间，根据我的经验，这并不小。啊，我明白了，对不起，我没有仔细阅读代码试图执行的操作。如果这是实际目标（使用大量右手边求解），那么您可能应该使用LU分解或类似方法。对于大型矩阵，进程之间的通信可能代价高昂，如果矩阵在节点上生成，并行的速度优势可能会更大。请注意，对于单进程情况，使用了相同的
A
，因此享有不公平的内存位置优势。我认为这并不像您认为的那样。我相信它会在每个核心上解决相同的线性系统。还有，你应该在朱莉娅体内计时，而不是在全局范围内。它是用来求解由同一个矩阵
A
给出的方程组，但不同的右侧
b
，因此相应的
x
是向量，其所有元素对于每个解出的系统都等于1到100之间的数字。就像@DavidP.Sanders说的，在Julia中进行计时，例如，使用
@time
宏。否则，您也在测量初始化所有工作程序的时间，根据我的经验，这并不小。啊，我明白了，对不起，我没有仔细阅读代码试图执行的操作。如果这是实际目标（使用大量右手边求解），那么您可能应该使用LU分解或类似方法。对于大型矩阵，进程之间的通信可能代价高昂，如果矩阵在节点上生成，并行的速度优势可能会更大。注意，对于单个进程情况，使用相同的
A
，因此享有不公平的内存位置优势。