1. Introduction
Synchronous programming languages [1] reconcile concurrency with determinate behavior with a semantics that abstracts from execution time. The execution of a program is divided into (logical) ticks, or instants/reactions. In each tick, (sensor) inputs are read from an environment and (actu-ator) outputs are written to the environment. The synchrony hypothesis states that for each tick, outputs are synchronous with inputs. This is traditionally reflected in the requirement that shared variable values are unique throughout a tick. This is a natural requirement for hardware design, where each wire must assume a unique value for each clock tick. However, this seems unduly restrictive from the perspective of imperative programming, where it is quite natural to read a variable and subsequently write a different value to it. This has recently motivated the sequentially constructive model of computation (SC MoC), which allows shared variables values to change within a reaction as long as the result is still determinate and does not depend on run-time scheduling choices [2]. More specifically, a run is considered SC-admissible if it adheres to certain restrictions concerning the access to shared variables, in particular that writes occur before reads; a program is considered SC if it allows SC-admissible runs for all possible input sequences, and if all such runs lead to the same result.
The class of programs considered valid under the sequentially constructive circuit (scc) semantics, proposed here, in relation to other program classes. “acyclic SC” refers to programs that can be scheduled statically. Most esterel compilers handle acyclic BC (berry constructive) [3]. Esterel v5 handles all of BC [4]. The scest2SCL compiler handles acyclic SC [5]. Our work extends compilation to SCC, that is SC (sequentially constructive) without “speculation.”