View and Compare Code Execution Times

You run a software-in-the-loop (SIL) or processor-in-the-loop (PIL) simulation that produces execution-time metrics for tasks and functions in your generated code. During the simulation, you can use the Simulation Data Inspector to observe streamed execution times. At the end of the simulation, you can:

• View execution-time metrics for a profiled model component.

• Open a report of execution-time metrics for all profiled components. Through report icons, you can view, for example, the profiled code section and the execution-time distribution for each profiled function.

• Use the Simulation Data Inspector to plot and compare execution times from various simulations.

Run SIL Simulation That Generates Execution-Time Metrics

Open the rtwdemo_sil_topmodel model, which has two subsystems CounterTypeA and CounterTypeB. At the command line, type rtwdemo_sil_topmodel.

To run a SIL simulation that generates execution-time metrics, on the SIL/PIL tab:

1. In the Mode section, select SIL/PIL Simulation Only.

2. In the Prepare section, specify these settings:

   1. System Under Test — Top model

   2. SIL/PIL Mode — Software-in-the-Loop (SIL)

3. To measure code execution times for the subsystems, in the Prepare section:

   1. Click Settings.

   2. Under Profiling:

      • Click the Task Profiling button on. This action selects the Measure task execution time configuration parameter, which provides execution-time metrics for the task generated from the top model rtwdemo_sil_topmodel.

      • Click the Save Options button until it displays ALL DATA. This action sets the Save options configuration parameter to All data.

      • Click the Functions button until it displays COARSE. This action sets the Measure function execution times configuration parameter to Coarse (referenced models and subsystems only), which provides execution-time metrics for the functions generated from the subsystems CounterTypeA and CounterTypeB.

   3. Under Coverage, click the Coverage Collection button off, which disables code coverage analysis. You collect code coverage data separately from profiling data.

   4. Click the Settings button to open the Configuration Parameters dialog box. On the Data Import/Export pane, clear Single simulation output.

4. To view streamed execution times during the simulation, open the Simulation Data Inspector. In the Results section, click .

5. In the Run section, click Run SIL/PIL.

In the MATLAB^® base workspace, the simulation generates a variable with the default name, executionProfile, which stores the execution profiling data. You can specify an alternative name through the Workspace variable configuration parameter.

Note

If the Data Import/Export > Single simulation output check box is selected, the simulation creates the variable in your specified Simulink.SimulationOutput object.

When the simulation is complete, the profiled model components are colored blue and the Code view displays the generated code. To view execution-time metrics for a profiled component, click the component. For example, subsystem CounterTypeB.

For top-model SIL or PIL simulations, the Simulink^® Editor background is also colored blue. When you click the background, the display window shows execution-time metrics for top-model tasks.

You can trace from a model component to the profiled code section in the Code view. In the Profiling display window, on a code section row, click the icon . For example, if you click the model background and then click the icon for the rtwdemo_sil_topmodel_initialize task, you see the measurement probes around the call site in the SIL application. To see the profiling metrics for the component, place your cursor on the call site.

If you click the icon for a function, the call site is highlighted. The Code view displays the average execution time and number of function calls to the left of the code line. In this example, the maximum and average times are the same because the initialization function was called only one time.

The Profiling display window also has links to:

• The complete profiling report, which provides execution-time metrics for all profiled code sections.

• The Simulation Data Inspector, which allows you to plot and compare execution-time measurements for the profiled code section.

• The execution-time distribution for the profiled code section.

• Pie charts that show the relative execution times of caller and called functions

If you close the model or display window, you can reopen the colored model and display window with this line command:

annotate(executionProfile)

Code Execution Profiling Report Sections

At the end of the simulation, you can open the report through the Profiling display window or by using this line command:

report(executionProfile)

The report contains these sections:

1.  Summary

   This section gives information about the creation of the report.

   

2.  Feasibility Checks

   If the number of timer ticks per second is known, the simulation performs feasibility checks and displays results in this section. The checks are shown in this table.

   Check	Comments
   Overall average CPU utilization lower than threshold	The default threshold value is 70%. To change the threshold value, for example, to 85%, use this command: executionProfile.CPUUtilization=0.85; For information about CPU utilization, see section 5.
   Overall maximum CPU utilization lower than threshold
   All average execution times are shorter than their task period	Use the results of these checks to verify that task overrun does not occur.
   All maximum execution times are shorter than their task period

   In the Results column, the report displays Passed or Failed.

   

3.  Profiled Sections of Code

   This section contains information about profiled code sections. In the Section column, expand and collapse profiled sections by clicking [+] and [–] respectively. This graphic shows fully expanded sections.

   

   In this example, the report contains time measurements for:

   • The model initialization function initialize.

   • A task represented by the step function step [0.1 0].

   • Functions generated from the subsystems CounterTypeA and CounterTypeB.

   From the report, you can trace the model component that produces a set of metrics. For example, in the Section column, if you click the CounterTypeA hyperlink, the Simulink Editor identifies the subsystem.

   

   By default, the report displays time in nanoseconds (10^-9 seconds). You can specify the time unit and numeric display format. For example, to display time in microseconds (10^-6 seconds), use the following command:

   report(executionProfile,...
            'Units', 'Seconds', ...
            'ScaleFactor', '1e-06', ...
            'NumericFormat', '%0.3f')

   The report displays time in seconds only if the timer is calibrated, that is, the number of timer ticks per second is known. On a Windows^® machine, the software determines this value for a SIL simulation. On a Linux^® machine, calibrate the timer manually. For example, if your processor speed is 1 GHz, specify the number of timer ticks per second:

   executionProfile.TimerTicksPerSecond = 1e9;
   

   To view execution-time metrics for a task or function in the Command Window, on the corresponding row, click .

   >> executionProfile.Sections(5)
     ExecutionTimeCodeSection with properties:
   
                               Name: 'CounterTypeA'
                             Number: 5
               ExecutionTimeInTicks: [122 102 100 86 88 88 88 86 88 88 156 122  … ]
                    SelfTimeInTicks: [122 102 100 86 88 88 88 86 88 88 156 122  … ]
              TurnaroundTimeInTicks: [122 102 100 86 88 88 88 86 88 88 156 122  … ]
          TotalExecutionTimeInTicks: 19436
               TotalSelfTimeInTicks: 19436
         TotalTurnaroundTimeInTicks: 19436
        MaximumExecutionTimeInTicks: 1270
        MaximumExecutionTimeCallNum: 27
             MaximumSelfTimeInTicks: 1270
             MaximumSelfTimeCallNum: 27
       MaximumTurnaroundTimeInTicks: 1270
       MaximumTurnaroundTimeCallNum: 27
                           NumCalls: 101
             ExecutionTimeInSeconds: [3.3889e-08 2.8333e-08 2.7778e-08 2.3889e-08 … ]
                               Time: [101×1 double]

   To display measured execution times in the Simulation Data Inspector, click the icon . Use the Simulation Data Inspector to manage and compare plots from various simulations.

   To display the execution-time distribution, click the icon .

   

   In this example, to create the histogram, the software uses these commands:

   section=executionProfile.Sections(5);
   data=section.ExecutionTimeInSeconds;
   histogram(data, 30,'Normalization','probability');

   The software creates the histogram only if the number of calls is greater than one.

   If the generated code for your model contains nested functions, the simulation generates pie charts that show the relative execution times of caller and called functions. To display the pie charts, click the icon for the caller function. For example, step [0.1 0].

   

   The pie charts, which display average and maximum execution time distributions, can help you to identify functions that are bottlenecks in code execution.

   This table describes the information that Profiled Sections of Code provides.

   Column	Description
   Section	Name of task, top model, subsystem, or Model block. Click the link to go to the model. With a task, the sample period and sample offset are listed next to the task name. For example, rtwdemo_sil_topmodel_step [0.1 0] indicates that the sample period is 0.1 seconds and the sample offset is 0.
   Maximum Turnaround Time (Simulink Real-Time™ and support packages in real-time mode)	Longest time between start and end of code section. Includes preemption time.
   Average Turnaround Time (Simulink Real-Time and support packages in real-time mode)	Average time between start and end of code section. Includes preemption time.
   Maximum Execution Time	Longest time between start and end of code section.
   Average Execution Time	Average time between start and end of code section.
   Maximum Self Time	Maximum execution time, excluding time in child sections.
   Average Self Time	Average execution time, excluding time in child sections.
   Calls	Number of calls to the code section.
   	Icon that you click to see the profiled code section in the Code view of the SIL/PIL app. The code section can be a task or a function. The specified workspace variable, for example, executionProfile, must be present in the base workspace.
   	Icon that you click to display the profiled code section in the Command Window. Equivalent to executing the command executionProfile.Sections(i). The specified workspace variable, for example, executionProfile, must be present in the base workspace.
   	Icon that you click to display measured execution times with Simulation Data Inspector. The specified workspace variable, for example, executionProfile, must be present in the base workspace.
   	Icon that you click to display the execution-time distribution for the profiled code section. The specified workspace variable, for example, executionProfile, must be present in the base workspace.
   	Icon that you click to display pie charts that show the relative execution times of caller and called functions in the generated code.

4.  Execution Times in Percentages

   This section provides function execution times as percentages of caller function and total execution times, which can help you to identify performance bottlenecks in generated code.

   

   This table describes the information that each column provides.

   Column	Comparison Performed
   Self Time / Caller Function	Function self time compared with the total execution time of the caller function.
   Self Time / Task	Function self time compared with the total execution time of the task.
   Self Time / Simulation	Function self time compared with the total execution time of the simulation.
   Function / Simulation	Function execution time, which includes self time and time spent in child functions, compared with the total execution time of the simulation.

5.  CPU Utilization

   To help you to decide whether you can run the generated code on your target hardware, this section of the code execution profiling report provides CPU workload information:

   • Average and maximum CPU time required by each task during a sample period.

   • Total CPU usage in a sample period.

   The software computes the percentage of CPU time assigned to a task by dividing task execution time by sample time.

   

   The software generates CPU Utilization only if the number of timer ticks per second is known.

6.  Definitions

   This section provides descriptions of some metrics.

   

View Code Execution Profiles for Multiple Model Blocks

You can configure a top-model simulation that runs multiple Model blocks in SIL or PIL mode with code execution profiling enabled. When you run the simulation, it generates separate code execution profiling reports for the referenced models.

1. Open the top model that contains Model blocks. For example, at the command line, type rtwdemo_sil_modelblock.

2. On the SIL/PIL tab, in the Mode section, specify SIL/PIL Simulation Only.

3. In the Prepare section, specify these settings:

   • System Under Test –– Model blocks in SIL/PIL mode

   • Top Model Mode –– Normal

4. Model block Counter A is already configured to run in SIL mode. For Model block Counter B, set the block parameter Simulation mode to Software-in-the-loop (SIL).

5. Both Model blocks reference the model rtwdemo_sil_counter. To generate execution times for the Model blocks:

   1. Select CounterA or CounterB.

   2. On the Model Block tab, in the Actions section, click Open as Top Model.

   3. On the SIL/PIL tab, in the Settings gallery, click Functions to COARSE, which sets the Measure function execution times configuration parameter for rtwdemo_sil_counter to Coarse (referenced models and subsystems only).

6. To run a top-model simulation:

   1. Select the rtwdemo_sil_modelblock window.

   2. On the SIL/PIL tab, in the Run section, click Run SIL/PIL.

   Since the Single simulation output check box is selected, the simulation creates the variable executionProfile in out, a Simulink.SimulationOutput object.

7. When the simulation is complete, to show the number of Model blocks that are profiled, in the Command Window, enter:

   NumOfReports=out.executionProfile.getModuleNumber()

   NumOfReports =
        2

8. To open the report for CounterA, the first Model block, run:

   report(out.executionProfile.getModule(1))

   

9. In the Summary section, the report provides a link to the second Model block report. To open the report for CounterB, click Open report or run:

   report(out.executionProfile.getModule(2))

For more information about generating function execution times for model reference hierarchies, see Control Profiling Granularity.

Compare Code Execution-Time Performance Against Baseline

You can create a code execution profiling report that compares the performance of the generated code against the performance of a reference version. For example, suppose you want to use the current execution-time metrics in executionProfile as the baseline for rtwdemo_sil_topmodel.

1. In the Workspace browser, rename executionProfile to executionProfileBaseline.

2. Run another SIL simulation.

3. To create a report that compares the latest performance against the baseline, in the Command Window, run:

   report(executionProfile,'baseline', executionProfileBaseline)

In the report, the Comparison with Baseline Performance and CPU Utilization sections provide comparisons of execution-time metrics. The differences in execution-time metrics are color-coded:

• Red — An increase in execution times or CPU usage.

• Green — A decrease in execution times or CPU usage.

• Black — No change.

Visualize Task Scheduling

You can use the Simulation Data Inspector to visualize task scheduling and the order of function calls. At the end of the simulation, perform one of these actions:

• Run the schedule function. For details, see Visualize Task Scheduling

• From the SIL/PIL tab, in the Results gallery, click Generate Schedule. For more information, see Analyze Results and Export Test Cases.