Avoid loops (i.e. for, while, etc.).

Vectorize your code as in the following example

(as found in the link below)

http://www.mathworks.com/help/matlab/matlab_prog/vectorization.html

This code computes the sine of 1,001 values ranging from 0 to 10:

i = 0;

for t = 0:.01:10

i = i + 1;

y(i) = sin(t);

end

This is a vectorized version of the same code:

t = 0:.01:10;

y = sin(t);

For functions that do not use high-level matlab functions or toolboxes, one solution is to write them in C/C++ (for instance) and to compile them.

Suppose they read data from input file and write results to output file that are specified as argv[1,2] on a command line.

In matlab, you just then have to type "!myexecutable input.dat output.dat" (it is at least working on linux; with ! you can use shell commands: !mkdir, !rm ...)

Hope it is usefull (I personnaly never managed to make mex working properlly)

Avoid loops (i.e. for, while, etc.).

Vectorize your code as in the following example

(as found in the link below)

http://www.mathworks.com/help/matlab/matlab_prog/vectorization.html

This code computes the sine of 1,001 values ranging from 0 to 10:

i = 0;

for t = 0:.01:10

i = i + 1;

y(i) = sin(t);

end

This is a vectorized version of the same code:

t = 0:.01:10;

y = sin(t);

1. Optimize your code.

2. Vectorize your code (as suggested aboce by Jose Fornari)

3. (Try to) Parallelize your code.

Look into the "profiler" and see where you are spending a lot of time. work on making those more efficient.

Also, we have found that sometimes mex won't necessarily make things faster, if you can do things with matrices using matrix operators in matlab that can sometimes be more efficient than trying to write your own code. we have found this to be true in some limited cases.

but to make mex, that will require you to understand c/c++, and how to pass data back and forth between matlab and you mex code, you'll need to put in handlers in the call for data, and any allocation. it can be pretty messy if you don't have any experience. so back to my first suggestion, look at the "profiler" and get a sense of where you're spending your time.

good luck.

Profiler:

http://www.mathworks.com/help/matlab/ref/profile.html

Mex:

http://www.mathworks.com/help/matlab/creating-c-c-and-fortran-programs-to-be-callable-from-matlab-mex-files.html

Never use Loops, especially the loop of loops (codes killer), vectorization such scenario to avoid alot of wasted computation time. I totally Agree Jose

Regards

Mohammad

Did you look a bit closer at the LSGO benchmark package? There is a folder "MATLAB" which implements the functions in Matlab, and a folder "C" that implements the same functions in C. You just need to make a mex or oct file out of the C implementation, and you get the faster versions of the code running in Matlab/Octave.

Avoiding loops in the code by using vectorized operations and use of vectors and matrices will help in fast execution. Also try to use Matlab library functions and operators.

I want to add to Jose's answer:

You can also vectorize multiplications or divisions by using the elementwise multiplication/division method. Just use the point operator:

Example:

t = 0:0.1:10;

x = 0:0.2:20;

res = [ ];

for i = 1:length(t)

res(end+1) = x(i)*exp(t(i));

end

Better:

t = 0:0.1:10;

x = 0:0.2:20;

res = x.*exp(t);

When you are using nested loops (loop within a loop), you can replace them by using elementwise matrix operations.

If you have to use the loop, try to use the parallel computing toolbox in Matlab to distribute the seperate loop iterations onto different cores or threads on your CPU.

Even for all the optimizations that are possible, MATLAB is still a memory pig.

At the beginning of every run of the big script that calls everythingelse should always use clear all function.

Can also redefine many opf the variables at the top as lessor resolution.

ie do not need double real to use as counters. integers should also be used as counters. reals instead of double reals, arrays sized to needs, without excess sprawl and many empty rows, columsn cells etc....

Although these optimizations help, as do the vectorization over loops, memory useage will still accumulate over runs, and even exiting MATLAB will not free up all memory used by program or scripts.

If running overnight may wish to periodically reboot whole machine, or at least reboot at the very beginning of a run of many scripts.

MATLAB's high level coding and vectorization and all the wonderful things do come at a price.

To emphasize Gert's answer: you can mex m files as well. I'm not sure how much that will speed things up. Are there already C versions of your code? If so, mex them.

In addition to the above answers, I would suggest using the MATLAB Parallel Computing Toolbox which is quite helpful if you have multicore processor, or computer cluster. However, the first think to check is if the size of your arrays is growing inside the loops. That could take a lot of computational time. Define your arrays before the loops and it will run much faster.

I agree with what most of these people have said here, vectorize your code; avoiding loops as much as you can. And make good use of the profiler.

I'm going for what seems easy, i.e., if you don't want to re-write the code:

Re: optimizing code: if anything is printing to the screen during the run, it slows the run tremendously. end any line in a semicolon that you can.

I don't know about Octave, but the latest versions of Matlab seem to parallelize quite easily. I think it's a matter of pushing a button or making a selection in a menu, or possibly adding a few lines at the top of the code. Hopefully, someone will correct me if I'm wrong....

Those seem like the fastest options, and possibly running as C if you are comfortable with it.

Another thing: preallocate your arrays. If you do any type of dynamic array expansion that will grind to a halt when arrays get large.

You may want to look at this contribution (I've not checked it out personally)

http://www.mathworks.com/matlabcentral/fileexchange/5685

Moreover, you might consider the use of Nvidia CUDA within Matlab.

Some implementation have already been demonstrated http://www.nvidia.com/object/tesla-matlab-accelerations.html

However a direct implementation of you code in CUDA will be an impressive improvement (calculation time divided by a factor 20 or more) depending on the operation that your routines have to perform. Everything that can be parallelized (FFT, Matrix products ...) will benefit from the use of the massively parallel GPU architecture.

Sincerely

Most of the methods that have been suggested so far are good ones. However to be able to really evaluate the improvement of any of these methods you can use the stopwatch functions tic and toc in Matlab. You need to insert a "tic" command at the beginning of the m-file (or at the beginning of any loop or part of the code) and to insert the "toc" command at the end. Matlab after executing the designated part of the code will reply with a message stating the elapsed time in seconds like:

Elapsed time is 0.180344 seconds.

I would certainly agree with testing the code with timers, as this can help you locate the most time-expensive parts. I have recently started doing this, and I have often been surprised which parts of the code are the slowest, so it is also a good learning exercise. With that done, try to make these parts more efficient (lots of good fundamental advice above), if you don't mind hacking at code written by someone else.

I would like to thank you all for your kind answers. My question, however seems to be remained unanswered!

To those who recommend stopwatch functions (tic & toc), I have to say Matlab profile is more handy and useful. This feature can compute the amount of time spend by each function/command.

To those guys who concern about memory usage, I am willing to say I have no problem in this matter. My program and benchmark functions can perfectly run without demanding much memory.

Finally, I have to mention that I did not write the main core of the benchmark functions and I also do not want to modify them. They are pretty standard functions and let suppose they run at their maximum speed. Therefore, I do not want (neither can) use any vectorization techniques, although they are very promising). I also cannot use parallel computing, because I have no such facilities.

My question actually is how to speed up a piece of program already written in Matlab/Octave, without recoding it. I know we can convert/compile the .m file codes to a kind of pre-complied C/C++ files (which technically called as .mex files) and use them instead or along with Matlab/Octave .m files. Since .mex files are pre-compiled (in contrast with original .m files which need interpreter), they can be run much faster (even if their original .m files are not written optimally).

Considering above facts, do you have any suggestion to convert those programs (link are available in question part) to .mex file and run them on both Matlab/Octave in Win/Linux platform?

Thanks again.

Yes, that's what I thought -- as benchmarks, you wouldn't want to alter them....

Weirdly, I thought someone had a pointer to a place to easily convert .m to .mex, but now the comment is gone? OK --

http://www.mathworks.com/products/matlab-coder/

I'm at a university and am lucky enough to get all of the Matlab products, but maybe this won't work for you.

Non-Matlab (manual instructions):

http://www.mathworks.com/matlabcentral/answers/36518

Ok. sorry that's just a Google search, but, maybe it will help.

If the functions that you want to speed up are written as m-files, I'd say you won't be able to compile them, without rewriting them completely.

Mex functions are compiled from C++ source code, using C++ libraries with functions that do not look like m-code at all. Then you can use such functions in your Octave m-scripts or functions, just as you can call other m-scripts/functions. But the other way round is not possible: you cannot normally call m-functions in C++ code, unless you call the Octave interpreter in the C++ function, but in that case you wouldn't gain any speed at all (in fact it could be even slower).

I would recommend you read the following introduction to understand how Octave works with C++ code:

http://octave.sourceforge.net/coda/‎

Or in PDF: http://octave.sourceforge.net/coda/coda.pdf‎

By the way, there you will find references to "oct" functions, rather than "mex". That's because Octave C++ libraries are different from Matlab's, and they are optimized to produce such oct-functions, although for compatibility reasons they also accept and can produce mex- ones.

What you may rather be looking for is the "just-in-time" compiler, that is under development in Octave. This feature makes a double work the first time it finds an m-function: it interprets it as usual, but also compiles the underlying code, and when that function is found again, it uses the compiled version instead of re-interpreting it. More details here:

http://www.gnu.org/software/octave/doc/interpreter/JIT-Compiler.html

However, take into account that it is experimental; it may be available or not for you depending on what distribution of Octave you are using, its functionality is limited, and it may fail or produce bugs. If you want to gain speed in a safer way, I'd endorse the others' recommendations: (1) pre-allocate matrices so that their size does not have to be changed in each iteration of the loops, and (2) vectorice as much as is reasonable, to reduce the number of function calls.