Main Content

Comparing Performance

When simulation execution time exceeds the time required for code generation, accelerator and rapid accelerator simulation modes give speed improvement compared to normal mode. Accelerator and rapid accelerator modes generally perform better than normal mode when simulation execution times are several minutes or more. However, models with a significant number of Stateflow® or MATLAB Function blocks might show only a small speed improvement over normal mode because these blocks also simulate through code generation in normal mode.

Including tunable parameters in your model can also increase the simulation time.

The figure shows the relative performance of normal mode, accelerator mode, and rapid accelerator mode simulations in general terms for a hypothetical model.

Performance When Target Must Be Rebuilt

The solid lines, labeled all targets out of date, in the figure show performance when the target code must be rebuilt. For this hypothetical model, the time scale is on the order of minutes. However, the time scale could be longer for more complex models.

Compiling a model in normal mode generally requires less time than building the accelerator target or the rapid accelerator executable. For small simulation stop times, normal mode results in quicker overall simulations compared to the accelerator and rapid accelerator modes.

The crossover point where accelerator mode or rapid accelerator mode results in faster overall simulation depends on the complexity and content of your model. For example, models that contain large numbers of blocks that use interpreted code might not run much faster in accelerator mode than they would in normal mode unless the simulation stop time is very large. For more information, see Select Blocks for Accelerator Mode. Similarly, models with a large number of Stateflow charts or MATLAB Function blocks might not show much speed improvement over normal mode unless the simulation stop time is large. You can speed up the simulation of models with Stateflow or MATLAB Function blocks through code generation.

The figure represents a model with a large number of Stateflow charts or MATLAB Function blocks. The curve labeled Normal would have a much smaller initial elapsed time than shown if the model did not contain these blocks.

Performance When Targets Are Up to Date

The dashed lines, labeled all targets up to date, in the figure show that the time to determine whether the accelerator target or the rapid accelerator executable is up to date is significantly smaller than the time required to generate code, which is represented by the solid lines, labeled all targets out of date. You can take advantage of this characteristic when you wish to test various design tradeoffs.

For instance, you can generate the accelerator mode target once and use it to simulate your model with a series of gain settings. This method is especially efficient for the accelerator or rapid accelerator modes because this type of change does not result in the target code being regenerated. The target code is generated the first time the model runs, but on subsequent runs, the software spends only the time necessary to verify that the target is up to date. This process is much faster than generating code, so subsequent runs can be significantly faster than the initial run.

Because checking the targets is quicker than code generation, the crossover point is smaller when the target is up to date than when code must be generated. Subsequent runs of your model might simulate faster in accelerator or rapid accelerator mode when compared to normal mode, even for small stop times.

Analyze Performance of Simulation Modes

To see the effect of using accelerator or rapid accelerator mode for simulations of your model, you can run equivalent simulations using different simulation modes and inspect the timing information captured in the simulation metadata.

This example uses the model sldemo_fuelsys. For more information about the model, see Modeling a Fault-Tolerant Fuel Control System.

model = "sldemo_fuelsys";

To configure the baseline simulation, create a Simulink.SimulationInput object. Set the stop time to 10000.

simIn = Simulink.SimulationInput(model);
simIn = setModelParameter(simIn,"StopTime","10000");

To capture baseline timing information, simulate the model using normal mode.

simOut = sim(simIn);

The Simulink.SimulationOutput object contains a Simulink.SimulationMetadata object with information about the simulation, including a structure of timing information, TimingInfo.

normalMode = simOut.SimulationMetadata.TimingInfo;

From the timing information, extract the initialization time, execution time, and total elapsed time for the simulation.

normalInit = normalMode.InitializationElapsedWallTime;
normalExec = normalMode.ExecutionElapsedWallTime;
normalTotal = normalMode.TotalElapsedWallTime;

Simulate the model again using rapid accelerator mode. The first time you simulate a model in rapid accelerator mode, the rapid accelerator target builds during the initialization phase.

simIn = setModelParameter(simIn,"SimulationMode","rapid");
simOut = sim(simIn);
### Building the rapid accelerator target for model: sldemo_fuelsys
### Successfully built the rapid accelerator target for model: sldemo_fuelsys

Build Summary

Top model rapid accelerator targets built:

Model           Action                       Rebuild Reason                                    
===============================================================================================
sldemo_fuelsys  Code generated and compiled  Code generation information file does not exist.  

1 of 1 models built (0 models already up to date)
Build duration: 0h 0m 48.581s

Access the timing information for the first rapid accelerator simulation. Then, extract the initialization time, execution time, and total elapsed time for the simulation.

rapidAccel = simOut.SimulationMetadata.TimingInfo;
rapidBuildInit = rapidAccel.InitializationElapsedWallTime;
rapidBuildExec = rapidAccel.ExecutionElapsedWallTime;
rapidBuildTotal = rapidAccel.TotalElapsedWallTime;

Simulate again to see the benefit of rapid accelerator mode for a simulation that does not build the rapid accelerator target.

simOut = sim(simIn);
Build Summary

0 of 1 models built (1 models already up to date)
Build duration: 0h 0m 1.7911s

Access the timing information for the rapid accelerator simulation that ran without building the target. Then, extract the initialization time, the execution time, and the total elapsed time for the simulation.

rapidAccelNoRebuild = simOut.SimulationMetadata.TimingInfo;
rapidInit = rapidAccelNoRebuild.InitializationElapsedWallTime;
rapidExec = rapidAccelNoRebuild.ExecutionElapsedWallTime;
rapidTotal = rapidAccelNoRebuild.TotalElapsedWallTime;

Build a table to compare the timing for each simulation.

InitializationTime = [normalInit;rapidBuildInit;rapidInit];
ExecutionTime = [normalExec;rapidBuildExec;rapidExec];
TotalSimulationTime = [normalTotal;rapidBuildTotal;rapidTotal];

simNames = ["Normal Mode";"Rapid Accelerator";"Rapid Accelerator No Rebuild"];
timingTable = table(TotalSimulationTime,InitializationTime, ...
    ExecutionTime,RowNames=simNames);

In the first rapid accelerator simulation, the initialization time increases because the rapid accelerator target builds during the initialization phase. For this model and simulation duration, using rapid accelerator mode reduces the execution time so much that the first rapid accelerator simulation is still faster than using normal mode.

timingTable
timingTable=3×3 table
                                    TotalSimulationTime    InitializationTime    ExecutionTime
                                    ___________________    __________________    _____________

    Normal Mode                           92.268                 5.8193             86.356    
    Rapid Accelerator                     61.405                 50.257             10.895    
    Rapid Accelerator No Rebuild          12.662                 2.2544              10.33    

Related Topics