A Foundation for Development of Programming Languages for Real-Time Systems

Applications of real-time systems have grown considerably in both diversity and popularity, and the demand for real-time software has never been higher. In contrast, the choice of programming languages used to develop these systems has mostly remained limited to decades-old languages, namely Ada and C/C++, and more recently real-time Java. We postulate that the main reason for this mono-culture is the difficulty of developing new programming languages for real-time systems, due to their strict correctness requirements. Wang et al. argue that implementing even general-purpose languages is not easy, and is the source of many problems in today's languages. They propose the Micro Virtual Machine as a minimal abstraction layer to relieve the challenges of implementing a managed language, and design a micro VM specification named Mu. Compared to conventional language VMs, a micro VM is minimal and low-level. This makes micro VM an appealing idea towards creating a platform for development of programming languages for real-time systems, as it allows supporting a wide range of languages, aligned with the huge diversity of real-time systems. It also makes correct implementation and formal verification of the platform easier, which is vital for many real-time systems. Prior to this thesis, the only concrete micro VM specification was [Mu, 2018]. However,Mu is not designed for real-time systems and lacks some of the essential features. My thesis is that a real-time-enabled micro virtual machine is capable of providing an efficient and usable foundation for development of program-ming languages, suitable for building real-time software. The first high-level contribution of this thesis is the design of RTMu, a micro VM instance aiming at programming languages for real-time systems. We build on the Mu specification and propose a set of modifications to its abstractions over concurrency and memory management to make it suitable for real-time systems. The second contribution is the affirmation of the implementability of the RTMu's abstractions. For this purpose, we build a high-performance implementation of the RTMu specification, based-on a high-performance implementation of Mu. The third contribution is the design of a real-time extension to RPython, to make it a fully-featured language for real-time systems, named RT-RPython. We implement RT-RPython on top of RTMu and evaluate its performance through the CollisionDetection benchmark suite. This thesis is a proof of concept for establishing the use of micro VMs to build new high-quality programming languages for real-time systems. It also provides empirical demonstration of performance and predictability for micro VMs in the real-time domain. We believe that RTMu can help in tackling the current lack of diversity in programming languages for real-time systems

An Abstraction-Refinement Theory for the Analysis and Design of Concurrent Real-Time Systems

Concurrent real-time systems with shared resources belong to the class of safety-critical systems for which it is required to determine both temporally and functionally conservative guarantees. However, the growing complexity of real-time systems makes it more and more challenging to apply standard techniques for their analysis. Especially the presence of both cyclic data dependencies and cyclic resource dependencies makes many related analysis approaches inapplicable. The usage of Static Priority Preemptive (SPP) scheduling further impedes the employment of many "classical" analysis techniques. To address this growing complexity and to be able to give guarantees nevertheless we present an abstraction-refinement theory for real-time systems. We introduce a timed component model that is defined in such a generic way that both real-time system implementations and any kinds of analysis models for such applications can be expressed therein. Thereafter, we devise three different abstraction-refinement theories for the timed component model, exclusion, inclusion and bounding. Exclusion can be used to remove unconsidered corner cases, inclusion allows for the substitution of uncertainty with non-determinism, while bounding permits to replace non-determinism with determinism. The latter enables the creation of efficiently analyzable models that can be used to give temporal or functional guarantees on non-deterministic and non-monotone implementations. We use such abstractions to construct analysis models from concurrent real-time systems with shared resources and SPP scheduling. On these models we apply various analysis techniques, with the goal to increase analysis accuracy. Our first accuracy improvement is achieved by combining the rather coarse state-of-the-art period-and-jitter interference characterization with an explicit consideration of cyclic data dependencies. The interference-limiting effect of such cycles can be exploited even more with an "iterative buffer sizing". Next we replace period-and-jitter with execution intervals, resulting in an even higher accuracy. In our last approach we increase both accuracy and applicability by enabling the support of real-time systems with tasks consisting of multiple phases and operating at different rates. With a modification of this approach we further enable the analysis of applications with multiple shared resources. Finally, we also present the so-called HAPI simulator that is capable of simulating any kinds of concurrent real-time systems with shared resources