Ada Tasking Research Articles

Highly parallel Ada—Ada on an ultracomputer

We examine the suitability of Ada to a specific multiprocessor architecture, the NYU Ultracomputer. The Ultracomputer is an MIMD machine with shared memory, and a special hardware primitive, the fetch-and-add operation, with which non-blocking versions of well-known synchronization primitives can be implemented. We show that fetch-and-add can be used to implement some common Ada tasking idioms, and that well-known algorithms for MIMD machines find a natural description in Ada. Furthermore, Ada solutions implemented with fetch-and-add have fewer and smaller critical sections than previously presented versions. The fetch-and-add primitive also provides an efficient solution to the problem of initializing a number of identical tasks, and to the potentially expensive implementation of termination for large numbers of tasks. We conclude that the Ada tasking model "fits" well an MIMD architecture such as the Ultracomputer.

A runtime supervisor to support Ada tasking

This paper describes a simple and efficient approach to implementing the Ada operations of entry calls, conditional and timed entry calls, accept statements, selective wait statements and delay statements. This is accomplished by describing the tasking supervisor -- a collection of programs which control the tasking operations. Ada definitions of the data structures and the supervisor procedures are given. The semantics of the Ada tasking operations are related to the supervisor by following the description of tasking in chapter 9 of the Reference Manual for the Ada Programming Language (1983). The structure of the object code for various Ada source language constructs is given. The interaction between the Ada object code and the run-time supervisor is described in detail. The remaining tasking opertions are described in Part 1 of this report (Riccardi and Baker 1984).

Runtime detection and description of deadness errors in Ada tasking

Abstract : A runtime monitoring system for detecting and describing tasking errors in Ada programs is presented. Basic concepts for classifying tasking errors, called deadness errors, are defined. These concepts indicate which aspects of an Ada computation must be monitored in order to detect deadness errors resulting from attempts to rendezvous or terminate. They also provide a basis for the definition and proof of correct detection. Descriptions of deadness errors are given in terms of the basic concepts. The monitoring system has two parts: (1) a separately compiled runtime monitor that is added to any Ada source text to be monitored, and (2) a pre-processor that transforms the Ada source text so that necessary descriptive data is communicated to the monitor at runtime. Some basic preprocessing transformations and an abstract monitoring for a limited class of errors were previously presented.

An overview and example of application of CAEDE

CAEDE is an experimental, integrated, iconic design environment which supports (1) a structured design methodology based on Buhr's System Design With Ada book (2) an iconic design entry system, (3) a design data base, and (4) design tools. The design data base is automatically represented in Prolog and the majority of the design tools are written in Prolog. Tools are currently available for structural and temporal analysis, and for source code generation. This paper describes both the ideas behind CAEDE and an example of a CAEDE tools written in Prolog for representing and analyzing the temporal behaviour of Ada tasking designs, without having to program them in Ada first.

Monitoring for Deadlock and Blocking in Ada Tasking

We present a deadlock monitoring algodrithm for Ada tasking programs which is based on transforming the source program. The transformations introduce a new task called the monitor, which receives information from all other tasks about their tasking activities. The monitor detects deadlocks consisting of circular entry calls as well as some noncircular blocking situations. The correctness of the program transformations is formulated and proved using an operational state graph model of tasking. The main issue in the correctness proof is to show that the deadlock monitor algorithm works correctly without having simultaneous information about the state of the program. In the course of this work, we have developed some useful techniques for programming tasking applications, such as a method for uniformly introducing task identifiers. We argue that the ease of finding and justifying program transformations is a good test of the generality and uniformity of a programming language. The complexity of the full Ada language makes it difficult to safely apply transformational methods to arbitrary programs. We discuss several problems with the current semantics of Ada's tasks.

Adam: An Ada‐based language for multiprocessing

AbstractAdam is a high‐level language for parallel processing. It is intended for programming resource scheduling applications, in particular supervisory packages for run‐time scheduling of multiprocessing systems. An important design goal was to provide support for implementation of Ada and its run‐time environment. Adam has been used to implement Ada task supervision and also as a high‐level target language for compilation of Ada tasking.Adam provides facilities corresponding to the Ada sequential constructs (including subprograms, packages, exceptions, generics). In addition, it provides specialized module constructs for implementation of packages that may be shared between parallel processes, and new predefined types for scheduling. The parallel processing constructs of Adam are more primitive than Ada tasking. Strong restrictions are enforced on the ways in which parallel processes can interact.A compiler for Adam has been implemented in MacLisp on DEC PDP‐10 computers. Runtime support packages in Adam for scheduling (on a single CPU) and I/O are also provided. The compiler contains a library manipulation facility for separate compilation.The Adam compiler has been used to build an Ada compiler for most of the July 1980 Ada, including task types and rendezvous constructs. This was achieved by implementing the translation of Ada tasking into Adam parallel processing as a preprocessor to the Adam compiler. This present Ada compiler, which has been operational since December 1980, uses a procedure call implementation of tasking. It can be easily modified to other implementations. Compilation of Ada tasking into a high‐level target language such as Adam facilitates studying questions of correctness and efficiency of various compilation algorithms, and code optimizations specific to tasking, e.g. elimination of unnecessary threads of control.This paper gives an overview of Adam and examples of its use. Emphasis is placed on the differences from Ada. Experience using Adam to build the experimental Ada system is evaluated. Design of a run‐time supervisor in Adam is discussed in detail.

Experiences with matrix multiplication using Ada tasks

This paper relates our experiences in learning Ada using Ada/Ed and presents a problem in its various stages of development and solution. The major focus of our efforts centered on the use of Ada tasking facilities and the conversion of the final solution into a generic package. Multiplication of square matrices was selected as the basis for our study, since the calculation of inner products (row X column) provided an excellent opportunity for using tasks.

Self-reproducing Ada tasks

Strictly to experiment with the expressive power of Ada tasking, a simple-minded parallel tree search is implemented. The major difficulty is found to be the problem of termination. After a sufficiently Ada-like solution has been found, a curious programming idiom is used to eliminate much of the synchronism required by such solution.

Multiprocessor Implementations of Tasking Facilities in ADA

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 approach is the same in the three cases and it consists of translating the ADA parallel constructs into procedural calls to kernel primitives. The kernel primitives corresponding to the most complex implementation are described.

Some experiences of implementing the ada concurrency facilities on a distributed multiprocessor computer system

The paper first identifies the concurrency requirements for a high-level concurrent programming language, and then discusses how the concurrency primitives proposed for the programming language Ada meet these requirements. This is followed by a description of an actual implementation of the Ada tasking constructs on a distributed multiprocessor computer system comprising a number of multiprocessor-shared memory stations linked by a serial communications network. A brief description of the system and the overheads involved when implementing the rendezvous mechanism on this architecture is presented, and also the implications of processing interrupts by mapping them into external entry calls to high-level service tasks are discussed

Axioms and proof rules for Ada tasks

An axiomatic proof system is developed for use in proving partial correctness and absence of deadlock in Ada tasks. Axioms for the Ada tasking primitives in isolation are presented, and then rules proposed that describe the logical interaction of tasks through the rendezvous mechanism. These axioms and rules are then used to present partial correctness proofs of parallel-processing examples written in Ada. The system is extended to deal with questions of blocking and detection of deadlock and, finally, the problems of task termination and exception handling are discussed.

An implementation and empirical evaluation of the tasking facilities in ADA

An implementation of Ada's tasking facilities, on the LSI-11 microcomputer, is described.The performance and the size of the kernel are compared with those of another language having the same basic characteristics, but with a synchronization mechanism based on shared data.The execution of typical test examples shows that the time spent in the two kernels is more or less the same.

A multi-processing implementation-oriented formal definition of Ada in SEMANOL

A formal definition of the syntax and semantics of Preliminary Ada has been designed and partially implemented as a metaprogram in the SEMANOL system. The paper describes the design in detail and also presents excerpts of the actual SEMANOL metaprogram. Special attention is paid to the following aspects, lacking in the formal denotational definition of Ada: (1) formal definition of the connection between the concrete and abstract syntax of Ada, a necessary element of a formal definition if it is to be executable; (2) formal definition of the semantics of concurrency in Ada tasking; (3) formal definition of the semantics of exceptions and interrupts. The complete SEMANOL metaprogram will be an executable formal definition. In effect, it defines a multi-processing operating system which accepts an Ada program, as a set of compilation units, together with data, and causes the program to be executed in a concurrent mode in accordance with the semantics of tasks prescribed in the Ada reference manual and rationale.

Algorithms for translating Ada multitasking

Algorithms are presented for translating the multitasking constructs of Ada into the language Ada-M. The purpose of the translation is to study various implementations of Ada tasking and their relative problems, merits, and efficiencies. The multiprocessing constructs of Ada-M are lower level than those of Ada and, hence, flexible enough to permit development of a variety of compilation techniques for Ada tasking. Ada-M is sufficiently high-level, however, to permit the implementations to be developed quickly and Understandably. Requirements for data structures, scheduling, and other pertinant elements of Ada tasking compilation are identified by the translation.

An experience with parallelism in Ada

One of the more interesting and controversial features of Ada is the tasking structure. The Ada tasking facility provides high level mechanisms for communication and synchronization among tasks executing in parallel. The open question about these mechanisms is whether they provide programmers with both the appropriate level of abstraction and also the necessary level of control.This paper describes in detail the implementation of a system using parallelism that was written during the Ada test and evaluation process.

On a formal model of the tasking concept in Ada

This paper describes the August 1980 state of the development of a formal model of the Ada tasking concept. The model is being developed at the Department of Computer Science, Technical university of Denmark in collaboration with the Danish Datamatics Centre as part of a full Ada compiler development project summarized below. The paper includes a short characterization of the (present) tasking concepts in Ada on which the model is based. The model description is rather informal to let you have a idea about the modelling principles. In appendix A a detailed example is given, unfolding the course of a rendezvous. The paper ends with a sketch of how an implementation can be systematically derived from the formal model.