Ada Tasking Research Articles

M2OS for Arduino Uno

This paper presents the current status of the porting of M2OS to the Arduino Uno board. M2OS is a small realtime operating system targeted to microcontrollers with very tight memory constraints. M2OS provides support for a simple Ada tasking model based on nonpreemptive one-shot tasks. The paper puts special emphasis on the adaptation of the standard Arduino core library to be used by Ada applications running on M2OS.

Leveraging real-time and multitasking Ada capabilities to small microcontrollers

Small embedded microcontrollers typically operate for years without further programmer intervention, so that shipping software free of errors becomes paramount. The Ada programming language includes many safety characteristics (e.g., strong typing or contract-based programming) that help to largely reduce the number of errors introduced by programmers. However, Ada is barely used in microcontrollers with tight memory constraints due to the overhead introduced at run-time. The tasking semantics included in the language represent one major source of this overhead. In this paper we present a new Ada run-time environment that includes a new scheduling policy based on the one-shot task model that simplifies the implementation of the Ada tasking primitives and allows stack sharing techniques to be applied. Consequently, the proposed approach allows using the inherent safety characteristics of the Ada language along with a set of tasking constructs more suitable for small memory devices. Despite its simplicity, the tasking primitives have an equivalent, if not superior, expressiveness to the typical tasking constructs provided by the operating systems targeted to small microcontrollers. An implementation based on a small kernel, a modified run-time system and an automatic code transformation tool have been developed in the context of this work. Initial tests provide promising results, showing the tasking constructs are functionally correct and the proposed run-time features a small memory footprint.

Multiprocessor Ada platform based on MaRTE OS and GNAT

This paper presents the implementation of a multiprocessor Ada platform based on MaRTE OS and GNAT. The paper describes the modifications required to adapt MaRTE OS to a multiprocessor architecture, namely the protection of the internal data structures against concurrent access and the management of several ready queues. We also describe the adaptation of the GNAT run-time library in order to be used on top of the multiprocessor services provided by MaRTE OS. The developed MaRTE/GNAT platform provides full Ada tasking functionality and the multiprocessor support defined in the Ravenscar profile. Two multiprocessor architectures are supported: the multiprocessor version of the XtratuM hypervisor for Intel x86 architecture and the Linux operating system (with MaRTE taking the role of a Pthreads multiprocessor library).

Bringing safe, dynamic parallel programming to the spark verifiable subset of ada

SPARK is a verifiable subset of Ada which has been in use for over 20 years for developing the most critical parts of complex real-time applications [1][2]. A restricted subset of the Ada tasking model is included in the newer versions of SPARK ("RavenSPARK"), but this is a very static model, with a fixed number of tasks and minimal task interaction [3]. In this presentation we will describe an extension of SPARK to support safe highly parallel programming, targeted at the growing number of multicore and manycore processors appearing on the market today.

Ada for real-time and parallel processing

This tutorial covers two of the major problems with parallel and real-time programming - time management and storage management. Parallel processing, whether on single-processor machines or multiple processors, has many pitfalls. We will examine these potential pitfalls, and discuss ways to avoid common problems, such as deadlocks and race conditions. We will also discuss how to write code that efficiently passes data with other parallel processes. The basics of parallel processing are covered, leading to a discussion and examples using Ada tasking. In addition, the Ada Real-Time Systems Annex is also covered.

MA1

Level - Intermediate. This tutorial assumes basic knowledge or experience with the Ada programming language. This tutorial covers two of the major problems with parallel and real-time programming - time management and storage management. Parallel processing, whether on single-processor machines or multiple processors, has many pitfalls. We will examine these potential pitfalls, and discuss ways to avoid common problems, such as deadlocks and race conditions. We will also discuss how to write code that efficiently passes data with other parallel processes. The basics of parallel processing are covered, leading to a discussion and examples using Ada tasking. In addition, the Ada Real-Time Systems Annex is also covered.

MA1

This tutorial assumes basic knowledge or experience with the Ada programming language. This tutorial covers two of the major problems with parallel and real-time programming -- time management and storage management. Parallel processing, whether on single-processor machines or multiple processors, has many pitfalls. We will examine these potential pitfalls, and discuss ways to avoid common problems, such as deadlocks and race conditions. We will also discuss how to write code that efficiently passes data with other parallel processes. The basics of parallel processing are covered, leading to a discussion and examples using Ada tasking. In addition, the Ada Real-Time Systems Annex is also covered.

Parallel evolution of game evaluation functions in ada

This is an Ada experience report, where we conclude that Ada tasking and distributed processing facilities make it a good research tool for experimentation with algorithms that might eventually need multiple processors. We implemented a genetic algorithm in Ada to create effective computer players for Connect4. Key to our success was employing Ada tasking and ALRM Annex E Distributed computing to harness a symmetric multiproces-sor and a distributed machine with very few code changes. Easy extension of an original single-task code to multi-tasking and distributed variants-even though extension was not planned in advance-was essential to timely completion. Using either the parallel or distributed implementation, about 150 processor hours were sufficient to evolve players that neither the GNU "Four-in-a-Row" Expert player nor the author could defeat. This algorithm relies on human expertise to restrict the genetic search space. Work is in progress on a new algorithm with near-zero encoded knowledge, which will run on 220 distributed nodes within the same distributed computing framework.

MP1

This tutorial assumes basic knowledge or experience with the Ada programming language. Basic understanding of tasking and real-time constraints -- at the level of tutorial MA1 -- would be helpful. We assume that attendees have a minimal background on real time operating systems, Ada tasking and critical real time applications/systems; however, a (very) short presentation of such topics will be included in the tutorial. This tutorial deals with real time scheduling theory and its use with Ada. Real time scheduling theory was firstly proposed in 1974, but stays mostly unused by many software designers. Too many practitioners have no background on real time scheduling. This tutorial should help them to understand the basis of such a theory and to apply it with Ada technologies. This tutorial is expected to help Ada engineers to predict the performances of their critical Ada real time applications. This tutorial will be organized in three parts: 1. First, we define what a real time system is and then, the theoretical results of the real time scheduling theory are presented. The basic task models and schedulers are explained (their behavior and their properties). The tutorial focusses on fixed priority scheduler and its feasibility tests (eg. Rate monotonic and worst case task response time) which is the most useful scheduler with current real-life applications. However, a dynamic priority scheduler is also presented (eg. EDF). At the end of this first part, attendees should understand what a feasibility test is and how it can help them to predict performances of their real time applications. This part is ended with a short introduction on shared resource support (eg. what a priority inversion is, how PIP/PCP work). 2. Second, we show how real time scheduling features are taken into account in Ada international standards such as ISO/IEC Ada 1995 and 2005, the POSIX 1003 Ada binding and ARINC 653 (which is an avionic operating system standard providing an Ada binding). In this part, we try to show the relationships between the real time scheduling theory and the implementation of real time schedulers into practical systems. 3. Finally, some Ada program examples are presented and explained.

Orchestrating shots for the national ignition racility

The National Ignition Facility (NIF), currently under construction at the Lawrence Livermore National Laboratory, is a stadium-sized facility containing a 192-beam, 1.8 Megajoule, 500-Terawatt, ultra-violet laser system together with a 10-meter diameter target chamber with room for nearly 100 experimental diagnostics. When completed, NIF will be the world's largest and most energetic laser experimental system, providing an international center to study inertial confinement fusion and physics of matter at extreme densities and pressures. The NIF is operated by the Integrated Computer Control System (ICCS), which is a layered architecture of over 700 lower-level front-end processors attached to nearly 60,000 control points and coordinated by higher-level supervisory subsystems in the main control room. An Ada95 based shot automation framework has been developed and deployed during the past year to orchestrate and automate shots performed at the NIF using the ICCS. Ada95 provides language features that have enabled the construction of a complex, highly distributed control application. The Ada tasking model and protected types provide multi-threaded behaviors and synchronization mechanisms required by the ICCS. The Shot Automation framework is designed to automate 4-hour shot sequences including derivation of shot goals from an experiment definition, set up of the laser and diagnostics, automatic alignment of laser beams, and a countdown to charge and fire the lasers. A typical sequence consists of one or more preparatory verification shots leading to an amplified system shot that is followed by post-shot analysis and archiving. The framework provides for flexible model-based workflow execution with work divided into data driven packets called "macro steps". The Shot Director program is the top-level orchestrating component of the shot automation framework, which manages the state machine that defines the structure of the shot sequence. Collaboration Supervisors translate shot lifecycle state commands from the Shot Director into sequences of "macro steps" that are distributed to subsystem shot supervisors while maintaining the order of macro steps for each subsystem and supporting collaboration between different macro steps. Each macro step has phases for database-driven verification and a scripted execution. This provides a highly flexible framework for performing a variety of NIF shot types. Database tables define the order of work and dependencies (workflow) of macro steps to be performed for a shot. A graphical model editor facilitates the definition and viewing of an execution model. A Change Manager tool enables "de-participation" of individual devices, of entire laser segments (beams, quads, or bundles of beams) or of individual diagnostics. This software has been successfully deployed to the NIF facility and is currently being used to support NIF laser commissioning shots and the build-out of additional laser bundles. The software will also be used to automate future target and experimental shot campaigns.

GNAT/ORK: AN OPEN CROSS-DEVELOPMENT ENVIRONMENT FOR EMBEDDED RAVENSCAR–ADA SOFTWARE

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.

Conflict resolution for readers and writers

For those of us who have been teaching Operating Systems for years, you may remember with nostalgia the days when Operating Systems texts [ex: Deitel 1984] included Ada code to illustrate solutions for concurrency problems. I find concurrency the most difficult topic to teach in Operating Systems, and expressing solutions in Ada is a strong teaching aid. Ada's tasking construct is powerful and readable. In addition, an Ada Programming Support Environment enables hands-on experimentation.The Readers/Writers problem, a classic mutual exclusion synchronization problem, puzzled computer science professionals for years. Explaining these solutions, as presented in current Operating Systems texts, is daunting.We contrast code expressed in C to that proposed by Burns [Burns1985] and Barnes [Barnes1995] for readability. We then suggest a slight modification to obtain what we consider to be a preferred solution, one that illuminates concurrency issues in general.

Implementation of mode changes with the Ravenscar profile

The use of concurrency in the development of safety-critical systems has not been recommended for a long time. Recently, a safe Ada tasking subset has been defined, known as the Ravenscar Profile. The imposed restrictions invalidated most of the proposed implementations for dealing with mode changes.In this paper, it is described an implementation approach for mode changes, that is compliant with the Ravenscar Profile. It relies on the decoupling between jobs and tasks and on centralizing tasks activations in a system manager. The proposed ideas have been tested with the ORK, which is a kernel integrated with the GNAT compiler for developing and executing applications that follow the Ravenscar Profile.

Compositional Petri net models of advanced tasking in Ada-95

The Ada language has been designed to support development of concurrent and distributed software. While the Ada-83 standard defined the basic mechanisms of rendezvous-based tasking, the Ada-95 standard significantly extended this capability with the introduction of several advanced tasking constructs. We present and discuss formal models of these key tasking constructs using the Petri net model. We also provide some formal evaluation of the models using one particular net-based method, invariant analysis. The constructs considered are the asynchronous transfer of control, the protected object, and the requeue statement. By modeling these advanced Ada tasking constructs with Petri nets, we obtain compositional models of the constructs that are complementary to earlier work in net-based modeling of Ada tasking, both in terms of defining precise behavior for tasking semantics, and also in terms of providing support for automated analysis of concurrent software.

A Linux kernel module implementation of restricted Ada tasking

An Ada tasking kernel is implemented as a layer beneath the Linux operating system on a PC-compatible machine. This implementation is derived from Yodaiken's Real-Time Linux kernel, with new scheduling and synchronization primitives introduced specifically to support the GNAT Ada runtime system. Primitive operations for real-time Ada tasks are directly implemented on top of the underlying hardware in the form of a loadable Linux kernel module. This design not only reduces execution overhead and improves control over execution timing for tasks, but also opens the door for a simple restricted-tasking runtime system that could be certified for safety-critical applications.

Restricted tasking models

High-integrity systems rarely make use of high-level language features such as Ada tasking. In this paper, simple language profiles (of Ada 95 concurrency features) are developed that are appropriate for various levels of integrity. A level-0 model (collection of Ada95 features) defines a minimal language profile and delivers deterministic (non-preemptive) behaviour. Scheduling is undertaken as part of the application and can thus be inspected and verified. Five other models are also presented that give different levels of expressive power. The motivation for this paper is to try and define models that would become de facto standards and that would be directly supported by kernel vendors and other tool suppliers.

T-SMART—task-safe, minimal Ada realtime toolset

This paper describes T-SMART, an Ada83 executive and toolset for the production of safety critical and hard real time applications. T-SMART consists of three main integrated parts:- Ada runtime executive audited to DO-178B standard for use in safety-critical systems- Traditional Ada compilation system tools such as Compiler, Binder and Debugger- Tools to support program verification, such as schedulability and coverage analysis.The existing toolset is suitable for building safety-critical and hard real time systems in Ada83 with some extensions and enforced coding style. The extensions have been designed to be compatible with the recent revision of the Ada language (Ada95) in order to ease the transition (both for the vendor who must audit the runtime executive, and for the user who must certify the application) when the Ada95 safety-critical market is eventually established.Although such toolsets are not uncommon, the significant differentiator is that the runtime executive has undergone the most stringent independent auditing to DO-178B standard, making it suitable for formal certification. Use of this toolset in actual safety-critical applications lays to rest the view that Ada tasking cannot be used in this market sector, and so provides valuable input to the evolution of the Safety and Security Annex in Ada95, which currently prohibits the use of Ada tasking.

Using compliance notation to verify Ada tasking

Tasking is the most important-aspect of Ada not addressed by existing verification systems. The DRA Compliance Notation allows a subset of Ada to be embedded in a engine supported by Z. We propose incorporating a reduced tasking model into the Notation.

Low-level Ada tasking support for GNAT-performance and portability improvements

GNARL is the tasking runtime system of the Gnu NYU Ada95 Translator (GNAT). GNARL is divided into two main layers, the lower of which isolates dependences on a particular host operating system or real-time kernel. For portability, the primary implementation of this lower level accesses OS services via the POSIX interfaces. In this paper we describe our recent redesign of the low-level interface, to improve both performance and portability. Performance comparisons between the new and old runtime system on Solaris2.4 show up to approximately 40 percent improvement on tasking related operations.

Task dependence and termination in Ada

This article analyzes the semantics of task dependence and termination in Ada. We use a contour model of Ada tasking in examining the implications of and possible motivation for the rules that determine when procedures and tasks terminate during execution of an Ada program. The termination rules prevent the data that belong to run-time instances of scope units from being deallocated prematurely, but they are unnecessarily conservative in this regard. For task instances that are created by invoking a storage allocator, we show that the conservative termination policy allows heap storage to be managed more efficiently than a less conservative policy. The article also examines the manner in which the termination rules affect the synchronization of concurrent tasks. Master-slave and client-server applications are considered. We show that the rules for distributed termination of concurrent tasks guarantee that a task terminates only if it can no longer affect the outcome of an execution. The article is meant to give programmers a better understanding of Ada tasking and to help language designers assess the strengths and weaknesses of the termination model.