Storage Request Coordination via Claim-Then-Execute Protocol
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In a multi-processor, multi-thread environment, traditional data storage systems face inefficiencies due to the need for sequential processing of storage requests, which can lead to lengthy processing times and reduced performance, especially when multiple processors or threads need to access a common data storage device.
Innovation Solution
An apparatus and method that coordinates storage requests using modules such as an append/invalidate module and a restructure module, allowing for the interleaving of processing steps across multiple processors or threads, ensuring proper update order and enabling parallel execution of storage requests, even when they relate to a common file or object.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional file servers sequentially process storage requests to ensure data integrity, then data consistency is maintained, but processing time increases and productivity decreases
Solution Approach 1:
The patent divides the storage request processing into separate phases: a claim phase where processors claim metadata blocks, and an execute phase where actual storage operations occur. This segmentation allows multiple processors to proceed in parallel without interfering with each other, resolving the contradiction between sequential processing requirements for data consistency and parallel processing needs for productivity.
Solution Approach 2:
The patent implements preliminary claim actions where processors must claim metadata blocks before executing storage operations. This preliminary action ensures that each processor has exclusive access to the metadata it needs, allowing subsequent parallel execution of storage operations while maintaining data consistency through the claim-then-execute protocol.
2Reliability
If storage requests are processed sequentially to maintain proper update order, then data integrity is preserved, but processing time increases
Solution Approach 1:
The patent segments the storage operation into claim and execute phases, allowing multiple processors to claim metadata blocks in parallel while maintaining update order integrity through the structured claim-then-execute protocol. This eliminates the need for sequential processing while preserving data integrity.
Solution Approach 2:
The patent introduces metadata blocks as intermediary structures that mediate between multiple processors. Processors claim these metadata blocks to coordinate access, and the metadata structure itself enforces proper update ordering during the execute phase, allowing parallel processing while maintaining integrity.
3Productivity
If multiple processors access common data simultaneously, then productivity increases through parallel processing, but coordination complexity increases
Solution Approach 1:
The patent segments the coordination mechanism into simple claim and execute phases, avoiding complex coordination protocols. Each processor independently claims metadata blocks and executes operations in parallel, with the system automatically managing conflicts through the phased approach, thus reducing coordination complexity while enabling parallel processing.
Solution Approach 2:
The patent implements self-service coordination where processors automatically manage their own access to shared data by claiming metadata blocks and executing operations independently. The system handles conflict resolution automatically through the claim-then-execute protocol, eliminating the need for complex external coordination mechanisms.
Data Source
AI summary
An apparatus, system, and method are disclosed for coordinating storage requests in a multi-processor/multi-thread environment. An append/invalidate module generates a first append data storage command from a first storage request and a second append data storage command from a second storage request. The storage requests overwrite existing data with first and second data including where the first and second data have at least a portion of overlapping data. The second storage request is received after the first storage request. The append/invalidate module updates an index by marking data being overwritten as invalid. A restructure module updates the index based on the first data and updates the index based on the second data. The updated index is organized to indicate that the second data is more current than the first data regardless of processing order. The modules prevent access to the index until the modules have completed updating the index.