Sub-IU Write Aggregation for Atomic Log Ordering in SSDs
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing storage protocols do not guarantee atomicity and ordering of small writes to non-volatile memory, especially in enterprise SSDs, leading to potential overlap and incorrect sequencing of log data.
Innovation Solution
Implementing a sub-indirection unit (IU) write ordering mechanism by aggregating log data in a local cache, determining if a write command needs to be aggregated based on host hints or sequential patterns, and ensuring the data is written atomically and sequentially before sending it to the memory device.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If small writes are performed directly to non-volatile memory without aggregation, then write speed is improved, but atomicity and ordering of log data cannot be guaranteed
Solution Approach 1:
The patent implements preliminary action by aggregating small log writes in a volatile cache buffer before committing them to non-volatile memory as full IU-sized atomic writes. The controller collects multiple small writes, aggregates them into a complete indirection unit, and then performs a single atomic write operation to ensure both speed efficiency and ordering guarantees.
Solution Approach 2:
The patent introduces a volatile cache buffer as an intermediary between the host and non-volatile memory. This intermediary buffer temporarily holds small log writes and enables their aggregation into properly sized atomic units before writing to NVM, thus mediating between the host's small write requirements and the storage medium's atomic write requirements.
2Reliability
If log writes are aggregated into full IU-sized units, then atomicity is guaranteed, but write amplification increases
Solution Approach 1:
The patent applies merging by combining multiple small log writes into a single full IU-sized write operation. Instead of writing each small log entry separately (which would cause write amplification), the controller merges multiple small writes that fit within one indirection unit and writes them together as a single atomic operation, reducing total write volume while maintaining atomicity.
Solution Approach 2:
The controller performs preliminary aggregation of small writes in the cache buffer before writing to NVM. By collecting and combining small writes into full IU units in advance, the system avoids the write amplification that would result from writing each small unit separately, while still ensuring atomicity through the aggregation process.
3Device complexity
If host-side caching is implemented to achieve sub-IU write ordering, then device complexity is reduced, but host memory usage increases
Solution Approach 1:
The patent implements self-service by enabling the storage device controller to autonomously perform write aggregation and ordering without requiring host-side caching infrastructure. The controller independently manages the volatile cache buffer, aggregates writes, and ensures proper ordering, thereby reducing device complexity while avoiding increased host memory requirements.
Solution Approach 2:
The volatile cache buffer acts as an intermediary managed by the storage device rather than the host. This shifts the caching burden from host memory to device-managed buffer memory, reducing host memory usage while maintaining the aggregation functionality needed for sub-IU write ordering.
Data Source
AI summary
Sub indirection unit (IU) write ordering can be achieved by aggregating log data in local cache. The cache is IU sized. If a write command is analyzed and determined to need to be aggregated, through a host provided hint or perhaps a determination of sequential write commands, the log data is placed in the local cache to aggregate log data. The log data is aggregated in order both sequentially and atomically. The log data is written to a cache and then, when additional log data is to be aggregated with the log data, copied to a new cache along with the additional log data so that the order can be maintained. Sufficient log data is aggregated until IU size is reached at which time the entire log data of a full IU sized cache is sent to the memory device.