{"id":14738,"date":"2023-06-09T13:57:32","date_gmt":"2023-06-09T17:57:32","guid":{"rendered":"https:\/\/blogs.mathworks.com\/simulink\/?p=14738"},"modified":"2023-06-09T13:57:32","modified_gmt":"2023-06-09T17:57:32","slug":"avoiding-unwanted-data-copies-in-simulink-generated-code-via-reusing-i-o","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/simulink\/2023\/06\/09\/avoiding-unwanted-data-copies-in-simulink-generated-code-via-reusing-i-o\/","title":{"rendered":"Avoiding Unwanted Data Copies in Simulink Generated Code via Reusing I\/O"},"content":{"rendered":"
\r\n
Recently, we've had a few customers ask if it's possible to configure their models to alter values on a bus that goes into and out of their model without making a data copy. There are several ways to do this with Embedded Coder<\/a>\u00ae, but we'll focus on models which pass their inputs and outputs as arguments. In particular, we'll show how to pass arguments by reference in the generated code from for a Model block. This technique can be used to eliminate unnecessary copies of variables from input ports to output ports. This can lead to more efficient code.<\/div>\r\n

The Model<\/h2>\r\n
Let's say we have a model that operates on its bus argument. The input and output to this model have the same bus type, which for this demonstration includes elements, b1<\/span>, a boolean, and d1<\/span>, a double. In principle, these are two of many elements. Pressing CTRL+B generates code for the model.<\/div>\r\n
\"ModelSnapshot.png\"<\/div>\r\n

The Code<\/h2>\r\n
The model modifies the value of d1<\/span> on the bus based on the value of b1<\/span>. If we generate code from this model, we get the following step function:<\/div>\r\n
\r\n
void A_step(my_bus *arg_in, my_bus *arg_out)<\/span><\/div>\r\n
{<\/span><\/div>\r\n
real_T tmp;<\/span><\/div>\r\n
*arg_out = *arg_in;<\/span><\/div>\r\n
if (arg_in->b1) {<\/span><\/div>\r\n
tmp = -2.5;<\/span><\/div>\r\n
} else {<\/span><\/div>\r\n
tmp = 2.5;<\/span><\/div>\r\n
}<\/span><\/div>\r\n
<\/div>\r\n
arg_out->d1 = tmp + arg_in->d1;<\/span><\/div>\r\n
}<\/span><\/div>\r\n<\/div>\r\n
Notice that the step function has two arguments, arg_In1<\/span> and arg_Out1<\/span>, and on line 4, the code copies the input to the ouput. If this were a large bus, the copy could be quite expensive, so we'd like to eliminate it.<\/div>\r\n

A More Efficient Code<\/h2>\r\n
In order to eliminate the copy, we can open the Code Mappings<\/a> panel with CTRL+SHIFT+C and go to the Functions tab. Once there, click on the A_step hyperlink in the Function Preview column.<\/div>\r\n
\"CodeMappingsPanel.png\"<\/div>\r\n
The hyperlink will open a new window which will allow us to configure the C step function interface<\/a> for our model.<\/div>\r\n
\"StepConfig.png\"<\/div>\r\n
To make our argument shared, we make sure the Configure arguments for Step function prototype is checked and then set the C Identifier Name for the input and output ports to the same value. In our case, let's call it arg_shared<\/span>. When we re-generate code, we get:<\/div>\r\n
\r\n
void A_step(my_bus *arg_shared)<\/span><\/div>\r\n
{<\/span><\/div>\r\n
real_T tmp;<\/span><\/div>\r\n
if (arg_shared->b1) {<\/span><\/div>\r\n
tmp = -2.5;<\/span><\/div>\r\n
} else {<\/span><\/div>\r\n
tmp = 2.5;<\/span><\/div>\r\n
}<\/span><\/div>\r\n
<\/div>\r\n
arg_shared->d1 += tmp;<\/span><\/div>\r\n
}<\/span><\/div>\r\n<\/div>\r\n
Notice that there is only a single argument to the step function and the copy is elimiated, which leads to much more efficient code.<\/div>\r\n

Now It's Your Turn<\/h2>\r\n
How are you avoiding unwanted copies in your generated code? What kinds of improvements to generated code efficiency would you find helpful?<\/div>\r\n
<\/div>\r\n
<\/div>\r\n
<\/div>\r\n<\/div>\r\n