What runs here
The AUTOSAR Classic Operating System (Os) gives gateway processing, local I/O control and supporting software predictable opportunities to run. Multi-core operation uses a configured assignment: tasks belong to OS-Applications assigned to particular cores, with scheduling performed per core. Adding cores therefore requires deliberate allocation of work.
| Component | Role |
|---|---|
| Tasks and interrupt service routines (ISRs) | Execute scheduled work and respond to hardware events. |
| Counters, alarms and schedule tables | Trigger configured actions and periodic processing. |
| OS-Applications | Group OS objects and define protection and access boundaries. |
| Resources and spinlocks | Coordinate access to shared state within a core or across cores. |
| Inter-OS-Application Communicator (IOC) | Transfers data across OS-Application boundaries, including between cores. |
Protection capabilities depend on the selected scalability class and implementation. Memory protection restricts access; timing protection monitors configured execution, arrival and locking limits. These mechanisms do not automatically prove that every deadline is met. See the AUTOSAR Specification of Operating System.
Why it looks like this
A zone controller combines workloads with different urgency. A local actuator response may have a tighter deadline than diagnostic processing, while gateway traffic can arrive in bursts. Priorities, bounded interrupt handling and deliberate core allocation help keep these workloads predictable.
Several MCU cores provide processing capacity for consolidating functions, but introduce contention for shared memory, interconnects and peripherals. Moving work to another core can increase communication and synchronization costs. Allocation should follow measured execution demand and data dependencies.
An MCU offers direct peripheral access and a constrained memory budget. Static OS configuration makes resource use explicit, although integration and verification effort remain significant costs. Consolidation can reduce separate controllers while increasing the engineering effort needed to demonstrate interference control.
Where functions have different Automotive Safety Integrity Levels (ASILs), protection mechanisms support the safety argument. The ASIL belongs to allocated safety requirements; installing a particular OS does not make the whole controller ASIL D. Software development and verification must address the applicable requirements of ISO 26262-6:2018.
Updates can change execution demand, stack use and communication patterns. Even a small gateway feature change can require renewed timing and protection analysis.
How it connects
Above the OS, the generated Runtime Environment (RTE) maps application runnables to tasks and execution events. Basic Software modules also require scheduled execution; the integration defines when their main functions run. RTE configuration and OS configuration must agree on activation patterns and execution context.
Below it, the OS port uses MCU interrupt, timer and protection facilities. MCAL drivers and complex drivers interact with peripherals under configured interrupt and task contexts. Memory protection unit (MPU) settings must match the intended OS-Application boundaries; DMA and other bus masters need separate consideration.
Between cores, IOC provides explicit data-transfer interfaces, while shared-memory designs need synchronization and memory-visibility rules. Between nodes, CAN or Ethernet stacks carry messages. The OS schedules local processing; it does not provide vehicle-wide network scheduling or end-to-end freshness guarantees. AUTOSAR describes these architectural boundaries in its Classic Platform overview.
Compared with other node classes
- HPC application processor: Linux, QNX or Android environments support richer process and application models, potentially within virtual machines; their scheduling and isolation arrangements differ from this statically configured MCU integration.
- HPC safety island: AUTOSAR OS or a safety RTOS serves a dedicated MCU subsystem, with particular attention to supervision and communication with the application processor.
- MCU-based ECU: The same OS concepts apply, but a narrower function set may require fewer cores and less cross-core coordination.
- Smart node or LIN slave: Bare-metal execution or a tiny scheduler can suit limited workloads; coordination and fault handling remain explicit design responsibilities.
Best practices
- Allocate tasks, interrupts and peripheral ownership together; minimize unnecessary cross-core dependencies.
- Analyse worst-case response times, including interrupt load, blocking, communication and shared-hardware contention.
- Keep spinlock sections short, define a consistent acquisition order and bound waiting time.
- Configure protection boundaries and permitted accesses explicitly; review trusted code and shared buffers carefully.
- Define fault reactions with the safety architecture, then test overload, protection violations and startup failures.
- Reassess timing, stack margins and generated configuration after software or calibration changes.
Common pitfalls
- Assuming spare average CPU capacity proves that deadlines will be met.
- Treating separate cores as complete isolation despite shared hardware and privileged software.
- Confusing timing protection with end-to-end deadline monitoring, or treating a protection hook as a complete recovery strategy.