QUIC is a UDP-based transport protocol, standardized in RFC9000 (2021). It enhances privacy by encrypting entire packets and offers improvements over TCP, such as native multiplexing and connection migration. Despite these advantages, QUIC, like TCP, suffers from head-of-line blocking and variable latency, making it unsuitable for critical real-time systems. RFC9221 addresses this by introducing an extension that allows QUIC to transmit datagrams without retransmission, improving its suitability for real-time applications. However, real-time networks require a thorough evaluation of QUIC’s performance. The potential delays caused by its cryptographic operations and the complex traffic patterns it generates could impact time-sensitive traffic. We conduct experiments using Mininet across a range of scenarios, including software updates in bandwidth-constrained environments and in the presence of malicious nodes. Additionally, we assess implementations in both Go and C. The performance of QUIC, along with its datagram extension, is compared against UDP and DTLS. Finally, the results are validated through testing on a physical network testbed. Our results show that, despite its cryptographic overhead, QUIC performs similarly to UDP and DTLS in most cases. However, it may interact poorly with lower-layer mechanisms like token-bucket filters. Overall, QUIC shows potential to replace older transport protocols in real-time systems.
Conventional wisdom maintains that the interval of time mutually exclusive access is granted to a shared resource (i.e., in a critical section) should be as short as possible. However, the arbitration of shared-resource accesses introduces overhead. As a result, there exist task systems for which schedulability can only be guaranteed when accesses are grouped together into one large critical section, as opposed to many smaller sections. Furthermore, when the shared resource is a graphics processing unit (GPU), the durations of some GPU accesses decrease when multiple such accesses compose a single critical section, compared to when they are kept separate. In this paper, an extended resource model is presented in which each critical section can comprise several grouped accesses, rather than each access forming its own critical section. This model reveals a trade-off between overhead and blocking: a low-priority task with resource accesses grouped into fewer critical sections incurs less overhead at the expense of greater blocking suffered by higher-priority tasks. An optimal algorithm for resolving this trade-off for a shared GPU under uniprocessor fixed-priority scheduling is presented, along with an experimental evaluation that demonstrates its benefits compared to the extremes of critical-section granularity.
Typically, in a cyber-physical system (CPS), timing jitters between sensing and actuation adversely affect its physical behavior. Logical execution time (LET) paradigm has gained industry attention because it offers zero jitters in tasks’ response time. In autonomous CPS such as self-driving cars, Robot Operating System 2 (ROS2) is becoming a popular software platform to implement computation tasks. Towards a practical LET implementation of ROS2 computation chains, we propose to use at least two table-driven reservation servers: (i) one exclusively runs the processor thread that publishes the chain’s output while (ii) others isolate the chain’s main computations from best-effort workloads on the same processing unit. We show how to architecturally adapt the chain non-intrusively as well as dimension the servers and allocate appropriate threads to them so that we obtain negligible jitters while keeping the observed maximum end-to-end latency comparable to a high-priority execution of the chain. Also, our approach is versatile and can produce latency bands, thereby offering an opportunity to co-optimize jitters and average end-to-end latency. This further supports multi-mode application design, which is especially important for a high-performance operation in different environments, e.g., city and highway driving. Our idea does not involve modification or recompilation of the application code or ROS2 libraries, which is crucial in industry settings. We have also developed tools to automate our approach. By applying our proposed mechanism on a real-world benchmark implementing Lidar-based localization, we maintain a constant end-to-end latency that is even 13% shorter than an improved LET implementation.
We present a Markov chain-based framework for studying the longterm average behaviors of periodic real-time task systems in which the tasks have stochastically varying computation times. In sharp contrast to previous work, we construct our Markov chains w.r.t. to a unit of time that is not required to be the hyperperiod of the task system. Our chains have an important property called irreducibility, and this secures the mathematical basis for a simple sampling procedure for estimating the long-term averages of interest. This is significant because for task systems of practical interest, it will be computationally infeasible to use hyperperiods to determine the required expected values. Our experimental results show that our method can be used to analyze long-term average behaviors - such as deadline misses and weakly-hard constraint violations - with high accuracy, and that it scales well to large systems (with up to 1000 tasks). We further demonstrate its practical utility using a case study of a rover control system.
Many mixed-criticality system models drop all jobs of low-criticality tasks when a criticality mode switch occurs, ensuring that high-criticality tasks still can meet their deadlines in the new mode. However, this means that even important low-criticality tasks are discarded, which may not be acceptable in some systems in practice. This paper addresses that distinction between criticality and importance through a new Inelastic Graceful Earliest Deadline First with Virtual Deadlines (IG-EDF-VD) scheme that upon a criticality mode switch only discards the least important low-criticality tasks necessary to ensure feasibility. Moreover, we consider elastic scheduling within our mixed-criticality model (EG-EDF-VD), using compression of workload-elastic tasks’ utilizations (and, as a result, execution time budgets) to reduce further the number of low-criticality tasks that are dropped.
