Traditional real-time approaches often ignore the dynamic, state-dependent nature of (functional) requirements in distributed Cyber-Physical Systems (CPSs), leading to overly pessimistic design solutions, which either significantly over-provision computational and communication resources, or result in inferior functional performance. This Challenge aims to foster fundamental discussions and collaborations at the intersection of real-time systems and control engineering. We propose to explore a paradigm shift: moving beyond static, worst-case real-time attributes towards dynamic, context-aware ones, rooted in physics-driven performance. We provide a realistic automotive use-case, featuring a distributed lateral motion control functionality, and challenge the real-time community to develop innovative scheduling and design solutions. The ultimate goal is to facilitate more efficient, robust, and adaptive distributed applications, by aligning real-time system design with the dynamic needs of control, without over-dimensioning resources.

We introduce Silverline, a novel framework for lightweight virtualization and orchestration of distributed real-time systems. Leveraging WebAssembly (Wasm) for robust sandboxing and multi-language (polyglot) capabilities, Silverline decouples applications from their platforms through distinct manifests, enabling a centralized orchestrator to optimize resource allocation and deploy Wasm modules seamlessly across the edge-cloud continuum. It features a split data and control plane with orchestration sidecars, allowing applications to use native communication protocols and respond autonomously to network changes. We evaluate our framework in two real application contexts: an industrial automation use-case and an automotive body electronics demonstrator. Through micro-benchmarks and end-to-end testing, we demonstrate Silverline's potential for managing real-time workloads in diverse heterogeneous ecosystems.

The precision advantages offered by harnessing the quantum states of sensors can be readily compromised by noise. However, when the noise has a different spatial function than the signal of interest, recent theoretical work shows how the advantage can be maintained and even significantly improved. In this Letter, we experimentally demonstrate the associated sensing protocol, using trapped-ion sensors. An entangled state of multidimensional sensors is created that isolates and optimally detects a signal, while being insensitive to otherwise overwhelming noise fields with different spatial profiles over the sensor locations. The quantum protocol is found to outperform a perfect implementation of the best comparable strategy without sensor entanglement. While our demonstration is carried out for magnetic and electromagnetic fields over a few microns, the technique is readily applicable over arbitrary distances and for arbitrary fields, thus present a promising application for emerging quantum sensor networks.

We consider the selective sensing of planar waves in the presence of noise. We present different methods to control the sensitivity of a quantum sensor network, which allow one to decouple it from arbitrarily selected waves while retaining sensitivity to the signal. Comparing these methods with classical (non-entangled) sensor networks we demonstrate two advantages. First, entanglement increases precision by enabling the Heisenberg scaling. Second, entanglement enables the elimination of correlated noise processes corresponding to waves with different propagation directions, by exploiting decoherence-free subspaces. We then provide a theoretical and numerical analysis of the advantage offered by entangled quantum sensor networks, which is not specific to waves and can be of general interest. We demonstrate an exponential advantage in the regime where the number of sensor locations is comparable to the number of noise sources. Finally, we outline a generalization to other waveforms, e.g., spherical harmonics and general time-dependent fields.

We consider the task of multiple parameter estimation in the presence of strong correlated noise with a network of distributed sensors. The signals and the noises have different spatial dependence but are encoded with the same local generators. We study how to find and improve noise-insensitive strategies. We show that sequentially probing with GHZ states from the decoherence-free subspace that we identify is asymptotically optimal up to a factor of at most 4 in the limit of many repetitions. The implementation of such strategies only requires local read-out and ‘passive’ resources—an initially entangled state of the sensors and tunable local interaction strength.

In embedded real-time automotive systems, Software-in-the-Loop (SiL) represents the state-of-the-art for testing software code at design time. SiL environments focus on testing the functional software behaviour, typically neglecting the timing non-idealities introduced by the target embedded hardware. This separation of concerns prevents a credible virtual testing and validation of time-critical systems.In this paper, we propose an industry-viable modular co-simulation architecture based on the Functional Mock-up Interface (FMI) 3.0 standard, coupling timing simulation and functional simulations to obtain a timing-aware functional simulation of automotive applications. The proposed method enables an evaluation of the behaviour of functional software on the target hardware earlier in the development process. Also, our solution allows for the co-simulation of submodels generated with different tools, with minimal modifications required. Ultimately, this approach enables front-loading of development efforts, leading to reduced costs and time to market. A case study is presented to show a detailed examination of the proposed architecture.

The concept of Digital Twins (DTs) has been discussed intensively for the past couple of years. Today we have instances of digital twins that range from static descriptions of manufacturing data and material properties over live interfaces on operational data of cyber physical systems to the functions and services they provide. Currently, there are no standardized interfaces to aggregate atomic DTs (e.g., the twin of the lowest-level function of a machine) to higher-level DTs providing more complex services in the virtual world. Additionally, there is no existing infrastructure to reliably link the DTs in the virtual world to the integrated CPSs in the physical world, such as a car consisting of many ECUs with even more functions. The concept of the Metaverse is gaining increasing traction and has been explored from different angles, usually centered around a human user, true to its original definition. Beyond social interactions, the Metaverse offers possibilities to integrate layers of interconnected Digital Twins (DTs) representing parts of and interacting with the physical world in real-time, enabling not only analysis and representation of current state, but also feedback loops and control. This paper describes how the Metaverse can become the virtual world where DTs of humans and machines live, and how to reliably connect DTs to the physical world.

The domains of Cyber-Physical Systems (CPSs) and Information Technology (IT) are converging. Driven by the need for increased compute performance, as well as the need for increased connectivity and runtime flexibility, IT hardware, such as microprocessors and Graphics Processing Units (GPUs), as well as software abstraction layers are introduced to CPS. These systems and components are being enhanced for the execution of hard real-time applications. This enables the convergence of embedded and IT: Embedded workloads can be executed reliably on top of IT infrastructure. This is the dawn of Reliable Distributed Systems (RDSs), a technology that combines the performance and cost of IT systems with the reliability of CPSs. The Fabric is a global RDS runtime environment, weaving the interconnections between devices and enabling abstractions for compute, communication, storage, sensing & actuation. This paper outlines the vision of RDS, introduces the aspects required for implementing RDSs and the Fabric, relates existing technologies, and outlines open research challenges.

In the last decade quantum machine learning has provided fascinating and fundamental improvements to supervised, unsupervised and reinforcement learning. In reinforcement learning, a so-called agent is challenged to solve a task given by some environment. The agent learns to solve the task by exploring the environment and exploiting the rewards it gets from the environment. For some classical task environments, such as deterministic strictly epochal environments, an analogue quantum environment can be constructed which allows to find rewards quadratically faster by applying quantum algorithms. In this paper, we analytically analyze the behavior of a hybrid agent which combines this quadratic speedup in exploration with the policy update of a classical agent. This leads to a faster learning of the hybrid agent compared to the classical agent. We demonstrate that if the classical agent needs on average $\langle J \rangle$ rewards and $\langle T \rangle_c$ epochs to learn how to solve the task, the hybrid agent will take $\langle T \rangle_q \leq \alpha \sqrt{\langle T \rangle_c \langle J \rangle}$ epochs on average. Here, $\alpha$ denotes a constant which is independent of the problem size. Additionally, we prove that if the environment allows for maximally $\alpha_o k_\text{max}$ sequential coherent interactions, e.g. due to noise effects, an improvement given by $\langle T \rangle_q \approx \alpha_o\langle T \rangle_c/4 k_\text{max}$ is still possible.

To offer an infrastructure for autonomous systems offloading parts of their functionality, dynamic distributed systems must be able to satisfy non-functional quality-of-service (QoS) requirements. However, providing hard QoS guarantees without complex global verification that are satisfied even under uncertain conditions is very challenging. In this work, we propose a contract-based QoS assurance for centralized, hierarchical systems, which requires local verification only and has the potential to cope with dynamic changes and uncertainties.

We consider the sensing of scalar valued fields with specific spatial dependence using a network of sensors, e.g. multiple atoms located at different positions within a trap. We show how to harness the spatial correlations to sense only a specific signal, and be insensitive to others at different positions or with unequal spatial dependence by constructing a decoherence-free subspace for noise sources at fixed, known positions. This can be extended to noise sources lying on certain surfaces, where we encounter a connection to mirror charges and equipotential surfaces in classical electrostatics. For general situations, we introduce the notion of an approximate decoherence-free subspace, where noise for all sources within some volume is significantly suppressed, at the cost of reducing the signal strength in a controlled way. We show that one can use this approach to maintain Heisenberg-scaling over long times and for a large number of sensors, despite the presence of multiple noise sources in large volumes. We introduce an efficient formalism to construct internal states and sensor configurations, and apply it to several examples to demonstrate the usefulness and wide applicability of our approach.

Temporal isolation is one of the key challenges for co-running mixed-criticality applications on Commercial Off-The-Shelf (COTS) multi-core platforms. In particular, the main memory subsystem is one of the most prominent causes of interference and loss of isolation. Existing mechanisms for memory bandwidth regulation are limited to conservative bandwidth reservation, use pessimistic worst-case execution time (WCET) estimations or require dedicated hardware that is not feasible in COTS multi-core platforms.In this paper, we propose a novel mechanism for memory interference control that uses feedback-based control to dynamically regulate memory accesses of individual cores in a multicore platform. Our mechanism directly regulates the source of interference by leveraging information about memory utilization, acquired from existing hardware performance counters provided by modern COTS-based memory controllers. The proposed solution is implemented on Linux as a loadable kernel module. The results of evaluating our approach with real and synthetic benchmarks on a COTS multi-core (NXP S32V234) platform demonstrate that it is able to provide temporal isolation with up to 4x and 2x more overall throughput for non-real-time applications compared to static and dynamic memory bandwidth-based regulation approaches, respectively, while maintaining guarantees for applications running on the real-time core.

Most off-the-shelf embedded control systems lack proper mechanisms to handle computational overload conditions. Therefore, delays may accumulate and produce overruns, potentially harming the stability and performance of the controlled system. In this paper, we explore a controller implementation in which overrun events are tolerated and tackled with a proper countermeasure, which can be easily plugged into existing controller implementations and in particular commercial off-the-shelf control systems. When an overrun occurs, the control period of the next job is reinitialized and its control parameters are adjusted to counteract the additional delay of the previous job. The main strength of this approach resides in a straightforward applicability and in a high flexibility in deployment. It does neither require a stochastic model of the timing evolution of the system, nor rely on prediction of future delays. We provide an exact tool to determine the system stability, which requires only the knowledge of the worst case response time. The final controlled system exhibits a good trade-off between simplicity and performance, both during nominal and overload conditions.

As the field of artificial intelligence is pushed forward, the question arises of how fast autonomous machines can learn. Within artificial intelligence, an important paradigm is reinforcement learning, where agents - learning entities capable of decision making - interact with the world they are placed in, called an environment. Thanks to these interactions, agents receive feedback from the environment and thus progressively adjust their behaviour to accomplish a given goal. An important question in reinforcement learning is how fast agents can learn to fulfill their tasks. To answer this question we consider a novel reinforcement learning framework where quantum mechanics is used. In particular, we quantize the agent and the environment and grant them the possibility to also interact quantum-mechanically, that is, by using a quantum channel for their communication. We demonstrate that this feature enables a speed-up in the agent's learning process, and we further show that combining this scenario with classical communication enables the evaluation of such an improvement. This learning protocol is implemented on an integrated re-programmable photonic platform interfaced with photons at telecommunication wavelengths. Thanks to the full tunability of the device, this platform proves the best candidate for the implementation of learning protocols, where a continuous update of the learning process is required.

Robotic systems are typically subject to real-time constraints. Still, the ROS ecosystem—the most popular repository of open-source robotics software—exhibits little evidence of the use of real-time theory to bound or control worst-case response times. Hurdles to adoption are the amount of expertise required to correctly use real-time scheduling mechanisms and the inherent unpredictability of typical robotics workloads, which defy static provisioning. To overcome these hurdles, ROS-Llama, an automatic latency manager for ROS2, is proposed. Crucially, use of ROS-Llama requires only little effort and knowledge of realtime concepts. Relevant properties of ROS2 and essential requirements of the robotics domain are identified, and the conceptual and practical challenges in developing such a mostly automatic tool are discussed. Experiments on a mobile robot demonstrate the viability of the approach and show that ROS-Llama reduces the maximum observed latency under load compared to the default Linux scheduler. Finally, open problems in the underlying real-time analysis and major platform limitations in Linux and ROS2 that prevent further improvements are identified.

Early run-time prediction of co-running independent applications prior to application integration becomes challenging in multi-core processors. One of the most notable causes is the interference at the main memory subsystem, which results in significant degradation in application performance and response time in comparison to standalone execution. Currently available techniques for run-time prediction like traditional cycle-accurate simulations are slow, and analytical models are not accurate and time-consuming to build. By contrast, existing machine learning-based approaches for run-time prediction simply do not account for interference. In this paper, we use a machine learning-based approach to train a model to correlate performance data (instructions and hardware performance counters) for a set of benchmark applications between the standalone and interference scenarios. After that, the trained model is used to predict the run-time of co-running applications in interference scenarios. In general, there is no straightforward one-to-one correspondence between samples obtained from the standalone and interference scenarios due to the different run-times, i.e. execution speeds. To address this, we developed a simple yet effective sample alignment algorithm, which is a key component in transforming interference prediction into a machine learning problem. In addition, we systematically identify the subset of features that have the highest positive impact on the model performance. Our approach is demonstrated to be effective and shows an average run-time prediction error, which is as low as 03% and 0.1% for two co-running applications.

As the field of artificial intelligence advances, the demand for algorithms that can learn quickly and efficiently increases. An important paradigm within artificial intelligence is reinforcement learning 1 , where decision-making entities called agents interact with environments and learn by updating their behaviour on the basis of the obtained feedback. The crucial question for practical applications is how fast agents learn 2 . Although various studies have made use of quantum mechanics to speed up the agent’s decision-making process 3 , 4 , a reduction in learning time has not yet been demonstrated. Here we present a reinforcement learning experiment in which the learning process of an agent is sped up by using a quantum communication channel with the environment. We further show that combining this scenario with classical communication enables the evaluation of this improvement and allows optimal control of the learning progress. We implement this learning protocol on a compact and fully tunable integrated nanophotonic processor. The device interfaces with telecommunication-wavelength photons and features a fast active-feedback mechanism, demonstrating the agent’s systematic quantum advantage in a setup that could readily be integrated within future large-scale quantum communication networks.

The QNX operating system has emerged as a promising candidate as a base operating system for upcoming domain or vehicle integration computers in centralized automotive E/E. In this work, we look deeper in the Adaptive Partitioning Scheduler offered by QNX with the aim of assessing its suitability in providing temporal isolation and guaranteed execution behavior to different applications. With APS, QNX has introduced budget-based scheduling into a mainstream commercial OS and hence deserves merit. However we also found certain drawbacks in the APS scheduler and in order to mitigate the problems caused by them, we propose some guidelines for system designers to configure their systems efficiently.

Real-time servers have been widely explored in the scheduling literature to predictably execute aperiodic activities, as well as to allow hierarchical scheduling settings. As they allow achieving timing isolation between previously isolated and functionally diverse applications, there is a renewed interest for the adoption of fixed priority real-time servers in the automotive domain, as a way to implement more efficient reservation mechanisms than TDMA-based methods. Thus, this paper presents an overhead-aware schedulability analysis for hierarchical fixed priority preemptive (HFPP) systems, and proposes a practical server parameterization technique preserving the least possible utilization and enhancing the aggregated WCRT, i.e. the sum of WCRTs, of the tasks in a hierarchical scheduling setting.

Due to the trends of centralizing the EIE architecture and new computing-intensive applications, high-performance hardware platforms are currently finding their way into automotive systems. However, the Systems-on-Chip (SoCs) currently available on the market have significant weaknesses when it comes to providing predictable performance for time-critical applications. The main reason for this is that these platforms are optimized for average-case performance. This shortcoming represents one major risk in the development of current and future automotive systems. In this paper we describe how highperformance and predictability could (and should) be reconciled in future HW /SW platforms. We believe that this goal can only be reached via a close collaboration among system suppliers, IP providers, semiconductor companies, and OS/hypervisor vendors. Furthermore, academic input will be needed to solve remaining challenges and to further improve initial solutions.