Storage Controller Command Peek Logic for Latency Reduction
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Non-volatile memory-based storage devices face inefficiencies in command processing due to resource bottlenecks, particularly when shared resources are exhausted, leading to increased latency and decreased processing efficiency.
Innovation Solution
A device controller is introduced that includes command fetch logic, preprocessing logic, and processing logic. This controller peeks commands from submission queues without moving the head pointer, determines their executability based on device resource status, and allocates resources only when commands are executable, thereby optimizing resource usage and prioritizing executable commands.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If the storage device fetches a large number of write commands, then the write resources are utilized, but the shared resources are occupied for longer periods causing read commands to be blocked
Solution Approach 1:
The patent segments the command processing into distinct phases: peeking commands from submission queues without moving the head pointer, determining executability based on resource status, and only fetching commands that are executable. This segmentation allows read and write commands to be processed independently without blocking each other, resolving the contradiction between write throughput and read latency.
Solution Approach 2:
The patent applies preliminary action by peeking at commands from submission queues before fetching them. The command fetch logic peeks at the head of submission queues to determine if commands are executable based on current resource availability, and only fetches commands that pass this preliminary check. This prevents blocking read commands while still allowing write commands to be processed when resources are available.
2Reliability
If the storage device blocks shared resources until write resources are available, then write commands can be processed, but read commands are prevented from executing
Solution Approach 1:
The patent introduces dynamic resource allocation where the command fetch logic continuously monitors resource availability and adjusts its behavior accordingly. When shared resources are available, read commands can be fetched and executed immediately. When shared resources are occupied by write commands, the system dynamically switches to processing only write commands without blocking read command execution attempts, thereby maintaining overall processing efficiency while ensuring write command reliability.
3Device complexity
If the storage device processes commands sequentially without peeking, then the processing logic is simple, but commands with resource conflicts cause pipeline bottlenecks
Solution Approach 1:
The patent applies preliminary action by having the command fetch logic peek at commands from submission queues before fetching them. The command preprocessing logic determines whether peeked commands are executable based on current resource availability, and only fetches commands that pass this preliminary check. This preliminary filtering action prevents resource conflicts from causing pipeline bottlenecks while maintaining relatively simple processing logic.
Solution Approach 2:
The patent implements skipping by allowing the command fetch logic to skip fetching commands that would cause resource conflicts. By peeking at commands first and determining executability before fetching, the system can skip over commands that would block the pipeline, thereby maintaining high processing throughput without significantly increasing logic complexity.
Data Source
AI summary
A device controller of a storage device including a non-volatile memory peeks a command from a submission queue, and determines whether the peeked command is executable based on a status of device resources. In response to determining that the command is executable, the device controller fetches the command, allocates the device resources to the fetched command, and executes the command.