STATERA Library · Series 08 · Volume 03 · Chapter 10 · EN
Source: https://github.com/Statera-Library/08_Vol_03_Real_Time_Operating_Systems/blob/main/Chapter_10_Mixed_Criticality_Systems/Chapter_10_Mixed_Criticality_Systems_EN.md
Volume 03 Real Time Operating Systems
10. Mixed Criticality Systems
10.01 Mixed Criticality System Concepts: ASIL D and QM Coexistence
Mixed-criticality systems allow software with different assurance requirements to share computing hardware while preserving the timing, isolation, and fault-containment guarantees required by the most critical functions. In the attached structure, this topic begins Chapter 10 and establishes the conceptual foundation for later discussions of hypervisors, time partitioning, certification, safety compute, AI compute, and verification.
A representative automotive or robotic platform may contain ASIL D functions together with Quality Management, or QM, functions. ASIL D represents the highest Automotive Safety Integrity Level defined by ISO 26262 and is associated with functions whose failures can contribute to severe hazardous situations. QM software is not assigned an ASIL requirement and can therefore be developed under conventional quality processes when safety analysis demonstrates that no additional functional-safety measures are required.
Coexistence does not mean that ASIL D and QM software simply execute beside each other without restrictions. The fundamental architectural requirement is freedom from interference. A failure, overload, memory corruption, timing anomaly, or uncontrolled resource consumption originating in a QM application must not invalidate the assumptions used to demonstrate the safety of the ASIL D function. The shared platform must therefore establish explicit boundaries around resources that can influence safety behavior.
Spatial isolation protects memory and device resources. An MPU, MMU, IOMMU, operating-system protection mechanism, or hypervisor can prevent a QM component from reading or overwriting memory owned by an ASIL D partition. Peripheral access must be controlled with similar rigor because unrestricted DMA or device register access can bypass ordinary CPU memory protection. Isolation consequently includes memory regions, DMA buffers, interrupt sources, communication endpoints, and hardware ownership.
Temporal isolation addresses interference caused by execution time rather than memory access. A computationally expensive QM task must not consume CPU capacity indefinitely and cause an ASIL D control task to miss its deadline. Priority scheduling, CPU affinity, execution budgets, cyclic scheduling, and static time partitions can reserve predictable processing opportunities. Worst-case execution and response-time analysis must consider interference from every resource that remains shared between criticality domains.
Mixed-criticality scheduling extends conventional real-time scheduling by recognizing that tasks have different levels of assurance and potentially different execution assumptions. Under normal operation, processors may execute both critical and noncritical workloads efficiently. When execution demand exceeds predefined assumptions or the system enters a degraded condition, scheduling policy can protect higher-criticality tasks by reducing, suspending, or eliminating lower-criticality workloads while maintaining essential safety functions.
Resource sharing is especially important because CPU partitioning alone does not guarantee isolation. Caches, memory controllers, DRAM bandwidth, interconnects, GPUs, storage devices, network interfaces, and interrupt controllers may introduce indirect interference. A QM AI workload can generate intensive memory and accelerator traffic even when it runs on a separate core. Mixed-criticality architecture therefore requires analysis of shared hardware paths and mechanisms for bounding or monitoring their interference.
Communication across criticality boundaries must be deliberately constrained. An ASIL D component may legitimately consume information generated by a QM perception or planning function, but that information cannot automatically inherit ASIL D integrity. The safety domain must treat lower-assurance information according to its safety assumptions, applying mechanisms such as range checking, plausibility validation, timeout supervision, sequence monitoring, freshness checking, redundancy, or independent safety constraints before acting on it.
This distinction is particularly relevant to autonomous vehicles and intelligent robots. A high-performance AI computer may perform perception, semantic reasoning, trajectory generation, or learned policy inference, while a smaller safety controller independently supervises velocity, braking, steering limits, collision conditions, or emergency stopping. The AI subsystem can improve capability without becoming the sole authority for safety. The safety path retains sufficient independence to detect unacceptable behavior and transition the machine toward a safe state.
Fault containment is therefore a central design objective. Hardware exceptions, software crashes, deadline overruns, communication failures, and resource exhaustion should remain within defined containment regions whenever possible. Watchdogs, health monitors, heartbeat mechanisms, deadline monitors, memory protection, exception handlers, and partition supervisors provide complementary detection layers. Recovery may involve restarting a QM application, isolating a partition, switching to degraded operation, or commanding a controlled safe stop.
A useful conceptual separation exists between functional behavior and safety authority. The QM domain may provide sophisticated functionality whose output is valuable during normal operation, while the ASIL D domain determines whether commands remain inside verified safety constraints. This avoids forcing every advanced algorithm into the highest assurance process while still preventing an uncertified component from obtaining unrestricted control over safety-critical actuators or system states.
Mixed-criticality design also affects the operating-system architecture. A single RTOS may separate applications using protection domains, or multiple operating systems may execute in isolated virtual machines or partitions. A hypervisor can allocate CPUs, memory, interrupts, and devices between domains and mediate selected communication paths. The appropriate solution depends on timing requirements, hardware architecture, failure assumptions, certification strategy, and how strongly the safety case depends on the isolation mechanism.
The concept of decomposition is important when allocating safety requirements. Instead of implementing an entire complex application as one ASIL D component, architecture may distribute safety responsibilities across sufficiently independent elements when permitted by the applicable safety analysis and standard. Such decomposition is not merely a software packaging technique. Independence assumptions, common-cause failures, communication dependencies, shared hardware, and verification evidence must all support the intended safety argument.
The ASIL D and QM boundary should therefore be established early in system architecture rather than added after software implementation. Engineers identify safety goals, hazardous behaviors, safety-related control paths, required fault reactions, and the components capable of violating those goals. These results guide partition placement and resource allocation. A well-defined boundary also clarifies which software requires rigorous safety lifecycle evidence and which functionality can evolve more rapidly under QM processes.
Verification must demonstrate both correct operation and effective isolation. Testing should intentionally stress QM workloads, exhaust communication bandwidth, generate interrupt storms, provoke memory faults, delay messages, overload processors, and crash noncritical applications while observing the safety domain. The important question is not simply whether the ASIL D function works under ideal conditions, but whether its required timing and safety behavior remain valid while neighboring components behave abnormally.
For robotics, mixed-criticality architecture becomes increasingly important as deterministic control and nondeterministic AI computation converge on shared edge platforms. Motor control, emergency stopping, power management, and safety supervision may require tightly bounded behavior, while vision models, world models, VLA policies, mapping, and optimization workloads can exhibit variable execution times. Treating every workload identically either weakens safety assurance or unnecessarily constrains computationally intensive intelligence.
The practical objective is therefore controlled coexistence rather than complete physical separation. ASIL D and QM workloads may share a processor, system-on-chip, network, or computing enclosure when architecture provides sufficient spatial isolation, temporal isolation, controlled communication, resource management, monitoring, and fault containment. This principle forms the basis for the subsequent Chapter 10 topics covering hypervisor isolation, AUTOSAR mixed platforms, safety-critical task monitoring, communication channels, time partitioning, certification, and safety/AI compute coexistence.
10.02 Hypervisor-Based Isolation: Jailhouse, Xen, KVM-RT
Hypervisor-based isolation provides a hardware-assisted method for running workloads with different timing, safety, and functional requirements on the same computing platform. Within a mixed-criticality system, the hypervisor establishes boundaries between operating systems or execution domains so that faults in a general-purpose or QM workload do not directly propagate into a safety-critical real-time domain. Jailhouse, Xen, and KVM represent different architectural approaches to this isolation problem.
A hypervisor operates between physical hardware and one or more software domains, controlling access to CPUs, memory, interrupts, and peripheral devices. Hardware virtualization extensions such as Intel VT-x, AMD-V, and Arm virtualization support reduce the amount of privileged software required for isolation. Memory virtualization and IOMMU mechanisms additionally prevent unauthorized memory and DMA access, allowing independently managed software environments to coexist while maintaining explicit resource ownership.
Real-time virtualization differs from conventional server virtualization because average throughput is less important than bounded interference and predictable latency. A safety-critical task must retain its assigned processor time even when another virtual machine performs intensive computation, networking, or storage operations. Therefore, RT-oriented configurations commonly dedicate CPU cores, pin virtual CPUs to physical CPUs, control interrupt affinity, preallocate memory, and minimize dynamic resource management during critical operation.
Jailhouse follows a static partitioning philosophy and is particularly attractive when strong separation and low virtualization overhead are required. Rather than continuously scheduling virtual machines like a conventional cloud hypervisor, Jailhouse can divide a running multicore system into isolated cells. Linux typically boots first and configures the platform, after which selected CPU cores, memory regions, interrupts, and devices are removed from Linux and assigned exclusively to other cells.
This architecture makes Jailhouse conceptually suitable for robotic controllers that combine Linux-based applications with highly deterministic control software. Linux can operate in the root cell and execute networking, diagnostics, visualization, or high-level robotics functions, while another cell runs a small RTOS or bare-metal controller. Because resources can be statically assigned, the real-time cell can avoid many scheduling and resource-contention effects generated by the Linux environment.
Jailhouse nevertheless does not automatically guarantee complete temporal isolation. CPU cores may be dedicated while last-level caches, DRAM controllers, interconnects, or other shared hardware resources remain common between cells. A high-bandwidth Linux or AI workload can therefore influence memory access latency experienced by a real-time cell. System designers must analyze the complete hardware interference path rather than assuming that CPU and address-space separation alone establish deterministic behavior.
Xen uses a more general virtualization architecture capable of supporting multiple guest domains with sophisticated resource management. A privileged management domain, commonly called Domain 0, manages devices and guest lifecycle operations, while other domains execute guest operating systems. Xen supports several virtualization modes and can provide CPU allocation, memory separation, interrupt handling, device assignment, and inter-domain communication suitable for complex embedded and consolidated computing platforms.
For real-time use, Xen can employ scheduling policies and CPU-pinning strategies designed to improve determinism. Critical virtual CPUs can be assigned dedicated physical processors while less critical domains share remaining resources. Static memory allocation and direct device assignment can further reduce unpredictable interference. The resulting architecture can support combinations such as an RTOS safety domain, a Linux robotics domain, and additional service domains within a single multicore computing system.
The flexibility of Xen also introduces architectural complexity. Hypervisor scheduling, Domain 0 activities, virtualized device paths, interrupt routing, and shared backend services can contribute to latency if they are not carefully designed. Consequently, mixed-criticality Xen deployments usually seek to remove critical paths from shared services. Direct hardware assignment, dedicated cores, controlled communication channels, and minimized dependence on management-domain activity are valuable techniques for reducing timing variability.
KVM takes a different approach by integrating virtualization into the Linux kernel. With KVM, Linux itself provides the core virtualization infrastructure, while user-space components such as QEMU commonly provide virtual-machine device models and management. This architecture benefits from the extensive Linux ecosystem and hardware support, making KVM attractive when system consolidation, maintainability, compatibility, and access to conventional Linux development tools are major requirements.
Real-time KVM configurations normally combine KVM with a real-time capable host, particularly Linux with PREEMPT_RT, and apply additional tuning to the host and guests. Virtual CPUs can be pinned to isolated physical cores, host tasks can be excluded from critical CPUs, interrupt affinities can be controlled, and memory can be locked or preallocated. Huge pages and careful NUMA placement may further reduce latency variation caused by memory management and translation overhead.
The main challenge with KVM-RT is that deterministic execution depends on more than the guest operating system. Host scheduling, QEMU threads, virtual interrupt delivery, device emulation, kernel activity, and shared hardware resources can all affect guest latency. A real-time guest therefore cannot be considered isolated merely because its internal scheduler is deterministic. The complete host-to-hardware execution path must be configured and measured under realistic worst-case workloads.
Device virtualization strongly influences mixed-criticality behavior. Emulated devices offer flexibility but introduce additional software layers, while paravirtualized interfaces such as virtio can reduce overhead. For highly critical devices, direct assignment through technologies such as PCI passthrough can remove much of the host-mediated path. IOMMU configuration is essential because an assigned DMA-capable device must remain restricted to the memory belonging to its authorized domain.
Communication between isolated domains must balance performance with containment. Shared memory can provide extremely low latency, but synchronization errors or improperly defined ownership can undermine isolation assumptions. Virtual network channels, event mechanisms, or controlled message queues provide alternative interfaces. Safety-oriented designs typically minimize cross-domain interfaces, define explicit message formats, validate incoming data, and enforce timeout and freshness requirements at the receiving safety boundary.
Interrupt architecture is equally important because unexpected interrupt activity can introduce substantial jitter. Directly assigned devices should preferably deliver interrupts to CPUs belonging to their designated domain, while unrelated host or guest interrupts should be routed away from real-time cores. MSI/MSI-X configuration, IRQ affinity, CPU isolation, and hypervisor interrupt handling must therefore be considered together when constructing a predictable real-time partition.
A practical robotics architecture may allocate deterministic motor control, emergency handling, or safety supervision to a dedicated RTOS partition while Linux executes ROS 2, perception, mapping, networking, and system management. High-performance AI processing can occupy additional CPU or accelerator resources. The hypervisor then becomes an architectural boundary that prevents software consolidation from turning every component into one uncontrolled failure and timing domain.
Choosing between Jailhouse, Xen, and KVM-RT depends on the required balance between static determinism and platform flexibility. Jailhouse emphasizes relatively simple static hardware partitioning, Xen provides richer multi-domain virtualization and scheduling capabilities, and KVM-RT integrates naturally with the Linux virtualization ecosystem. None should be selected solely by benchmark latency; architecture, device ownership, shared-resource interference, maintainability, safety evidence, and failure containment must also be evaluated.
Hypervisor-based isolation ultimately provides an enabling mechanism rather than an automatic safety guarantee. Determinism and mixed-criticality assurance emerge from the combined design of CPU partitioning, memory protection, IOMMU configuration, interrupt routing, device assignment, communication boundaries, resource monitoring, and worst-case verification. When these mechanisms are engineered together, safety-critical real-time control and feature-rich Linux or AI workloads can coexist on shared multicore hardware while maintaining clearly defined isolation boundaries.
10.03 AUTOSAR Adaptive and Classic Mixed Platform Design
AUTOSAR mixed-platform design combines two complementary execution environments so that deterministic control and high-performance software can coexist within the same vehicle or robotic architecture. The Classic Platform focuses on deeply embedded, resource-bounded, real-time functions, while the Adaptive Platform supports computationally intensive and dynamically managed applications. Their integration provides a structured foundation for mixed-criticality computing.
AUTOSAR Classic Platform is designed for microcontroller-based electronic control units that require predictable timing, static configuration, and tightly controlled resource usage. Applications are organized as software components whose runnable entities execute according to predefined events and timing constraints. The Runtime Environment separates application software from Basic Software, allowing functional components to communicate through standardized interfaces rather than direct hardware dependencies.
Below the Runtime Environment, Classic Basic Software provides standardized services for operating-system functions, communication, memory management, diagnostics, ECU state management, and hardware abstraction. The layered architecture separates application logic from microcontroller-specific drivers. This organization supports deterministic execution and controlled configuration, which are particularly valuable for braking, steering, motor control, power management, and safety supervision.
AUTOSAR Adaptive Platform addresses high-performance computing systems where applications require dynamic deployment, service-oriented communication, multicore processing, and more flexible lifecycle management. Instead of the highly static execution model of Classic, Adaptive applications execute as processes on a POSIX-oriented operating environment. This makes the platform suitable for centralized compute nodes supporting perception, localization, planning, connectivity, and other complex software workloads.
Service-oriented communication is fundamental to Adaptive Platform architecture. Applications expose and consume services rather than depending on fixed signal-oriented connections. SOME/IP can support service discovery and network communication, while ara::com provides standardized Adaptive communication interfaces. This model allows applications to discover services dynamically and enables software architectures to evolve more flexibly as computing functions are consolidated onto high-performance processors.
Execution Management coordinates the startup, shutdown, and lifecycle of Adaptive applications according to configured machine and process states. Other platform services provide capabilities such as diagnostics, logging, persistence, time synchronization, network management, cryptography, and software update support. Together, these mechanisms create a managed execution environment suitable for applications whose complexity and lifecycle requirements exceed those of conventional embedded control software.
Classic and Adaptive therefore should not be interpreted as competing platforms. They address different computational characteristics within the same system. Classic is appropriate where deterministic response, constrained resources, and direct control interaction dominate, whereas Adaptive is appropriate where computational performance, dynamic services, complex networking, and software flexibility dominate. Mixed-platform architecture deliberately preserves these strengths rather than forcing every function into one execution model.
A typical mixed architecture places actuator-related and safety-relevant control in the Classic domain while Adaptive executes perception, planning, localization, user interfaces, connectivity, or advanced computation. For a robot, Classic could supervise motors, braking, emergency-stop behavior, and low-level sensor-actuator loops, while Adaptive could host ROS-related integration, environmental interpretation, route planning, fleet connectivity, or higher-level autonomy.
Communication between the two domains forms an important architectural boundary. Classic communication traditionally relies on automotive networks and signal-oriented mechanisms, while Adaptive systems increasingly use Ethernet and service-oriented communication. SOME/IP can provide a common integration mechanism across Ethernet-based architectures. Gateways may translate between CAN-oriented Classic communication and Ethernet-oriented Adaptive services when both network technologies coexist.
Diagnostic integration presents another cross-platform requirement. Classic ECUs commonly use diagnostic mechanisms associated with UDS, while Ethernet-based systems can use Diagnostics over Internet Protocol, or DoIP. A centralized diagnostic architecture can therefore connect conventional embedded controllers and high-performance Adaptive nodes while preserving domain-specific implementation details. Similar coordination is required for logging, health monitoring, system states, and fault reporting.
Time synchronization is essential when control, perception, and planning information crosses platform boundaries. Sensor observations produced or processed by an Adaptive application must remain temporally meaningful when consumed by Classic control functions. Ethernet-based synchronization technologies such as generalized Precision Time Protocol can establish a shared time reference, while application interfaces must preserve timestamps, freshness information, sequence consistency, and timeout behavior.
Mixed-platform design becomes a mixed-criticality problem when Classic safety functions and Adaptive QM or differently classified workloads share computing resources. A high-performance Adaptive application must not cause a critical Classic function to miss deadlines or lose access to required memory and devices. CPU partitioning, memory protection, interrupt routing, IOMMU protection, execution monitoring, and controlled device ownership can therefore become fundamental architectural requirements.
Classic and Adaptive environments may execute on separate ECUs connected through Ethernet, providing physical separation between the domains. More consolidated systems may place them on a common multicore SoC. In this case, hardware partitioning or a hypervisor can allocate processors, memory regions, interrupts, and devices to separate execution environments. Such consolidation reduces hardware duplication but requires stronger evidence that shared resources cannot create unacceptable interference.
This architecture directly connects AUTOSAR mixed-platform design with hypervisor-based isolation. A Classic or safety-oriented RTOS domain can receive dedicated CPU and device resources while Linux or another POSIX environment supports Adaptive applications. Jailhouse-style static partitioning or other virtualization technologies can establish boundaries between these environments, although deterministic behavior still depends on controlling shared caches, DRAM bandwidth, interconnects, interrupts, and accelerator resources.
Safety-related information originating from an Adaptive application must also be treated according to its assurance level. For example, perception or planning software may generate an obstacle classification or desired trajectory, but a safety-oriented control domain can independently validate command limits, data freshness, operating conditions, and actuator constraints. This preserves a clear distinction between high-level functional intelligence and the authority responsible for maintaining verified safety behavior.
Software updates introduce another major difference between the platforms. Classic software is traditionally configured and deployed in relatively static ECU images, whereas Adaptive architectures are designed for more dynamic application and platform lifecycle management. In a mixed system, update dependencies must be controlled carefully so that an Adaptive software update does not silently invalidate interfaces, timing assumptions, communication contracts, or safety mechanisms relied upon by Classic components.
Development therefore requires system-level interface definition rather than independent implementation of two platforms. ARXML-based descriptions and platform configuration define software components, services, interfaces, communication relationships, and deployment information. Integration testing must then verify not only functional communication but also timing behavior, startup sequencing, failure handling, synchronization, resource interference, and recovery when either platform becomes unavailable or degraded.
For modern robotic and autonomous systems, the resulting architecture creates a useful separation between deterministic machine control and rapidly evolving high-level computation. Classic-style control principles can protect bounded actuator and safety behavior, while Adaptive-style computing provides the flexibility required by perception, planning, connectivity, and increasingly AI-intensive applications. This separation enables advanced software to evolve without unnecessarily placing every computational function inside the most restrictive execution environment.
AUTOSAR Classic and Adaptive mixed-platform design is therefore fundamentally an architectural integration strategy. Classic contributes deterministic embedded control, Adaptive contributes service-oriented high-performance computing, and carefully defined communication and isolation mechanisms connect them. Combined with hardware partitioning, hypervisor isolation, synchronized communication, safety validation, and lifecycle management, the approach supports consolidation of real-time control and advanced computing while preserving explicit criticality boundaries.
10.04 Safety-Critical Task Isolation and Monitoring [w/Code]
Safety-critical task isolation ensures that functions responsible for protecting a robot, vehicle, or autonomous machine can execute predictably even when other software behaves incorrectly or consumes excessive resources. In a mixed-criticality system, isolation establishes explicit boundaries around safety tasks, while monitoring continuously verifies that execution remains inside defined timing, memory, communication, and functional limits.
A safety-critical task may supervise braking, emergency stopping, steering limits, motor torque, power distribution, actuator constraints, or system health. Failure of such a task can directly affect the ability of the machine to remain in a safe state. Consequently, its execution environment must be protected not only from ordinary software defects but also from interference caused by lower-criticality control, communication, perception, planning, or AI workloads.
Spatial isolation prevents one task or software domain from corrupting another task\'s memory or accessing unauthorized devices. MPU or MMU protection can assign separate address regions, while an IOMMU extends protection to DMA-capable peripherals. Stack regions, shared buffers, device registers, communication memory, and executable code should have explicitly defined ownership and permissions so that accidental or malicious accesses remain contained within their assigned domain.
Temporal isolation protects the execution time required by safety-critical tasks. A lower-priority application must not monopolize processors, generate excessive interrupts, or create scheduling conditions that prevent a safety task from meeting its deadline. Dedicated CPU cores, priority-based scheduling, execution budgets, CPU affinity, time partitioning, and controlled interrupt routing can reserve predictable processing opportunities for the most critical functions.
Resource isolation must extend beyond CPU scheduling because modern multicore systems contain many shared components. Last-level caches, DRAM controllers, memory buses, interconnects, storage, network interfaces, and accelerators can create interference even when software executes on different cores. Safety analysis must therefore identify shared resources and either partition them, bound their utilization, or monitor their behavior under realistic worst-case workloads.
Task monitoring complements isolation by detecting when execution violates expected behavior. A deadline monitor can determine whether a periodic control task completes before its required deadline, while execution-time monitoring can detect unusually long processing. Period and activation monitoring can identify missing, duplicated, or unexpectedly frequent executions. These mechanisms convert timing assumptions into observable runtime conditions that can trigger controlled fault responses.
Watchdogs provide another independent supervision layer. A task may periodically update a watchdog or heartbeat only after completing required processing correctly. If the expected update does not occur within the configured window, supervisory logic can assume that the task is stalled, deadlocked, overloaded, or otherwise unhealthy. Windowed watchdogs can additionally detect execution that occurs too early, helping identify abnormal scheduling or uncontrolled loops.
Health monitoring evaluates more than whether software is simply alive. Supervisors can observe task states, error counters, queue utilization, memory consumption, communication status, sensor validity, CPU load, and internal diagnostic information. These observations can be combined into health states such as normal, degraded, failed, or recovering. The resulting health model allows the system to select a fault response proportional to the severity and persistence of the detected problem.
Communication monitoring is essential when safety-critical tasks consume data from other domains. Messages can be checked for valid ranges, sequence counters, timestamps, freshness, timeout conditions, checksums, source identity, and semantic plausibility. A safety controller receiving velocity, obstacle, trajectory, or actuator commands should not assume that upstream software is correct merely because communication succeeded. Data validity must be established at the safety boundary.
Fault containment determines what happens after abnormal behavior is detected. A failure should remain inside the smallest practical containment region instead of propagating through the entire system. Depending on architecture and severity, recovery may restart an individual task, reset a communication channel, terminate a process, isolate a virtual machine, reset an ECU, disable a subsystem, or command a transition to a predefined safe or degraded operating state.
The safe state depends on the physical system and cannot always be interpreted as simply turning everything off. An AMR may require controlled deceleration before applying a brake, while a manipulator may need to stop motion without releasing a payload. A UAV may require continued stabilization even after higher-level autonomy fails. Safety monitoring must therefore connect detected faults to system-specific reactions that preserve controllability and minimize physical hazards.
Redundant monitoring can reduce dependence on a single software component. A primary controller may execute normal control while an independent safety monitor evaluates velocity, acceleration, position, torque, or operating envelopes. The monitor does not necessarily reproduce the complete control algorithm; instead, it verifies safety invariants and intervenes when outputs exceed allowable boundaries. This architecture separates sophisticated functional behavior from independent safety authority.
Mixed-criticality platforms often implement these boundaries through RTOS protection domains, operating-system process isolation, hardware partitioning, or hypervisor-based virtualization. A safety RTOS partition can receive dedicated CPUs, memory, interrupts, and devices while Linux or Adaptive applications execute in another domain. Isolation mechanisms reduce fault propagation, while monitoring determines whether each partition continues to satisfy the assumptions on which the system safety architecture depends.
AI workloads make monitoring particularly important because their execution time and outputs may vary significantly with input complexity and system load. Perception, world-model inference, planning, or learned policies can operate in a lower-assurance domain while deterministic safety tasks independently supervise resulting commands. Timeout checks, confidence or validity conditions, physical envelopes, velocity limits, and emergency logic can prevent variable AI behavior from obtaining unrestricted actuator authority.
Monitoring itself must be designed as a safety mechanism rather than ordinary diagnostic logging. A monitor that depends completely on the task it supervises may fail simultaneously with that task. Critical monitors should therefore have sufficient independence in execution context, memory, timing source, or hardware supervision. Hardware watchdogs, independent timer sources, separate cores, safety islands, or external controllers can provide stronger supervision when required by the safety concept.
Fault detection latency must also be bounded. Detecting a failed control task several seconds after its deadline may be useless if the physical system can reach a hazardous state within milliseconds. Designers must relate monitoring periods and timeout thresholds to the fault-tolerant time interval of the controlled system. Detection time, decision time, communication latency, and actuator reaction time together determine whether the system can reach a safe condition before a hazard develops.
Verification must deliberately challenge both isolation and monitoring mechanisms. Tests should create CPU overload, memory corruption attempts, interrupt storms, communication delays, lost messages, task deadlocks, priority inversion, device failures, and abnormal execution times. Safety tasks must continue meeting their guarantees where isolation is expected to contain the disturbance, while monitors must detect conditions that exceed the defined containment capability and initiate the intended response.
Runtime evidence can also support field diagnostics and root-cause analysis. Timestamped deadline violations, watchdog events, task-state transitions, resource usage, communication faults, and recovery actions can be recorded in protected diagnostic buffers. Logging must remain bounded so that the diagnostic mechanism itself does not interfere with critical execution. The resulting traces help engineers reconstruct failures while preserving the deterministic behavior required during operation.
Safety-critical task isolation and monitoring therefore form two complementary protection layers. Isolation attempts to prevent faults and resource interference from reaching critical functions, while monitoring detects violations that isolation cannot prevent or that originate inside the critical function itself. Combined with bounded fault detection, controlled recovery, independent supervision, and system-specific safe-state logic, these mechanisms allow safety control, conventional software, and high-performance AI workloads to coexist within a robust mixed-criticality architecture.
10.05 Mixed Criticality Communication Channel Design
A mixed-criticality communication channel provides a controlled path for exchanging information between software functions that have different safety, timing, and assurance requirements. In a robot or vehicle, a safety-critical controller may need information from a lower-criticality perception, planning, or AI subsystem, while the receiving function must remain protected from invalid, delayed, corrupted, or excessive data. The communication channel therefore becomes part of the safety architecture rather than merely a software interface.
The fundamental design principle is that communication must preserve the criticality boundary between domains. A message produced by a QM or non-safety application does not automatically become safety-qualified when it enters an ASIL D domain. The receiving safety function must apply explicit assumptions about data integrity, timing, freshness, source identity, and allowable values. The channel should therefore define what information may cross the boundary, how it is transported, how it is validated, and what happens when communication assumptions are violated.
Communication architecture depends strongly on the physical and software deployment model. Safety and non-safety functions may execute on separate ECUs connected through CAN, CAN FD, or Ethernet, or they may execute as isolated domains on a common multicore SoC. Within a single processor, shared memory, inter-process communication, virtual networking, or hypervisor-mediated channels may be used. Across ECUs, network protocols and gateways provide the communication path. In every case, the interface should expose only the information necessary for the receiving function.
Timing behavior is one of the most important properties of a mixed-criticality channel. A safety controller cannot treat an arbitrarily delayed message as equivalent to a current measurement. Each safety-relevant message should therefore have an explicitly defined transmission period, maximum latency, deadline, and acceptable age. Timeout supervision can detect missing communication, while timestamps and sequence information allow the receiver to determine whether data is current, delayed, duplicated, or received out of order.
Data integrity must be protected independently of communication success. A message may successfully reach its destination while containing corrupted or inconsistent information. CRCs, checksums, sequence counters, end-to-end protection, source identification, and range validation can provide multiple layers of protection. For safety-related values, the receiver should also perform plausibility checks against physical constraints and related signals. Communication acknowledgement alone should never be treated as proof that the transmitted information is safe to use.
Bandwidth and queue behavior must also be bounded. A lower-criticality application such as AI perception or logging may generate large and variable amounts of data, but it must not consume communication resources required by safety functions. Dedicated channels, bandwidth reservation, priority assignment, bounded queues, rate limiting, message filtering, and traffic shaping can prevent noncritical traffic from starving critical communication. The design objective is predictable delivery rather than simply maximizing aggregate network throughput.
CAN-based communication is often appropriate for compact control information because its arbitration and priority mechanisms support predictable transmission of high-priority messages. CAN or CAN FD can therefore connect motor controllers, safety controllers, sensors, and other embedded nodes. However, application-level safety still requires monitoring of message freshness, sequence, range, and validity. A correctly transmitted CAN frame does not by itself establish that the associated control information is functionally safe.
Ethernet becomes increasingly important when mixed-criticality systems combine high-performance computing with distributed control. Adaptive applications, perception systems, planning modules, and AI workloads may exchange large datasets over Ethernet, while safety-related information can use logically separated or prioritized traffic. Technologies such as TSN can provide more deterministic traffic scheduling where required. Nevertheless, network determinism must be evaluated together with endpoint processing, operating-system scheduling, interrupt behavior, buffering, and application-level timeout requirements.
Shared-memory communication can provide extremely low latency when safety and non-safety domains reside on the same computing platform. However, shared memory introduces additional concerns regarding ownership, synchronization, memory protection, cache coherency, and stale data. A robust design defines which domain owns each buffer, when data may be written or consumed, and how the receiver detects incomplete or outdated information. IOMMU and MPU/MMU mechanisms can further restrict unauthorized access to shared communication memory.
Hypervisor-based systems introduce another communication boundary between virtual machines or isolated execution domains. Virtual Ethernet, shared-memory mechanisms, event channels, virtio-based interfaces, or carefully controlled device assignment can connect domains while preserving resource separation. The communication mechanism should not allow a failure in one domain to compromise another domain\'s memory or execution resources. Critical channels should also minimize dependencies on noncritical management software and avoid unbounded virtualization paths.
The communication interface should define a clear failure model. Missing messages, corrupted data, duplicated messages, incorrect sequence numbers, excessive transmission rates, stale information, invalid values, and unavailable communication services should each have an identifiable response. Depending on the function, the response may be to hold the previous safe value, reduce operating capability, reject the command, switch to a redundant source, initiate a controlled stop, or transition to another predefined degraded state.
A particularly important pattern for robotics is separating functional intelligence from safety authority. An AI or planning subsystem may generate a desired velocity, trajectory, steering command, or manipulation target, but a safety controller can independently verify that the command remains inside defined physical and operational limits. The communication channel transfers the proposed command, while the receiving safety layer determines whether it is acceptable. This architecture allows advanced AI functionality to evolve without giving the AI subsystem unrestricted authority over safety-critical actuators.
Communication monitoring should therefore operate continuously during system execution. The monitor can track message frequency, latency, sequence continuity, queue utilization, communication errors, and data validity. Diagnostic records should capture important communication faults with timestamps and relevant system states. When communication becomes unreliable, the system should respond within the required fault-tolerant time interval rather than waiting for a higher-level application to recognize the problem.
Verification must test the communication channel under both normal and abnormal conditions. Tests should introduce message loss, corruption, duplication, reordering, delay, bandwidth saturation, queue overflow, network disconnection, endpoint restart, CPU overload, and domain failure. The objective is to demonstrate that safety-critical communication continues to satisfy its timing and integrity requirements under expected interference and that violations are detected and handled according to the safety concept.
A well-designed mixed-criticality communication channel therefore combines interface minimization, controlled transport, bounded timing, data integrity protection, resource isolation, runtime monitoring, and defined fault responses. It creates a deliberate boundary through which information can cross without allowing the criticality of the receiving domain to depend blindly on the behavior of the transmitting domain. This principle is essential when integrating safety controllers, RTOS domains, Linux systems, Adaptive applications, ROS 2 components, and AI workloads within a common robotic or autonomous architecture.
10.06 Time Partitioning Implementation
Time partitioning is a fundamental mechanism for allowing software functions with different criticality levels to share a computing platform while maintaining predictable execution. In a mixed-criticality robot or vehicle, safety-critical control may require strict timing guarantees, whereas perception, planning, diagnostics, or AI workloads may have variable execution times. Time partitioning assigns each execution domain a controlled portion of processor time so that noncritical workloads cannot continuously consume resources required by critical functions. The topic is positioned within Chapter 10 as a core mechanism for mixed-criticality system design.
The basic concept is to divide processor execution into predefined time windows and associate each window with a particular task, partition, or execution domain. A repeating major frame can contain multiple minor windows, and each window defines when a particular workload is permitted to execute. The scheduler or partition manager switches between these windows according to a deterministic schedule. This approach differs from ordinary priority scheduling because temporal ownership is explicitly established in advance rather than being determined only by instantaneous task priorities.
A time-partitioned system normally begins by defining the timing requirements of each workload. Safety-critical tasks require sufficient execution capacity to complete within their deadlines, while lower-criticality functions receive the remaining processor budget. The partition schedule must consider task periods, worst-case execution times, deadlines, interrupt overhead, context-switch cost, and required margins. The resulting schedule should provide sufficient capacity for normal operation while preserving predictable behavior when computational demand increases unexpectedly.
A typical mixed-criticality schedule may reserve recurring execution windows for safety control, real-time communication, state estimation, and other deterministic functions, while assigning separate windows to Linux services, perception, AI inference, logging, or maintenance activities. The exact allocation depends on system requirements. A safety partition might execute frequently with short windows because its control loop has a strict deadline, whereas an AI workload may execute less frequently using larger windows because its output can tolerate greater latency. This creates temporal separation without necessarily requiring separate processors.
Time partitioning can be implemented at several architectural levels. An RTOS scheduler can use fixed scheduling policies and execution budgets, while a hypervisor can assign CPU time to virtual machines or isolated domains. Hardware-supported virtualization can strengthen the boundary between domains, and multicore systems can combine time partitioning with CPU affinity or dedicated cores. In a consolidated robotic computer, one domain can therefore execute deterministic safety functions while another receives controlled processor time for Linux, ROS 2, perception, or AI workloads.
The distinction between spatial and temporal isolation is important. Spatial isolation prevents one domain from accessing another domain\'s memory or devices, whereas temporal isolation prevents one domain from consuming more than its permitted share of execution time. A robust mixed-criticality system normally requires both. A perfectly protected memory region is not sufficient if a noncritical task can still monopolize shared CPU capacity, and a perfectly scheduled CPU is not sufficient if a faulty application can overwrite safety-critical memory.
Implementation requires a reliable scheduling reference and a mechanism for enforcing partition boundaries. The scheduler must determine the active partition, allow only authorized tasks to execute, and switch execution at defined boundaries. Timers or hardware scheduling facilities can provide precise timing references. Context-switch overhead and interrupt processing must be included in the timing analysis because a theoretically correct partition schedule can still violate deadlines if the implementation introduces significant unaccounted execution time.
Interrupt handling requires special attention because interrupts can cross otherwise clean partition boundaries. A high-frequency device interrupt or interrupt storm generated by a lower-criticality subsystem can consume processor time outside the expected budget. Critical interrupts should therefore be routed carefully, and interrupt service routines should be bounded and assigned appropriate ownership. Deferred processing should also be controlled so that background work cannot unexpectedly consume the execution window reserved for safety-critical tasks.
Memory and I/O activity can also affect the effectiveness of time partitioning. A partition may have a fixed CPU budget but still experience variable execution time because of cache misses, memory contention, DMA activity, storage operations, or network processing. On multicore SoCs, shared caches, DRAM controllers, interconnects, and accelerators can create indirect interference. Consequently, time partitioning should be combined with resource allocation, memory protection, device ownership, and performance monitoring rather than treated as an isolated scheduling technique.
Runtime monitoring verifies that the implemented schedule continues to satisfy its assumptions. Execution-time monitoring can detect when a task consumes more CPU time than expected, while deadline monitoring can identify missed completion times. Partition overrun detection is particularly important because a faulty or overloaded workload should not silently continue executing into another partition\'s reserved window. When an overrun occurs, the system can terminate the task, suspend the partition, record a diagnostic event, or transition to a predefined degraded operating mode.
Time partitioning is especially valuable when AI and safety functions share an edge computer. AI inference can have variable computational demand depending on the model, input, accelerator state, and concurrent workloads. A safety controller should not depend on the AI task voluntarily yielding the processor. Instead, the safety domain receives explicitly reserved execution opportunities, while AI processing operates within a separate temporal budget. This allows advanced perception, world-model inference, planning, or VLA computation to coexist with deterministic control without allowing variable AI execution to dominate the processor.
Verification of a time-partitioned architecture must demonstrate both normal scheduling behavior and worst-case interference conditions. Testing should deliberately overload lower-criticality partitions, increase interrupt activity, generate heavy network traffic, stress memory bandwidth, and execute computationally intensive AI workloads while measuring the timing of safety tasks. The measured response time, jitter, execution budget, and deadline behavior should be compared against the defined timing requirements. The purpose is to demonstrate that temporal isolation is effective under realistic and abnormal operating conditions.
A complete implementation therefore treats time partitioning as part of the overall safety architecture rather than simply as a scheduler configuration. CPU budgets, partition periods, execution windows, interrupt routing, memory and device ownership, monitoring, watchdog supervision, and fault responses must work together. When these mechanisms are correctly coordinated, a mixed-criticality platform can provide deterministic execution for safety functions while efficiently sharing computing resources with Linux, ROS 2, perception, planning, diagnostics, and AI workloads. This establishes the temporal foundation for later mixed-criticality certification, safety/AI coexistence, and verification activities.
10.07 Mixed Criticality System Certification Strategy
Certification of a mixed-criticality system is not achieved by certifying every software component to the highest safety level. The objective is to demonstrate that safety-critical functions satisfy their applicable safety requirements while lower-criticality or QM functions can coexist without compromising them. The certification strategy therefore begins with a clear criticality boundary, safety goals, architectural assumptions, and evidence that isolation, timing, communication, monitoring, and fault-containment mechanisms preserve the required safety properties.
The first step is to establish the safety concept and identify which functions are safety-related. In an automotive system, ISO 26262 provides the primary functional-safety framework, while ASIL classification determines the rigor required for relevant safety functions. ASIL D functions may include emergency stopping, braking, steering limits, torque limitation, or safety supervision, whereas perception, visualization, logging, analytics, or other functions may remain QM when the safety analysis supports that classification. The certification argument must clearly document why each function receives its assigned criticality.
Mixed-criticality certification depends strongly on freedom from interference. When ASIL D and QM functions share a processor, memory system, network, or accelerator, the safety case must demonstrate that a failure in the QM domain cannot invalidate the safety assumptions of the ASIL D domain. Spatial isolation, temporal isolation, controlled communication, resource management, and fault containment therefore become certification evidence rather than merely implementation features. The stronger the architectural separation, the more clearly the safety argument can demonstrate independence between domains.
Spatial isolation evidence demonstrates that software cannot access or corrupt resources belonging to another criticality domain. Memory protection through MPU or MMU mechanisms, IOMMU protection for DMA, controlled device ownership, and restricted communication buffers can establish these boundaries. The certification evidence should show not only the intended configuration but also the effectiveness of the protection mechanisms under fault conditions. Unauthorized memory access, invalid DMA operations, and unintended device access should be considered during verification and fault-injection activities.
Temporal isolation requires evidence that safety-critical tasks receive sufficient and predictable execution time. A certification strategy should therefore document task periods, deadlines, worst-case execution times, CPU budgets, interrupt overhead, scheduling policies, and time-partitioning behavior. If Linux, AI, or other variable workloads share the platform, their execution must not cause safety tasks to exceed their timing limits. Measurements under overload and interference conditions are important because nominal timing performance alone cannot establish deterministic behavior.
Communication across the criticality boundary requires its own safety argument. Data generated by a QM or AI subsystem should not automatically be considered safety-qualified merely because it has been transmitted successfully. Safety-relevant messages may require checks for integrity, source identity, sequence, freshness, range, plausibility, and timeout conditions. The receiving safety function must define what assumptions it makes about incoming information and what reaction occurs when those assumptions are violated. This creates an explicit and reviewable interface between functional intelligence and safety authority.
The certification strategy should also define how monitoring contributes to the safety case. Deadline monitoring, execution-time monitoring, watchdogs, heartbeat supervision, communication monitoring, and health monitoring provide runtime evidence that the system continues to operate within its safety assumptions. A monitor that depends entirely on the software it supervises may share the same failure mode and therefore provide weak independence. Where necessary, independent timers, dedicated cores, hardware watchdogs, safety islands, or separate safety controllers can strengthen the monitoring argument.
Fault containment and recovery must be connected directly to the safety concept. Certification evidence should explain how the system responds when a safety task fails, a QM application crashes, communication becomes unavailable, a partition overruns its budget, or a shared resource becomes abnormal. Possible responses include task restart, partition isolation, rejection of invalid commands, transition to degraded operation, controlled deceleration, emergency stop, or another system-specific safe-state action. The selected response must be consistent with the physical hazard and required fault-tolerant time interval.
A mixed-criticality platform may use an RTOS, hypervisor, AUTOSAR Classic, AUTOSAR Adaptive, Linux, or combinations of these technologies. The certification strategy should avoid assuming that the presence of a particular technology automatically provides safety qualification. Instead, the safety argument must identify which mechanisms are relied upon, what their failure assumptions are, how they are configured, and what verification evidence demonstrates their effectiveness. For hypervisor-based systems, CPU allocation, memory isolation, interrupt routing, device assignment, and shared-resource interference must all be addressed.
Development evidence should be organized around traceability from safety goals to requirements, architecture, implementation, verification, and final safety evidence. Safety requirements should map to concrete architectural mechanisms and test cases, while verification results should demonstrate that the implemented system satisfies those requirements. Configuration management is particularly important in mixed-criticality systems because changes to a QM or Adaptive component can affect interfaces, timing, resource consumption, or safety assumptions even when the safety software itself has not changed.
The certification strategy must therefore distinguish between what is directly safety-critical and what is merely part of the supporting infrastructure. A QM AI model does not necessarily need to be developed as an ASIL D component if the architecture prevents its failure from directly violating a safety goal. Instead, the safety architecture can constrain its authority and independently validate its outputs. This approach allows advanced perception, planning, world-model inference, and other computationally intensive functions to evolve while maintaining a controlled safety boundary around deterministic control and safety supervision.
Verification should intentionally challenge the assumptions on which the certification argument depends. Tests should include CPU overload, excessive memory traffic, interrupt storms, partition overruns, communication loss, corrupted messages, stale data, invalid commands, process crashes, device failures, and long-duration operation. The purpose is not simply to demonstrate that individual components work, but to demonstrate that the complete mixed-criticality architecture continues to protect safety functions when lower-criticality components behave incorrectly or when expected operating conditions are exceeded.
The final certification evidence should form a coherent safety case rather than a collection of independent test reports. The argument should connect safety goals and ASIL requirements to architectural decomposition, isolation mechanisms, timing guarantees, controlled communication, monitoring, fault detection, recovery, verification, and configuration control. For a mixed-criticality robot or vehicle, the resulting evidence should demonstrate that safety-critical functions remain bounded and dependable while QM, Linux, Adaptive, ROS 2, and AI workloads provide advanced capabilities without compromising the independence and integrity of the safety domain.
10.08 Robot Safety Compute and AI Compute Coexistence
Robot safety compute and AI compute coexistence is based on the principle that deterministic safety functions and high-performance intelligent functions should not be forced into the same computational role. Safety compute must preserve bounded latency, predictable execution, fault detection, and safe-state behavior, while AI compute must provide the throughput required for perception, world-model inference, planning, and other data-intensive workloads. Within Chapter 10, this topic follows certification strategy and prepares the architecture for subsequent mixed-criticality testing and verification.
Safety compute is responsible for functions whose failure can directly create a hazardous physical condition. Typical responsibilities include emergency stop, actuator limits, velocity and acceleration constraints, torque supervision, power protection, watchdog operation, and deterministic control loops. These functions generally require high predictability rather than maximum computational performance. A dedicated MCU, safety controller, RTOS domain, or protected processor can therefore provide an execution path that remains available even when higher-level computing becomes overloaded or unavailable.
AI compute has a fundamentally different objective. GPUs, NPUs, CPUs, and specialized accelerators can execute perception, object recognition, semantic understanding, world-model prediction, localization, planning, and learned policies at high throughput. These workloads may have variable execution times because computational demand depends on sensor input, model complexity, memory access, accelerator utilization, and concurrent processes. Their value is therefore primarily in expanding robot capability rather than directly guaranteeing the final safety response.
The central architectural principle is that AI compute should propose behavior while safety compute retains the authority to enforce physical constraints. An AI planner may generate a trajectory or desired velocity, but the safety layer independently evaluates velocity, acceleration, workspace, collision, actuator, and operating-envelope constraints before allowing the command to reach the control layer. This creates a controlled interface between intelligence and safety. Advanced AI can therefore evolve without becoming an unrestricted authority over safety-critical actuators.
A practical robot may use a hierarchical compute structure in which fast control operates at the lowest level, edge computation performs state estimation and fusion, and high-performance AI compute performs perception and planning. The different layers operate at different time scales and should not be confused with one another. A camera may generate frames at tens of frames per second, an AI model may infer at a lower or variable rate, while motor controllers can execute control loops at much higher frequencies. Each layer therefore requires its own timing contract.
The communication path between safety compute and AI compute must preserve this hierarchy. AI outputs should be transferred through controlled interfaces containing timestamps, sequence information, validity conditions, and timeout requirements. The safety side should verify that received commands remain physically meaningful and sufficiently fresh before using them. If the AI result is delayed, missing, inconsistent, or outside the permitted operating envelope, the safety path should reject, constrain, replace, or safely degrade the command rather than blindly executing it.
Resource isolation becomes increasingly important when safety and AI workloads share a common edge computer. CPU cores, memory, cache, DRAM bandwidth, interconnects, storage, network interfaces, and accelerators can all become sources of interference. A large AI inference workload may consume substantial memory bandwidth or accelerator resources even when the safety task is assigned a separate CPU core. Therefore, CPU affinity and scheduling must be combined with memory protection, device ownership, bandwidth control, interrupt management, and monitoring of shared-resource effects.
Time partitioning provides another mechanism for controlled coexistence. Safety tasks can receive guaranteed execution windows or dedicated processor capacity, while AI workloads use the remaining computational budget. Under normal conditions, AI compute can exploit available resources for maximum capability. Under overload, the system should reduce AI inference frequency, simplify models, drop nonessential workloads, or move computation to another resource before allowing safety timing guarantees to deteriorate. This establishes graceful degradation according to criticality.
Hypervisor or operating-system partitioning can provide stronger separation when multiple execution environments share one SoC. A safety-oriented RTOS domain may receive dedicated CPUs, memory regions, interrupts, and devices, while Linux hosts AI frameworks, ROS 2 components, perception pipelines, or planning applications. The isolation mechanism itself must be included in the safety analysis because a virtual boundary is useful only when its configuration and failure assumptions prevent lower-criticality software from violating safety requirements.
Monitoring forms the continuous supervision layer across the architecture. Safety monitoring can observe task deadlines, execution time, communication freshness, resource consumption, watchdog state, sensor validity, and actuator conditions. AI compute can additionally be monitored for model execution failures, excessive latency, accelerator overload, thermal limitations, or abnormal resource consumption. Monitoring should not merely record information; it should provide actionable conditions for mode switching, workload reduction, fault containment, and transition to a safe or degraded state.
The resulting operating modes should be explicitly defined. Normal operation can provide full AI capability and normal autonomy. When computational or communication resources become constrained, degraded operation can reduce perception rate, planning frequency, model complexity, or nonessential services while preserving deterministic control. A fallback mode can switch to a simpler model, alternative processor, or independent computation path. If necessary, the system ultimately enters a safe state in which only the minimum functions required to prevent hazardous behavior remain active.
This architecture also enables compute redundancy and graceful fallback. The primary AI path may use a high-performance GPU or NPU for sophisticated models, while a simpler CPU or MCU path can provide reduced functionality when the primary path fails. The fallback does not need to reproduce the full capability of the primary system. Its purpose is to preserve essential operation or provide a controlled transition until recovery is possible. Safety compute remains the independent foundation that guarantees the robot does not lose basic physical control.
Verification must demonstrate coexistence under realistic worst-case conditions rather than only during nominal operation. The system should be stressed with heavy AI inference, CPU overload, memory-bandwidth saturation, network traffic, accelerator utilization, thermal constraints, communication delays, process crashes, and partition failures. Engineers should measure safety-task latency, jitter, deadline compliance, resource interference, transition time, and safe-state response. The objective is to prove that increasing AI workload does not silently weaken safety guarantees.
The complete architecture therefore treats safety compute and AI compute as complementary rather than competing resources. Safety compute provides deterministic control, monitoring, constraint enforcement, and safe-state authority, while AI compute provides perception, prediction, reasoning, planning, and high-level autonomy. Isolation, controlled communication, time partitioning, resource management, monitoring, fallback, and graceful degradation connect these domains. The result is a robot architecture in which intelligence can become increasingly powerful without allowing computational complexity or AI variability to compromise deterministic physical safety.
10.09 Mixed Criticality System Test and Verification
Mixed-criticality system testing and verification is intended to demonstrate that safety-critical functions remain deterministic, protected, and dependable while QM, Linux, Adaptive, ROS 2, and AI workloads execute on the same platform. The central verification objective is not simply to prove that each component works independently, but to demonstrate freedom from interference across the complete architecture. Testing therefore connects isolation, timing guarantees, controlled communication, monitoring, fault containment, and safe-state behavior into one system-level verification process.
The verification process begins with the safety assumptions and architectural boundaries defined for the mixed-criticality system. ASIL D functions must have clearly defined requirements for timing, memory, communication, resource access, and fault response, while QM functions may operate with less restrictive assumptions. Verification must establish that these assumptions remain valid when both domains operate simultaneously. The test environment should therefore represent realistic deployment conditions rather than evaluating safety functions only in an isolated or ideal execution environment.
Spatial isolation is verified by deliberately attempting to cross memory and device boundaries. Tests can introduce invalid memory accesses, corrupted shared buffers, unauthorized device operations, and DMA activity originating from lower-criticality software. MPU, MMU, and IOMMU mechanisms should prevent such actions from reaching protected resources. The objective is to demonstrate that a fault in one execution domain remains contained within that domain and cannot directly corrupt safety-critical code, data, or hardware resources.
Temporal isolation requires measurement of task execution under both normal and stressed conditions. Safety tasks should be evaluated for worst-case execution time, deadline compliance, period stability, response time, and jitter while QM or AI workloads generate substantial processor demand. CPU overload, excessive scheduling activity, and interrupt storms should be introduced deliberately. The verification result should demonstrate that safety-critical tasks retain their required execution opportunities and do not experience unacceptable timing degradation.
Shared-resource interference must also be verified because CPU isolation alone does not guarantee complete temporal independence. Cache contention, DRAM bandwidth consumption, interconnect traffic, DMA activity, network processing, storage operations, and accelerator utilization can influence execution latency. Tests should therefore combine heavy AI inference and high-rate perception processing with safety control and measure the resulting timing behavior. The purpose is to establish practical bounds on interference rather than assuming that logical partitioning automatically eliminates it.
Communication verification evaluates whether information crossing the criticality boundary remains valid and sufficiently timely. Messages should be tested for loss, delay, duplication, reordering, corruption, stale information, invalid values, and excessive transmission rates. Sequence checks, CRC or checksum protection, timestamps, freshness checks, range validation, plausibility checks, and timeout supervision should be exercised. The receiving safety function must demonstrate that invalid or outdated information is rejected, constrained, or handled according to the defined safety response.
A particularly important verification pattern is the separation between AI-generated proposals and safety-authorized actions. An AI or planning system may produce a desired trajectory, velocity, steering command, or actuator request, but the safety layer must independently verify physical and operational constraints before execution. Testing should intentionally provide unrealistic, delayed, or unsafe AI outputs and confirm that the safety controller prevents them from producing hazardous actuator behavior. This demonstrates that functional intelligence does not automatically become safety authority.
Monitoring and supervision mechanisms require dedicated verification because they form the runtime detection layer. Deadline monitors, execution-time monitors, watchdogs, heartbeat supervision, communication monitoring, and health monitoring should be tested by creating the abnormal conditions they are expected to detect. Missing execution, excessive execution time, lost communication, stale data, abnormal resource usage, and partition overruns should produce the specified diagnostic or protective response within the required fault-tolerant time interval.
Fault injection is essential for demonstrating fault containment and recovery. Individual processes, communication channels, partitions, devices, and computing resources can be intentionally failed while the remainder of the system continues operating. Appropriate tests include process crashes, communication disconnection, corrupted data, queue overflow, CPU overload, device failure, and partition failure. The expected result is not necessarily uninterrupted full functionality; rather, the system should contain the fault and transition to an explicitly defined degraded or safe operating mode.
Mode-management verification evaluates whether the system preserves the highest-criticality functions when resources become constrained. During normal operation, AI and other advanced workloads may operate at their intended performance levels. Under overload or fault conditions, the system should reduce AI inference frequency, suspend nonessential workloads, select a simpler model, or use an alternative computational path before safety timing is compromised. If the fault becomes sufficiently severe, the system should transition to a safe state that prevents hazardous physical behavior.
Long-duration and stress testing are required because many mixed-criticality failures emerge only after extended operation. The system should execute realistic combinations of safety control, networking, perception, planning, logging, and AI inference while CPU, memory, I/O, and communication resources remain active. Engineers should record latency, jitter, deadline misses, resource utilization, thermal behavior, communication errors, watchdog events, and recovery actions. This helps reveal cumulative interference and rare timing failures that short nominal tests may not expose.
Verification evidence should maintain traceability from safety goals and requirements to architectural mechanisms and test results. Each important safety assumption should correspond to a verification activity capable of challenging that assumption. Results should record the configuration, workload conditions, measured timing, detected faults, system response, and final operating state. Configuration control is important because changes to AI models, software versions, interfaces, resource allocation, or scheduling policies can modify the interference behavior of the complete system and may require re-verification.
The final verification objective is to demonstrate controlled coexistence rather than perfect isolation in every respect. Safety-critical functions must remain bounded, predictable, and protected, while lower-criticality workloads retain useful computational capability. The evidence should show that isolation prevents unacceptable fault propagation, timing remains within defined limits, communication violations are detected, monitoring operates correctly, and recovery mechanisms produce the intended degraded or safe behavior. In this way, mixed-criticality testing becomes the practical evidence that safety and high-performance intelligence can coexist on a shared robotic computing platform.
10.10 Cargo UAV FCC Mixed Criticality Case Study
A cargo UAV Flight Control Computer (FCC) provides a representative mixed-criticality architecture in which deterministic flight control and higher-level mission intelligence must coexist without compromising flight safety. The FCC receives redundant sensor inputs such as IMU, GNSS, barometer, magnetometer, and air-data measurements, while also receiving mission commands, trajectories, and flight-mode requests. At the output side, it controls motors, ESCs, servos, tilt mechanisms, and payload-release functions. This makes the FCC a natural boundary between safety-critical control and higher-level computation.
The most critical functions of the FCC are associated with maintaining stable and controllable flight. State estimation, inner-loop rate control, attitude control, control allocation, actuator limitation, and emergency response require deterministic execution and bounded latency. The architecture therefore uses multi-rate control layers, with the inner rate loop operating at approximately 200--1000 Hz, attitude control at 100--500 Hz, position and velocity control at 20--100 Hz, and slower navigation, mission, health, and diagnostic functions at lower rates. This separation reflects different timing criticalities within the same flight-control system.
The safety-critical domain should retain independent authority over physical flight constraints. Geofencing, altitude limits, speed limits, attitude limits, climb and descent limits, payload and center-of-gravity constraints, battery and power limits, no-fly zones, and the overall operational envelope must not depend exclusively on a mission computer or AI planner. A high-level system may propose a trajectory or flight mode, but the FCC must validate the command before it reaches the control loops. Invalid, stale, excessive, or physically impossible commands must be rejected, constrained, or replaced by a predefined safe response.
State estimation provides another important safety boundary because all subsequent control functions depend on the quality of the estimated state. Sensor fusion combines IMU, GNSS, barometric, magnetic, and air-data information, followed by bias estimation and innovation or validity checks. The resulting state vector contains quantities such as attitude, angular rates, position, velocity, and sensor biases. Sensor redundancy and independent validity checks allow the FCC to detect inconsistent measurements before they propagate into attitude, position, or actuator commands.
The FCC should separate high-criticality flight-control execution from lower-criticality mission and AI computation through spatial and temporal isolation. A safety-oriented RTOS or dedicated flight-control processor can execute the deterministic control loops, while a higher-performance computing domain handles mission planning, perception, mapping, optimization, or AI functions. If these functions share hardware, memory protection, CPU affinity, time partitioning, controlled device access, and resource monitoring become essential. A failure or overload in the mission domain must not prevent the safety domain from maintaining stable flight.
Communication between the mission computer and FCC should follow the mixed-criticality communication principle. Mission commands, waypoints, trajectories, and flight-mode requests should cross a controlled interface with defined timing, sequence, freshness, range, and plausibility requirements. The FCC should verify the received information rather than assuming that successful communication means valid flight authority. Communication loss must have a defined response, such as holding the current state temporarily, returning to a designated route, returning to base, controlled descent, or landing, depending on the operational context and remaining flight authority.
The control architecture itself is inherently multi-rate and should be protected from lower-frequency computational variability. The inner rate controller must continue operating even when navigation, mission planning, or AI inference becomes delayed. Attitude and outer-loop controllers can operate at lower frequencies while maintaining their required deadlines, and control allocation converts the desired forces or moments into actuator commands while respecting effectiveness and physical constraints. This hierarchy ensures that a temporary loss of high-level intelligence does not immediately remove the UAV\'s fundamental ability to stabilize and control its flight.
Fault management provides the mechanism for dealing with failures across both safety and non-safety domains. The FCC should detect and classify faults, assess their severity and remaining control authority, decide an appropriate response, and reconfigure or reallocate resources where possible. Faults may originate from sensors, actuators, communication links, power systems, software processes, or computing resources. The response should be proportional to the remaining capability of the aircraft. A minor sensor anomaly may trigger redundancy selection, while a severe control or power failure may require immediate transition to a predefined emergency behavior.
Power management is particularly important for a cargo UAV because remaining energy directly affects available flight authority. Battery monitoring, power distribution, energy estimation, and power-margin management should therefore be integrated with fault and mission management. When energy margins become insufficient, the system may progressively restrict nonessential computation or mission capability before affecting safety-critical control. A low-power strategy can follow a controlled sequence such as limiting performance, returning toward a designated recovery location, and finally landing when continued flight is no longer justified.
Redundancy strengthens the mixed-criticality safety architecture by reducing dependence on individual components. Redundant sensors can be cross-checked and voted upon, while redundant communication links can provide alternate command or telemetry paths. Dual or triple computing resources can provide another level of resilience, while independent watchdogs supervise execution health. These mechanisms should not simply duplicate hardware; their value comes from combining redundancy with isolation, cross-checking, fault detection, and controlled safe-state behavior.
The FCC software lifecycle must also preserve the safety boundary throughout development and deployment. Secure boot and authentication establish software integrity, while configuration management controls flight parameters, safety limits, sensor mappings, and hardware variants. Versioning and compatibility management prevent an updated mission or AI component from silently changing assumptions used by the safety controller. Update and rollback mechanisms should provide a controlled recovery path when a new software version introduces unexpected behavior. Traceability from requirements through implementation and verification is therefore essential.
Verification should progress from software-level testing toward increasingly realistic physical tests. Unit testing and Software-in-the-Loop can validate algorithms and state transitions, while Processor-in-the-Loop evaluates behavior on the target processing environment. Hardware-in-the-Loop introduces realistic sensor, actuator, and timing interactions, followed by propulsion and actuator testing. Tethered tests can provide an intermediate step before incremental flight testing. Fault injection and stress testing should deliberately challenge communication, sensors, computing resources, power systems, and control loops to verify that safety mechanisms remain effective under abnormal conditions.
The Cargo UAV FCC case therefore demonstrates a practical mixed-criticality pattern: deterministic low-level flight control remains the safety authority, while mission computing and advanced AI provide higher-level capability without unrestricted actuator authority. Multi-rate execution, spatial and temporal isolation, controlled communication, redundancy, independent monitoring, fault management, power-aware degradation, and staged verification work together to preserve this boundary. The resulting architecture allows perception, planning, mission adaptation, and other intelligent functions to evolve while the FCC continues to guarantee bounded, predictable, and verifiable flight-control behavior.
Author: Richard Minsoo Go
LinkedIn: Richard Minsoo Go











Top comments (0)