Documentation

Copy-on-Write

If a function does not modify an input argument, MATLAB does not make a copy of the values contained in the input variable.

For example, suppose that you pass a large array to a function.

A = rand(1e7,1);
B = f1(A);

The function f1 multiplies each element in the input array X by 1.1 and assigns the result to the variable Y.

function Y = f1(X)
   Y = X.*1.1; % X is a shared copy of A
end

Because the function does not modify the input values, the local variable X and the variable A in the caller's workspace share the data. After f1 executes, the values assigned to A have not changed. The variable B in the caller's workspace contains the result of the element-wise multiplication. The input is passed by value. However, no copy is made when calling f1.

The function f2 does modify its local copy of the input variable, causing the local copy to be unshared with input A. The value of X in the function is now an independent copy of the input variable A in the caller's workspace. When f2 returns the result to the caller's workspace, the local variable X is destroyed.

A = rand(1e7,1);
B = f2(A);

function Y = f2(X)
   X = X.*1.1; % X is an independent copy of A
   Y = X;      % Y is a shared copy of X
end

Passing Inputs as MATLAB Expressions

You can use the value returned from a function as an input argument to another function. For example, use the rand function to create the input for the function f2 directly.

B = f2(rand(1e7,1));

The only variable holding the value returned by rand is the temporary variable X in the workspace of the function f2. There is no shared or independent copy of these values in the caller's workspace. Directly passing function outputs saves the time and memory required to create a copy of the input values in the called function. This approach makes sense when the input values are not used again.

Assigning In-Place

You can assign the output of a function to the same variable as the input when you do not need to preserve the original input values.

A = f2(A);

Reassignment to the same variable name follows the copy-on-write behavior described previously: modifying the input variable values results in a temporary copy of those values. However, MATLAB can apply memory optimizations under certain conditions.

Consider the following example. The memoryOptimization function creates a large array of random numbers in the variable A. Then it calls the local function fLocal, passing A as the input, and assigning the output of the local function to the same variable name.

Because the call to the local function, A = fLocal(A), assigns the output to the variable A, MATLAB does not need to preserve the original value of A during execution of the function. Within fLocal, the input X has the only copy of the value originally held by A.

Therefore, modifications made to X inside fLocal do not result in a copy of the data. The assignment, X = X.*1.1, modifies X in place, without allocating a new array for the result of the multiplication.

function memoryOptimization
   A = rand(1e7,1);
   A = fLocal(A);
end
function X = fLocal(X)
   X = X.*1.1; 
end

Eliminating the copy in the local function saves memory and improves execution speed for large arrays. However, MATLAB cannot apply memory optimization when it is possible to use the variable after the function throws an error. Therefore, this optimization is not applied in scripts, on the command line, in calls to eval, or to code inside try/catch blocks.

Also, MATLAB does not apply memory optimization when the original variable can be accessed directly during execution of the called function. For example, if fLocal was a nested function, MATLAB could not apply the optimization because variables can be shared with the parent function.

Finally, MATLAB does not apply memory optimization when the assigned variable is declared as global or persistent.