Coordination Language Research Articles

On the expressiveness and efficiency of guarded lists in Bach

Concurrency theory has received considerable attention, but mostly in the scope of synchronous process algebras such as CCS, CSP, and ACP. As another way of handling concurrency, data-based coordination languages aim to provide a clear separation between interaction and computation by synchronizing processes asynchronously by means of information being available or not on a shared space. Although these languages enjoy interesting properties, verifying program correctness remains challenging. In particular, model checking logic formulae is known to raise performance issues due to the state space explosion problem. In this paper, we propose a guarded list construct as a solution to address this problem. Beyond increasing performance, it also enriches the expressiveness of data-based coordination languages and allows for program transformations that further increase the speed of computations.

Deterministic Coordination across Multiple Timelines

We discuss a novel approach for constructing deterministic reactive systems that revolves around a temporal model that incorporates a multiplicity of timelines. This model is central to Lingua Franca ( LF ), a polyglot coordination language and compiler toolchain we are developing for the definition and composition of concurrent components called reactors, which are objects that react to and emit discrete events. Our temporal model differs from existing models like the logical execution time (LET) paradigm and synchronous languages in that it reflects that there are always at least two distinct timelines involved in a reactive system; a logical one and a physical one—and possibly multiple of each kind. This article explains how the relationship between events across timelines facilitates reasoning about consistency and availability across components in cyber-physical systems (CPSs).

Codesign of reactor-oriented hardware and software for cyber-physical systems

Modern cyber-physical systems often make use of heterogeneous systems-on-chip with reconfigurable logic to provide adequate computing power and flexible I/O. However, modeling, verifying, and implementing the computations spanning CPUs and reconfigurable logic is still challenging. The hardware and software components are often designed by different teams and at different levels of abstraction, making it hard to reason about the resulting computation. We propose to lift both hardware and software design to the same level of abstraction by using the Lingua Franca coordination language. Lingua Franca is based on a sparse synchronous model that allows modeling concurrency and timing while keeping a sequential model for the actual computation. We define hardware reactors as a subset of the reactor model of computation underlying Lingua Franca. We also present and evaluate reactor-chisel, a hardware runtime implementing the semantics of hardware reactors, and an extension to the Lingua Franca compiler enabling reactor-oriented hardware-software codesign.

High-performance Deterministic Concurrency Using Lingua Franca

Actor frameworks and similar reactive programming techniques are widely used for building concurrent systems. They promise to be efficient and scale well to a large number of cores or nodes in a distributed system. However, they also expose programmers to nondeterminism, which often makes implementations hard to understand, debug, and test. The recently proposed reactor model is a promising alternative that enables deterministic concurrency. In this article, we present an efficient, parallel implementation of reactors and demonstrate that the determinacy of reactors does not imply a loss in performance. To show this, we evaluate Lingua Franca (LF), a reactor-oriented coordination language. LF equips mainstream programming languages with a deterministic concurrency model that automatically takes advantage of opportunities to exploit parallelism. Our implementation of the Savina benchmark suite demonstrates that, in terms of execution time, the runtime performance of LF programs even exceeds popular and highly optimized actor frameworks. We compare against Akka and CAF, which LF outperforms by 1.86× and 1.42×, respectively.

Towards Building Verifiable CPS using Lingua Franca

Formal verification of cyber-physical systems (CPS) is challenging because it has to consider real-time and concurrency aspects that are often absent in ordinary software. Moreover, the software in CPS is often complex and low-level, making it hard to assure that a formal model of the system used for verification is a faithful representation of the actual implementation, which can undermine the value of a verification result. To address this problem, we propose a methodology for building verifiable CPS based on the principle that a formal model of the software can be derived automatically from its implementation. Our approach requires that the system implementation is specified in Lingua Franca (LF), a polyglot coordination language tailored for real-time, concurrent CPS, which we made amenable to the specification of safety properties via annotations in the code. The program structure and the deterministic semantics of LF enable automatic construction of formal axiomatic models directly from LF programs. The generated models are automatically checked using Bounded Model Checking (BMC) by the verification engine Uclid5 using the Z3 SMT solver. The proposed technique enables checking a well-defined fragment of Safety Metric Temporal Logic (Safety MTL) formulas. To ensure the completeness of BMC, we present a method to derive an upper bound on the completeness threshold of an axiomatic model based on the semantics of LF. We implement our approach in the LF V erifier and evaluate it using a benchmark suite with 22 programs sampled from real-life applications and benchmarks for Erlang, Lustre, actor-oriented languages, and RTOSes. The LF V erifier correctly checks 21 out of 22 programs automatically.

Automated replication of tuple spaces via static analysis

• Data replication may improve the efficiency of a distributed system. • Implementing replication manually requires a significant effort. • We propose an experimental technique for automated replication of tuple spaces. • We combine program transformation and static analysis, preserving strong consistency. • Transformed programs exhibit desirable properties (e.g. reduced non-local accesses). Coordination languages for tuple spaces can offer significant advantages in the specification and implementation of distributed systems, but often do require manual programming effort to ensure consistency. We propose an experimental technique for automated replication of tuple spaces in distributed systems. The system of interest is modelled as a concurrent Go program where different threads represent the behaviour of the separate components, each owning its own local tuple repository. We automatically transform the initial program by combining program transformation and static analysis, so that tuples are replicated depending on the components' read-write access patterns. In this way, we turn the initial system into a replicated one where the replication of tuples is automatically achieved, while avoiding unnecessary replication overhead. Custom static analyses may be plugged in easily in our prototype implementation. We see this as a first step towards developing a fully-fledged framework to support designers to quickly evaluate many classes of replication-based systems under different consistency levels.

From symbolic constraint automata to Promela

In this paper, we study a subclass of constraint automata with local variables. The fragment denotes an executable subset of constraint automata for which synchronization and data constraints are expressed in an imperative guarded command style, instead of a denotational style as in the coordination language Reo. To demonstrate the executability property, we provide a translation scheme from symbolic constraint automata to Promela, the language of the model checker Spin. As a proof of concept, we model in Reo a software defined network circuit, and use the Spin model checker to verify that our model satisfies some temporal properties.

Designing an ERP System by Adopting the Decision Tree Algorithm: A Case Study in the General Company of Oil Products Distribution

The study endeavored to design a proposed system model of ERP by adopting an algorithm. The study was applied in the Oil Products Distribution Company -Iraq. The problem of the study was manifested by many questions regarding the level of the viewpoints on the system of ERP and the support presented by the possible managers and users in the company, and the most influential motivations in adopting the system and the good features attained from using it. The case study system was adopted by making use of many sighting and on-field interviews, and depending on documents and records in gathering data and the necessary information, in addition to the checklist which included 35 responders from different levels of the company management officials. The analysis was carried out depending on the suitable statistical tools through using the statistical program of (pass) to know the motivations behind adopting the system of ERP and the results expected from using it. Designing the ERP system was the essential objective of the study and it was accomplished by (My SQL Database version 5.7 17 ) , the structural information language SQL, the software program language OHP 5.6 30, the language of designing the site profile HTML, and the coordination language CSS 4. The study has come up with a group of conclusions, some of them were linked to the analysis results of the preliminary realization of the motivations behind adopting the system of ERP and the good features attained from designing and operating it to managers and it is within the accepted level and on the positive direction, due to the absence of a unified central database that provides information to different parts of the company, information that can be used making decisions because gathering data is done a single basis. This paved the way to present a proposed model for the system with the existence of certain provisions among which the participation of all managers effectively in every step of applying the system of ERP, as well as the necessity of guiding specialized personals (analysts and programmers) so that they might supervise the managing of the system and activate its activation. The study recommended the information communication of its subject matters through several titles for future studies.

Preface for the special issue on tool papers of the 21st International Conference on Coordination Models and Languages, COORDINATION 2019

Preface for the special issue on tool papers of the 21st International Conference on Coordination Models and Languages, COORDINATION 2019

Anemone: A workbench for the Multi-Bach coordination language

Although many research efforts have been spent on the theory and implementation of data-based coordination languages, not much effort has been devoted to constructing programming environments to analyze and reason over programs written in these languages. This paper proposes a workbench for describing concurrent systems using a Linda-like language, for animating them and for reasoning over them using a reachability logic. • Programming environments are required to analyze and reason on coordination programs. • Animations help to understand the modeling of concrete systems. • Multi-Bach is a process algebra well-suited to describe concurrent systems.

Compositional workflow modeling with priority constraints

Priority is an important concept in Business Process Management (BPM), useful in the context of workflow patterns such as, e.g., cancelable and compensable tasks within business transactions. Unfortunately, the presence of priority in workflows makes them difficult to be analyzed formally by automated validation and verification tools. In the past, we demonstrated that the Reo coordination language can be successfully used for modeling, automatic validation and model checking of process models. In this paper, we propose a constraint-based approach to formalize priority in Reo. We introduce special channels to initiate, propagate, and block priority flows, define their semantics as constraints, and model priority propagation as a Constraint Satisfaction Problem (CSP). The semantic extension we propose in this paper enables workflow analysis in presence of priority constraints.

Hubs for VirtuosoNext: Online verification of real-time coordinators

• Modelling of the coordination mechanism between tasks in a RTOS (VirtuosoNext); • Build new coordinators by plugging existing ones; • Specify timed scenarios to interact with the coordinator; • Verify timed behavioural properties of coordinators using UPPAAL; • Implementation: open source and running as a service online. VirtuosoNext TM is a distributed real-time operating system (RTOS) featuring a generic programming model dubbed Interacting Entities . This paper focuses on these interactions, implemented as so-called Hubs . Hubs act as synchronisation and communication mechanisms between the application tasks and implement the services provided by the kernel. While the kernel provides the most basic services, each carefully designed, tested and optimised, tasks are limited to this handful of basic hubs, leaving the development of more complex mechanisms up to application specific implementations. This work presents a toolset that supports the building of new services compositionally, using notions borrowed from the Reo coordination language, on which the developer can delegate coordination-related duties. This toolset uses a formal compositional semantics for hubs that captures dataflow and time, formalising the behaviour of existing hubs, and allowing the definition of new ones. Furthermore, it enables the analysis and verification of hubs under our automata interpretation, including time-sensitive behaviour via the Uppaal model checker, usable on http://arcatools.org/hubs . We illustrate the proposed tools and methods by verifying key properties on different interaction scenarios between tasks and a composed hub.

On the expressiveness of multiplicities in data-based coordination languages

Coordination languages and models have proved to be well suited to program the interaction of a wide variety of data-intensive distributed systems. Building upon previous work by the authors, this paper aims at exploring how the addition of multiplicity information to tuples increases the expressiveness of Linda-like languages. It proposes a set of languages integrating the multiplicity in different perspectives. The expressiveness hierarchy between these languages is then studied through the notion of modular embedding proposed by De Boer and Palamidessi. Complementing these theoretical study, considerations on the implementation are drawn, which attest that the more expressive a language is, the more expensive is its implementation.

Process calculi as a tool for studying coordination, contracts and session types

We recall techniques, mainly based on the theory of process calculi, that we used to prove results in twenty years of research, spanning across the old and the new millennium, on the expressiveness of coordination languages and on behavioural contracts for Service-Oriented Computing. Then, we show how such techniques recently contributed to the clarification of aspects that were unclear about session types, in particular, asynchronous session subtyping that was considered decidable since 2009, while it was proved to be undecidable in 2017.

Preface to the Special Issue on Foundations of Coordination Languages and Self-Adaptive Systems (Foclasa 2018)

Preface to the Special Issue on Foundations of Coordination Languages and Self-Adaptive Systems (Foclasa 2018)

A DSL for WSN software components coordination

Wireless Sensor Networks (WSNs) have become an integral part of urban scenarios. They are usually composed of a large number of devices. Developing systems for such networks is a hard task and often involves validation on simulation environments before deployment on real settings. Component-based development allows systems to be built from reusable, existing components that share a common interface. This paper proposes a domain specific language (DSL) for coordination of WSN software components. The language provides high-level composition primitives to promote a flexible coordination execution flow and interaction between them. We present the language specification as well as a case study of an in-network WSN data storage coordination. The current specification of the language generates code for the NS2 simulation environment. The case study shows that the language implements a flexible development model. Moreover, we analyze the code reusability promoted by the language and show that it reduces the programming effort in a component-based development framework.

Preface to the special issue on Coordination Models and Languages (Coordination 2017)

Preface to the special issue on Coordination Models and Languages (Coordination 2017)

A formal framework capturing real-time and stochastic behavior in connectors

• We propose an extension for Reo, including both new primitive channels and semantics as stochastic timed automata. • We adapt PTCTL to describe the properties of stochastic and timed connectors. • We develop a Python framework to model and verify stochastic and timed connectors. Modern distributed systems are often coupled with flexible architectures, composed of heterogeneous components, and deployed on different execution nodes. In such architectures, connectors (or middlewares) are widely used to orchestrate the separated components and make them functioning. Apparently, correctness of such systems highly depends on the behavior of connectors. Reo is a channel-based coordination language where complex connectors are compositionally constructed from simpler ones. In this paper, we propose a stochastic and real-time extension of Reo, including a set of new primitive channels and an expressive semantics as Stochastic Timed Automata for Reo ( STA r ). Furthermore, a logical formalization of STA r for property analysis has been proposed and the transformation from STA r to PRISM and JANI has been implemented. Several case studies are presented to demonstrate how STA r and its corresponding logic can be used to capture coordination scenarios in the real world.

Flow Constraint Language for Coordination by Exogenous Connectors

Construction of Cyber-Physical Systems (CPS) by reusing or composing existing components (sub-systems) is the emerging need in software based system development. For software development, a number of paradigms exists to deal with the reusability at different levels. Component-based development (CBD) represents a paradigm shift in software development for its emphasis on development for/with reuse. Software composition mechanisms are the essence of this paradigm. In general, a software system in CBD is comprised of two kinds of elements: computation and communication. Defining/creating these elements in a generic way and for system construction allowing these elements to be customised in specific to the system needs can increase the level of reusability. In this paper, for a development paradigm (referred to as EX-MAN in CBD) for CPS construction, we focus on software elements dealing with the communications elements (referred to as connectors) among the computational elements. We define constraints (written in our proposed flow constraint language (FCL)) as a property for coordination by the exogenous connectors to customise the behaviour of connectors for system construction. In this paper, the semantics of FCL constraints for a sample exogenous connector is described for system construction/execution. In order to verify the operational semantics of FCL constraints of this exogenous connector, we use Coloured Petri Nets (in CPN tools) to model and simulate the connectors with constraints. Exogenous connectors are implemented in a tool exogenous composition framework (ECF) for system construction.

Reasoning about connectors using Coq and Z3

Reo is a channel-based exogenous coordination language in which complex coordinators, called connectors, are compositionally built out of simpler ones. In this paper, we present an approach to model and reason about connectors using Coq and Z3. Both models reflect the original structure of connectors as closely as possible. In our framework, both basic connectors (channels) and composition operations are modeled as axioms. Then complex connectors are modeled as the combination of logical predicates which correspond to simpler connectors. With such definitions provided, connector properties, as well as equivalence and refinement relations between different connectors, can be formalized as goals in Coq and proved using pre-defined tactics, if satisfied by connectors. When failing to prove whether a property is satisfiable or not with Coq, we use Z3, an SMT solver, to search for possible bounded counter examples automatically.