Implementing atomic actions in Ada 95

Atomic actions are an important dynamic structuring technique that aid the construction of fault-tolerant concurrent systems. Although they were developed some years ago, none of the well-known commercially-available programming languages directly support their use. This paper summarizes software fault tolerance techniques for concurrent systems, evaluates the Ada 95 programming language from the perspective of its support for software fault tolerance, and shows how Ada 95 can be used to implement software fault tolerance techniques. In particular, it shows how packages, protected objects, requeue, exceptions, asynchronous transfer of control, tagged types, and controlled types can be used as building blocks from which to construct atomic actions with forward and backward error recovery, which are resilient to deserter tasks and task abortion

EOS: A project to investigate the design and construction of real-time distributed embedded operating systems

The EOS project is investigating the design and construction of a family of real-time distributed embedded operating systems for reliable, distributed aerospace applications. Using the real-time programming techniques developed in co-operation with NASA in earlier research, the project staff is building a kernel for a multiple processor networked system. The first six months of the grant included a study of scheduling in an object-oriented system, the design philosophy of the kernel, and the architectural overview of the operating system. In this report, the operating system and kernel concepts are described. An environment for the experiments has been built and several of the key concepts of the system have been prototyped. The kernel and operating system is intended to support future experimental studies in multiprocessing, load-balancing, routing, software fault-tolerance, distributed data base design, and real-time processing

The embedded operating system project

This progress report describes research towards the design and construction of embedded operating systems for real-time advanced aerospace applications. The applications concerned require reliable operating system support that must accommodate networks of computers. The report addresses the problems of constructing such operating systems, the communications media, reconfiguration, consistency and recovery in a distributed system, and the issues of realtime processing. A discussion is included on suitable theoretical foundations for the use of atomic actions to support fault tolerance and data consistency in real-time object-based systems. In particular, this report addresses: atomic actions, fault tolerance, operating system structure, program development, reliability and availability, and networking issues. This document reports the status of various experiments designed and conducted to investigate embedded operating system design issues

Action Refinement in End-Based Choice Settings

The choice operator is essential for the description of action-based reactive systems. If the atomicity of actions is dropped (e.g. by action refinement), one has to decide when the choice is triggered. The standard approach is to trigger the choice when actions start. This thesis examine the alternative approach that the choice is triggered when actions terminate. This end-based choice is motivated and a process algebra, which contains an end-based choice and an action refinement operator, is established. Consistent semantics (operational, denotational, axiomatical) are given. Furthermore, the difference between the start-based and the end-based choice are examined, in particular with respect to equivalence notions. New equivalence are established, since the standard equivalences are not preserved by the end-based action refinement operator

Atomic Actions in Concurrent Systems (fault-Tolerance, Control)

159 p.Thesis (Ph.D.)--University of Illinois at Urbana-Champaign, 1985.The concept of an indivisible sequence of actions has been in use to design concurrent systems. An atomic action is an activity, possibly consisting of many steps performed by many processors, that appears primitive and indivisible to any activity outside the atomic action. The aim of the thesis is to show that atomicity is fundamental to programming concurrent systems and to demonstrate that many different concurrency control schemes which have appeared in many different contexts have actually the same goal: to provide a mechanism that ensures atomicity of system activities.A formal model of atomic actions is presented. Actions are specified in terms of their state transformation sequences. Atomic actions are specified as restricted state transformation sequences. Backward and forward recoverability of actions is defined for this model. It is shown that if an action is backward recoverable (or forward recoverable) then it is necessarily an atomic action. A notation is proposed to use atomic actions for fault tolerance in a system of communicating sequential processes. The technique provides a construct to implement atomic actions, which is used to support the different recovery schemes in a complementary manner. An implementation is proposed which employs local compile-time and run-time checking of the forward and backward recovery schemes. A new protocol is proposed to implement atomic actions in database systems. The protocol employs preventive and corrective measures to ensure the atomicity of transactions in a database system.U of I OnlyRestricted to the U of I community idenfinitely during batch ingest of legacy ETD