Clearing distributed definitions from remote kernels

Question

The documentation shows the following example to "Remove a distributed definition..."

Oh, course this doesn't work without redefining the function prior to re distributing the definition. The following does work:

ClearAll[f];
f[x_] := Labeled[Framed[x^2], $KernelID]
DistributeDefinitions[f];
ParallelMap[f, {1, 2, 3, 4}]

and will give the same output as the above screen clip. OK, but...

This seems a very cumbersome way to do this and just doesn't seem right at all.

It would seem clearer to me if one could call back the distribution of a function definition, something like UnDistributeDefinitions[], to withdrawal the function from remote kernels rather than needing to clear the function in the main kernel, redefine it, then redistribute it.

I came across this issue as I looked to move a DistributeDefinitions[] into a function that will run a bunch of other functions from a standalone cell in a notebook. To test whether it would work, I need to clear all the functions I wanted to distribute or restart the kernel.

Just seems a messy way to do things. So, does a way exist to clear definitions in remote kernels without clearing them in the main kernel?

Answer 1

Let me summarize the issues from the comments above and hopefully clear this for you. We start with the definition of f which calculates something and prints the $KernelID. We don't distribute this definition

f[x_] := {x^2, $KernelID};

Now we call ParallelMap and see that the function is called by the subkernels. While $KernelID of the main kernel is 0, the id of the subkernels is a positive integer

ParallelMap[f, {1, 2, 3, 4}]
(* {{1, 2}, {4, 2}, {9, 1}, {16, 1}} *)

This works because ParallelMap distributes automatically the definition of f. To suppress this behavior there is an option for most parallel functions: DistributedContexts. This can be set to None.

To answer your question: to clear the definition on the sub-kernels, you only have to use

ParallelEvaluate[Clear[f]]
ParallelMap[f, {1, 2, 3, 4}]
(* {{1, 0}, {4, 0}, {9, 0}, {16, 0}} *)

You see, that now the evaluating kernel has always the id 0. What's more interesting is, that now the definition of f is not redistributed automatically by ParallelMap. In fact, after clearing the definition on the sub-kernels even an explicit call to

DistributeDefinitions[f];
ParallelMap[f, {1, 2, 3, 4}]
(* {{1, 0}, {4, 0}, {9, 0}, {16, 0}} *)

is useless and f gets evaluated on the main kernel. This seems to be because f hasn't changed. You have to check the output of DistributeDefinitions to see whether some symbols was really distributed. Of course you can always make the definition explicitly on the sub-kernels with ParallelEvaluate[f[x_] := {x^2, $KernelID};] and everything is fine again.

Be careful when you play with distributing, redistributing or deleting definitions on the sub-kernels. It's not always clear on the first glance what happens and especially, who evaluates your expression.

Answer 2

Well if I am not wrong, the above solutions, as the one in the documentation do not solve the problem, in that DistributeDefinitions also distribute variables on which the original f depended.

One can clear f manually on parallel kernels, but one should also recursively clear all the other variables, which becomes cumbersome.

A proper function for instance would be UnDistributeDefinitions[f,Recursive->True/False], or even UndistributeDefinitions[] -> All distributions are cleared.