{"id":10376,"date":"2021-03-26T16:08:22","date_gmt":"2021-03-26T20:08:22","guid":{"rendered":"https:\/\/blogs.mathworks.com\/simulink\/?p=10376"},"modified":"2021-04-07T09:23:15","modified_gmt":"2021-04-07T13:23:15","slug":"linking-c-mex-s-function-to-c-code","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/simulink\/2021\/03\/26\/linking-c-mex-s-function-to-c-code\/","title":{"rendered":"Linking C MEX S-Function to C++ Code"},"content":{"rendered":"
Today, I am happy to welcome guest blogger <\/span>Navid Rahbariasr<\/span><\/a>. Navid recently received a request from a user trying to include C++ code in a referenced model in accelerator mode. Unfortunately, this user was forced to use MATLAB R2020b and was not able to take advantage of the new <\/span>C++ support for model reference simulation target<\/span><\/a> added in MATLAB R2021a. Here is the workaround Navid came up with.<\/span><\/div>
--Guy<\/span><\/div>

Configuring the S-Function Builder to include C++ Code<\/span><\/h3>
Let's start with a simple example where our S-Function is calling a method <\/span>get_a<\/span> defined in custom C++ source code. The header and the source code for the custom C++ code are as follows:<\/span><\/div>
\"\"<\/img><\/div>
\"\"<\/img><\/div>
Note that \"::\" is a C++ operator. It is called the <\/span>scope resolution operator<\/span><\/a> and can be used to access a global variable when there is a local variable with the same name. So, in this example we have a global variable named <\/span>a<\/span>, and a local variable with the same name inside the method. By adding :: in front of <\/span>a<\/span> we indicate our interest in the global variable <\/span>a<\/span>, which in this example has the value of 2. This operator :: is not defined in C, so if you try to compile this code in C, you will get a syntax error.<\/span><\/div>
Now we use the <\/span>S-Function Builder<\/span><\/a> to create an S-function that calls the <\/span>get_a <\/span>function and routes the value to output. In case you did not notice, the S-Function Builder has been entirely revamped in R2020b, allowing you to see the final S-Function code interactively.<\/span><\/div>
We include the custom header in the includes section of the S-Function Builder as shown below:<\/span><\/div>
\"\"<\/img><\/div>
We call the method <\/span>get_a<\/span> in the S-function outputs wrapper function and assign it to the output of the S-Function block:<\/span><\/div>
\"\"<\/img><\/div>
We add the C++ source code as a library entry so that S-Function can call the method defined in it. You can find the library entry at the bottom of the S-function Builder interface:<\/span><\/div>
\"\"<\/img><\/div>
And finally, we build the S-Function: <\/span><\/div>
\"\"<\/img><\/div>
Note that we have set the Language of the S-Function to C++. If we set it to C, we will get an error that method <\/span>get_a<\/span> is unresolved:<\/span><\/div>
\"\"<\/img><\/div>
By setting the language to C++, the S-function is built. Now if we run the model and check the output, we see the output is 2, the value of the global variable <\/span>a<\/span>:<\/span><\/div>
\"\"<\/img><\/div>

Referencing the Model<\/span><\/h3>
If we reference the above model in normal mode, we will get the expected value of 2.<\/span><\/div>
\"\"<\/img><\/div>
However, if we set the model block into accelerator mode and try to run the model, we see an error about an unresolved external symbol that looks quite similar to the one shown above when the S-Function Builder language was set to C instead of C++:<\/span><\/div>
\"\"<\/img><\/div>
The error suggests that Simulink cannot find the <\/span>sfcn_test_wrapper.c<\/span> and <\/span>custom_code.c -- <\/span>which is accurate because these files have cpp extension rather than c! This is happening because the Simulink engine is first generating a simulation target for the reference model in accelerator mode whose language is C, and thus it is interpreting the symbols as C rather than C++, therefore the accelerator mode build cannot correctly link with the S-Function.<\/span><\/div>
\"graphical_issue.png\"<\/img><\/div>
This was a limitation of the simulation target in Simulink until R2021a, when <\/span>C++ support for model reference simulation target<\/span><\/a> <\/span>has been added.<\/span><\/div>

Workaround<\/span><\/h3>
If we want the accelerated referenced model to build successfully, we need to write the S-Functions in C, but our source code is using C++ features, so how we can write the S-Function in C? <\/span><\/div>
The trick is to link the S-function to the compiled version of the source code, so the compiler does not need to recompile it (it is like grinding the C++ food for the C compiler that does not have the right teeth to chew it!) But can C-code call compiled C++ methods? The answer is yes, provided we wrap the C++ declaration methods with <\/span>extern C {}<\/span>, so that the compiler uses C naming conventions when compiling the methods.<\/span><\/div>
We first modify our custom header file as below by wrapping the method with extern C:<\/span><\/div>
\"\"<\/img><\/div>
Note that <\/span>#ifdef __cplusplus<\/span> is a compiler directive. It effectively means \"if the language is C++...\". When we compile the source code, as the compiler detects it is C++ it wraps the method declaration with <\/span>extern \"C\" { }<\/span> so the compiled object will have C naming schemes. <\/span><\/div>
Now we compile the source code into an object file by using mex with -c flag:<\/span><\/div>
mex -c custom_source.cpp<\/span><\/div>
By running this command, you will get an object file <\/span>custom_code.obj <\/span>in the folder which contains the compiled version of the <\/span>custom_source.cpp<\/span>:<\/span><\/div>
\"\"<\/img><\/div>
Now we go to the S-Function builder and modify two things:<\/span><\/div>
1) Change the language to C<\/span><\/div>
2) Link the S-function to the compiled obj file rather than the uncompiled source file (Surprise! You can link the S-Function to obj files!)<\/span><\/div>
\"\"<\/img><\/div>
As we are linking the S-Function to a compiled C++ code rather than uncompiled C++ code, the S-Function can be built using the C language.<\/span><\/div>
Now if we go to the top model and run the model in accelerated mode, it will build the simulation target successfully and we will get the expected output of 2:<\/span><\/div>
\"\"<\/img><\/div>
Basically, we were able to link the accelerator build which only understands C language to the C MEX S-function and the compiled C++ obj file:<\/span><\/div>
\"graphical_wrkarnd.png\"<\/img><\/div>

C++ support for model reference simulation target in R2021a<\/span><\/h3>
The above workaround is useful for older releases. In R2021a, if your model includes C++ S-Functions, you can simply set the <\/span>Language<\/span><\/a> to C++ in the Simulation Target section of the configuration set, which will allow the accelerator build to understand the C++ language and interpret the C++ S-Function correctly.<\/span><\/div>
\"\"<\/img><\/div>
and everything is built using C++:<\/span><\/div>
\"\"<\/img><\/div>

Now it's your turn<\/span><\/h3>
Let us know in the comments below if the addition of <\/span>C++ support for model reference simulation target<\/span><\/a> added in MATLAB R2021a opens new possibilities for you.<\/span><\/div>\r\n<\/div>