Асинхронная оценка в Mathematica

Question

Иногда, когда я пишу экспериментальный код в Mathematica, я опасаюсь, стоит ли мне его оценивать или нет, потому что это может в конечном итоге поставить мою систему на колени.

В качестве надуманного примера, если вы попытаетесь запустить следующий фрагмент кода на 64-разрядной машине, это, скорее всего, приведет к полной остановке системы после того, как она израсходует всю вашу память.

junk = Table[{x, x}, {10^9}]; (* nom nom nom memory. Please don't run this. *)

Конечно, вы можете просто добавить MemoryConstrained и надеяться на лучшее, но иногда вы не хотите, чтобы это блокировало дальнейший ввод. В связи с этим я подумал, что для достижения среднего уровня лучше всего было бы выполнить оценку в отдельном ядре.

Это было достаточно легко сделать:

ClearAll[GetAvailableKernel];
GetAvailableKernel[] := Block[{i, kernels},
  kernels = Kernels[];
  If[Length@kernels !=  0,
   For[i = 1, i <= Length@kernels, i++,
    If[kernels[[i, 1, 2]] > 0, Return@kernels[[i]]]
    ]
   ];
  LaunchKernels[1]]

ClearAll[SafeEvaluate];
SetAttributes[SafeEvaluate, HoldFirst];
Options[SafeEvaluate] = {"EvaluationKernel" -> Null, 
   "ConstrainMemory" -> True, "MaxMemory" -> 2 1024^3};

SafeEvaluate[expr_, OptionsPattern[]] := Block[{evalkernel, result},
  If[OptionValue["EvaluationKernel"] != Null,
   evalkernel = OptionValue["EvaluationKernel"],
   evalkernel = GetAvailableKernel[]
   ];

  result  = If[OptionValue["ConstrainMemory"],
    With[{memory = OptionValue["MaxMemory"]},
     ParallelEvaluate[MemoryConstrained[expr, memory], evalkernel]],
    ParallelEvaluate[expr, evalkernel]];
  result]

Тогда вы можете просто пойти дальше и сделать что-то вроде:

SafeEvaluate[Table[{x, x}, {1024^3}]]

И Математика грациозно вернет $Aborted, сообщая вам, что у него кончилась память. Оценивая в отдельном ядре, мы можем поместить код в песочницу в его собственное параллельное ядро Если что-то пойдет не так, наше основное ядро ​​не будет затронуто.

---

Это подводит меня к моей главной мысли: Как мне достичь асинхронной оценки в Mathematica?

То, что у меня есть сейчас, работает, но оно полностью блокирует дальнейший ввод пользователя. Я не могу просто установить, забыть и проверить позже.

Есть мысли?

Answer 1

У меня почти нулевой опыт параллельных вычислений в Mathematica, так что это может быть не лучшим способом, но это то, что мне удалось выкопать из документов :

Запускядро:

In[1]:= LaunchKernels[1]

Out[1]= KernelObject[1, "local"]

Отправить долгое, чтобы закончить работу:

In[2]:= job = 
 ParallelSubmit[First@SingularValueList[RandomReal[1, {2000, 2000}]]]

Начать работу:

In[3]:= Parallel`Developer`QueueRun[]

Out[3]= True

Сейчасзадание выполняется параллельно в фоновом режиме ...

... и мы можем делать все, что захотим, в основном ядре.Если я понимаю ваш вопрос, это то, что вам нужно.Мы можем запустить Parallel`Developer`QueueRun[] еще раз, чтобы проверить, какие параллельные оценки завершились (отображение объекта оценки будет динамически обновляться).

In[4]:= 1 + 1

Out[4]= 2

Дождаться окончания оценки (если оно еще не выполнено) и собратьрезультат:

In[5]:= WaitAll[job]

Out[5]= 1000.23

Answer 2

Довольно часто случается так, что вашей системе не хватает памяти и она начинает меняться. И обмен заставит систему умереть медленной смертью. На Linux вот что я делаю

alias m804='ulimit -v 3800000; /usr/local/bin/math8.0.4/mathematica'

Затем система просто выдает сообщение о нехватке памяти и завершает работу, прежде чем перейти к обмену. В противном случае ведет себя как обычно.

Answer 3

Это было очень давно, когда я использовал Mathematica, но у меня была идея. Насколько я знаю, вы можете установить автоматическую оценку функции при загрузке документа Mathematica. Было бы невозможно использовать Mathematica для создания документа с помощью SafeEvaluate [function] в качестве «запуска при загрузке» и запуска другого процесса Mathematica в фоновом режиме с этим документом. Тогда вы все еще можете использовать тот, который вы видите для ввода. Конечно, тогда вам нужно будет объединить этот процесс, чтобы увидеть, завершился ли он, или иметь функцию, которая оценивает, сохранить результирующий файл, который вы объединяете.