Coordination is a relatively recent field, considerably inspired by concurrency theory. Coordination languages and models are based on the philosophy that an application or a system should be divided into the parts that perform computations, typically components or services, and the parts that coordinate the results and resources required to perform the computations. The coordination aspect focuses on the latter, describing how the components or services are connected. We study a specific class of coordination models, namely synchronous, exogenous, and composable models, and we exploit implementation techniques for such models in distributed environments. Our work concentrates on the Reo coordination model as the main representative of this class of coordination models.
Current engines that execute Reo allow the coordination layer to run only in a single thread of execution, although the components can execute in parallel or on a distributed platform. Furthermore, due to the synchrony aspect these engines only support small systems, and do not scale. To address these limitations, our approach to implement Reo-like models makes a tradeoff between pre-compiling the possible behaviour and calculating it at runtime.
Our work contributes to the field of coordination, in particular to Reo, by improving existing approaches to execute synchronisation models in three major ways. First, this work supports decoupled execution and lightweight reconfiguration. We introduce a distributed protocol that allows actors to reach consensus about data exchange, and performs the actual communication of data. We developed a prototype Dreams engine to test this protocol, using an actor library for the Scala language. Reconfiguration of a small part of the system is independent of the execution or behaviour of unrelated parts of the same system. Second, Dreams outperforms previous Reo engines by using constraint satisfaction techniques. In each round of the execution of the Dreams framework, descriptions of the behaviour of all building blocks are combined and a coordination pattern for the current round is chosen. This choice is made using constraint satisfaction techniques, requiring less time than previous approaches that collect all patterns before selecting one. Third, our work improves scalability by identifying synchronous regions. We statically discover regions of the coordination layer that can execute independently, thus achieving a truly decoupled execution of connectors. Consequently, the constraint problem representing the behaviour at each round is smaller and more easily solved.