Communication-induced Checkpointing Research Articles

Scalable Communication-Induced Checkpointing Protocol with Little Overhead for Distributed Computing Environments

The existing communication-induced checkpointing protocols may not scale well due to their slow acquisition of the most recent timestamps of the next checkpoints of other processes. Accurate situation awareness with diversified information conveyance paths is needed to reduce the number of unnecessary forced checkpoints taken as few as possible. In this paper, a scalable communication-induced checkpointing protocol is proposed to considerably cut down the possibility of performing unnecessary forced checkpointing by exploiting the beneficial features of reliable communication channels. The protocol enables the sender of an application message to swiftly attain the most recent timestamp-related information of the next checkpoint of its receiver and accelerate the spread of the information to others, with little overhead. This behavioral feature may significantly elevate the accuracy of the awareness of the situations in which forced checkpointing is actually needed for useless checkpoint-free recovery. In addition, it generates no extra control message and no message logging overhead while significantly lessening the latency of message sending. Moreover, the protocol can always be operated under the non-deterministic execution model. The evaluation results indicate that the proposed protocol outperforms the existing ones at the reduced forced checkpointing overheads from 12.5% to 84.2%, and at the reduced total execution times from 2.5% to 11.5%.

Communication-Induced Checkpointing with Message Logging beyond the Piecewise Deterministic (PWD) Model for Distributed Systems

This paper introduces an effective communication-induced checkpointing protocol using message logging to enable the number of extra checkpoints to be far lower than the previous number. Even if a situation occurs in which it is decided that a process receiving a message has to perform forced checkpointing, our protocol allows the process to skip the forced checkpointing action if it recognizes that the state of its sender right before the receipt of the message is recoverable. Additionally, the communication-induced checkpointing protocol is thus not required to assume the piecewise deterministic model, despite being combined with message logging. This protocol can maintain these features by piggybacking a one-bit variable and an n-size vector on each message sent. Our simulation results verify our claim that the presented protocol performs much better than the representative optimized protocol with respect to the forced checkpointing frequency, regardless of the communication pattern.

Autonomic Web Services Based on Different Adaptive Quasi-Asynchronous Checkpointing Techniques

Companies, organizations and individuals use Web services to build complex business functionalities. Web services must operate properly in the unreliable Internet infrastructure even in the presence of failures. To increase system dependability, organizations, including service providers, adapt their systems to the autonomic computing paradigm. Strategies can vary from having one to all (S-CHOP, self-configuration, self-healing, self-optimization and self-protection) features. Regarding self-healing, an almost identical tool is communication-induced checkpointing (CiC), a checkpoint contains the state (heap, registers, stack, kernel state) for each process in the system. CiC is based on quasi-synchronous checkpointing where processes take checkpoints relying of control information piggybacked inside application messages; however, avoiding dangerous patterns such as Z-paths and Z-cycles; in such a regard the system takes forced checkpoints and avoids inconsistent states. CiC, unlike other tools, does not incur system performance, our proposal does not incur high overhead (as results show), and it has the advantage of being scalable. As we have shown in a previous work, CiC can be used to address dependability problems when dealing with Web services, as CiC mechanism work in a distributed and efficient manner. Therefore, in this work we propose an adaptable and dynamic generation of checkpoints to support fault tolerance. We present an alternative considering Quality of Service (QoS) criteria, and the different impact applications have on it. We propose taking checkpoints dynamically in case of failure or QoS degradation. Experimental results show that our approach has significantly reduced the generation of checkpoints of various well-known tools in the literature.

Efficient Communication Induced Checkpointing Protocol for Broadcast Network-based Distributed Systems

This paper proposes an enhanced Fully Informed Communication-Induced Checkpointing (FI-CIC) protocol to highly improve the possibility of detecting Z-cycle free patterns with no extra control message by utilizing the advantageous feature of the broadcast network in an effective way compared with the original FI-CIC protocol. Experimental results show that our protocol outperforms the previous one in terms of the number of forced checkpoints per process.

Autonomic Web Services Enhanced by Asynchronous Checkpointing

The evolution of business software technologies is constant and is becoming increasingly complex which leads to a great probability of software/hardware failures. Business processes are built based on web services as they allow the creation of complex business functionalities. To attack the problem of failures presented by the use of web services, organizations are extrapolating the autonomic computing paradigm to their business processes as it enables them to detect, diagnose, and repair problems improving dependability. Sophisticated solutions that increase system dependability exist, however, those approaches have drawbacks; for example, they affect system performance, have high implementation costs, and or they may jeopardize the scalability of the system. To facilitate evolution to self-management, systems must implement the monitoring, analyzing, planning, and execution (MAPE) control loop. An open challenge for MAPE loop is to carry out in an efficient manner the diagnosis and decision-making processes, recollecting data from which the system can detect, diagnose, and repair potential problems. Also, dealt by systems dependability, specifically as fault tolerant mechanisms. One useful tool for this purpose is the communication induced checkpointing (CiC). We use CiC in attacking the dependability problem of using web services in a distributed and efficient manner. First, we present an approach for web services compositions that supports fault tolerance based on the CiC mechanism. Second, we present an algorithm aimed at web services compositions based on an autonomic computing and checkpointing mechanism. Experimental results support the feasibility of this concept proposal.

Communication-aware Approaches for Transparent Checkpointing in Cloud Computing

Checkpoint/Restart or checkpointing is a fault tolerance technique which consists on taking frequent snapshots of an application, so that, in the event of a failure, the application's state can be restored and the application's execution continued without necessarily restarting it. The advent of Cloud Computing brought new challenges with regard to this technique as Fault Tolerance needs to be supplied transparently in environments running highly heterogeneous applications. In this context, we propose two new fully transparent checkpointing approaches. Both approaches use communication-induced checkpointing and guarantee a consistent view of the applications with regard to the outside world process. The first approach is uncoordinated and creates checkpoints for applications independently. The second approach is coordinated, and applications are first grouped into clusters before the checkpointing process is started. We have compared the proposed approaches with state of the art approaches. The results show that our approaches perform better when considering the communication latencies, and the overhead on the execution of the Virtual Machines.

Fault Tolerance Approach Based on Checkpointing towards Dependable Business Processes

The Business Process Execution Language (BPEL) has become one of the predominant standards for Web services compositions oriented to business processes. An important capability of BPEL is that it allows processes to interact synchronously/asynchronously with other BPEL processes and/or choreographies at large-scale. However, it is a well-known fact that a greater system complexity leads to a greater probability of software/hardware failures. To attack the problem of failures for interactive business processes more efficient fault tolerance mechanisms are need. Nowadays there exist sophisticated solutions that tackle business processes fault tolerance, however, present drawbacks such as they affect the systems performance, they have a high implementation costs, they can jeopardize the scalability of the system and/or they do not support asynchronous BPEL communication among processes. In this paper, we propose to attack the dependability problem in a distributed manner, a fault tolerant solution based on communication-induced checkpointing (CiC) for interactive BPEL processes.

Self-healing in autonomic distributed systems based on delayed communication-induced checkpointing

An autonomic distributed system is composed of geographically distributed autonomic components. One open challenge in autonomic computing is the efficient monitoring at runtime oriented towards the collection of information, from which the system itself will detect, diagnose, and repair problems that result from failures in software and/or hardware components. For this purpose, communication-induced checkpointing CIC can be a useful tool. CIC aims to form global consistent snapshots from which the system can recover. To achieve this, CIC solutions monitor exchanged information among the processes to identify dangerous checkpointing patterns. When a dangerous pattern is identified, it is broken by locally triggering a forced checkpoint. Nevertheless, not all triggered forced checkpoints are necessary. In this paper, we present a delayed CIC approach that reduces forced checkpoints by using triggering rules called safe checkpoint conditions. Finally, we present simulation results that show that our proposal is more efficient than other current solutions.

A fully informed model-based checkpointing protocol for preventing useless checkpoints

Checkpointing and rollback recovery are widely used techniques for handling failures in distributed systems. When processes involved in a distributed computation are allowed to take checkpoints independently without any coordination with each other, some or all of the checkpoints taken may not be part of any consistent global checkpoint, and hence, are useless for recovery. Communication-induced checkpointing algorithms allow processes to take checkpoints independently and also ensure that each checkpoint taken is part of a consistent global checkpoint by forcing processes to take some additional checkpoints. It is well known that it is impossible to design an optimal communication-induced checkpointing algorithm (i.e. a checkpointing algorithm that takes minimum number of forced checkpoints). So, researchers have designed communication-induced checkpointing algorithms that reduce forced checkpoints using different heuristics. In this paper, we present a communication-induced checkpointing algorithm which takes less number of forced checkpoints when compared to some of the existing checkpointing algorithms in its class.

A Scalable Communication-Induced Checkpointing Algorithm for Distributed Systems

A Scalable Communication-Induced Checkpointing Algorithm for Distributed Systems

Theoretical and experimental evaluation of communication-induced checkpointing protocols in [formula omitted] and [formula omitted] families

Communication-induced checkpointing (CIC) protocols help in bounding rollback propagation by ensuring that each checkpoint taken is useful, while at the same time allowing each process to take checkpoints independently. In this paper, we focus on the evaluation of CIC protocols belonging to two families, namely, the F E family and F Lazy - E family. We present both theoretical and experimental evaluation of the protocols belonging to these two families. The results of our experimental evaluation not only confirm the theoretical comparison but also reveals the fine differences between these protocols.

An enhanced model-based checkpointing protocol for preventing useless checkpoints

Checkpointing and rollback recovery are widely used techniques to handle failures in distributed computing systems. If there is no coordination among processes during checkpointing, processes may take useless checkpoints. Useless checkpoints are checkpoints that cannot be part of any consistent global checkpoint. In this paper, we propose a Communication-Induced checkpointing algorithm that prevents useless checkpoints by directing processes to take forced checkpoints more efficiently whenever a communication pattern that may lead to a Z-Cycle (ZC) is observed. Existence of ZC among checkpoints is known to be necessary and sufficient for making a checkpoint useless. The basic idea behind our algorithm can be extended to existing model-based checkpointing algorithms to reduce the number of forced checkpoints. We also compare the performance of our algorithm with an existing well-known algorithm.

An optimistic checkpointing and message logging approach for consistent global checkpoint collection in distributed systems

Checkpointing and rollback recovery are widely used techniques for achieving fault-tolerance in distributed systems. In this paper, we present a novel checkpointing algorithm which has the following desirable features: A process can independently initiate consistent global checkpointing by saving its current state, called a tentative checkpoint. Other processes come to know about a consistent global checkpoint initiation through information piggy-backed with the application messages or limited control messages if necessary. When a process comes to know about a new consistent global checkpoint initiation, it takes a tentative checkpoint after processing the message (not before processing the message as in existing communication-induced checkpointing algorithms). After a process takes a tentative checkpoint, it starts logging the messages sent and received in memory. When a process comes to know that every other process has taken a tentative checkpoint corresponding to current consistent global checkpoint initiation, it flushes the tentative checkpoint and the message log to the stable storage. The tentative checkpoints together with the message logs stored in the stable storage form a consistent global checkpoint. Two or more processes can concurrently initiate consistent global checkpointing by taking a new tentative checkpoint; in that case, the tentative checkpoints taken by all these processes will be part of the same consistent global checkpoint. The sequence numbers assigned to checkpoints by a process increase monotonically. Checkpoints with the same sequence number form a consistent global checkpoint. We also present the performance evaluation of our algorithm.

FINE: A Fully Informed aNd Efficient communication-induced checkpointing protocol for distributed systems

Communication-Induced Checkpointing ( CIC) protocols are classified into two categories in the literature: Index-based and Model-based. In this paper, we discuss two data structures being used in these two kinds of CIC protocols, and their different roles in helping the checkpointing algorithms to enforce Z-cycle Free ( ZCF) property. Then, we present our Fully Informed aNd Efficient ( FINE) communication-induced checkpointing algorithm, which not only has less checkpointing overhead than the well-known Fully Informed ( FI) CIC protocol proposed by Helary et al. but also has less message overhead. Performance evaluation indicates that our protocol performs better than many of the other existing CIC protocols.

Efficient global checkpointing algorithms for mobile agents

AbstractAs a widely used fault‐tolerance technique, checkpointing can be divided into three categories: independent checkpointing, coordinated checkpointing, and communication‐induced checkpointing (CIC). Independent checkpointing and coordinated checkpointing have been widely used in the design of fault‐tolerant mobile agent systems, but CIC has not attracted much attention. CIC is flexible, efficient, and scalable, which is desirable for mobile agent (MA) systems. Furthermore, CIC can be well integrated with independent checkpointing for reliable MA migrations. In this paper, we propose two CIC‐based checkpointing algorithms for MA systems. The Basic‐CIC algorithm is developed by applying the classic CIC technique to MA systems, while the deferred message processing‐based CIC (DM‐CIC) improves the time efficiency by deciding when to make the forced checkpointing. Simulation results show that DM‐CIC is stable and can help the system recover fast from failures. Copyright © 2007 John Wiley & Sons, Ltd.

On the Complexity of Removing Z-Cycles from a Checkpoints and Communication Pattern

Communication-induced checkpointing protocols are mechanisms used to produce checkpoints and communication patterns which enjoy desirable properties, such as No-Z-Cycle (NZC). NZC guarantees that each checkpoint can be part of a global consistent checkpoint. It would be nice to define communication-induced checkpointing protocols that enforce NZC, adding a minimum number of checkpoints to remove all the Z-cycles from the distributed computation. In this paper, we prove that this is impossible by formulating the minimum Z-cycle removal (MinZCR) problem and showing that there are no online competitive protocols for it. Moreover, we prove that the problem of enforcing NZC with an optimal number of checkpoints is difficult even if the whole input instance is known because its decision version is NP-complete. Finally, we also prove that MinZCR is difficult to approximate: it is APX-hard and this implies that no polynomial time approximation scheme exists for the problem

Performance comparisons of index‐based communication‐induced checkpointing protocols

Communication‐induced checkpointing (CIC) protocols can be used to prevent the domino effect. Such protocols that belong to the index‐based category have been shown to perform more efficiently. In this paper, some results of comparing index‐based CIC protocols are proposed. First, we prove that comparing several protocols based on the lazy indexing strategy can be simply based on their checkpoint‐inducing conditions. Next, we show that improved indexing strategies may not always yield a better performance than the classical strategy. Finally, we present a simulation study to verify our foregoing theoretical results. The simulation is conducted in the typical point‐to‐point computational environment. Influences of enhancements on indexing strategies and checkpoint‐inducing conditions for index‐based CIC protocols are discussed.

An Efficient Index-Based Checkpointing Protocol with Constant-Size Control Information on Messages

Communication-induced checkpointing (CIC) protocols can be used to prevent the domino effect. Such protocols that belong to the index-based category were shown to have a better performance. In this paper, we propose an efficient index-based CIC protocol. The fully informed (FI) protocol proposed in the literature has been known to be the best index-based CIC protocol that one can achieve since the optimal protocol needs to acquire the future information. We discover that the enhancement adopted by such a protocol rarely takes effect in practice. By discarding this enhancement, we obtain a new protocol, called NMMP. Simulation results show that our protocol is almost as efficient as FI in some typical computational environments. Especially, we demonstrate that the two protocols have the same behavior over a tree communication network. Surprisingly, NMMP only has to piggyback on each message control information of constant size, regardless of the number of processes.

More properties of communication-induced checkpointing protocols with rollback-dependency trackability

Rollback-Dependency Trackability (RDT) is a property stating that all rollback dependencies between local checkpoints are on-line trackable using a transitive dependency vector. In this paper, we introduce some properties of communication-induced checkpointing protocols possessing the RDT property. First, we demonstrate that wherever an RDT protocol detects a PCM-path in the checkpoint and communication pattern associated with a distributed computation, it can also detect an EPSCM-path there. Moreover, if this detected PCM-path is non-visibly doubled, its corresponding EPSCM-path is also non-visibly doubled. Next, we go on to prove that if an RDT protocol breaks all EPSCM-cycles and non-visibly doubled EPSCM-paths, it breaks all visibly doubled EPSCM-paths as well. From these results, we find that some RDT protocols actually have the same behavior for all possible patterns. Furthermore, we also construct patterns to show that a few RDT protocols are incomparable in terms of the number of forced checkpoints. Last but not least, we discuss a simulation study to verify our previous theoretical results.

MPI/FT: A Model-Based Approach to Low-Overhead Fault Tolerant Message-Passing Middleware

Fault tolerance in parallel systems has traditionally been achieved through a combination of redundancy and checkpointing methods. This notion has also been extended to message-passing systems with user-transparent process checkpointing and message logging. Furthermore, studies of multiple types of rollback and recovery have been reported in literature, ranging from communication-induced checkpointing to pessimistic and synchronous solutions. However, many of these solutions incorporate high overhead because of their inability to utilize application level information. This paper describes the design and implementation of MPI/FT, a high-performance MPI-1.2 implementation enhanced with low-overhead functionality to detect and recover from process failures. The strategy behind MPI/FT is that fault tolerance in message-passing middleware can be optimized based on an application's execution model derived from its communication topology and parallel programming semantics. MPI/FT exploits the specific characteristics of two parallel application execution models in order to optimize performance. MPI/FT also introduces the self-checking thread that monitors the functioning of the middleware itself. User aware checkpointing and user-assisted recovery are compatible with MPI/FT and complement the techniques used here. This paper offers a classification of MPI applications for fault tolerant MPI purposes and MPI/FT implementation discussed here provides different middleware versions specifically tailored to each of the two models studied in detail. The interplay of various parameters affecting the cost of fault tolerance is investigated. Experimental results demonstrate that the approach used to design and implement MPI/FT results in a low-overhead MPI-based fault tolerant communication middleware implementation.