自重启 MathKernel - 在 Mathematica 中可能吗？

Question

这个问题来自最近的问题“正确的方法来限制 Mathematica em> 内存使用？”

我想知道，是否可以以编程方式重新启动 MathKernel，保持当前前端进程连接到新的 MathKernel 进程并在新的 MathKernel 会话中评估某些代码？我的意思是“透明”重新启动，它允许用户继续使用前端，同时拥有新的 MathKernel 进程，并在其中评估/评估之前内核中的一些代码？

这个问题的动机是有一种方法可以在 MathKernel 占用太多内存时自动重新启动，并且不会中断计算。换句话说，计算应该在新的 MathKernel 进程中自动继续，而无需与用户交互（但保留用户与 Mathematica 交互的能力，就像原来一样）。关于应在新内核中评估哪些代码的详细信息当然是针对每个计算任务的。我正在寻找如何自动继续计算的通用解决方案。

Answer 1

Stack Exchange Mathematica 聊天中的 评论，完全引用了：

昨天，Arnoud Buzing在 如果您有多个单元格，您可以将 Quit 单独放入一个单元格中并设置此选项：

SetOptions[$FrontEnd, "ClearEvaluationQueueOnKernelQuit" -> False]

然后，如果您在其上方和下方都有一个单元格并选择所有三个单元格并进行评估，则内核将退出，但前端评估队列将继续（并为最后一个单元重新启动内核）。

——阿努德·布津

Answer 2

以下方法运行一个内核以使用其自己的内核打开前端，然后关闭并重新打开前端，更新第二个内核。

该文件是 MathKernel 输入，C:\Temp\test4.m

Needs["JLink`"];
$FrontEndLaunchCommand="Mathematica.exe";
UseFrontEnd[
nb = NotebookOpen["C:\\Temp\\run.nb"];
SelectionMove[nb, Next, Cell];
SelectionEvaluate[nb];
];
Pause[8];
CloseFrontEnd[];
Pause[1];
UseFrontEnd[
nb = NotebookOpen["C:\\Temp\\run.nb"];
Do[SelectionMove[nb, Next, Cell],{12}];
SelectionEvaluate[nb];
];
Pause[8];
CloseFrontEnd[];
Print["Completed"]

演示笔记本，C:\Temp\run.nb 包含两个单元：

x1 = 0;
Module[{}, 
 While[x1 < 1000000, 
  If[Mod[x1, 100000] == 0, Print["x1=" <> ToString[x1]]]; x1++];
 NotebookSave[EvaluationNotebook[]];
 NotebookClose[EvaluationNotebook[]]]

Print[x1]
x1 = 0;
Module[{}, 
 While[x1 < 1000000, 
  If[Mod[x1, 100000] == 0, Print["x1=" <> ToString[x1]]]; x1++];
 NotebookSave[EvaluationNotebook[]];
 NotebookClose[EvaluationNotebook[]]]

初始内核打开前端并运行第一个单元，然后退出前端-end，重新打开它并运行第二个单元格。

整个过程可以通过将 MathKernel 输入粘贴（一次性）到内核会话中来运行，也可以从批处理文件运行，例如 C:\Temp\RunTest2.bat

@echo off
setlocal
PATH = C:\Program Files\Wolfram Research\Mathematica\8.0\;%PATH%
echo Launching MathKernel %TIME%
start MathKernel -noprompt -initfile "C:\Temp\test4.m"
ping localhost -n 30 > nul
echo Terminating MathKernel %TIME%
taskkill /F /FI "IMAGENAME eq MathKernel.exe" > nul
endlocal

设置起来有点复杂，并且在当前形式中，它取决于知道关闭并重新启动第二个内核之前需要等待多长时间。

Answer 3

也许并行计算机器可以用于此目的？这是一个说明这个想法的粗略设置：

Needs["SubKernels`LocalKernels`"]

doSomeWork[input_] := {$KernelID, Length[input], RandomReal[]}

getTheJobDone[] :=
  Module[{subkernel, initsub, resultSoFar = {}}
  , initsub[] :=
      ( subkernel = LaunchKernels[LocalMachine[1]]
      ; DistributeDefinitions["Global`"]
      )
  ; initsub[]
  ; While[Length[resultSoFar] < 1000
    , DistributeDefinitions[resultSoFar]
    ; Quiet[ParallelEvaluate[doSomeWork[resultSoFar], subkernel]] /.
        { $Failed :> (Print@"Ouch!"; initsub[])
        , r_ :> AppendTo[resultSoFar, r]
        }
    ]
  ; CloseKernels[subkernel]
  ; resultSoFar
  ]

这是一个过于复杂的设置，用于生成 1,000 个三元组数字的列表。 getTheJobDone 运行一个循环，该循环一直持续到结果列表包含所需数量的元素为止。循环的每次迭代都在子内核中进行评估。如果子内核评估失败，则重新启动子内核。否则，其返回值将添加到结果列表中。

要尝试此操作，请评估：

getTheJobDone[]

要演示恢复机制，请打开“并行内核状态”窗口并不时终止子内核。每当子内核终止时，getTheJobDone 就会感受到痛苦并打印 Ouch!。然而，整体工作仍在继续并返回最终结果。

这里的错误处理非常粗糙，可能需要在实际应用程序中得到支持。另外，我还没有调查子内核中真正严重的错误情况（例如内存不足）是否会对主内核产生不利影响。如果是这样，那么如果 MemoryInUse[] 超过预定阈值，子内核可能会自杀。

更新 - 将主内核与子内核崩溃隔离

在使用这个框架时，我发现如果子内核崩溃，主内核和子内核之间共享变量的任何使用都会导致 Mathematica 不稳定。这包括使用如上所示的 DistributeDefinitions[resultSoFar]，以及使用 SetSharedVariable 的显式共享变量。

为了解决这个问题，我通过文件传输了 resultSoFar。这消除了两个内核之间的同步，最终结果是主内核仍然幸福地没有意识到子内核崩溃。它还具有在主内核崩溃时保留中间结果的良好副作用。当然，这也会使子内核调用速度慢一些。但如果每次对子内核的调用都执行大量工作，那么这可能不是问题。

以下是修订后的定义：

Needs["SubKernels`LocalKernels`"]

doSomeWork[] := {$KernelID, Length[Get[$resultFile]], RandomReal[]}

$resultFile = "/some/place/results.dat";

getTheJobDone[] :=
  Module[{subkernel, initsub, resultSoFar = {}}
  , initsub[] :=
      ( subkernel = LaunchKernels[LocalMachine[1]]
      ; DistributeDefinitions["Global`"]
      )
  ; initsub[]
  ; While[Length[resultSoFar] < 1000
    , Put[resultSoFar, $resultFile]
    ; Quiet[ParallelEvaluate[doSomeWork[], subkernel]] /.
        { $Failed :> (Print@"Ouch!"; CloseKernels[subkernel]; initsub[])
        , r_ :> AppendTo[resultSoFar, r]
        }
    ]
  ; CloseKernels[subkernel]
  ; resultSoFar
  ]

Answer 4

当我运行 CUDAFunction 进行长循环并且 CUDALink 内存不足时，我有类似的要求（此处类似：https://mathematica.stackexchange.com/questions/31412/cudalink-ran-out-of-available-memory）。即使使用最新的 Mathematica 10.4 版本，内存泄漏也没有任何改善。我在这里找到了一个解决方法，希望您会发现它很有用。这个想法是，您使用 bash 脚本多次调用 Mathematica 程序（以批处理模式运行），并从 bash 脚本传递参数。以下是详细说明和演示（适用于 Window 操作系统）：

• 要在 Win_OS 中使用 bash 脚本，您需要安装 cygwin (https://cygwin.com/install.html）。
• 将您的 mathematica 笔记本转换为包 (.m)，以便能够在脚本模式下使用。如果您使用“另存为..”保存笔记本，所有命令都将转换为注释（Wolfram Research 注意到了这一点），因此最好创建一个包（文件 -> 新包），然后复制并将您的命令粘贴到其中。
• 使用 Vi 编辑器（而不是 Windows 的记事本或 gedit）编写 bash 脚本，以避免“\r”的问题 (http://www.linuxquestions.org/questions/programming-9/shell-scripts-in-windows-cygwin-607659/）。

这是 test.m 文件的演示

str=$CommandLine;
len=Length[str];
Do[
If[str[[i]]=="-start",
start=ToExpression[str[[i+1]]];
Pause[start];
Print["Done in ",start," second"];
];
,{i,2,len-1}];

该 mathematica 代码从命令行读取参数并使用它进行计算。
这是使用不同参数多次运行 test.m 的 bash 脚本 (script.sh)。

#c:\cygwin64\bin\bash
for ((i=2;i<10;i+=2))
do
math -script test.m -start $i
done

在 cygwin 终端中输入“chmod a+x script.sh”以启用脚本，然后您可以通过输入“./script.sh”来运行它。

Answer 5

您可以使用 Exit[] 以编程方式终止内核。当您下次尝试计算表达式时，前端（笔记本）将自动启动新内核。

保留“以前内核中的一些代码”将会更加困难。您必须决定要保留什么。如果您认为要保留所有内容，那么重新启动内核就没有意义。如果您知道要保存哪些定义，则可以在终止内核之前使用 DumpSave 将它们写入文件，然后使用 << 加载该文件进入新内核。

另一方面，如果您知道哪些定义占用了太多内存，则可以使用 Unset、Clear、ClearAll 或 Remove 以删除这些定义。如果您的内存所在，您还可以将 $HistoryLength 设置为小于 Infinity（默认值）的值。

Answer 6

听起来像是 CleanSlate 的工作。

<< Utilities`CleanSlate`;
CleanSlate[]

来自：http://library.wolfram.com/infocenter/TechNotes/4718/

“CleanSlate，尝试尽一切可能将内核返回到最初加载 CleanSlate.m 包时的状态。”