Efficient embedded software design with synchronous models

Abstract

Model-based design is an important approach for embedded software. The method starts from a mathematical representation of the design problem and derives the software implementation from this representation. The model that has had most success especially for control dominated application is synchronous reactive. While this model simplifies the way of dealing with concurrency by decoupling functional and timing aspects, when implemented, it may be inefficient since the synchronous assumption implies constraints that are stronger than needed. We present in this paper a method for improving the efficiency of the software design process, by relaxing computation constraints, while preserving the synchronous computation semantics, with the introduction of a particular inter-task communication mechanism. We show how this mechanism can be implemented on single processor, multi processor and distributed implementation platforms.

Optimizing the Implementation of Communication in Synchronous Reactive Models

“…An upper bound for the buffer size based on the concept of temporal concurrency control is also defined in [1] for the case of SR semantics preserving communication. The bound makes use of a different definition of the validity lifetime, based on the SR semantics.…”

“…Overall, the space requirements are reduced. In [1] a similar approach is proposed for SR semantics-preserving implementations. However, the resulting buffer size is not optimal and still subject to improvement.…”

“…In any semantics preserving implementation of a link b i → b j without delay, the reader block must have a priority lower than the writer (or its scheduling must be constrained by a precedence order) [1]. In the low to high priority communication [8], it must be dw ≤ Tw for the writer task, to guarantee that the latency is not higher than a one unit delay.…”

“…In the following, we define our improvements with respect to the sizing methods in [8] and [1] based on the number of reader instances, and on temporal concurrency control, respectively. We provide extensions to the theory and the code that implements the read and write operations in the general case of multiple-unit delays and deadlines (or better, response times) larger than periods.…”

“…A better bound is obtained in [1]. For each reader, the number of required buffers is upper bound by the minimum between the number of times the writer is activated in the data lifetime and the number of reader instances that may be active in the lifetime.…”