Contents

Applications on the HPC application processor

The HPC application processor runs compute-heavy vehicle features, user interfaces, and driver-assistance applications that can evolve through controlled software updates.

What runs here

This layer implements vehicle features on the HPC’s application processor: the Cortex-A class CPU cores and, where available, GPU or neural processing unit (NPU). Applications turn sensor data, vehicle state, and user requests into useful behavior.

Component Role
Feature services Coordinate functions such as personalization, charging preferences, or cabin comfort across several ECUs.
Human–machine interface (HMI) applications Present information and accept input through displays, touch, voice, or other controls.
Driver-assistance applications Perform allocated tasks such as perception, sensor fusion, or trajectory planning.
Application configuration and models Supply feature settings, calibration data, and machine-learning models under version control.

These applications consume middleware and platform services. The OTA client, diagnostic server, host intrusion detection, operating system, and hypervisor belong to supporting layers. An application may expose health information or participate in an update without owning those mechanisms.

Why it looks like this

Application processors support large software stacks, rich graphics, and workloads that benefit from parallel computation. GPUs and NPUs can accelerate suitable algorithms, but introduce dependencies on drivers, runtimes, memory movement, and supported model operations.

Consolidating features can reduce duplicated compute hardware and simplify access to shared data. The tradeoff is contention: applications compete for CPU time, memory bandwidth, accelerators, and thermal capacity. High average throughput does not establish a bounded response time. Driver-assistance pipelines need explicit deadlines and data-age limits; HMI work needs responsive interaction and predictable startup.

The grid’s QM–ASIL B label describes the intended allocation here, not an inherent property of Cortex-A cores or every application. QM means quality management without an assigned ASIL. Safety-related software needs requirements, development evidence, and suitable supporting mechanisms; hardware capability alone does not establish compliance. Higher-integrity responsibilities may be allocated elsewhere through the system safety architecture. ISO 26262 overview

Feature software often changes faster than its platform. Separate deployment is feasible only when interfaces, dependencies, resource budgets, and safety assumptions remain compatible. An application update still needs vehicle-level impact assessment and validation within the applicable software update management process. UN Regulation No. 156

How it connects

Above this layer are user interactions and vehicle-level feature behavior. Peer applications exchange requests, events, or data through defined interfaces. Below it, middleware provides communication and lifecycle APIs; platform services provide facilities such as persistence, diagnostics, logging, and update support.

On AUTOSAR Adaptive, applications can use Communication Management through ara::com. Execution Management launches application processes according to configured manifests and dependencies. Other application environments may use different APIs; an HPC need not run every application on Adaptive. AUTOSAR Adaptive Platform

Across nodes, applications may communicate through SOME/IP or DDS over Ethernet, with gateways translating to MCU-facing interfaces where required. High-bandwidth sensor paths may use dedicated interfaces. Contracts should define units, timestamps, validity, coordinate frames, timeouts, and behavior when a provider disappears.

An application requesting motion should pass a defined command to the responsible control function. The receiving controller applies the checks and authority limits allocated by the architecture. Local communication with a safety island similarly needs explicit freshness, fault-response, and ownership rules.

Compared with other node classes

  • HPC safety island: Applications emphasize bounded real-time control and safety monitoring, with deliberately controlled dependencies on the application processor.
  • Zone controller: Application logic concentrates on nearby I/O, gateway behavior, and local coordination rather than rich graphics or large perception workloads.
  • MCU-based ECU: Application software components commonly execute through an AUTOSAR Classic RTE with statically configured tasks and communication.
  • Smart node / LIN slave: Firmware usually implements a narrow motor, lamp, or sensor function with limited memory and deployment flexibility.

Best practices

  • Define versioned service contracts, including failure behavior, and test compatibility across supported vehicle configurations.
  • Budget CPU, memory, accelerator use, bandwidth, and startup time; verify deadlines under contention and thermal constraints.
  • Assign safety responsibilities explicitly and demonstrate required freedom from interference between applications sharing resources.
  • Package executable code, models, calibration, and persistent-data migrations with traceable dependencies and tested recovery behavior.
  • Validate perception and decision behavior against relevant operating scenarios and functional limitations, alongside fault testing. ISO 21448:2022
  • Provide actionable health and diagnostic information while minimizing sensitive data in logs.

Common pitfalls

  • Treating a process, container, or virtual machine boundary as sufficient evidence of safety isolation.
  • Assuming independently packaged applications can be updated without checking providers, consumers, models, and stored data.
  • Accepting stale sensor data or delayed commands because network delivery succeeded.
  • Making essential control depend on an HMI process or an unavailable remote service without a defined degraded behavior.

What it means for your discipline

  • HPC & application software Core

    Implements feature behavior, service contracts, and application lifecycle handling. Tests timing, dependency compatibility, and recovery across supported application versions.

  • E/E architecture Core

    Allocates functions between application processors, safety islands, and other ECUs. Defines service ownership, resource budgets, and deployment boundaries.

  • Functional safety Partial

    Derives application safety requirements and assesses shared-resource interference and failure responses. Reviews whether application or model changes affect the safety argument.

  • Cybersecurity Partial

    Defines application permissions and protection for exposed interfaces and sensitive data. Reviews dependencies and update content for attack paths.

  • Software update & OTA Partial

    Tracks application, model, calibration and platform dependencies when assembling update packages. Coordinates activation, health checks and recovery, including persistent-data compatibility, across supported vehicle configurations.

No direct stake: Base software · Hardware & silicon · Networks & communication · 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)
  • Cockpit & IVI apps — Runs HMI, media and navigation applications with defined responsiveness, startup and platform compatibility requirements.
  • ADAS functions — Runs perception, fusion and planning applications with explicit deadlines, data validity rules and validated model dependencies.
  • Vehicle services — Coordinates vehicle features through versioned service contracts with defined resource budgets and failure behavior.
MCU-based ECU · AUTOSAR Classic

Not directly involved on this node type.