A new paradigm for the design of concurrent systems (original) (raw)
Related papers
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.
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.
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.
The ClassiC programming language and design of synchronous concurrent object oriented languages
Journal of Systems Architecture, 1998
Many real-time systems make use of concurrent programming systems and are often designed using object oriented design methods. Concurrent Object Oriented Languages (COOLS) are a class of programming language that integrates the facilities of concurrent and object oriented programming in an integrated rather than orthogonal manner. With the increasing interest in the use of object oriented languages such as C++ for the programming of embedded and real-time systems COOLs seem to be a natural candidate for such tasks. Several COOLs have been described in the literature which address the requirements of concurrent programming, inter-process communication (IPC) and synchronisation in various dierent ways. This paper discusses one such language, ClassiC, and examines the approach to this problem taken in its design. In particular, it is shown that the features of ClassiC allow derivation of active classes from other active classes. It is shown how this property can be used to overcome some of the problems associated with synchronous IPC schemes while maintaining the advantages of them and how the use of the asynchronous IPC model allows ver-i®cation of synchronisation and deadlock properties based on the use of CSP methods.
A branching time semantics for the Ada rendezvous mechanism
Proceedings of HICSS-29: 29th Hawaii International Conference on System Sciences, 1996
Branching-time semantics based on domains built upon tree structures have been proposed to model concurrent processes. However, the resulting models imposed severe restrictions to ensure monotonicity and compositionality. To address these issues, we construct a semantic domain without sacrificing these two properties. We also provide a simple and faithful semantics of the Ada rendezvous mechanism.