KR20140070834A - Modified searching method and apparatus for b+ tree - Google Patents

Abstract

The present invention relates to a method and an apparatus for updating modified b+ tree nodes. The method for updating modified b+ tree nodes according to the present invention comprises the steps of: queuing an update operation with entries of a preset operation queue to store an inputted update operation; searching a plurality of nodes corresponding to the entries of the queue according to a first algorithm; and performing an update according to the update operation of the searched nodes. According to the present invention, search speed can be improved based on the internal parallelism of a flash SSD when a B+ tree is searched and thus the efficiency of update of the nodes can be improved.

Description

 [0001] MODIFIED SEARCHING METHOD AND APPARATUS FOR B + TREE [0002]

The present invention relates to a modified B + tree node update method and apparatus, and more particularly, to a method and apparatus for updating a modified B + tree node using an I / O (input / output) To a method and apparatus for updating a modified B + tree node.

 An SSD is a storage device designed to permanently store data on a semiconductor flash memory. The SSD differs from a conventional hard disk drive because there is no component that actually operates, and has a semiconductor memory array in which the integrated circuit is configured as a disk drive.

This approach has several advantages. First, the data transfer speed is much faster than the conventional hard disk drive. Search time and latency are also drastically reduced, and most users can feel the computer boot up time is also very fast. Durability is stronger and quieter because there is no driven or faulty part itself.

However, unlike the conventional hard disk, the flash memory and the flash SSD (Solid State Drive) are applied to the database management system (DBMS). In the DBMS, the asymmetric read / write speed and the SSD There is a problem in that the usable period of time is shortened. Accordingly, supplementary techniques for these problems are being developed, and the use of SSDs in various fields such as DBMS is increasing.

SUMMARY OF THE INVENTION The present invention is conceived to solve the problems of the prior art, and it is an object of the present invention to provide a search method for updating a node of a B + tree using a plurality of I / Os based on internal parallelism of a flash SSD, And a method for updating the node through the network.

According to an aspect of the present invention, there is provided a method of updating a modified B + tree, the method comprising: queuing the update operation with an entry of a predetermined operation queue to store an update operation; Searching a plurality of nodes corresponding to a plurality of entries of the queue according to a first algorithm; And performing an update according to the update operation of the searched plurality of nodes.

Setting a search range including at least one key value based on a plurality of entries of the queue; Generating a set of pointers comprising pointers for searching for child nodes based on the set search range; Transmitting an I / O request in parallel using the generated pointer set; And retrieving a node corresponding to the entry based on the transmitted I / O request.

Preferably, prior to the step of searching, further comprising the step of sorting the entries of the operation queue, wherein the searching step searches for a node corresponding to a plurality of entries of the sorted queue.

The step of performing the update preferably propagates a plurality of boundary keys generated according to the update of the node to an intermediate node including a parent node of the node, and the intermediate node is updated according to the Pinsky.

The step of performing the update preferably performs relocation and merging of nodes when the node underflows according to an index delete operation.

The step of performing the update preferably performs partitioning of the node when the node overflows according to an index insertion operation.

The step of performing the update preferably records the updated node in the flash memory.

Preferably, the boundary key generated according to the update travels through the route to the root node.

According to an aspect of the present invention, there is provided an apparatus for updating a modified B + tree, the apparatus comprising: an update operation queuing unit for queuing the update operation with an entry of a preset operation queue to store an update operation inputted; An operation node searching unit for searching a plurality of nodes corresponding to a plurality of entries of the queue according to a first algorithm; And an update performing unit for performing an update according to the update operation of the searched plurality of nodes.

 According to the present invention, in search of a B + tree, the efficiency of update of the node is increased along with the improvement of the search speed based on the internal parallelism of the flash SSD.

1 is a reference diagram showing an internal structure of a flash SSD (Solid State Drive)
2A and 2B are reference diagrams for measuring a delay time for random input / output (Read / Write) according to the I / O size of the flash SSD.
FIGS. 3A to 3C are reference views showing benchmark results for input / output (Read / Write) at an outstanding I / O level.
4 is a reference diagram for explaining an intermediate node structure for a B + tree configuration.
5 is a flowchart illustrating a method of updating a modified B + tree according to an embodiment of the present invention.
6 is a detailed flowchart illustrating a node search step of a modified B + tree update method according to an embodiment of the present invention.
7 is an exemplary diagram illustrating an operation queue according to an embodiment of the present invention.
FIGS. 8 to 14 are schematic diagrams illustrating a tree structure of a modified B + tree update method according to an embodiment of the present invention. FIG.
15 is a block diagram illustrating an apparatus for updating a modified B + tree according to an embodiment of the present invention.

Hereinafter, some embodiments of the present invention will be described in detail with reference to the accompanying drawings. In the following description, well-known functions or constructions are not described in detail since they would obscure the invention in unnecessary detail.

The following embodiments are a combination of elements and features of the present invention in a predetermined form. Each component or characteristic may be considered optional unless otherwise expressly stated. Each component or feature may be implemented in a form that is not combined with other components or features. In addition, some of the elements and / or features may be combined to form an embodiment of the present invention. The order of the operations described in the embodiments of the present invention may be changed. Some configurations or features of certain embodiments may be included in other embodiments, or may be replaced with corresponding configurations or features of other embodiments.

Embodiments of the present invention may be implemented by various means. For example, embodiments of the present invention may be implemented by hardware, firmware, software, or a combination thereof.

For a hardware implementation, the method according to embodiments of the present invention may be implemented in one or more application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs) , Field programmable gate arrays (FPGAs), processors, controllers, microcontrollers, microprocessors, and the like.

In the case of an implementation by firmware or software, the method according to embodiments of the present invention may be implemented in the form of a module, a procedure or a function for performing the functions or operations described above. The software code can be stored in a memory unit and driven by the processor. The memory unit is located inside or outside the processor, and can exchange data with the processor by various known means.

It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory and are intended to provide further explanation of the invention, and are not intended to limit the scope of the invention.

A solid state drive (SSD) or a solid state disk (SSD) is a data storage device that uses a memory chip such as a synchronous DRAM (SDRAM) or a flash memory without using a magnetic disk. In the embodiment of the present invention, the data storage device may be other than the SSD if it is based on a memory chip such as a flash memory. Hereinafter, an SSD will be described as an example of a data storage device.

1 is a block diagram schematically showing an internal configuration of a flash SSD. 1, the flash SSD includes a CPU unit 101, a RAM unit 103, a host interface unit 105, a buffer control module 107, an ECC (Error Correction Code) module 109, And a chip portion 111. The internal structure of the flash SSD will be schematically described with reference to FIG.

When the CPU 101 instructs a data write request, data is loaded from the external data storage unit and transferred to the buffer control module 107 via the host interface unit 105. The host interface unit 105 and the buffer control module 107 are interconnected through at least one channel data bus 113. The CPU unit 101 is connected to the host interface unit 105, the buffer control module 107, and the like via the CPU bus 115. The flash memory chip unit 111 writes the requested data, and data divided for each channel is written to a plurality of flash memory chips.

The difference due to the internal parallelism of the flash SSD will be described with reference to FIGS. 2 and 3. FIG. In order to benchmark the performance of the flash SSDs in parallel, we need a host interface type such as SATA II, SATA III, controllers of major SSD controller vendors (Intel, Fusion-io, SandForce, Marvell etc.) , SLC 35 nm, MLC 35 nm, MLC 25 nm) flash SSD.

FIG. 2A is a reference diagram for explaining a measurement of a delay time for a random input according to an I / O size. FIG. 2B is a diagram illustrating a measurement of a delay time for a random input according to an I / It is a reference diagram. It is measured by setting the I / O size to increase twice in 2Kb. 2A and 2B, it can be seen that the increase in I / O size and the delay time due to input / output (read / write) do not increase linearly. That is, it can be seen that the delay time according to the 4 Kb random input / output (read / write) is almost equal to or less than the delay time according to the 2 Kb random input / output (read / write), and the bandwidth is improved more than twice. This is because handling large I / Os is more suitable for SSDs.

FIG. 3A shows a benchmark result when an I / O size is fixed to 4Kb and an input (Read) is performed. FIG. 3B shows a case where an I / O size is fixed to 4Kb to perform an output Benchmark results are shown. It can be seen that the input / output (Read / Write) bandwidth gradually increases at the outstanding I / O level.

Outstanding I / O level refers to the number of simultaneous I / O requests when sending multiple I / O requests at the same time. That is, when a plurality of I / O requests are requested to one SSD at the same time, simultaneous I / O processing can be performed in a plurality of flash memory chips built in the SSD. Therefore, a fast bandwidth 1 to 10 times faster than the current hard disk), which is an important I / O characteristic of a memory chip based data storage device.

FIG. 3C shows a case where input / output is mixed at an outstanding I / O level. Output bandwidth of a non-interleaved workload is greater than highly interleaved workloads.

As described with reference to FIGS. 2 and 3, in order to utilize the parallelism of the package level, it is preferable that the size of the I / O basic unit is large. When the size of the basic I / O unit for increasing the bandwidth increases, the delay time for processing the corresponding I / O unit may become large. Therefore, it should be decided in relation to the delay time and the bandwidth extension.

To take advantage of channel level parallelism, multiple I / O requests must be sent simultaneously to a memory chip-based storage device such as a flash SSD. It is also possible to utilize one individual process per I / O request to create multiple I / O requests, but this method is too costly to create a process, so that multiple I / O requests from one individual process Asynchronous (asynchronous) I / O technique that can simultaneously send data to the host. Synchronous (sync) I / O is a type that performs other processing after waiting for completion of data transmission. Asynchronous (async) I / O does not wait for completion of data transmission / I / O type.

The internal node structure for the B + tree structure will be described with reference to FIG. Pi is the i-th positioned pointer value, Ki is the i-th key value (i is a natural number). F means a fanout connected to nodes deployed from an intermediate node. That is, the intermediate nodes constituting the B + tree are composed of pointer values and key values indicating a child node. Accordingly, in the present invention, an associated pointer to retrieve child nodes associated with key values is Pi and Pi + 1 close to Ki.

A modified B + tree node update method according to an embodiment of the present invention will be described with reference to FIG. The B + tree node update method according to this embodiment includes an update operation queuing step (S100), a node search step (S200), and an update performing step (S300).

A method for updating a B + tree according to the present embodiment relates to a method for optimizing update operations such as insertion, deletion, and update by equalizing the levels of channels of a flash memory.

First, the update operation queuing step (SlOO) queues the update operation with an entry of a preset operation queue to store the received update operation.

Describing the operation queue according to the present embodiment, the update operation resides until a batch update operation is performed in the operation queue. The application of the operation queue includes an algorithm for scanning the entries of the operation queue before searching the tree. Thus, the entries in the queue are successfully searched.

In this embodiment, the entry of the operation queue is composed of an index record and an operation flag specifying an operation type. Referring to Fig. 7, Fig. 7 shows an example of an operation queue. The area of the array that constitutes the operation queue is divided into two parts. One for the aligned array area and the other for the recently added entry. The two regions are separated by aligned offsets. The operation queue should take into account the cost of searching the index records in the operation queue and the cost of inserting new entries. In every update operation, the operation queue creates a new entry and adds the most recently inserted entry in the next slot without considering the order of the key values.

The insertion cost of the operation queue is minimized when it is performed through accessing pages of one main memory.

The method of updating a B + tree according to the present embodiment further includes a step of sorting entries of an operation queue prior to the searching step, and the searching step described below searches for a node corresponding to a plurality of entries of the sorted queue .

Referring to FIG. 8, the update method according to the present embodiment aligns the entries of the operation queue when the operation queue becomes full. Alignment to the operation queue is performed during the sort period, and entries before the aligned offset need not be sorted. Thus, the inserted entries after the aligned offset are aligned. And then combined with the aligned region. It is preferable that the combination of these is performed by merseyside. Because of this feature, the search within the operation queue is performed by the binary search, and the search by the nonlinear search is by linear search.

The node searching step of the B + tree updating method according to the present embodiment searches a plurality of nodes corresponding to a plurality of entries of the queue according to the first algorithm. The first algorithm is an algorithm for multiple searches of the modified B + tree, which is described in more detail in FIG.

Referring to FIG. 6, the first algorithm for node search in the node search step according to the present embodiment includes a search range setting step S210, a point set creation step S220, an I / O request transmission step S230, And includes a search step S240

The search range setting step S210 sets a search range including at least one key value based on a plurality of entries of the queue. The key value refers to data that allows the user to retrieve the data of the child node based on the user's input.

According to an embodiment of the present invention, a search range setting step (S210) includes extracting a start value of a search range and an end value of a search range for at least one or more key values based on a user's input request, And setting a search range having an end value. For example, the start value of the search range may be extracted as a minimum value among key values based on a user's input request, and the end value of the search range may be extracted as a maximum value among key values based on a user's input request. Therefore, when the key value set according to the user's request is {1, 2, 42, 65, 67}, the minimum value is set to 1 and the maximum value is set to 67, so that the search range is set to 1? S <67.

The point set creation step S220 creates a pointer set composed of pointers for searching child nodes based on the set search range. A pointer set is a set of pointers for indicating the position of a child node.

According to an exemplary embodiment of the present invention, the step of generating a pointer set (S220) includes extracting key values corresponding to a search range, and associating pointers to retrieve child nodes related to extracted key values And sets the pointer according to the I / O parameter set based on the type of the B + tree for calculating the available memory of the extracted extracted and related pointers.

According to another embodiment of the present invention, when the number of extracted related pointers exceeds the I / O parameter, a plurality of pointer sets are set according to the setting of the I / O parameter. If the number of associated pointers extracted exceeds the set I / O parameter, if I / O is transmitted in parallel, it will be used in excess of the maximum available memory, and problems such as system delay and search speed may occur. Therefore, when the number of extracted related pointers exceeds the set I / O parameter, a plurality of pointer sets are set. That is, the pointer set is set to fit the unit of the memory space secured by using the index based on the I / O parameter and the height of the B + tree, and the set is repeatedly set for the remaining pointers. For a plurality of pointer sets, I / O requests are sent in parallel to one pointer set, data search is performed according to the transmitted I / O requests, and I / O request.

The I / O request transmission step (S230) transmits the I / O request in parallel using the generated pointer set. According to an embodiment of the present invention, it is possible to simultaneously transmit at least one asynchronous I / O request to the data storage device using a pointer included in the pointer set. The data storage device is preferably a data storage device using a memory chip having a plurality of I / O channels.

The node searching step (S240) searches the data of the node corresponding to the input request based on the transmitted I / O request. According to an embodiment of the present invention, it is possible to retrieve data of a node using a depth first search (DFS).

In the present embodiment, the update performing step S300 performs update according to the update operation of the plurality of discovered nodes.

That is, in step S300, the node performs relocation and merging when the node underflows according to the index deletion operation, or performs partitioning when the node overflows according to the index insertion operation.

It is also preferable that a plurality of boundary keys generated according to the update of the node are propagated to the intermediate node including the parent node of the node, and the intermediate node is updated according to the Pinsky.

Further, the boundary key generated according to the update propagates through the route to the root node, and the intermediate node can be divided in the propagation process.

9 through 14, the entries of the operation queue are grouped into a plurality of groups through the key value of the root node, and the intermediate nodes corresponding to the selected group are read (FIG. 9).

Next, regroups the entries of the selected group through the key value of the corresponding intermediate node. The corresponding intermediate node in FIG. 10 is accessible at once to the leaf node. In this case, referring to FIG. 11, the entries of the operation queue are distributed to the leaf nodes, and the leaf nodes collectively perform update operations for the respective entries.

Referring to Fig. 12, by the insertion operation, the leaf nodes exceed the degree of the tree according to this embodiment, and the node is divided. The newly generated boundary key according to the node partitioning is inserted into the intermediate node, that is, the parent node. In the present embodiment, the tree updated according to the node update is as shown in Fig. 14, the operation queue waits for the queuing of the update operation. Hereinafter, the modified B + tree update method according to the above-described embodiment is shown in Table 1 as pseudo code.

First, according to the node search method according to the present embodiment, it is traversed until reaching the leaf node (line 10-21). The update operation is performed on the leaf node corresponding to the index of the entry after the leaf node (line 3-6, 28-39). If the leaf node is filled by the insert operation (overflow), the node is divided (line 29-30). If the leaf node is underflowed by the delete operation, node relocation and merging are performed (lines 33-34). The update operation is performed collectively for grouped entry groups. The updated leaf node is written to flash memory (line 8).

When a plurality of nodes are divided, a plurality of boundary keys are propagated to the parent node, and therefore, recording of the boundary key is required (line 6, 31-32). The intermediate node is updated using the boundary key to receive the propagated boundary key record from the leaf node (lines 21-24). When the rudrPzl record is inserted into the intermediate node, the partitioning is performed, and the record of the other boundary key generated at this time is also propagated to the parent node of the node (line 24, 29-32). This propagation is repeated until it reaches the root node, and the record for the intermediate node being updated is written to the flash memory (line 26).

Hereinafter, an apparatus for updating a modified B + tree for performing a node search method according to the above-described embodiment will be described. Referring to FIG. 15, the update apparatus according to the present embodiment includes an update operation queuing unit 100 for queuing an update operation with an entry of a preset operation queue in order to store an update operation inputted, an operation for sorting entries of an operation queue A queue searching unit (200) for searching a plurality of nodes corresponding to a plurality of entries of the queue according to a first algorithm, an update performing unit (400).

Each element of the updated B + tree update apparatus performs each step corresponding to the update method described above, and detailed description thereof will be omitted.

The modified B + tree update method of the present invention can be implemented by a computer-readable code on a computer-readable recording medium. A computer-readable recording medium includes all kinds of recording apparatuses in which data that can be read by a computer system is stored.

Examples of the computer-readable recording medium include ROM, RAM, CD-ROM, magnetic tape, floppy disk, optical data storage, and the like. Computer-readable code in a distributed fashion can be stored and executed. In addition, functional programs, codes, and code segments for implementing the present invention can be easily deduced by programmers skilled in the art to which the present invention belongs.

It will be apparent to those skilled in the art that various modifications, substitutions and substitutions are possible, without departing from the scope and spirit of the invention as disclosed in the accompanying claims. will be.

Therefore, the embodiments disclosed in the present invention and the accompanying drawings are intended to illustrate and not to limit the technical spirit of the present invention, and the scope of the technical idea of the present invention is not limited by these embodiments and the accompanying drawings . The scope of protection of the present invention should be construed according to the following claims, and all technical ideas within the scope of equivalents should be construed as falling within the scope of the present invention.

Claims (18)

Queuing the update operation with an entry of a preset operation queue to store the received update operation;
Searching a plurality of nodes corresponding to a plurality of entries of the queue according to a first algorithm; And
And performing an update according to the update operation of the searched plurality of nodes. 2. The method of claim 1,
Setting a search range including at least one key value based on a plurality of entries of the queue;
Generating a set of pointers comprising pointers for searching for child nodes based on the set search range;
Transmitting an I / O request in parallel using the generated pointer set; And
And retrieving a node corresponding to the entry based on the transmitted I / O request. 2. The method according to claim 1,
Further comprising the step of sorting the entries of the operation queue,
Wherein the searching step searches for a node corresponding to a plurality of entries of the sorted queue. The method according to claim 1,
Wherein the step of performing the update comprises propagating a plurality of boundary keys, which occur in response to the update of the node, to an intermediate node including a parent node of the node, wherein the intermediate node is updated according to the Pinsky. Updated B + tree. The method according to claim 1,
Wherein performing the update comprises performing a relocation and merge of the node when the node underflows according to an index delete operation. The method according to claim 1,
Wherein performing the update further comprises partitioning the node when the node overflows according to an index insertion operation. The method according to claim 1,
Wherein the updating step writes the updated node to the flash memory. 5. The method of claim 4,
Wherein the boundary key generated according to the update travels to the root node and propagates. An update operation queuing unit for queuing the update operation with an entry of a preset operation queue to store an update operation inputted;
An operation node searching unit for searching a plurality of nodes corresponding to a plurality of entries of the queue according to a first algorithm; And
And an update performing unit for performing an update according to the update operation of the searched plurality of nodes. 10. The apparatus of claim 9,
A search range setting unit for setting a search range including at least one key value based on a plurality of entries of the queue;
A pointer set generation unit for generating a pointer set composed of pointers for searching child nodes based on the set search range;
A transfer unit for transmitting an I / O request in parallel using the generated pointer set; And
And a node searching unit for searching for a node corresponding to the entry based on the transmitted I / O request. The apparatus for updating a modified B + tree according to claim 9,
And an operation queue rearranging unit for rearranging the entries of the operation queue,
Wherein the node searching unit searches for a node corresponding to a plurality of entries of the sorted queue. 10. The method of claim 9,
Wherein the update performing unit propagates a plurality of boundary keys generated according to the update of the node to an intermediate node including a parent node of the node and the intermediate node is updated according to the Fenski. Lt; / RTI &gt; 10. The method of claim 9,
Wherein the update performing unit performs relocation and merging of the node when the node underflows according to the index delete operation. 10. The method of claim 9,
Wherein the update performing unit performs a node split when the node overflows according to an index insertion operation. 10. The method of claim 9,
Wherein the update performing unit writes the updated node to the flash memory. 13. The method of claim 12,
Wherein the boundary key generated in accordance with the update propagates through the route to the root node. Queuing the update operation with an entry of a preset operation queue to store the received update operation;
Arranging entries of the operation queue;
Searching a plurality of nodes corresponding to the plurality of entries of the sorted queue according to a first algorithm; And
And performing an update according to the update operation of the searched plurality of nodes. 18. The method of claim 17,
Setting a search range including at least one key value based on a plurality of entries of the queue;
Generating a set of pointers comprising pointers for searching for child nodes based on the set search range;
Transmitting an I / O request in parallel using the generated pointer set; And
And retrieving a node corresponding to the entry based on the transmitted I / O request.

Images