并行计算的计算监控问题

Question

形如ProgressIndicator和Monitor并不能显示Parallel系列的计算过程。

但是Parallel系列的函数都可以在分配内核之后分解成ParallelEvaluate[expr,{ker1,ker2,...}]的形式，能不能设计代码分别地监控各个并行核的进度来监控整个计算的进度？

 

ps:已有前提:需要计算的函数的计算量已经充分大到，无论如何分配计算到各个并行内核，均不足以在短时间内完成计算。

=================================================================

debug:

Clear["Global`*"]
CloseKernels[];
KernelNum = 2;
LaunchKernels[KernelNum];
Proc = ConstantArray[0., KernelNum];
SetSharedVariable[Proc];
fn := Cos[i];
eachKernel[id_] := Module[{}, Proc[[Mod[id, 2] + 1]] += 1;
  {Hue[(Arg[fn] + \[Pi])/(2 \[Pi]), 1/(1 + 0.3 Log[Abs[fn] + 1]), 
    1 - 1/(1.1 + 5 Log[Abs[fn] + 1]), 1], i}]
Column@Table[With[{m = m}, Dynamic[Proc[[m]]]], {m, 1, KernelNum}]
ParallelTable[eachKernel[i], {i, -20, 20, 0.1}]

报错：

Answer 1

Clear["Global`*"]
CloseKernels[];
KernelNum = 2;
LaunchKernels[KernelNum];
Proc = ConstantArray[0., KernelNum];
SetSharedVariable[Proc];
eachKernel[id_] := Module[{},
  Proc[[Mod[id, 2] + 1]] += 1;
  Sum[i,{i,1000000}]
  ]
Column@Table[With[{m = m}, Dynamic[Proc[[m]]]], {m, 1, KernelNum}]
ParallelTable[eachKernel[i], {i, 20}];

如果并行计算的东西属于0.00001秒然后计算次数100000次这类，那么会极大影响整体运行时间。

串行版本是：

f[id_] := Module[{}, Sum[i, {i, 1000000}]]
Table[f[i], {i, 20}]

 

Comments

那种主函数耗时那么短的应该考虑用矩阵求迹什么的吧。。不说这个，完全看不懂啊，啥原理啊到底，能不能加注释= =

---

能讲解下倒数第一行的目的是什么吗？Proc是定义一个和核心数量相等大小的表以作计数用，eachKernel是给每一个核心计数器增加计数，倒数第二是建立动态的计数器，然而倒数第一行究竟是为何？

---

并行运行程序呀.......

---

这个程序的串行版本是咋样的？我每次运行最后一行都会有很大几率得到不同的结果。

---

现在算是看明白了...最少 12 个字符

---

对于非整值和符号值报错...出错过程已附加

---

仔细看程序.程序中用id对每个proc进行进度+1，但是你的id设置成了浮点数，所以不存在proc的第1.1部分.

---

你还需要理解一下我的程序的思路.首先在主内核中申明一个进度变量，并共享到各子内核中，并在主内核中用dynamic实时更新该进度变量.随后，我们只需要在子内核的运算中，不断改变该共享变量即可.由于我是从其他地方复制粘贴再修改的程序，所以设置了proc是两个数，分别对应2个内核，用mod和part来确定修改哪个proc.你完全可以修改为proc只有一个数，所有子内核共同修改此数，因此不涉及到part.

Answer 2

(*不建议核函数计算较快(<0.1s)的使用本程序。感谢@苹果*)



RebootLaunchKernels[n___] := (
   CloseKernels[];
   LaunchKernels[n];);
bootParallelMonitor[n___] := (
   (*清除旧定义*)
   UnsetShared[$Proc];
   Clear[$Proc];
   (*判定是否需要重启内核*)
   If[$KernelCount < 2,
    RebootLaunchKernels[n],
    If[IntegerQ[n] \[And] (n =!= $KernelCount), 
     RebootLaunchKernels[n], Null],
    RebootLaunchKernels[n]];
   (*建立并行计算监视器*)
   $Proc = ConstantArray[0., $KernelCount + 1];
   SetSharedVariable[$Proc];
   Column@
    Table[With[{m = m}, Dynamic[$Proc[[m]]]], {m, 
      1, $KernelCount + 1}]);
$KernelMonitor[id_] := Module[{},(*分类累加器*)If[IntegerQ[id] \[And] (id > 1),
    $Proc[[Mod[id, $KernelCount] + 1]] += 1, Null];
   (*主累加器*)
   $Proc[[$KernelCount + 1 + 0*id]] += 1;
   (*被并行执行的核函数*)
   $Parallelfn];

运行示例：

bootParallelMonitor[]
fn := Cos[i];
$Parallelfn =
  Hue[(Arg[fn] + \[Pi])/(2 \[Pi]), 1/(1 + 0.3 Log[Abs[fn] + 1]), 
   1 - 1/(1.1 + 5 Log[Abs[fn] + 1]), 1];
ParallelTable[$KernelMonitor[i], {i, -20, 20 ,0.1}, Method -> "CoarsestGrained"]

测速：

$Parallelfn = Sum[i, {i, 1000000}];
getData[n_] := 
  AbsoluteTiming[
      Short[ParallelTable[#[i], {i, n}]]] & /@ {$KernelMonitor} // 
   Flatten;
getData1[n_] := 
  AbsoluteTiming[
      Short[ParallelTable[#[i], {i, n}]]] & /@ {$Parallelfn} // 
   Flatten;

TableForm[getData1 /@ {30, 50, 130, 200, 2000, 10000}, 
 TableHeadings -> {{"n=30", "n=50", "n=130", "n=200", "n=2000", 
    "n=10000"}, {"t2", "Parallel"}}]
TableForm[getData /@ {30, 50, 130, 200, 2000, 10000}, 
 TableHeadings -> {{"n=30", "n=50", "n=130", "n=200", "n=2000", 
    "n=10000"}, {"t1", "ParallelMonitor"}}]

结果是挺令人懵逼的。我正在考虑找另外的途径来实现这个目的，而不是用动态更新。。

 

Comments

这个和动态更新无关。凑12字符。