The Experts below are selected from a list of 2382 Experts worldwide ranked by ideXlab platform

Dhabaleswar K. Panda - One of the best experts on this subject based on the ideXlab platform.

  • crfs a lightweight user level filesystem for generic Checkpoint Restart
    International Conference on Parallel Processing, 2011
    Co-Authors: Xiangyong Ouyang, Raghunath Rajachandrasekar, Xavier Besseron, Hao Wang, Jian Huang, Dhabaleswar K. Panda
    Abstract:

    Checkpoint/Restart (C/R) mechanisms have been widely adopted by many MPI libraries [1 -- 3] to achieve fault-tolerance. However, a major limitation of such mechanisms is the intensive IO bottleneck caused by the need to dump the snapshots of all processes into persistent storage. Several studies have been conducted to minimize this overhead [4, 5], but most of these proposed optimizations are performed inside specific MPI stack or check pointing library or applications, hence they are not portable enough to be applied to other MPI stacks and applications. In this paper, we propose a filesystem based approach to alleviate this Checkpoint IO bottleneck. We propose a new filesystem, named Checkpoint-Restart File system (CRFS), which is a lightweight user-level filesystem based on FUSE (File system in User space). CRFS is designed with Checkpoint/Restart I/O traffic in mind to efficiently handle the concurrent write requests. Any software component using standard filesystem interfaces can transparently benefit from CRFS's capabilities. CRFS intercepts the Checkpoint file write system calls and aggregates them into fewer bigger chunks which are asynchronously written to the underlying filesystem for more efficient IO. CRFS manages a ?exible internal IO thread pool to throttle concurrent IO to alleviate IO contention for better IO performance. CRFS can be mounted over any standard filesystem like ext3, NFS and Lustre. We have implemented CRFS and evaluated its performance using three popular C/R capable MPI stacks: MVAPICH2, MPICH2 and OpenMPI. Experimental results show significant performance gains for all three MPI stacks. CRFS achieves up to 5.5X speedup in Checkpoint writing performance to Lustre filesystem. Similar level of improvements are also obtained with ext3 and NFS filesystems. To the best of our knowledge, this is the first such portable and light-weight filesystem designed for generic Checkpoint/Restart data.

  • ICPP - CRFS: A Lightweight User-Level Filesystem for Generic Checkpoint/Restart
    2011 International Conference on Parallel Processing, 2011
    Co-Authors: Xiangyong Ouyang, Raghunath Rajachandrasekar, Xavier Besseron, Hao Wang, Jian Huang, Dhabaleswar K. Panda
    Abstract:

    Checkpoint/Restart (C/R) mechanisms have been widely adopted by many MPI libraries [1 -- 3] to achieve fault-tolerance. However, a major limitation of such mechanisms is the intensive IO bottleneck caused by the need to dump the snapshots of all processes into persistent storage. Several studies have been conducted to minimize this overhead [4, 5], but most of these proposed optimizations are performed inside specific MPI stack or check pointing library or applications, hence they are not portable enough to be applied to other MPI stacks and applications. In this paper, we propose a filesystem based approach to alleviate this Checkpoint IO bottleneck. We propose a new filesystem, named Checkpoint-Restart File system (CRFS), which is a lightweight user-level filesystem based on FUSE (File system in User space). CRFS is designed with Checkpoint/Restart I/O traffic in mind to efficiently handle the concurrent write requests. Any software component using standard filesystem interfaces can transparently benefit from CRFS's capabilities. CRFS intercepts the Checkpoint file write system calls and aggregates them into fewer bigger chunks which are asynchronously written to the underlying filesystem for more efficient IO. CRFS manages a ?exible internal IO thread pool to throttle concurrent IO to alleviate IO contention for better IO performance. CRFS can be mounted over any standard filesystem like ext3, NFS and Lustre. We have implemented CRFS and evaluated its performance using three popular C/R capable MPI stacks: MVAPICH2, MPICH2 and OpenMPI. Experimental results show significant performance gains for all three MPI stacks. CRFS achieves up to 5.5X speedup in Checkpoint writing performance to Lustre filesystem. Similar level of improvements are also obtained with ext3 and NFS filesystems. To the best of our knowledge, this is the first such portable and light-weight filesystem designed for generic Checkpoint/Restart data.

  • application transparent Checkpoint Restart for mpi programs over infiniband
    International Conference on Parallel Processing, 2006
    Co-Authors: Qi Gao, Wei Huang, Dhabaleswar K. Panda
    Abstract:

    Ultra-scale computer clusters with high speed interconnects, such as InfiniBand, are being widely deployed for their excellent performance and cost effectiveness. However, the failure rate on these clusters also increases along with their augmented number of components. Thus, it becomes critical for such systems to be equipped with fault tolerance support. In this paper, we present our design and implementation of Checkpoint/Restart framework for MPI programs running over InfiniBand clusters. Our design enables low-overhead, application-transparent Checkpointing. It uses coordinated protocol to save the current state of the whole MPI job to reliable storage, which allows users to perform rollback recovery if the system runs into faulty states later. Our solution has been incorporated into MVAPICH2, an open-source high performance MPI-2 implementation over InfiniBand. Performance evaluation of this implementation has been carried out using NAS benchmarks, HPL benchmark, and a real-world application called GROMACS. Experimental results indicate that in our design, the overhead to take Checkpoints is low, and the performance impact for Checkpointing applications periodically is insignificant. For example, time for Checkpointing GROMACS is less than 0.3% of the execution time, and its performance only decreases by 4% with Checkpoints taken every minute. To the best of our knowledge, this work is the first report of Checkpoint/Restart support for MPI over InfiniBand clusters in the literature.

  • ICPP - Application-Transparent Checkpoint/Restart for MPI Programs over InfiniBand
    2006 International Conference on Parallel Processing (ICPP'06), 1
    Co-Authors: Qi Gao, Wei Huang, Dhabaleswar K. Panda
    Abstract:

    Ultra-scale computer clusters with high speed interconnects, such as InfiniBand, are being widely deployed for their excellent performance and cost effectiveness. However, the failure rate on these clusters also increases along with their augmented number of components. Thus, it becomes critical for such systems to be equipped with fault tolerance support. In this paper, we present our design and implementation of Checkpoint/Restart framework for MPI programs running over InfiniBand clusters. Our design enables low-overhead, application-transparent Checkpointing. It uses coordinated protocol to save the current state of the whole MPI job to reliable storage, which allows users to perform rollback recovery if the system runs into faulty states later. Our solution has been incorporated into MVAPICH2, an open-source high performance MPI-2 implementation over InfiniBand. Performance evaluation of this implementation has been carried out using NAS benchmarks, HPL benchmark, and a real-world application called GROMACS. Experimental results indicate that in our design, the overhead to take Checkpoints is low, and the performance impact for Checkpointing applications periodically is insignificant. For example, time for Checkpointing GROMACS is less than 0.3% of the execution time, and its performance only decreases by 4% with Checkpoints taken every minute. To the best of our knowledge, this work is the first report of Checkpoint/Restart support for MPI over InfiniBand clusters in the literature.

Gene Cooperman - One of the best experts on this subject based on the ideXlab platform.

  • CRAC: Checkpoint-Restart Architecture for CUDA with Streams and UVM
    arXiv: Distributed Parallel and Cluster Computing, 2020
    Co-Authors: Twinkle Jain, Gene Cooperman
    Abstract:

    The share of the top 500 supercomputers with NVIDIA GPUs is now over 25% and continues to grow. While fault tolerance is a critical issue for supercomputing, there does not currently exist an efficient, scalable solution for CUDA applications on NVIDIA GPUs. CRAC (Checkpoint-Restart Architecture for CUDA) is new Checkpoint-Restart solution for fault tolerance that supports the full range of CUDA applications. CRAC combines: low runtime overhead (approximately 1% or less); fast Checkpoint-Restart; support for scalable CUDA streams (for efficient usage of all of the thousands of GPU cores); and support for the full features of Unified Virtual Memory (eliminating the programmer's burden of migrating memory between device and host). CRAC achieves its flexible architecture by segregating application code (Checkpointed) and its external GPU communication via non-reentrant CUDA libraries (not Checkpointed) within a single process's memory. This eliminates the high overhead of inter-process communication in earlier approaches, and has fewer limitations.

  • NSCI: SI2-SSE: An Extensible Model to Support Scalable Checkpoint-Restart for DMTCP across Multiple Disciplines
    2018
    Co-Authors: Gene Cooperman
    Abstract:

    DMTCP (Distributed MultiThreaded Checkpointing) is a widely used package for transparent Checkpoint-Restart. Checkpoint-Restart saves to disk the state of a running process, and then to Restart (possibly on a new computer) the process where it left off. DMTCP has grown from a monolithic package to a highly adaptable package supporting HPC (e.g., MPI), GPUs, high-performance networks; and applications such as cyber-security, EDA, science, and engineering.

  • DMTCP: bringing interactive Checkpoint–Restart to Python
    Computational Science & Discovery, 2015
    Co-Authors: Kapil Arya, Gene Cooperman
    Abstract:

    DMTCP (Distributed MultiThreaded Checkpointing) is a mature Checkpoint–Restart package. It operates in user space without kernel privilege, and adapts to application-specific requirements through plugins. While DMTCP has been able to Checkpoint Python and IPython 'from the outside' for many years, a Python module has recently been created to support DMTCP. IPython support is included through a new DMTCP plugin. A Checkpoint can be requested interactively within a Python session or under the control of a specific Python program. Further, the Python program can execute specific Python code prior to Checkpoint, upon resuming (within the original process) and upon Restarting (from a Checkpoint image). Applications of DMTCP are demonstrated for: (i) Python-based graphics using virtual network client, (ii) a fast/slow technique to use multiple hosts or cores to check one (Cython Behnel S et al 2011 Comput. Sci. Eng. 13 31–39) computation in parallel, and (iii) a reversible debugger, FReD, with a novel reverse-expression watchpoint feature for locating the cause of a bug.

  • transparent Checkpoint Restart over infiniband
    High Performance Distributed Computing, 2014
    Co-Authors: Jiajun Cao, Gregory Kerr, Kapil Arya, Gene Cooperman
    Abstract:

    Transparently saving the state of the InfiniBand network as part of distributed Checkpointing has been a long-standing challenge for researchers. The lack of a solution has forced typical MPI implementations to include custom Checkpoint-Restart services that "tear down" the network, Checkpoint each node in isolation, and then re-connect the network again. This work presents the first example of transparent, system-initiated Checkpoint-Restart that directly supports InfiniBand. The new approach simplifies current practice by avoiding the need for a privileged kernel module. The generality of this approach is demonstrated by applying it both to MPI and to Berkeley UPC (Unified Parallel C), in its native mode (without MPI). Scalability is shown by Checkpointing 2,048 MPI processes across 128 nodes (with 16 cores per node). The run-time overhead varies between 0.8% and 1.7%. While Checkpoint times dominate, the network-only portion of the implementation is shown to require less than 100 milliseconds (not including the time to locally write application memory to stable storage).

  • Use of Checkpoint-Restart for complex HEP software on traditional architectures and Intel MIC
    Journal of Physics: Conference Series, 2014
    Co-Authors: Kapil Arya, Gene Cooperman, Andrea Dotti, Peter Elmer
    Abstract:

    Process Checkpoint-Restart is a technology with great potential for use in HEP workflows. Use cases include debugging, reducing the startup time of applications both in offline batch jobs and the High Level Trigger, permitting job preemption in environments where spare CPU cycles are being used opportunistically and efficient scheduling of a mix of multicore and single-threaded jobs. We report on tests of Checkpoint-Restart technology using CMS software, Geant4-MT (multi-threaded Geant4), and the DMTCP (Distributed Multithreaded Checkpointing) package. We analyze both single- and multi-threaded applications and test on both standard Intel x86 architectures and on Intel MIC. The tests with multi-threaded applications on Intel MIC are used to consider scalability and performance. These are considered an indicator of what the future may hold for many-core computing.

Andrew Lumsdaine - One of the best experts on this subject based on the ideXlab platform.

  • Checkpoint Restart enabled parallel debugging
    EuroMPI'10 Proceedings of the 17th European MPI users' group meeting conference on Recent advances in the message passing interface, 2010
    Co-Authors: Joshua Hursey, Paul Hargrove, Jeffrey M Squyres, Christopher January, Mark Oconnor, David Lecomber, Andrew Lumsdaine
    Abstract:

    Debugging is often the most time consuming part of software development. HPC applications prolong the debugging process by adding more processes interacting in dynamic ways for longer periods of time. Checkpoint/Restart-enabled parallel debugging returns the developer to an intermediate state closer to the bug. This focuses the debugging process, saving developers considerable amounts of time, but requires parallel debuggers cooperating with MPI implementations and Checkpointers. This paper presents a design specification for such a cooperative relationship. Additionally, this paper discusses the application of this design to the GDB and DDT debuggers, Open MPI, and BLCR projects.

  • EuroMPI - Checkpoint/Restart-enabled parallel debugging
    Recent Advances in the Message Passing Interface, 2010
    Co-Authors: Joshua Hursey, Paul Hargrove, Jeffrey M Squyres, Christopher January, David Lecomber, Mark O’connor, Andrew Lumsdaine
    Abstract:

    Debugging is often the most time consuming part of software development. HPC applications prolong the debugging process by adding more processes interacting in dynamic ways for longer periods of time. Checkpoint/Restart-enabled parallel debugging returns the developer to an intermediate state closer to the bug. This focuses the debugging process, saving developers considerable amounts of time, but requires parallel debuggers cooperating with MPI implementations and Checkpointers. This paper presents a design specification for such a cooperative relationship. Additionally, this paper discusses the application of this design to the GDB and DDT debuggers, Open MPI, and BLCR projects.

  • interconnect agnostic Checkpoint Restart in open mpi
    High Performance Distributed Computing, 2009
    Co-Authors: Joshua Hursey, Timothy I Mattox, Andrew Lumsdaine
    Abstract:

    Long running High Performance Computing (HPC) applications at scale must be able to tolerate inevitable faults if they are to harness current and future HPC systems. Message Passing Interface (MPI) level transparent Checkpoint/Restart fault tolerance is an appealing option to HPC application developers that do not wish to restructure their code. Historically, MPI implementations that provided this option have struggled to provide a full range of interconnect support, especially shared memory support. This paper presents a new approach for implementing Checkpoint/Restart coordination algorithms that allows the MPI implementation of Checkpoint/Restart to be interconnect agnostic. This approach allows an application to be Checkpointed on one set of interconnects (e.g., InfiniBand and shared memory) and be Restarted with a different set of interconnects (e.g., Myrinet and shared memory or Ethernet). By separating the network interconnect details from the Checkpoint/Restart coordination algorithm we allow the HPC application to respond to changes in the cluster environment such as interconnect unavailability due to switch failure, re-load balance on an existing machine, or migrate to a different machine with a different set of interconnects. We present results characterizing the performance impact of this approach on HPC applications.

  • HPDC - Interconnect agnostic Checkpoint/Restart in open MPI
    Proceedings of the 18th ACM international symposium on High performance distributed computing - HPDC '09, 2009
    Co-Authors: Joshua Hursey, Timothy I Mattox, Andrew Lumsdaine
    Abstract:

    Long running High Performance Computing (HPC) applications at scale must be able to tolerate inevitable faults if they are to harness current and future HPC systems. Message Passing Interface (MPI) level transparent Checkpoint/Restart fault tolerance is an appealing option to HPC application developers that do not wish to restructure their code. Historically, MPI implementations that provided this option have struggled to provide a full range of interconnect support, especially shared memory support. This paper presents a new approach for implementing Checkpoint/Restart coordination algorithms that allows the MPI implementation of Checkpoint/Restart to be interconnect agnostic. This approach allows an application to be Checkpointed on one set of interconnects (e.g., InfiniBand and shared memory) and be Restarted with a different set of interconnects (e.g., Myrinet and shared memory or Ethernet). By separating the network interconnect details from the Checkpoint/Restart coordination algorithm we allow the HPC application to respond to changes in the cluster environment such as interconnect unavailability due to switch failure, re-load balance on an existing machine, or migrate to a different machine with a different set of interconnects. We present results characterizing the performance impact of this approach on HPC applications.

  • the design and implementation of Checkpoint Restart process fault tolerance for open mpi
    International Parallel and Distributed Processing Symposium, 2007
    Co-Authors: Joshua Hursey, Timothy I Mattox, Jeffrey M Squyres, Andrew Lumsdaine
    Abstract:

    To be able to fully exploit ever larger computing platforms, modern HPC applications and system software must be able to tolerate inevitable faults. Historically, MPI implementations that incorporated fault tolerance capabilities have been limited by lack of modularity, scalability and usability. This paper presents the design and implementation of an infrastructure to support Checkpoint/Restart fault tolerance in the Open MPI project. We identify the general capabilities required for distributed Checkpoint/Restart and realize these capabilities as extensible frameworks within Open MPI's modular component architecture. Our design features an abstract interface for providing and accessing fault tolerance services without sacrificing performance, robustness, or flexibility. Although our implementation includes support for some initial Checkpoint/Restart mechanisms, the framework is meant to be extensible and to encourage experimentation of alternative techniques within a production quality MPI implementation.

Gerhard Wellein - One of the best experts on this subject based on the ideXlab platform.

  • craft a library for easier application level Checkpoint Restart and automatic fault tolerance
    IEEE Transactions on Parallel and Distributed Systems, 2019
    Co-Authors: Faisal Shahzad, Thomas Zeiser, Georg Hager, Jonas Thies, Moritz Kreutzer, Gerhard Wellein
    Abstract:

    In order to efficiently use the future generations of supercomputers, fault tolerance and power consumption are two of the prime challenges anticipated by the High Performance Computing (HPC) community. Checkpoint/Restart (CR) has been and still is the most widely used technique to deal with hard failures. Application-level CR is the most effective CR technique in terms of overhead efficiency but it takes a lot of implementation effort. This work presents the implementation of our C++ based library CRAFT (Checkpoint-Restart and Automatic Fault Tolerance), which serves two purposes. First, it provides an extendable library that significantly eases the implementation of application-level Checkpointing. The most basic and frequently used Checkpoint data-types are already part of CRAFT and can be directly used out of the box. The library can be easily extended to add more data-types. As means of overhead reduction, the library offers a built-in asynchronous Checkpointing mechanism and also supports the Scalable Checkpoint/Restart (SCR) library for node level Checkpointing. Second, CRAFT provides an easier interface for User-Level Failure Mitigation (ULFM) based dynamic process recovery, which significantly reduces the complexity and effort of failure detection and communication recovery mechanism. By utilizing both functionalities together, applications can write application-level Checkpoints and recover dynamically from process failures with very limited programming effort. This work presents the challenges addressed by the library, its design, and its use. The associated overheads are analyzed using benchmarks.

  • CRAFT: A Library for Easier Application-Level Checkpoint/Restart and Automatic Fault Tolerance
    IEEE Transactions on Parallel and Distributed Systems, 2019
    Co-Authors: Faisal Shahzad, Thomas Zeiser, Georg Hager, Jonas Thies, Moritz Kreutzer, Gerhard Wellein
    Abstract:

    In order to efficiently use the future generations of supercomputers, fault tolerance and power consumption are two of the prime challenges anticipated by the High Performance Computing (HPC) community. Checkpoint/Restart (CR) has been and still is the most widely used technique to deal with hard failures. Application-level CR is the most effective CR technique in terms of overhead efficiency but it takes a lot of implementation effort. This work presents the implementation of our C++ based library CRAFT (Checkpoint-Restart and Automatic Fault Tolerance), which serves two purposes. First, it provides an extendable library that significantly eases the implementation of application-level Checkpointing. The most basic and frequently used Checkpoint data-types are already part of CRAFT and can be directly used out of the box. The library can be easily extended to add more data-types. As means of overhead reduction, the library offers a built-in asynchronous Checkpointing mechanism and also supports the Scalable Checkpoint/Restart (SCR) library for node level Checkpointing. Second, CRAFT provides an easier interface for User-Level Failure Mitigation (ULFM) based dynamic process recovery, which significantly reduces the complexity and effort of failure detection and communication recovery mechanism. By utilizing both functionalities together, applications can write application-level Checkpoints and recover dynamically from process failures with very limited programming effort. This work presents the challenges addressed by the library, its design, and its use. The associated overheads are analyzed using benchmarks.

  • CRAFT: A library for easier application-level Checkpoint/Restart and Automatic Fault Tolerance
    arXiv: Distributed Parallel and Cluster Computing, 2017
    Co-Authors: Faisal Shahzad, Thomas Zeiser, Georg Hager, Jonas Thies, Moritz Kreutzer, Gerhard Wellein
    Abstract:

    In order to efficiently use the future generations of supercomputers, fault tolerance and power consumption are two of the prime challenges anticipated by the High Performance Computing (HPC) community. Checkpoint/Restart (CR) has been and still is the most widely used technique to deal with hard failures. Application-level CR is the most effective CR technique in terms of overhead efficiency but it takes a lot of implementation effort. This work presents the implementation of our C++ based library CRAFT (Checkpoint-Restart and Automatic Fault Tolerance), which serves two purposes. First, it provides an extendable library that significantly eases the implementation of application-level Checkpointing. The most basic and frequently used Checkpoint data types are already part of CRAFT and can be directly used out of the box. The library can be easily extended to add more data types. As means of overhead reduction, the library offers a build-in asynchronous Checkpointing mechanism and also supports the Scalable Checkpoint/Restart (SCR) library for node level Checkpointing. Second, CRAFT provides an easier interface for User-Level Failure Mitigation (ULFM) based dynamic process recovery, which significantly reduces the complexity and effort of failure detection and communication recovery mechanism. By utilizing both functionalities together, applications can write application-level Checkpoints and recover dynamically from process failures with very limited programming effort. This work presents the design and use of our library in detail. The associated overheads are thoroughly analyzed using several benchmarks.

  • craft a library for easier application level Checkpoint Restart and automatic fault tolerance
    arXiv: Distributed Parallel and Cluster Computing, 2017
    Co-Authors: Faisal Shahzad, Thomas Zeiser, Georg Hager, Jonas Thies, Moritz Kreutzer, Gerhard Wellein
    Abstract:

    In order to efficiently use the future generations of supercomputers, fault tolerance and power consumption are two of the prime challenges anticipated by the High Performance Computing (HPC) community. Checkpoint/Restart (CR) has been and still is the most widely used technique to deal with hard failures. Application-level CR is the most effective CR technique in terms of overhead efficiency but it takes a lot of implementation effort. This work presents the implementation of our C++ based library CRAFT (Checkpoint-Restart and Automatic Fault Tolerance), which serves two purposes. First, it provides an extendable library that significantly eases the implementation of application-level Checkpointing. The most basic and frequently used Checkpoint data types are already part of CRAFT and can be directly used out of the box. The library can be easily extended to add more data types. As means of overhead reduction, the library offers a build-in asynchronous Checkpointing mechanism and also supports the Scalable Checkpoint/Restart (SCR) library for node level Checkpointing. Second, CRAFT provides an easier interface for User-Level Failure Mitigation (ULFM) based dynamic process recovery, which significantly reduces the complexity and effort of failure detection and communication recovery mechanism. By utilizing both functionalities together, applications can write application-level Checkpoints and recover dynamically from process failures with very limited programming effort. This work presents the design and use of our library in detail. The associated overheads are thoroughly analyzed using several benchmarks.

  • A SURVEY OF Checkpoint/Restart TECHNIQUES ON DISTRIBUTED MEMORY SYSTEMS
    Parallel Processing Letters, 2013
    Co-Authors: Faisal Shahzad, Markus Wittmann, Thomas Zeiser, Georg Hager, Moritz Kreutzer, Gerhard Wellein
    Abstract:

    The road to exascale computing poses many challenges for the High Performance Computing (HPC) community. Each step on the exascale path is mainly the result of a higher level of parallelism of the basic building blocks (i.e., CPUs, memory units, networking components, etc.). The reliability of each of these basic components does not increase at the same rate as the rate of hardware parallelism. This results in a reduction of the mean time to failure (MTTF) of the whole system. A fault tolerance environment is thus indispensable to run large applications on such clusters. Checkpoint/Restart (C/R) is the classic and most popular method to minimize failure damage. Its ease of implementation makes it useful, but typically it introduces significant overhead to the application. Several efforts have been made to reduce the C/R overhead. In this paper we compare various C/R techniques for their overheads by implementing them on two different categories of applications. These approaches are based on parallel-file-system (PFS)-level Checkpoints (synchronous/asynchronous) and node-level Checkpoints. We utilize the Scalable Checkpoint/Restart (SCR) library for the comparison of node-level Checkpoints. For asynchronous PFS-level Checkpoints, we use the Damaris library, the SCR asynchronous feature, and application-based Checkpointing via dedicated threads. Our baseline for overhead comparison is the naïve application-based synchronous PFS-level Checkpointing method. A 3D lattice-Boltzmann (LBM) flow solver and a Lanczos eigenvalue solver are used as prototypical applications in which all the techniques considered here may be applied.

Dan Meng - One of the best experts on this subject based on the ideXlab platform.

  • dcr a fully transparent Checkpoint Restart framework for distributed systems
    International Conference on Cluster Computing, 2009
    Co-Authors: Zhigang Huo, Jingnan Cai, Dan Meng
    Abstract:

    Checkpoint/Restart has been widely used in computing systems for fault tolerance, job scheduling and system maintenance purposes. However, the lack of transparency has hindered adoptions of many implementations of it. In this paper, we present a fully transparent parallel Checkpoint/Restart framework, DCR, which takes the advantages of kernel-level Checkpointing method and TCP session preservation. DCR is fully transparent to application programmers and users. No source code modifications, recompilations, or system call interceptions are required. Because of the simplicity of its design and the dominance of TCP/IP in parallel applications, DCR can be readily deployed in widely scales of computers, from single CPU computers to large-scale clusters. A new on-demand blocking Checkpoint protocol, which makes use of the reliability mechanism of TCP, is proposed to eliminate the global synchronization. We have demonstrated the effectiveness and efficiency of DCR by multiple MPICH2 applications running on Dawning 5000A.

  • CLUSTER - DCR: A fully transparent Checkpoint/Restart framework for distributed systems
    2009 IEEE International Conference on Cluster Computing and Workshops, 2009
    Co-Authors: Zhigang Huo, Jingnan Cai, Dan Meng
    Abstract:

    Checkpoint/Restart has been widely used in computing systems for fault tolerance, job scheduling and system maintenance purposes. However, the lack of transparency has hindered adoptions of many implementations of it. In this paper, we present a fully transparent parallel Checkpoint/Restart framework, DCR, which takes the advantages of kernel-level Checkpointing method and TCP session preservation. DCR is fully transparent to application programmers and users. No source code modifications, recompilations, or system call interceptions are required. Because of the simplicity of its design and the dominance of TCP/IP in parallel applications, DCR can be readily deployed in widely scales of computers, from single CPU computers to large-scale clusters. A new on-demand blocking Checkpoint protocol, which makes use of the reliability mechanism of TCP, is proposed to eliminate the global synchronization. We have demonstrated the effectiveness and efficiency of DCR by multiple MPICH2 applications running on Dawning 5000A.