Contents

Middleware & runtime on the HPC application processor

This layer starts and manages application processes and lets vehicle software discover services and exchange data locally or across the vehicle network.

3 min read · Discipline stake: Software BSW Networks Safety Update

What runs here

On an HPC application processor, middleware connects feature applications to reusable communication and execution services. AUTOSAR Adaptive provides standardized C++ interfaces through the AUTOSAR Runtime for Adaptive Applications (ARA). A service-oriented architecture can also use other middleware; choosing SOA does not by itself mean adopting AUTOSAR Adaptive.

Component Role
Communication Management (ara::com) Provides service discovery and typed communication through client proxies and provider skeletons, using methods, events and fields.
Communication bindings Map application communication onto local mechanisms or network protocols such as SOME/IP or DDS.
Execution Management (ara::exec) Manages configured application process lifecycles and receives execution-state reports.
State Management Coordinates operating states and requests the corresponding execution changes.
Manifests and generated interfaces Describe deployment, execution configuration and service instances.

These are functional responsibilities; an implementation need not package each as a separate daemon. Logging, OTA and diagnostics interact with this runtime but belong to the platform-services row of this grid. AUTOSAR Adaptive Platform.

Why it looks like this

Application processors provide the memory, address-space isolation and computing capacity needed for substantial C++ processes, networking and concurrent workloads. Middleware helps independently developed applications share information without embedding every peer’s physical location in application logic. Explicit service contracts also support software evolution, although compatible deployment still needs engineering control.

This flexibility costs memory, CPU time, integration effort and startup complexity. Serialization, copying, scheduling and discovery all contribute to latency. Shared caches, memory bandwidth and accelerator workloads can introduce interference. Measure the complete path from producer to consumer under representative contention.

The grid’s QM–ASIL B label describes the intended allocation, not an intrinsic safety rating of Cortex-A cores or Adaptive middleware. Safety-relevant use needs a justified implementation, bounded resource use, suitable monitoring and evidence for the complete execution environment. Moving a tight control loop to a safety MCU can simplify that argument, but does not remove its communication requirements.

How it connects

Above this layer, applications offer and consume typed interfaces. Below it, runtime libraries and processes use OS facilities for threads, scheduling, memory, interprocess communication and networking. Execution Management manages processes; the OS schedules their threads. The hypervisor beneath a VM supplies a separate isolation boundary.

Across nodes, SOME/IP supports service communication, with SOME/IP Service Discovery handling offers, discovery and event subscriptions. DDS provides data-centric publish/subscribe communication with quality-of-service policies; DDSI-RTPS specifies its interoperability wire protocol. A DDS binding behind ara::com does not imply that every native DDS capability is exposed. Binding support and configuration must be checked against the selected release and implementation. AUTOSAR platform design, OMG DDSI-RTPS.

A Classic ECU can participate through compatible SOME/IP support or through a gateway. Translating a CAN signal into a service requires explicit decisions about units, validity, timestamps and failure behavior. GPU/NPU execution normally uses dedicated runtime APIs; service middleware can distribute its results.

Compared with other node classes

  • HPC safety island: Classic RTE and COM typically support statically configured communication around safety and control tasks; communication with the application processor crosses an explicit boundary.
  • Zone controller: RTE, COM and PduR combine local application communication with configured routing. Translating signals into services requires additional gateway logic.
  • MCU-based ECU: Generated RTE interfaces and configured COM signal processing favor predictable resource use and tightly integrated functions.
  • Smart node / LIN slave: Protocol handling serves a narrow sensor or actuator function with much smaller runtime requirements. A 10BASE-T1S physical link alone does not provide service middleware.

Best practices

  • Define interface versions, units, validity, timestamps and unavailable-service behavior before integrating applications.
  • Bound queues, payload sizes, discovery activity and retry behavior; measure startup and latency under load.
  • Coordinate process dependencies and shutdown so consumers handle providers appearing, restarting or disappearing.
  • Match DDS reliability, history and resource limits to data freshness needs; reliable delivery alone does not guarantee timely use.
  • Apply authorization, network controls and required communication protection; service discovery is not authentication.
  • Test mixed software versions, peer resets, network loss and overload, including the required degraded behavior.

Common pitfalls

  • Treating successful service discovery as proof that data is fresh, authorized or safe to use.
  • Assuming SOME/IP and DDS communicate directly without a defined bridge and semantic mapping.
  • Assuming a service interface removes dependencies: application behavior can still depend on startup order, timing and compatible versions.

What it means for your discipline

  • HPC & application software Core

    Application engineers define service contracts, use communication APIs and implement lifecycle and failure handling. Their daily work includes managing concurrency, compatibility and data freshness.

  • Base software Core

    Platform engineers integrate the Adaptive runtime, configure manifests and bindings, and connect process management to the OS. They investigate startup, resource consumption and middleware failures.

  • Networks & communication Partial

    Network engineers configure reachability, multicast handling and traffic policies for service communication. They validate discovery behavior and latency across the deployed network.

  • Functional safety Partial

    Safety engineers specify communication failure detection and timing assumptions for safety-relevant services. They assess whether runtime monitoring and isolation support the allocated safety requirements.

  • Software update & OTA Partial

    Coordinate application activation with execution manifests, process dependencies and operating-state transitions. Validate service compatibility across mixed versions and after rollback, including provider restarts and unavailable services.

No direct stake: E/E architecture · Cybersecurity · Hardware & silicon · Diagnostics & lifecycle

Where it sits in the software stack

Generic layered software of a central HPC (application processor with hypervisor, plus a safety island) and of a classic MCU-based ECU (AUTOSAR Classic). Highlighted modules matter for this topic. Click any module to open its page.

HPC · application processor (MPU) and safety island (MCU)
  • AUTOSAR Adaptive — Manages application process lifecycles, operating states and typed service interfaces through AUTOSAR Adaptive.
  • SOME/IP · DDS — Carries service communication using SOME/IP or DDS, with configured discovery, subscriptions and delivery policies.
MCU-based ECU · AUTOSAR Classic

Not directly involved on this node type.