A new paradigm for the design of concurrent systems

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.

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.

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.

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.

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.

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.

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.

ACM Transactions on Software Engineering and Methodology, 1995

IEEE Transactions on Software Engineering, 2000

Abstract Concurrent systems are typically large and complex, requiring long, development time and much labor. They are, therefore, prime candidates for simplification and automation of the design and programming process. Their major application areas include real time systems, operating systems and cooperative computation. New applications are emerging with the trends towards wide usage of personal computers connected in a network and towards use of parallel processing in supercomputer architectures.

Proceedings Sixth IEEE International Conference on Engineering of Complex Computer Systems. ICECCS 2000, 2000

The task of programming concurrent systems is substantially more dificult than the task of programming sequential systems with respect to both correctness and eflciency. In this paper we describe a constraint-based methodology for writing concurrent applications. A system is modeled as: (a) a set of processes containing a sequence of "markers" denoting the processes points of interest; and (b) a constraint store. Process synchronization is specijied by incrementally adding constraints on the markers' execution order into the constraint store. The constraint store contains a declarative specijication based on a temporal constraint logic program. The store, thus, acts as a coordination entity which on the one hand encapsulates the system synchronization requirements, and on the other hand, provides a declarative specijication of the system concurrency issues, This provide great advantages in writing concurrent programs and manipulating them while preserving correctness.

Lecture Notes in Computer Science, 1985

Science of Computer Programming, 1984

Asubset of ADA is introduced, ADA-CF. to study the basicsynchronization and communication primitive of ADA, the rendezvous. Basing ourselves on the techniques introduced by Apt, Francez and de Roever for their CSP proof system, we develop a Hoare-style proof system for proving partial correctness properties which is sound and relatively complete. The proof system is then extended to deal with safety, deadlock, termination and failure. No prior exposure of the reader to parallel program proving techniques is presupposed. Two non-trivial example proofs are given of ADA-CF programs; the first one concerns a buffered producer-consumer algorithm, the second one a parallel sorting algorithm due to Brinch Hansen. Features of ADA expressing dynamic process creation and realtime constraints are not covered by our proof methods. Consequently, we do not claim that the methods described can be extended to full AD-\ without serious additional further research.

International Conference on Computing and Information, 1990

ionsChris Marlin & Michael OudshoornDepartment of Computer ScienceThe University of AdelaideG.P.O. Box 498Adelaide, S.A. 5001 AustraliaDennis FreidelHewlett Packard -- Colorado Networks Division3404 East Harmony RoadFort Collins, Colorado 80525 U.S.A.AbstractLanguage-level concurrency is becoming more widely available in programming languages, placingparallel programming features in the hands of many programmers for the first time. Unfortunately,the precise semantics of these ...

2000

Whether in commercial or military applications, no real-time system can simply be coded straight-away from the requirements. A method is needed to enable system designers to move from a requirements statement through a decomposition of the problem, to a system architecture, and then to an identification and specification of system components. For real-time systems, a design method must help identify concurrency and shared access to resources. The products of a design method should enable low-level design and coding assignments to be distributed to programmers. In many cases, the programmers will be required to code in Ada 1 , a language developed with concurrent, real-time systems in mind. Several methods exist for designing real-time systems that will be implemented in Ada. This paper helps a designer to choose between two such design methods. One method, developed by Nielsen and Shumate at the Hughes Aircraft Company, aims specifically at large, real-time systems that will be implemented in Ada. 2,3 The second method, devised by Gomaa, applies more generally to real-time systems, but includes some optional steps when the implementation language is Ada. 4,5,6 For each method, this paper compares the goals, the underlying assumptions, the design steps, and the resulting products. Then, the two design methods are evaluated , and one of the methods is recommended for designing real-time control systems that will be implemented with Ada. First, the Nielsen and Shumate method is reviewed. Designing Large Real-Time Systems With Ada Nielsen and Shumate have devised a method for designing large, real-time systems with Ada concepts and constructs. Nielsen and Shumate argue that: Ada requires a new design method for real-time systems since it differs from conventional language/executive combinations in two important ways: (1) concurrency and process communication are inherent in the language and do not require a separate RTE [Real-Time Executive]; and (2) the nature of the tasking model is different from current popular approaches used for task scheduling, communication, and synchronization.[3, p. 696]

2008 13th Asia-Pacific Computer Systems Architecture Conference, 2008

This is a discussion paper on a very important topic that is about to become mainstream. It deals with the issues of software engineering in concurrent systems. It introduces this topic and illustrates the arguments for a change of perspective. It underlines these arguments with two examples, an asynchronous stream-based programming model and an asynchronous thread-based virtual machine model. Both support concurrency on very different abstractions but both capture similar support for concurrency engineering.