Consistent System State Research Articles

Revisiting transactions in Ada

Classical lock-based concurrency control does not scale with current and foreseen multi-core architectures, opening space for alternative concurrency control mechanisms. The concept of transactions executing concurrently in isolation with an underlying mechanism maintaining a consistent system state was already explored in fault-tolerant and distributed systems, and is currently being explored by transactional memory, this time being used to manage concurrent memory access. In this paper we discuss the use of Software Transactional Memory (STM), and how Ada can provide support for it. Furthermore, we draft a general programming interface to transactional memory, supporting future implementations of STM oriented to real-time systems.

Asynchronous Backup and Initialization of a Database Server for Replicated Database Systems

A possibility of a temporary disconnection of database service exists in many computing environments. It is a common need to permit a participating site to lag behind and re-initialize to full recovery. It is also necessary that active transactions view a globally consistent system state for ongoing operations. We present an algorithm for on-the-fly backup and site-initialization. The technique is non-blocking in the sense that failure and recovery procedures do not interfere with ordinary transactions. As a result the system can tolerate disconnection of services and reconnection of disconnected services, without incurring high overheads.

Maximum Tolerable Error Bound In Distributed Simulated Annealing

Simulated annealing is an attractive, but expensive, heuristic method for approximating the solution to combinatorial optimization problems. Attempts to parallel simulated annealing, particularly on distributed memory multicomputers, are hampered by the algorithm's requirement of a globally consistent system state. In a multicomputer, maintaining the global state S involves explicit message traffic and is a critical performance bottleneck. To mitigate this bottleneck, it becomes necessary to amortize the overhead of these state updates over as many parallel state changes as possible. By using this technique, errors in the actual cost C(S) of a particular state S will be introduced into the annealing process. This paper places analytically derived bounds on this error in order to assure convergence to the correct optimal result. The resulting parallel simulated annealing algorithm dynamically changes the frequency of global updates as a function of the annealing control parameter, i.e. temperature. Implementation results on an Intel iPSC/2 are reported.

Supporting fault-tolerant distributed computations under real-time requirements

In contrast to conventional (trans)action concepts, the proposed dynamic action model includes the possibility for optimistic recovery to gain high efficiency during normal operation. To minimize time overhead we use a redundant recovery graph to record the necessary recovery information. Based on this graph we provide decentralized protocols that efficiently produce a consistent system state concurrent to normal system activity. Considering real-time applications in distributed systems, error processing time has to be minimized. To achieve this, the proposed concept is extended to the parallel dynamic action scheme where the different versions are executed in parallel. This leads to a recovery concept that combines efficient distributed processing during normal operation and prompt reaction in case of an error.

A Highly Available Multimicroprocessor System for Real-Time Applications

This paper describes the implementation of a highly available multimicroprocessor system based on the M.A.R.A. (Modular Architecture for Real Time Processing) multimicroprocessor architecture developed by Selenia. The proposed solution is based on the full duplication of a M.A.R.A. node. Fault detection is independently performed on the two nodes. At every time, only one of the two nodes (Master Node) controls the application, while the other node (Slave Node) is always ready to substitute the Master node. In case of a detected fault, the Master node communicates its unavailability to the Slave Node, and disconnects itself from the application. The Slave Node resumes the control of the application starting from the most recent consistent system state. To avoid any loss of application, the Slave Node during normal operation continuously maintains and updates a copy of the system state on the basis of informations provided to it by the Master Node. The application software is structured in atomic transactions. An atomic transaction is intended as a set of actions which updates the system state so that either all the actions have been executed (transaction commit), or none will have been (transaction abort). Therefore in case of a fault in the Master Node, the consistent system state is resumed by the Slave Node by aborting the not yet committed transactions and restoring them; it also completes the commit phases of the transactions which were committing in the Master Node when the fault has happened. The application software is supported by a run-time environment which makes transparent the duplicated configuration of the system.

Global States of a Distributed System

A global state of a distributed transaction system is consistent if no transactions are in progress. A global checkpoint is a transaction which must view a globally consistent system state for correct operation. We present an algorithm for adding global checkpoint transactions to an arbitrary distributed transaction system. The algorithm is nonintrusive in the sense that checkpoint transactions do not interfere with ordinary transactions in progress; however, the checkpoint transactions still produce meaningful results.