Programs with ironclad timing guarantees

Software Technologies for Future …, 2003

… -Alpes, http://hal. inria. fr/inria …, 2009

2004

This chapter describes the design of Hume: a domain-specific language targeting real-time embedded systems. Hume provides a number of high level features including higher-order functions, polymorphic types, arbitrary but sized user-defined data structures, asynchronous processes, lightweight exception handling, automatic memory management and domain-specific meta-programming features, whilst seeking to guarantee strong space/time behaviour and maintaining overall determinacy.

Workshop Programme, 2009

As real-time software is increasing in size and complexity, the need for advanced modeling and analysis capabilities early in the software development process is getting more and more urgent. One particular concern is the lack of sufficient methods and tools to effectively reason about the timing of software in such a way that software systems can be constructed hierarchically from components while still guaranteeing the timing properties [1]. In this talk, we will discuss deficiencies in current real-time embedded hardware and software ...

Control Engineering Practice, 1996

To ensure temporally predictable execution behaviour of an embedded hard realtime computer control system, layer-by-layer predictability of the system must be provided. Based on a simple structured programming language, a programming environment for hard real-time applications is under construction designed to function temporally predictably, and to support an experimental hardware platform as well as a corresponding operating system. A compiler with an integrated analyser for execution-time analysis of tasks is used to determine usable, realistic and not too pessimistic run-time estimates.

In general-purpose software applications, computation time is just a quality factor: faster is better. In cyber-physical systems (CPS), however, computation time is a correctness factor: missed deadlines for hard real-time applications, such as avionics and automobiles, can result in devastating, life-threatening consequences. Although many modern modeling languages for CPS include the notion of time, implementation languages such as C lack any temporal semantics. Consequently, models and programs for CPS are neither portable nor guaranteed to execute correctly on the real system; timing is merely a side effect of the realization of a software system on a specific hardware platform. In this position paper, we present the research initiative for a precision timed (PRET) infrastructure, consisting of languages, compilers, and microarchitectures, where timing is a correctness factor. In particular, the timing semantics in models and programs must be preserved during compilation to ensure that the behavior of real systems complies with models. We also outline new research and design challenges present in such an infrastructure.

2014 IEEE 20th International Conference on Embedded and Real-Time Computing Systems and Applications, 2014

In this paper we introduce exact and non-exact real-time waits in the reactive Globally Asynchronous Locally Synchronous (GALS) programming languages and synchronous languages as their subset. The language constructs that allow use of real-time waits are illustrated on the SystemJ GALS language. They allow system designers to explicitly use, at the specification level, not only logical time but also real-time in order to control program execution. We transform the real-time constructs into a logical model of time, and statically bound the amount of delay introduced by these constructs. In addition, the introduced concepts utilize execution platforms that allow finding best and worst reaction time of a GALS or synchronous program.

Real-time Systems - RTS, 2000

A method for extending programming languages with timing constructs is proposed. It enables the specification of timing constraints in programs. The approach is not language specific and the extension can be included in many existing programming languages. With the extension it is possible to write real-time program components that can be proven correct independently of the properties of the machine that is used for their execution. It therefore provides a similar abstraction from the execution platform as is normal in non-real-time programming. The presented approach distinguishes two phases in system construction: (1) a platform-independent programming phase that includes the expression of timing requirements, and (2) an implementation phase where all platform dependencies are addressed. The latter only differs from a normal compilation in the sense that a feasible schedule must be found to execute the program.

Functional Programming Languages and Computer Architecture, 1987

We present an applicative language, SIGNAL, designed to program real-time systems. The language is based on a synchronous notion of time. We assume the execution of operations to have a zero logical time duration ; then, the sequence of communication events determines entirely a temporal reference. The ordering of the runable operations is limited only by the dependencies between the calculi : this is the point of view of data flow languages. SIGNAL is a data flow language (where the potential parallelism is implicit), which permits a structural description of interconnected processes. SIGNAL handles possibly infinite sequences of values (called signals) characterized oy an implicit clock which specifies the relative instants (with respect to other signals) at which these values are available. Specific operators, such as delay, undersampling, deterministic merge, are designed to express temporal relations between different signals : in this way, a SIGNAL program expresses both functional and temporal relationships between all the involved signals. The language is semantically sound, and its declarative style allows to derive, by a simple projection on the commutative field Z/3Z, a complete static calculus of the timing of any SIGNAL process, called its clock calculus. Hence, the language SIGNAL is also a formal system to reason about timing and concurrency. The clock calculus is completed together with the dependency analysis of a given program. This leads to a conditional dependence graph in which the edges may be labelled by the involved clocks. From this graph, we generate code for a sequential machine, but it appears to be the suitable level to study the implementation on a multiprocessor architecture.

1996

In this paper we propose a method for extending programming languages that enables the specification of timing properties of systems. The way time is treated is not language specific and the extension can therefore be included in many existing programming languages. The presented method includes a view on the system development process. An essential feature is that it enables the construction of (hard) real-time programs that may be proven correct independently of the properties of the machines that are used for their execution. It therefore provides a similar abstraction from the execution platform as is normal for non-real-time languages. The aim of this paper is to illustrate the method and demonstrate its applicability to actual real-time problems. To this end we define a simple programming language that includes the timing extension. We present a formal semantics for a characteristic part of the language constructs and apply formal methods to prove the correctness of a small ex...