A new paradigm for the design of concurrent systems (original) (raw)
Formal modeling of synchronization methods for concurrent objects in Ada 95
ACM SIGAda Ada Letters, 1999
One important role for One important role for Ada programming is Ada programming is to aid engineering of concurrent and to aid engineering of concurrent and distributed software. In a concurrent and distributed software. In a concurrent and distributed environment, objects may distributed environment, objects may execute concurrently and need to be execute concurrently and need to be synchronized to serve a common goal. Three synchronized to serve a common goal. Three basic methods by which objects in a basic methods by which objects in a concurrent environment can be constructed concurrent environment can be constructed and synchronized have been identified [1]. and synchronized have been identified [1]. To formalize the semantics of these methods To formalize the semantics of these methods and to provide a formal model of their core and to provide a formal model of their core behavior, we provide some graphic models behavior, we provide some graphic models based on the based on the Petri net formalism. The Petri net formalism. The purpose of this formal modeling is to purpose of this formal modeling is to illustrate the possibility of automatic illustrate the possibility of automatic program analysis for object-oriented program analysis for object-oriented features in Ada-95. Models for the three features in Ada-95. Models for the three distributed-object synchronization methods distributed-object synchronization methods are discussed, and a potential deadlock are discussed, and a potential deadlock situation for one of the methods/models is situation for one of the methods/models is illustrated. We conclude with some illustrated. We conclude with some comparison of the three methods in terms of comparison of the three methods in terms of the model abstractions. the model abstractions.
Practical use of Ada 95's concurrency features
Concurrency, IEEE, 1998
The authors compare the new concurrency features in Ada 95 to the concurrency syntax in Ada 83. An example of resource contention in a flexible manufacturing environment illustrates Ada 95's improvements. Parallel Programming W hen Ada was introduced in 1983, it was one of very few languages with built-in support for concurrency. Unfortunately, because of several shortcomings, its concurrency features were never widely accepted for embedded real-time systems.
Proceedings of the 1999 ACM symposium on Applied computing - SAC '99, 1999
In this paper we describe a design pattern for distributed rendezvous. We propose a variant of rendezvous that supports multiple server threads, each one devoted to a di erent client. On the server side a ForwarderObject is in charge of forwarding calls to the corresponding servers threads. This design pattern encapsulates both the forwarding algorithm and the server interface, so both can be changed independently. Guidelines are given on how to implement the design pattern in Ada 95, taking advantage of language speci c features such as streams. The Multithreaded Rendezvous pattern has been successfully applied in the implementation of Transactional Drago, an Ada extension to program fault-tolerant distributed applications.
DCCA: a versatile paradigm for the description and development of concurrent communicating systems
Proceedings of the Twenty-Eighth Hawaii International Conference on System Sciences, 1995
exist that facilitate the formal specification and prototyping of distributed systems. In this paper, we describe certain features of the Dynamic Coordinated Concurrent Activities (DCCA) model. Any DCCA specification consists of a set of of largely independent processes, each of which, however, needs to coordinate with several of its Upeers" in the course of its execution. Several diverse realworld applications subscribe to such a paradigm -for example, a distributed control system for an automated factory, and a multiprocessor cache coherence system. DCCA is versatile enough to facilitate the specification of the protocols in both these systems on the same basis. Rapid prototyping and validation is also possible for DCCA models, as we describe in this paper. DCCA, and the attendant toolset could be of great use to a software engineer.
Multiprocessor Implementations of Tasking Facilities in ADA
IFAC Proceedings Volumes, 1983
This paper analyzes the efficiency problems related to the implementation of the ADA tasking facilities on monoprocessor and multiprocessor systems. Three different implementations of the basic communication mechanism in ADA-the rendezvous concept-are discussed and compared. The implementation approac h is the same in the three cases and it consists of translating the ADA parallel constructs into procedural calls to kerne l primi ti ves. The kernel primi ti ves corresponding to the most complex implementation are described.
A Model of Intertask Communication in Ada
Language-level concurrency is becoming more widely available in programming languages, placing parallel programming features in the hands of many programmers for the rst time. Unfortunately, the precise semantics of these features is frequently not well understood, principally because of the informal way in which such features are described. Typical of such informal description techniques is the manner in which technical English is used in the Ada Language Reference Manual to de ne the tasking facilities of Ada.
An Experimental Implementation of Action-Based Concurrency
SQRL Report 58, 2009
This paper reports on an experimental implementation of action-based concurrent objects. Concurrency is expressed by allowing objects to have actions with a guard and a body, in addition to methods and variables. Condition synchronization is expressed by method guards protecting entry into an object. An action of an object can execute any time when its guard is true, with the restriction that at most one action or methods can execute within an object, thus guaranteeing atomicity. In principle, all objects can execute in parallel. The appeal of this model is that it is conceptually simple for programmers and comes with a verification and refinement theory based on atomic actions that is a straightforward extension of that for sequential programs. The concurrency model is suited for tightly coupled shared-memory processors. The implementation makes use of a recent thread library, NPTL, that supports a large number of kernel threads. Each active object has its own thread that cycles through the actions, evaluates their guards, and executes an enabled action. Syntactic constraints restrict when guards need to be re-evaluated. We compare the efficiency of the generated code with that of C/Pthreads, Ada, and Java using classical concurrency examples.
Lecture Notes on Programming Concurrent Computer Systems
2005
Concurrent programming is the activity of constructing a program containing multiple processes that execute in parallel. The aim of the course is to introduce the basic concepts, principles and techniques in programming concurrent computing systems, and to provide practice in solving problems and skill in writing concurrent programs. The course will also provide methods for evaluating systems, algorithms and languages from a broad perspective. Zhiming Liu is a research fellow at UNU/IIST. His research interests include theory of computing systems, including sound methods for specification, verification and refinement of fault-tolerant, real-time and concurrent systems, and formal techniques for OO development. His teaching interests are Communication and Concurrency, Concurrent and Distributed Programming, Software Engineering, Formal specification and Design of Computer Systems.
Safe Non-blocking Synchronization in Ada2x
2018
The mutual-exclusion property of locks stands in the way to scalability of parallel programs on many-core architectures. Locks do not allow progress guarantees, because a task may fail inside a critical section and keep holding a lock that blocks other tasks from accessing shared data. With non-blocking synchronization, the drawbacks of locks are avoided by synchronizing access to shared data by atomic read-modify-write operations.
On developing and verifying design abstractions for reliable concurrent programming in Ada
2001
Ada 95 is an expressive concurrent programming language, which allows building large multi-tasking applications. Much of the complexity of these applications stems from the interactions between the tasks. Design abstractions (such as atomic actions, conversations etc.) have been proposed to deal with such complexity. This paper argues that Petri nets offer a promising, tool-supported, technique for checking the logical correctness of abstractions. The paper illustrates the effectiveness of this approach by showing the correctness of an Ada implementation of the atomic action protocol using a variety of Petri net tools.