Maximal Causality Analysis

Schneider, Klaus; Brandt, Jens; Schuele, Tobias; Tuerk, Thomas

doi:10.1109/acsd.2005.24

Cited by 29 publications

(21 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…signal status is unknown ⊥ signal is absent or inhibited signal is present or activated signal is inconsistent (e. g. runtime error) These conditions predetermine some values of the extension. For the remaining ones, we prefer values x ∈ D in order to accept as many programs as possible, and hence choose to use the maximal extension of g w. r. t. [23]. As an example, Figure 2, consider Boolean conjunction ∧ : B 2 → B.…”

Section: Embedding Clocks and Values In A Complete Latticementioning

confidence: 99%

“…Malik [21] was first to show that this problem in general is NP-hard [21] and used the embedding of Boolean algebra in ternary algebra as proposed by Bryant for the simulation of switch-level circuits [22]. More details about causality analysis for synchronous programs may be found in [21,12,14,23]. In the domain of polychronous programs, causal cycle detection using SMT solvers has been reported in [24,25].…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Constructive polychronous systems

Talpin¹,

Brandt²,

Gemünde³

et al. 2014

Science of Computer Programming

View full text Add to dashboard Cite

Abstract. The synchronous paradigm provides a logical abstraction of time for reactive system design which allows automatic synthesis of embedded programs that behave in a predictable, timely and reactive manner. According to the synchrony hypothesis, a synchronous model reacts to input events and generates outputs that are immediately made available. But even though synchrony greatly simplifies design of complex systems, it often leads to rejecting models when data dependencies within a reaction are ill-specified, leading to causal cycles. Constructivity is a key property to guarantee that the output during each reaction can be algorithmically determined. Polychrony deviates from perfect synchrony by using a partially ordered or relational model of time. It captures the behaviors of (implicitly) multi-clocked data-flow networks and can analyze and synthesize them to GALS systems or to Kahn process networks (KPNs). In this paper, we provide a unified constructive semantic framework, using structural operational semantics, which captures the behavior of both synchronous modules and multi-clocked polychronous processes. Along the way, we define the very first operational semantics of Signal.

show abstract

Section: Embedding Clocks and Values In A Complete Latticementioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Constructive polychronous systems

Talpin¹,

Brandt²,

Gemünde³

et al. 2014

Science of Computer Programming

View full text Add to dashboard Cite

show abstract

“…Instead it should be possible to evaluate those control-flow conditions from already known values. Checking this property statically is known as causality analysis [7,15,[23][24][25][26][27][28] in the context of synchronous programs.…”

Section: Logical Correctness and Causalitymentioning

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

“…algebraic loops) in Modelica programs can be resolved in the same way as done for synchronous programs: By means of a three-or four-valued logic one may perform a causality analysis at compile time that can assure that during runtime, all the cycles can be resolved [32,33]. To this end, we report about the experiences we made by extending our synchronous programming language Quartz [31] to describe hybrid systems [4,5].…”

Section: Introductionmentioning

confidence: 99%

Transferring Causality Analysis from Synchronous Programs to Hybrid Programs

Bauer

Schneider

2011

Linköping Electronic Conference Proceedings

View full text Add to dashboard Cite

Outputs of synchronous programs may suffer from cyclic dependencies since statements are allowed to read the current outputs' values to determine the actions that generate the current values of the outputs. For this reason, compilers have to perform a causality analysis that ensures that at any point of time, there is a unique and constructive way to determine the outputs. The discrete parts of hybrid systems may suffer from the same problem as observed in synchronous programs. As we recently extended our synchronous language Quartz to describe hybrid systems, we explain in this paper how the causality analysis as originally introduced for synchronous systems can also be used to handle cyclic dependencies in hybrid Modelica programs.

show abstract

Maximal Causality Analysis

Cited by 29 publications

References 24 publications

Constructive polychronous systems

Constructive polychronous systems

Clock refinement in imperative synchronous languages

Transferring Causality Analysis from Synchronous Programs to Hybrid Programs

Contact Info

Product

Resources

About