Modern safety-critical systems often feature multi-core multi-SoC platforms and execute both periodic and sporadic workloads with real-time requirements. Periodic tasks benefit from a time-triggered (TT) approach, while sporadic events are best modeled by event-triggered (ET) tasks and scheduled using classical online mechanisms such as fixed-priority. Integrating TT and ET tasks in a multi-core environment has mainly been studied in fully partitioned solutions. However, for certain workloads, it may be beneficial to have a global scheduling approach for ET tasks. In this paper, we extend the current state-of-the-art in Response-Time Analysis (RTA) and Real-Time Calculus (RTC) to analyze the schedulability of sporadic ET tasks in a homogeneous multi-core TT system. We generalize previous promising results integrating TT and ET tasks using affine envelopes to homogeneous multi-core systems. While our method can be applied to any TT schedule generation mechanism, we also present a concrete schedule synthesis method based on a variant of the Least-Laxity First scheduling approach. We demonstrate the performance of our approach, in terms of both schedulability and runtime, through real-world and synthetic experiments inspired by real workloads. We note that our affine-envelope-based interference bound and the generalized burst limiting constraint (BLC) are also independent of the concrete TT synthesis algorithm and of the underlying timing analysis method (RTA or RTC). This modularity allows the framework to be combined with alternative schedulability analyses or TT schedule generation techniques, while preserving the demonstrated gains in schedulability and scalability for mixed TT and ET workloads on homogeneous multi-core platforms.

We introduce a new paradigm for synthesizing time-triggered schedules that guarantees the correct temporal behavior of time-triggered (TT) tasks and the schedulability of sporadic event-triggered (ET) tasks with arbitrary deadlines at design time. The approach first expresses a constraint for the TT task schedule in the form of a maximal affine envelope that ensures that as long as the schedule generation respects this envelope, all sporadic ET tasks meet their deadline. The second step consists of modeling this envelope as a burst limiting constraint (BLC) and building the schedule. The BLC constraint can be added to any existing TT schedule generation method as an additional constraint on the TT slot positioning. Here, we propose an efficient TT schedule generation method that integrates the BLC constraint via simulating a modified Least-Laxity-First (LLF) scheduler. We show via synthetic and real-world test cases that our novel method achieves better schedulability and a faster schedule generation for most use cases compared to other approaches inspired by, e.g., hierarchical scheduling. Moreover, we present an extension to our method that finds the most favorable schedule for TT tasks with respect to ET schedulability, thus increasing the probability that the system remains feasible when ET tasks are later added or changed.

Container-based virtualization is a lightweight deployment solution within heterogeneous Fog and Edge Computing (FEC) systems. When used in real-time FEC applications, orchestration is needed to adapt to variations in system behavior, transient overload scenarios, and changes in resource availability. Container-based orchestration can efficiently and automatically deploy, redimension, and relocate containers according to the measured real-time performance of critical applications. This paper presents a highly configurable orchestration framework for real-time containers that improves the scalability and expressiveness of state-of-the-art approaches. We propose three different heuristics for the offline placement and dimensioning of containers on nodes that scale with the size of modern industrial systems and enhance the decision-making of the online hierarchical controller to include time-utility functions which can model more accurately the usefulness of results in the case of deadline misses. We show our framework’s performance and efficiency using synthetic test cases and a real-world test bed.

Container-based virtualization is a promising deployment model in fog and edge computing applications, because it allows a seamless co-existence of virtualized applications in a heterogeneous environment without introducing significant overhead. Certain application domains (e.g., industrial automation, automotive, or aerospace) mandate that applications exhibit a certain degree of temporal predictability. Container-based virtualization cannot be easily used for such applications, since the technology is not designed to support real-time properties and handle temporal disturbances. This article proposes a framework consisting of a static offline and a dynamic online phase for resource allocation and adaptive re-dimensioning of real-time containers. In the offline phase, the optimal initial deployment and dimensioning of containers are decided based on ideal system models. Additionally, to adapt to dynamic variations caused by changing workloads or interferences, the online phase adapts the CPU usage and limits of real-time containers at runtime to improve the real-time behavior of the real-time containerized applications while optimizing resource usage. We implement the framework in a real Linux-based system and show through a series of experiments that the proposed framework is able to adjust and re-distribute computing resources between containers to improve the real-time behavior of containerized applications in the presence of temporal disturbances while optimizing resource usage.

In order to meet the requirements of critical applications, modern multi-core multi-SoC real-time systems must handle both periodic and sporadic events within specified deadlines. A two-level scheduling hierarchy that combines time-triggered and fixed-priority scheduling is effective for managing periodic time-triggered (TT) and sporadic event-triggered (ET) tasks, respectively. We introduce two polling-based approaches, called simple and advanced polling, for guaranteeing both TT and ET task deadlines within single core systems. We then propose an optimization heuristic for the task-to-core allocation problem based on genetic algorithms for fully partitioned multi-core systems that can be applied to both polling methods. We evaluate the schedulability and runtime performance of the polling approaches and investigate the effectiveness of the allocation heuristic using synthetic test cases based on real-world application characteristics. The results show that both polling approaches achieve high schedulability with low runtime, and the allocation heuristic can generate good solutions for fully partitioned systems. Furthermore, we show that the server design problem of the advanced polling approach can be integrated into the allocation heuristic to achieve better solutions in terms of schedulability and that our choice of the genetic algorithm has a good speedup when being parallelized.

Container-based virtualization has become a promising deployment model for industrial applications mainly due to its benefits, such as providing support for co-located applications in heterogeneous environments. However, such facilitation brings challenges, including full temporal isolation among real-time applications and support for time-critical applications. In this paper, we tackle such challenges, in particular when the applications are time-sensitive Control Applications. The literature suggests that flexible timing constraints for Control Applications are beneficial in responding to disturbances and minimizing response deviation. Therefore, we propose a mechanism to support such a runtime adaptation in container-based virtualization. To show the performance of the proposed mechanism, we implement our approach on a Linux-based hierarchical scheduling platform, and we evaluate it for a Control application.

Fog and edge computing offer the flexibility and decentralized architecture benefits of cloud computing without suffering from the latency issues inherent in the cloud. This makes fog computing very attractive in real-time and safety-critical applications, especially if combined with container-based technologies. Whereas different orchestration systems are available to manage the container placement based on their resource demand, no orchestration system is considering real-time requirements for containerized applications. In this paper, we present the architecture and design of a real-time container orchestrator based on Kubernetes. Moreover, this paper defines metrics for the performance evaluation of real-time containers, and describes an initial model for allocating a mixture of real-time and non-real-time containers. We present an initial implementation of our real-time container extension and evaluate its feasibility on Linux-based systems.

Time-Sensitive Networks (TSN) enable real-time communication guarantees over Ethernet by defining a timed-gate mechanism (802.1Qbv), binding frame transmissions to a global schedule, and a synchronization protocol (802.1AS), which aligns the time of each node to a reference clock. When the reference clock is lost, the individual clocks drift apart until a new master clock is elected (re-synchronization interval). This may lead to a complete loss of determinism due to an inconsistent alignment of the transmission patterns between nodes.In this paper, we address the problem of creating time-triggered schedules for 802.1Qbv with an enhanced robustness against the temporary loss of synchronization. We analyze the protocol behavior upon a loss of synchronization and derive new constraints for the computation of schedules able to tolerate the worst-case drift of individual clocks during the resynchronization interval. Moreover, we formulate the problem as a design space exploration to synthesize schedules with the maximum tolerance towards loss-of-sync issues. We have developed a scheduler tool based on the Z3 SMT/OMT solver and conducted a series of experiments with a set of synthetic use-cases. Our evaluation exposes a series of trade-offs between the robustness of the schedule and the feasibility and computation run-time of the scheduler as well as the end-to-end communication latency.

Modern Advanced Driver-Assistance Systems (ADAS) merge critical and non-critical software functions with complex timing requirements and inter-dependencies onto the same integrated hardware platform. Real-time safety-critical automotive applications feature complex dependency chains between tasks (e.g., performing sensing, processing and actuation) which have to satisfy worst-case end-to-end latency constraints. The resulting scheduling problem requires both the assignment of tasks to the available cores of the platform and the computation static schedule tables for the real-time tasks, such that task deadlines, as well as end-to-end task chain constraints, are satisfied. We propose a heuristic approach based on Simulated Annealing (SA) which creates static schedule tables by simulating Earliest Deadline First (EDF) scheduling parameterized by task offsets and local deadlines decided by SA. We evaluate the proposed solution with real-world and synthetic test cases scaled to fit the future requirements of ADAS systems.

Time-Sensitive Networking (TSN) extends IEEE 802.1 Ethernet for safety-critical and real-time applications in several areas, e.g., automotive, aerospace or industrial automation. However, many of these systems also have stringent security requirements, and security attacks may impair safety. Given a TSN-based distributed architecture, a set of applications with tasks and messages, as well as a set of security and redundancy requirements, we are interested to synthesize a system configuration such that the real-time, safety and security requirements are satisfied. We use the Timed Efficient Stream Loss-Tolerant Authentication (TESLA) low-resource multicast authentication protocol to guarantee the security requirements, and redundant disjunct message routes to tolerate link failures. We consider that the tasks are scheduled using static cyclic scheduling and that the messages use the time-sensitive traffic class in TSN, which relies on schedule tables (called Gate Control Lists, GCLs) in the network switches. A configuration consists of the schedule tables for tasks as well as the disjoint routes and GCLs for messages. We propose a Constraint Programming-based formulation for this problem and we evaluate it on several test cases.

Time-Sensitive Networking (TSN) introduces standardized mechanisms that add real-time capabilities to IEEE 802.1 Ethernet networks. In particular, the Time-Aware Shaper (TAS) can be used to send frames in a deterministic fashion according to a predefined global schedule. Existing methods for generating the global communication schedule enforce isolation either in the time or in the space domain. This extended abstract presents a novel, more flexible window-based scheduling algorithm which removes the previously required isolation constraints for Scheduled Traffic (ST) by integrating worst-case delay analysis to guarantee bounded latency.

In mixed-criticality Ethernet-based time-triggered networks, like TTEthernet, time-triggered communication (TT) coexists with rate-constrained (RC) and best-effort (BE) traffic. A global communication scheme, i.e., a schedule, establishes contention-free transmission times for TT flows ensuring guaranteed low latency and minimal jitter. Current approaches use Satisfiability Modulo Theories (SMT) to formulate the scheduling constraints and solve the resulting problem. However, these approaches do not take into consideration the impact of the TT schedule on RC traffic. Hence, the resulting TT schedule may cause the worst-case latency requirements of RC traffic not to be fulfilled anymore.In this paper, we present a novel method for including an RC analysis in state-of-the-art SMT-based schedule synthesis algorithms via a feedback loop in order to maintain the optimality properties of the SMT-based approaches while also being able to improve the RC traffic delays. Our method is designed in such a way that it can be readily integrated into existing SMT- or MiP-based solutions. We evaluate our approach using variants derived from a realistic use-case and present methods to further improve the efficiency of our feedback-based approach.

In this paper we address a network architecture that uses a combination of network virtualization and software defined networking in order to reduce complexity of network management and at the same time support high quality of service. Within this network architecture, we propose a framework to be able to dynamically distribute the network bandwidth to various services such that the network resources are utilized efficiently. In many industrial domains, multiple services may use the same hardware platform for the sake of a better resource utilization. Therefore, bandwidth distribution among the services should be done in an efficient way during runtime. We also develop an admission control in this framework which dynamically coordinates the bandwidth distributions based on requested quality of services. We show the applicability of the proposed framework by implementing it on a common SDN controller. Moreover, we conduct a set of experiments to show the performance of the proposed framework.

Time-Sensitive Networks are becoming the standard in real-time networking over IEEE 802 Ethernet. The set of TSN standards currently being defined by the IEEE TSN task group offer mechanisms introducing real-time behavior over specialized hardware network nodes. Out of these standards we identify those enabling the integration of deterministic real-time communication with the legacy best-effort traffic. In this demonstration we show the management of a simple TSN hardware setup via the Slate XNS tool-chain. We demonstrate the ease-of-use of the tools in charge of the entire network as well as the provided scheduling capabilities allowing one-click deployment of deterministic communications with properly configured IEEE 802.1Qbv and IEEE 802.1ASrev sub-standards.

Time Sensitive Networks (TSN) emerge as the set of sub-standards incorporating real-time support as an extension of standard Ethernet. In particular, IEEE 802.1Qbv defines a time-triggered communication paradigm with the addition of a time-aware shaper governing the selection of frames at the egress queues according to a predefined schedule, encoded in so-called Gate Control Lists (GCL). Nonetheless, the design of compositional systems with real-time demands requires a proper configuration of these mechanisms to truly achieve the temporal isolation of communication streams with end-to-end timeliness guarantees. In this paper we address how the synthesis of communication schedules for GCLs defined in IEEE 802.1Qbv can be formalized as a system of constraints expressed via first-order theory of arrays (T_A). We formulate the necessary constraints showing the suitability of the theory of arrays and discuss optimization opportunities arising from the underlying scheduling problem. Our evaluation using general-purpose SMT/OMT solvers proves the validity of the approach, scaling well for small-to medium-networks, and exposing trade-offs for the time needed to synthesize a schedule. Furthermore, we conduct a comparison against previous work and conclude the appropriateness of the method as the basis for future TSN scheduling tools.

Mixed-criticality and high availability distributed systems, like those on large industrial deployments, strongly rely on deterministic communication in order to guarantee the realtime behavior. The time-triggered paradigm-as in TTEthernet-guarantees the deterministic delivery of messages with fixed latency and limited jitter. We look closely at industrial deployments in which production as well as consumption of messages is carried out within software tasks running on distributed embedded nodes (i.e. end-systems). We present an approach to minimize the end-to-end latency of such tasks, respecting their precedence constraints as well as the scheduled communication in an underlying switched TTEthernet network. The approach is based on and validated by a large industrial use-case for which we analyze a test bed implementing our solution.

Variable-bandwidth servers (VBS) control process execution speed by allocating variable CPU bandwidth to processes. VBS enables temporal isolation of EDF-scheduled processes in the sense that the variance in CPU throughput and latency of each process is bounded independently of any other concurrently running processes. In this paper we aim at reducing CPU power consumption with VBS by CPU voltage and frequency scaling while maintaining temporal isolation. Scaling to lower frequencies is possible whenever there is CPU slack in the system. We first show that, in the presence of CPU slack, frequency scaling of EDF-scheduled, possibly non-periodic tasks (as they arise with VBS) is safe up to full CPU utilization and propose a frequency-scaling VBS algorithm that exploits CPU slack to minimize operating frequencies with maximal CPU utilization while maintaining temporal isolation. Additional power may be saved by redistributing computation time of individual processes while still maintaining temporal isolation if the system has knowledge of future events. We introduce an offline algorithm as an optimal baseline and an online algorithm that approximates the baseline. While the offline algorithm works for various, possibly complex power consumption models, the online algorithm may reduce power consumption only for a simplified power consumption model by reducing the CPU utilization jitter in the system.

We propose two complementary methods to account for scheduler overhead in the schedulability analysis of Variable Bandwidth Servers (VBS), which control process execution speed by allocating variable CPU bandwidth to processes. Scheduler overhead in VBS may be accounted for either by decreasing process execution speed to maintain CPU utilization (called response accounting), or by increasing CPU utilization to maintain process execution speed (called utilization accounting). Both methods can be combined by handling an arbitrary fraction of the total scheduler overhead with one method and the rest with the other. Distinguishing scheduler overhead due to releasing and due to suspending processes allows us to further improve our analysis by accounting for releasing overhead in a separate, virtual VBS process. Although our analysis is based on the VBS model, the general idea of response and utilization accounting may also be applied to other, related scheduling methods.