Question

在R2018b中，考虑以下玩具类别：

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

尽管此问题与this和this question非常相似，但它们的根本问题本质上是the documentation中概述的限制的某些变体：

您可以将句柄对象作为输入发送到parfor循环的主体。但是，在循环迭代过程中为处理工作对象上的对象所做的任何更改都不会自动传播回客户端。也就是说，循环内部所做的更改不会在循环之后自动反映

但是，据我所知，上面的玩具类符合parfor切片规则以及有关句柄类的这些详细信息。根据我的理解，因此它应该正确地将修改后的obj复制回myMethod's工作区。

但是，运行以下命令：

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]

请给我的6名工作人员中的parpool：

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

这意味着obj.test_value已正确分配，并且修改后的obj实际上已正确复制到myMethod's工作区中。但是以某种方式，此修改过的obj与修改前的obj是一个不同的实体，因为更改不会在堆栈中传播得更高...

将parallel()函数更改为子函数（而不是嵌套函数）并显式传递obj参数，不会影响此结果。

Sooooo ...这是怎么回事？

Answer 1

我可以将问题简化为：

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

从等式中删除嵌套函数，子函数和parfor。运行上面的代码（经过明显的更改）将导致：

Inside method:
ans =
     4.8089e-01   % <- obj re-initialized OK
Outside class:
ans =
     NaN          % <- but this does NOT modify the handle class!

这意味着我没有意识到这是一种语言“功能”！显然，方法可以修改现有对象，但不能完全重新定义。我将尝试在文档中进行挖掘以找到更多有关此的信息，但这带来了一个全新的问题：如何将parfor所做的更改复制回该对象？

TL; DR：

function myMethod(obj)
%   ↓ new object   ↓ old object
    obj       =    obj.copy();

克里斯是对的；尽管新对象和旧对象的名称相同，但是它们是不同的东西-它们彼此shadow。对新obj所做的任何更改都不会修改旧obj。

parfor不会传播更改来处理类

1 个答案: