Purgeable Memory Checkpointing for Virtual Machine Failover
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current checkpoint-based high-availability techniques for virtual machines are bottlenecked by the need to transfer entire pages of modified memory, leading to network bandwidth consumption and performance issues due to page-level granularity, where only modified pages are detected and transferred, causing faults and additional overhead.
Innovation Solution
Implementing a system that designates portions of memory as 'purgeable' which can be reconstructed by the application, reducing the data forwarded during checkpoints to a secondary host, allowing only essential memory changes to be transferred, and reconstructing purgeable memory upon failover.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If page-level memory transfer is used during checkpoints, then high-availability failover capability is ensured, but network bandwidth consumption increases and performance deteriorates
Solution Approach 1:
The patent segments memory into two distinct categories: essential memory that must be transferred to ensure failover capability, and purgeable memory that can be reconstructed. This segmentation allows selective transfer of only necessary data, reducing network bandwidth consumption while maintaining high-availability functionality.
Solution Approach 2:
The patent extracts and identifies purgeable memory portions that can be reconstructed by the application after failover. By separating these non-essential memory segments from the critical ones, the system transfers only the minimum necessary data over the network, directly reducing bandwidth consumption while preserving failover capability.
2Reliability
If all memory changes are transferred during checkpoints, then complete state recovery is achieved, but data transfer overhead and network bandwidth consumption increase
Solution Approach 1:
The patent applies partial action by transferring only a subset of memory changes—specifically, those in essential memory regions—rather than transferring all memory changes. The application can reconstruct the remaining purgeable memory portions after failover, achieving sufficient state recovery with reduced transfer overhead and time.
Solution Approach 2:
The patent changes the parameter of memory transfer completeness from 100% (all memory) to a selective subset (essential memory only). By modifying this parameter and relying on application-side reconstruction capabilities, the system reduces data transfer overhead and network bandwidth consumption while maintaining adequate state recovery.
3Measurement precision
If page-level granularity is used for memory modification detection, then modified pages can be accurately identified, but performance bottlenecks occur due to frequent faults and transfers
Solution Approach 1:
The patent applies local quality by treating different memory regions differently: essential memory regions are monitored with page-level granularity for accurate modification detection, while purgeable memory regions are excluded from transfer. This localized approach maintains detection accuracy where needed while improving overall checkpoint performance by reducing unnecessary transfers.
Data Source
AI summary
A data processing system provides checkpoint high-available for an application in a virtualized environment with reduced network demands. An application executes on a primary host machine comprising a first virtual machine. A virtualization module receives a designation from the application of a portion of the memory of the first virtual machine as purgeable memory, where the purgeable memory can be reconstructed by the application when the purgeable memory is unavailable. Changes are tracked to a processor state and to a remaining portion that is not purgeable memory and the changes are periodically forwarded at checkpoints to a secondary host machine. In response to an occurrence of a failure condition on the first virtual machine, the secondary host machine is signaled to continue execution of the application by using the forwarded changes to the remaining portion of the memory and by reconstructing the purgeable memory.