13
$\begingroup$

Here is an example:

x = 0; Dynamic[x]

now please run:

SessionSubmit[x = 1; Pause[10];]

Problems:

  • Annoying one: Dynamic[x] is not updated before Pause is finished

  • Serious one: if Pause or whatever that follows x=1 is longer than DynamicEvaluationTimeout (6sec) then the FrontEnd will become unresponsive.

    This means that by doing a very standard thing and not requiring any fancy result you will get your FE stuck just because you modified a tracked variable within a scheduled task.

Diagnosis:

It looks like scheduled evaluations are or behave as wrapped with PreemptProtect.

One can see via LinkSnooper that soon after x=1 the Kernel tells the FrontEnd to update dynamic object. FrontEnd, using preemptive link, asks for the content of Dynamic[x] but the response is delayed till pause is finished. That delay is what causes problems.

One should note that in case x=1;Pause[10] evaluated as a normal code line it does not happen because preemptive link calculations can interrupt main link calculations. There is no documentation about what should happen when the long calculation is initiated from a scheduled task as opposed to a main link request.

Questions:

  • is that behavior expected? (not being able to interrupt a scheduled task)

  • is there a workaround? For simple cases one could do SessionSubmit[x = 1; SessionSubmit@Pause[10];] but that does not scale at all.

  • at the end I could live with waiting till whole task is finished but I can not accept that the FrontEnd stalls. To prevent it I'd need to make x=1 not to trigger updating at all till the scheduled evaluation is finished. That way FE won't ask back to early and won't get stuck.

$\endgroup$
  • 1
    $\begingroup$ you it might be helpful to read Todd Gayley's answer here. $\endgroup$ – ihojnicki Jun 25 at 13:40
  • $\begingroup$ @ihojnicki it makes the reason clear, thanks. Would be nice to have documented that Scheduled and Asynchronous tasks are preemptive. Would be nice to have an official answer about details why they are preemptive, what alternatives one has to schedule a longer task, what are best practices in similar cases (URLSubmit can do this, probably being split into a sequence of such tasks), etc etc. $\endgroup$ – Kuba Jun 25 at 17:29
  • 1
    $\begingroup$ sorry, but I cannot comment intelligently on the design decisions of the of the kernel. As for SessionSubmit, it says that it is preemptive at the bottom of the Details section. $\endgroup$ – ihojnicki Jun 25 at 21:09
  • $\begingroup$ @ihojnicki you are right. I missed that. I need to sum up use cases and try to come up with best practices. It would be nice to be able to control tracking to delay sending UpdateDynamicObjects till it is safe. E.g. RunScheduledTask[QueueTracking[procedure], ...] where when QueueTracking finished all collected ids are sent. $\endgroup$ – Kuba Jun 26 at 14:39
  • $\begingroup$ @ihojnicki here are more related problems 201084 $\endgroup$ – Kuba Jun 27 at 10:21
3
$\begingroup$
  • is that behavior expected? (not being able to interrupt a scheduled task)

Yes, as ihojnicki reminded us: sheduled tasks are preemptive.

  • is there a workaround?

There is a workaround I am using for some time so I decided to share it.

The problem appears in a notebook based FrontEnd with Dynamic interactivity enabled, fortunately because the workaround requires being able to launch dialogs and use Dynamics.

The solution is the same as here 112332. Instead of a scheduled evaluation we schedule a launch of a dialog which will trigger a main link evaluation of a desired procedure.

Here is a function:

MainLinkSubmit::usage = "MainLinkKSubmit[procedure] allows you to submit a non preemptive call from a preemptive one "<>
    "(e.g. from scheduled task). Notebooks based front end environment is required.";

MainLinkSubmit // Attributes = {HoldAll};

MainLinkSubmit[procedure_] /; TrueQ @ $Notebooks := MessageDialog[
  Dynamic[
    NotebookClose[]; procedure
    , SynchronousUpdating->False
  ]
  , CellContext -> $Context
  , Visible     -> False
];

And here is an example:

x = 0; Dynamic[x]


SessionSubmit @ ScheduledTask[
  MainLinkSubmit[x = 1; Pause[1]; x = 2; Pause[1]; x = 3]
, {2}
]

FYI, this function is included in a prototype of my utilities package: https://github.com/kubaPod/Meh

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.