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 PDF

Info

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
Application number
CN202111179858.5A
Other languages
Chinese (zh)
Other versions
CN113821177A (en
Inventor
庄铸滔
陈志广
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Sun Yat Sen University
Original Assignee
Sun Yat Sen University
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by Sun Yat Sen University filed Critical Sun Yat Sen University
Priority to CN202111179858.5A priority Critical patent/CN113821177B/en
Publication of CN113821177A publication Critical patent/CN113821177A/en
Application granted granted Critical
Publication of CN113821177B publication Critical patent/CN113821177B/en
Active legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00Input 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/06Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601Interfaces specially adapted for storage systems
    • G06F3/0602Interfaces specially adapted for storage systems specifically adapted to achieve a particular effect
    • G06F3/0604Improving or facilitating administration, e.g. storage management
    • GPHYSICS
    • G06COMPUTING; CALCULATING OR COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F3/00Input 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/06Digital input from, or digital output to, record carriers, e.g. RAID, emulated record carriers or networked record carriers
    • G06F3/0601Interfaces specially adapted for storage systems
    • G06F3/0628Interfaces specially adapted for storage systems making use of a particular technique
    • G06F3/0638Organizing 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

Storage structure of LSM tree based on NVM and data storage method thereof
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.
CN202111179858.5A 2021-10-11 2021-10-11 Storage structure of LSM tree based on NVM and data storage method thereof Active CN113821177B (en)

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)

* Cited by examiner, † Cited by third party
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)

* Cited by examiner, † Cited by third party
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

Patent Citations (1)

* Cited by examiner, † Cited by third party
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