CODEWITHSUNDEEP
matlab
Folau
Folau

Reputation: 257

Loading Variables into Functions from Structs in Matlab

Say I have a project which is comprised of:

Within the script I will be accessing the functions many times within for loops (some over a thousand times within the minute long simulation). Each function is also looking for data contained with a struct files as part of their calculations, which are usually parameters that are fixed over the course of the simulation, however need to be varied manually between runs to observe the effects.

As typically these functions form the bulk of the runtime I'm trying to save time, as my simulation can't quite run at real-time as it stands (the ultimate goal), and I lose alot of time passing variables/parameters around functions. So I've had three ideas to try and do this:

  1. Load the structs in the main simulation, then pass each variable in turn to the function in the form of a large argument (the current solution).
  2. Load the structs every time the function is called.
  3. Define the structs as global variables.

In terms of both the efficiency of the system (most relevent as the project develops), and possibly as I'm no expert programmer from a "good practise" perspective what is the best solution for this? Is there another option that I have not considered?

Upvotes: 2

Views: 98

Answers (2)

TTT
TTT

Reputation: 1205

Matlab does what's known as a "lazy copy" when passing arguments between functions. This means that it passes a pointer to the data to the function, rather than creating a new instance of that data, which is very efficient memory- and speed-wise. However, if you make any alteration to that data inside the subroutine, then it has to make a new instance of that argument so as to not overwrite the argument's value in the main function. Your response to matlabgui indicates you're doing just that. So, the subroutine may be making an entire new struct every time it's called, even though it's only modifying a small part of that struct's values.

If your subroutine is altering a small part of the array, then your best bet is to just pass that small part to it, then assign your outputs. For instance, 

[modified_array] = somesubroutine(struct.original_array);
struct.original_array=modified_array;

You can also do this in just one line. Conceptually, the less data you pass to the subroutine, the smaller the memory footprint is. I'd also recommend reading up on in-place operations, as it relates to this.

Also, as a general rule, don't use global variables in Matlab. I have not personally experienced, nor read of an instance in which they were genuinely faster.

Upvotes: 0

matlabgui
matlabgui

Reputation: 5672

As mentioned above in the comments - the 1st item is best one.

Have you used the profiler to find out where you code takes most of its time?

profile on % run your code profile viewer

Note: if you are modifying your input struct in your child functions -> this will take more time, but if you are just referencing them then that should not be a problem.

Upvotes: 1

Related Questions