Superblock Redundancy for Multi-Die Memory Endurance
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing redundant data storage systems in non-volatile memory face challenges due to the limited number of programming and erasure cycles, which can lead to decreased system performance and reliability, especially when implementing redundant storage schemes that require frequent updates of redundancy information.
Innovation Solution
The proposed solution involves using superblocks and logical addressing to store data and redundancy information across multiple memory units, where data is compacted and erased in superblocks, and redundancy information is updated less frequently, and encoded with Error Correction Codes (ECC) to ensure data recovery in case of memory unit failure.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If redundant storage schemes are implemented with frequent updates of redundancy information, then data reliability is improved, but the number of programming operations increases leading to decreased memory endurance
Solution Approach 1:
The patent segments data into superblocks that span multiple memory units (dies), with each superblock containing data and redundancy information distributed across different dies. This segmentation allows redundancy to be updated less frequently since entire superblocks can be atomically replaced rather than updating individual redundancy entries, thus improving reliability while reducing programming operation frequency.
Solution Approach 2:
The patent performs preliminary actions by pre-calculating and storing redundancy information for entire superblocks before data is actually needed. The redundancy is computed in advance and stored in dedicated locations across multiple dies, so that when failures occur, the redundancy is already ready for immediate use without requiring frequent updates.
2Reliability
If redundancy information is updated frequently to maintain data integrity, then data integrity is improved, but system performance decreases due to increased programming operations
Solution Approach 1:
The patent merges data and redundancy information into unified superblock structures that are treated as atomic units. Instead of updating redundancy information separately from data, the entire superblock is replaced as a unit, which reduces the frequency of programming operations while maintaining data integrity, thus improving system performance.
Solution Approach 2:
The patent uses copying of entire superblocks to replace failed data. When a memory unit fails, the corresponding superblock is copied from surviving memory units using the distributed redundancy information, rather than performing incremental updates. This copying approach maintains data integrity while minimizing the number of programming operations required.
3Reliability
If data is stored across multiple memory units with redundancy, then reliability against memory unit failure is improved, but device complexity increases
Solution Approach 1:
The patent implements a universal superblock structure that can be stored across any combination of memory units (dies) in the system. The same superblock format is used regardless of which specific dies are available, providing flexibility and simplifying the management of redundancy across multiple memory units without proportionally increasing complexity.
Solution Approach 2:
The patent introduces a mapping structure as an intermediary between logical addresses and physical memory locations. This mapping table tracks which memory units store which superblocks and where redundancy information is located, abstracting the complexity of multi-unit storage from the user and simplifying data retrieval and redundancy management operations.
Data Source
AI summary
A method for data storage includes storing data in a memory that includes one or more memory units, each memory unit including memory blocks. The stored data is compacted by copying at least a portion of the data from a first memory block to a second memory block, and subsequently erasing the first memory block. Upon detecting a failure in the second memory block after copying the portion of the data and before erasure of the first memory block, the portion of the data is recovered by reading the portion from the first memory block.