Why is assignment with RedefinesParen so slow

Question

LR 2023-10-2

1
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2028264-why-is-assignment-with-redefinesparen-so-slow

评论： James Lebak 2023-10-3

I want to make a class that wraps around an array, so I tried matlab.mixin.indexing.RedefinesParen to allow interfacing with the object as if it were an array. I'm finding that assigning to the wrapped array is typically 40-80x slower than regular assignment to an array. Here is a simple test class:

classdef TestCustomParen < matlab.mixin.indexing.RedefinesParen
    properties
        X
    end
    methods
        function obj = cat(dim,varargin)
            obj.X = cat(dim,varargin{:});
        end
        function sz = size(obj)
            sz = size(obj.X);
        end
    end
    methods(Static)
        function obj = empty
            obj = TestCustomParen;
        end
    end
    methods(Access=protected)
        function x = parenReference(obj, indexOp)
            x = obj.X(indexOp.Indices{1});
        end
        function obj = parenAssign(obj,indexOp,varargin)
            obj.X(indexOp.Indices{1}) = varargin{1};
        end
        function n = parenListLength(obj,indexOp,ctx)
            n = listLength(obj.X,indexOp(3:end),ctx);
        end
        function obj = parenDelete(obj,indexOp)
            obj.X.(indexOp) = [];
        end
    end
end

I'm not too concerned with what all the implementations are doing, just focsuing on parenAssign here.

And the timing script:

x = TestCustomParen;
tic
for ind = 1:1e4
    x(ind) = rand;
end
toc
y = [];
tic
for ind = 1:1e4
    y(ind) = rand;
end
toc

And the result:

Elapsed time is 0.085126 seconds.

Elapsed time is 0.001309 seconds.

(It seems I can't actually run this code in the post)

I also tried a version of this where the arrays are both pre-allocated, and in that case the difference becomes even more dramatic (more than 100x slowdown).

Is this slowdown just due to the overhead of accessing indexOp and opening cells? Is is possible to get this sort of behavior in a performant way? The documentation says overriding subsref is no longer recommended, but would that be faster?

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

请先登录，再进行评论。

请先登录，再回答此问题。

Answer 1

Matt J 2023-10-2

1
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/2028264-why-is-assignment-with-redefinesparen-so-slow#answer_1323699

编辑：Matt J 2023-10-2

在 MATLAB Online 中打开

TestCustomParen.m

Here is the proper way to time the operations. The difference isn't that big.

x = TestCustomParen;
x.X=rand(500);
y=x.X;
a=rand;
    
  timeit(@()assig(x,a))\timeit(@()assig(y,a)),
ans = 0.8566
  timeit(@()Assig(x,a))\timeit(@()Assig(y,a)),
ans = 0.9793
function assig(z,a)
   z(1)=a;
end
function Assig(z,a)
   z(:)=a;
end

12 个评论
显示 10更早的评论隐藏 10更早的评论

LR 2023-10-2

在 MATLAB Online 中打开

TestCustomParen.m

Can you elaborate? This does not seem to just be a different timing method, but timing something else alltogether. Instead of assigning a random value in a loop to different indices, you're assigning a constant value to a constant set of indices.

Here is something that looks more like what you have but timing a loop over indices as well. It's not too surprising that assigning to a constant set of indices allows for some optimization, but my use case is random access/assignment to a wrapped array.

n = 1e4;
x = TestCustomParen;
x.X = zeros(1,n);
y = x.X;
timeit(@() assig(x,n)) / timeit(@() assig(y,n))
ans = 48.6528
timeit(@() assig2(x)) / timeit(@() assig2(y))
ans = 1.5216
function assig(z,n)
    for ind = 1:n
        z(ind) = 1;
    end
end
function assig2(z)
    z(1) = 1;
end

Looks like something might actually have been improved in 23b since this is just showing a ~100x while on my 23a laptop I'm seeing ~300x to ~1000x.

Matt J 2023-10-2

编辑：Matt J 2023-10-2

在 MATLAB Online 中打开

Your question seems to be, will parenAssign allow you to achieve the same element-by-element assignment speed in a for-loop as a builtin numeric vector y. The answer seems to be no, probably because you are still repeatedly invoking an mfunction, which will never be as fast as JIT-accelerated builtin code. Although, I invite @James Lebak to comment on that.

However, if you vectorize the assignment, the issue mostly goes away. Also, the revised demo below does seem to confirm that parenAssign overloading is significantly faster than subsasgn overloading when the vector data isn't too large.

for n=logspace(0,6,7)
    
    x = TestCustomParen; %uses overloaded parenAssign
    x.X=rand(1,n);
    obj = myclass(x.X);  %uses overloaded subsasgn
    y=x.X;
    
    I=randperm(n);
    
    T=timeit(@()assig(y,I));
    
    n,
    parenTime = timeit(@()assig(x,I))/T,
    subsasgnTime=timeit(@()assig(obj,I))/T,
    
    disp ' '
end
n = 1
parenTime = 1.8960
subsasgnTime = 5.2336
 
n = 10
parenTime = 1.5231
subsasgnTime = 4.1442
 
n = 100
parenTime = 3.7847
subsasgnTime = 10.9212
 
n = 1000
parenTime = 1.1000
subsasgnTime = 2.6711
 
n = 10000
parenTime = 1.1730
subsasgnTime = 1.7853
 
n = 100000
parenTime = 1.0259
subsasgnTime = 1.1305
 
n = 1000000
parenTime = 1.0050
subsasgnTime = 1.0131
 
function assig(z,I)
   z(I) = 1;
end

LR 2023-10-2

在 MATLAB Online 中打开

Thanks for the references, I've only skimmed them but I'll look in more detail. I don't immediately see a better way to do the parenAssign method with this forwarding. The parenAssign example does

[obj.(indexOp(2:end))] = varargin{:};

which I did not quite understand. Does it only work when the value being assigned is of the same class as obj? If you see how the example in my OP can be modified to run faster please let me know. I feel like it's a pretty simple use case, I want a wrapper for an array that can be operated on like an array but does some other stuff under the hood. Like:

wrappedArray=TestCustomParen;
>> wrappedArray(4)=1;
>> wrappedArray(4)
ans =
     1

It would not be the end of the world if I had to do something like this, if it were much faster:

wrappedArray=TestCustomParen;
>> wrappedArray(4)=TestCustomParen(1); % Assign a wrapped scalar
>> wrappedArray(4)
ans =
     1

"it is usually better to return another instance of the same class"

I'm a little confused by this statement though, would you also return another instance of the wrapper class that just wraps a scalar double? Like:

wrappedArray=TestCustomParen;
>> wrappedArray(4)=TestCustomParen(1); % Assign a wrapped scalar
>> wrappedArray(4)
ans =
  TestCustomParen with properties:
    X: 1

In fact the parenReference method in that mapping class example seems to just be returning map values whatever their type so maybe that's not a big deal.

LR 2023-10-2

编辑：LR 2023-10-2

在 MATLAB Online 中打开

Cool, I'll hit accept on the answer. Thanks both for the info. @James Lebak I'd be grateful if you could indicate if there's been any significant performance improvements to this stuff in 23b. The above tests seem to indicate that going from 23a to 23b and modifying my code from

obj.X(indexOp(1).Indices{1}) = varargin{1};

to

obj.X.(indexOp(1)) = varargin{1};

results in a more than 20x speedup.

James Lebak 2023-10-3

In 23b we made significant improvements to dot-indexing performance. On my machine I see your original code running about 2x faster in 23b versus 23a, and my suspicion is that those improvements are probably the cause.

请先登录，再进行评论。

Why is assignment with RedefinesParen so slow

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

采纳的回答

12 个评论
显示 10更早的评论隐藏 10更早的评论

更多回答（0 个）

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

Why is assignment with RedefinesParen so slow

0 个评论 显示 -2更早的评论隐藏 -2更早的评论

采纳的回答

12 个评论 显示 10更早的评论隐藏 10更早的评论

更多回答（0 个）

另请参阅

类别

标签

产品

版本

Community Treasure Hunt

0 个评论
显示 -2更早的评论隐藏 -2更早的评论

12 个评论
显示 10更早的评论隐藏 10更早的评论