Virtual Machine Memory Snapshotting via Persistent Memory Blocks
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional methods for taking snapshots of virtual machine memory require pausing the virtual machine, leading to significant performance delays due to the large data volumes and latency-sensitive nature of virtual memory operations.
Innovation Solution
The proposed solution involves allocating blocks in persistent memory, prioritizing and copying portions of virtual memory, and applying write requests while minimizing pauses, allowing snapshots to be taken without suspending the virtual machine's operations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional snapshot methods are used (pausing VM and copying memory to persistent storage), then data consistency is achieved, but VM performance deteriorates due to operation pauses and latency
Solution Approach 1:
The patent applies preliminary action by pre-allocating persistent memory blocks before snapshots are needed and establishing copy-on-write mappings in advance. When a snapshot is required, the system can immediately redirect writes to the persistent memory blocks without pausing the VM, as the infrastructure is already prepared. This eliminates the pause-time trade-off while maintaining data consistency through pre-configured memory mappings.
Solution Approach 2:
The patent introduces an intermediary layer between the VM's volatile memory and the persistent storage system. This intermediary persistent memory block acts as a buffer that captures memory states without requiring VM pauses. The hypervisor mediates memory access by redirecting writes to the persistent memory blocks while the VM continues running, thus maintaining both performance and data consistency.
2Measurement precision
If VM is paused for snapshotting, then complete memory state is captured, but operation delays occur due to large data volumes
Solution Approach 1:
The patent segments the memory snapshot process into multiple persistent memory blocks that can be populated incrementally. Instead of pausing the VM to capture the entire memory state at once, the system divides memory into segments and redirects writes to corresponding persistent memory blocks as they occur. This allows continuous VM operation while progressively capturing the complete memory state across multiple segments.
Solution Approach 2:
The patent enables continuity of useful action by allowing the VM to continue executing operations throughout the snapshot process. The persistent memory blocks continuously receive memory writes without interruption, capturing the complete memory state evolution while the VM runs uninterrupted. This eliminates operation delays while maintaining complete state capture through continuous write redirection.
3Reliability
If access to virtual memory is suspended for snapshotting, then data integrity is maintained, but latency-sensitive operations are impacted
Solution Approach 1:
The patent changes the parameter of memory access by transitioning from direct volatile memory access to redirected persistent memory block access. Instead of suspending access, the system modifies the access path by updating memory mappings to point to persistent memory blocks. This parameter change maintains data integrity through the redirect mechanism while preserving access speed by keeping the memory interface active and responsive.
Data Source
AI summary
Various embodiments set forth techniques for taking a snapshot of virtual memory of a virtual machine. One technique includes allocating, in a persistent memory, one or more blocks associated with a virtual memory; detecting a write request associated with a first portion of the virtual memory; in response to detecting the write request associated with the first portion, prioritizing the first portion; based on the prioritizing, copying the first portion into the one or more blocks in the persistent memory ahead of a second portion of the virtual memory; and after copying the first portion: applying the write request to the first portion; and copying the second portion into the one or more blocks in the persistent memory.