## MATLAB Coder Optimizations in Generated Code

To improve the execution speed and memory usage of generated code, MATLAB^{®}
Coder™ introduces the following optimizations:

### Constant Folding

When possible, the code generator evaluates expressions in your MATLAB code that involve compile-time constants only. In the generated code, it replaces these expressions with the result of the evaluations. This behavior is known as constant folding. Because of constant folding, the generated code does not have to evaluate the constants during execution.

The following example shows MATLAB code that is constant-folded during code generation. The function
`MultiplyConstant`

multiplies every element in a matrix by a
scalar constant. The function evaluates this constant using the product of three
compile-time constants, `a`

, `b`

, and
`c`

.

function out=MultiplyConstant(in) %#codegen a=pi^4; b=1/factorial(4); c=exp(-1); out=in.*(a*b*c); end

The code generator evaluates the expressions involving compile-time constants,
`a`

,`b`

, and `c`

. It replaces
these expressions with the result of the evaluation in generated code.

Constant folding can occur when the expressions involve scalars only. To
explicitly enforce constant folding of expressions in other cases, use the `coder.const`

function.

#### Control Constant Folding

You can control the maximum number of instructions that can be constant-folded from the command line or the project settings dialog box.

At the command line, create a configuration object for code generation. Set the property

`ConstantFoldingTimeout`

to the value that you want.`cfg=coder.config('lib'); cfg.ConstantFoldingTimeout = 200;`

Using the app, in the project settings dialog box, on the

**All Settings**tab, set the field**Constant folding timeout**to the value that you want.

### Loop Fusion

When possible, the code generator fuses successive loops with the same number of runs into a single loop in the generated code. This optimization reduces loop overhead.

The following code contains successive loops, which are fused during code
generation. The function `SumAndProduct`

evaluates the sum and
product of the elements in an array `Arr`

. The function uses two
separate loops to evaluate the sum `y_f_sum`

and product
`y_f_prod`

.

function [y_f_sum,y_f_prod] = SumAndProduct(Arr) %#codegen y_f_sum = 0; y_f_prod = 1; for i = 1:length(Arr) y_f_sum = y_f_sum+Arr(i); end for i = 1:length(Arr) y_f_prod = y_f_prod*Arr(i); end

The code generated from this MATLAB code evaluates the sum and product in a single loop.

### Successive Matrix Operations Combined

When possible, the code generator converts successive matrix operations in your MATLAB code into a single loop operation in generated code. This optimization reduces excess loop overhead involved in performing the matrix operations in separate loops.

The following example contains code where successive matrix operations take place.
The function `ManipulateMatrix`

multiplies every element of a
matrix `Mat`

with a `factor`

. To every element in
the result, the function then adds a `shift`

:

function Res=ManipulateMatrix(Mat,factor,shift) Res=Mat*factor; Res=Res+shift; end

The generated code combines the multiplication and addition into a single loop operation.

### Unreachable Code Elimination

When possible, the code generator suppresses code generation from unreachable
procedures in your MATLAB code. For
instance, if a branch of an `if, elseif, else`

statement is unreachable, then code is not
generated for that branch.

The following example contains unreachable code, which is eliminated during code
generation. The function `SaturateValue`

returns a value based on
the range of its input `x`

.

function y_b = SaturateValue(x) %#codegen if x>0 y_b = x; elseif x>10 %This is redundant y_b = 10; else y_b = -x; end

The second branch of the `if`

, `elseif`

,
`else`

statement is unreachable. If the variable
`x`

is greater than 10, it is also greater than 0. Therefore,
the first branch is executed in preference to the second branch.

MATLAB Coder does not generate code for the unreachable second branch.

`memcpy`

Calls

To optimize generated code that copies consecutive array elements, the code
generator tries to replace the code with a `memcpy`

call. A
`memcpy`

call can be more efficient than code, such as a
`for`

-loop or multiple, consecutive element assignments.

See memcpy Optimization.

`memset`

Calls

To optimize generated code that assigns a literal constant to consecutive array
elements, the code generator tries to replace the code with a
`memset`

call. A `memset`

call can be more
efficient than code, such as a `for`

-loop or multiple, consecutive
element assignments.

See memset Optimization.