Host Command Segmentation for Parallel Device Controller Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for transferring commands from a host to a device controller are inefficient, as they typically involve processing one command at a time, limiting processing speed and not providing a concrete method to divide commands into sub-commands for simultaneous execution.
Innovation Solution
A method and system that divide a command into sections of equal size, distribute them into groups, and restructure them as sub-commands, allowing for synchronous execution by the device controller, utilizing a segment size aligned with non-volatile memory pages and adhering to specifications like NVME for efficient command transfer.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If one command is transferred per transfer via interface, then the command transfer follows conventional protocol, but the processing speed is limited
Solution Approach 1:
The patent divides a single command into multiple sub-commands (first sub-command, second sub-command, etc.) that can be transferred simultaneously through the same interface. This segmentation allows the device controller to process multiple command portions in parallel, thereby increasing productivity without requiring additional interface transfers, while maintaining compliance with conventional transfer protocols.
2Speed
If a command is divided into multiple sub-commands, then processing speed increases, but the method to implement division and distribution is not concrete
Solution Approach 1:
The patent provides a concrete segmentation method by dividing commands into fixed-size sections (e.g., 64-byte segments) that correspond to memory page sizes. Each section is assigned to a specific sub-command group, creating a systematic and reproducible division process that reduces implementation complexity while enabling parallel processing.
Solution Approach 2:
The patent introduces a new dimension of command organization by distributing command sections across multiple sub-commands that can be executed in different task contexts. This dimensional transformation from sequential single-command processing to parallel multi-sub-command execution provides a feasible implementation path that increases speed without proportionally increasing complexity.
3Productivity
If multiple sub-commands are executed simultaneously, then processing efficiency improves, but temporary storage requirements increase
Solution Approach 1:
The patent optimizes storage usage by allocating memory resources locally to each sub-command based on its specific requirements. Instead of provisioning storage for all possible sub-commands simultaneously, the system dynamically allocates storage space for active sub-commands only, matching resource consumption to actual processing needs and reducing overall temporary storage requirements.
Solution Approach 2:
The patent employs periodic execution of sub-commands in structured batches rather than all-at-once simultaneous execution. Sub-commands are processed in organized groups (first batch, second batch, etc.), allowing temporary storage to be released and reused between batches. This periodic approach maintains high productivity while minimizing peak storage requirements through efficient resource recycling.
Data Source
AI summary
A method for transferring a command from a host to a device controller and a system using the method are disclosed. The method includes the steps of: A. determining a segment size; B. dividing a command into a number of sections each having a size the same as the segment size; C. sequentially distributing the sections to n groups; D. changing distributing order to a reverse order or keeping the same distributing order in step C if a cycle of distribution is finished while there are sections left for distributing; E. restructuring the section(s) in each group as a sub-command after all sections are distributed; and F. providing the sub-commands to a device controller synchronously.