Why does overwriting the whole matrix take so long?

I have code that in concept looks like this and takes very long to run:

clear all
tic
[A,B] = ndgrid(1:10^4,1:10^4);
for ind = 1:numel(A)
    C = A(ind)*B(ind);
end
C = A.*B;
toc

Elapsed time is 26.513977 seconds.

First I tried this code (added a line before final multiplication) because C changed size in my actual code, but it didn't improve:

clear all
tic
[A,B] = ndgrid(1:10^4,1:10^4);
for ind = 1:numel(A)
    C = A(ind)*B(ind);
end
C = zeros(size(A));
C = A.*B;
toc

Elapsed time is 26.368709 seconds.

However, clearing C instead worked:

clear all
tic
[A,B] = ndgrid(1:10^4,1:10^4);
for ind = 1:numel(A)
    C = A(ind)*B(ind);
end
clear C
C = A.*B;
toc

Elapsed time is 2.157905 seconds.

Why is this? What's good practice to reduce runtime for such a case? I don't think I'm supposed to clear every variable before I recompute/overwrite it...

Thanks

[dpb]

What release? Nothing like that seems apparent here w/ R2012b. I've 32-bit machine so ran out of memory w/ 10^4 so used 10^3 X 10^3 and 10^3 X 10^4 with no issue. The version with clear actually takes a tad longer than the others (as I would expect).

[the cyclist]

I see this behavior in R2015a.

I also scaled it down to 10^3, and see the same relative timing impact.

[JS]

My version is R2014a and I use Windows 7 Professional 64-bit with an Intel i7-4700U 2.1Ghz and 8GB RAM

[dpb]

Since Cyclist confirmed behavior with R2015, this needs to be reported to TMW as bug/issue at www.mathworks.com

Out of curiosity, is there any difference between interactive vis a vis m-file in the timings that could thus be related to JIT?

[JS]

I'm not sure if I understood your comment properly, but I just tried entering the slow code line by line into the command window and it (the line C=A.*B;) was much faster, without clearing C first.

[Jan]

@JS: The JIT acceleration is applied in function M-files, while the code in the command window is not accelerated - at least this has been the case for many Matlab versions. Therefore dpb asks for the difference between the timings.

Answer 1

[Jan]

The JIT acceleration does not provide its full power if the size of a variable is changed. This has been discussed e.g. at http://www.mathworks.com/matlabcentral/answers/214625-matlab-jit-and-execution-time .

Your examply shows that clearing the variable before redifining it with a new size avoid the interference. Another method would be not to redefine variables.

tic
[A,B] = ndgrid(1:10^4,1:10^4);
for ind = 1:numel(A)
    C = A(ind)*B(ind);
end
D = A.*B;   % Not C !
toc

[dpb]

The problem here is it appears there's a real step backwards with R2014 and later w/ a factor 10X roughly between the two. W/ R2012b here I see nowhere near such...

>>  [A,B] = ndgrid(1:10^3,1:10^4);
tic,for ind = 1:numel(A)
  C = A(ind)*B(ind);
end
clear C,C = A.*B;toc
Elapsed time is 0.553354 seconds.
>>  [A,B] = ndgrid(1:10^3,1:10^4);
tic,for ind = 1:numel(A)
  C = A(ind)*B(ind);
end
C = A.*B;toc
Elapsed time is 0.558813 seconds.
>>

I moved the tic after the ndgrid to just time the loop and the final multiply and then redid the above several times. Essentially identical result. Again, all from the command line.

[Jan]

@dpb: I get a similar slowdown as the OP under Matlab 2009a and 2011b (both 64, Win7), when the code is written into a function, while there is no slowdown in the command window:

• Command window with clear: 0.25 sec
• Command window without clear: 0.25 sec
• Function with clear: 0.24 sec
• Function without clear: 3.74 sec !!!

This seems to imply, that a powerful JIT deceleration is applied in the function. Hm.

[dpb]

Hmmmm....well, I presumed it wouldn't have happened in an m-file, but guess shouldn't've; I suppose OP found it in a file first. OK, let me see what happens here...

Ewwww! Most interesting!

R11      R12      R14        R2012b
m-file
17.9680  24.6400  0.222978   0.526563 CLEAR
17.3440  21.3750  5.067407  10.223897 OVERWRITE
interactive
23.4680  17.1410 13.182092   0.714583 CLEAR
14.9840  17.0780 13.244173   0.672088 OVERWRITE

Note especially the gains that have been lost in the m-file since R14 w/ R2012b (and my understanding is it's gotten worse but w/ the larger memory footprint req'd I've not tried upgrading as this machine is max'ed at 4GB). OTOH, the interactive performance is best, hands down. What can this mean????

[JS]

@Jan The size of the variable doesn't change though.

[dpb]

"The size of the variable doesn't change"

Ah, but it does -- in the loop you're only computing the one term, overwriting C each pass thru the loop. Now that may not have been the intent, but that's the code as written...

[JS]

Wow, I don't know how I could miss that... now the problem seems a little bit less weird to me :)