Simulink.sdi.enablePCTSupport

R2026b

Control when to import data from parallel simulations into the Simulation Data Inspector

collapse all in page

Syntax

Simulink.sdi.enablePCTSupport(mode)

Description

Simulink.sdi.enablePCTSupport(mode) configures data import into the Simulation Data Inspector from parallel workers according to the mode specified by mode. You can configure the Simulation Data Inspector to import only data from local workers, or data from local and remote workers. You can also set the mode to manual, which allows you to manually import runs into the Simulation Data Inspector using the Simulink.sdi.sendWorkerRunToClient function. By default, the Simulation Data Inspector is configured for the manual import mode.

example

Examples

collapse all

Configure Simulation Data Inspector parallel worker support to import the output automatically from both local and remote workers.

Simulink.sdi.enablePCTSupport("all")

To prevent the output from Parallel Computing Toolbox™ workers from automatically importing into the Simulation Data Inspector, specify the manual support mode.

Simulink.sdi.enablePCTSupport("manual")

This example uses:

Open Live Script

To manually send runs created using parallel workers to the Simulation Data Inspector, use Simulink.sdi.sendWorkerRunToClient .

Setup

This example runs several simulations of the ThreeSigs model, varying the value of the amplitude Sine Wave block. To set up for the parallel simulation, define a vector of amplitude values and configure the Simulation Data Inspector for manual Parallel Computing Toolbox™ support.

ampVals = [0.1 0.2 0.3 0.4];
Simulink.sdi.enablePCTSupport("manual");

Initialize Parallel Workers

Use parpool (Parallel Computing Toolbox) to start a pool of four parallel workers. This example calls parpool inside an if statement so you only create a parallel pool if you do not already have one. 

p = gcp("nocreate");
if isempty(p)
parpool(4);
end

You can use spmd (Parallel Computing Toolbox) to run initialization code common to all workers. For example, load the ThreeSigs model and use Simulink.sdi.markSignalForStreaming to select signals to log to the Simulation Data Inspector. To avoid data concurrency issues when simulating with sim in parfor, create a temporary directory on each worker. 

spmd
    load_system("ThreeSigs")
    Simulink.sdi.markSignalForStreaming("ThreeSigs/Sine Wave",1,"on")
    
    workDir = pwd;
    addpath(workDir)
    tempDir = tempname;
    mkdir(tempDir)
    cd(tempDir)
end

Run Parallel Simulations with parfor

To stream data from parallel workers to the Simulation Data Inspector, run parallel simulations using parfor (Parallel Computing Toolbox). Each worker runs a simulation of the ThreeSigs model with a different amplitude value. The software cannot access the contents of the parfor loop, so the variable ampVal is defined in the worker's workspace, where the model can see it, using assignin.

parfor (index = 1:4)
    assignin("base","ampVal",ampVals(index));
    set_param("ThreeSigs/Sine Wave","Amplitude","ampVal")
sim("ThreeSigs");

Access Data and Send Run to Client MATLAB

You can use the Simulation Data Inspector programmatic interface on the worker the same way you would in the client MATLAB®. This example creates a Simulink.sdi.Run object and attaches the value of the amplitude used in the simulation with the Tag property.

    IDs = Simulink.sdi.getAllRunIDs;
    lastIndex = length(IDs);
    runID = Simulink.sdi.getRunIDByIndex(lastIndex);
    parRun = Simulink.sdi.getRun(runID);
    parRun.Tag = strcat("Amplitude = ",num2str(ampVals(index)));
    
    Simulink.sdi.sendWorkerRunToClient   
end

Close Temporary Directories and View Runs in the Simulation Data Inspector

Use another spmd section to delete the temporary directories created on the workers once the simulations complete. 

spmd
    cd(workDir)
    rmdir(tempDir,"s")
    rmpath(workDir)
end

In each simulation, the Simulink.sdi.sendWorkerRunToClient function imported runs from all the workers into the Simulation Data Inspector. You can view the data and check the run properties to see the amplitude values used during simulation. 

Simulink.sdi.view

This example uses:

Open Live Script

Execute parallel simulations of the model ThreeSigs with different input filter time constants and access the data in different ways using the Simulation Data Inspector programmatic interface.

Setup

Clear the Simulation Data Inspector and check that Parallel Computing Toolbox™ support is configured to import runs created on local workers automatically. Then, create a vector of filter parameter values to use in each simulation.

Simulink.sdi.clear
Simulink.sdi.enablePCTSupport("local")

Ts_vals = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1];

Initialize Parallel Workers

Use the gcp function to create a pool of local workers to run parallel simulations if you don't already have one. In an spmd code block, load the ThreeSigs model and select signals to log. To avoid data concurrency issues using sim in parfor, create a temporary directory for each worker to use during simulations. 

p = gcp;
spmd
    load_system("ThreeSigs")
    workDir = pwd;
    addpath(workDir)
    tempDir = tempname;
    mkdir(tempDir)
    cd(tempDir)
end

Run Parallel Simulations

Use parfor to run the seven simulations in parallel. Select the value for Ts for each simulation, and modify the value of Ts in the model workspace. Then, run the simulation and build an array of Simulink.sdi.WorkerRun objects to access the data with the Simulation Data Inspector. After the parfor loop, use another spmd segment to remove the temporary directories from the workers.

parfor index = 1:7
    % Select value for Ts
    Ts_val = Ts_vals(index);
    
    % Change the filter time constant and simulate
    modelWorkspace = get_param("ThreeSigs","modelworkspace");
    assignin(modelWorkspace,"Ts",Ts_val)
    sim("ThreeSigs");
    
    % Create a worker run for each simulation
    workerRun(index) = Simulink.sdi.WorkerRun.getLatest
end

spmd        
    % Remove temporary directories
    cd(workDir)
    rmdir(tempDir,"s")
    rmpath(workDir)
end

Get Dataset Objects from Parallel Simulation Output

The getDataset function puts the data from a WorkerRun object into a Dataset object so you can easily post-process.

ds(7) = Simulink.SimulationData.Dataset;

for a = 1:7
    ds(a) = getDataset(workerRun(a));
end
ds(1)
ans = 
Simulink.SimulationData.Dataset '' with 3 elements

                         Name      BlockPath      
                         ________  ______________ 
    1  [1x1 Signal]      sineSig   ThreeSigs/Out1
    2  [1x1 Signal]      randSig   ThreeSigs/Out2
    3  [1x1 Signal]      chirpSig  ThreeSigs/Out3

  - Use braces { } to access, modify, or add elements using index.

Get DatasetRef Objects from Parallel Simulation Output

For big data workflows, use the getDatasetRef function to reference the data associated with the WorkerRun.

for b = 1:7
    datasetRef(b) = getDatasetRef(workerRun(b));
end
datasetRef(1)
ans = 
  DatasetRef with properties:

           Name: 'Run <run_index>: <model_name>'
            Run: [1×1 Simulink.sdi.Run]
    numElements: 3

Process Parallel Simulation Data in the Simulation Data Inspector

You can also create local Simulink.sdi.Run objects to analyze and visualize your data using the Simulation Data Inspector programmatic interface. This example shows a tag indicating the filter time constant value for each run.

for c = 1:7
    Runs(c) = getLocalRun(workerRun(c));
    Ts_val_str = num2str(Ts_vals(c));
    desc = strcat("Ts = ", Ts_val_str);
    Runs(c).Description = desc;
    Runs(c).Name = strcat("ThreeSignals run Ts=", Ts_val_str);    
end

Clean Up Worker Repositories

Clean up the files used by the workers to free up disk space for other simulations you want to run on your worker pool.

Simulink.sdi.cleanupWorkerResources

Input Arguments

collapse all

Simulation Data Inspector data import mode for data logged on parallel workers, specified as one of these options:

  • "manual" — Do not automatically import runs created on parallel workers. You can manually import runs created on parallel workers using the Simulink.sdi.sendWorkerRunToClient function.

  • "local" — Automatically import runs created on local workers.

  • "all" — Automatically import runs created on local and remote workers.

Data Types: char | string

Alternative Functionality

You can modify the parallel computing support mode in the Simulation Data Inspector by selecting Preferences > Parallel.

In the Parallel pane of the Preferences menu there are three options to control when to import data from parallel simulations: manual, from local pools only, or from all pools (local and remote).

Version History

Introduced in R2017b

expand all

See Also

| |

Topics