Prev: question about expanding an index
Next: Inverse Fourier transforms
From: Jason on 17 Jun 2010 15:15
Why is it better to preallocate memory with zeros instead of ones (A vs C below)? Also, why is it better not to allocate memory at all for D in the code below?

Code example:

clear; clc;

C=ones([1000,1000,10]);
A=zeros([1000,1000,10]);
B=NaN*ones([1000,1000,10]);
X=1000*rand(1000,1000,10);

tic
B=X;
dt = toc;
disp(['B:',num2str(dt)])

tic
A=X;
dt = toc;
disp(['A:',num2str(dt)])

tic
C=X;
dt = toc;
disp(['C:',num2str(dt)])

tic
D=X;
dt = toc;
disp(['D:',num2str(dt)])
From: dpb on 17 Jun 2010 15:39
Jason wrote:
> Why is it better to preallocate memory with zeros instead of ones (A vs
> C below)? Also, why is it better not to allocate memory at all for D in
> the code below?

Caching/etc for first I think...for example, if interchange A and B in
order, it doesn't change relative speed; the first reference to X is
still longer time than second.

Internals, I presume for the latter...it could be in essence only a
pointer created. I don't know ML is that smart but...

--
From: James Tursa on 17 Jun 2010 15:54
"Jason " <jtisaacs(a)ece.ucsb.edu> wrote in message <hvds8a$9pj$1(a)fred.mathworks.com>...
> Why is it better to preallocate memory with zeros instead of ones (A vs C below)? Also, why is it better not to allocate memory at all for D in the code below?
>
> Code example:
>
> clear; clc;
>
> C=ones([1000,1000,10]);
> A=zeros([1000,1000,10]);
> B=NaN*ones([1000,1000,10]);
> X=1000*rand(1000,1000,10);
>
> tic
> B=X;
> dt = toc;
> disp(['B:',num2str(dt)])
>
> tic
> A=X;
> dt = toc;
> disp(['A:',num2str(dt)])
>
> tic
> C=X;
> dt = toc;
> disp(['C:',num2str(dt)])
>
> tic
> D=X;
> dt = toc;
> disp(['D:',num2str(dt)])

I don't think this has to do with the pre-allocation or the assignment per se. It has to do with clearing the variables from memory. e.g., you get the same effect with this:

C=ones([1000,1000,10]);
A=zeros([1000,1000,10]);
B=NaN*ones([1000,1000,10]);

tic
clear B;
dt = toc;
disp(['B:',num2str(dt)])

tic
clear A;
dt = toc;
disp(['A:',num2str(dt)])

tic
clear C;
dt = toc;
disp(['C:',num2str(dt)])

I don't have conclusive evidence, but in my opinion, MATLAB appears to set all cleared / freed memory to 0's. Probably this is a security feature so that your data doesn't hang around in memory after the data block is cleared, and maybe it is also an optimization that allows for fast allocation. e.g., in a mex routine mxMalloc and mxCalloc appear to always do the same thing ... return a memory block filled with 0's and they both take the same amount of time even for a large block. *Apparently* MATLAB (or some support library function??) keeps track of this somehow in the background so when A is cleared there is no need to set the memory to 0's because MATLAB knows it already is 0's. i.e., maybe the memory manager keeps track of which blocks have been written to and which ones haven't. But for the non-zero arrays MATLAB has to go manually set the data block to 0's before freeing it. That
takes extra time. You can experiment with this by inserting this line in the above modified code and varying the number of non-zeros by changing the value of x:

A(1:x:end)=1;

In any event, it appears clearing 0 data takes less time that clearing non-zero data.

James Tursa
 | 
Pages: 1
Prev: question about expanding an index
Next: Inverse Fourier transforms