Contents

Virtualisation & partitioning on the MCU-based ECU

Hardware memory protection and operating-system controls help software of different safety criticalities share an MCU without disrupting one another.

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

What runs here

On a brake, steering or battery-management ECU, partitioning usually forms part of the real-time operating system and its hardware configuration. Several software partitions share one MCU and OS instance. Here, MPU means memory protection unit: hardware that checks memory accesses against configured permissions.

In AUTOSAR Classic, an OS-Application groups tasks, interrupt handlers and other OS objects under a protection boundary. It is different from an application software component (SWC); their mapping must be designed explicitly.

Component Role
MPU configuration Restricts access to memory regions according to the executing software’s permissions.
OS-Applications and access rules Define ownership of OS objects and permitted interactions.
OS timing protection Supervises configured execution, locking and arrival limits.
ProtectionHook Supports a configured response when the OS detects a protection violation.

AUTOSAR OS scalability class SC3 provides memory protection, SC2 provides timing protection, and SC4 combines both. The selected implementation and configuration must provide the protections the design requires. These mechanisms are specified in the AUTOSAR Classic Platform Specification of Operating System.

Why it looks like this

Control ECUs must deliver predictable responses with limited RAM, embedded flash and processing capacity. Sharing an MCU can reduce hardware cost while keeping tightly coupled control functions close to their peripherals. Static partition layouts make memory ownership and resource demand easier to review.

For mixed-criticality software, the engineering objective is freedom from interference: faults in one element must not invalidate another element’s safety requirements. An MPU addresses certain memory-access faults; it cannot stop every source of interference. Interrupt load, peripheral access, DMA transfers and shared hardware resources also need analysis.

Timing protection complements scheduling analysis. AUTOSAR OS does not provide deadline monitoring through its timing-protection mechanism; meeting deadlines still requires a justified schedule and appropriate supervision.

ASIL belongs to safety requirements and their allocation. Putting software inside a protected partition does not automatically make it suitable for ASIL D. The software architecture, verification and integration evidence remain part of the work described by ISO 26262-6:2018.

Updates also affect the argument: changing code, linker placement or execution demand can invalidate partition assumptions even when interfaces remain unchanged.

How it connects

Above this cell, application SWCs use the RTE and configured service interfaces. Crossing a protection boundary requires an explicit communication path. AUTOSAR OS provides IOC, or Inter-OS-Application Communicator, for communication between OS-Applications. Trusted functions provide controlled calls into trusted OS-Applications; their permissions and input handling deserve particular scrutiny.

Below it, the OS relies on processor privilege controls, protection hardware and timers. Linker sections must match the intended memory permissions. Drivers and shared BSW services need clear ownership because access to a peripheral can affect several partitions.

Across nodes, local partitioning ends at the ECU boundary. Network interfaces need their own timing contracts, validation and, where required, end-to-end protection. A protected receive buffer does not establish that an incoming control value is correct or fresh.

Compared with other node classes

  • HPC application processor: A Type-1 hypervisor can separate guest operating systems. MCU partitioning here separates software within a shared OS instance.
  • HPC safety island: Separate cores provide another physical boundary, but shared interconnects, memory and peripherals still need interference analysis.
  • Zone controller: The same MPU approach applies, with partition design shaped by local I/O, gateway traffic and power-control responsibilities.
  • Smart node / LIN slave: This grid assumes no dedicated partitioning layer; the simpler software still needs suitable fault handling.

Best practices

  • Define memory ownership, permitted communication and timing assumptions before configuring partitions.
  • Review the actual MCU protection coverage, including DMA and peripheral access; do not assume CPU permissions cover every bus master.
  • Keep privileged code and trusted interfaces small. Validate arguments and bound service execution.
  • Analyse worst-case execution and blocking under credible interrupt and communication loads.
  • Inject memory and timing faults to verify detection and the intended safe or degraded response.
  • Recheck memory maps, budgets and safety evidence after software, compiler, linker or configuration changes.

Common pitfalls

  • Treating MPU isolation as complete freedom from interference, or treating lockstep execution as a substitute for partitioning.
  • Sharing writable buffers without ownership, consistency and failure-handling rules.
  • Terminating a faulty partition without considering actuator outputs, held resources and dependent functions.
  • Assuming partitions can be updated independently despite a shared executable, configuration and safety argument.

What it means for your discipline

  • Base software Core

    Configure OS-Applications, protection rules, linker mappings and fault hooks. Check that generated configuration and privileged services preserve the intended boundaries.

  • Functional safety Core

    Define the required freedom from interference and assess the supporting analysis and fault-injection evidence. Determine how partition failures affect safety requirements and degraded operation.

  • HPC & application software Partial

    Keep application code within its assigned memory and execution budgets. Use approved interfaces across partitions and handle unavailable or invalid data.

  • Hardware & silicon Partial

    Establish which memory, peripherals and bus masters the MCU can protect. Supply the hardware constraints needed for partition configuration and interference analysis.

  • Software update & OTA Partial

    Defines update boundaries around shared executables, linker layouts and OS configuration. Checks whether partitions can actually be updated independently and includes dependent software in installation and rollback plans.

No direct stake: E/E architecture · Cybersecurity · 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)

Not directly involved on this node type.

MCU-based ECU · AUTOSAR Classic
  • OS — Defines OS-Application boundaries, controls permitted interactions, and handles configured memory and timing protection violations.
  • Microcontroller · HSM — Provides memory protection hardware, privilege controls and timers; DMA and peripheral protection coverage must be checked separately.