Contents

Operating system on the HPC safety island (MCU)

A small real-time operating system schedules safety control and monitoring tasks on the HPC’s dedicated MCU cores, with predictable execution and controlled fault handling.

3 min read · Discipline stake: BSW Safety Hardware Software

What runs here

The safety island runs an AUTOSAR Classic Operating System (OS), or another safety-oriented real-time operating system (RTOS). Its workload includes control loops, supervision and fault reactions allocated to the island by the system architecture.

Component Role
Task scheduler Runs configured tasks according to priorities and preemption rules.
Interrupt handling Responds to timers, peripheral events and fault notifications.
Counters, alarms and schedule tables Trigger periodic work and planned task activations.
Resource and event services Coordinate shared data and task execution.
Protection mechanisms and hooks Detect configured violations and invoke defined reactions.

AUTOSAR OS normally uses statically configured tasks, stacks and OS objects. Static configuration still allows event-driven execution. Memory and timing protection depend on the selected scalability class, hardware and configuration; they are not present in every deployment. See the AUTOSAR Specification of Operating System.

“Certified up to ASIL D” must describe a particular implementation and its assessed scope. AUTOSAR conformance alone does not establish suitability for ASIL D, and an OS certificate does not certify the integrated vehicle function.

Why it looks like this

Safety monitoring needs bounded response times, including when application processors are overloaded or faulty. A small RTOS lets engineers analyse execution times, interrupt interference and blocking without hosting the application processor’s full software environment.

Local SRAM and dedicated real-time cores can reduce dependence on shared resources. Lockstep execution compares redundant hardware execution to detect certain faults; the paired cores typically execute one software workload. They do not provide two independent scheduling resources.

Physical separation helps contain faults, but shared interconnects, memory, clocks, power and reset controls still require analysis. The actual boundaries are silicon-specific; TI’s safety architecture overview illustrates mechanisms for controlling access to shared resources.

Memory capacity and verification effort favour a small, stable configuration. Safety software may follow a more controlled update cadence than user-facing applications, while retaining compatible interfaces across releases. OS selection and integration must support the software safety lifecycle described in ISO 26262-6:2018.

How it connects

Above the OS, the AUTOSAR Classic Runtime Environment (RTE) maps application runnables to tasks. Basic software main functions also need scheduled execution. Watchdog Manager (WdgM), communication protection and fault memory use this execution environment but remain separate services.

Below, the OS port uses processor exceptions, timers and protection hardware. MCAL supplies peripheral drivers alongside this processor-specific integration; the OS does not necessarily access every hardware facility through MCAL.

Communication with application processors commonly uses shared-memory buffers and mailbox interrupts through platform-specific software. Define buffer ownership, memory ordering, cache handling, timeouts and restart behaviour. AUTOSAR’s Inter-OS-Application Communicator (IOC) supports configured communication between OS-Applications, including across supported cores; it is not automatically a bridge to Linux or another independently running OS. External vehicle communication passes through drivers and communication stacks.

Compared with other node classes

  • HPC application processor: Linux, QNX or Android instances support richer application environments; the safety island concentrates on a bounded safety workload with explicit dependencies on those instances.
  • Zone controller: AUTOSAR OS may coordinate multiple independently executing cores and many local I/O activities, making task placement and shared-resource contention prominent.
  • MCU-based ECU: The OS model is similar, but the safety island must also address interference and coordinated recovery inside a shared HPC SoC.
  • Smart node / LIN slave: Bare metal or a tiny scheduler can suit a sufficiently simple workload; its timing and fault behaviour still need justification.

Best practices

  • Derive task periods, priorities, deadlines and fault reactions from allocated requirements; include interrupt load and resource blocking in timing analysis.
  • Match the OS version, processor port, compiler and configuration to supplier safety evidence and safety-manual assumptions.
  • Configure memory access, stack sizes and timing protection deliberately. Execution budgets alone do not establish end-to-end deadline compliance.
  • Keep essential monitoring and safe-state actions executable during application-processor failure, according to the safety concept.
  • Bound cross-processor communication and test stale data, interrupt floods, missing messages and independent restarts.
  • Reassess timing, protection and interface compatibility after updates, including changes on the application processor.

Common pitfalls

  • Treating lockstep cores as independent cores for extra application throughput.
  • Assuming dedicated cores eliminate interference from DMA, shared memory or reset dependencies.
  • Equating OS protection with complete freedom from interference, or feeding a watchdog without checking meaningful application progress.

What it means for your discipline

  • Base software Core

    Configures tasks, interrupts, stacks, protection and OS hooks, and integrates RTE and basic software scheduling. Checks that the processor port and generated configuration satisfy timing and supplier assumptions.

  • Functional safety Core

    Allocates timing and fault-containment requirements and evaluates the OS safety evidence. Defines fault reactions and verifies freedom from interference and safe-state behaviour.

  • Hardware & silicon Partial

    Explains which memories, timers, interrupts and reset domains remain available during faults. Supplies the silicon constraints needed to configure protection and analyse shared-resource interference.

  • HPC & application software Partial

    Designs bounded runnables and explicit communication contracts. Provides execution-time evidence and handles unavailable peers, stale inputs and restart transitions.

No direct stake: E/E architecture · Cybersecurity · Networks & communication · Diagnostics & lifecycle · Software update & OTA

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 OS — Schedules island tasks and interrupts, with configured memory protection, timing protection and fault hooks.
MCU-based ECU · AUTOSAR Classic

Not directly involved on this node type.