|Publication number||US7383276 B2|
|Application number||US 10/768,527|
|Publication date||Jun 3, 2008|
|Filing date||Jan 30, 2004|
|Priority date||Jan 30, 2004|
|Also published as||US20050171960, US20080071809|
|Publication number||10768527, 768527, US 7383276 B2, US 7383276B2, US-B2-7383276, US7383276 B2, US7383276B2|
|Inventors||David B. Lomet|
|Original Assignee||Microsoft Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (2), Non-Patent Citations (9), Referenced by (17), Classifications (14), Legal Events (5)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This invention relates to methods and systems for data storage. More particularly, this invention relates to methods and systems for utilizing B-trees for storing data, maintaining a robust and simple data structure and allowing high concurrency of access.
A B-tree is a tree structure which stores data, and allows operations to find, delete, insert, and browse the data. Each data record stored in a B-tree has an associated key. In order to be used for a B-tree, these keys must be orderable according to a predetermined function. For example, the keys may be numeric, in which case the ordering may be from least to greatest. As another example, the keys may be names, in which case the ordering may be alphabetical.
A B-tree is height-balanced, so all leaves are at the same level of the tree. Insertions and deletions of records to the B-tree are managed so that the height-balanced property of the B-tree is maintained. The insertion of a new data record may require the split of a node into two nodes; a deletion may require the deletion of a node. Insertion and deletion procedures must maintain the properties of the B-tree (e.g. height balance) in order to ensure that they result in valid B-trees.
Each B-tree leaf contains one or more of the stored records in one of a disjoint set of ranges of key values, while each index node (non-leaf node) of a B-tree provides access to a range of key values stored in one or more adjacent key ranges contained in data nodes. Each index node of the B-tree stores, for each of its child nodes, an ordered pair consisting of a key value within the range and a pointer to the child node. The key values break the range of key values represented by the node into sub-ranges, and the pointers to a leaf within the sub-range (if the index node is one level above the leaf level) or point to an index node corresponding to that sub-range.
It can be seen that an index node will have as many ordered pairs of <key, pointer> as it has child nodes. The range represented by each index node need not be explicitly stored in the index node. In the sub-tree of
To search a B-tree for a record, the search begins at the root node and follows pointers from node to node based on the key value for the record being sought, descending down the tree, until either the key is located or the search fails because a leaf node is reached which does not contain a record with the key being searched for. For example, if the record with key value 113 is being sought, when index node 1000 is reached, the key values are consulted. Since the key value being sought is greater than the key value in the rightmost pair in node 1000, the pointer 1040 from that pair is followed. Node 1045 is reached. When the key values are consulted, it can be seen that pointer 1048 should be followed to find any record with a key value 109≦v≦122. This pointer 1048 leads to the appropriate leaf from leaves 1010 which contains the record for the specified key value. If a record was searched for with a key value of 112, the search would end in the same location, but because no record is found with that key value in the leaf node, the search would return an unsuccessful result.
When a node has the maximum number of key values (when there is not sufficient space for any additional index term or data record), if a new key value must be inserted into the range covered by the node, the node will be split. In order to ensure that concurrent accesses are not reading data from the node during the split, it is necessary to deny concurrent access to the node being changed. Because two nodes will now hold the information previously held by the node being split, an additional link is necessary in the parent node of the node being split. Concurrent accesses to that parent node must therefore be denied while the parent is updated. If the addition of a new key value and pointer in the parent node will overfill the parent node, the parent node will be split as well. It can be seen that node insertions may cause splits recursively up the B-tree. This may require that a node high in the tree be locked while nodes much further down in the tree are being split, and while the split slowly propagates its way up to the locked node. This greatly impairs concurrent access to the tree. The necessity for a number of locks or latches to prevent concurrent accesses to nodes being changed slows access to the information stored in the B-tree by limiting concurrent access.
A Blink-tree is a modification of the B-tree which addresses this issue.
One benefit of using these side pointers is to enable highly concurrent operation by allowing splits to occur with each atomic action of the split involving only one level of the tree. With B-link trees, in order for a split to occur on a full node the contents of the full node are divided (one atomic action), and a new index term is posted to the parent (second atomic action). This avoids the situation in which multiple levels of the tree are involved in a single atomic action. If a split is occurring in a node at the same time that a search is being performed for a key value in the range for that node, and the node has been split, with the lefthand node replacing the node which has been split, the tree can be traversed to find data even if no index term has yet been inserted into the parent of the node for the righthand node from the new pair. In such a case, the parent node will point to the lefthand node, and if the data is not found in the lefthand node, the side pointer of the lefthand node provides access to the righthand node. Thus a node split need not be a single atomic operation with the parent and child nodes both inaccessible until the split is completed.
In B-trees and Blink-trees, latches are used in order to provide mutual exclusion when a node split or node deletion is occurring. A latch is a low-cost, usually short-duration lock, one which does not include deadlock control. Hence, it is not necessary to access a lock manager in order to acquire or release a latch. Latches are therefore more lightweight than locks; they typically require only tens of instructions, not hundreds like locks. They prevent access of incorrect or outdated data during concurrent access of the data structure by allowing only an updater holding the latch to use the resource that has been latched.
Because no deadlock control exists for latches, a partial ordering is imposed on latches. The holder of a latch on a parent node may request the latch for a child node of that parent node. Latches can propagate downward. However, the holder of a latch on a child node can not request the latch for the parent without first releasing its latch on the child; latches do not propagate upwards. In this way, the deadlock situation in which the holder of a latch for parent node A is requesting a latch for child node B at the same time that the holder of a latch for child node B requests a latch for parent node A is avoided. In a standard B-tree, the latch must be maintained for the node being updated, and for the parent of that node (and possibly for multiple ancestors up the tree, even perhaps to the root), so the pointers and key values in the parent can be modified to reflect the change. If the latch is not maintained for the parent, the tree can become inconsistent. The latches must typically be maintained for all the nodes on the path to a leaf node that may need to be updated because of a node split at the leaf.
In a Blink-tree, however, a latch is not required on the parent node (and any further ancestors) while the child node is being split. As described above, where the child node has been latched for the node split, the parent latch need not be held during the child node split, while the new nodes have been created but the parent node for these new nodes has not yet been updated. A node split therefore need not be an atomic operation that includes posting the index term to the parent, but can be divided into two parts (“half splits”), the first “half split” where a child node is split, moving some data from an old node to a new node, and setting up a side link from the old node to the new node. After such a “half split” the Blink-tree will be well formed. A subsequent second “half split” posts an index term to the parent node.
However, there is a risk that several changes (node deletes, described below, and splits) will occur, and that when the parent node is changed to reflect the new child node, that that child node will no longer exist. To guard against this requires that the existence of the child node be re-verified, which requires re-visiting the left-hand (originally full) node and ensuring that the side pointer for that node still references the right-hand (new) node. Additionally, when a node split occurs, the path to the node being split is remembered. There is a risk that when the key value and pointer for the split is to be added to the remembered parent node, that parent node no longer exists because it may have been deleted. Guarding against this requires a tree re-traversal which is resource intensive. Thus, the prior art methods of B-link node splitting incur extra execution costs, which in turn limit concurrency and throughput, and increase the complexity of the implementation.
A Blink-tree data structure, method and system is presented which includes the advantages of B-tree data structures and conventional Blink-tree data structures, yet allows highly concurrent access of the data and deals robustly with node deletion.
In order to do this, the “delete state” is tracked for a Blink-tree data structure. This delete state is guaranteed to capture when a node among some set of nodes has been deleted. Thus, the absence of state indicating that any node among the set of nodes has been deleted ensures that some specific node in that set has not been deleted. Two delete states are tracked to deal separately with the two complications resulting from node deletes: (i) a parent to which an index term is scheduled to be posted may have been deleted; (ii) a new node for which an index term is scheduled to be posted may have been deleted. By tracking delete states, Blink-tree node split operations avoid tree re-traversals to find the parent node to be updated; and they avoid having to verify that a newly created node whose index term is scheduled to be posted still exists. Additionally, split operations are divided into two atomic operations, and the second atomic operation does not need to be completed for the tree to be used. The two atomic operations allow for high concurrency, and the tolerance for “lazy” scheduling of the second atomic operation (index term posting) is a simple solution which allows for easy implementation and coherence.
For a target node to be split, first, the side pointer and a portion of the stored data is moved to a new index node and the side pointer of the target node is set to point to the new index node. Then, a post operation is queued. When this operation is performed, the information regarding the new index node is posted to the parent node. Should a node delete be detected that might cause the need to re-traverse the tree to find a parent, or to re-verify that a new node still exists, the index term posting half of the node split operation is terminated, thus avoiding making this more complex and expensive. Such incomplete posting of index terms are completed when it is detected that the index term is missing in a subsequent traversal of the tree.
Other features of the invention are described below.
The foregoing summary, as well as the following detailed description of preferred embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the invention, there is shown in the drawings exemplary constructions of the invention; however, the invention is not limited to the specific methods and instrumentalities disclosed. In the drawings:
The first tracked delete state, the index delete state (DX) indicates whether it is safe to directly access a parent node (hence an index node, not a data node) without re-traversing the B-tree. DX contains this information for all nodes above the leaf level; and in one embodiment it is maintained outside of the tree since any index node may be deleted. DX (nodeA) can be consulted to determine that index nodeA may have been deleted, or that index nodeA cannot have been deleted. In one embodiment, DX(n) is a binary function over all index nodes n in the B-tree, with one possible value indicating that the node cannot have been deleted, and the other possible value indicating that the node may have been deleted. In another embodiment, DX is a counter which is incremented when an index node has been deleted, so that a change in DX indicates that a node delete has occurred, while no change means that no nodes have been deleted since the earlier inspection of DX.
The second tracked delete state, data delete state (DD) indicates whether it is safe to post an index term for a leaf node that resulted from a data node split. Since we access the parent of the leaf node resulting from a split in any event to post the index term, the DD state can be stored in the parent, and where each node is assigned to a disk page, without incurring any extra I/O to access the page. Leaf node deletes are much more common than index node deletes, and so there is real value to localizing leaf node deletes to a sub-tree without requiring additional latching. A DD state is maintained in each level 1 node (nodes which are parents of a leaf). In one embodiment, DD is a binary function over all leaf nodes and DD (nodeB) returns one value if leaf nodeB may have been deleted, and another if leaf nodeB cannot have been deleted. For index nodes which are higher up in the tree, DX is used for this verification.
In one embodiment, for both delete state tests, the value indicating that the node may have been deleted may be returned even when the node being asked about has not been deleted. In one embodiment, if this value is returned, further activity on the node is abandoned or postponed. No index term will be posted. The absence of a posted index term will be re-discovered when a Blink-tree traversal is required to include a side link traversal. The abandonment of the posting of the index term when delete states indicate that a node may have been deleted allows concurrency to be accomplished in a simple manner. The tree will always allow searches to be executed correctly, and where an index node posting is abandoned due to the delete state, subsequent actions will allow the missing index node posting to be discovered and requeued. This allows the node split to be simple and avoids retraversals, and yet allows for a way for such node postings to be detected and performed later.
In another embodiment, the tree is re-traversed when the node may have been deleted. This may cause a delay while the presence of the node is found (or while the correct node which is the parent of the node being split or deleted is found). However, deletions and splits of nodes will still occur correctly, and will enable index terms to be propagated up the tree correctly despite this delay.
Because a Blink-tree is used, the tree remains search correct even when index terms are missing. Since the delete state need only be checked during structure modifications, normal Blink-tree operations can be almost completely unaffected.
In one embodiment, delete states are maintained as binary functions for each node. In another embodiment, delete states are maintained as counters for a group of nodes, which are updated when a node is deleted.
Exemplary Computing Environment
The invention is operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well known computing systems, environments, and/or configurations that may be suitable for use with the invention include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, embedded systems, distributed computing environments that include any of the above systems or devices, and the like.
The invention may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network or other data transmission medium. In a distributed computing environment, program modules and other data may be located in both local and remote computer storage media including memory storage devices.
With reference to
Computer 110 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 110 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CDROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can accessed by computer 110. Communication media typically embodies computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.
The system memory 130 includes computer storage media in the form of volatile and/or nonvolatile memory such as read only memory (ROM) 131 and random access memory (RAM) 132. A basic input/output system 133 (BIOS), containing the basic routines that help to transfer information between elements within computer 110, such as during start-up, is typically stored in ROM 131. RAM 132 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 120. By way of example, and not limitation,
The computer 110 may also include other removable/non-removable, volatile/nonvolatile computer storage media. By way of example only,
The drives and their associated computer storage media discussed above and illustrated in
The computer 110 may operate in a networked environment using logical connections to one or more remote computers, such as a remote computer 180. The remote computer 180 may be a personal computer, a server, a router, a network PC, a peer device or other common network node, and typically includes many or all of the elements described above relative to the computer 110, although only a memory storage device 181 has been illustrated in
When used in a LAN networking environment, the computer 110 is connected to the LAN 171 through a network interface or adapter 170. When used in a WAN networking environment, the computer 110 typically includes a modem 172 or other means for establishing communications over the WAN 173, such as the Internet. The modem 172, which may be internal or external, may be connected to the system bus 121 via the user input interface 160, or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 110, or portions thereof, may be stored in the remote memory storage device. By way of example, and not limitation,
Blink-tree with Delete States
A Blink-tree according to one embodiment of the invention is shown in
As shown in
According to one embodiment of the invention, the normal data record operations of reading a record, range reading records, inserting a record, updating a record, and deleting a record are supported. To implement one embodiment of the invention, latches come in multiple modes: share, update, and exclusive. These latch modes support different levels of concurrent access.
An exclusive latch on a resource prohibits other latches from being obtained for the resource, and can only be obtained if no other latch is held on the resource. No other latches are allowed if an exclusive latch is held. A share latch is compatible with other share latches, and with another type of latch known as an update latch. Share latches allow reading of the resource but not modification of it. Only one update latch may be held on a resource at one time though share latches may be held on it concurrently; update latches are used to allow a user to upgrade the latch to an exclusive latch without relinquishing the update latch. Users with a share latch may not upgrade to an exclusive latch without first releasing control of the resource.
Because adding records and deleting records may require changes in the structure of the tree (deletion or addition of index nodes), node deletion and node split operations may be necessitated by the addition or deletion of records and the structural requirements of the Blink-tree.
To use the tree, according to one embodiment of the invention, several functions/operations are supported. These include:
Tree Traversal—traversal of a tree to find a desired node. This node may be a leaf node or an internal node. This is used to find a node for a user (for example for a record lookup) and also to provide traversal for other operations;
Node Update—inserting, modifying, or deleting information in a node;
Node Split—splitting a node into two separate nodes, in order to accommodate more information at that point in the tree than can fit into one node. According to one embodiment of the invention, this is performed in two distinct “half-split” operations, with the second half-split capable of being queued to be performed later (or abandoned, if the tree has changed too much to make it a simple change.);
Access Parent—used to access a parent node and to check if a deletion may have occurred, in order to allow simplicity in splitting nodes and realize the efficiency gain from keeping the delete states;
Post Index Term—used to post an index term to a node, in order to perform the second part of a node split operation; and
Delete Node—used to delete a node, in order to consolidate index nodes with low occupancy.
A more complete description of these operations, according to one embodiment, is supplied below.
In order to perform operations on the tree, the tree must be traversed to find the desired node. The node may be a leaf node or an intermediate node. Because nodes may be split or deleted, and a parent node may not contain index terms for all its child nodes, traversals may occur which utilize side pointers rather than pointers which appear as part of an index pair.
With reference again to
The tree traversal operation, in one embodiment, proceeds according to the following pseudocode, where tree traversal begins with nodeA, (which has been latched), the key value being searched for is K and the requested level of the node to be found is R:
In one embodiment, the tree traversal also receives data as to the requested type of latch to be used.
In order to read a record with a given key, the tree is traversed to find the leaf node which will contain the desired key if it exists. When tree traversal is being done to perform a read operation, a share latch is obtained for the each node in the path to the leaf node as the tree is being traversed. Once the appropriate leaf node is returned, a read operation is performed.
Thus a read node operation can, in one embodiment, be represented by the following pseudocode, where “Traverse” is the tree traversal operation detailed above and “root” is the root node of the tree:
An update to a node is similar to the reading of a node, except that the latch obtained before the update must be exclusive, rather than shared. Thus, an update of a node consists of a tree traverse to the node followed by an insert, modify or delete of the node via an update operation. During the traversal, nodes are latched in share mode until a leaf node for the record to be inserted, updated, or deleted is reached. The leaf node is then latched with an update latch, and an exclusive latch is obtained when we confirm that the node accessed is the desired node (which, to find it, may require further side traversal). The leaf node is returned from the tree traversal latched exclusively and an update operation may then be performed on the leaf node.
If the operation necessitates the insertion of an entry into a node which is at maximum capacity, a split node action for the maximum capacity node is undertaken, and then the insert is retried. As in the case of a read record, if at the completion of the update node operation the node is found to be under-utilized, a delete node operation is enqueued for that node.
The pseudocode for an insert, modify, or delete in one embodiment is as follows, where Action represents the action to be performed on the target node and Action Information represents information needed for the action (for example, the record to be inserted where the Action is an insertion). Update is a function which inserts, modifies or deletes the node according to the specified action. This may, in the case of an insert or of certain updates, cause a node to be too full. If this is the case, the update will fail if the node is full, a split node will be attempted, and the action retried:
Update Node (Key Value, Level, Action, Action Information)
In order to perform a split node operation, two distinct half split operations are performed. The first half split operation involves moving the high range contents of the target node being split to a new node. The side pair is also moved to the new node. The side pair in the target node is changed to point to the new node, and contains also the low key value for the new node. When this first half split operation is completed, all the data is accessible and can be found during a tree traversal. The first half split operation is not enqueued to be performed at some future time, because split node operations create room for adding data to a node. If this is not done promptly, the update operation which called for the split node will need to wait or be aborted. This first half split operation can be done immediately, however, because the exclusive latch will already be held by the calling operation on the node. A latch need not be held on the parent of the target node being split, only on the target node itself. No latch is needed on the new node as others cannot access the new node. The only path to the new node is via the original target node, on which we are already holding an exclusive latch.
The second half split operation involves the posting of an index term and index pointer for the new node in the parent node. This is done by enqueueing this index posting on the queue of work.
In order to perform an index posting, an Access Parent operation is performed. An Access Parent operation is used to access a parent node when a split or delete has occurred to one of its children. The Access Parent operation accesses the parent of a node so that the index term for a node can be inserted or deleted or so that a deletion can occur. It is given the remembered parent node address (RememberedParent) of the node (Node) and the type of action being performed, and returns with the latched parent node or an error if the parent may have been deleted. The Access Parent operation can be described, in one embodiment, with the following pseudocode:
When an access parent operation is run, it returns with the latch on the parent of the target node which has changed (by being split or deleted) if the parent node exists. The parent node being accessed in an access parent operation will be level 1 or higher. That is, it will not be a leaf node. Thus, there will be a delete state stored in DX for the node. Access parent first latches DX with a share latch, and then, if the state stored therein indicates that the parent must exist, the parent node is latched. Once the parent node is latched, it can not be deleted until it is unlatched.
Access parent returns with an error if the delete state of the parent node indicates that the parent node may not exist. In this way, access parent verifies without the necessity of tree traversal that the parent node definitely exists, and only if it does definitely exist is a traversal undertaken.
In one embodiment, access parent is also called with an indication of whether it is handling a delete or an index posting due to a split. If access parent is called for the index posting to a parent node of child node information, the delete state of the child node is also checked to ensure that the child node still exists. If it might not exist, access parent returns with an error.
For a second half split index posting, if access parent returns with an error, the index posting is not performed. All data in the tree still remains properly accessible through side pointers, and an error returned from access parent in this situation is generally sufficiently rare that the lack of an index posting for the new node is not an issue. In another embodiment, when an access parent returns with an error, the tree is traversed to find the correct parent for the index posting and the index posting is then made.
When the second half split has identified the parent node and has obtained the latch on the parent node, the update node operation is then used to post the index term. This may lead to a split of the parent node; however, such a parent node split will be a separate atomic action, decoupled from the split caused it.
Thus, the split node operation can be described, in one embodiment, with the following pseudocode, where a latch is held on the OriginalNode (the node to be split):
In Step 1, where a new node is allocated, no latch is required as the node is invisible to the rest of the tree. The first half of the split operation is embodied in steps 1-4, and the second in the operation enqueued in step 5.
The Post Index Term operation can be described, in one embodiment, with the following pseudocode:
When post index operation is taken off the queue to be performed, a check is performed to see if the stored parent node for which an index term is being posted may have been deleted, in decision 640. This is done, in one embodiment, by consulting a delete state. In decision 650, a check is performed to see if the new node for which an index term is being posted may have been deleted. This is done, in one embodiment, by consulting a delete state. In step 660, if the parent node and the new node for which a term is being posted both have not been deleted, the new index node data is added to the parent node.
In one embodiment, if it is possible that the stored parent node has been deleted (in other words, a “yes” answer to decision 640) or that the new node has been deleted (a “yes” answer to decision 650) then step 660 does not occur. The second half-split operation is abandoned. As described above, this abandonment of the posting of the index term when delete states indicate that a deletion may have occured allows B-link tree concurrency to be accomplished in a simple manner and avoids costly retraversals while allowing for the resultant “missing” node postings to be detected and the node posting to be peformed at a later time. In an alternate embodiment, a retraversal may be done to ensure that the stored parent node and new node are both still in existence.
Delete Node Operations
When a node is deleted, the delete node operation is run on the node. This permits the consolidation of index nodes with low occupancy. The delete node operation first calls the access parent operation to access the parent node of the node targeted for deletion. Access parent finds the parent node. Delete state information for the target node will be found in the parent node; this delete state information is updated in the access parent operation. Access parent returns with the parent node latched.
The left sibling of the target node is then accessed and latched. The target node is then accessed and latched. The contents of the target node are moved to the left sibling. The target node is then de-allocated and its index term removed from the parent.
The steps in Delete Node, in one embodiment, are as follows:
Index Delete State DX
As described above, delete state generally stores state information regarding whether a node was definitely not deleted, or whether it may have been deleted. In one embodiment, this is done using a stored binary state for each index node.
In another embodiment, delete state is stored using counters. Index delete state DX is maintained as a counter that is incremented whenever an index node is deleted. Before an action is placed on the work queue, the present value of DX is stored along with the action on the queue.
When the action is performed, if DX has changed from the remembered index delete state, this is treated as a “may have been deleted” state. While this is a conservative method (because it marks all nodes as “may have been deleted” even if only one was) if deletes are not common it will cause few problems. Because leaf node deletes, which are more common, are tracked separately from index node deletes, DX rarely changes.
During an unsuccessful parent access, the new DX counter value is saved so that when the need for the index posting is detected again, the more recent DX value is entered with the enqueued action, hence making it possible for this later action to complete successfully. This is done because a change in DX is used to determine whether a node may have been deleted between the time a structure modification is scheduled and the time when it is actually done. For example, because of a sibling traversal, it may be discovered that an index term has not been posted. A new index term posting is scheduled. The latest Dx value is stored when the posting is scheduled, and it is compared to the current Dx value when the parent node is accessed to post the index term. The new posting thus will only fail if there are further node deletes between the scheduling of the new posting and the parent node is accessed for execution of the index term posting.
If the system crashes, all queued actions are lost. Therefore DX state need not be maintained across a system crash, but can be restarted when the system is brought up again.
Data Delete State DD
The data delete state is used to determine whether leaf nodes that are immediate descendents of a lowest level index node may have been deleted. If not, a new node resulting from a split will not have been deleted, and the index term for that new node may be posted in that lowest level index node, without further verification that the node still exists.
The DD state describing node deletes among leaf nodes is stored in their parent index node. Some access savings are achieved, since the parent index node is accessed in any event during the posting operation.
DD may be maintained as a binary state for each leaf node in a given index node. In another embodiment, as with DX state, DD is maintained as a counter. Whenever a leaf node is deleted, the parent is latched and accessed in any event, in order to post the index term. Hence, the update of DD during leaf node delete occurs with little overhead.
If DD for the parent node has changed when we attempt to post an index term for a new leaf node split, then the new node may already have been deleted, and hence no index term posting is required. In that case, we abort the posting.
To make this “optimistic” approach work, the prior value for DD is stored when the node is visited in the traversal on the way to a leaf node. No additional latching is required.
The modifications to the operations listed above to implement the counter version of delete states include:
It is noted that the foregoing examples have been provided merely for the purpose of explanation and are in no way to be construed as limiting of the present invention. While the invention has been described with reference to various embodiments, it is understood that the words which have been used herein are words of description and illustration, rather than words of limitations. Further, although the invention has been described herein with reference to particular means, materials and embodiments, the invention is not intended to be limited to the particulars disclosed herein; rather, the invention extends to all functionally equivalent structures, methods and uses, such as are within the scope of the appended claims. Those skilled in the art, having the benefit of the teachings of this specification, may effect numerous modifications thereto and changes may be made without departing from the scope and spirit of the invention in its aspects.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5446887 *||Sep 17, 1993||Aug 29, 1995||Microsoft Corporation||Optimal reorganization of a B-tree|
|US6792432 *||Jul 23, 1998||Sep 14, 2004||Sybase, Inc.||Database system with methods providing high-concurrency access in B-Tree structures|
|1||Bayer, R. et al., "Concurrency of Operations on B-Trees", Acta Informatica, 1977, 9(1), 1-21.|
|2||Comer, D., "The Ubiquitous B-Tree", Computing Surveys, Jun. 1979, 11(2), 121-137.|
|3||Kornacker, M. et al., "Concurrency and Recovery in Generalized Search Trees", ACM Sigmod, 1997, 62-72.|
|4||Lehman, P.L. et al., "Efficient Locking for Concurrent Operations on B-Trees", ACM Transactions on Database Systems, Dec. 1981, 6(4), 650-670.|
|5||Lomet, D. et al., "Concurrency and Recovery for Index Trees", VLDB J., 1997, 6(3), 224-240.|
|6||Lomet, D., et al., "Access Method Concurrency with Recovery", ACM Sigmod Conf., 1992, 351-360.|
|7||Lomet, D., Simple, Robust and Highly Concurrent B-Trees with Node Deletion, 8 pages.|
|8||Sagiv, Y. et al., "Concurrent Operations on B Trees with Overtaking", J Computer and System Sciences, 1986, 33(2), 275-296.|
|9||Srinivasan, V. et al., "Performance of B-Tree Concurrency Control Algorithms", ACM Sigmod Conf., 1991, 416-425.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7697518||Sep 15, 2006||Apr 13, 2010||Netlogic Microsystems, Inc.||Integrated search engine devices and methods of updating same using node splitting and merging operations|
|US7725450 *||Mar 14, 2007||May 25, 2010||Netlogic Microsystems, Inc.||Integrated search engine devices having pipelined search and tree maintenance sub-engines therein that maintain search coherence during multi-cycle update operations|
|US7747599||Jul 19, 2005||Jun 29, 2010||Netlogic Microsystems, Inc.||Integrated search engine devices that utilize hierarchical memories containing b-trees and span prefix masks to support longest prefix match search operations|
|US7805427||Sep 28, 2007||Sep 28, 2010||Netlogic Microsystems, Inc.||Integrated search engine devices that support multi-way search trees having multi-column nodes|
|US7831626||Sep 20, 2007||Nov 9, 2010||Netlogic Microsystems, Inc.||Integrated search engine devices having a plurality of multi-way trees of search keys therein that share a common root node|
|US7873650 *||Jun 11, 2004||Jan 18, 2011||Seisint, Inc.||System and method for distributing data in a parallel processing system|
|US7953721||Dec 21, 2007||May 31, 2011||Netlogic Microsystems, Inc.||Integrated search engine devices that support database key dumping and methods of operating same|
|US7987205||Dec 21, 2007||Jul 26, 2011||Netlogic Microsystems, Inc.||Integrated search engine devices having pipelined node maintenance sub-engines therein that support database flush operations|
|US8086641||Dec 17, 2008||Dec 27, 2011||Netlogic Microsystems, Inc.||Integrated search engine devices that utilize SPM-linked bit maps to reduce handle memory duplication and methods of operating same|
|US8266234||Jun 11, 2004||Sep 11, 2012||Seisint, Inc.||System and method for enhancing system reliability using multiple channels and multicast|
|US8843472||Oct 11, 2011||Sep 23, 2014||International Business Machines Corporation||Recovery of inconsistent data in databases|
|US8886677||Jun 26, 2007||Nov 11, 2014||Netlogic Microsystems, Inc.||Integrated search engine devices that support LPM search operations using span prefix masks that encode key prefix length|
|US8909677 *||Apr 27, 2007||Dec 9, 2014||Hewlett-Packard Development Company, L.P.||Providing a distributed balanced tree across plural servers|
|US8914356||Nov 1, 2012||Dec 16, 2014||International Business Machines Corporation||Optimized queries for file path indexing in a content repository|
|US9058253 *||Jul 3, 2008||Jun 16, 2015||Samsung Electronics Co., Ltd.||Data tree storage methods, systems and computer program products using page structure of flash memory|
|US20090012976 *||Jul 3, 2008||Jan 8, 2009||Samsung Electronics Co., Ltd.||Data Tree Storage Methods, Systems and Computer Program Products Using Page Structure of Flash Memory|
|US20140279859 *||Mar 15, 2013||Sep 18, 2014||International Business Machines Corporation||Index record-level locking for file systems using a b+tree structure|
|U.S. Classification||1/1, 707/E17.007, 707/999.102, 707/999.101|
|International Classification||G06F17/00, G06F7/00|
|Cooperative Classification||Y10S707/99943, Y10S707/99942, G06F17/30348, G06F17/30336, G06F17/30327|
|European Classification||G06F17/30S2P3, G06F17/30C, G06F17/30S2P9|
|Jan 30, 2004||AS||Assignment|
Owner name: MICROSOFT CORPORATION, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:LOMET, DAVID B.;REEL/FRAME:014948/0794
Effective date: 20040129
|Apr 19, 2011||CC||Certificate of correction|
|Sep 20, 2011||FPAY||Fee payment|
Year of fee payment: 4
|Dec 9, 2014||AS||Assignment|
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034541/0477
Effective date: 20141014
|Nov 19, 2015||FPAY||Fee payment|
Year of fee payment: 8