Subversion Repositories HelenOS-historic

/*

 * Copyright (C) 2006 Jakub Jermar

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - The name of the author may not be used to endorse or promote products

 *   derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * This B-tree has the following properties:

 * - it is a ballanced 2-3-4 tree (i.e. BTREE_M = 4)

 * - values (i.e. pointers to values) are stored only in leaves

 * - leaves are linked in a list

 * - technically, it is a B+-tree (because of the previous properties)

 *

 * Be carefull when using these trees. They need to allocate

 * and deallocate memory for their index nodes and as such

 * can sleep.

 */

#include <adt/btree.h>

#include <adt/list.h>

#include <mm/slab.h>

#include <debug.h>

#include <panic.h>

#include <typedefs.h>

#include <print.h>

static void _btree_insert(btree_t *t, __native key, void *value, btree_node_t *rsubtree, btree_node_t *node);

static void node_initialize(btree_node_t *node);

static void node_insert_key_left(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree);

static void node_insert_key_right(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree);

static btree_node_t *node_split(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree, __native *median);

static void node_remove_key_left(btree_node_t *node, __native key);

static void node_remove_key_right(btree_node_t *node, __native key);

static index_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right);

static bool try_insert_by_left_rotation(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree);

static bool try_insert_by_right_rotation(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree);

#define ROOT_NODE(n)		(!(n)->parent)

#define INDEX_NODE(n)		((n)->subtree[0] != NULL)

#define LEAF_NODE(n)		((n)->subtree[0] == NULL)

#define MEDIAN_LOW_INDEX(n)	(((n)->keys-1)/2)

#define MEDIAN_HIGH_INDEX(n)	((n)->keys/2)

#define MEDIAN_LOW(n)		((n)->key[MEDIAN_LOW_INDEX((n))]);

#define MEDIAN_HIGH(n)		((n)->key[MEDIAN_HIGH_INDEX((n))]);

/** Create empty B-tree.

 *

 * @param t B-tree.

 */

void btree_create(btree_t *t)

{

	list_initialize(&t->leaf_head);

	t->root = (btree_node_t *) malloc(sizeof(btree_node_t), 0);

	node_initialize(t->root);

	list_append(&t->root->leaf_link, &t->leaf_head);

}

/** Destroy empty B-tree. */

void btree_destroy(btree_t *t)

{

	ASSERT(!t->root->keys);

	free(t->root);

}

/** Insert key-value pair into B-tree.

 *

 * @param t B-tree.

 * @param key Key to be inserted.

 * @param value Value to be inserted.

 * @param leaf_node Leaf node where the insertion should begin.

 */ 

void btree_insert(btree_t *t, __native key, void *value, btree_node_t *leaf_node)

{

	btree_node_t *lnode;

	ASSERT(value);

	lnode = leaf_node;

	if (!lnode) {

		if (btree_search(t, key, &lnode)) {

			panic("B-tree %P already contains key %d\n", t, key);

		}

	}

	_btree_insert(t, key, value, NULL, lnode);

}

/** Recursively insert into B-tree.

 *

 * @param t B-tree.

 * @param key Key to be inserted.

 * @param value Value to be inserted.

 * @param rsubtree Right subtree of the inserted key.

 * @param node Start inserting into this node.

 */

void _btree_insert(btree_t *t, __native key, void *value, btree_node_t *rsubtree, btree_node_t *node)

{

	if (node->keys < BTREE_MAX_KEYS) {

		/*

		 * Node conatins enough space, the key can be stored immediately.

		 */

		node_insert_key_right(node, key, value, rsubtree);

	} else if (try_insert_by_left_rotation(node, key, value, rsubtree)) {

		/*

		 * The key-value-rsubtree triplet has been inserted because

		 * some keys could have been moved to the left sibling.

		 */

	} else if (try_insert_by_right_rotation(node, key, value, rsubtree)) {

		/*

		 * The key-value-rsubtree triplet has been inserted because

		 * some keys could have been moved to the right sibling.

		 */

	} else {

		btree_node_t *rnode;

		__native median;

		/*

		 * Node is full and both siblings (if both exist) are full too.

		 * Split the node and insert the smallest key from the node containing

		 * bigger keys (i.e. the new node) into its parent.

		 */

		rnode = node_split(node, key, value, rsubtree, &median);

		if (LEAF_NODE(node)) {

			list_append(&rnode->leaf_link, &node->leaf_link);

		}

		if (ROOT_NODE(node)) {

			/*

			 * We split the root node. Create new root.

			 */

			t->root = (btree_node_t *) malloc(sizeof(btree_node_t), 0);

			node->parent = t->root;

			rnode->parent = t->root;

			node_initialize(t->root);

			/*

			 * Left-hand side subtree will be the old root (i.e. node).

			 * Right-hand side subtree will be rnode.

			 */			

			t->root->subtree[0] = node;

			t->root->depth = node->depth + 1;

		}

		_btree_insert(t, median, NULL, rnode, node->parent);

	}	

}

/* TODO */

void btree_remove(btree_t *t, __native key)

{

}

/** Search key in a B-tree.

 *

 * @param t B-tree.

 * @param key Key to be searched.

 * @param leaf_node Address where to put pointer to visited leaf node.

 *

 * @return Pointer to value or NULL if there is no such key.

 */

void *btree_search(btree_t *t, __native key, btree_node_t **leaf_node)

{

	btree_node_t *cur, *next;

	/*

	 * Iteratively descend to the leaf that can contain the searched key.

	 */

	for (cur = t->root; cur; cur = next) {

		/* Last iteration will set this with proper leaf node address. */

		*leaf_node = cur;

		/*

		 * The key can be in the leftmost subtree.

		 * Test it separately.

		 */

		if (key < cur->key[0]) {

			next = cur->subtree[0];

			continue;

		} else {

			void *val;

			int i;

			/*

			 * Now if the key is smaller than cur->key[i]

			 * it can only mean that the value is in cur->subtree[i]

			 * or it is not in the tree at all.

			 */

			for (i = 1; i < cur->keys; i++) {

				if (key < cur->key[i]) {

					next = cur->subtree[i];

					val = cur->value[i - 1];

					if (LEAF_NODE(cur))

						return key == cur->key[i - 1] ? val : NULL;

					goto descend;

				} 

			}

			/*

			 * Last possibility is that the key is in the rightmost subtree.

			 */

			next = cur->subtree[i];

			val = cur->value[i - 1];

			if (LEAF_NODE(cur))

				return key == cur->key[i - 1] ? val : NULL;

		}

		descend:

			;

	}

	/*

	 * The key was not found in the *leaf_node and is smaller than any of its keys.

	 */

	return NULL;

}

/** Get pointer to value with the smallest key within the node.

 *

 * Can be only used on leaf-level nodes.

 *

 * @param node B-tree node.

 *

 * @return Pointer to value assiciated with the smallest key.

 */

void *btree_node_min(btree_node_t *node)

{

	ASSERT(LEAF_NODE(node));

	ASSERT(node->keys);

	return node->value[0];

}

/** Get pointer to value with the biggest key within the node.

 *

 * Can be only used on leaf-level nodes.

 *

 * @param node B-tree node.

 *

 * @return Pointer to value assiciated with the biggest key.

 */

void *btree_node_max(btree_node_t *node)

{

	ASSERT(LEAF_NODE(node));

	ASSERT(node->keys);

	return node->value[node->keys - 1];

}

/** Initialize B-tree node.

 *

 * @param node B-tree node.

 */

void node_initialize(btree_node_t *node)

{

	int i;

	node->keys = 0;

	/* Clean also space for the extra key. */

	for (i = 0; i < BTREE_MAX_KEYS + 1; i++) {

		node->key[i] = 0;

		node->value[i] = NULL;

		node->subtree[i] = NULL;

	}

	node->subtree[i] = NULL;

	node->parent = NULL;

	link_initialize(&node->leaf_link);

	link_initialize(&node->bfs_link);

	node->depth = 0;

}

/** Insert key-value-lsubtree triplet into B-tree node.

 *

 * It is actually possible to have more keys than BTREE_MAX_KEYS.

 * This feature is used during insert by right rotation.

 *

 * @param node B-tree node into wich the new key is to be inserted.

 * @param key The key to be inserted.

 * @param value Pointer to value to be inserted.

 * @param lsubtree Pointer to the left subtree.

 */ 

void node_insert_key_left(btree_node_t *node, __native key, void *value, btree_node_t *lsubtree)

{

	int i;

	for (i = 0; i < node->keys; i++) {

		if (key < node->key[i]) {

			int j;

			for (j = node->keys; j > i; j--) {

				node->key[j] = node->key[j - 1];

				node->value[j] = node->value[j - 1];

				node->subtree[j + 1] = node->subtree[j];

			}

			node->subtree[j + 1] = node->subtree[j];

			break;	

		}

	}

	node->key[i] = key;

	node->value[i] = value;

	node->subtree[i] = lsubtree;

	node->keys++;

}

/** Insert key-value-rsubtree triplet into B-tree node.

 *

 * It is actually possible to have more keys than BTREE_MAX_KEYS.

 * This feature is used during splitting the node when the

 * number of keys is BTREE_MAX_KEYS + 1. Insert by left rotation

 * also makes use of this feature.

 *

 * @param node B-tree node into wich the new key is to be inserted.

 * @param key The key to be inserted.

 * @param value Pointer to value to be inserted.

 * @param rsubtree Pointer to the right subtree.

 */ 

void node_insert_key_right(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree)

{

	int i;

	for (i = 0; i < node->keys; i++) {

		if (key < node->key[i]) {

			int j;

			for (j = node->keys; j > i; j--) {

				node->key[j] = node->key[j - 1];

				node->value[j] = node->value[j - 1];

				node->subtree[j + 1] = node->subtree[j];

			}

			break;	

		}

	}

	node->key[i] = key;

	node->value[i] = value;

	node->subtree[i + 1] = rsubtree;

	node->keys++;

}

/** Split full B-tree node and insert new key-value-right-subtree triplet.

 *

 * This function will split a node and return pointer to a newly created

 * node containing keys greater than or equal to the greater of medians

 * (or median) of the old keys and the newly added key. It will also write

 * the median key to a memory address supplied by the caller.

 *

 * If the node being split is an index node, the median will not be

 * included in the new node. If the node is a leaf node,

 * the median will be copied there.

 *

 * @param node B-tree node wich is going to be split.

 * @param key The key to be inserted.

 * @param value Pointer to the value to be inserted.

 * @param rsubtree Pointer to the right subtree of the key being added.

 * @param median Address in memory, where the median key will be stored.

 *

 * @return Newly created right sibling of node.

 */ 

btree_node_t *node_split(btree_node_t *node, __native key, void *value, btree_node_t *rsubtree, __native *median)

{

	btree_node_t *rnode;

	int i, j;

	ASSERT(median);

	ASSERT(node->keys == BTREE_MAX_KEYS);

	/*

	 * Use the extra space to store the extra node.

	 */

	node_insert_key_right(node, key, value, rsubtree);

	/*

	 * Compute median of keys.

	 */

	*median = MEDIAN_HIGH(node);

	/*

	 * Allocate and initialize new right sibling.

	 */

	rnode = (btree_node_t *) malloc(sizeof(btree_node_t), 0);

	node_initialize(rnode);

	rnode->parent = node->parent;

	rnode->depth = node->depth;

	/*

	 * Copy big keys, values and subtree pointers to the new right sibling.

	 * If this is an index node, do not copy the median.

	 */

	i = (int) INDEX_NODE(node);

	for (i += MEDIAN_HIGH_INDEX(node), j = 0; i < node->keys; i++, j++) {

		rnode->key[j] = node->key[i];

		rnode->value[j] = node->value[i];

		rnode->subtree[j] = node->subtree[i];

		/*

		 * Fix parent links in subtrees.

		 */

		if (rnode->subtree[j])

			rnode->subtree[j]->parent = rnode;

	}

	rnode->subtree[j] = node->subtree[i];

	if (rnode->subtree[j])

		rnode->subtree[j]->parent = rnode;

	rnode->keys = j;	/* Set number of keys of the new node. */

	node->keys /= 2;	/* Shrink the old node. */

	return rnode;

}

/** Remove key and its left subtree pointer from B-tree node.

 *

 * Remove the key and eliminate gaps in node->key array.

 * Note that the value pointer and the left subtree pointer

 * is removed from the node as well.

 *

 * @param node B-tree node.

 * @param key Key to be removed.

 */

void node_remove_key_left(btree_node_t *node, __native key)

{

	int i, j;

	for (i = 0; i < node->keys; i++) {

		if (key == node->key[i]) {

			for (j = i + 1; j < node->keys; j++) {

				node->key[j - 1] = node->key[j];

				node->value[j - 1] = node->value[j];

				node->subtree[j - 1] = node->subtree[j];

			}

			node->subtree[j - 1] = node->subtree[j];

			node->keys--;

			return;

		}

	}

	panic("node %P does not contain key %d\n", node, key);

}

/** Remove key and its right subtree pointer from B-tree node.

 *

 * Remove the key and eliminate gaps in node->key array.

 * Note that the value pointer and the right subtree pointer

 * is removed from the node as well.

 *

 * @param node B-tree node.

 * @param key Key to be removed.

 */

void node_remove_key_right(btree_node_t *node, __native key)

{

	int i, j;

	for (i = 0; i < node->keys; i++) {

		if (key == node->key[i]) {

			for (j = i + 1; j < node->keys; j++) {

				node->key[j - 1] = node->key[j];

				node->value[j - 1] = node->value[j];

				node->subtree[j] = node->subtree[j + 1];

			}

			node->keys--;

			return;

		}

	}

	panic("node %P does not contain key %d\n", node, key);

}

/** Find key by its left or right subtree.

 *

 * @param node B-tree node.

 * @param subtree Left or right subtree of a key found in node.

 * @param right If true, subtree is a right subtree. If false, subtree is a left subtree.

 *

 * @return Index of the key associated with the subtree.

 */ 

index_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right)

{

	int i;

	for (i = 0; i < node->keys + 1; i++) {

		if (subtree == node->subtree[i])

			return i - (int) (right != false);

	}

	panic("node %P does not contain subtree %P\n", node, subtree);

}

/** Insert key-value-rsubtree triplet and rotate the node to the left, if this operation can be done.

 *

 * Left sibling of the node (if it exists) is checked for free space.

 * If there is free space, the key is inserted and the smallest key of

 * the node is moved there. The index node which is the parent of both

 * nodes is fixed.

 *

 * @param node B-tree node.

 * @param inskey Key to be inserted.

 * @param insvalue Value to be inserted.

 * @param rsubtree Right subtree of inskey.

 *

 * @return True if the rotation was performed, false otherwise.

 */

bool try_insert_by_left_rotation(btree_node_t *node, __native inskey, void *insvalue, btree_node_t *rsubtree)

{

	index_t idx;

	btree_node_t *lnode;

	/*

	 * If this is root node, the rotation can not be done.

	 */

	if (ROOT_NODE(node))

		return false;

	idx = find_key_by_subtree(node->parent, node, true);

	if ((int) idx == -1) {

		/*

		 * If this node is the leftmost subtree of its parent,

		 * the rotation can not be done.

		 */

		return false;

	}

	lnode = node->parent->subtree[idx];

	if (lnode->keys < BTREE_MAX_KEYS) {

		__native key;

		/*

		 * The rotaion can be done. The left sibling has free space.

		 */

		node_insert_key_right(node, inskey, insvalue, rsubtree);

		key = node->key[0];

		if (LEAF_NODE(node)) {

			void *value;

			value = node->value[0];

			node_remove_key_left(node, key);

			node_insert_key_right(lnode, key, value, NULL);

			node->parent->key[idx] = node->key[0];

		} else {

			btree_node_t *lsubtree;

			lsubtree = node->subtree[0];

			node_remove_key_left(node, key);

			node_insert_key_right(lnode, node->parent->key[idx], NULL, lsubtree);

			node->parent->key[idx] = key;

			/* Fix parent link of the reconnected left subtree. */

			lsubtree->parent = lnode;

		}

		return true;

	}

	return false;

}

/** Insert key-value-rsubtree triplet and rotate the node to the right, if this operation can be done.

 *

 * Right sibling of the node (if it exists) is checked for free space.

 * If there is free space, the key is inserted and the biggest key of

 * the node is moved there. The index node which is the parent of both

 * nodes is fixed.

 *

 * @param node B-tree node.

 * @param inskey Key to be inserted.

 * @param insvalue Value to be inserted.

 * @param rsubtree Right subtree of inskey.

 *

 * @return True if the rotation was performed, false otherwise.

 */

bool try_insert_by_right_rotation(btree_node_t *node, __native inskey, void *insvalue, btree_node_t *rsubtree)

{

	index_t idx;

	btree_node_t *rnode;

	/*

	 * If this is root node, the rotation can not be done.

	 */

	if (ROOT_NODE(node))

		return false;

	idx = find_key_by_subtree(node->parent, node, false);

	if (idx == node->parent->keys) {

		/*

		 * If this node is the rightmost subtree of its parent,

		 * the rotation can not be done.

		 */

		return false;

	}

	rnode = node->parent->subtree[idx + 1];

	if (rnode->keys < BTREE_MAX_KEYS) {

		__native key;

		/*

		 * The rotaion can be done. The right sibling has free space.

		 */

		node_insert_key_right(node, inskey, insvalue, rsubtree);

		key = node->key[node->keys - 1];

		if (LEAF_NODE(node)) {

			void *value;

			value = node->value[node->keys - 1];

			node_remove_key_right(node, key);

			node_insert_key_left(rnode, key, value, NULL);

			node->parent->key[idx] = key;

		} else {

			btree_node_t *rsubt;

			rsubt = node->subtree[node->keys];

			node_remove_key_right(node, key);

			node_insert_key_left(rnode, node->parent->key[idx], NULL, rsubt);

			node->parent->key[idx] = key;

			/* Fix parent link of the reconnected right subtree. */

			rsubt->parent = rnode;

		}

		return true;

	}

	return false;

}

/** Print B-tree.

 *

 * @param t Print out B-tree.

 */

void btree_print(btree_t *t)

{

	int i, depth = t->root->depth;

	link_t head;

	list_initialize(&head);

	list_append(&t->root->bfs_link, &head);

	/*

	 * Use BFS search to print out the tree.

	 * Levels are distinguished from one another by node->depth.

	 */	

	while (!list_empty(&head)) {

		link_t *hlp;

		btree_node_t *node;

		hlp = head.next;

		ASSERT(hlp != &head);

		node = list_get_instance(hlp, btree_node_t, bfs_link);

		list_remove(hlp);

		ASSERT(node);

		if (node->depth != depth) {

			printf("\n");

			depth = node->depth;

		}

		printf("(");

		for (i = 0; i < node->keys; i++) {

			printf("%d,", node->key[i]);

			if (node->depth && node->subtree[i]) {

				list_append(&node->subtree[i]->bfs_link, &head);

			}

		}

		if (node->depth && node->subtree[i]) {

			list_append(&node->subtree[i]->bfs_link, &head);

		}

		printf(")");

	}

	printf("\n");

}