Fault Tolerant Disaggregated Memory Span Management
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Disaggregated datacenter memory systems lack effective fault tolerance mechanisms, leading to high failure rates and inefficient resource allocation due to unpredictable server failures and high storage overheads in replication-based approaches.
Innovation Solution
A low-latency, low-overhead fault-tolerant framework that uses span-based management and erasure coding, employing one-sided remote memory accesses (RMAs) for efficient swapping and compaction techniques to minimize network overheads and fragmentation.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If in-memory replication is used on remote nodes for fault tolerance, then reliability is improved, but storage overhead and network utilization during writes or failure recovery increase significantly
Solution Approach 1:
The patent changes the fundamental parameter of fault tolerance implementation from replication (storing full copies) to erasure coding (storing encoded fragments with parity information). This allows the system to maintain reliability while reducing storage overhead from 100% (replication) to approximately 33-50% (erasure coding with k:n ratio), directly resolving the contradiction between reliability and storage overhead.
Solution Approach 2:
Instead of copying entire data objects for fault tolerance, the patent uses erasure coding to create encoded representations where original data can be reconstructed from fragments and parity information. This partial copying approach maintains fault tolerance while minimizing the quantity of stored redundant information.
2Quantity of substance
If erasure coding is used with single memory page striping across multiple remote nodes, then storage overhead is reduced, but access latency increases due to multiple network fetches required for page reconstruction
Solution Approach 1:
The patent segments memory into fixed-size spans (e.g., 2MB) and assigns complete spans to individual remote nodes rather than striping single pages across nodes. This segmentation approach allows a compute node to retrieve an entire span in a single network fetch, eliminating the latency penalty of multiple small fetches while maintaining efficient storage utilization through erasure coding across multiple spans.
Solution Approach 2:
The patent changes the granularity dimension from page-level (4KB) to span-level (2MB), operating at a higher dimension of memory organization. This dimensional change allows erasure coding to operate across spans while enabling single-fetch retrieval of entire spans, resolving the latency issue inherent in page-level striping.
3Quantity of substance
If disaggregated memory is implemented without fault tolerance mechanisms, then storage overhead is minimized, but the failure rate of applications increases due to unpredictable server failures
Solution Approach 1:
The patent implements erasure coding with configurable redundancy ratios (e.g., k:n where k is data spans and n is total spans including parity), allowing the system to tune the balance between storage overhead and fault tolerance. This parameterizable approach enables minimal yet effective protection against server failures without excessive storage consumption.
4Reliability
If span-based management with erasure coding is implemented, then fault tolerance efficiency is improved, but memory usage increases compared to simple replication
Solution Approach 1:
The patent applies erasure coding to spans rather than individual pages, using partial redundancy at the span level. This partial action approach provides fault tolerance for the most commonly accessed memory units while avoiding the overhead of protecting every single page, optimizing the balance between fault tolerance efficiency and memory usage.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Aspects of the disclosure are directed to a low-latency, low-overhead fault tolerant remote memory framework, which packs similar-size in-memory objects into individual page-aligned spans and applies erasure coding on these spans. The framework fully utilizes efficient one-sided remote memory accesses (RMAs) to swap spans in and out using minimal network input/outputs (I/Os), with compaction techniques that reduce remote memory fragmentation. The framework can achieve lower tail latency and higher application performance compared to other fault tolerance solutions, at the cost of potentially more memory usage.