Real-Time Workshop

Acceptance or Denial of Requests for
Input Expressions

A block can request that its output be represented in code as an expression. Such a request may be denied if the destination block cannot accept expressions at its input port. Furthermore, conditions independent of the requesting block and its destination block(s) can prevent acceptance of expressions.

In this section, we will discuss block-specific conditions under which requests for input expressions are denied. For information on other conditions that prevent acceptance of expressions, see Generic Conditions for Denial of Requests to Output Expressions.

A block should not be configured to accept expressions at its input port under the following conditions:

• The block must take the address of its input data. It is not possible to take the address of most types of input expressions.
• The code generated for the block will reference the input more than once (e.g. the Abs or Max blocks). This would lead to duplication of a potentially complex expression and a subsequent degradation of code efficiency.

If a block refuses to accept expressions at an input port, then no block that is connected to that input port is permitted to output a generic or trivial expression.

A request to output a constant expression is never denied, because there is no performance penalty for a constant expression, and it is always possible to take the parameter's address.

Example: Acceptance and Denial of Expressions at Block Inputs

This example illustrates how various built-in blocks handle requests to accept different categories of expressions at their inputs.

The sample model of Figure 9-5 contains:

• Two Gain blocks. Gain blocks request their destination blocks to accept generic expressions.
• An Abs block. This block always denies expressions at its input port. The Abs block code uses the macro rt_ABS(u), which evaluates the input u twice. (see the TLC implementation of the Abs block in
  matlabroot/rtw/c/tlc/blocks/absval.tlc.)
• A Trigonometric Function block. This block accepts expressions at its input port.

Figure 9-5: Two Gain Blocks Requesting to Output an Expression

The Gain1 block's request to output an expression is denied by the Abs block. The Gain2 block's request to output an expression is accepted by the Trigonometric Function block.

The generated code is shown in the code excerpt below. Note that the output of the Gain1 block is stored in the temporary variable rtb_Gain1, rather than generating an input expression to the Abs block.

• void MdlOutputs(int_T tid)
  {
  /* local block i/o variables */
  real_T rtb_Gain1;
  
  /* Gain: '<Root>/Gain1' incorporates:
   *   Inport: '<Root>/In1'
   *
   * Regarding '<Root>/Gain':
   *   Gain value: 2.0
   */
  rtb_Gain1 = rtU.In1 * 2.0;
  
  /* Outport: '<Root>/Out1' incorporates:
   *   Abs: '<Root>/Abs'
   */
  rtY.Out1 = rt_ABS(rtb_Gain1);
  
  /* Outport: '<Root>/Out2' incorporates:
   *   Trigonometry: '<Root>/Trigonometric Function'
   *   Gain: '<Root>/Gain2'
   *   Inport: '<Root>/In2'
   *
   * Regarding '<Root>/Gain2':
   *   Gain value: 2.0
   */
  rtY.Out2 = sin((2.0 * rtU.In2));
  }
  

Using the S-Function API to Specify Input Expression Acceptance

The S-Function API provides macros that let you:

• Specify whether a block input should accept non-constant expressions (i.e. trivial or generic expressions).
• Query whether a block input accepts non-constant expressions.

By default, block inputs do not accept non-constant expressions.

You should call the macros in your mdlSetWorkWidths function. The macros have the following arguments:

• SimStruct *S: pointer to the block's SimStruct.
• int idx: zero-based index of the input port.
• bool value: pass in TRUE if the port accepts input expressions; otherwise pass in FALSE.

The macro available for specifying whether or not a block input should accept a non-constant expression is as follows:

• void ssSetInputPortAcceptExprInRTW(SimStruct *S, int portIdx, bool value)
  
  

The corresponding macro available for querying the status set by any prior calls to ssSetInputPortAcceptExprInRTW is as follows:

• bool ssGetInputPortAcceptExprInRTW(SimStruct *S, int portIdx)
  

Generic Conditions for Denial of Requests to Output Expressions

Even after a specific block requests that it be allowed to generate an output expression, that request may be denied, for generic reasons. These reasons include, but are not limited to:

• The output expression is non-trivial, and the output has multiple destinations
• The output expression is non-constant, and the output is connected to at least one destination that does not accept expressions at its input port
• The output is a test point
• The output has been assigned an external storage class
• The output must be stored using global data (e.g. is an input to a merge block, or a block with states)
• The output signal is complex

You do not need to consider these generic factors when deciding whether or not to utilize expression folding for a particular block. However, these rules may be helpful when examining generated code, and analyzing cases where the expression folding optimization is suppressed.

Categories of Output Expressions

Utilizing Expression Folding in Your TLC Block Implementation