KR20220106622A - Zipper compaction method and apparatus for compacting the plural of skiplists - Google Patents

Abstract

The present invention relates to a zipper compaction method and apparatus for merging a plurality of skiplists. According to one embodiment of the present invention, the zipper compaction method for merging the plurality of skiplists includes: a scanning step of storing position information in a stack in order by finding a position to insert a node of a first skiplist into a second skiplist from a head to a tail in order; and a step of merging the node of the first skiplist from the tail to the head in the second skiplist in order by using the stored position information.

Description

ZIPPER COMPACTION METHOD AND APPARATUS FOR COMPACTING THE PLURAL OF SKIPLISTS

The present invention relates to a zipper compaction method and apparatus for merging a plurality of skip lists.

ZipperDB uses the high read/write performance and byte-addressability of Persistent Memory (PM) for read amplification and write stall. It is designed to reduce problems.

The zipper database consists of several PM poolsets, and several levels exist in each pool. Zipper database stores data as skiplists instead of SSTables (Sorted-String Tables), and each level consists of one persistent skiplist. A skiplist represents an ordered data structure that can be searched, added, or removed. Skiplists can replace binary search trees, and can be quickly traversed using skip pointers. Each persistent skiplist is implemented through libpmemobj, and has a pointer to each level instead of a manifest that manages the existing file metadata.

Embodiments of the present invention are intended to provide a zipper compaction method and apparatus for merging a plurality of ski lists into one.

Embodiments of the present invention merge a plurality of skip lists to search a plurality of skip lists in a lock-free manner without other transactions holding a lock even while merging a plurality of ski lists into one To provide a zipper compaction method and apparatus for

However, the problems to be solved by the present invention are not limited thereto, and may be variously expanded in an environment within the scope not departing from the spirit and scope of the present invention.

According to an embodiment of the present invention, in a zipper compaction method performed by a zipper compaction device, a position to insert a node of a first skip list into a second skip list sequentially from a head to a tail is found and location information is stored. Scan steps to sequentially store in the stack; and sequentially merging the nodes of the first skip list from the tail to the head into the second skip list using the stored location information. A zipper compaction method for merging a plurality of skip lists can be provided. have.

In the scanning step, the first skip list may be searched along the lowest layer pointer, and location information for inserting a node of the first skip list into a second skip list may be stored in a stack.

In the scanning step, when the pointer of each layer needs to be updated in the node to be inserted while searching the first skip list, information on the node and the pointer of the first skip list to be inserted may be stored in the stack.

In the scanning step, the next node may be visited along the pointer of the lowest layer of the first skip list and a position to insert the next node in the second skip list may be searched.

In the scanning step, if the key value of the previously searched node is smaller than the key value of the currently searched node, the search may be performed again from the previous node of the highest layer instead of searching from the head.

In the merging step, the node of the first skip list may be merged into the second skip list starting from the lowest pointer by using the location information stored in the stack.

In the merging, after updating the lowest layer pointer of the node of the first skip list, the upper layer pointer of the node of the first skip list may be updated to point to the node of the second skip list.

In the merging, the uppermost layer of the node of the first skip list may be updated to point to the tail of the second skip list.

In the above method, when the read transaction is temporarily stopped while searching the first skip list and resumes again, the read thread recognizes the currently searched skip list as the first skip list, and if it cannot find the node to be searched for, merging is in progress or The method may further include restarting the search in the merged second skip list.

The method further includes the steps of: when all nodes of the first skip list are merged into a second skip list, the first skip list becomes an empty skip list having only a head node and a tail node, and the step of deleting the first skip list is further performed. may include

On the other hand, according to another embodiment of the present invention, a first memory for storing the first skip list and the second skip list; a second memory for storing one or more programs related to a zipper compaction in the permanent memory; and a processor executing the stored one or more programs, wherein the processor searches for a position in the first memory to insert a node of a first skip list into a second skip list sequentially from head to tail, and stacks the location information. A zipper compaction device for merging a plurality of skip lists, sequentially storing in the , and sequentially merging the nodes of the first skip list from the tail to the head into the second skip list using the stored location information can

The processor may search the first skip list along the lowest layer pointer, and store information about a location for inserting a node of the first skip list into a second skip list in a stack.

When the pointer of each layer needs to be updated in the node to be inserted while searching the first skip list, the processor may store information on the node and pointer of the first skip list to be inserted in the stack.

The processor may visit the next node along the pointer of the lowest layer of the first skip list and search for a position to insert the next node in the second skip list.

If the key value of the previously searched node is smaller than the key value of the currently searched node, the processor may search again from the previous node of the highest hierarchy instead of searching from the head.

The processor may retrieve and use the location information stored in the stack to merge the nodes of the first skip list into the second skip list starting from the lowest pointer.

The processor may update the upper layer pointer of the node of the first skip list to point to the node of the second skip list after updating the pointer of the lowest layer of the node of the first skip list.

The processor may update the uppermost layer of the node of the first skip list to point to the tail of the second skip list.

The processor, when the read transaction is temporarily stopped while searching the first skip list and resumes again, the read thread recognizes the currently searched skip list as the first skip list, and when a node to be searched is not found, a merge is in progress or Search may be restarted from the second skip list that has been merged.

The processor, when all nodes of the first skip list are merged into a second skip list, the first skip list becomes an empty skip list having only a head node and a tail node, and thus the first skip list may be deleted.

Meanwhile, according to another embodiment of the present invention, there is provided a non-transitory computer-readable storage medium for storing instructions that, when executed by a processor, cause the processor to execute a method, the method comprising: a node of a first skip list a scanning step of finding positions to insert into the second skip list sequentially from the head to the tail and sequentially storing the position information in a stack; and sequentially merging the nodes of the first skip list from the tail to the head into the second skip list using the stored location information.

The disclosed technology may have the following effects. However, this does not mean that a specific embodiment should include all of the following effects or only the following effects, so the scope of the disclosed technology should not be construed as being limited thereby.

Embodiments of the present invention may merge a plurality of ski lists into one.

According to embodiments of the present invention, even while merging a plurality of ski lists into one, other transactions can search a plurality of skip lists in a lock-free manner without holding a lock.

1 is a view showing a scanning process in a zipper compaction method according to an embodiment of the present invention.
2 to 8 are views illustrating a merging process in a zipper compaction method according to an embodiment of the present invention.
9 is a diagram illustrating a skip list after zipper compaction is completed in the zipper compaction method according to an embodiment of the present invention.
10 is a block diagram of a zipper compaction apparatus for merging a plurality of skip lists according to an embodiment of the present invention.
11 and 12 are flowcharts of a scanning step and a merging step in a zipper compaction method for merging a plurality of skip lists according to an embodiment of the present invention.

Since the present invention can apply various transformations and can have various embodiments, specific embodiments are illustrated in the drawings and described in detail in the detailed description. However, this is not intended to limit the present invention to a specific embodiment, it can be understood to include all transformations, equivalents or substitutes included in the spirit and scope of the present invention. In describing the present invention, if it is determined that a detailed description of a related known technology may obscure the gist of the present invention, the detailed description thereof will be omitted.

Terms such as first, second, etc. may be used to describe various elements, but the elements are not limited by the terms. The terms are used only for the purpose of distinguishing one component from another.

The terms used in the present invention are only used to describe specific embodiments, and are not intended to limit the present invention. The terms used in the present invention have been selected as currently widely used general terms as possible while considering the functions in the present invention, but these may vary depending on the intention, precedent, or emergence of new technology of those of ordinary skill in the art. In addition, in a specific case, there is a term arbitrarily selected by the applicant, and in this case, the meaning will be described in detail in the description of the corresponding invention. Therefore, the term used in the present invention should be defined based on the meaning of the term and the overall content of the present invention, rather than the name of a simple term.

The singular expression includes the plural expression unless the context clearly dictates otherwise. In the present invention, terms such as "comprises" or "have" are intended to designate that the features, numbers, steps, operations, components, parts, or combinations thereof described in the specification exist, but one or more other features It is to be understood that this does not preclude the possibility of the presence or addition of numbers, steps, operations, components, parts, or combinations thereof.

Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings, and in the description with reference to the accompanying drawings, the same or corresponding components are given the same reference numerals, and the overlapping description thereof will be omitted. do.

1 is a view showing a scanning process in a zipper compaction method according to an embodiment of the present invention.

1 shows a skip list having a small size of level K-1 and a skip list having a large size of level K, in which zipper compaction is to be performed. The skiplist having a small size of level K-1 includes node 3, node 12, and node 14, and the skiplist having a large size of level K includes node 7, node 10, and node 17. Here, it is assumed that a skip list having a small size is merged into a skip list having a large size. The merged skip list is not limited in size, and a small skip list may be merged into a large skip list. In this case, according to an embodiment of the present invention, a skip list having a small size is designated as a first skip list, and a skip list having a large size is designated as a second skip list. Conversely, in an embodiment, a skip list having a large size may be designated as a first skip list, and a skip list having a small size may be designated as a second skip list.

First, the zipper compaction apparatus performs a scan process for compaction of a skip list having a small size of level K-1 and a skip list having a large size of level K-1. Nodes that need to be changed in the scan process are saved by pushing them on the stack. A skip list with a small size of level K-1 is searched along the lowest hierarchical pointer. First, the first node (node 3) searches a skip list with a large size of level K and finds an insertion position. In addition, while searching the skip list having a large size of K of level K, it is checked whether the pointer of each layer needs to be updated in node 3. Here, the value of the pointer is not changed immediately, only the pointer information is stored on the stack. In FIG. 1 , since H0 and H1 of the skip list having a large size of level K need to be updated to point to node 3, H0 and H1 are stored together with node 3 in the stack.

After step ①, the next node 12 is visited following the pointer of the lowest layer of the skip list with a small size of level K-1, and a position to insert the node 12 from the skip list with a large size of level K is found. Also, in each layer, node 10 of level K, which is located immediately before node 12, is stored along with node 12 in the stack. In the example above, R3, R2, R1, and R0 are stored with node 12.

After step ②, the next node 14 is visited by following the lowest layer pointer of node 12. Here, it is not necessary to search for a skiplist node with a large size of level K to be connected with a skiplist node with a small size of level K-1 from the skip list head every time, because the previously searched key (12) value This is because it is smaller than the current key (14) value. Therefore, instead of searching from the head, the search starts again from the previous highest layer. In FIG. 1 , when searching for node 14, a search is performed from R3 of the skip list having a large size of level K.

2 to 8 are views illustrating a merging process in a zipper compaction method according to an embodiment of the present invention.

After the scanning process of FIG. 1 , the zipper compaction device updates the corresponding pointer while removing the pointer from the stack during the merging process, and compacts the skip list from the tail to the head in sequence.

As in the example of FIG. 2 , the pointer of the lowest layer of node 14 is modified to point to node 17 and clwb (cache line wite back) is called to ensure persistence (S101). In the situation of FIG. 2 in which the lowest layer of node 14 is connected to node 17, the upper layer pointer (next[1]) of node 14 is not modified to point to node 17. It can be thought that this may affect the search, but the remaining layers except for layer 0 are probabilistic shortcuts to the next node, and do not affect the correct search result. Therefore, it is not necessary to update the remaining layers except for layer 0 atomically.

After updating the lower layer pointer of node 14, the upper layer pointer of node 14 is updated to point to node 17 as shown in FIG. 3 after FIG. 2 (S102).

Thereafter, node 12, which is the next node, is taken out from the stack and the pointer is updated (S103). In FIG. 4 , the uppermost layer of node 12 points to the tail of level K, and the next layer is updated to point to node 17 .

In subsequent processes of FIGS. 5 and 6 , the rightmost node in each layer is updated as in the process of FIG. 4 . In FIG. 5, the layer pointer of node 10 is updated to point to node 12 (S104 and S105). In FIG. 6, the layer pointer of node 7 is updated to point to node 12 (S106).

Next, as in FIGS. 7 and 8 , node 3 is taken out of the stack and the pointer of node 3 and the rightmost node of each layer are updated. In FIG. 7, the lowest pointer of node 3 is updated to point to node 7 (S107), and H0 of the skip list having a large level K is updated to point to node 3 (S108). And in FIG. 8, the upper pointer of node 3 is updated to point to node 7 (S107), and H1 of the level K skip list is updated to point to node 3 (S108). After that, the head part of level K-1 is not used.

9 is a diagram illustrating a skip list after zipper compaction is completed in the zipper compaction method according to an embodiment of the present invention.

9 shows a skip list after zipper compaction is completed.

The fail-atomic 8-byte store instruction used by the zipper compaction algorithm ensures that the read thread simultaneously finds the correct data while merging two skiplists. For example, the read thread is guaranteed to return a correct result even if it simultaneously accesses the skip list in any state shown in the figures of FIGS. 1 to 9 .

Conversely, consider a case where a read transaction is suspended while the background compaction thread is performing zipper compaction. If a read transaction is temporarily aborted while searching for a small skiplist of level K-1, which is a low level, and is resumed, the existing skiplist with a small size of level K-1 is a skip list with a large size of level K or a higher level. It may be being compacted into a list. In this case, the read thread cannot know whether the level of the skip list is changed in the middle. As in the conventional method, when a read thread searches for a key, it may move to the tail node of the skip list of level K-1, level K, or higher. However, since the read thread recognizes the skip list it is currently searching for as level K-1, if it does not find the node it is looking for after completing the level K-1 search, it searches again in the level K skip list where compaction is in progress. Start. One embodiment of the present invention ensures that a read transaction returns a correct search result, although it may revisit an already visited node multiple times.

10 is a block diagram of a zipper compaction apparatus for merging a plurality of skip lists according to an embodiment of the present invention.

As shown in FIG. 10 , the zipper compaction apparatus 100 for merging a plurality of skip lists according to an embodiment of the present invention includes a first memory 110 , a second memory 120 , and a processor 130 . includes However, not all illustrated components are essential components. The zipper compaction apparatus 100 for merging a plurality of skip lists may be implemented by more elements than the illustrated elements, and a zipper compaction apparatus for merging a plurality of skip lists by fewer elements ( 100) can be implemented.

Hereinafter, a detailed configuration and operation of each component of the zipper compaction apparatus 100 for merging a plurality of skip lists of FIG. 10 will be described.

The first memory 110 stores a skip list having a small size and a skip list having a large size. The first memory 110 is not limited to a specific memory and may be implemented as a non-volatile memory or a volatile memory.

The second memory 120 stores one or more programs related to the zipper compaction in the first memory 110 .

The processor 130 executes one or more programs stored in the second memory 120 . The processor 130 scans the skip list by storing position information to insert the nodes of the small skip list into the large skip list sequentially from head to tail in the stack, and uses the stored position information to skip the small size. Merge the nodes of the list from tail to head into the skip list of larger size.

According to embodiments, the processor 130 may search for a skip list with a small size along a pointer of a lowermost layer, and store information about a location for inserting a node of a small skip list into a large skip list in a stack.

According to embodiments, when the pointer of each layer needs to be updated in the node to be inserted while searching the skip list having a small size, the processor 130 may store information on the node and the pointer of the skip list having the small size to be inserted in the stack. have.

According to embodiments, the processor 130 may visit the next node by following the pointer of the lowermost layer of the small skip list and search for a position to insert the next node in the large skip list.

According to embodiments, if the key value of the previously searched node is smaller than the key value of the currently searched node, the processor 130 may search again from the previous highest layer instead of searching from the head.

According to embodiments, the processor 130 may retrieve and use the location information stored in the stack to merge the nodes of the skip list with the smallest size into the skip list with the largest size from the lowest pointer.

According to embodiments, the processor 130 updates the lowermost layer pointer of the node of the small skip list and then updates the upper layer pointer of the node of the small skip list to point to the node of the large skip list. can do.

According to embodiments, the processor 130 may update the uppermost layer of the node of the small skip list to point to the tail of the large skip list.

According to embodiments, the processor 130 temporarily stops the read transaction while searching the small skip list and resumes again, the read thread recognizes the currently searched skip list as a small skip list, and performs the search. If a node is not found, the search can resume on a large skiplist where compaction is in progress.

According to embodiments, the processor 130 may delete the small skip list having only the head node and the tail node by merging all nodes of the skip list with the small size into the skip list with the large size.

11 and 12 are flowcharts of a scanning step and a merging step in a zipper compaction method for merging a plurality of skip lists according to an embodiment of the present invention.

The zipper compaction method for merging a plurality of skip lists shown in FIGS. 11 and 12 is performed by the zipper compaction apparatus 100 . The scan phase shown in FIG. 11 will be described, and the merge phase shown in FIG. 12 will be described.

In step S201, the zipper compaction apparatus 100 starts a scanning step. Here, in step S201, lowSkipList and lowNode indicate a skip list and node having a small size of level K-1, and upperSkipList and upperNode indicate a skip list and node having a large size of level K.

In step S202, the zipper compaction device 100 calculates (1) lowNode = lowSkipList.head.next, (2) Rightmost[] = upperSkipList.head.next, (3) curLayer = MaxLayer, (4) upperNode = upperSkipList. set as head.

In step S203, the zipper compaction apparatus 100 checks whether lowNode is NULL.

In step S204, if the lowNode is not NULL, the zipper compaction apparatus 100 checks whether curLayer is not 0 or the key of the next node of upperNode is less than or equal to the key of lowNode.

In step S205, the zipper compaction apparatus 100 determines that if curLayer is not 0 or the key of the next node of upperNode is less than or equal to the key of lowNode, the next node of upperNode is a tail or upperNode Checks whether the key of the next node of is greater than the key of lowNode.

In step S206, the zipper compaction apparatus 100 determines that if the next node of upperNode is a tail or the key of the next node of upperNode is not greater than the key of lowNode, (1) upperNode = upperNode.next As in [curLayer] , the next node of upperSkipList is visited, and a pointer to the upperNode in the current layer is stored in the rightmost array as in (2) rightmost[curLayer] = upperNode . And the zipper compaction apparatus 100 performs step S204.

In step S207, if the next node of upperNode is a tail or the key of the next node of upperNode is greater than the key of lowNode, the zipper compaction device 100 determines the next layer as curLayer = curLayer - 1 explore And the zipper compaction apparatus 100 performs step S204.

On the other hand, in step S208, the zipper compaction device 100 has a rightmost[] pointer that should point to lowNode and lowNode if curLayer is not 0 or the key of the next node of upperNode is greater than the key of lowNode. store them on the stack.

In step S209, the zipper compaction apparatus 100 designates the next node of the lowNode as a lowNode as shown in (1) lowNode = lowNode.next[0], and (2) upperNode as the uppermost layer as shown in upperNode = rightmost[MaxLayer]. , and (3) curLayer = MaxLayer, setting the current level as the top layer. And the zipper compaction apparatus 100 performs step S203.

Thereafter, in step S204 , if the lowNode is NULL, the zipper compaction apparatus 100 performs the merge phase shown in FIG. 12 .

Meanwhile, as shown in FIG. 12 , in step S301 , the zipper compaction apparatus 100 starts the merging step.

In step S302, the zipper compaction apparatus 100 checks whether the stack is empty.

In step S303, if the stack is not empty, the zipper compaction apparatus 100 removes (1) (lowNode, rightmost[]) from the stack, and (2) sets h (layer) to the lowest layer 0.

In step S304, the zipper compaction apparatus 100 checks whether h is the highest layer of lowNode.

In step S305, if h is not the highest layer of lowNode, the zipper compaction apparatus 100 checks whether the key of the next node of rightmost[h] is smaller than the key of the next node of lowNode. The zipper compaction apparatus 100 performs step S302 when h is the highest layer of lowNode.

In step S306, the zipper compaction device 100 determines that if the key of the next node of rightmost[h] is smaller than the key of the next node of lowNode, (1) lowNode.next[h] = rightmost[h].next, ( 2) Rightmost[h].next = lowNode, (3) h=h+1 is performed, and step S304 is performed. If the key of the next node of rightmost[h] is not smaller than the key of the next node of lowNode, the zipper compaction apparatus 100 performs step S304.

Meanwhile, in step S307, if the stack is empty, the zipper compaction apparatus 100 ends the merging step.

On the other hand, a non-transitory computer-readable storage medium for storing instructions that, when executed by a processor, cause the processor to execute a method, the method comprising: transferring a node of a first skiplist from head to tail into a second a scanning step of finding a position to be inserted into the skip list and sequentially storing the position information in a stack; and sequentially merging the nodes of the first skip list from the tail to the head into the second skip list using the stored location information.

Meanwhile, according to an embodiment of the present invention, the various embodiments described above are implemented as software including instructions stored in a machine-readable storage media readable by a machine (eg, a computer). can be The device is a device capable of calling a stored command from a storage medium and operating according to the called command, and may include an electronic device (eg, the electronic device A) according to the disclosed embodiments. When the instruction is executed by the processor, the processor may perform a function corresponding to the instruction by using other components directly or under the control of the processor. Instructions may include code generated or executed by a compiler or interpreter. The device-readable storage medium may be provided in the form of a non-transitory storage medium. Here, 'non-transitory' means that the storage medium does not include a signal and is tangible, and does not distinguish that data is semi-permanently or temporarily stored in the storage medium.

In addition, according to an embodiment of the present invention, the method according to the various embodiments described above may be provided by being included in a computer program product. Computer program products may be traded between sellers and buyers as commodities. The computer program product may be distributed in the form of a machine-readable storage medium (eg, compact disc read only memory (CD-ROM)) or online through an application store (eg, Play Store™). In the case of online distribution, at least a portion of the computer program product may be temporarily stored or temporarily generated in a storage medium such as a memory of a server of a manufacturer, a server of an application store, or a relay server.

In addition, according to an embodiment of the present invention, the various embodiments described above are stored in a recording medium readable by a computer or a similar device using software, hardware, or a combination thereof. can be implemented in In some cases, the embodiments described herein may be implemented by the processor itself. According to the software implementation, embodiments such as the procedures and functions described in this specification may be implemented as separate software modules. Each of the software modules may perform one or more functions and operations described herein.

Meanwhile, computer instructions for performing the processing operation of the device according to the above-described various embodiments may be stored in a non-transitory computer-readable medium. The computer instructions stored in the non-transitory computer-readable medium, when executed by the processor of the specific device, cause the specific device to perform the processing operation in the device according to the various embodiments described above. The non-transitory computer-readable medium refers to a medium that stores data semi-permanently, rather than a medium that stores data for a short moment, such as a register, cache, memory, etc., and can be read by a device. Specific examples of the non-transitory computer-readable medium may include a CD, DVD, hard disk, Blu-ray disk, USB, memory card, ROM, and the like.

In addition, each of the components (eg, a module or a program) according to the above-described various embodiments may be composed of a single or a plurality of entities, and some of the above-described sub-components may be omitted, or other components may be omitted. Sub-components may be further included in various embodiments. Alternatively or additionally, some components (eg, a module or a program) may be integrated into a single entity to perform the same or similar functions performed by each corresponding component prior to integration. According to various embodiments, operations performed by a module, program, or other component are executed sequentially, parallel, iteratively, or heuristically, or at least some operations are executed in a different order, are omitted, or other operations are added. can be

In the above, preferred embodiments of the present invention have been illustrated and described, but the present invention is not limited to the specific embodiments described above, and is commonly used in the technical field pertaining to the present disclosure without departing from the gist of the present invention as claimed in the claims. Various modifications are possible by those having the knowledge of, of course, and these modifications should not be individually understood from the technical spirit or perspective of the present invention.

100: zipper compaction device
110: first memory
120: second memory
130: processor

Claims (21)

A zipper compaction method performed by a zipper compaction device, the method comprising:
a scanning step of finding positions at which nodes of the first skip list are to be inserted into a second skip list sequentially from head to tail, and sequentially storing position information in a stack; and
and sequentially merging the nodes of the first skip list from a tail to a head into a second skip list by using the stored location information. According to claim 1,
The scanning step is
A zipper compaction method for merging a plurality of skip lists, wherein information on a location for inserting a node of the first skip list into a second skip list is stored in a stack by searching the first skip list along a lowermost hierarchical pointer. According to claim 1,
The scanning step is
Zipper compaction for merging a plurality of skip lists by storing the node and pointer information of the first skip list to be inserted in a stack when the pointer of each layer needs to be updated at the node to be inserted while searching the first skip list Way. According to claim 1,
The scanning step is
A zipper compaction method for merging a plurality of skip lists, comprising visiting a next node along a pointer of a lowermost layer of a first skip list and searching for a position to insert a next node in a second skip list. According to claim 1,
The scanning step is
A zipper compaction method for merging a plurality of skip lists, in which, if the key value of the previously searched node is smaller than the key value of the currently searched node, search again from the previous node of the highest hierarchy instead of searching from the head. According to claim 1,
The merging step is
A zipper compaction method for merging a plurality of skip lists, wherein the node of the first skip list is merged into a second skip list from the lowest pointer by using the location information stored in the stack. According to claim 1,
The merging step is
Zipper compact for merging a plurality of skip lists, after updating the lowest layer pointer of the node of the first skip list, updating the upper layer pointer of the node of the first skip list to point to the node of the second skip list Sean method. According to claim 1,
The merging step is
A zipper compaction method for merging a plurality of skip lists, wherein the uppermost layer of the node of the first skip list is updated to point to the tail of the second skip list. According to claim 1,
If the read transaction is temporarily stopped while searching the first skiplist and resumes again, the read thread recognizes the currently searched skiplist as the first skiplist, and if it cannot find the node to be searched for, it is the first skiplist in which the merge is in progress or the merge is completed. 2 A zipper compaction method for merging a plurality of skiplists, further comprising the step of restarting the search in the skiplist. According to claim 1,
When all nodes of the first skip list are merged into a second skip list, the first skip list becomes an empty skip list having only a head node and a tail node, and the method further comprises the step of deleting the first skip list. Zipper compaction method for merging the skiplist of a first memory for storing the first skip list and the second skip list;
a second memory for storing one or more programs related to a zipper compaction in the permanent memory; and
a processor executing the stored one or more programs;
The processor finds a position in the first memory to insert the nodes of the first skip list into the second skip list sequentially from the head to the tail, and sequentially stores the location information in the stack,
A zipper compaction apparatus for merging a plurality of skip lists, sequentially merging nodes of the first skip list from a tail to a head into a second skip list using the stored location information. 12. The method of claim 11,
The processor is
A zipper compaction apparatus for merging a plurality of skip lists, wherein information on a location for inserting a node of the first skip list into a second skip list is stored in a stack by searching the first skip list along a lowermost hierarchical pointer. 12. The method of claim 11,
The processor is
Zipper compaction for merging a plurality of skip lists by storing the node and pointer information of the first skip list to be inserted in a stack when the pointer of each layer needs to be updated at the node to be inserted while searching the first skip list Device. 12. The method of claim 11,
The processor is
A zipper compaction apparatus for merging a plurality of skip lists, which visits the next node along the pointer of the lowest layer of the first skip list and searches for a position to insert the next node in the second skip list. 12. The method of claim 11,
The processor is
A zipper compaction device for merging a plurality of skip lists, in which, when the key value of the previously searched node is smaller than the key value of the currently searched node, the search is performed again from the previous node of the highest hierarchy instead of searching from the head. 12. The method of claim 11,
The processor is
A zipper compaction apparatus for merging a plurality of skip lists, wherein the node of the first skip list is merged into a second skip list from the lowest pointer by using the location information stored in the stack. 12. The method of claim 11,
The processor is
Zipper compact for merging a plurality of skip lists, after updating the lowest layer pointer of the node of the first skip list, updating the upper layer pointer of the node of the first skip list to point to the node of the second skip list Sean device. 12. The method of claim 11,
The processor is
A zipper compaction apparatus for merging a plurality of skip lists, for updating the uppermost layer of the node of the first skip list to point to the tail of the second skip list. 12. The method of claim 11,
The processor is
If the read transaction is temporarily stopped while searching the first skiplist and resumes again, the read thread recognizes the currently searched skiplist as the first skiplist, and if it cannot find the node to be searched for, it is the first skiplist in which the merge is in progress or the merge is completed. 2 Zipper compaction device for merging a plurality of skiplists, restarting the search in the skiplist. 12. The method of claim 11,
The processor is
When all nodes of the first skip list are merged into a second skip list, the first skip list becomes an empty skip list having only a head node and a tail node, and a plurality of skip lists are merged to delete the first skip list. Zipper compaction device for A non-transitory computer-readable storage medium for storing instructions that, when executed by a processor, cause the processor to execute a method, the method comprising:
a scanning step of finding positions at which nodes of the first skip list are to be inserted into a second skip list sequentially from head to tail, and sequentially storing position information in a stack; and
and sequentially merging the nodes of the first skip list from the tail to the head into the second skip list by using the stored location information.

Images