> For the complete documentation index, see [llms.txt](https://www.opal-rt.com/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.opal-rt.com/docs/rt-lab/model-and-simulation/single-core-and-multi-core-simulation/distribute-a-model-across-multiple-simulators-with-dolphin.md).

# Distribute a Model Across Multiple Simulators with Dolphin

## Introduction

RT-LAB can distribute a simulation model across multiple simulators when additional processing resources are required to execute the model in real time.

The model is divided into computation subsystems that run in parallel on separate target nodes. The simulators are connected through **Dolphin PCI Express (PCIe)**, which provides the low-latency communication required to exchange simulation data between the subsystems during real-time execution.

Use this architecture to scale a single RT-LAB simulation beyond the processing capacity of one simulator.

This is a **distributed simulation of one RT-LAB model**, not a co-simulation of independent RT-LAB models. The computation subsystems belong to the same model and execute together as a single simulation.

***

## Architecture

An RT-LAB model is divided into subsystems according to their role in the simulation:

* `SC_`: Console subsystem
* `SM_`: Master computation subsystem
* `SS_`: Slave computation subsystem

The console subsystem runs on the host computer and provides the user interface for interacting with the simulation. The `SM_` and `SS_` subsystems perform the real-time computation and can be assigned to different target nodes. The `SS_` subsystems are specifically used when a model needs to be divided across multiple CPU cores or target nodes. [\[OnBoarding...Simulation | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/QA/pages/3418620033/OnBoarding-+OPAL+Real-Time+Simulation)

For example:

| Subsystem       | Execution location |
| --------------- | ------------------ |
| `SC_Console`    | Host computer      |
| `SM_Plant1`     | Real-time target 1 |
| `SS_Plant2`     | Real-time target 2 |
| `SS_Controller` | Real-time target 3 |

RT-LAB compiles and executes these computation subsystems separately while coordinating them as part of the same simulation.

The target computers are physically connected through the Dolphin PCIe network to provide the low-latency data exchange required between real-time computation nodes.

***

### How Communication Works

Signals crossing RT-LAB subsystem boundaries are exchanged using `OpComm` blocks.

When the model runs in RT-LAB, connections between the main `SC_`, `SM_`, and `SS_` subsystems are replaced with communication links. Communication between the console and real-time nodes uses TCP/IP, while communication between the `SM_` and `SS_` real-time computation nodes uses a designated real-time link. [\[Building Models | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/PRD/pages/144148947/Building+Models)

In a Dolphin-based multi-target configuration, that real-time link is provided by the Dolphin interconnect. RT-LAB describes Dolphin as providing the real-time low-latency communication between target processors. [\[RT-LAB | U...troduction | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/RD/pages/45880058/RT-LAB+User+Guide+Introduction)

The architecture therefore uses two distinct communication paths:

| Communication                       | Connection   |
| ----------------------------------- | ------------ |
| Host ↔ real-time targets            | TCP/IP       |
| Real-time target ↔ real-time target | Dolphin PCIe |

The host network connection is used for RT-LAB management and interaction with the simulation. Dolphin carries the time-critical data exchanged between the real-time computation nodes.

***

## Requirements

Before configuring a distributed model, make sure that the participating real-time targets meet the hardware and software requirements for Dolphin communication.

### Real-Time Targets

You need at least two compatible real-time target computers.

Each target must:

* be available to RT-LAB;
* have RT-LAB target components installed;
* have a valid license; and
* support the required Dolphin hardware and driver.

RT-LAB target components must be installed on the OPAL-RT simulators participating in the simulation. Each target must also have a valid license to run a simulation. [\[Installing...Simulator | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/PRD/pages/143427974/Installing+Uninstalling+RT-LAB+on+an+OPAL-RT+Simulator) [\[Activate a...arget Node | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/PRD/pages/144247564/Activate+a+License+on+the+Target+Node)

### Dolphin Interconnect

The targets must be equipped with compatible Dolphin PCIe hardware.

Current OPAL-RT documentation identifies the **Dolphin MXH930 NTB PCIe adapter** for inter-target communication on OPAL-RTLinux 3. Dolphin PXH810/830 NTB adapters are also identified as inter-target communication devices but are marked EOL. [\[Drivers fo...alrtlinux3 | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/DRIVDOC/pages/21133323/Drivers+for+OPALRT-Linux+3.x+List+of+Supported+Drivers+for+opalrtlinux3)

The documented MXH930 configuration includes supported OPAL-RT simulator platforms such as:

* OP5033XG
* OP5033XG2
* OP5707XG
* OP5707XG2

The exact requirements depend on the simulator and OPAL-RTLinux version. [\[Dolphin MX...figuration | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/OS/pages/3117777648/Dolphin+MXH930+Installation+and+Configuration)

> **Important:** Verify the compatibility of the simulator, OPAL-RTLinux version, Dolphin adapter, firmware, driver, and RT-LAB version before configuring the system.

***

## Connect the Real-Time Targets

Install the supported Dolphin adapter in each target and connect the targets using the appropriate PCIe cables.

Depending on the system architecture, a Dolphin setup can include:

* two targets connected directly; or
* several targets interconnected through a Dolphin PCIe switch.

For example, the documented MXH930 configuration supports SFF-8644 PCIe 3.0 cabling and identifies the Dolphin MXS824 PCIe 3.0 switch as part of supported multi-system configurations. [\[Dolphin MX...figuration | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/OS/pages/3117777648/Dolphin+MXH930+Installation+and+Configuration)

For systems using the MXH930 adapter, see Dolphin MXH930 Installation and Configuration for the detailed hardware installation, firmware, cabling, boot, driver, and configuration requirements. [\[Dolphin MX...figuration | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/OS/pages/3117777648/Dolphin+MXH930+Installation+and+Configuration)

> **Note:** Do not confuse Dolphin NTB inter-target communication with Dolphin configurations used only to connect a simulator to an I/O expansion chassis. For example, the older PXH832 documentation describes a simulator-to-I/O-expansion configuration, while the MXH930 NTB driver is explicitly identified for **inter-target communication**. [\[Dolphin PXH832 | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/OPER/pages/3510173701/Dolphin+PXH832), [\[Drivers fo...alrtlinux3 | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/DRIVDOC/pages/21133323/Drivers+for+OPALRT-Linux+3.x+List+of+Supported+Drivers+for+opalrtlinux3)

***

## Prepare the RT-LAB Model

Once the Dolphin network is operational, prepare the RT-LAB model for distributed execution.

### 1. Identify the Computation to Distribute

Identify portions of the model that can execute in parallel.

The objective is to distribute computational load while limiting the number of signals exchanged between targets.

Good partition boundaries generally:

* separate computationally intensive parts of the model;
* minimize signals crossing between subsystems; and
* avoid unnecessary feedback between target nodes.

Communication between targets consumes part of the available real-time computation period, so moving computation to another target is useful only when the additional processing capacity outweighs the communication overhead.

***

### 2. Divide the Model into Computation Subsystems

Create:

* one `SM_` master computation subsystem; and
* one or more `SS_` slave computation subsystems.

For example:

SC\_ConsoleSM\_Network\_ASS\_Network\_BSS\_Controller

The `SM_` and `SS_` subsystems contain the portions of the model that execute on the real-time targets. `SS_` subsystems are optional and are intended for models that need to be divided across additional CPU cores or target nodes. [\[OnBoarding...Simulation | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/QA/pages/3418620033/OnBoarding-+OPAL+Real-Time+Simulation)

## Assign the Subsystems to Targets

### 4. Configure the Execution Nodes

Assign each computation subsystem to the real-time target and CPU core on which it must execute.

For example:

| RT-LAB subsystem | Target   | Purpose                  |
| ---------------- | -------- | ------------------------ |
| `SM_Network_A`   | Target 1 | First network partition  |
| `SS_Network_B`   | Target 2 | Second network partition |
| `SS_Controller`  | Target 3 | Controller computation   |

The exact distribution should be selected according to the computational requirements of each subsystem.

RT-LAB supports multi-subsystem and multi-target simulations as part of its distributed execution architecture. [\[RTLABTT-54...ease notes | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/RTI/pages/3069607984/RTLABTT-5400+release+notes)

If one target is overloaded, move suitable computation to another target. If communication becomes the limiting factor, reconsider the partition so that tightly coupled computations remain on the same target.

## Example Architecture

Consider an electrical model that is too computationally demanding to execute on one target.

The electrical network contains a transmission line that provides a valid partition point.

The model can be configured as follows:

Host computer    |    | TCP/IP    |Target 1SM\_Network\_A    |    | Dolphin PCIe    |Target 2SS\_Network\_B

The two network sections execute simultaneously on separate targets.

Signals required across the RT-LAB subsystem boundary are transferred using `OpComm`, while the Dolphin interconnect carries the real-time data between the target computers. The electrical network itself is partitioned at an appropriate ARTEMiS transmission-line or Stubline boundary. The combination is consistent with the distributed cluster architecture described in the ARTEMiS documentation. [\[ARTEMiS Stubline | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/Artemis/pages/12160911/ARTEMiS+Stubline)

For larger systems, additional target nodes can be introduced when supported by the Dolphin hardware topology. OPAL-RT's current development material, for example, includes validation work for a Dolphin NTB cluster with six nodes, confirming that Dolphin is used beyond simple two-node connections. Because that source describes current internal validation rather than a public product limit, I would **not document six nodes as a supported maximum**. [\[2026-11-03...Sprint 299 | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/DRIVDOC/pages/3747774642/2026-11-03+Sprint+299)

***

## Limitations and Considerations

### Dolphin Is Required for This Workflow

For the workflow described on this page, the real-time targets use Dolphin for low-latency inter-target communication. RT-LAB's documentation identifies Dolphin Interconnect as providing real-time communication between target processors. [\[RT-LAB | U...troduction | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/RD/pages/45880058/RT-LAB+User+Guide+Introduction)

Other RT-LAB communication technologies such as shared memory or UDP/IP exist, but they serve different deployment situations. [\[RT-LAB | U...troduction | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/RD/pages/45880058/RT-LAB+User+Guide+Introduction)

### Communication Adds Overhead

Adding another target provides additional computation resources but also introduces inter-target communication.

A model may therefore perform worse if it is partitioned such that large amounts of data must continuously cross the Dolphin link.

### Electrical Models Require Valid Partition Points

Electrical circuits cannot generally be split at arbitrary locations. Communication delays introduced by distributed execution can alter the system dynamics. [\[ARTEMiS Stubline | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/Artemis/pages/12160911/ARTEMiS+Stubline)

Use an appropriate ARTEMiS decoupling method where required.

### This Is Still One RT-LAB Model

Each target executes one or more computation subsystems belonging to the same RT-LAB model.

The targets do **not** run independent models that happen to exchange data.

To connect independent models or applications instead, use RT-LAB Orchestra. Orchestra provides a data-centered communication mechanism specifically designed for exchanges between separate co-simulation components. [\[Orchestra | Confluence\]](https://opal-rt.atlassian.net/wiki/spaces/RD/pages/45881870/Orchestra)

## When to Use This Architecture

Use a distributed RT-LAB model with Dolphin when:

* a model cannot meet its real-time deadline on a single simulator;
* additional simulators are available;
* the model can be divided into parallel computation subsystems;
* the simulators support the required Dolphin interconnect;
* the communication overhead remains compatible with the simulation time step; and
* electrical network partitions, when applicable, have valid decoupling points.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://www.opal-rt.com/docs/rt-lab/model-and-simulation/single-core-and-multi-core-simulation/distribute-a-model-across-multiple-simulators-with-dolphin.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
