Using true concurrency to model execution of parallel programs

Proceedings of the 2015 International Conference on Distributed Computing and Networking - ICDCN '15, 2015

Partial orders are used extensively for modeling and analyzing concurrent computations. In this paper, we define two properties of partially ordered sets: width-extensibility and interleaving-consistency, and show that a partial order can be a valid state based model: (1) of some synchronous concurrent computation iff it is width-extensible, and (2) of some asynchronous concurrent computation iff it is widthextensible and interleaving-consistent. We also show a duality between the event based and state based models of concurrent computations, and give algorithms to convert models between the two domains. When applied to the problem of checkpointing, our theory leads to a better understanding of some existing results and algorithms in the field. It also leads to efficient detection algorithms for predicates whose evaluation requires knowledge of states from all the processes in the system.

Acta Informatica, 1976

A language for parallel programming, with a primitive construct for synchronization and mutual exclusion, is presented. Hoare's deductive system for proving partial correctness of sequential programs is extended to include the parallelism described by the language. The proof method lends insight into how one should underst~,nd and present parallel programs. Examples are given using several of the standard problems in the literature. Methods for proving termination and the absence of deadlock are also given.

1993

In this paper we propose an abstract representation, called Synchronized Generalized Program Graph (SGPG), for concurrent programs. SGPG incorporates the data a!epenakncies, control flow, control dependencies, communication, and synchronization primitives of the concurrent program it represents. The features of SGPG and the process of its construction are outlined. Algorithms for generating the SGPG representation of an imperative concurrent programs are discussed in detail. The producer consumer problem is used as an illustrative example. SGPG can be used for the study and analysis of concurrent programs, research involving the implementation, testing, , meaasurement of cognitive complexity, and for proving correctness of concurrent programs.

1979

A simple model of concurrent computations is presented in which disjoint instructions /processes/ of program are executed concurrently by processors /in a sufficiently large number/ under a shared memory environment. The semantics of such a program specifies the tree of configuration sequences which are acceptable as possible computations of the program. We do not agree with the existing literature /e.g. [2]/ that every sharing one processor among processes can be conceived as a concurrency. We claim that the other meaning of concurrency can be defined as well. The difference between these two meanings turns out to be essential. We do not assume that each configuration is obtained from its predecessor in the computation by exactly one processor performing an atomic step /assignment or test/ in a process. On the contrary, we assume that a processor cannot be delayed during his activities. The length of a step is indefinite, it must be finite only. This reflects various speeds of processors. Hence, for the configuration in which several processors are able to start the execution of their subsequent steps, a maximal number of atomic steps will be started, the choice being nondeterministic. We discuss semantical phenomena of concurrent computations. It is argued that they can be expressed in the language of an algorithmic logic. The problem of complete axiomatization of the latter remains open. The comparison with another model of concurrency — Petri nets — is given and, we hope, it is interesting. For, our approach offers a structured /algebraic/ restriction of the language of nets and new variants of semantics. From the results obtained in the theory of vector addition systems we learn an important property of concurrent computations — there is no faithful one processor simulation of them.

Theoretical Computer Science, 1990

A transformation of sequential specifications into concurrent specifications is defined. The sequential specification is in the form of a regular expression extended with a declaration of the actions that are independent and have the potential for concurrent execution. The concurrent specification is in the form of a product of regular expressions. It is proved that a concurrent specification resulting from the application of the transformation to a sequential specification modified by inserting special actions, called synchronization guards, is behaviorally equivalent to the original specification. The programming language representation of a sequential specification is exemplified in a Pascal-like language, Banach.

Pact, 1997

The user has requested enhancement of the downloaded file. All in-text references underlined in blue are added to the original document and are linked to publications on ResearchGate, letting you access and read them immediately.

Theoretical Computer Science, 2010

Concurrent data structures are usually designed to satisfy correctness conditions such as sequential consistency and linearizability. In this paper, we consider the following fundamental question: what guarantees are provided by these conditions for client programs? We formally show that these conditions can be characterized in terms of observational refinement. Our study also provides a new understanding of sequential consistency and linearizability in terms of abstraction of dependency between computation steps of client programs. We would like to thank anonymous referees, Viktor Vafeiadis and Matthew Parkinson for useful comments. This work was supported by EPSRC.

Computing Research Repository - CORR, 2008

The semantics of assignment and mutual exclusion in concurrent and multi-core/multi-processor systems is presented with attention to low level architectural features in an attempt to make the presentation realistic. Recursive functions on event sequences are used to define state dependent functions and variables in ordinary (non-formal-method) algebra.

2004

We introduce a new specification formalism which we call hiddenCCS; hidden algebra is used to specify local goals as objects, and CCS is used to describe global goal of the synchronizing concurrent objects. We extend the object specification with synchronization elements associated with methods of different objects, and we use a CCS coordinating module to describe the interaction patterns of methods invocations. Some results refer to strong bisimulation over the hiddenCCS configurations. We investigate how the existing tools BOBJ, CWB, and Maude can be integrated to describe and verify useful properties of the synchronizing concurrent objects. The hiddenCCS specifications can be described in the rewriting logic using Maude. Finally we present the first steps towards temporal specifications and verification for hiddenCCS. the system properties from those of its objects and model checking tools. The symbiosis of object-oriented algebraic specification and interaction process algebra is given by a simple formal glue provided by some synchronization elements added to hidden algebra and appropriate semantic rules. HiddenCCS extends object-oriented hidden algebra with a CCS coordinating module able to describe the interaction patterns of method invocations. From an object-oriented point of view, we preserve the properties and the expressive power of hidden algebra specification and its hidden logic. From a process algebra point of view, we describe the possible patterns of interaction between objects and preserve the expressive power of CCS and its Hennessy-Milner logic.

International Journal of Computer Applications, 2013

Concurrent systems are very complex and error-prone because these systems are associated with significant issues, such as deadlock, starvation, communication, non-deterministic behavior and synchronization. Using formal methods, which are based on mathematical notions and theories, can help to increase confidence in these systems. Thus in recent years, most efforts have focused to specify, verify and develop concurrent systems formally. However, with specifications that have been done up to this time, several important aspects of concurrent systems, such as dynamic process creation, scheduling, starvation and infinite execution have not been specified formally yet. On the other hand, some specified aspects, such as deadlock, synchronization and communication have not been described as completely and accurately and/or have been specified using a combination of several different methods and formalisms so that the integration of existing specifications needs too much effort. It can be said unequivocally that until now there is no specification framework, based on a single formalism, for concurrent systems in which all important aspects of these systems are considered. Thus, our previous work tried to present an integrated formal specification framework of all the extracted aspects based on just one formal notation, i.e., the Z language. In this paper, the details of the mentioned formal framework are first presented. Then, this framework is evaluated from two viewpoints: comprehensiveness of the framework itself and appropriateness of Z to write an integrated formal specification of concurrent systems.