New results on the analysis of concurrent systems with an indefinite number of processes

Abstract

In this paper we extend some of the results presented by German and Sistla in [4]. Their framework for concurrent systems, at a certain level of abstraction, is suitable for modeling a number of resource-oriented problems in concurrency in which there is a unique control process (called the synchronizer) and an arbitrary number of identical user processes [13, 2]. Communication between processes is via synchronous actions in the style of Milner's Calculus of Communicating Systems [12]. In the first part of the paper, we consider certain “specialized” execution semantics instead of the “general” execution semantics considered in [4]. These semantics are aimed at “restricting” communications between processes that would otherwise be possible. Without such restrictions, it is not possible to model problems in which there is a need to distinguish processes based on either the current states of the user processes, or their indices, etc. In contrast to the work done in [4], we show that the reachability problem for each of the specialized execution semantics we consider is undecidable. As a consequence, both deadlock detection and the Model Checking problem for the synchronizer when reasoning with logics such as Linear temporal logic LTL [4], Linear Temporal Logic without the nexttime operator LTL/X [8], and Restricted Temporal Logic RTL [14] are also undecidable.

In the second part of the paper we consider the problem of detecting whether there are infinitely many model sizes k such that some execution of k user processes and the synchronizer deadlocks, assuming unrestricted execution semantics, and we show that this problem is decidable. This result extends a known result, namely, that detecting a single instance of deadlock in such a model, is decidable [4]. We say that models exhibit “strong stability” if and only if there are a “bounded” number of model sizes for which a potential deadlock exists, and thus we show that that detecting strong stability is decidable. We also consider a framework in which we allow an arbitrary number of synchronizers to participate in an execution, and show that strong stability is decidable in this case as well.