Module 12 · Lesson 1 of 26

Automotive E/E architectures: from ECUs to domain, zonal and HPC; the software-defined vehicle

From one ECU per function to domain, zonal and HPC: why central compute and the software-defined vehicle force POSIX, SOME/IP and hypervisors.

  • Beginner to advanced
  • 28 min read
  • 45 min lab
What you will need

A laptop with a text editor and a diagramming tool; Ubuntu 24.04 (WSL2, VM or container) and a board for the Ethernet and SOME/IP exercises in later sessions

By the end you can 7 objectives
  • Define ECU, E/E architecture, domain controller, zone controller and HPC and place each in a vehicle topology
  • Explain why the distributed architecture was replaced and what each successor buys
  • Compare signal-based CAN and service-oriented SOME/IP communication and the gateway between them
  • Justify why central compute requires a POSIX OS and a hypervisor for mixed ASIL
  • Analyse a vehicle function set and map it onto domain, zonal and HPC architectures with bus and ASIL placement
  • Trace an SDV application from service registration through OTA update to rollback
  • Evaluate fail-safe versus fail-operational design and the partitioning cost of mixed criticality
Read the lesson below; the video will appear here when published.
01

Why the car is a distributed computer

3 min read

A (electronic control unit) is the basic building block. Each ECU is a microcontroller with a power supply, input/output pins, and a transceiver for one or more vehicle buses. A premium car can contain more than a hundred of them: one manages the engine, another the anti-lock brakes, another the airbags, another each door lock or window motor.

The overall plan of which ECUs exist, how they are connected, and where each function lives is the vehicle's (electrical/electronic architecture). "E/E" separates this logical and wiring plan from the mechanical design: engine, chassis and electronics are designed together, and the E/E architecture is the electronics half of that joint design.

The first cars with electronics had one or two ECUs, and the natural way to add a function was to add an ECU. An ECU sits physically near its sensors and actuators because those need short, reliable wiring and a dedicated, real-time control loop. That is why the industry grew a distributed architecture: one function per ECU, placed where the function is.

The cost of that choice is wiring. Every ECU needs power, ground and bus connections, and every sensor and actuator needs a wire to its ECU. The result, the wiring harness, is the spine of the car and one of its heaviest, most expensive, and hardest-to-package parts. In a premium car it can weigh tens of kilograms and run to several kilometres of wire; the industry often calls it one of the three heaviest and most expensive components, alongside the engine and the chassis. Each new function adds not just an ECU but metres of wire and connectors, and every change to the harness ripples through the whole vehicle.

Engineers should care about E/E architecture because it is the skeleton on which all automotive software hangs. This module is about Adaptive AUTOSAR, the standard middleware for the modern central-compute car. None of that makes sense without first understanding why the industry moved from hundreds of small ECUs to a few central computers, because that move is exactly what forced the operating-system and isolation choices the rest of this module builds on. The rest of this lesson tells that story from the wire up.

One ECU per function across the vehicleVehicle E/EPowertrain ECUengine controlChassis ECUsABS, stabilityBody ECUlocks, windows, lightsAirbag ECUrestraintInfotainmentradio, navigationInstrument clustergaugesVehicle E/EPowertrain ECUengine controlChassis ECUsABS, stabilityBody ECUlocks, windows, lightsAirbag ECUrestraintInfotainmentradio, navigationInstrument clustergauges
One ECU per function: a car as dozens of small computers joined by buses
02

How automotive E/E architecture evolved

4 min read

The first electronic controllers appeared in the late 1970s. Bosch's Motronic, introduced in 1979, combined digital ignition and fuel injection in one unit and set the pattern: a dedicated ECU for one function. Through the 1980s, anti-lock braking, airbags and body electronics each arrived as their own ECU, and the car became a small distributed system.

Communication came next. Bosch began developing the bus in 1983, presented it at the SAE congress in 1986, and the Mercedes-Benz W140 became the first production car to use it in 1991. CAN gave ECUs a shared two-wire bus so they could exchange small periodic frames instead of point-to-point wires. Because CAN was not cheap enough for a window motor or a seat switch, the consortium formed in the late 1990s and produced LIN 1.0 in 1999. For the most timing-critical chassis functions, the consortium (founded 2000) produced a time-triggered bus that first reached production in the BMW X5 in 2006.

In 2003 a group of carmakers and suppliers founded AUTOSAR (AUTomotive Open System ARchitecture) to standardise the software inside all those ECUs. The result, now called the Classic Platform, gave every ECU the same layered software structure and a "virtual functional bus" so a software component could communicate without knowing where its peer lived. Classic AUTOSAR remains the standard for the small, signal-based ECUs of the distributed and domain eras.

The two forces that created the modern architecture arrived in the 2010s. First, single-pair : the IEEE standardised 100BASE-T1 in 2015 and 1000BASE-T1 in 2016, giving the car a switched, high-bandwidth network cheap enough to carry the whole vehicle. Second, the realisation that infotainment and driver assistance needed far more compute than a microcontroller, and that their software needed a full operating system. BMW developed around 2011 as a service-oriented protocol for that Ethernet backbone, AUTOSAR published the first Adaptive Platform release in March 2017, and Tesla's Model 3 (2017) showed how far consolidation could go. Since 2020 the industry has converged on the phrase "software-defined vehicle" as the goal: decouple software from hardware, ship updates over the air, and treat the car as a compute platform.

Key turning points: Motronic (1979), CAN (1986), LIN 1.0 (1999), AUTOSAR Classic (2003), FlexRay in production (2006), SOME/IP (2011), 100BASE-T1 (2015), Adaptive Platform and Model 3 (2017), SDV (2020).

  • events: [{"date": "1979", "label": "Bosch Motronic", "detail": "The first widely used digital engine management, combining ignition and fuel injection in one ECU."}, {"date": "1986", "label": "CAN presented", "detail": "Bosch presents CAN at the SAE congress after starting work in 1983; the first production car follows in 1991."}, {"date": "1999", "label": "LIN 1.0", "detail": "A cheap single-wire sub-bus appears for simple body devices such as window motors."}, {"date": "2003", "label": "AUTOSAR Classic", "detail": "A consortium of carmakers and suppliers forms to standardise ECU software architecture."}, {"date": "2006", "label": "FlexRay in production", "detail": "The deterministic 10 Mbit/s bus debuts in the BMW X5."}, {"date": "2011", "label": "SOME/IP", "detail": "BMW develops a service-oriented middleware for Ethernet, later standardised by AUTOSAR."}, {"date": "2015", "label": "100BASE-T1", "detail": "The single-pair automotive Ethernet physical layer is standardised as IEEE 802.3bw."}, {"date": "2017", "label": "Adaptive Platform and Model 3", "detail": "AUTOSAR publishes its first Adaptive release; Tesla launches the heavily consolidated Model 3."}, {"date": "2020", "label": "Software-defined vehicle", "detail": "Volkswagen launches the ID.3 with central compute; over-the-air updates and the software-defined vehicle become the industry target."}]
Generations of automotive E/E architectureOne ECU perfunction1970s to1990sBus standardisationCAN, LIN,FlexRayAUTOSARClassic2003, ECUsoftwarestandardAutomotiveEthernet100BASE-T1,2015AdaptivePlatform2017,POSIX,SOME/IPZonal andHPCcentralcomputeSDVOTA, appstoreOne ECU perfunction1970s to1990sBus standardisationCAN, LIN,FlexRayAUTOSARClassic2003, ECUsoftwarestandardAutomotiveEthernet100BASE-T1,2015AdaptivePlatform2017,POSIX,SOME/IPZonal andHPCcentralcomputeSDVOTA, appstore
The generations of automotive E/E architecture from distributed to software-defined
03

The distributed architecture: one ECU per function

4 min read

In the classic distributed architecture every function is a dedicated ECU with a fixed job. The engine ECU controls injection and ignition; the ABS/ESP ECU controls braking stability; the airbag ECU fires restraints; a body ECU manages locks, windows and lights; separate ECUs drive the instrument cluster and the radio. Each ECU samples its own sensors, runs its own control loop, and drives its own actuators.

These ECUs talk over three main bus families. CAN is a multi-master bus that lets every ECU transmit small frames (up to 8 bytes of payload in classical CAN) and lets every other ECU see them; speeds up to 1 Mbit/s are typical, and the newer CAN FD variant raises the data rate and payload (up to 64 bytes) during the data phase. LIN is a cheap single-wire master/slave bus at up to 20 kbit/s, used for window motors, seat adjustment, switches and small sensors. FlexRay runs at 10 Mbit/s per channel with a deterministic, time-triggered schedule, which is why chassis and x-by-wire systems (functions that replace a mechanical control link with an electrical one) used it; MOST, a fibre-optic bus, carried infotainment and is now fading in favour of Ethernet.

Bus Speed Topology Typical use
CAN up to 1 Mbit/s (FD: higher, 64-byte frames) multi-master bus engine, body, chassis
LIN up to 20 kbit/s single-wire master/slave window motors, switches
FlexRay 10 Mbit/s per channel time-triggered, dual channel chassis, x-by-wire
Automotive Ethernet 100 Mbit/s to 10 Gbit/s switched point-to-point backbone, ADAS, cockpit

The buses do not all connect directly; a sits between them and forwards messages, for example from the powertrain CAN onto the body CAN, and exposes the diagnostic OBD-II connector. The gateway is the single integration point of the vehicle: every signal that crosses a bus boundary goes through it, so its routing table is a map of the whole car's communication.

Communication in this architecture is signal-based and completely static. Each ECU periodically transmits fixed signals, such as a wheel speed or an engine temperature, in fixed frames with fixed identifiers, and the consumers know in advance which identifier carries which signal. The whole map is captured in a document called the communication matrix, in practice a DBC file or the AUTOSAR system description: every frame, signal, cycle time and scaling is defined before the first prototype. There is no discovery and no dynamic binding; adding a signal means editing the matrix and re-flashing every affected ECU.

This model worked while cars had a few dozen ECUs, but it scales poorly. Each new function is a new ECU plus wiring plus a place in the harness and the matrix. The wiring harness, already one of the heaviest and most expensive parts of the car, grows with every feature. Each ECU is a recurring cost: a microcontroller, a connector, a power supply, a board and a housing. Every model variant and option package multiplies the matrix, because the same ECU must behave differently in every market and trim. And because nothing is discovered at runtime and nothing is updateable over the air, fixing a bug or adding a feature means a workshop visit and a flash.

Going deeperWhy the wiring harness dominates cost and risk

The harness is expensive for reasons beyond the copper. It is assembled largely by hand or by dedicated robots, because thousands of wires must be routed, crimped and taped into a shape that fits one specific body. It is one of the first components installed in assembly, so a mistake found downstream is hard to rework, and it is heavily variant-dependent, since every engine, trim and option changes which wires exist. A wiring change late in a programme is disproportionately expensive because it touches drawings, connectors, tooling and the physical build. That is why architectures are judged so heavily on harness metres and connector count, and why the zonal architecture's main selling point is not bandwidth but fewer, shorter wires.

The distributed topology around a gateway ECUGateway ECUPowertrain CANhigh-speed busEngine ECUGearbox ECUABS ECUBody CANlow-speed busDoor ECUSeat ECUChassis FlexRay10 Mbit/sSteering ECUSuspension ECULIN sub-bus20 kbit/sWindow motorMirror switchDiagnosticsOBD-II connectorGateway ECUPowertrain CANhigh-speed busEngine ECUGearbox ECUABS ECUBody CANlow-speed busDoor ECUSeat ECUChassis FlexRay10 Mbit/sSteering ECUSuspension ECULIN sub-bus20 kbit/sWindow motorMirror switchDiagnosticsOBD-II connector
The classic distributed topology: a gateway ECU between bus segments and LIN sub-buses
04

Domain architecture and the first consolidation

3 min read

A domain controller is a more powerful ECU that takes over the coordination, and often the software, of several related functions. The distributed architecture's "one function per ECU" gives way to a "one domain per controller" layout. The conventional domains are:

  • Powertrain: engine, transmission, electrification and thermal management.
  • Body: locks, windows, seats, lighting and climate.
  • Chassis: braking, steering and suspension.
  • Infotainment and telematics: display, audio, navigation and connectivity.
  • ADAS (advanced driver-assistance systems): radar, cameras, ultrasonic sensors and sensor fusion.

In a domain architecture each domain controller concentrates the higher-level logic of its domain, while the remaining small ECUs become smart sensors and actuators on the domain's local CAN or LIN sub-bus. The domain controllers then connect to each other through a central gateway, usually over a faster bus or early Ethernet.

What the move buys is real: fewer ECUs, less wiring, and functions that used to span several ECUs now running as software tasks inside one controller. It also means fewer separate suppliers per domain, easier diagnostics, and a natural first step toward updating software by domain rather than ECU by ECU. Several manufacturers moved to domain architectures through the 2010s.

What it does not buy is the end of the problems. Domains are still silos: a function that needs data from both the chassis and the ADAS domain must still go through the central gateway, with its latency and its static routing. Software is still tied to a specific ECU's hardware, because each domain controller is a bespoke box from a particular supplier. And the communication is still largely signal-based CAN, so the matrix problem persists inside and across domains. Domain architecture is consolidation by function, not by location or by platform, and the next two steps attack exactly those remaining costs.

Domain architecture with five domain controllersCentral gatewayPowertrain domaindomain controllerEngineGearboxThermalBody domaindomain controllerLocksWindowsSeatsChassis domaindomain controllerBrakingSteeringSuspensionInfotainment domaindomain controllerDisplayAudioTelematicsADAS domaindomain controllerRadarCamerasFusionCentral gatewayPowertrain domaindomain controllerEngineGearboxThermalBody domaindomain controllerLocksWindowsSeatsChassis domaindomain controllerBrakingSteeringSuspensionInfotainment domaindomain controllerDisplayAudioTelematicsADAS domaindomain controllerRadarCamerasFusion
Domain architecture: five domain controllers behind a central gateway
05

Zonal architecture and the Ethernet backbone

3 min read

Where domain architecture groups by function, zonal groups by place. A zone controller is an ECU mounted in a region of the car, such as front-left or rear-right, that gathers every nearby sensor and actuator over short local CAN or LIN links and connects them to the rest of the car over the Ethernet backbone. The same zone controller may, in one unit, handle a headlight, a door lock, a window motor and a side radar: functions from four different domains, unified by the fact that they live in the same corner of the car.

The point is the harness. In a distributed or domain car, a wire from the front of the car to the rear crosses the whole vehicle; in a zonal car, each device only needs a wire to its nearby zone controller, and only the zone controllers need to reach the centre. That converts long, heavy, parallel wiring into short local runs plus a few backbone cables. The saving in weight, cost, connector count and assembly time is the primary economic argument for zonal architecture.

The backbone is the second half of the idea. Because every zone controller is a gateway, the backbone becomes a switched Automotive Ethernet network, and the car gains a real data network with addressing, routing and quality of service instead of a broadcast bus. A function is no longer a box: it becomes software that can run where the compute is, reading its sensors and writing its actuators through the zones. That decoupling of function from location is the conceptual bridge to central compute and the software-defined vehicle.

Tesla's Model 3, launched in 2017, is the most-cited example of this shift in production: it consolidated most vehicle functions into a central compute module and a small number of body controllers, cutting the ECU count sharply compared with a conventional car of the same class. Zonal architecture is not a single standard; different manufacturers split the car into different numbers of zones and keep different amounts of logic in the zones versus the centre.

The transition has a cost. Moving every legacy function onto Ethernet means adapting dozens of CAN-speaking ECUs, and that is where the signal-to-service mapping of a later section comes from. A zonal car also concentrates risk: one zone controller now carries many functions, so its power supply, redundancy and software quality become critical in a way a door-lock ECU's never were.

Zonal architecture around an Ethernet backboneCentral computeon the Ethernet backboneFront-left zonezone controllerHeadlightDoorWindow motorFront-right zonezone controllerDoorMirrorSeatRear-left zonezone controllerDoorTail lightFuel pumpRear-right zonezone controllerDoorSeatTail lightCentral computeon the Ethernet backboneFront-left zonezone controllerHeadlightDoorWindow motorFront-right zonezone controllerDoorMirrorSeatRear-left zonezone controllerDoorTail lightFuel pumpRear-right zonezone controllerDoorSeatTail light
Zonal architecture: zone controllers near the hardware, an Ethernet backbone to central compute
06

HPC consolidation and the central compute SoC

3 min read

A (high-performance computer, also called a central compute unit) is a powerful central node, essentially a server for the car, built on a multi-core system-on-chip. It consolidates the functions that used to live in separate domain controllers, above all the cockpit and infotainment system and the ADAS stack, and increasingly the body and vehicle functions too.

The driving force is the workload. Infotainment needs a full graphics stack and an operating system rich enough to run a browser, a navigation stack and an app store. ADAS and automated driving need to ingest multiple cameras, radar and lidar, run sensor fusion and neural networks, and do it with bounded latency. Neither fits on the small microcontrollers of the classic ECU; both want general-purpose CPU cores, a GPU or NPU (neural processing unit) for inference, and gigabytes of memory. Consolidating them onto one SoC shares those expensive resources instead of duplicating them.

The SoCs used here are heterogeneous. Alongside many general-purpose application cores, they carry real-time cores, often lockstep pairs of Arm Cortex-R cores (two cores running the same code and comparing results) to run safety-critical control with deterministic timing, plus accelerators such as a GPU, an NPU, a DSP, a video codec and an image signal processor. This is a different animal from the single-core microcontroller of a door ECU, and it changes the software model completely: the HPC runs not a bare-metal loop but a full operating system, often more than one, which is the subject of the next section.

In production, this is the direction the industry has moved. Volkswagen's ID. family uses central compute units known as ICAS; Mercedes is consolidating onto its MB.OS hardware; Tesla has long run central computers for the vehicle and separate ones for driver assistance. The silicon comes from companies such as NVIDIA (DRIVE), Qualcomm (Snapdragon Ride and Cockpit) and Mobileye, alongside NXP and Renesas. The exact partitioning, how much runs centrally versus in a zone or a smart sensor, is a product decision rather than a fixed recipe, and it is one of the main things this lesson's lab asks you to justify.

Consolidation concentrates failure modes too. When one box runs the cluster and the braking support, a single hardware failure can take down several functions at once, so HPC platforms are designed with redundant power supplies and redundant communication paths, and with the fail-safe versus fail-operational reasoning developed in a later section.

The HPC software stackCockpit appsinfotainment, navigationADAS appsfusion, planningBody and vehicle appsconsolidated functionsHypervisor and OSesLinux, RTOS, QNXMulti-core SoCCPU, GPU, NPU, safety coreseach layer serves the one above itCockpit appsinfotainment, navigationADAS appsfusion, planningBody and vehicle appsconsolidated functionsHypervisor and OSesLinux, RTOS, QNXMulti-core SoCCPU, GPU, NPU, safety coreseach layer serves the one aboveit
The HPC software stack from multi-core SoC up to consolidated applications
07

Signal-based versus service-oriented communication

4 min read

SOME/IP is the protocol that carries service-oriented communication in the modern architecture. In the service-oriented model, a software component offers a service with methods (callable remotely, like a function call), events (published to subscribers), and fields (a value that can be read, written and subscribed to). Another component finds that service and uses it, without either side knowing where the other runs.

This is the opposite of the signal-based model. In signal-based communication the data is what matters: a producer broadcasts a raw signal on a fixed frame identifier and cycle, and any consumer that wants it knows the identifier in advance from the communication matrix. There is no concept of asking and no notion of a service; there are only shared signals. It is efficient, since a CAN frame carrying a handful of signals is tiny and fast, but completely static.

Service-oriented communication adds everything a dynamic system needs. SOME/IP carries a message header with a service ID and method ID that together identify the operation, a request ID pairing a request with its reply, and version fields; on top of it, SOME/IP-SD (service discovery) lets services announce themselves with an offer and lets clients search for them with a find and subscribe to their event groups over multicast, with a time-to-live so a dead service disappears. A client can start before its server, find it later, and rebind after a restart, none of which a signal matrix can express.

The two worlds must coexist for a long time, because hundreds of existing ECUs still speak CAN. The bridge is the gateway in each zone or domain controller. It performs signal-to-service mapping: it reads the CAN signals on one side and publishes or serves them as SOME/IP on the other. A wheel-speed signal that arrives as a raw CAN frame is translated into a structured event, say VehicleSpeed, that any service can subscribe to; a service request in the other direction is translated back into a CAN frame. The communication matrix remains the source of truth for the signal side, and the mapping is the contract that joins the old bus to the new network.

Step by stepSignal-to-service mapping at a zone controller
  1. Ingest: the zone controller receives a CAN frame carrying the wheel-speed signal on a known identifier

  2. Decode: it extracts and scales the raw signal using the communication matrix definition

  3. Represent: the value becomes a structured field of a vehicle-speed service

  4. Publish: SOME/IP-SD offers the service and pushes events to subscribed consumers

  5. Reverse path: a service method call, for example to lock a door, is encoded back into a CAN or LIN frame

  6. Forward: the frame is transmitted on the local bus to the actuator ECU

Going deeperSOME/IP and service discovery, at the level of the header

A SOME/IP message starts with a fixed header: a 32-bit message ID made of the service ID (bits 31 to 16) and the method or event ID (bits 15 to 0), a 32-bit length, a 32-bit request ID split into client ID and session ID, a protocol version byte, an interface version byte, a message type byte, and a return code byte. Message types distinguish requests, responses, errors and notifications, and the return code carries errors such as "unknown service" or "out of memory". Service discovery rides on top as specific message types, FindService, OfferService, Subscribe and SubscribeEventgroup, sent to a multicast group with a time-to-live in the header; an offered service that does not refresh its offer within that time is treated as gone. This is why SOME/IP scales to a dynamic, partially connected vehicle network where ECUs sleep, wake and rejoin, while a static signal matrix cannot.

Signal-based CAN versus service-oriented SOME/IPSignal-based(CAN)Service-oriented (SOME/IP)Addressingframe IDservice +method IDDiscoverystatic matrixSOME/IP-SD atruntimeData modelraw signalsmethods,events,fieldsTransportCAN framesEthernet,TCP/UDPBindingfixed atbuilddynamic,restartable
Signal-based CAN versus service-oriented SOME/IP across addressing, discovery, data model and transport
08

Why central compute forces a POSIX OS and a hypervisor

4 min read

A classic ECU runs bare metal or a tiny static RTOS: the AUTOSAR OS, derived from OSEK/VDX, a 1990s German-French standard for automotive real-time operating systems. It schedules tasks in a single address space with no memory protection, no file system and no processes. That model is perfect for one microcontroller doing one real-time job, and it cannot run the software of a central computer. A cockpit system needs processes, virtual memory, a file system, drivers, a graphics stack and a network stack, in short a general-purpose operating system with a POSIX interface.

The Adaptive AUTOSAR platform, which is the subject of this module, therefore specifies that its applications run on a POSIX operating system, with the PSE51 minimal real-time profile as the required baseline. PSE51 is the smallest POSIX profile: threads, mutexes, condition variables and real-time scheduling, but no file system and no process spawning. In practice the operating systems used are Linux, often with the PREEMPT_RT patches for bounded latency, and QNX, a commercial microkernel RTOS with a POSIX interface and a strong safety story. In the embedded-Linux world this is familiar territory: an automotive Linux is built with the same Yocto or Buildroot machinery as any other embedded Linux, and Automotive Grade Linux (AGL) is exactly such a distribution, aimed at the cockpit.

Why a hypervisor, then? Because one SoC must host software of very different criticality. ISO 26262 classifies each function's risk as an : ASIL A is the lowest, ASIL D the highest, and QM means quality managed, with no safety requirement. An HPC typically mixes QM infotainment with ASIL-B driver assistance and, often, ASIL-D vehicle-motion control on the same chip. Letting QM software sit directly beside ASIL-D software would be unacceptable: a bug or a resource storm in the infotainment stack could delay or corrupt the braking function. A partitions the SoC into isolated virtual machines, each with its own operating system and its own slice of CPU, memory and devices, so that no failure in one guest can reach another. That is the principle of freedom from interference, developed further in the next section.

The hypervisors used in production are type-1 (bare-metal) systems such as the QNX Hypervisor, SYSGO's PikeOS, OpenSynergy's COQOS and Green Hills INTEGRITY, which are certified for safety use; open alternatives such as Xen are also used, and Jailhouse demonstrates the static-partitioning approach of Linux alongside real-time cells. This is the same virtualization technology covered in module M11, and the next lesson of this module, "Classic vs Adaptive AUTOSAR; where Linux, POSIX (PSE51) and hypervisors fit", treats the operating-system and hypervisor question in full. Here the point is architectural: central compute is what made a POSIX OS and a hypervisor mandatory, and that is the load-bearing idea connecting this lesson to the rest of the module.

One SoC partitioned by a hypervisorInfotainmentQM, LinuxADAS perceptionASIL-B, Linux/RTOSVehicle controlASIL-D, RTOSHypervisorpartitions, freedom from interferenceSoC hardwarecores, cache, memory, I/Oeach guest isolated from the othersInfotainmentQM, LinuxADAS perceptionASIL-B, Linux/RTOSVehicle controlASIL-D, RTOSHypervisorpartitions, freedom frominterferenceSoC hardwarecores, cache, memory, I/Oeach guest isolated from theothers
One SoC partitioned by a hypervisor into QM, ASIL-B and ASIL-D guests
09

Mixed criticality, budgets, and the mistakes to avoid

5 min read

Mixed-criticality consolidation means one SoC runs ASIL-D control next to QM infotainment. The danger is interference: two software components sharing a chip can affect each other through every resource they hold in common. The interference channels are the CPU cores, the shared caches, the memory controller and its bandwidth, the on-chip interconnect, the I/O and DMA paths, and even the thermal budget, since one hot component raises the temperature of the whole die. Freedom from interference, a core ISO 26262 requirement, means demonstrating that no failure or misbehaviour in one partition can cause another partition to fail.

The standard defence is static partitioning. Assign each guest its own dedicated cores, carve out its own memory region, partition or colour the last-level cache so no guest can evict another's lines, give it its own I/O devices behind an IOMMU (I/O memory management unit, which confines DMA to the owning guest), and reserve memory-controller bandwidth. Then monitor the boundaries: a watchdog per partition, a health channel that the hypervisor supervises, and budget counters that trip before a guest can exceed its share.

Partitioning has a real price, and engineers routinely underestimate it. Dedicated cores sit idle when their guest is not busy; cache partitioning shrinks the effective cache for every guest and raises miss rates; fixed memory carve-outs waste RAM that another guest could use; reserved bandwidth caps peak performance. The cost of freedom from interference is silicon and power that no single function could justify on its own, and it is only worth paying because the alternative, certifying one giant mixed-criticality software stack, is worse.

Alongside isolation there is a budget problem. Compute must be budgeted per function, in DMIPS (a measure of integer CPU throughput) for control code and TOPS (trillions of operations per second) for neural-network inference, with headroom for the worst case. Power must be budgeted against the vehicle's supply and against heat: a sealed central unit in a hot car has a fixed thermal envelope, and it must throttle gracefully rather than shut down. Redundancy must be budgeted too. A fail-safe design stops safely on failure: the function degrades or disengages and warns the driver, which is acceptable while the human is the fallback. A fail-operational design must keep working after a failure, which is required when there is no human fallback, as in higher levels of automated driving; it needs duplicated compute, power and communication, and often diverse, independently developed channels, which roughly doubles the cost of the safety path.

The three architecture generations trade these costs differently:

Criterion Distributed Domain Zonal + HPC
Wiring heaviest lighter lightest, short local runs plus backbone
Bandwidth per-bus, low higher in-domain high backbone, switched
End-to-end latency bus arbitration, variable gateway hops predictable, QoS-capable
Cost per node many cheap ECUs fewer, larger ECUs few expensive compute nodes
Security perimeter many small endpoints fewer endpoints few, well-defended gateways

Common architecture mistakes

  • Symptom: the ASIL-D guest misses deadlines only under infotainment load. Cause: shared cache or memory bandwidth, an interference channel that was never partitioned. Diagnose with per-guest performance counters and cache-miss traces; fix by partitioning cache and reserving bandwidth.
  • Symptom: a zonal car still has a heavy harness. Cause: the team kept long point-to-point wiring and only renamed the boxes; zoning pays only when devices actually connect to the nearby zone. Diagnose from the wiring diagram; fix by re-homing each device to its zone.
  • Symptom: an Ethernet backbone that works in the lab jitters in the car. Cause: treating switched Ethernet as if it were deterministic without time-sensitive networking (TSN) for the streams that need it. Diagnose with per-stream latency measurements; fix with TSN schedules and stream priorities.
  • Symptom: a central unit throttles and drops features on a hot day. Cause: the thermal budget was sized for average rather than worst-case ambient and load. Diagnose by correlating frequency, power and temperature logs; fix by re-partitioning the workload or enlarging the thermal solution.
Going deeperThe price of partitioning, concretely

Partitioning is not a configuration flag; it is silicon you give away. Dedicated cores cannot be shared, so a guest that spikes cannot borrow a neighbour's idle core. Cache partitioning, by way-partitioning or page colouring, caps the lines a guest may fill, which lowers its effective cache and raises its miss rate and its memory traffic. Memory carve-outs fix addresses so a guest cannot grow into another, at the cost of stranding RAM. And a safety guest must be scheduled so nothing else can preempt or delay its critical tasks, which on shared hardware means reserving not just cores but interrupt routing, DMA channels and bus arbitration. The result is that a mixed-criticality SoC runs every guest worse than a dedicated chip of the same size would, which is exactly the trade the consolidation is making, and why the cost model is safety first and utilisation second.

Interference channels and how they are partitionedHow one guestdisturbsanotherPartitioningdefenceCPU coresstealsexecutiontimededicatedcores perguestLast-level cacheevicts theother guest'slinescachepartitioningor colouringMemory bandwidthsaturates theDRAMcontrollerbandwidthlimits andcarve-outsInterconnectcongestsshared busesstatic routesand QoSsettingsI/O and DMAwrites intoforeignmemoryIOMMU withstaticmappings
The shared-resource interference channels between partitions on one SoC
10

The software-defined vehicle and the new supply chain

5 min read

A (software-defined vehicle) is a car whose functions are defined by software that can be changed independently of the hardware it runs on. Today, most of a car's behaviour is fixed when the ECU is manufactured and can only be changed in a workshop by re-flashing. In an SDV the hardware is a stable compute platform, and features are software packages that can be deployed, updated and removed over the air (OTA).

The decoupling is the point. On the architecture of the previous sections, zonal controllers and HPCs on an Ethernet backbone, a feature is no longer a box with wires but an application with a service interface. Hardware and software get separate life cycles: the same platform can ship for years while the software changes monthly. OTA updates are the delivery mechanism, and they are now regulated: UNECE regulations R156 (software update management) and R155 (cybersecurity) require a managed, traceable update process with integrity checks, rollback and security, which is why OTA is an engineering discipline and not a convenience.

The end state the industry describes is an app-store model: third-party developers build apps against a published vehicle API, an OEM reviews and signs them, and they run in a sandbox on the car, the way a phone app runs on a phone. For that to work there must be a stable abstraction between the application and the car: a vehicle abstraction layer and hardware abstraction layer that present the car's services, such as speed, climate, doors and cameras, through one interface that is identical across vehicle lines and hardware generations. That abstraction is precisely what Adaptive AUTOSAR's runtime (the ARA interfaces) and the OEM platforms built on it, such as Volkswagen's Cariad stack or Mercedes' MB.OS, are meant to provide: write the app once, run it on any vehicle with the platform. Without that layer, every app would be a per-model integration, and the app-store economics would not close.

This shift reorders the supply chain. Classically the tiers were clean: the OEM (the carmaker) integrates; the Tier-1, a supplier such as Bosch, Continental or Denso, delivers a complete system, an ECU with its software; the Tier-2 supplies chips and components. Software sat inside the Tier-1's box, and the OEM often did not even own it. In an SDV world the software becomes the product and the differentiator, so OEMs build software in house, Volkswagen founded Cariad, Mercedes builds MB.OS, and Tesla has always been a software company, while Tier-1s reposition as software suppliers and integration partners, and Tier-2 chipmakers such as NVIDIA and Qualcomm gain influence because the silicon defines the compute platform. A "Tier-0.5" has even appeared: suppliers that work so closely with an OEM that they are effectively co-developers. The practical consequence for an engineer is that the skills in this module, POSIX, C++, service-oriented middleware and hypervisors, are now OEM- and platform-level skills, not hidden inside a supplier's black box.

Step by stepDeploying an SDV application end to end
  1. Package: the app is built against the vehicle API and signed with the OEM's key

  2. Stage: the OEM uploads the package to the update backend and targets a fleet or a set of vehicles

  3. Download: the vehicle's update client downloads and verifies the package signature and integrity

  4. Deploy: the app is installed into a sandbox and its services register with the runtime

  5. Discover: other services and the HMI find the new service through service discovery

  6. Monitor: the platform watches health, resources and telemetry of the new app

  7. Rollback: if health checks fail, the update is reverted to the previous known-good version

The developer ecosystem is not a free market

An automotive app store is not the phone app store. Apps can touch safety-relevant vehicle services, so the OEM reviews, signs, sandboxes and monitors them, and the vehicle API exposes a deliberately limited, safe subset of the car. Safety, cybersecurity and liability shape the ecosystem far more than convenience does.

The software-defined vehicle stackAppsreviewed, signed, sandboxedVehicle API / HALportable across vehicle linesAdaptive middlewareARA, SOME/IPOperating systemLinux or QNXStable hardwareHPC and zonesapps are decoupled from the hardware belowAppsreviewed, signed, sandboxedVehicle API / HALportable across vehicle linesAdaptive middlewareARA, SOME/IPOperating systemLinux or QNXStable hardwareHPC and zonesapps are decoupled from thehardware below
The SDV stack: apps above a vehicle abstraction layer, middleware and the OS on stable hardware
11

Try it

1 min read

Open the lab for this lesson and take the given function set, door locks, cameras and brake-by-wire, and map it onto domain, zonal and HPC architectures, justifying the gateway count, the bus types and the ASIL placement for each. Then sketch an SDV application end to end on paper: its service interface, how it registers and is discovered, the OTA path from a signed package to a running service, and the rollback trigger. Revisit the harness, bandwidth and security trade-off table for each of your three mappings and defend the cheapest design that still meets the safety goal. The practice pack has the templates and the step-by-step checklists for both exercises.

Key takeaways

  • A modern car is a distributed computer: over a hundred small ECUs, one per function, joined by CAN, LIN and FlexRay.
  • The wiring harness is the constraint: heavy, expensive and hard to package, it drove consolidation.
  • Domain architecture groups functions into domain controllers; zonal groups them by location around an Ethernet backbone.
  • HPC consolidation concentrates cockpit, ADAS and body functions on a few multi-core SoCs.
  • Signal-based CAN is static; service-oriented SOME/IP adds discovery, methods, events and dynamic binding.
  • Central compute needs a POSIX OS (Linux or QNX) and a hypervisor to separate QM from ASIL-D.
  • Mixed criticality is bought with partitioning: dedicated cores, cache and memory come at a performance cost.
  • The software-defined vehicle decouples software from hardware, ships OTA updates and reorders the supply chain.

Reflect

  1. Explain to a colleague, in two sentences: define ECU, E/E architecture, domain controller, zone controller and HPC and place each in a vehicle topology
  2. Which objective are you least sure about? Re-read that section, then do its exercise in the practice pack.
  3. What surprised you when you ran the commands yourself?

On a real board

Repeat the key commands on your Raspberry Pi or lab board over SSH or the serial console. Note anything that behaves differently from your PC, such as missing tools, a BusyBox shell or a read-only filesystem.

Practise this lessonExercises, quiz, interview preparation and spaced review

References and further reading

Official documentation first. Links checked when the lesson was published.

Find your next step

↑ ↓ to move · Enter to open · Esc to close