Abstract. We apply model checking of knowledge properties to the design of distributed controllers that enforce global constraints on concurrent systems. We calculate when processes can decide, autonomously, to take or block an action so that the global constraint will not be violated. When the separate processes cannot make this decision alone, it may be possible to temporarily coordinate several processes in order to achieve sufficient knowledge jointly and make combined decisions. Since the overhead induced by such coordinations is important, we strive to minimize their number, again using model checking. We show how this framework is applied to the design of controllers that guarantee a priority policy among transitions. 1

Composition of components by means of multi-party interactions allows specifying intended global properties in a very abstract manner useful in many application domains. Composition by multi-party interactions allows guaranteeing most safety properties “by construction”, but deadlock freedom must generally be checked for. In this paper, we propose an algorithm that — if necessary — constructs a memoryless orchestrator given by a set of priority rules which enforce deadlock freedom. In the context of distributed systems, such as webservices, the resulting prioritized system must later be executed in a distributed fashion. We present here a new algorithm that allows executing systems with (binary) interactions and priorities. We argue that this algorithm is efficient, where efficiency is measured by the mean/maximal number of communications needed between the enabledness and the execution of an action. We have implemented this algorithm and compared it to an implementation of an existing algorithm (α-core). Finally, we motivate the usage of this kind of specification for webservices and compare it to other works.

Abstract. Controlling concurrent systems to impose some global invariant is an undecidable problem. One can gain decidability at the expense of reducing concurrency. Even under this flexible design assumption, the synthesis problem remains highly intractable. One practical method for designing controllers is based on checking knowledge properties upon which the processes can make their decisions whether to allow or block transitions. A major deficiency of this synthesis method lies in calculating the knowledge based on the system that we want to control, and not on the resulted system. The original system has less knowledge, and as a result, we may introduce far more synchronization than needed. In this paper we show techniques to reduce this overhead. 1