Silviu S. Craciunas

SMT-based Task- and Network-level Static Schedule Generation for Time-Triggered Networked Systems

In Ethernet-based time-triggered networks, like TTEthernet, a global communication scheme, for which the schedule synthesis is known to be an NP-complete problem, establishes contention-free windows for the exchange of messages with guaranteed low latency and minimal jitter. However, in order to achieve end-to-end determinism at the application level, software tasks running on the end-system nodes need to obey a similar execution scheme with tight dependencies towards the network domain. In this paper we address the simultaneous co-synthesis of network as well as application schedules for preemptive time-triggered tasks communicating in a switched multi-speed time-triggered network. We use Satisfiability Modulo Theories (SMT) to formulate the scheduling constraints and solve the resulting problem using a state-of-the-art SMT solver. Furthermore, we introduce a novel incremental scheduling approach, based on the demand bound test for asynchronous constrained-deadline periodic tasks, which significantly improves scalability for the average case without sacrificing schedulability. We demonstrate the performance of our approach using synthetic network topologies and system configurations.

The JAviator: A High-Payload Quadrotor UAV with High-Level Programming Capabilities

We present the JAviator (Java Aviator), a high-performance quadrotor model helicopter that is built around a high-integrity frame, which is horizontally and vertically symmetric, and supports high payloads through light-weight materials and advanced brushless motors. The JAviator is 1.3m in diameter, weighs 2.2kg in total, and generates a maximum lift of 5.4kg, which translates into a theoretical maximum payload of 3.2kg. Without payload the maximum flight time is around 40min. The JAviator may be programmed in Java using a real-time extension called Exotasks. As an alternative to Java threads, Exotasks enable time-portable programming of high-performance, hard real-time applications in Java. With Exotasks we are able to fly the JAviator using different hardware platforms and software workloads without changing any of the application-level real-time software. The JAviator also serves as a test platform for other software projects such as our own realtime operating system called Tiptoe, which is in a prototypical stage and meant to provide even stronger forms of time portability than Exotasks. Tiptoe supports the execution of real-time processes whose temporal behavior, even including system-level aspects such as their I/O communication and memory management, can be predicted per process, independently of the other processes. The paper describes the JAviator’s hardand software design in detail and reports on propulsion, flight, and software tests.

Combined task- and network-level scheduling for distributed time-triggered systems

Ethernet-based time-triggered networks (e.g. TTEthernet) enable the cost-effective integration of safety-critical and real-time distributed applications in domains where determinism is a key requirement, like the aerospace, automotive, and industrial domains. Time-Triggered communication typically follows an offline and statically configured schedule (the synthesis of which is an NP-complete problem) guaranteeing contention-free frame transmissions. Extending the end-to-end determinism towards the application layers requires that software tasks running on end nodes are scheduled in tight relation to the underlying time-triggered network schedule. In this paper we discuss the simultaneous co-generation of static network and task schedules for distributed systems consisting of preemptive time-triggered tasks which communicate over switched multi-speed time-triggered networks. We formulate the schedule problem using first-order logical constraints and present alternative methods to find a solution, with or without optimization objectives, based on satisfiability modulo theories (SMT) and mixed integer programming (MIP) solvers, respectively. Furthermore, we present an incremental scheduling approach, based on the demand bound test for asynchronous tasks, which significantly improves the scalability of the scheduling problem. We demonstrate the performance of the approach with an extensive evaluation of industrial-sized synthetic configurations using alternative state-of-the-art SMT and MIP solvers and show that, even when using optimization, most of the problems are solved within reasonable time using the incremental method.

Programmable temporal isolation through variable-bandwidth servers

We introduce variable-bandwidth servers (VBS) for scheduling and executing processes under programmable temporal isolation. A VBS is an extension of a constant-bandwidth server where throughput and latency of process execution can not only be controlled to remain constant across different competing workloads but also to vary in time as long as the resulting bandwidth stays below a given bandwidth cap. We have designed and implemented a VBS-based EDF-style constant-time scheduling algorithm, a constant-time admission test, and four alternative queue management plugins which influence the scheduling algorithms overall temporal and spatial complexity. Experiments confirm the theoretical bounds in a number of microbenchmarks and demonstrate that the scheduler can effectively manage in constant time any number of processes up to available memory while maintaining response times of individual processes within a bounded range. We have also developed a small-footprint, bare-metal virtual machine that uses VBS for temporal isolation of multiple, concurrently running processes executing real code.

I/O resource management through system call scheduling

A principal challenge in operating system design is controlling system throughput and responsiveness while maximizing resource utilization. Unlike previous attempts in kernel resource management, which often involve non-trivial changes in kernel subsystems, we focus on the kernels edge. System calls are usually the default mechanism for user processes to get access to operating system services. System calls can therefore be used to control throughput and responsiveness and thus also affect resource utilization directly. We propose a simple, non-intrusive kernel-space mechanism for explicit, per-process system call scheduling already at kernel entry in order to control the time and rate at which system calls are executed, and, as a result, the per-process utilization of the involved resources. We have developed a high-performance Linux 2.6 kernel patch with SMP support that implements system call scheduling for network- and disk-related I/O calls with policies that resemble traffic shaping in network routers. Our experiments show that already simple and easy-to-use policies provide effective I/O-related process isolation with low overhead, and reduce thrashing in certain overload scenarios. While system call scheduling may still not be able to outperform resource management systems that use specifically tuned kernel subsystems, our experiments indicate that it may sufficiently support relevant soft real-time applications yet using a vastly simpler and more generic approach.

Programmable temporal isolation in real-time and embedded execution environments

We begin this paper with a wish list of features that we feel a modern real-time and embedded execution environment should offer. We then look at some of the key weaknesses of conventional real-time operating systems (RTOS) and limitations of virtual execution environments (VEE), which typically offer some of the features but not all in one system. We propose to remedy the problem by carefully combining, in a single virtualized execution environment, well-known operating systems and virtualization techniques with an efficient real-time scheduler, which we have recently developed. The scheduler enables temporal isolation of concurrently executing processes and allows to change guaranteed process execution speeds efficiently at any time during execution. We also report on preliminary experiments with a prototypical bare-metal implementation.

Scheduling Real-Time Communication in IEEE 802.1Qbv Time Sensitive Networks

The enhancements being developed by the Time-Sensitive Networking Task Group as part of IEEE 802.1 emerge as the future of real-time communication over Ethernet networks for automotive and industrial application domains. In particular IEEE 802.1Qbv is key to enabling timeliness guarantees via so-called time-aware shapers. In this paper, we address the computation of fully deterministic schedules for 802.1Qbv-compliant multi-hop switched networks. We identify and analyze key functional parameters affecting the deterministic behaviour of real-time communication under 802.1Qbv and, based on a generalized configuration of these parameters, derive the required constraints for computing offline schedules guaranteeing low and bounded jitter and deterministic end-to-end latency for critical communication flows. Furthermore, we discuss several optimization directions and concrete configurations exposing trade-offs against the required computation time. We also show the performance of our approach via synthetic network workloads on top of different network configurations.

Optimal static scheduling of real-time tasks on distributed time-triggered networked systems

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.

Response Time versus Utilization in Scheduler Overhead Accounting

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.

Analysis of Deterministic Ethernet scheduling for the Industrial Internet of Things

Scheduling and guaranteeing strict timeliness for real-time communication across large networks, like those envisioned in the Industrial Internet of Things (IoT), in coexistence with non-critical traffic, opens up a remarkable opportunity of application for Deterministic Ethernet. However, the inherently dynamic behavior and flexibility required in IoT systems contrast with the typically static design of scheduled time-triggered networks. This paper explores the feasibility of online incremental synthesis of network schedules that adapt to such dynamic behavior without losing the strict timeliness guarantees. We investigate the computational complexity of the incremental scheduling problem and profile performance metrics enabling the evaluation of potential trade-offs setting the boundaries of online-close to real-time- time-triggered scheduling for the Industrial Internet of Things.