We then identify a sufficiently large class of automata for which using our new product instead of the existing one is semantics-preserving. In this paper, we provide a solution by defining a new, local product operator on those automata that avoids these problems. However, this approach has two problems: state space explosion at compile-time and oversequentialization at run-time. This approach ensures that implementations of those automata at run-time reach a consensus about their global behavior in every step.
#XPRESSIVE THREADS CODE#
As part of the compilation process, our tool computes the product of a number of automata, each of which models a constituent of the protocol to generate code for. However, a crucial step toward adoption of coordination languages for multicore programming is the development of compiler technology: programmers must have tools to automatically generate efficient code for high-level protocol specifications.In ongoing work, we are developing compilers for a coordination language, Reo, based on that language's automata semantics. To exemplify our work, in a case study, we show and explain how a generated connector implementation can be executed.Ī promising new application domain for coordination languages is expressing interaction protocols among threads/processes in multicore programs: coordination languages typically provide high-level constructs and abstractions that more easily compose into correct (with respect to a programmer's intentions) protocol specifications than do low-level synchronization constructs (e.g., locks, semaphores, etc.) provided by conventional languages. Our theory relies on the definition of a new product operator on constraint automata (Reo’s formal semantics), which we use to formally justify distributions of disjoint parts of a coordination scheme over different machines according to several possible motivations (e.g., performance, QoS constraints, privacy, resource availability, and network topology). Such implementations have three performance advantages: faster compilation at build time (compared to a purely centralized approach), reduced latency at run time (compared to a purely distributed approach), and improved parallelism at run time (compared to a purely centralized approach). In this paper, we describe a theoretical justification and a practical proof-of-concept tool for automatically generating partially distributed, partially centralized implementations of Reo connectors. Coordination languages, such as Reo, have emerged for the specification and implementation of interaction protocols among concurrent entities, manifested as connectors.
0 kommentar(er)
