parfor does not propagate changes to handle class - matlab

Question

In R2018b, consider the following toy class:
classdef MyObj < handle
properties
use_parallel = true
test_value = NaN
end
methods
function myMethod(obj)
% Call one of the nested functions below:
if all([obj.use_parallel])
parallel();
disp('Parallel (inside myMethod):')
[obj.test_value]
else
sequential();
disp('Sequential (inside myMethod):')
[obj.test_value]
end
% Sequentially assign some values
function sequential()
for ii = 1:numel(obj)
obj(ii).test_value = ii; end
end
% Assign some values in parallel
function parallel()
parfor ii = 1:numel(obj)
set_value(obj(ii),labindex());
obj_copy(ii) = obj(ii);
end
obj = obj_copy;
end
end
end
end
% parfor requires subfunction (and not nested function):
function set_value(obj,index)
obj.test_value = index;
end
Though this question closely resembles this and this question, their underlying problem was essentially some variant of the limitation outlined in the documentation:
You can send handle objects as inputs to the body of a parfor-loop. However, any changes made to handle objects on the workers during loop iterations are not automatically propagated back to the client. That is, changes made inside the loop are not automatically reflected after the loop
However, as far as I can see, the toy class above is compliant with the parfor slicing rules as well as these particulars regarding handle classes. In my understanding, it should therefore correctly copy the modified obj back to myMethod's workspace.
However, running the following:
clc
% Assign sequentially
M(3) = MyObj();
[M.use_parallel] = deal(false);
M.myMethod();
disp('Sequential (outside class):')
[M.test_value]
disp(' ')
% Assign in parallel
N(3) = MyObj();
[N.use_parallel] = deal(true);
N.myMethod();
disp('Parallel (outside class):')
[N.test_value]
gives on my parpool of 6 workers:
Sequential (inside myMethod):
ans =
1 2 3 % <- OK
Sequential (outside class):
ans =
1 2 3 % <- OK. Nothing unexpected
Parallel (inside myMethod):
ans =
1 1 1 % <- OK, apparently, lab 1 did everything
Parallel (outside class):
ans =
NaN NaN NaN % <- hmmm...changes did not propagate
This means the obj.test_value gets correctly assigned, and the modified obj is indeed correctly copied into myMethod's workspace. Yet somehow, this modified obj is a different entity than the obj before modification, because the changes do not propagate higher up the stack...
Changing the parallel() function to a subfunction (instead of a nested function) and explicitly passing the obj parameter around, does not affect this outcome.
Sooooo...what's going on here?

Answer 1

I can reduce the problem to this:
classdef MyObj < matlab.mixin.Copyable
properties
test_value = NaN
end
methods
function myMethod(obj)
obj = obj.copy();
obj.test_value = rand;
disp('Inside method:')
obj.test_value
end
end
end
Removing nested functions, subfunctions and parfor from the equation. Running the code (after obvious changes) above results in:
Inside method:
ans =
4.8089e-01 % <- obj re-initialized OK
Outside class:
ans =
NaN % <- but this does NOT modify the handle class!
That means it's a language "feature" I wasn't aware of! Apparently, methods can modify existing objects, but not redefine them completely. I'll try digging in the documentation to find out some more about this, but this poses a whole new problem: how to copy the changes made by parfor back into the object?
TL;DR:
function myMethod(obj)
% ↓ new object ↓ old object
obj = obj.copy();
Cris was right; though the new and old objects have identical names, they are different things—they shadow each other. Any changes made to the new obj will not modify the old obj.