Why (in MATLAB) this code is faster? - performance

Question

I have written some code in two different ways in MATLAB. Firstly, I used two for loops, which seems stupid at the first glance:
Initial = [zeros(10,1) ones(10,1)];
for xpop=1:10
for nvar=1:10
Parent(xpop,nvar) = Initial(nvar,1)+(Initial(nvar,2)-Initial(nvar,1))*rand();
end
end
In the second scheme, I tried to do vectorized computation (I assumed it can be faster):
Parent = repmat(Initial(:,1),1,10) + rand(10,10).*(repmat(Initial(:,2),1,10)-repmat(Initial(:,1),1,10));
The elapsed time in three different run of the code can be seen following:
Elapsed time is 0.000456 seconds.
Elapsed time is 0.006342 seconds.
Elapsed time is 0.000457 seconds.
Elapsed time is 0.006147 seconds.
Elapsed time is 0.000471 seconds.
Elapsed time is 0.006433 seconds.
Why is the first scheme faster than the second? Is it really doing two stupid for loops inside the '.*' command?

Answer 1

Your test setup is simply too small to show the advantages of vectorization.
Initial = [zeros(10,1) ones(10,1)];
Elapsed time is 0.000078 seconds.
Elapsed time is 0.000995 seconds.
Now for a larger problem:
Initial = [zeros(1000,1) ones(1000,1)];
Elapsed time is 2.797949 seconds.
Elapsed time is 0.049859 seconds.

Answer 2

It is good for you to test these things. However you need to learn how to do these tests to gain good information.
First of all, the time taken is terribly small, so repeat tests are always best. Second, use a tool like timeit. It does all of the work for you, eliminating many sources of error, although it needs to have its target encapsulated as a function.
Next, there are issues with TINY problems. You test case is trivially small. In fact, there are many reasons for code taking time. Consider function overhead and startup costs. A function takes time to call, since there is overhead to set up and destroy function workspaces. Also, a GOOD function will have error testing, and offer several options. But for that to happen, it must check to see if those options were set. So time is spent, often doing nothing of value because you just want to use the function in some simple form. This means that when you call functions to vectorize a tiny computation, it may actually take more time than if you just did the unvectorized form inline. So small test cases are often misleading. (I was going to add a timing comparison for larger problem, but by then Marc had already done so in his answer. See the vest difference for larger problems.)
You should also learn to use bsxfun, a tool designed to optimize certain computations of the form you are testing. Again, small problems will often NOT show much gain in speed, if any.
Next, there are issues with JIT, the acceleration in place in MATLAB to optimize some simple codes. If that (invisible to you) tool manages to handle well the code you are testing, then it will appear as if the loop is faster.
It is good to do some tests, so lets make a comparison. Since your examples are all mainly inline, I'll just put a big loop around each case. This will reduce one of the large sources of testing error.
Ktot = 100;
N = 10;
Initial = [zeros(N,1) ones(N,1)];
tic
for k = 1:Ktot
for xpop=1:N
for nvar=1:N
Parent(xpop,nvar) = Initial(nvar,1)+(Initial(nvar,2)-Initial(nvar,1))*rand();
end
end
end
toc
tic
for k = 1:Ktot
Parent = repmat(Initial(:,1),1,N) + rand(N,N).*(repmat(Initial(:,2),1,N)-repmat(Initial(:,1),1,N));
end
toc
Can you improve your vectorized form? Why do two repmats, when one will work as well?
tic
for k = 1:Ktot
Parent = repmat(Initial(:,1),1,N) + rand(N,N).*repmat(Initial(:,2)-Initial(:,1),1,N);
end
toc
What about bsxfun?
tic
for k = 1:Ktot
Parent = bsxfun(#plus,Initial(:,1),bsxfun(#times,rand(N,N),Initial(:,2)-Initial(:,1)));
end
toc
So, with N = 10 and Ktot = 100, I see times like this:
Elapsed time is 0.003935 seconds.
Elapsed time is 0.012250 seconds.
Elapsed time is 0.008269 seconds.
Elapsed time is 0.004304 seconds.
Again, this is a small problem. What happens if we expand the problem? Try N = 100, instead of N = 10.
Elapsed time is 0.131186 seconds.
Elapsed time is 0.031671 seconds.
Elapsed time is 0.027205 seconds.
Elapsed time is 0.019763 seconds.
So there we saw things sorting out a bit more logically. Now the bsxfun variant is starting to show some gains. Next, go up to N = 1000.
Elapsed time is 12.288608 seconds.
Elapsed time is 3.412531 seconds.
Elapsed time is 2.690691 seconds.
Elapsed time is 1.626599 seconds.
Essentially, all of these codes do the same work, it is just that some are more efficient in how they structure the problem, while some have more overhead. As we see in the larger problems, explicit loops fall flat.