Coordinated Atomic Actions Research Articles

A Formal Approach to implement java exceptions in cooperative systems

The increasing number of systems that work on the top of cooperating elements have required new techniques to control cooperation on both normal and abnormal behaviors of systems. The controllability of the normal behaviors has received more attention because they are concerned with the users expectations, while for the abnormal behaviors it is left to designers and programmers. However, for cooperative systems, the abnormal behaviors, mostly represented by exceptions at programming level, become an important issue in software development because they can affect the overall system behavior. If an exception is raised and not handled accordingly, the system may collapse. To avoid such situation, certain concepts and models have been proposed to coordinate propagation and recovering of exceptional behaviors, including the Coordinated Atomic Actions (CAA). Regardless of the effort in creating these conceptual models, an actual implementation of them in real systems is not very straightforward. This article provides a reliable framework for the implementation of Java exceptions propagation and recovery using CAA concepts. To do this, a Java framework (based on a formal specification) is presented, together with a set of properties to be preserved and proved with the Java Pathfinder (JPF) model checker. In practice, to develop new systems based on the given coordination concepts, designers/programmers can instantiate the framework to implement the exceptional behavior and then verify the correctness of the resulting code using JPF. Therefore, by using the framework, designers/programmers can reuse the provided CAA implementation and instantiate fault-tolerant Java systems.

Frameworks for designing and implementing dependable systems using Coordinated Atomic Actions: A comparative study

This paper 1 Some preliminary results included in this paper were presented at 17th International Symposium on Software Reliability Engineering (ISSRE’06) (see Capozucca et al., 2006). 1 presents ways of implementing dependable distributed applications designed using the Coordinated Atomic Action (CAA) paradigm. CAAs provide a coherent set of concepts adapted to fault tolerant distributed system design that includes structured transactions, distribution, cooperation, competition, and forward and backward error recovery mechanisms triggered by exceptions. DRIP (Dependable Remote Interacting Processes) is an efficient Java implementation framework which provides support for implementing Dependable Multiparty Interactions (DMI). As DMIs have a softer exception handling semantics compared with the CAA semantics, a CAA design can be implemented using the DRIP framework. A new framework called CAA-DRIP allows programmers to exclusively implement the semantics of CAAs using the same terminology and concepts at the design and implementation levels. The new framework not only simplifies the implementation phase, but also reduces the final system size as it requires less number of instances for creating a CAA at runtime. The paper analyses both implementation frameworks in great detail, drawing a systematic comparison of the two. The CAAs behaviour is described in terms of Statecharts to better understand the differences between the two frameworks. Based on the results of the comparison, we use one of the frameworks to implement a case study belonging to the e-health domain.

Analysis and framework-based design of a fault-tolerant web information system for m-health

The e-health domain has the objective to assist and manage citizens’ health. It concerns many actors like patient, doctors, hospitals and administration. Current and forthcoming generations of application will be web based and will integrate more and more mobile devices. In such application domain, called m-health, dependability is a key notion. In addition, more and more functionalities of such systems will be implemented as services for providing qualities like adaptability and maintainability. This paper presents, through a case study, how we can analyse and design an application that controls the insulin injection and that is embedded in a mobile device belonging to an e-health Web Information System (WIS). In order to ensure the dependability of the control systems, we show how to use Coordinated Atomic Actions (CAA). CAAs provide well defined concepts for fault tolerance, error-detection and error recovery in a distributed context where competitive and cooperative concurrencies are considered. The combination of CAA and SOA at design level it is proposed, with the purpose of being able to design systems that are partially implemented using service-oriented technologies. We updated and used our implementation framework, called CAA-DRIP, which originally was not tailored for service-oriented mobile applications. Thus, in this paper, we also propose an adaptation of CAA-DRIP for mobile devices.

Systems of systems and coordinated atomic actions

System of systems (SoS) is an emerging field in the design and development of complex systems that are built from large scale component systems. A SoS has the following attributes: operational and managerial independence of components, a geographic extent that limits control mechanisms to information exchange, an evolutionary nature, and emergent behavior. The subsystems that comprise the SoS often are built by different organizations with conflicting goals, designed under different assumptions and built to different quality standards. These factors impact fault detection, fault isolation, and fault tolerance and can result in systems that cannot easily be debugged, integrated, or maintained. When fault detection and fault tolerance are deficient, the system may behave in a fragile or brittle manner, randomly and repeatedly crashing. Crashes prevent automated diagnosis algorithms from being executed and can prevent manual root cause analysis by erasing system state. Fragility during system integration can prevent achieving schedule milestones and deadlines. Deficient fault detection and fault isolation also impacts end users and system maintainers. (Think <insert name of infamous project here>).From the system architect's point of view, designing a system that can detect all possible fault conditions across all components can be an extremely difficult, if not impossible challenge. Can any system be trusted to diagnose or repair itself when it has been corrupted by faults? How do you prevent local faults from growing into global failures? The end users may have unreasonable expectations about how the system should behave when components within the SoS behave abnormally or fail. They may expect better behavior than the typical PC. The system maintainers may expect a coherent systems view of failures to isolate faulted components and to provide an orderly and safe shutdown or recovery.(Think power grid blackouts, Telecomm failures, etc.)The most beneficial way to achieve fault tolerance is to design in fault detection and fault reporting such that defined boundaries such as subsystems serve as natural firewalls for fault containment. Although partitioning the system into subsystems for fault containment is well known and practiced, the end result as experienced at the time of system integration is rarely a success. COTS middleware, intended to aid distributed design often becomes in effect a step backwards by providing fertile ground for faults and failures that breach fault containment boundaries. (Think <insert name of OS or middleware vendor here>)What can be done to improve this situation? This paper addresses the system architectural partitioning concept of the Coordinated Atomic Actions (CAA). CAA promotes a different manner of organizing software architecture that improves fault containment across potentially faulty components. CAA was first invented by members of Brian Randell's research group at the University of Newcastle at Tyne in the mid 1990's. CAA promotes the concept of the "transaction" which has been traditionally identified with database applications. When you access your bank account via ATM, you are exercising database transactions within your bank's financial SoS. CAA applies transactions to cooperating concurrent distributed processes, which are the basis for most large complex computing systems.

Rigorous development of an embedded fault-tolerant system based on coordinated atomic actions

Describes our experience using coordinated atomic (CA) actions as a system structuring tool to and validate a sophisticated and embedded control system for a complex industrial application that has high reliability and safety requirements. Our study is based on an extended production model, the specification and simulator for which were defined and developed by FZI (Forschungszentrum Informatik, Germany). This fault-tolerant production cell represents a manufacturing process involving redundant mechanical devices (provided in order to enable continued production in the presence of machine faults). The challenge posed by the model specification is to a control system that maintains specified safety and liveness properties even in the presence of a large number and variety of device and sensor failures. Based on an analysis of such failures, we provide details of: (1) a for a control program that uses CA actions to deal with both safety-related and fault tolerance concerns and (2) the formal verification of this based on the use of model checking. We found that CA action structuring facilitated both the and verification tasks by enabling the various safety problems (involving possible clashes of moving machinery) to be treated independently. Even complex situations involving the concurrent occurrence of any pairs of the many possible mechanical and sensor failures can be handled simply yet appropriately. The formal verification activity was performed in parallel with the activity, and the interaction between them resulted in a combined exercise in design for validation; formal verification was very valuable in identifying some very subtle residual bugs in early versions of our which would have been difficult to detect otherwise.

An application of fault tolerance patterns and coordinated atomic actions to a problem in railway scheduling

Developing and applying advanced approaches for system structuring is vital for fighting ever-increasing complexity of modern and future software systems. The concept of Coordinated Atomic (CA) actions has been developed at Newcastle University for designing and structuring complex concurrent and distributed applications. Certain successful experience has been gained in applying them in several application areas. The purpose of the research, some initial results of which we report here, is twofold: to show how CA actions can be used in a new application area (a railway control system) and to analyse how the design patterns which have been developed using our previous experience can help in designing such system using CA actions.

Coordinated atomic actions as a technique for implementing distributed gamma computation

The intentions of this paper are to discuss Coordinated Atomic (CA) actions and to demonstrate how they can be used in a very new application area. We apply this concept to designing a particular case of the Gamma computational paradigm, i.e. distributed Gamma computation. Within our approach, each Gamma reaction is an action. We demonstrate how Gamma computation can be effectively implemented in conventional distributed message passing systems using CA actions. The paper discusses our design and the benefits we gain by applying CA actions: allowing as much concurrency as possible, together with guaranteeing data consistency, a better system structuring, clear separation of different system levels, and additional flexibility. This experimental design and the Java implementation allow us to conclude that CA actions are a very powerful paradigm which can be used for implementing many complex systems and, in particular, software to support some parallel computational models and paradigms.

On distribution of coordinated atomic actions

The concept of coordinated atomic (CA) actions was introduced about two years ago. Since then this research has addressed many new problems and, in particular, problems of CA action distribution and implementation. Recently we have gained some experience in implementing different schemes in Ada 95 and Java. Our intention within this paper is to discuss how distributed CA action schemes can be realised. In particular, we outline different ways of action component distribution, trade-offs, applications for which these schemes are applicable. We discuss a wide range of schemes (some of them have not yet been implemented) based on a classification of various approaches to CA action distribution; to do this we analyse all possible ways of different action component distribution. We believe that this general discussion should help to better understand the current state of CA action implementation and is important for future research in CA actions.