Correct-by-Construction Asynchronous Implementation of Modular Synchronous Specifications

Potop-Butucaru, Dumitru; Caillaud, Benoît

doi:10.1109/acsd.2005.10

Cited by 33 publications

(37 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In some sense, their solutions have some similarities with the approach in [34]. For example, the work in [26] uses a concurrent transition system formalism to define both synchronous and asynchronous compositions of synchronous systems linked by FIFO channels, and studies conditions under which a synchronous system can thus be correctly simulated as an asynchronous GALS system. Likewise, the work in [11] uses FIFO channels to connect several synchronous hardware circuits into a GALS system that correctly simulates the lockstep synchronous behavior of the bigger circuit obtained by composing the subcircuits.…”

Section: Related Workmentioning

confidence: 99%

“…Their model of this system encapsulates synchronous subdomains as automata transition functions within different processes of the LOTOS process calculus. Within the GALS framework, several research efforts, including [11,26], have studied the problem of correctly simulating a synchronous model as an asynchronous GALS model. In some sense, their solutions have some similarities with the approach in [34].…”

Section: Related Workmentioning

confidence: 99%

See 1 more Smart Citation

Formalization and Correctness of the PALS Architectural Pattern for Distributed Real-Time Systems

Meseguer

Ölveczky

2010

Formal Methods and Software Engineering

View full text Add to dashboard Cite

Abstract. Many Distributed Real-Time Systems (DRTS), such as integrated modular avionics systems and distributed control systems in motor vehicles, are made up of a collection of components communicating asynchronously among themselves and with their environment that must change their state and respond to environment inputs within hard real-time bounds. Such systems are often safety-critical and need to be certified; but their certification is currently very hard due to their distributed nature. The Physically Asynchronous Logically Synchronous (PALS) architectural pattern can greatly reduce the design and verification complexities of achieving virtual synchrony in a DTRS. This work presents a formal specification of PALS as a formal model transformation that maps a synchronous design, together with a set of performance bounds of the underlying infrastructure, to a formal DRTS specification that is semantically equivalent to the synchronous design. This semantic equivalence is proved, showing that the formal verification of temporal logic properties of the DRTS can be reduced to their verification on the much simpler synchronous design. An avionics system case study is used to illustrate the usefulness of PALS for formal verification purposes.

show abstract

Section: Related Workmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 99%

Formalization and Correctness of the PALS Architectural Pattern for Distributed Real-Time Systems

Meseguer

Ölveczky

2010

Formal Methods and Software Engineering

View full text Add to dashboard Cite

show abstract

“…Hence, Signal solves most of the problems mentioned in introduction-however, the price one has to pay for this powerful model is that input/output determinism is generally lost. It can be guaranteed if the program is shown to be endochronous [51] or weakly endochronous [52]. While endochrony proves determinism by the existence of a base clock (usually called master trigger in this context), weak endochrony also reveals some internal nondeterminism that can safely be exploited for a more efficient execution.…”

Section: Lustre and Signalmentioning

confidence: 99%

Clock refinement in imperative synchronous languages

2013

View full text Add to dashboard Cite

The synchronous model of computation divides the program execution into a sequence of logical steps. On the one hand, this view simplifies many analyses and synthesis procedures, but on the other hand, it imposes restrictions on the modeling and optimization of systems. In this article, we introduce refined clocks in imperative synchronous languages to overcome these restrictions while still preserving important properties of the basic model. We first present the idea in detail and motivate various design decisions with respect to the language extension. Then, we sketch all the adaptations needed in the design flow to support refined clocks. Reviewhave been proposed for the development of safety-critical embedded systems. They are based on a convenient programming model, which allows one to generate deterministic single-threaded code from multi-threaded synchronous programs. Thus, synchronous programs can directly be executed on simple micro-controllers without having the need to use complex operating systems. In addition, synchronous programs can straightforwardly be translated to hardware circuits [4][5][6], which makes synchronous languages attractive for the use in hardware-software co-design. Furthermore, the concise formal semantics of synchronous languages is the basis for formal verification of the correctness of the programs as well as of the used compilers [7][8][9][10]. Finally, since macro steps consist of only finitely many micro steps whose number is known at compile-time, one can determine tight bounds on the reaction time by a simplified worst-case execution time analysis [11][12][13][14].All these advantages are due to the underlying synchronous model of computation [1], which divides the execution of programs into micro and macro steps, where variables change synchronously only between macro steps and remain constant during micro steps. The partitioning into micro and macro steps is explicitly *Correspondence: gemuende@cs.uni-kl.de Department of Computer Science, University of Kaiserslautern, Kaiserslautern, Germany given by the programmer, and the micro steps are executed in a causal ordering so that there are no read-afterwrite conflicts [7,15]. As a consequence, all threads of a program run in lockstep: they execute the micro steps of their current macro steps in the common global variable environment, and therefore automatically synchronize at the end of the macro step.Obviously, the synchronous model of computation enforces deterministic concurrency, which has many advantages in system design, e.g., to avoid Heisenbugs [16] and to allow compile-time analyses, e.g., on WCET. At the same time, however, it imposes tight restrictions on modeling possibilities, since there is no means to express the independence of threads in certain program locations. This phenomenon-where synchronous lockstep execution of threads is enforced even though it is not necessary-is often referred to as over-synchronization. Over-synchronization occurs quite frequently, since the input signals of a system us...

show abstract

“…The Globally Asynchronous Locally Synchronous paradigm [Cha84] has been proposed to employ synchronous modules in an asynchronous environment. Several approaches were suggested to map synchronous systems into this framework, for instance, [Ben01,PBC07]. Related approaches include Communicating Reactive Processes [BRS93], in which synchronous modules communicate via CSP rendezvous and Multiclock Esterel [BS01], which substitutes local clocks for a global one.…”

Section: Relating Synchrony and Asynchronymentioning

confidence: 99%

On the Compositionality of Round Abstraction

Ghica

Menaa

2010

CONCUR 2010 - Concurrency Theory

View full text Add to dashboard Cite

Game Semantics is an approach to denotational semantics that has been successful in providing accurate, fully abstract models for various programming languages. It has thereafter been applied, amongst other things, to model checking, access control analysis, information flow analysis, and recently, hardware synthesis.While the roots of modern Game Semantics are sequential, several game models of asynchronous concurrency have since been devised. However, synchronous concurrency has not been considered hitherto.This thesis studies synchronous concurrency in game-like models. The central idea is to investigate deriving such synchronous models from their asynchronous counterparts using round abstraction-a technique that allows aggregating a sequence of computational steps to form a larger, more abstract macro-step.We define round abstraction within a trace-semantic setting that generalises game semantic models. We note that, in general, round abstraction is not compositional. We then identify sufficient conditions to guarantee correct composition, thereby proposing a framework for round abstraction that is sound when applied to synchronous and asynchronous behaviours.

show abstract

Correct-by-Construction Asynchronous Implementation of Modular Synchronous Specifications

Cited by 33 publications

References 16 publications

Formalization and Correctness of the PALS Architectural Pattern for Distributed Real-Time Systems

Formalization and Correctness of the PALS Architectural Pattern for Distributed Real-Time Systems

Clock refinement in imperative synchronous languages

On the Compositionality of Round Abstraction

Contact Info

Product

Resources

About