Code Generation from MATLAB Code
Starting in R2023b, the code generator eliminates redundant code by reusing identical static functions generated for each MATLAB Function block in a model. Eliminating redundant code reduces code complexity, reduces memory usage at run time, and improves code readability. Previously, the code generator produced separate functions, resulting in duplication, despite having identical implementations and sharing the same external MATLAB® file.
Consider the model ReuseCodeForMLFB, which includes two MATLAB
Function blocks mfcn1 and mfcn2 that call
the function multi_two. Set the model configuration parameter
Shared code placement to either Auto or
Shared Location. The associated global data store stores the
input of the model.
The table compares the code generated in R2023a and R2023b for the model
ReuseCodeForMLFB. In R2023a, the code contains duplicate functions
ReuseCodeForMLFB_multi_two and
ReuseCodeForMLFB_multi_two_f to represent the calls to
multi_two from mfcn1 and mfcn2.
In R2023b, the code reuses the function ReuseCodeForMLFB_multi_two, thus
removing code redundancy.
| Generated Code in R2023a | Generated Code in R2023b |
|---|---|
/* Real-time model */
static RT_MODEL_ReuseCodeForMLFB_T ReuseCodeForMLFB_M_;
RT_MODEL_ReuseCodeForMLFB_T *const ReuseCodeForMLFB_M = &ReuseCodeForMLFB_M_;
static void fcn1(void);
static void fcn2(void);
/* Forward declaration for local functions */
static real_T ReuseCodeForMLFB_multi_two(real_T u);
/* Forward declaration for local functions */
static real_T ReuseCodeForMLFB_multi_two_f(real_T u);
/* Function for MATLAB Function: '<Root>/mfcn1' */
static real_T ReuseCodeForMLFB_multi_two(real_T u)
{
real_T y;
y = 2.0 * u;
myData = u;
return y;
}
/* Output and update for atomic system: '<Root>/mfcn1' */
static void fcn1(void)
{
/* Outport: '<Root>/Out1' incorporates:
* Inport: '<Root>/In1'
*/
ReuseCodeForMLFB_Y.Out1 = ReuseCodeForMLFB_multi_two(ReuseCodeForMLFB_U.In1) +
3.0;
}
/* Function for MATLAB Function: '<Root>/mfcn2' */
static real_T ReuseCodeForMLFB_multi_two_f(real_T u)
{
real_T y;
y = 2.0 * u;
myData = u;
return y;
}
/* Output and update for atomic system: '<Root>/mfcn2' */
static void fcn2(void)
{
/* Outport: '<Root>/Out2' incorporates:
* Inport: '<Root>/In1'
*/
ReuseCodeForMLFB_Y.Out2 = ReuseCodeForMLFB_multi_two_f(ReuseCodeForMLFB_U.In1)
+ 5.0;
}
/* Model step function */
void ReuseCodeForMLFB_step(void)
{
/* MATLAB Function: '<Root>/mfcn1' */
fcn1();
/* MATLAB Function: '<Root>/mfcn2' */
fcn2();
} |
/* Real-time model */
static RT_MODEL_ReuseCodeForMLFB_T ReuseCodeForMLFB_M_;
RT_MODEL_ReuseCodeForMLFB_T *const ReuseCodeForMLFB_M = &ReuseCodeForMLFB_M_;
/* Exported functions */
extern real_T ReuseCodeForMLFB_multi_two(real_T u);
static void fcn1(void);
static void fcn2(void);
/* Function for MATLAB Function: '<Root>/mfcn1' */
real_T ReuseCodeForMLFB_multi_two(real_T u)
{
real_T y;
y = 2.0 * u;
myData = u;
return y;
}
/* Output and update for atomic system: '<Root>/mfcn1' */
static void fcn1(void)
{
/* Outport: '<Root>/Out1' incorporates:
* Inport: '<Root>/In1'
*/
ReuseCodeForMLFB_Y.Out1 = ReuseCodeForMLFB_multi_two(ReuseCodeForMLFB_U.In1) + 3.0;
}
/* Output and update for atomic system: '<Root>/mfcn2' */
static void fcn2(void)
{
/* Outport: '<Root>/Out2' incorporates:
* Inport: '<Root>/In1'
*/
ReuseCodeForMLFB_Y.Out2 = ReuseCodeForMLFB_multi_two(ReuseCodeForMLFB_U.In1) + 5.0;
}
/* Model step function */
void ReuseCodeForMLFB_step(void)
{
/* MATLAB Function: '<Root>/mfcn1' */
fcn1();
/* MATLAB Function: '<Root>/mfcn2' */
fcn2();
} |
Model Architecture and Design
Code Interface Configuration and Integration
Code Generation
Deployment
Performance
Starting in R2023b, the enhanced TLC block interface more effectively integrates code for S-Function blocks into the generated code of the model as compared to the existing TLC block interface. This improved integration significantly enhances the code quality and offers these benefits:
Improved buffer allocation for the inputs and outputs of S-Function blocks in the generated code
Improved inlining of the code generated for the S-Function block
Reuse of local variables used in
for-loop iterationsA more explicit set of cross-release compatible TLC library functions
For example, consider the model mtimestwo that includes two identical
S-Function blocks.
In this case, the TLC for these S-Functions is expressed as:
%function Outputs(block, system) Output
/* Multiply input by two start */
%assign rollVars = ["U", "Y"]
%assign paramVal = (1 == block.SFcnParamSettings.GenUncompilableCode) ? "2_0" : "2.0"
%roll idx = RollRegions, lcv = RollThreshold, block, "Roller", rollVars
%<LibBlockOutputSignal(0, "", lcv, idx)> = \
%<LibBlockInputSignal(0, "", lcv, idx)> * %<paramVal>;
%endroll
/* Multiply input by two end */
%endfunctionThis table compares the code generated with the TLC block interface and the enhanced TLC block interface.
The generated code with the enhanced TLC block interface eliminates the redundant temporary
variable i1 and data copies u0 and y0.
It also eliminates unnecessary creation of local scope for S-Function
blocks.
| Code with TLC block interface | Code with enhanced TLC block interface |
|---|---|
void mTLC_timestwo_demo_step(void)
{
real_T rtb_Gain[10];
int32_T i;
for (i = 0; i < 10; i++) {
/* Outport: '<Root>/Out1' incorporates:
* Gain: '<S1>/Gain'
* Inport: '<Root>/In1'
*/
mTLC_timestwo_demo_Y.Out1[i] = 5.0 * mTLC_timestwo_demo_U.In1[i];
}
/* S-Function (sfcn_timestwo_v3): '<S1>/S-Function' incorporates:
* Outport: '<Root>/Out1'
*/
/* Multiply input by two start */
{
int_T i1;
const real_T *u0 = &mTLC_timestwo_demo_Y.Out1[0];
real_T *y0 = &rtb_Gain[0];
for (i1=0; i1 < 10; i1++) {
y0[i1] = u0[i1] * 2.0;
}
}
/* Multiply input by two end */
/* Gain: '<S2>/Gain' */
for (i = 0; i < 10; i++) {
rtb_Gain[i] *= 10.5;
}
/* End of Gain: '<S2>/Gain' */
/* S-Function (sfcn_timestwo_v3): '<S2>/S-Function' incorporates:
* Outport: '<Root>/Out1'
*/
/* Multiply input by two start */
{
int_T i1;
const real_T *u0 = &rtb_Gain[0];
real_T *y0 = &mTLC_timestwo_demo_Y.Out1[0];
for (i1=0; i1 < 10; i1++) {
y0[i1] = u0[i1] * 2.0;
}
}
/* Multiply input by two end */
} |
void mTLC_timestwo_demo_step(void)
{
real_T rtb_Gain[10];
int32_T i;
for (i = 0; i < 10; i++) {
/* Outport: '<Root>/Out1' incorporates:
* Gain: '<S1>/Gain'
* Inport: '<Root>/In1'
*/
mTLC_timestwo_demo_Y.Out1[i] = 5.0 * mTLC_timestwo_demo_U.In1[i];
}
/* S-Function (sfcn_timestwo_v3): '<S1>/S-Function' incorporates:
* Outport: '<Root>/Out1'
*/
/* Multiply input by two start */
for (i = 0; i < 10; i++) {
rtb_Gain[i] = mTLC_timestwo_demo_Y.Out1[i] * 2.0;
}
/* Multiply input by two end */
/* Gain: '<S2>/Gain' */
for (i = 0; i < 10; i++) {
rtb_Gain[i] *= 10.5;
}
/* End of Gain: '<S2>/Gain' */
/* S-Function (sfcn_timestwo_v3): '<S2>/S-Function' incorporates:
* Outport: '<Root>/Out1'
*/
/* Multiply input by two start */
for (i = 0; i < 10; i++) {
mTLC_timestwo_demo_Y.Out1[i] = rtb_Gain[i] * 2.0;
}
/* Multiply input by two end */
} |
For more information, see Improve Code Efficiency and Integration of Inlined S-Functions.
Before R2023b, the generated code contained unnecessary temporary variables and data copies for modeling patterns that used multiple Bus Assignment blocks to change the value of a nested bus element. Starting in R2023b, the code generator does not generate the unnecessary temporary variables and data copies. Instead, the generated code performs inplace updates by reusing the input bus buffers. Eliminating unnecessary temporary variables and data copies reduces RAM consumption and improves code execution speed.
Consider the mBusRouting model in which the bus signal
BusType1 feeds into the Bus Selector and Bus Assignment block
BusAssignment2. The Bus Selector block outputs the nested bus element
field3 and the Bus Assignment1 block changes the value
of the field4 of the field3. Depending on the value of
In3, the Bus Assignment2 block assigns the new values to
the bus element field3 of the input bus signal.
In R2023a, the code generator produced this code:
void mBusRouting_step(void)
{
BusType2 rtb_Switch;
rtb_Switch.field4 = rtU.In2;
if (!(rtU.In3 <= 3.0)) {
memset(&rtb_Switch, 0, sizeof(BusType2));
}
rtY.Out2 = rtU.In1;
rtY.Out2.field3 = rtb_Switch;
}The generated code contained an unnecessary temporary variable rtb_Switch
for holding the updated value before assigning the value to
rtY.Out2.field3.
In R2023b, the code generator produces this code:
void mBusRouting_step(void)
{
rtY.Out2 = rtU.In1;
rtY.Out2.field3.field4 = rtU.In2;
if (!(rtU.In3 <= 3.0)) {
memset(&rtY.Out2.field3, 0, sizeof(BusType2));
}
}The generated code does not contain the temporary variable rtb_Switch for
holding the updated value. The code directly assigns the value to
rtY.Out2.field3. For more information, see Reduce Data Copies for Bus Assignment Blocks in Generated Code.
Starting in R2023b, the generated code contains fewer data copies for models containing an atomic For Each subsystem whose:
Input and output signals use the
Reusablestorage class.Function packaging is set to
inlineorNonreuasablewith thevoid_voidfunction interface setting.For Each block has the same dimension specified for the input Partition Dimension and output Concatenation Dimension.
For example, the model mRCSCInForEachSS contains an atomic inlined For Each
subsystem ForEachSS. The input and output signals of
ForEachSS are configured to use the Reusable storage
class through the Code Mappings editor.
In R2023a, the code generator produced this code:
void mRCSCInForEachSS_step(void)
{
BusObject sig_1_0[96];
int32_T ForEach_itr;
for (ForEach_itr = 0; ForEach_itr < 96; ForEach_itr++) {
sig_1_0[ForEach_itr].a = 2.0 * sig[ForEach_itr].a;
sig_1_0[ForEach_itr].b = sig[ForEach_itr].b;
sig[ForEach_itr] = sig_1_0[ForEach_itr];
}
}The generated code contained the unnecessary temporary array sig_1_0 and
data copies.
In R2023b, the code generator produces this code:
void mRCSCInForEachSS_step(void)
{
int32_T ForEach_itr;
for (ForEach_itr = 0; ForEach_itr < 96; ForEach_itr++) {
sig[ForEach_itr].a = 2.0 * sig[ForEach_itr].a;
}
}
The generated code does not contain the unnecessary temporary array sig_1_0
and data copies. Instead, the code performs inplace updates by reusing the
sig buffers. Reusing the buffers reduces RAM consumption and improves code
execution speed. For more information, see Specify Buffer Reuse for Signals in a Path.
In R2023b, the code generator may eliminate unnecessary temporary variables and associated data copies, which reduces RAM consumption and improves code execution speed.
Consider the model mCodeMetrics_MLSB with a MATLAB System block.
The following compares code generated in R2023a to the code generated in R2023b for the
model. In R2023a, the generated code contains a temporary variable u0 and
redundant data copies of the variable. In R2023b, the temporary variable
u0 and data copies are eliminated.
R2023a Generated Code
void mCodeMetrics_MLSB1_step(void)
{
real_T u0[400];
real_T i;
real_T j;
real_T rtb_MATLABSystem;
boolean_T found;
// MATLABSystem: '<Root>/MATLAB System' incorporates:
// Inport: '<Root>/In4'
std::memcpy(&u0[0], &mCodeMetrics_MLSB1_U.In4[0], 400U * sizeof(real_T));
// Implement algorithm. Calculate y as a function of input u and
// discrete states.
// 'mCodeMetrics_MLSB1SystemObject:32' i = 1;
i = 1.0;
// 'mCodeMetrics_MLSB1SystemObject:33' found = false;
found = false;
// 'mCodeMetrics_MLSB1SystemObject:34' y = 0;
rtb_MATLABSystem = 0.0;
// 'mCodeMetrics_MLSB1SystemObject:35' while (i < size(u1, 1)) && (found == false)
while (i < 20.0 && !found) {
// 'mCodeMetrics_MLSB1SystemObject:36' j = 1;
j = 1.0;
// 'mCodeMetrics_MLSB1SystemObject:37' while (j < size(u1, 2))
while (j < 20.0 && !(u0[(int32_T)i - 1 + 20 * ((int32_T)j - 1)] == 0.0)) {
// 'mCodeMetrics_MLSB1SystemObject:38' if u1(i, j) == 0
// 'mCodeMetrics_MLSB1SystemObject:40' else
// 'mCodeMetrics_MLSB1SystemObject:41' j = j + 1;
j = j + 1.0;
}
// 'mCodeMetrics_MLSB1SystemObject:45' if (j < size(u1, 2))
if (j < 20.0) {
// 'mCodeMetrics_MLSB1SystemObject:46' found = true;
found = true;
// 'mCodeMetrics_MLSB1SystemObject:47' y = i + j*size(u1, 1);
rtb_MATLABSystem = i + j * 20.0;
}
// 'mCodeMetrics_MLSB1SystemObject:49' i = i + 1;
i = i + 1.0;
}
// Outport: '<Root>/Out2'
mCodeMetrics_MLSB1_Y.Out2 = rtb_MATLABSystem;
}R2023b Generated Code
void mCodeMetrics_MLSB1_step(void)
{
real_T i;
real_T j;
real_T rtb_MATLABSystem;
boolean_T found;
// MATLABSystem: '<Root>/MATLAB System'
// Implement algorithm. Calculate y as a function of input u and
// discrete states.
// 'mCodeMetrics_MLSB1SystemObject:32' i = 1;
i = 1.0;
// 'mCodeMetrics_MLSB1SystemObject:33' found = false;
found = false;
// 'mCodeMetrics_MLSB1SystemObject:34' y = 0;
rtb_MATLABSystem = 0.0;
// 'mCodeMetrics_MLSB1SystemObject:35' while (i < size(u1, 1)) && (found == false)
while (i < 20.0 && !found) {
// 'mCodeMetrics_MLSB1SystemObject:36' j = 1;
j = 1.0;
// 'mCodeMetrics_MLSB1SystemObject:37' while (j < size(u1, 2))
while (j < 20.0 && !(mCodeMetrics_MLSB1_U.In4[(int32_T)i - 1 + 20 *
((int32_T)j - 1)] == 0.0)) {
// 'mCodeMetrics_MLSB1SystemObject:38' if u1(i, j) == 0
// 'mCodeMetrics_MLSB1SystemObject:40' else
// 'mCodeMetrics_MLSB1SystemObject:41' j = j + 1;
j = j + 1.0;
}
// 'mCodeMetrics_MLSB1SystemObject:45' if (j < size(u1, 2))
if (j < 20.0) {
// 'mCodeMetrics_MLSB1SystemObject:46' found = true;
found = true;
// 'mCodeMetrics_MLSB1SystemObject:47' y = i + j*size(u1, 1);
rtb_MATLABSystem = i + j * 20.0;
}
// 'mCodeMetrics_MLSB1SystemObject:49' i = i + 1;
i = i + 1.0;
}