↓ Skip to main content

ARINC 653 Multi-Core IMA: VxWorks 653 Architecture

ARINC 653 Multi-Core IMA: VxWorks 653 Architecture

Warning! Resources are sourced from the internet and are intended for learning and exchange purposes only. If any content infringes upon your rights, please contact us for removal, check the full Legal Disclaimer for details.
Wait a moment
Download linkage will show in 20 seconds

Aerospace and defense developers face a familiar problem: every new generation of equipment must deliver more computing capability while reducing size, weight, power consumption (SWaP), and lifecycle costs. More advanced avionics, autonomous functions, and mission systems all compete for limited hardware resources.

Traditional federated architectures address functional separation by assigning individual Line Replaceable Units (LRUs) to separate applications. This approach provides straightforward resource isolation, but it also increases hardware count, wiring complexity, power consumption, and maintenance costs.

Integrated Modular Avionics (IMA) takes a different approach. Multiple applications with different safety-criticality levels share a common computing platform, with the operating environment responsible for enforcing isolation and controlling resource allocation.

ARINC 653 provides the software architecture needed to make this arrangement practical. However, moving from single-core to multi-core processors introduces a problem that conventional partitioning alone cannot solve: applications can interfere with one another through shared hardware resources.

VxWorks 653 Multi-core Edition addresses this problem by extending the established ARINC 653 architecture to multi-core hardware, combining module-level resource management, partition-level execution environments, and controlled scheduling to support mixed-criticality avionics systems.

🧩 ARINC 653 and the Evolution of Integrated Modular Avionics
#

ARINC 653 is a foundational standard for partitioned avionics software. Its Application/Executive (APEX) interface defines a common set of services that applications use to interact with the underlying operating environment.

These services cover several core areas:

  • Partition management and configuration.
  • Process creation, scheduling, and management.
  • Time management and clock services.
  • Inter-partition communication.
  • Intra-partition communication.
  • Error detection and health monitoring.

The standard’s central concept is the separation of applications through spatial and temporal partitioning.

Spatial partitioning prevents one application from accessing memory assigned to another partition. Temporal partitioning controls when each partition receives processor time, preventing one workload from consuming another application’s allocated execution window.

This separation allows applications with different Design Assurance Levels (DALs) to execute on the same computing module, provided the complete system architecture and certification evidence establish the required isolation and assurance.

For developers, the advantage is substantial. Instead of designing and maintaining separate hardware platforms for every function, teams can consolidate applications while retaining defined execution boundaries and standardized interfaces.

VxWorks 653 was developed specifically for this class of system. Its ARINC 653 foundation supports partitioned execution, health monitoring, controlled communication, and the certification processes required by safety-critical avionics programs.

The challenge becomes more complicated when the underlying processor contains multiple cores.

⚠️ Why Multi-Core Processors Complicate Certification
#

Moving an ARINC 653 application from a single-core processor to a multi-core SoC may appear straightforward. More cores provide more execution capacity, so assigning different partitions to different cores seems like a natural way to improve performance.

The problem is that processor cores rarely operate in complete isolation.

They typically share some combination of:

  • Last-level cache and memory hierarchy.
  • Main memory and memory controllers.
  • System interconnects and internal buses.
  • I/O controllers and DMA resources.
  • Hardware accelerators and other peripheral devices.
  • Power, thermal, and clock-management resources.

When multiple cores access these resources simultaneously, contention can introduce unpredictable delays.

For example, one partition may execute within its allocated time window but experience a longer memory-access latency because another core is generating heavy memory traffic. The first partition has not violated its scheduling allocation, yet its execution time has changed.

This distinction matters in real-time systems. A scheduler can control CPU allocation, but that does not automatically control access latency to shared hardware resources.

Shared-Resource Interference
#

Consider two safety-critical applications executing concurrently on separate processor cores.

Application A performs time-sensitive control calculations. Application B processes sensor data and generates substantial memory traffic.

Although the applications occupy separate memory partitions and receive independent processor time, they may still compete for:

  • Shared cache capacity.
  • Memory bandwidth.
  • Interconnect bandwidth.
  • Memory-controller queues.

The resulting interference can increase worst-case execution time (WCET) and invalidate timing assumptions established during single-core testing.

Cache behavior introduces additional complications. Cache eviction, cache-line migration, and shared-cache contention can cause execution-time variation even when application code remains unchanged.

The same issue applies to I/O. DMA transfers initiated by one partition may consume memory bandwidth needed by another application unless the hardware and platform software provide appropriate controls.

CAST-32A and Multi-Core Assurance Objectives
#

In November 2016, the Certification Authorities Software Team (CAST) published CAST-32A, a position paper addressing the certification challenges associated with multi-core processors in airborne systems.

CAST-32A established objectives covering processor planning, shared-resource usage, interference analysis, software behavior, and error handling. Although its initial focus was dual-core processors, its underlying concerns apply to systems with larger core counts.

The regulatory guidance has since evolved. The FAA issued AC 20-193, Use of Multi-Core Processors, on January 8, 2024. This active advisory circular describes an acceptable means of compliance for airborne systems using multi-core processors.

For certification teams, the practical requirement is clear: demonstrating spatial and temporal partitioning is not sufficient by itself. The system must also identify relevant interference channels, establish mitigation strategies, and provide evidence that shared-resource contention does not compromise application timing or safety objectives.

This requires coordination between hardware selection, platform software configuration, application architecture, and verification activities.

⚙️ VxWorks 653 Multi-core Edition Architecture
#

Wind River’s VxWorks 653 3.0 Multi-core Edition extends the ARINC 653 foundation to multi-core processor platforms.

The architecture is designed to support applications with different criticality levels while providing controlled access to processor and platform resources.

Its main capabilities include:

  • A certification-oriented platform targeting DO-178C Design Assurance Level A programs.
  • Concurrent execution of applications with different DAL requirements across multiple cores.
  • Fault isolation and containment through partitioning and health monitoring.
  • Static system configuration and resource allocation based on ARINC 653.
  • Role-based development and configuration aligned with RTCA DO-297.

A key design decision is the separation of platform-level responsibilities from application execution responsibilities.

The architecture uses two operating-system layers: the Module Operating System (MOS) and the Partition Operating System (POS).

Module Operating System (MOS)
#

The MOS operates at the module level and manages resources shared across the computing platform.

Its responsibilities extend beyond conventional operating-system scheduling. It must establish and enforce the boundaries within which partition operating systems execute.

Typical responsibilities include:

  • Managing processor cores and module-level scheduling.
  • Enforcing spatial and temporal partitioning.
  • Managing access to shared memory and hardware resources.
  • Controlling interconnect and cache resource allocation where supported by the hardware.
  • Providing inter-partition communication mechanisms.
  • Supervising health monitoring and system-level error handling.
  • Detecting and responding to platform-level faults.

The MOS acts as the supervisory layer for the entire module. It determines which partition environments can execute, when they can execute, and which platform resources they can access.

On multi-core hardware, this layer also plays an important role in controlling or coordinating shared-resource usage. The exact enforcement mechanisms depend on the processor’s hardware capabilities and the platform configuration.

Memory protection alone cannot guarantee temporal isolation. Effective resource management must account for the complete hardware access path, including caches, memory controllers, interconnects, and peripheral traffic.

Partition Operating System (POS)
#

The POS executes inside an individual partition and provides the runtime environment for the applications assigned to that partition.

A typical POS implementation includes:

  • A guest operating system kernel.
  • A partition-specific Board Support Package (BSP).
  • Virtualization and hardware-abstraction components.
  • Device drivers and permitted I/O interfaces.
  • An APEX library implementing the required ARINC 653 services.
  • An application binary interface (ABI) for application execution.

VxWorks Cert can serve as a partition operating system, while other supported guest environments may include VxWorks 7, Wind River Linux, and third-party operating systems.

The exact guest operating systems available depend on the platform release, processor architecture, and system configuration.

This separation provides a practical migration path for existing software. Applications can retain a familiar execution environment while the MOS manages their placement and resource allocation at the module level.

It also allows different development teams to work on separate partitions without requiring every application to share the same operating-system environment.

One distinction matters during certification: supporting multiple guest operating systems does not automatically make every guest or application certifiable. Each software component must have the appropriate assurance evidence, and the integrated system must demonstrate that the required isolation and safety objectives are satisfied.

Two-Level Scheduling
#

The two-level scheduling architecture is central to VxWorks 653 Multi-core Edition.

At the first level, the MOS manages processor-core allocation and module-level time partitioning. It assigns execution windows to partitions according to the statically configured schedule.

At the second level, the POS schedules the processes and threads belonging to its own partition.

The relationship can be represented as follows:

Multi-Core Computing Module
           |
Module Operating System
           |
Module-Level Scheduler
           |
+----------+----------+
|          |          |

Core 0 Core 1 Core 2 | | | +—+ +—+ +—+ |POS| |POS| |POS| +—+ +—+ +—+ | | | App App App Threads Threads Threads APEX APEX APEX Services Services Services

Within each allocated execution window, the POS performs the scheduling required by its guest operating system.

This arrangement supports several deployment models.

A critical partition can receive a dedicated processor core, reducing the number of competing workloads. Less demanding partitions can share a core through time-multiplexed execution windows.

A system can also combine different guest operating systems on the same hardware, provided the selected platform configuration supports those environments and the resulting interactions satisfy the system’s assurance requirements.

The architectural advantage is flexibility without abandoning the established ARINC 653 partitioning model.

🔒 Resource Isolation, Determinism, and Fault Containment
#

Multi-core certification depends on more than assigning partitions to processor cores. The architecture must establish how each application accesses shared resources and what happens when a partition or platform component fails.

Spatial and Temporal Isolation
#

Spatial isolation protects partition memory and restricts unauthorized access between applications.

Temporal isolation ensures that each partition receives its configured processor allocation.

Together, these mechanisms establish the conventional ARINC 653 execution boundaries.

However, multi-core systems require additional attention to resource contention. A partition may be isolated at the software level while still experiencing interference through shared caches or memory controllers.

Developers must therefore evaluate the processor’s hardware capabilities and determine which resources can be partitioned, allocated, throttled, or otherwise controlled.

Shared-Resource Management
#

A practical multi-core design should identify shared-resource interference channels early in the architecture phase.

Depending on the processor, mitigation strategies may include:

  • Assigning dedicated cores to high-criticality applications.
  • Configuring cache partitioning or allocation controls.
  • Restricting memory bandwidth consumption.
  • Controlling DMA and peripheral access.
  • Establishing deterministic interconnect arbitration.
  • Separating high-bandwidth workloads from time-sensitive applications.

Not every processor supports every mechanism. Some controls are enforced directly by hardware, while others depend on platform software or system-level workload constraints.

The certification argument must explain which mechanisms are used, which interference paths remain, and how their effects are bounded.

Health Monitoring and Error Handling
#

Fault containment is another essential part of the architecture.

The health monitoring system identifies abnormal conditions and applies predefined recovery actions according to their severity and scope.

A process-level fault may require restarting an individual process. A partition-level failure may require restarting the affected partition. More serious faults may require module-level recovery or a system-defined response.

The objective is to prevent a local failure from propagating into unrelated applications.

Health monitoring also provides a structured way to record events, trigger recovery procedures, and support system-level fault analysis.

On multi-core platforms, these mechanisms must account for failures in both partition software and shared platform resources.

🔄 Migrating Existing ARINC 653 Applications to Multi-Core Hardware
#

For avionics programs with established single-core applications, replacing the entire software architecture at once is rarely the best migration strategy.

A staged approach allows developers to retain existing application behavior as a reference while introducing multi-core execution incrementally.

A practical migration plan consists of two main phases.

Phase 1: Re-host on a Single Core
#

The first step is to move the existing single-core ARINC 653 application suite onto one core of the new multi-core processor.

At this stage, the objective is not to maximize processor utilization. It is to establish a reliable baseline.

Developers should verify:

  • Application functionality and behavioral equivalence.
  • APEX interface compatibility.
  • BSP and device-driver integration.
  • Partition schedules and execution budgets.
  • Interrupt handling and I/O behavior.
  • Memory usage and processor utilization.
  • Timing behavior under representative operating conditions.

This phase helps identify problems caused by the new processor, hardware abstraction layer, or guest operating environment without introducing the additional complexity of concurrent multi-core workloads.

The resulting measurements provide a reference for subsequent performance and timing analysis.

Phase 2: Redeploy Across Additional Cores
#

Once the single-core configuration is stable, partitions and selected I/O workloads can be moved to additional cores.

The migration should proceed incrementally.

High-criticality applications are good candidates for dedicated-core assignments when the platform and resource requirements permit. Other applications may share cores through statically configured execution windows.

After each change, developers should repeat timing and interference analysis.

In particular, they should measure how the relocated workloads affect shared caches, memory bandwidth, interconnect traffic, and I/O performance.

Testing only each partition in isolation is insufficient. The verification environment should reproduce representative concurrent workloads, including combinations that create high shared-resource demand.

The original single-core configuration remains useful as a comparison point, but it cannot by itself establish the worst-case behavior of the multi-core deployment.

Supporting Multiple Deployment Models
#

This phased strategy allows the same platform architecture to support different levels of integration.

A system can begin with a deployment that resembles the original federated architecture, with critical applications assigned dedicated cores.

It can then evolve into a mixed configuration, combining dedicated-core applications with time-multiplexed partitions.

Finally, the system can move toward a more consolidated IMA deployment, in which multiple guest environments and applications share the available processor resources under controlled scheduling and isolation.

The application architecture does not need to change all at once. The platform configuration determines how workloads are placed and how hardware resources are allocated.

🛠️ Configuration Management and DO-297 Role Separation
#

Multi-core IMA programs involve several independent engineering organizations. The platform supplier, system integrator, and application suppliers may all have different responsibilities, development environments, and certification obligations.

RTCA DO-297 provides the development assurance framework for IMA systems and defines the relationship among these roles.

VxWorks 653 supports this model through configuration-driven system integration.

XML-based configuration tables describe the platform resources, partition assignments, scheduling parameters, communication channels, and other system-level settings.

A qualified configuration toolchain processes these definitions and generates the corresponding system configuration artifacts.

The separation of responsibilities generally follows three levels:

Platform supplier

Provides the underlying hardware platform, Module Operating System, supported partition environments, and associated verification and certification evidence.

System integrator

Defines the integrated system architecture, assigns applications to partitions, establishes resource allocations, and verifies that the complete configuration meets system requirements.

Application supplier

Develops and verifies individual applications within their assigned partitions and provides the required application-level certification evidence.

This arrangement reduces unnecessary overlap between development activities. Application teams can concentrate on application behavior, while the platform and integration teams manage module-level resource allocation and system-wide constraints.

However, configuration data must be treated as part of the certified system baseline. Changes to partition placement, execution windows, processor assignments, or shared-resource settings can affect timing and isolation assumptions.

The configuration compiler, checker, and associated development tools must therefore have qualification and verification evidence appropriate to the applicable certification objectives.

✈️ Multi-Core Avionics in Practice
#

Multi-core IMA is no longer simply an architectural experiment. Safety-critical airborne systems are already using multi-core processors to consolidate applications while addressing the associated certification challenges.

A relevant example is Wind River’s collaboration with Airbus on the A330 MRTT automatic air-to-air refuelling system.

The system uses VxWorks 653 as its real-time operating platform, with multiple safety-critical applications executing under an ARINC 653-based architecture. The resulting automatic refuelling capability achieved certification for multiple DAL A applications running concurrently across processor cores, addressing CAST-32A requirements.

The project demonstrates that a carefully engineered multi-core platform can support demanding avionics functions without abandoning the assurance requirements associated with traditional safety-critical software.

Further details are available in Wind River’s coverage of its Airbus automatic air-to-air refuelling collaboration.

Wind River has also extended VxWorks 653 support to ARM-based platforms. Its announcement of VxWorks 653 Multi-core Edition on ARM architecture describes support for 64-bit virtualization and guest operating environments, including VxWorks 7 and Linux.

These developments illustrate an important industry direction: avionics developers are increasingly evaluating processor architectures and operating environments based on their ability to consolidate workloads while retaining deterministic behavior and a defensible certification strategy.

🔭 Designing for the Next Generation of IMA Systems
#

Multi-core processors offer significant opportunities for reducing hardware count, improving computing capacity, and integrating previously separate avionics functions. They also introduce engineering problems that cannot be solved by conventional processor scheduling alone.

ARINC 653 remains a key architectural foundation for these systems. Its APEX interface, partition management, health monitoring, and spatial and temporal separation provide a standardized execution model for applications with different criticality requirements.

VxWorks 653 Multi-core Edition extends this model through its MOS/POS architecture. The MOS manages module-level execution and shared resources, while individual POS environments provide the runtime services required by their applications.

The distinction between the two layers is particularly important during system integration. Processor allocation, partition scheduling, memory protection, cache behavior, and I/O traffic must be considered together rather than treated as independent configuration problems.

For developers migrating legacy applications, re-hosting first and expanding across additional cores incrementally provides a controlled way to establish timing baselines and identify new interference paths.

The final certification argument must demonstrate more than successful application execution. It must show that the selected hardware, platform configuration, guest operating systems, and concurrent workloads preserve the required timing, isolation, and fault-containment properties under the conditions defined by the system safety and certification plans.

Related