RAID Deferred Parity Updates for NVMe Controller Scalability
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
RAID storage systems face scaling issues when used with NVMe storage devices due to performance mismatch between NVMe devices and RAID storage controllers, leading to limitations in managing multiple NVMe devices.
Innovation Solution
Implementing a method for deferred parity data update operations in RAID storage systems, where RAID primary data storage devices perform XOR operations and send completion messages to the RAID storage controller, allowing the RAID parity data storage device to update parity data independently, thus offloading parity updates from the RAID storage controller and enabling better scalability with high-performance NVMe devices.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If conventional RAID storage controllers are used with NVMe storage devices, then data redundancy and reliability are maintained, but the system cannot scale to manage multiple NVMe devices due to performance bottlenecks
Solution Approach 1:
The patent segments the RAID functionality into two parts: the RAID storage controller maintains basic management functions while the NVMe storage devices themselves perform parity update operations. This segmentation allows the controller to manage multiple devices without being bottlenecked by parity calculation, as each NVMe device independently handles its own parity updates, thereby resolving the scaling limitation.
Solution Approach 2:
The NVMe storage devices are empowered to perform their own parity update operations autonomously without requiring intensive intervention from the RAID storage controller. Each NVMe device independently calculates and applies parity updates to its data blocks, enabling the system to scale to many devices since the controller only needs to initiate and coordinate these self-service operations rather than execute them all centrally.
2Productivity
If parity updates are performed synchronously with data writes, then data consistency is maintained, but system performance and throughput are reduced due to the bottleneck at the RAID controller
Solution Approach 1:
The system performs preliminary actions by having NVMe storage devices calculate parity values and prepare parity update blocks in advance, before the actual parity update is committed. The controller initiates parity update operations that the NVMe devices execute autonomously, allowing data writes and parity updates to proceed in parallel rather than sequentially, thereby improving throughput while maintaining consistency through pre-coordinated operations.
Solution Approach 2:
The patent introduces an intermediary mechanism where NVMe storage devices act as intermediaries between the RAID controller and the actual parity update execution. The controller sends parity update commands to NVMe devices, which then independently perform the parity calculations and updates. This intermediary role allows the controller to maintain data consistency oversight while delegating performance-intensive operations, resolving the contradiction between consistency and throughput.
3Adaptability or versatility
If the RAID controller manages all parity update operations centrally, then data integrity is ensured, but the controller becomes a performance bottleneck that limits system scalability
Solution Approach 1:
NVMe storage devices perform parity update operations autonomously without requiring continuous controller intervention. Each device independently receives parity update commands from the controller, calculates the necessary parity values, and applies updates to its local data blocks. This self-service capability dramatically reduces controller management overhead and enables the system to scale to many more devices, as the controller only needs to issue commands rather than execute operations.
Solution Approach 2:
The patent segments parity update execution authority from the RAID controller to the individual NVMe storage devices. The controller retains responsibility for initiating and coordinating parity updates, while actual parity calculation and application are segmented to each NVMe device that executes them locally. This segmentation distributes the computational burden across multiple devices, improving scalability while the controller maintains overall data integrity through coordination.
Applied Scientific Principles
This section explains which scientific principles are used to turn an abstract innovation direction into a practical engineering solution.
Function Achieved in This Case
This approach enhances the RAID storage controller's ability to manage multiple NVMe devices by offloading parity updates, improving system scalability and performance without requiring significant updates to existing RAID storage systems.
Implementation Method 1
perform an XOR operation on the first primary data in the first storage subsystem and the second primary data in the first buffer subsystem to produce first interim parity data
Implementation Method 2
write, to the first buffer subsystem via a first Direct Memory Access (DMA) operation from a host system, second primary data
Data Source
AI summary
A RAID storage-device-assisted deferred parity data update system includes a RAID primary data drive that retrieves second primary data via a DMA operation from host system, and XOR's it with first primary data to produce first interim parity data, which causes a RAID storage controller device to provide an inconsistent parity stripe journal entry in the host system. The RAID primary data drive then retrieves third primary data via a DMA operation from the host system, XORs it with the second primary data and the first interim parity data to produce second interim parity data. A RAID parity data drive retrieves the second interim parity data via a DMA operation, and XORs it with first parity data to produce second parity data that it uses to overwrite the first parity data, which causes the RAID storage controller device to remove the inconsistent parity stripe journal entry from the host system.