SYMPOSIUM MINISYMPOSIA

ABSTRACT

Modern computational systems very often include multiple modules cooperating with each other. Such systems typically require sophisticated concurrent software to allow for proper synchronization of cooperating modules. There are extensive discussions in the literature on how to create and verify concurrent software. Generally, the synchronization of concurrent modules is a nontrivial issue and complete specification requires rather specialized knowledge. A software engineer might need some tools in order to develop such software correctly and efficiently. In this paper we use the graphical concurrency constraints to specify requirements for modules synchronization. The appropriate synchronization primitives are constructed automatically from these constraints.

The paper contains description of a temporal algebra for concurrency constraints, their graphical representation, correctness criteria, optimization and transformation into a programming language synchronization constructs.

Many concurrency constraints can be identified. In this paper we discuss three basic types of constraints: exclusion, precedence, and timed precedence. These constraints allow us to specify the synchronization of modules when the critical section problem is present or when the precedence of execution between modules needs to be imposed.

We describe a temporal algebra for these concurrency constraints. The algebra includes AND and OR operators. We use the approach based on graphical diagrams for explicit and visual specifications of modules synchronization. The AND operator (most often found in real life applications) is specified graphically in a natural way but there are some restrictions for graphical specification of the OR operator.

The constraint diagrams are analyzed for consistency and redundancy. The correctness criteria for a constraint diagram are discussed. The criteria for equivalence of constraint diagrams are established. This is a basis for constraint diagram optimization.

A method for generating programming language synchronization constructs from constraint diagrams is presented. The method is based on translation rules and allows the software engineer to define his/her own translation rules for different synchronization primitives. In the paper we present translation rules for generation of standard semaphore operations.

We tested our approach using two subsystems: a graphical concurrency constraints processor, and a multiprogramming computer simulator. In order to integrate operations of these subsystems we have to define the mapping between programming segments in the constraint diagram and in a multiprogramming computer simulator. Then the synchronization primitives are automatically inserted into appropriate places in programs loaded to the computer simulator. The simulator allowed us to trace both programs and program skeletons and test their synchronization.

Getting More Information

To obtain more information about the meeting send e-mail to: fscc98@pax.st.usm.edu.

Return to PAX
Return to USM

USM
inquire@delphi.st.usm.edu
Updated
http://pax.st.usm.edu