Storage Configuration Object Suspension for Concurrent IO Processing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional storage systems face performance issues due to high memory consumption and lock contention when using counter-based barrier mechanisms for concurrent IO command processing, and splitting counters per thread increases memory usage unnecessarily.
Innovation Solution
The method involves suspending configuration objects by generating a bitmap to track IO commands, allowing pre-modified commands to be processed before modification, thereby reducing the need for concurrent updates and minimizing memory overhead.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If a command counter per configuration object is used to protect against concurrent updates, then thread safety is improved, but processing speed deteriorates due to lock contention and cache line contention
Solution Approach 1:
The patent segments the command counter into multiple per-thread counters instead of using a single shared counter. Each thread maintains its own counter, eliminating the need for locks and atomic operations when updating counters. This segmentation removes the bottleneck of concurrent update protection while maintaining thread safety through individual thread ownership of counters.
Solution Approach 2:
The patent introduces a bitmap as an intermediary data structure to track which configuration objects have pending IO commands. The bitmap serves as a mediator between the command submission mechanism and the modification process, allowing the system to efficiently determine whether it's safe to modify a configuration object without requiring complex locking protocols.
2Productivity
If the command counter is split to a counter per thread, then lock contention is eliminated, but memory consumption increases
Solution Approach 1:
The patent merges the counter functionality with the existing per-thread command queue structure. Instead of allocating separate counter memory for each thread, the counter is integrated into the thread's existing command processing data structures. This merging approach eliminates the need for additional per-thread counter memory while maintaining the benefits of per-thread counting.
Solution Approach 2:
The patent discards the traditional approach of maintaining persistent per-thread counters in memory. Instead, counter values are recovered and reused from the thread's command queue metadata structure. When threads complete their command processing, the counter resources are recovered and made available for reuse, preventing permanent memory allocation for each thread's counter.
3Measurement precision
If arithmetic operations are performed for each command even without suspend requests, then command counting accuracy is improved, but processing overhead increases
Solution Approach 1:
The patent applies partial action by performing arithmetic operations only when necessary - specifically when suspend requests are active or when determining whether configuration objects can be modified. The bitmap mechanism allows the system to skip detailed counter checks for commands that don't require suspension, reducing unnecessary arithmetic operations while maintaining accuracy where needed.
Solution Approach 2:
The bitmap data structure serves itself by providing built-in tracking of pending commands without requiring additional verification operations. The bitmap automatically reflects the state of command processing, eliminating the need for separate counter validation arithmetic operations. The structure is self-updating and self-describing, reducing processing overhead.
Data Source
AI summary
A method, computer program product, and computing system for receiving a plurality of input/output (IO) commands for a plurality of configuration objects of a storage system. A modification command for a configuration object of the plurality of configuration objects may be received. The configuration object may be suspended in response to receiving the modification command. One or more IO commands directed to the suspended configuration object from the plurality of IO commands may be processed before the configuration object is modified.