CN113821177B - Storage structure of LSM tree based on NVM and data storage method thereof - Google Patents
Storage structure of LSM tree based on NVM and data storage method thereof Download PDFInfo
- Publication number
- CN113821177B CN113821177B CN202111179858.5A CN202111179858A CN113821177B CN 113821177 B CN113821177 B CN 113821177B CN 202111179858 A CN202111179858 A CN 202111179858A CN 113821177 B CN113821177 B CN 113821177B
- Authority
- CN
- China
- Prior art keywords
- sstable
- memtable
- nvm
- key
- data
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 21
- 238000013500 data storage Methods 0.000 title claims abstract description 10
- 238000005056 compaction Methods 0.000 claims description 8
- 238000013461 design Methods 0.000 claims description 6
- 230000006870 function Effects 0.000 claims description 3
- 238000009434 installation Methods 0.000 claims description 3
- 230000008569 process Effects 0.000 description 3
- 238000003491 array Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000006467 substitution reaction Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 230000003139 buffering effect Effects 0.000 description 1
- 230000008859 change Effects 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000005012 migration Effects 0.000 description 1
- 238000013508 migration Methods 0.000 description 1
- 238000011160 research Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0602—Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
- G06F3/0604—Improving or facilitating administration, e.g. storage management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/06—Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
- G06F3/0601—Interfaces specially adapted for storage systems
- G06F3/0628—Interfaces specially adapted for storage systems making use of a particular technique
- G06F3/0638—Organizing or formatting or addressing of data
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Human Computer Interaction (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a storage structure of an LSM tree based on NVM and a data storage method thereof, comprising the following steps: a DRAM layer for inserting data into the data structure WriteBatch and constructing a write object queue, writing MemTable the data of the data structure WriteBatch according to the write object queue; and the DISK layer is used for converting MemTable into SSTable and merging the SSTable based on the NVM to complete the writing operation. The invention takes the NVM as a SSTabl storage carrier to improve the throughput rate of the system. The invention is used as a storage structure of an LSM tree based on the NVM and a data storage method thereof, and can be widely applied to the field of storage equipment.
Description
Technical Field
The invention relates to the field of storage equipment, in particular to a storage structure of an LSM tree based on an NVM and a data storage method thereof.
Background
In the field of data storage, it is common to implement data storage based on an LSM tree storage structure, and the existing LSM tree storage structure uses a conventional block storage device as a storage carrier of SSTable, which has the problem of insufficient flexibility, and needs to read data on a hard disk into a DRAM before performing operation, so that the read-write performance of the whole system is general, and the throughput rate is low.
Disclosure of Invention
In order to solve the technical problems, the invention aims to provide a storage structure of an LSM tree based on an NVM and a data storage method thereof, wherein the NVM is used as a SSTabl storage carrier so as to improve the throughput rate of a system.
The first technical scheme adopted by the invention is as follows: a memory structure of an NVM-based LSM tree, comprising the steps of:
A DRAM layer for inserting data into the data structure WriteBatch and constructing a write object queue, writing MemTable the data of the data structure WriteBatch according to the write object queue;
And the DISK layer is used for converting MemTable into SSTable and merging the SSTable based on the NVM to complete the writing operation.
The second technical scheme adopted by the invention is as follows: a data storage method of an NVM-based LSM tree storage structure, comprising a write operation:
Inserting data into the data structure WriteBatch and constructing a write object queue;
writing MemTable data of the data structure WriteBatch according to the write object queue;
converting MemTable to SSTable;
and merging SSTable based on the NVM to complete the write operation.
Further, the writing MemTable of the data structure WriteBatch specifically further includes:
Judging whether the current MemTable is full;
If MemTable is determined to be full, memTable is converted to Immutable MemTable and a new MenTable is created.
Further, the step of converting MemTable to SSTable specifically includes:
converting MemTable to SSTable;
Traversing Immutable MemTable to obtain the number of data items of Immutable MemTable;
An SSTable with the same number of data items as Immutable MemTable is newly built, and the data item Immutable MemTable is inserted at the tail of the SSTable.
Further, the step of merging sstables based on NVM to complete writing operation specifically includes:
creating Compaction an object and an SSTable array, wherein the Compaction object comprises SSTable combined record information, and the SSTable array is provided with a threshold value capable of accommodating the number of key value pairs;
constructing an iterator for SSTable to be combined, wherein the iterator returns key value pairs of SSTable to be combined from small to large in sequence;
Traversing the iterator, and judging whether each returned key value pair can be discarded according to a preset rule;
judging that the returned key value pair is not discardable, and adding the key value pair into the newly created SSTable;
When one SSTable is filled, one SSTable is newly created, and the newly created SSTable is pressed into the tail end of the SSTable array;
and judging that all the non-discardable key value pairs are inserted into the SSTable array, and executing installation replacement to complete the writing operation.
Further, the method also comprises the following steps of:
Searching key to be indexed in Mutable MemTable;
the key to be indexed is not found in Mutable MemTable, and the key to be indexed is found in Immutable MemTable;
the key to be indexed is not found in Immutable MemTable, and is found in the SSTable.
Further, the step of searching for the key to be indexed in Mutable MemTable specifically includes:
Creating an iterator SkipList and searching for keys to be indexed by calling a query function of the iterator;
And returning a search result.
Further, the step of searching the key to be indexed in the SSTable without searching the key to be indexed in Immutable MemTable specifically includes:
no key to be indexed is found in either Mutable MemTable or Immutable MemTable;
starting to search from the L0 layer to the upper layer until the highest layer;
searching a key to be indexed, outputting the key to be indexed and ending;
And if the key to be indexed is not found, outputting a result of not finding.
The method and the system have the beneficial effects that: according to the invention, the NVM is used as an LSM tree design of the replacement equipment of the traditional block equipment, the NVM is used as a storage carrier of SSTabl, and the read-write operation of the SSTable is directly carried out on the NVM, so that the operation of reading data from a hard disk into a DRAM is eliminated, and the throughput rate of the system is greatly improved.
Drawings
FIG. 1 is a system frame diagram of a memory structure of an NVM-based LSM tree of the present invention;
FIG. 2 is a write operation of an embodiment of the present invention;
FIG. 3 is a read operation of an embodiment of the present invention.
Detailed Description
The invention will now be described in further detail with reference to the drawings and to specific examples. The step numbers in the following embodiments are set for convenience of illustration only, and the order between the steps is not limited in any way, and the execution order of the steps in the embodiments may be adaptively adjusted according to the understanding of those skilled in the art.
We designed and implemented a new storage architecture for NVM-based LSM tree, named NVLSM (Novel LSM). NVLSM can effectively utilize the byte-addressable nature of the NVM to reduce read and write latency, thereby enabling higher throughput rates. NVLSM does not use the conventional block storage device as a storage carrier of SSTable, but uses NVM as a storage carrier of SSTable, so that the unit of operation on SSTable basic data of NVLSM is not a block but a byte, and therefore NVLSM has a greater flexibility than the conventional LSM design, and at the same time, the byte-addressable property of NVM is fully utilized. Meanwhile, because SSTable is stored on the NVM, unlike the prior art that data on a hard disk is read into the DRAM first and then is operated, NVLSM read-write operation of SSTable is directly carried out on the NVM, thus eliminating the operation of reading data from the hard disk into the DRAM, and greatly improving the throughput rate of the system. Finally, NVLSM changes the data structure of the previous SSTable based on the block device, so that the SSTable stored on the NVM has extra space for storing the data of the upper SSTable, thus reducing the number of times of writing operation of the SSTable to the NVM when merging, improving the writing performance of the LSM, and improving the throughput rate of the whole system.
Referring to fig. 1, the present invention provides a memory structure of an NVM-based LSM tree, comprising:
A DRAM layer for inserting data into the data structure WriteBatch and constructing a write object queue, writing MemTable the data of the data structure WriteBatch according to the write object queue;
And the DISK layer is used for converting MemTable into SSTable and merging the SSTable based on the NVM to complete the writing operation.
A storage method applied to the storage structure of the NVM-based LSM tree described above, referring to fig. 2, includes a write operation:
Inserting data into the data structure WriteBatch and constructing a write object queue;
writing MemTable data of the data structure WriteBatch according to the write object queue;
Specifically, in the write operation to NVLSM, first we insert the data to be written into the data structure WriteBatch, so that the data can be written into WriteBatch and then MemTable for multiple write operations to the database, which can increase the writing rate. Since there may be multiple WriteBatch to write MemTable at the same time, NVLSM has a queue of write objects, and when data is needed, the current writer waits for all the previous writers in the queue to complete and then writes.
Converting MemTable to SSTable;
and merging SSTable based on the NVM to complete the write operation.
Further as a preferred embodiment of the method, the writing MemTable the data of the data structure WriteBatch specifically further includes:
Judging whether the current MemTable is full;
If MemTable is determined to be full, memTable is converted to Immutable MemTable and a new MenTable is created.
Specifically, when performing the insert operation on MemTable, we reserve space for the current write operation, i.e. determine whether the current MemTable is already filled, if so, change MemTable to Immutable MemTable, and then create a new MenTable so that the data item in the current WriteBatch can be inserted into MemTable. After the insert operation is completed, the writer holding the lock will notify other writers so that the next writer waiting for the lock can continue writing.
Further as a preferred embodiment of the method, the step of converting MemTable to SSTable specifically includes:
converting MemTable to SSTable;
Traversing Immutable MemTable to obtain the number of data items of Immutable MemTable;
An SSTable with the same number of data items as Immutable MemTable is newly built, and the data item Immutable MemTable is inserted at the tail of the SSTable.
The above-mentioned operation of reserving a space for newly inserted data includes an operation of converting Immutable MemTable into SSTable and an operation of pushing the merging operation of SSTable into a background thread queue. In the process of converting Immutable MemTable into SSTable, we will create an SSTable, first traverse Immutable MemTable to obtain the number of data items of Immutable MemTable, and then create an SSTable with the same number of data items, so as to insert Immutable MemTable data items at the tail of SSTable. This corresponds to copying Immutable MemTable data items into SSTable, and therefore, unlike the prior art in which Immutable MemTable data items are written to the buffer first, then the Write operation of the system is invoked to Write the buffered data to disk, NVLSM eliminates the overhead of serializing the memory data by effectively utilizing the byte-addressable nature of NVM like and DRAM.
Because of the nature of the LSM tree storage structure, all the insert and update operations for NVLSM are first placed into memory, then with the constant filling of the memory MemTable, the data in the memory is transferred to NVM only if the upper limit is reached, which is a Flush operation.
Further as a preferred embodiment of the method, the step of merging sstables based on NVM to complete writing specifically includes:
creating Compaction an object and an SSTable array, wherein the Compaction object comprises SSTable combined record information, and the SSTable array is provided with a threshold value capable of accommodating the number of key value pairs;
Specifically, the record information includes the layer number Lx of the LSM where the present merge operation is located, and an array including SSTable selected from the Lx layer and all sstables of lx+1 layers overlapping the selected SSTable key range.
The strategy for selecting an SSTable from the Lx layer is that NVLSM maintains a merge pointer for each layer SSTable, where the pointer is located indicates the location of the SSTable to be selected for the next merge operation. The merge pointers will move cyclically, i.e. when a pointer moves to the last SSTable of the current layer, the next merge pointer will move to the first SSTable of the current layer.
Constructing an iterator for SSTable to be combined, wherein the iterator returns key value pairs of SSTable to be combined from small to large in sequence;
Traversing the iterator, and judging whether each returned key value pair can be discarded according to a preset rule;
judging that the returned key value pair is not discardable, and adding the key value pair into the newly created SSTable;
When one SSTable is filled, one SSTable is newly created, and the newly created SSTable is pressed into the tail end of the SSTable array;
and judging that all the non-discardable key value pairs are inserted into the SSTable array, executing installation replacement, namely replacing the current NVLSM version with the updated NVLSM, and completing the writing operation.
Specifically, a new version NVLSM is created, then SSTable of the layer without merging operation is copied to the new NVLSM version, for the two layers with merging operation, we traverse all the created SSTable arrays and the SSTable arrays of the original two layers, and the SSTable is orderly discharged through merging operation, thus completing the construction of NVLSM of a new version. After completing the above ordered discharge of sstables, we update the merge value Compaction Score of sstables of each layer, i.e. see if lx+1 layer needs to perform new merge operation again, and also update the merge pointer of each layer, so that the merge pointer rotates in the range space of keys.
In addition, a case is included: under the condition that only one SSTable participates in merging in the Lx layer and no SSTable participates in merging in the Lx+1 layer, namely only one SSTable participates in merging operation, SSTable of the Lx layer is simply moved to the Lx+1 layer.
Further as a preferred embodiment of the method, referring to fig. 3, further comprising a read operation:
Searching key to be indexed in Mutable MemTable;
Specifically, mutable MemTable means that the current MemTable still can perform the insert operation, and Mutable MemTable becomes Immutable MemTable when the data amount of Mutable MemTable exceeds the threshold value, at which time MemTable can no longer perform the insert or update operation, and only perform the read operation.
The key to be indexed is not found in Mutable MemTable, and the key to be indexed is found in Immutable MemTable;
Specifically, if Immutable MemTable is present in the current DRAM, a query is made in ImmuTable MemTable, the process of the query being the same as Mutable MemTable.
The key to be indexed is not found in Immutable MemTable, and is found in the SSTable.
Further as a preferred embodiment of the method, the step of searching for the key to be indexed in Mutable MemTable specifically includes:
Creating an iterator SkipList and searching for keys to be indexed by calling a query function of the iterator;
And returning a search result.
Further as a preferred embodiment of the method, the step of searching the SSTable for the key to be indexed, in which the key to be indexed is not found in Immutable MemTable, specifically includes:
no key to be indexed is found in either Mutable MemTable or Immutable MemTable;
starting to search from the L0 layer to the upper layer until the highest layer;
searching a key to be indexed, outputting the key to be indexed and ending;
And if the key to be indexed is not found, outputting a result of not finding.
Specifically, unlike conventional SSTable lookup for blocks such as SSD or HDD, which uses a Bloom Filter to accelerate the lookup process, since NVM itself has a faster read speed (read speed substantially consistent with DRAM), in the lookup for SSTable we use a simple binary lookup, i.e., first, since the ranges of the keys of sstables of other layers, except L0, do not overlap, we use a binary lookup to determine which SSTable of one layer the key to index is in, then, for this SSTable we use a binary lookup to find the key value pair of the key given to the top user (because the key of the internally stored key value pair is additionally added with the type of key, i.e., whether the serial number of the key is deleted or not), then, compare the keys to index, and if so, return the unseen or return value depending on the type of key, i.e., whether the key is deleted or not. For sstables located in the L0 layer, since the ranges of their keys may intersect, we will use a binary search for each SSTable to determine whether the key to be indexed is in the current SSTable, which is a tolerable overhead since the number of sstables in the L0 layer is not very large. Because NVLSM searches for SSTable are all carried out in NVM, the search in SSTable does not need to deserialize operation of disk, thus eliminating the serialization/deserialization operation of original LSM, and the time of reading in block twice of searching index block and then reading and searching data block.
The invention NVLSM is LSM tree design of replacing equipment which completely uses NVM as SSD or HDD, and different from the previous research, most of the LSM tree design uses NVM as DRAM buffer, uses NVM for buffering MemTable data structure which should be located in DRAM, and then uses the high capacity property of NVM to make background thread not blocked to finish SSTable merging. Most of the utilization of the NVM combines three storage media of the DRAM, the NVM and the SSD to form a storage hierarchy from top to bottom, so that the complexity of data migration of different hierarchies is increased, and the programming difficulty is increased. And NVLSM has a two-layer structure, so that the complexity of the storage architecture is reduced.
In writing data NVLSM takes full advantage of the byte-addressable nature of the NVM. When writing the key value pair located in the memory layer MemTable into the NVM, unlike the conventional LSM design implementation such as LevelDB, which requires adding all data of Immutable MemTable into the buffer, then writing the key value pair into the block storage device such as SSD, NVLSM copies the data in Immutable MemTable directly onto the NVM by using the byte addressable property of the NVM, which is similar to memcpy operation, so that the writing speed is greatly improved, and the blocked time of the Compaction thread is reduced.
Meanwhile, since the NVM and the DRAM have byte addressing characteristics, NVLSM are not required to read the index block and the data block, and the search of the index key on the SSTable of the NVM is only required to be carried out on the NVM, so that the I/O operation time between the disk and the DRAM required by the prior block-based equipment is eliminated, and the reading performance is greatly improved.
While the preferred embodiment of the present application has been described in detail, the application is not limited to the embodiment, and various equivalent modifications and substitutions can be made by those skilled in the art without departing from the spirit of the application, and these equivalent modifications and substitutions are intended to be included in the scope of the present application as defined in the appended claims.
Claims (6)
1.A memory structure of an NVM-based LSM tree, characterized by an LSM tree design for treating NVM as an alternative device to SSD or HDD, comprising:
A DRAM layer for inserting data into the data structure WriteBatch and constructing a write object queue, writing MemTable the data of the data structure WriteBatch according to the write object queue;
The DISK layer is used for converting MemTable into SSTable and combining the SSTable based on the NVM to finish the writing operation;
the data storage method of the LSM tree storage structure based on the NVM comprises the following steps:
Inserting data into the data structure WriteBatch and constructing a write object queue;
writing MemTable data of the data structure WriteBatch according to the write object queue;
converting MemTable to SSTable;
merging SSTable based on NVM to complete writing operation;
the method further comprises the following steps of:
Searching key to be indexed in Mutable MemTable;
the key to be indexed is not found in Mutable MemTable, and the key to be indexed is found in Immutable MemTable;
the key to be indexed is not found in Immutable MemTable, and is found in the SSTable.
2. The memory structure of an NVM-based LSM tree of claim 1, wherein said writing MemTable data of data structure WriteBatch further comprises:
Judging whether the current MemTable is full;
If MemTable is determined to be full, memTable is converted to Immutable MemTable and a new MenTable is created.
3. The memory structure of an NVM-based LSM tree according to claim 2, wherein said step of converting MemTable to SSTable comprises:
converting MemTable to SSTable;
Traversing Immutable MemTable to obtain the number of data items of Immutable MemTable;
An SSTable with the same number of data items as Immutable MemTable is newly built, and the data item Immutable MemTable is inserted at the tail of the SSTable.
4. The memory structure of an NVM-based LSM tree according to claim 3, wherein said combining sstables based on NVM to complete the writing operation comprises:
creating Compaction an object and an SSTable array, wherein the Compaction object comprises SSTable combined record information, and the SSTable array is provided with a threshold value capable of accommodating the number of key value pairs;
constructing an iterator for SSTable to be combined, wherein the iterator returns key value pairs of SSTable to be combined from small to large in sequence;
Traversing the iterator, and judging whether each returned key value pair can be discarded according to a preset rule;
judging that the returned key value pair is not discardable, and adding the key value pair into the newly created SSTable;
When one SSTable is filled, one SSTable is newly created, and the newly created SSTable is pressed into the tail end of the SSTable array;
and judging that all the non-discardable key value pairs are inserted into the SSTable array, and executing installation replacement to complete the writing operation.
5. The memory structure of an NVM-based LSM tree of claim 4, wherein said step of searching for a key to be indexed in MutableMemTable, comprises:
Creating an iterator SkipList and searching for keys to be indexed by calling a query function of the iterator;
And returning a search result.
6. The memory structure of an NVM-based LSM tree of claim 5, wherein said step of searching for a key to be indexed in SSTable without searching for a key to be indexed in ImmutableMemTable comprises:
no key to be indexed is found in either Mutable MemTable or Immutable MemTable;
starting to search from the L0 layer to the upper layer until the highest layer;
searching a key to be indexed, outputting the key to be indexed and ending;
And if the key to be indexed is not found, outputting a result of not finding.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202111179858.5A CN113821177B (en) | 2021-10-11 | 2021-10-11 | Storage structure of LSM tree based on NVM and data storage method thereof |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202111179858.5A CN113821177B (en) | 2021-10-11 | 2021-10-11 | Storage structure of LSM tree based on NVM and data storage method thereof |
Publications (2)
Publication Number | Publication Date |
---|---|
CN113821177A CN113821177A (en) | 2021-12-21 |
CN113821177B true CN113821177B (en) | 2024-06-18 |
Family
ID=78920059
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CN202111179858.5A Active CN113821177B (en) | 2021-10-11 | 2021-10-11 | Storage structure of LSM tree based on NVM and data storage method thereof |
Country Status (1)
Country | Link |
---|---|
CN (1) | CN113821177B (en) |
Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN112395212A (en) * | 2020-11-05 | 2021-02-23 | 华中科技大学 | Method and system for reducing garbage recovery and write amplification of key value separation storage system |
Family Cites Families (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US10496283B2 (en) * | 2016-01-22 | 2019-12-03 | Suraj Prabhakar WAGHULDE | Adaptive prefix tree based order partitioned data storage system |
US10496371B2 (en) * | 2017-06-29 | 2019-12-03 | Intel Corporation | Key-value compaction |
CN110347336B (en) * | 2019-06-10 | 2020-07-10 | 华中科技大学 | Key value storage system based on NVM (non volatile memory) and SSD (solid State disk) hybrid storage structure |
CN110188108B (en) * | 2019-06-10 | 2021-03-02 | 北京平凯星辰科技发展有限公司 | Data storage method, device, system, computer equipment and storage medium |
-
2021
- 2021-10-11 CN CN202111179858.5A patent/CN113821177B/en active Active
Patent Citations (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN112395212A (en) * | 2020-11-05 | 2021-02-23 | 华中科技大学 | Method and system for reducing garbage recovery and write amplification of key value separation storage system |
Also Published As
Publication number | Publication date |
---|---|
CN113821177A (en) | 2021-12-21 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
CN110347336B (en) | Key value storage system based on NVM (non volatile memory) and SSD (solid State disk) hybrid storage structure | |
US10496283B2 (en) | Adaptive prefix tree based order partitioned data storage system | |
CN103838853B (en) | Mixed file system based on different storage media | |
CN109407978B (en) | Design and implementation method of high-concurrency index B + linked list data structure | |
US5008820A (en) | Method of rapidly opening disk files identified by path names | |
CN102779096B (en) | Page, block and face-based three-dimensional flash memory address mapping method | |
US9606746B2 (en) | Shiftable memory supporting in-memory data structures | |
US20050015557A1 (en) | Nonvolatile memory unit with specific cache | |
CN109710541B (en) | Optimization method for Greedy garbage collection of NAND Flash main control chip | |
CN111414134B (en) | Transaction write optimization framework method and system for persistent memory file system | |
CN110109927A (en) | Oracle database data processing method based on LSM tree | |
CN116069267B (en) | Writing cache method, system, equipment and storage medium of RAID card | |
CN114996275B (en) | Key value storage method based on multi-tree conversion mechanism | |
KR101438667B1 (en) | Database method for b+ tree based on PRAM | |
CN112732725B (en) | NVM (non volatile memory) hybrid memory-based adaptive prefix tree construction method, system and medium | |
CN102520885B (en) | Data management system for hybrid hard disk | |
KR20020092261A (en) | Management Scheme for Flash Memory with the Multi-Plane Architecture | |
CN113821177B (en) | Storage structure of LSM tree based on NVM and data storage method thereof | |
CN112181288B (en) | Data processing method of nonvolatile storage medium and computer storage medium | |
CN111274456B (en) | Data indexing method and data processing system based on NVM (non-volatile memory) main memory | |
US20090187719A1 (en) | Data backup method for logical volume manager | |
US10565174B2 (en) | Operating method for non-volatile memory | |
CN113505130A (en) | Hash table processing method | |
CN100568352C (en) | The method that is used for process database | |
US20240036735A1 (en) | Memory device and operation method thereof |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PB01 | Publication | ||
PB01 | Publication | ||
SE01 | Entry into force of request for substantive examination | ||
SE01 | Entry into force of request for substantive examination | ||
GR01 | Patent grant | ||
GR01 | Patent grant |