Skip to content

Realization layer

The question this layer answers

Where does it run, and how do its parts reach each other?

The realization layer closes the architecture path. Software is built into images, the images are deployed onto processors, the processors sit on boards, and data travels end to end across the result. This is the deployment chain a reviewer follows to check that a timing budget, a fault-containment claim or a security boundary holds in the device that actually ships.

Namespace: memo::architecture::realization · Source: src/architecture/realization/

Key elements

The execution platform. A ProcessingNode is a processor that software runs on, and a MemoryDevice is the memory it uses. Both are physical things, a chip and a board; they live in this layer because of their role as deployment targets. Hardware is wired as parts with ports. A PhysicalInterface joins two PhysicalPorts and states how the link is signalled (signalingKind: analog, digital, discrete, pulse or power transfer) and over what medium (mediumKind), with the electrical descriptors that kind needs. A PhysicalFlow is what crosses it, as a quantity. A ConnectionBinding allocates the interface to the cable, connector or medium that carries it. A PhysicalPort is a physical boundary feature: the connector the outside world plugs into. A RuntimeEnvironment is the operating system or runtime a node provides.

Deployment. A SoftwareDeploymentUnit is what is actually deployed, such as a firmware image. Its deploymentKind says how: native, containerised, cloud-hosted, embedded, or partitioned.

End-to-end flows. A FlowSpecification is a flow declared at a logical component's boundary, from an in-port to an out-port, as a source, a sink or a path. An EndToEndFlow is a complete source-to-sink flow traced across the layers, with the software-to-hardware bindings it crosses. Its latency budget and analysis purpose (latency, fault propagation, or security) drive AADL-style analysis.

How it connects

Within the layer. The deployment chain is a sequence of typed native allocations:

  • software modules build into a deployment unit (allocation … : BuildsInto);
  • the unit deploys to a processing node (allocation … : DeploysTo);
  • the node is hosted by its board (allocation … : HostedBy, from Core).

A node provides a runtime environment (ProvidesEnvironment). An end-to-end flow comprises flow specifications (FlowComprisesSpec) and traverses deployment units (FlowTraversesBinding).

To other layers:

  • Implementation elements are bound here. Software modules build into units (BuildsInto), and runtime software components bind to memory (MemoryBinding). See Implementation.
  • Logical exchanges get a medium. A component exchange is bound to the network medium that carries it (ConnectionBinding). See Logical.
  • Analysis reads across. An end-to-end flow is where latency, fault-propagation and security claims from the assurance disciplines are checked against the deployed structure.

In the running example

The temperature alarm stops at the logical and UI layers, so this layer's example comes from the GPCA infusion pump. The pump's software modules build into one firmware image. The image deploys, embedded, to the main controller, which is hosted by the controller board. Two #refinement dependencies record which interfaces realise which.

part gpcaFirmwareImage : SoftwareDeploymentUnit {
    @MemoIdentity { :>> providedId = "DU-001"; :>> label = "GPCAFirmwareImage"; }
    attribute :>> unitKind = "firmware image";
    attribute :>> version = "2.0.0";
}
allocation : BuildsInto allocate gpcaSoftware.tlm to gpcaFirmwareImage;
allocation : BuildsInto allocate gpcaSoftware.config to gpcaFirmwareImage;
allocation : BuildsInto allocate gpcaSoftware.alarm to gpcaFirmwareImage;
allocation : BuildsInto allocate gpcaSoftware.logging to gpcaFirmwareImage;
allocation : BuildsInto allocate gpcaSoftware.infusionMgr to gpcaFirmwareImage;
allocation : BuildsInto allocate gpcaSoftware.systemMonitor to gpcaFirmwareImage;
allocation gpcaSoftwareDeployment : DeploysTo allocate gpcaFirmwareImage to mainController {
    attribute :>> deploymentKind = DeploymentKind::embedded;
}
allocation : HostedBy allocate mainController to controllerBoard;
#refinement dependency sensorInputInterface to hwSoftwareBus;
#refinement dependency actuatorCommandInterface to pumpMotorDrive;

The full inventory

Generated from src/architecture/realization/.

Elements

Deployment

Element SysML kind What it is
SoftwareDeploymentUnit part def Software deployment unit definition specializing MemoPart.
RuntimeEnvironment part def Runtime environment definition specializing MemoPart.
FlowSpecification part def A flow declared at a logical component boundary (in-port → out-port).
EndToEndFlow part def A complete source→sink flow traced across the layers and the software→ hardware binding it traverses. latencyBudgetMs and analysisPurpose (latency | fault-propagation | security) drive the AADL-style analysis.

Physical

Element SysML kind What it is
ProcessingNode part def Processing node definition specializing PhysicalElement.
MemoryDevice part def Memory device definition specializing PhysicalElement.
PhysicalPort port def Physical port definition specializing MemoPort.

Connections at a glance

Each arrow is one relationship, from its source end to its target end. A grey box belongs to another layer.

flowchart LR
  SoftwareModule["SoftwareModule"]:::other
  SoftwareDeploymentUnit["SoftwareDeploymentUnit"]
  LogicalComponent["LogicalComponent"]:::other
  MemoPart["MemoPart"]:::other
  ProcessingNode["ProcessingNode"]
  RuntimeEnvironment["RuntimeEnvironment"]
  SoftwareComponent["SoftwareComponent"]:::other
  MemoryDevice["MemoryDevice"]
  MemoInterface["MemoInterface"]:::other
  PhysicalComponent["PhysicalComponent"]:::other
  EndToEndFlow["EndToEndFlow"]
  FlowSpecification["FlowSpecification"]
  PhysicalPort["PhysicalPort"]
  anyElement["any element"]:::other
  SoftwareModule -->|BuildsInto| SoftwareDeploymentUnit
  LogicalComponent -->|RealizedBy| MemoPart
  SoftwareDeploymentUnit -->|DeploysTo| ProcessingNode
  ProcessingNode -->|ProvidesEnvironment| RuntimeEnvironment
  SoftwareComponent -->|MemoryBinding| MemoryDevice
  MemoInterface -->|ConnectionBinding| PhysicalComponent
  EndToEndFlow -->|FlowComprisesSpec| FlowSpecification
  EndToEndFlow -->|FlowTraversesBinding| SoftwareDeploymentUnit
  PhysicalPort -->|PhysicalInterface| PhysicalPort
  anyElement -->|PhysicalTransfer| anyElement
  classDef other fill:#eef1f4,stroke:#9aa7b2,color:#4a5a66

Relationships declared here

Relationship From To What it says
BuildsInto SoftwareModule SoftwareDeploymentUnit Typed relationship from SoftwareModule to SoftwareDeploymentUnit.
RealizedBy LogicalComponent MemoPart Typed relationship from LogicalComponent to MemoPart.
DeploysTo SoftwareDeploymentUnit ProcessingNode Typed relationship from SoftwareDeploymentUnit to ProcessingNode.
ProvidesEnvironment ProcessingNode RuntimeEnvironment Typed relationship from ProcessingNode to RuntimeEnvironment.
MemoryBinding SoftwareComponent MemoryDevice AADL actual_memory_binding. Which memory a software component's code and data occupy — what makes a memory budget a claim about a device rather than a string.
ConnectionBinding MemoInterface PhysicalComponent AADL actual_connection_binding. Which physical thing carries an interface: a network medium under a component exchange, a cable or harness under a hardware Interface, a connector, a tube.…
FlowComprisesSpec EndToEndFlow FlowSpecification The end-to-end flow is realized by an ordered flow specification, one segment per traversed component boundary (AADL flow-spec → end-to-end).
FlowTraversesBinding EndToEndFlow SoftwareDeploymentUnit Typed relationship from EndToEndFlow to SoftwareDeploymentUnit.
PhysicalInterface PhysicalPort PhysicalPort Typed relationship from PhysicalPort to PhysicalPort.
PhysicalFlow any element any element What crosses a physical interface, as a quantity: a voltage, a current, a pressure, a force, a flow of fluid.
PhysicalTransfer any element any element The concrete flow a model types its physical flows by; a concrete flow def declares its two ends.

Relationships from elsewhere that reach this layer

None with an end typed in this layer.

Enumerations

Enumeration Values
FlowSpecKind source, sink, path

Go deeper