Snapify Snapshot Mechanism for Xeon Phi Offload Fault Tolerance
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Intel Xeon Phi coprocessors lack fault-tolerance support for offload applications, making it challenging to capture snapshots of processes and manage reliability and resource utilization effectively.
Innovation Solution
The implementation of Snapify, a set of extensions to the Xeon Phi's Many Integrated Core Platform Software Stack, which provides checkpoint and restart, process swapping, and migration capabilities by taking consistent snapshots of offload and host processes using a novel 3-way protocol and remote direct memory access (RDMA) data transfer mechanism.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If offload applications are executed on many-core coprocessors without fault-tolerance support, then execution speed and performance acceleration are improved, but system reliability and fault tolerance deteriorate
Solution Approach 1:
The patent implements preliminary checkpointing actions by capturing snapshots of offload application states before potential failures occur. The system periodically creates saved states of the application execution, enabling recovery to the most recent checkpoint without losing significant computational progress, thus maintaining both speed and reliability.
Solution Approach 2:
The patent creates copies of the application state through snapshot capture mechanisms. These snapshots are stored in memory or persistent storage, providing redundant copies that can be restored if the original execution fails, thereby improving fault tolerance while preserving execution efficiency.
2Reliability
If snapshots of offload processes are captured for fault tolerance, then system reliability is improved, but system complexity and overhead increase
Solution Approach 1:
The patent introduces an intermediary checkpointing mechanism that mediates between the offload application and the host system. This intermediary layer handles snapshot capture, storage, and restoration operations transparently, reducing the complexity burden on both the application and host while maintaining fault tolerance capabilities.
Solution Approach 2:
The patent extracts the checkpointing and snapshot management functionality as a separate, dedicated mechanism within the coprocessor system. By isolating this fault-tolerance infrastructure from the main application execution path, the system reduces overall complexity while preserving reliability benefits.
3Measurement precision
If communication between monitor process and offload process is disrupted, then fault detection capability is improved, but process stability and continuous execution deteriorate
Solution Approach 1:
The patent implements a feedback mechanism where the monitor process continuously checks communication status with offload processes. When communication disruption is detected, the system triggers appropriate recovery actions such as restoring from checkpoints or reinitializing processes, thereby maintaining continuous execution while preserving accurate fault detection.
Solution Approach 2:
The patent prepares cushioning measures in advance by maintaining checkpoint snapshots and recovery mechanisms ready before communication failures occur. This allows the system to quickly recover from disruptions without significant interruption to continuous execution, balancing fault detection precision with execution durability.
Data Source
AI summary
Methods are provided. A method includes capturing a snapshot of an offload process being executed by one or more many-core processors. The offload process is in signal communication with a host process being executed by a host processor. At least the offload is in signal communication with a monitoring process. The method further includes terminating the offload process on the one or more many-core processors, by the monitor process responsive to a communication between the monitor process and the offload processing being disrupted. The snapshot includes a respective predetermined minimum set of information required to restore a same state of the process as when the snapshot was taken.