Debugging tasked Ada programs

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.

Proceedings of the 1987 annual ACM SIGAda international conference on Ada - SIGAda '87, 1987

A standard package of low-level Ada tasking operations is needed, to support real-time embedded applications for which the existing Ada tasking operations are too slow or provide insufficient control over timing. This paper suggests criteria for such a package, and gives examples of how specific low-level tasking operations might be used to solve some important realtime problems.

SIGAda Conference, 1992

The draft standard Threads Extension to the POSIXPortable Operating System Interface provides an applicationprogram interface to services supporting thecreation and execution of multiple threads of controlsharing the address space and file descriptors of a singlePOSIX process. This paper reports on the progress ofan effort to test the compatibility of POSIX threads andAda by implementing Ada tasking using the proposedstandard POSIX

ACM Transactions on Programming Languages and Systems, 1990

A method is presented for using symbolic execution to generate the verification conditions required for proving correctness of programs written in a tasking subset of Ada. The symbolic execution rules are derived from proof systems that allow tasks to be verified independently in local proofs, which are then checked for cooperation. The isolation nature of this approach to symbolic execution of concurrent programs makes it better suited to formal verification than the more traditional interleaving approach, which suffers from combinatorial problems. The criteria for correct operation of a concurrent program include partial correctness, as well as more general safety properties, such as mutual exclusion and freedom from deadlock.

ACM SIGPLAN Notices, 1981

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.

ACM Transactions on Software Engineering and Methodology, 1995

Information and Software Technology, 1994

In this paper, we have developed a dynamic analyser for Ada programs, called AIDA. In software engineering, dynamic analysers that have been built previously have often incorporated first-order-logic assertion languages. For dynamic testing of both sequential and concurrent programs, however, temporal logic may be advantageous since it deals with the development of situations over time. AIDA investigates the applicability of temporal logic in building a dynamic analyser for Ada programs. AIDA is designed to test, debug and specify programs written in the Ada language. It affects the instrumentation of programs as well as the collecting, organizing and reporting of results of the executions of the instrumented program. The instrumentation approach is based on the idea that the intended function of a program can often be specified in terms of assertions or values that must be assumed by variables, at certain strategic paints in the program. This paper describes the design, implementation and experimental evaluation of AIDA. The goal of this work is to apply AIDA as a comprehensive dynamic analyser for Ada programs. AIDA can handle sequential processes, and concurrent tasks as well as it can understand fully all Ada statements.

ACM SIGAda Ada Letters, 1985

A b&act 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 in [2]. Here an Ada implementation of a monitor and a more extensive set of pre-processing transformations are described. This system provides an experimental automated tool for detecting deadness errors in Ada83 tasking and supplies useful diagnostics. The use of the runtime monitor for debugging and for programming evasive actions to avoid imminent errors is described and examples of experiments are given.

Proceedings of the fifth Washington Ada symposium on Ada - WADAS '88, 1988

The DAPSE (Distributed Ada Programming Support Environment) research project aims at (i) producing a technology base for developing future Ada programming support environments and (ii) demonstrating the suitability of this technology base by using it to build a prototype environment for the development of distributed Ada software. In this paper we emphasize those parts of the DAPSE project that specifically address the methodology and software tool support for building distributed applic~ tions in Ada. Our paper is structured into three major parts: (1) a brief overview of the entire DAPSE project and a general framework for distributed programming, (2) the specific distribution strategy chosen for the DAPSE project and the initial DAPSE distribution tool kit intended to support the chosen distribution strategy (including first lessons learned), and (3) future plans. 1 I n t r o d u c t i o n Ada has been designed to support the development of sequen-tial~ parallel~ and distributed software applications. As of today, however, none of the existing compilers, run-time environments, or Ada Programming Support Environments provide adequate support for developing distributed Ada programs. The state-of-the-practice in developing distributed Ada applications is to manually distribute distinct Ada programs and implement the required communication between them (e.g., substituting the regular Ada communication mechanisms by system calls to an underlying communication layer).

Safety of Computer Control Systems 1990 (Safecomp '90), 1990

Among existing techniques used to improve software reliability symbolic execution plays an important role. Symbolic testing is potentially more effective than numeric testing, since a symbolic execution represents a class of numeric executions. Symbolic execution can also be used to generate the necessary verification conditions that ensure program (partial) correctness, by adding to the program first order predicates describing its logical properties. Several tools have been built to provide environments in which symbolic execution can be performed. However all of these tools are quite unsatisfactory when dealing with programs that use arrays and/or pointers. In this paper we present a tool (SYMBAD) that provides an environment in which it is possible to perform both symbolic testing and verification on sequential Ada components. Furthermore SYMBAD can be used to find out which restrictions must be placed on input variables of a program in order to execute a particular path. SYMBAD has been designed and implemented at Dipartimento di Elettronica of Politecnico di Milano; it runs under Unix operating system and it is written in C and Lisp. The main SYMBAD features are presented; problems encountered in dealing with arrays and pointers and the adopted solutions are discussed; finally an example of a SYMBAD session is reported.

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.

Proceedings of the 15th IFAC World Congress, 2002, 2002

Ada tasking is a powerful abstraction mechanism for developing concurrent embedded systems. However, many implementations of concurrent tasking have been seen as potentially unsafe for critical systems because of their high degree of indeterminism. The Ravenscar profile is a subset of Ada 95 tasking with purpose of providing a basis for the implementation of certifiable critical systems. ORK is an open-source real-time kernel which provides full conformance with the Ravenscar profile on embedded computers. The kernel has a reduced size and complexity, and has been carefully designed to allow the building of reliable software for embedded applications. This kernel is integrated in a cross-compilation system based on GNAT 3.13, supporting the subset of Ada 95 tasking which is allowed by the Ravenscar profile in an efficient and compact way. It is closely integrated with other tools, including a tasking-aware version of GDB.

Proceedings of the conference on TRI-Ada '92 - TRI-Ada '92, 1992

DProto is a computer-aided software engineering (CASE) system for rapidly prototyping concurrent applications. The environment supports codesign and analysis of high-level software and hardware architectures early in the system life cycle. DProto comprises a comprehensive tool set for editing hierarchical dataflow specifications, objectbased data modeling, component reuse, resource modeling, user-interface prototyping, software/hardware allocation, interacti e simulation, and code genemtion. This paper conr eentrate on the methodology and tools in DPmto that support a high-level executable specification language for rapid construction of prototypes and the Ada code generation facility for building target applications. Emphasis is placed on describing the concurrent modeling primitives of the visual specification language and their translation into multitasked Ada for carrying out implementation details.

IEEE Transactions on Parallel and Distributed Systems, 1990

As computer systems have become more and more decentralized and parallel in operation, interest in concurrent and distributed software has grown. One very important and challenging problem for distributed-software engineering is program behavior analysis. We have advocated the use of Petri nets to d e h e a general static analysis framework for Ada tasking. The framework has evolved into a collection of tools that have proven to be a very valuable platform for experimental research. In this paper, we d e h e and discuss the design and implementation of tools that make up our Tasking-Oriented Toolkit for the Ada Language (TOTAL). Both modeling and query /analysis methods and tools are discussed. Example Ada tasking programs are used to demonstrate the utility of each tool individually as well as the way the tools integrate together.

Computer Languages, 1985

The Ada task system is critically evaluated from the point of view of real-time applications. Based on such an evaluation an abstract machine, supplying both an operational semantics and an implementation schema for it, is derived. Such a schema, depending on parameters, may supply a standard implementation following the Ada Reference Manual specifications, or may allow the user to implement ad hoc policies required by the time constraints of the specific application.