Flash Memory Data Structures Using Log Pages and In-Memory Tables
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional flash memory systems face performance and lifespan penalties due to the need for multiple reads and writes, and the inability to perform small edits without erasing entire pages, making it inefficient for processing large datasets.
Innovation Solution
Implementing a system that allows overwrites in flash memory by using logical-OR operations and Compare-and-Swap calls to update data structures, reducing the number of erasures and improving performance by writing only changes from 0s to 1s without altering existing 1s, and using an in-memory table to temporarily store changes before flushing them to flash memory.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If conventional data structures are implemented in flash memory with random edits, then data structure operations are simple, but performance degrades due to multiple reads and writes required for small edits
Solution Approach 1:
The patent segments the flash memory into data pages and log pages with distinct functions. Data pages store structured data while log pages store update operations. This segmentation allows the system to perform simple sequential writes to log pages without the performance penalty of random writes to data pages, resolving the contradiction between operational simplicity and processing speed.
Solution Approach 2:
The patent introduces a log page as an intermediary between the host system and the actual data storage. Updates are first written to the log page (simple sequential operation), then applied to data pages in batch (complex random operations). This intermediary buffer resolves the contradiction by isolating simple operations from complex ones.
2Reliability
If small edits are performed in flash memory by copying to new pages, then data integrity is maintained, but lifespan decreases due to increased write and erase operations
Solution Approach 1:
The patent performs preliminary actions by pre-allocating log pages and preparing backup pages before they are needed. When an update is required, the system has already prepared the necessary storage space, allowing it to perform the update operation without additional erasures. This preliminary preparation maintains data integrity while reducing the total number of write/erase cycles.
Solution Approach 2:
The patent implements a wear-leveling strategy where log pages and backup pages are systematically discarded and recovered. After a log page is filled with updates, it is discarded and its space is recovered for future use. This systematic discarding and recovering distributes wear across the memory, extending overall lifespan while maintaining data integrity through the structured update process.
3Ease of manufacture
If entire pages are erased in flash memory, then write operations can proceed, but performance penalty increases due to the erasure time
Solution Approach 1:
The patent implements periodic action by performing erasures only when necessary (when a log page is full or during garbage collection) rather than before every write operation. The system operates in cycles: write to log page → fill log page → discard and erase → repeat. This periodic erasure strategy maintains write feasibility while dramatically improving processing throughput by eliminating unnecessary erasures.
Solution Approach 2:
The patent ensures continuity of useful action by allowing writes to proceed continuously to log pages without interruption for erasures. The erasure operations occur in the background or in batches when log pages are full, maintaining continuous data ingestion while periodically cleaning up. This continuity maintains high processing throughput while ensuring write feasibility.
Data Source
AI summary
Systems and methods for managing content in a flash memory. Data structures such as trees and graphs are implemented in a flash memory. Nodes or field nodes such as pointers or invalidation bits are updated using an overwrite operation where possible or by invalidating certain fields and temporarily storing changes in an in-memory table.