Staggered QLC Programming Across Multiple Dies
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Foggy-fine programming in data storage devices is inefficient due to the need for multiple phases of writing, including foggy and fine programming, which requires significant data redundancy and protection against power loss, and is not effectively managed across multiple dies and super-devices.
Innovation Solution
Implementing a staggered programming approach where data passes through an encoder and DRAM before being written to SLC and MLC memory, with a ratio of SLC:foggy:fine writing of 4:1:1, and ensuring sufficient XOR context management by staggering programming across multiple dies and super-devices, allowing only four XOR parity contexts across 64 dies.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If foggy-fine programming is performed with multiple page transfers for each die, then data can be written to MLC memory, but data transfer volume increases significantly (5x or 8x the programmable unit) and requires large buffer memory
Solution Approach 1:
The patent segments the foggy-fine programming process across multiple dies within a super-device. Instead of performing complete foggy-fine programming sequences on single dies which require large data transfers, the process is divided into smaller units distributed across 8 dies. Each die performs a portion of the programming with reduced data transfer requirements, and the results are combined to achieve the complete programming task.
2Reliability
If foggy-fine programming is performed sequentially on single dies, then programming can be completed, but host write performance degrades due to the time-consuming nature of multiple programming passes
Solution Approach 1:
The patent divides the host write operation into multiple parallel programming tasks distributed across 8 dies. Each die handles a segment of the data with its own foggy-fine programming sequence, allowing simultaneous execution of multiple programming operations. This parallelization maintains high host write performance while ensuring reliable programming completion through the coordinated segmentation approach.
Solution Approach 2:
The patent uses SLC cache as a counterbalancing resource to offset the performance degradation caused by foggy-fine programming delays. Data is initially written to fast SLC cache, providing immediate host write acknowledgment, while the slower foggy-fine programming to MLC occurs in the background across multiple dies. This anti-weight approach balances the system by compensating for MLC programming latency with SLC cache speed.
3Reliability
If data is written to SLC cache first then foggy-fine programmed to MLC, then data protection against power loss is improved, but the staggered word line sequence requires data to be set aside multiple times increasing complexity
Solution Approach 1:
The patent segments data management across 8 dies with coordinated foggy-fine programming sequences. Each die manages its own data portion independently, reducing the overall complexity of managing large data buffers. The segmentation allows each die to handle smaller data units with simplified protection mechanisms, while the collective system achieves comprehensive power loss protection through the distributed architecture.
Data Source
AI summary
The present disclosure generally relates to improved foggy-fine programming. The data to be written initially passes through an encoder before being written to SLC. While the data is being written to SLC, the data also passes through DRAM before going through the encoder to prepare for fine writing. The data that is to be stored in SLC is in latches in the memory device and is then written to MLC as a foggy write. Thereafter, the data that has passed through the encoder is fine written to MLC. The programming occurs in a staggered fashion where the ratio of SLC:foggy:fine writing is 4:1:1. To ensure sufficient XOR context management, programming across multiple dies, as well as across multiple super-devices, is staggered so that only four XOR parity context are necessary across 64 dies.