Dynamic Submission Queue Arbitration for Blocked Commands
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing data storage apparatuses face inefficiencies in managing command execution due to limited resources and varying host device demands, leading to suboptimal utilization of storage resources and potential deadlocks, particularly with FUSED command operations.
Innovation Solution
Implement a data storage apparatus with a processor that can fetch commands from submission queues, determine if execution is blocked, and control command execution based on blocking conditions, including internal and external events, to optimize resource use and prevent deadlocks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Device complexity
If static arbitration logic is used to select commands from submission queues, then device complexity is reduced, but productivity decreases due to inability to dynamically adapt to varying host demands and resource availability
Solution Approach 1:
The patent implements dynamic arbitration logic that adapts to varying host demands and storage resource availability. The system monitors resource utilization and dynamically adjusts command selection from submission queues, transitioning from static round-robin or weighted round-robin approaches to a dynamic system that can prioritize commands based on current system state, thereby improving productivity without excessive complexity increase
Solution Approach 2:
The system incorporates feedback mechanisms that monitor storage resource availability and host demand patterns. This feedback is used to adjust arbitration decisions in real-time, allowing the system to optimize command processing throughput by selecting commands from submission queues based on current resource capacity and demand characteristics
2Productivity
If multiple commands are held in command slots awaiting execution, then productivity is improved through batch processing, but device complexity increases due to resource management overhead
Solution Approach 1:
The patent implements a command slot mechanism that pre-loads and holds multiple commands awaiting execution. By preparing commands in advance and holding them in dedicated slots, the system enables efficient batch processing when resources become available, improving productivity through reduced overhead per command while managing complexity through structured slot allocation
Solution Approach 2:
The system divides command storage into discrete command slots, segmenting the resource management task into manageable units. Each slot can be independently tracked and managed, simplifying the overall resource management complexity while enabling efficient batch processing of multiple commands
3Reliability
If commands are executed in strict FIFO order from submission queues, then reliability is improved through deterministic behavior, but productivity decreases due to inability to prioritize urgent commands
Solution Approach 1:
The patent implements dynamic command prioritization that balances deterministic FIFO execution with urgent command handling. The system can dynamically adjust priority levels based on command type, host demand, and resource availability, allowing urgent commands to be executed ahead of lower-priority commands while maintaining overall system reliability through controlled deviations from strict FIFO order
Data Source
AI summary
The disclosure relates in some aspects to managing the fetching and execution of commands stored in submission queues. For example, execution of a command may be blocked at a data storage apparatus due to an internal blocking condition (e.g., a large number of commands of a particular type are pending for execution at the data storage device). As another example, execution of a command may be blocked at a data storage apparatus due to an external blocking condition (e.g., a host device may specify that certain commands are to be executed immediately one after another). The disclosure relates in some aspects to controlling how commands are fetched and executed so that commands that cannot be executed by the data storage apparatus in the near future do not prevent other commands (that are not subject to the same blocking condition) from being executed.