{"id":9692,"date":"2018-05-04T08:50:09","date_gmt":"2018-05-04T12:50:09","guid":{"rendered":"https:\/\/blogs.mathworks.com\/pick\/?p=9692"},"modified":"2018-05-04T09:20:22","modified_gmt":"2018-05-04T13:20:22","slug":"persistent-data-for-lookup-tables-in-simulink","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/pick\/2018\/05\/04\/persistent-data-for-lookup-tables-in-simulink\/","title":{"rendered":"Persistent Data for Lookup Tables in Simulink"},"content":{"rendered":"
\n <\/p>\n

Richard is a Consultant at MathWorks focused on Model Based Design, primarily in the Aerospace and Defense industry.<\/i><\/p>\n

Richard’s<\/a> pick this week is Persistent Data for Lookup Tables in Simulink<\/a> by Jason Nicholson<\/a>.\n <\/p>\n

<\/introduction><\/p>\n

Pick<\/a><\/h3>\n

My pick this week is Persistent Data for Lookup Tables in Simulink<\/a> – a method to speed up simulations that use large lookup tables.\n <\/p>\n

As systems become more and more complex, the need for simulation increases. Simulation provides insight into the behavior
\n and performance of the system. However, as systems become more complex, the level of fidelity needed in a simulation also
\n increases, which often increases the time it takes for the simulation to run. This in turn slows the development process.\n <\/p>\n

Persistent Data for Lookup Tables in Simulink addresses a specific issue related to simulation performance – as noted in the
\n File Exchange entry: “Loading large lookup tables in Simulink models can be the bottle neck for the simulation speed. This is more important when
\n you cannot load a lookup table into the base workspace or model workspace when you build a Simulink library. When you don’t
\n know how the library will be used, loading data into the base or model workspace can cause problems and thus it is bad practice
\n to do so. This set of files shows how to load a lookup table in the mask initialization of a subsystem block and then save
\n it to UserData. On subsequent runs, the data stored in UserData is used for the lookup table. The speed up is 10-50x.”<\/i><\/p>\n

<\/p>\n

It should be noted that this approach is only valid when running multiple simulations of a Simulink model.<\/p>\n

The download from the File Exchange contains two Simulink models, a Simulink library containing the two implementations of
\n the masked Lookup Table block (with and without persistent data), and a script that describes the application.\n <\/p>\n

To test this, I extracted and ran the simulation execution code provided in RunSimulations<\/tt>.\n <\/p>\n

\r\nNUMBER_OF_TIMING_RUNS = 10;\r\nRUN_MODES = {'Normal'<\/span>, 'Accelerator'<\/span>};\r\nMODEL_1 = 'withoutPersistentLoading'<\/span>;\r\nMODEL_2 = 'withPersistentLoading'<\/span>;\r\nmodels = {MODEL_1, MODEL_2};\r\n\r\n% models = {'FastRestartTest'};<\/span>\r\n\r\n% loop over the run modes<\/span>\r\nfor<\/span> iMode = 1:length(RUN_MODES)\r\n    for<\/span> iModel = 1:length(models)\r\n        memoryBeforeRun = nan(NUMBER_OF_TIMING_RUNS, 1);\r\n        memoryAfterRun = nan(NUMBER_OF_TIMING_RUNS, 1);\r\n        load_system(models{iModel});\r\n        for<\/span> iSim = 1:NUMBER_OF_TIMING_RUNS\r\n            memoryBeforeRun(iSim) = getfield(memory, 'MemUsedMATLAB'<\/span>)\/1024^2;\r\n            simOut = sim(models{iModel}, 'SimulationMode'<\/span>, RUN_MODES{iMode});\r\n            if<\/span> iSim == 1\r\n                TimingInfo = simOut.SimulationMetadata.TimingInfo;\r\n            else<\/span>\r\n                TimingInfo(iSim) = simOut.SimulationMetadata.TimingInfo;\r\n            end<\/span>\r\n            memoryAfterRun(iSim) = getfield(memory, 'MemUsedMATLAB'<\/span>)\/1024^2;\r\n        end<\/span>\r\n        close_system(models{iModel});\r\n        \r\n        fprintf('Model \"%s\", in \"%s\" mode:\\n'<\/span>, models{iModel}, RUN_MODES{iMode})\r\n        outputTable = table(memoryBeforeRun, memoryAfterRun, ...<\/span>\r\n            vertcat(TimingInfo.InitializationElapsedWallTime), ...<\/span>\r\n            vertcat(TimingInfo.ExecutionElapsedWallTime), ...<\/span>\r\n            vertcat(TimingInfo.TerminationElapsedWallTime), ...<\/span>\r\n            vertcat(TimingInfo.TotalElapsedWallTime), ...<\/span>\r\n            'VariableNames'<\/span>, ...<\/span>\r\n            {'memoryBefore'<\/span>, 'memoryAfter'<\/span>, 'initializationTime'<\/span>, ...<\/span>\r\n            'executionTime'<\/span>, 'terminationTime'<\/span>, 'totalElapsedTime'<\/span>});\r\n        outputTable.Properties.VariableUnits = {'MB'<\/span>, 'MB'<\/span>, 'sec'<\/span>, 'sec'<\/span>, 'sec'<\/span>,'sec'<\/span>};\r\n        disp(outputTable)\r\n        fprintf('mean Initialization time = %g\\n'<\/span>, mean(outputTable.initializationTime));\r\n        fprintf('mean Total Elapsed time = %g\\n'<\/span>, mean(outputTable.totalElapsedTime));\r\n        fprintf('subsequent runs mean Initialization time = %g\\n'<\/span>, mean(outputTable.initializationTime(2:end)));\r\n        fprintf('subsequent runs mean Total Elapsed time = %g\\n'<\/span>, mean(outputTable.totalElapsedTime(2:end)));\r\n        fprintf('\\n\\n\\n'<\/span>);\r\n    end<\/span>\r\nend<\/span>\r\n<\/pre>\n
The results are:<\/p>\n
RunSimulations<\/pre>\n
Model \"withoutPersistentLoading\", in \"Normal\" mode:\r\n    memoryBefore    memoryAfter    initializationTime    executionTime    terminationTime    totalElapsedTime\r\n    ____________    ___________    __________________    _____________    _______________    ________________\r\n       3972.2         3972.3             3.6936            0.000501          0.003477             3.6976     \r\n       3972.3         3972.3             3.6783            0.000385          0.002951             3.6817     \r\n       3972.3         3972.3             3.5621                   0           0.00351             3.5656     \r\n       3972.3         3972.2             3.5239                   0          0.003008             3.5269     \r\n       3972.2         3972.2             3.5635              0.0005          0.002925             3.5669     \r\n       3972.2         3972.2             3.5189              0.0005          0.003007             3.5224     \r\n       3972.2         3972.2             3.6783            0.000869          0.003016             3.6822     \r\n       3972.2         3972.2             4.2864                   0           0.00401             4.2904     \r\n       3972.2         3972.2             4.0488            0.000502          0.003008             4.0523     \r\n       3972.2         3972.2             4.0197            0.000501          0.003009             4.0232     \r\nmean Initialization time = 3.75736\r\nmean Total Elapsed time = 3.76093\r\nsubsequent runs mean Initialization time = 3.76444\r\nsubsequent runs mean Total Elapsed time = 3.76797\r\n\r\n\r\n\r\nModel \"withPersistentLoading\", in \"Normal\" mode:\r\n    memoryBefore    memoryAfter    initializationTime    executionTime    terminationTime    totalElapsedTime\r\n    ____________    ___________    __________________    _____________    _______________    ________________\r\n       3081.1         3972.1              3.4181           0.000494          0.003146              3.4217    \r\n       3972.1         3097.5             0.16842           0.001027          0.003958              0.1734    \r\n       3097.5         3097.5            0.053643                  0          0.003551            0.057194    \r\n       3097.5         3097.5            0.053183           0.000785           0.00251            0.056478    \r\n       3097.5         3097.5            0.053181           0.000463          0.003542            0.057186    \r\n       3097.5         3097.5            0.053642                  0          0.003364            0.057006    \r\n       3097.5         3097.5            0.055127           0.000463          0.003007            0.058597    \r\n       3097.5         3097.5            0.055593           0.000503          0.003005            0.059101    \r\n       3097.5         3097.5            0.051575           0.000501          0.003099            0.055175    \r\n       3097.5         3097.5            0.054585                  0           0.00305            0.057635    \r\nmean Initialization time = 0.401701\r\nmean Total Elapsed time = 0.405348\r\nsubsequent runs mean Initialization time = 0.0665499\r\nsubsequent runs mean Total Elapsed time = 0.0701974\r\n\r\n\r\n\r\nModel \"withoutPersistentLoading\", in \"Accelerator\" mode:\r\n    memoryBefore    memoryAfter    initializationTime    executionTime    terminationTime    totalElapsedTime\r\n    ____________    ___________    __________________    _____________    _______________    ________________\r\n       3081.1         3972.2             3.4136            0.000433          0.004012             3.4181     \r\n       3972.2         3972.2              3.479            0.000351           0.00447             3.4839     \r\n       3972.2         3972.2             3.5448            0.000357          0.004129             3.5493     \r\n       3972.2         3972.2             3.5329              0.0005           0.00401             3.5374     \r\n       3972.2         3972.2              3.584            0.000828          0.004224             3.5891     \r\n       3972.2         3972.2             3.5119            0.000367          0.004014             3.5163     \r\n       3972.2         3972.2             3.6458            0.000499           0.00438             3.6506     \r\n       3972.2         3972.2             3.5952            0.000969           0.00513             3.6013     \r\n       3972.2         3972.2             3.5499              0.0005          0.004259             3.5547     \r\n       3972.2         3972.2             4.6684            0.000501          0.009526             4.6784     \r\nmean Initialization time = 3.65256\r\nmean Total Elapsed time = 3.65791\r\nsubsequent runs mean Initialization time = 3.67911\r\nsubsequent runs mean Total Elapsed time = 3.68456\r\n\r\n\r\n\r\nModel \"withPersistentLoading\", in \"Accelerator\" mode:\r\n    memoryBefore    memoryAfter    initializationTime    executionTime    terminationTime    totalElapsedTime\r\n    ____________    ___________    __________________    _____________    _______________    ________________\r\n         3081         3972.2              4.0312           0.000501          0.004511             4.0362     \r\n       3972.2         3097.5             0.21853           0.000501          0.004513            0.22354     \r\n       3097.5         3097.5            0.098708           0.000501           0.00401            0.10322     \r\n       3097.5         3097.5             0.10075           0.000462           0.00437            0.10558     \r\n       3097.5         3097.5             0.10271           0.000502          0.004011            0.10723     \r\n       3097.5         3097.5             0.10353           0.000356           0.00429            0.10818     \r\n       3097.5         3097.5            0.099265           0.000896          0.004016            0.10418     \r\n       3097.5         3097.5             0.11075                  0          0.004832            0.11559     \r\n       3097.5         3097.5             0.10829                  0          0.006519            0.11481     \r\n       3097.5         3097.5             0.11425           0.000497          0.005016            0.11976     \r\nmean Initialization time = 0.508801\r\nmean Total Elapsed time = 0.513832\r\nsubsequent runs mean Initialization time = 0.117421\r\nsubsequent runs mean Total Elapsed time = 0.122453\r\n\r\n\r\n\r\n<\/pre>\n
As can be seen in the results, the model without the persistent data takes about 2.8 seconds to run each simulation.  Running
\n      it in Accelerator mode increases the time slightly to around 2.9 seconds.  If we run the model with persistent data, the first
\n      iteration takes a little more time than the simulations without persistent data, about 3.0 seconds. However, subsequent runs
\n      with persistent data show a drastic improvement, running in a little over 0.5 seconds.  Similar to the runs without persistent
\n      data, the runs in Accelerator mode took slightly longer.  This additional time is caused by having to verify the Accelerator
\n      mode version is up to date and no changes have been made to the model between runs.\n   <\/p>\n
I was also curious to see how Jason’s solution would compare with the built-in capability Fast Restart<\/a>.  I modified the code used to generate the previous results to run the model without persistent data using Fast Restart.
\n       Here’s the code for RunFastRestart<\/tt>.\n   <\/p>\n
\r\nNUMBER_OF_TIMING_RUNS = 10;\r\n\r\nmemoryBeforeRun = nan(NUMBER_OF_TIMING_RUNS, 1);\r\nmemoryAfterRun = nan(NUMBER_OF_TIMING_RUNS, 1);\r\nload_system(models{iModel});\r\nfor<\/span> iSim = 1:NUMBER_OF_TIMING_RUNS\r\n    memoryBeforeRun(iSim) = getfield(memory, 'MemUsedMATLAB'<\/span>)\/1024^2;\r\n    simOut = sim('withoutPersistentLoading'<\/span>,  'FastRestart'<\/span>, 'on'<\/span>);\r\n    if<\/span> iSim == 1\r\n        TimingInfo = simOut.SimulationMetadata.TimingInfo;\r\n    else<\/span>\r\n        TimingInfo(iSim) = simOut.SimulationMetadata.TimingInfo;\r\n    end<\/span>\r\n    memoryAfterRun(iSim) = getfield(memory, 'MemUsedMATLAB'<\/span>)\/1024^2;\r\nend<\/span>\r\nset_param(gcs, 'FastRestart'<\/span>, 'off'<\/span>);\r\nclose_system(models{iModel});\r\n\r\nfprintf('Model \"%s\", using FastRestart\\n'<\/span>, models{iModel})\r\noutputTable = table(memoryBeforeRun, memoryAfterRun, ...<\/span>\r\n    vertcat(TimingInfo.InitializationElapsedWallTime), ...<\/span>\r\n    vertcat(TimingInfo.ExecutionElapsedWallTime), ...<\/span>\r\n    vertcat(TimingInfo.TerminationElapsedWallTime), ...<\/span>\r\n    vertcat(TimingInfo.TotalElapsedWallTime), ...<\/span>\r\n    'VariableNames'<\/span>, ...<\/span>\r\n    {'memoryBefore'<\/span>, 'memoryAfter'<\/span>, 'initializationTime'<\/span>, ...<\/span>\r\n    'executionTime'<\/span>, 'terminationTime'<\/span>, 'totalElapsedTime'<\/span>});\r\noutputTable.Properties.VariableUnits = {'MB'<\/span>, 'MB'<\/span>, 'sec'<\/span>, 'sec'<\/span>, 'sec'<\/span>,'sec'<\/span>};\r\ndisp(outputTable)\r\nfprintf('mean Initialization time = %g\\n'<\/span>, mean(outputTable.initializationTime));\r\nfprintf('mean Total Elapsed time = %g\\n'<\/span>, mean(outputTable.totalElapsedTime));\r\nfprintf('subsequent runs mean Initialization time = %g\\n'<\/span>, mean(outputTable.initializationTime(2:end)));\r\nfprintf('subsequent runs mean Total Elapsed time = %g\\n'<\/span>, mean(outputTable.totalElapsedTime(2:end)));\r\n\r\n<\/pre>\n
The results are:<\/p>\n
RunFastRestart<\/pre>\n
Model \"withPersistentLoading\", using FastRestart\r\n    memoryBefore    memoryAfter    initializationTime    executionTime    terminationTime    totalElapsedTime\r\n    ____________    ___________    __________________    _____________    _______________    ________________\r\n         3081         3988.5               3.513           0.000502          0.003007              3.5165    \r\n       3988.5         3988.5            0.020555           0.000501          0.002004             0.02306    \r\n       3988.5         3988.5            0.018047                  0          0.002006            0.020053    \r\n       3988.5         3988.5            0.017049           0.000497          0.002035            0.019581    \r\n       3988.5         3988.5            0.016983           0.000711          0.001507            0.019201    \r\n       3988.5         3988.5            0.017546                  0          0.002065            0.019611    \r\n       3988.5         3988.5            0.018549                  0          0.002006            0.020555    \r\n       3988.5         3988.5            0.020056                  0          0.002465            0.022521    \r\n       3988.5         3988.5            0.018049                  0          0.002006            0.020055    \r\n       3988.5         3988.5            0.018042             0.0005          0.001923            0.020465    \r\nmean Initialization time = 0.367784\r\nmean Total Elapsed time = 0.370157\r\nsubsequent runs mean Initialization time = 0.0183196\r\nsubsequent runs mean Total Elapsed time = 0.0205669\r\n<\/pre>\n
As you can see, using Fast Restart actually improved the overall performance of the simulation runs with an average run time
\n      around 0.018 seconds.  The first run using Fast Restart still requires the loading of the data and this can be seen in the
\n      execution time being very similar to the first simulation run without persistent data in normal mode shown previously.\n   <\/p>\n
Comments<\/a><\/h3>\n
As shown in the results, the speed up in simulation time using this method only applies to subsequent runs, as the first simulation
\n      will still encounter the bottle neck associated with loading the data the first time.  Furthermore, the results show that
\n      using FastRestart provides some improvement in these simple cases but I would expect even better performance for larger and
\n      more complex models.  The advantage of Fast restart is that it doesn’t require the user to create custom masks for blocks
\n      and their associated initialization code and it is applied to the entire model.  However, FastRestart is not a valid approach
\n      if you are using an older version of MATLAB (prior to R2014B release) or if you require running in Accelerator mode.  It is
\n      nice to know this approach is available if needed.\n   <\/p>\n
All in all, this is a great example of how to leverage functionality in Simulink to eliminate a bottle neck in simulation
\n      execution time.  Give it a try and let us know what you think here<\/a> or leave a message for Jason<\/a>.\n   <\/p>\n