### Archived Content

This website is an archive of the Spring 2019 semester of CS 225.
Click here to view the current semester.

# lab_btree

## Belligerent BTrees

Due: Mar 26, 23:59 PM

## Assignment Description

In this lab you’ll learn about BTrees and how they can be used to implement the dictionary ADT. Specifically you’ll learn about the algorithms involved in finding and inserting into a BTree. In addition to the algorithms, you’ll see why BTrees are a useful structure, and a potentially good alternative to self-balancing binary search trees.

## Lab Insight

B-Trees are a powerful data structure for distributed data storage. One can optimize access to this data structure by potentially splitting each node across a distributed system or perhaps even using a data structure like it to build databases (applications specifically designed to store and lookup massive amounts of data rapidly). To learn more about how B-Trees are used in databases, CS 411 is a database course that offers information on this topic.

## Checking Out The Code

From your CS 225 git directory, run the following on EWS:

git fetch release
git merge release/lab_btree -m "Merging initial lab_btree files"


If you’re on your own machine, you may need to run:

git fetch release
git merge --allow-unrelated-histories release/lab_btree -m "Merging initial lab_btree files"


Upon a successful merge, your lab_btree files are now in your lab_btree directory.

The code for this activity resides in the lab_btree/ directory. Get there by typing this in your working directory:

cd lab_btree/


## The BTree Class and Friends

You’ll find the definition of the BTree class in btree.h. Just like AVLTree, BTree is generic in that it can have arbitrary types for its keys (assuming they can be compared) and values. There are two subclasses in BTree: DataPair and BTreeNode. A DataPair is essentially just a key, value pair which is useful since our BTree implements dictionary functionality. The BTreeNode is a node in the BTree. It contains two vectors: elements and children. elements is the data in the node, children is pointers to the node’s child nodes. Note that DataPairs can be compared with <, >, and == based entirely on their keys (the functions are defined in the DataPair class).

Since BTreeNode uses vector pretty heavily, it would probably be a good idea to keep a reference open while working with them (in particular, vector’s insert and assign functions will probably prove useful).

The Doxygen for the BTree class is here.

## The insertion_idx Function

Doxygen for this function is here.

The elements of a BTreeNode are meant to be kept in sorted order so that they can be searched with a binary search to quickly find the key in the node (if it exists) or the proper child to explore. There’s a utility function in btree.h called insertion_idx which serves this purpose. It is not specific to BTree, rather it takes an arbitrary vector and arbitrary value and tries to find the index in the vector the value can be inserted at such that the vector will remain in sorted order. You should be able to safely use operator<, operator>, and operator== inside this function when comparing the parameter value to the elements in the vector. Thus, I should be able to do something like this to insert 5 into the position that keeps sorted_vec sorted:

/* sorted_vec is a sorted vector of ints */
size_t insert_idx = insertion_idx(sorted_vec, 5);
sorted_vec.insert(sorted_vec.begin() + insert_idx, 5);


You can test your function with provided test cases, or you can write your own testing functions for it somewhere. Note that because our entire tree is stored in memory, using an online algorithm such as a linear search is unnecessary and the more efficient binary search can be used.

## The find Function

The Doxygen for this function is here.

Searching a BTree is very much like searching a BST. The main difference is that instead of only having two possible children to explore, we have order-many potential children. As with a BST, it is natural to write find recursively. For a given level of the recursion, the steps are as follows. First you must do a binary search on the elements (remember they should always be stored in sorted order) using insertion_idx. If the key at insertion_idx is the one we are looking for, we are done (since keys in the tree are unique) and return, otherwise we didn’t find the key in the current node. If the current node is a leaf node, then we’ve run out of nodes to explore and we are also done. Otherwise, we need to call find recursively on the proper child of the current node. This can be done using the return value of insertion_idx.

Below is a few examples of find on a small, order 3 BTree.

The initial tree:

We search for 39. We start at the root, call insertion_idx, which should return 2, since that’s the index in the root node that 39 could be inserted at to maintain sorted order. Since this isn’t a valid index in the current node, we know we need to explore a child. We also know that 2 is conveniently the index of the child pointer (the bar) we want to explore.

We call insertion_idx on this node and find the key we are looking for.

Now let’s try finding something that isn’t in the tree, -2. We use insertion_idx to find the place we would insert -2, which is index 0. This is also the index of the child we want to explore.

When call insertion_idx on this node and find that the key is not in this node. Since this node is also a leaf node, the key isn’t in the tree.

## The split_child Function

The Doxygen for this function is here.

split_child is used as a part of the insertion process in a BTree to “fix” the tree. When a node becomes “too full”, i.e. when its number of elements becomes the tree’s order, we have to split the node into two nodes, and throw out the median element into the parent node. The process should become more clear with the below examples (combined with the insert examples). When actually implementing this function you will probably want to use vector’s assign function.

## The insert Function

The Doxygen for this function is here.

You have to write the recursive helper function insert (the public one is already written for you). Insertion into a BTree always happens at the leaf nodes; inserting involves finding the proper leaf node (recursively) that the key belongs in, and then “fixing” the tree on the way back up the recursive calls.

As with find, first you should do a binary search on the current node being explored. If the key we are trying to insert exists in the current node, then there’s no more work to be done (don’t replace the value associated with the already existing key).

Below is an example that illustrate the insertion/splitting process. Let’s start with 13.

We find the child we want to insert into in the same way as find. We have to verify that the key isn’t in the current node and then recursively call insert until we hit a leaf node to insert into.

We use insertion_idx at the leaf to find which spot the key belongs in.

Now let’s do an insert the requires a split; let’s insert 25.

Same process as with finding 25, we use insertion_idx to find the child to recursively explore.

We insert 25 to the place it belongs in the leaf, and we are done at this level of recursion. After the return (i.e. when we are back at the node containing 8, 20) we check the size of the node we just inserted into. We see that its size is equal to order, so we have to split it (using split_child). First we find the median of the node we are splitting (element 25) put it at the proper place in the 8, 20 node. We have to create a new node containing everything to the right of 25 (including the child pointers to the right of 25). Similarly, the left node contains everything to left of 25. We have to make sure to add the new right child pointer to the children of the 8, 20 node.

At this point we notice that the root has to be split.

The median of the current root (20) gets put into a new root node, and its two children are the 8 node and the 25 node.

Take note of the children indices that ended up in the two children nodes. 20 had index 1 in the original node. The child pointers that ended up in the left node had indices 0 and 1, the child pointers that ended up in the left node had indices 2 and 3. Note that for trees of odd order this ends up working out very nicely, since there’s only one choice of median. You have to be very careful though since this is not the case for even orders.

## Testing Your Code

As always, there are provided tests for the lab. Run them like you normally would:

make test
./test


There is also an executable called test_btree, made by running:

make test_btree


If you run it with no parameters it will default to some basic tests with sequential and random integer data. It also can take parameters:

USAGE: test_btree ORDER N
Tests N inserts and N finds on a BTree<int, int> of order ORDER.


Additionally, note that BTreeNodes can be printed (see here). E.g. if I’m in find I can do something like:

cout << *subroot << endl;


The following files are used in grading:

• btree.h
• btree.cpp

All other files will not be used for grading.

## Race Against std::map

So you made this BTree, now how good is it really? Well, you can find out by using the dict_racer executable. The usage is as follows:

USAGE: dict_racer ORDER N STEP RANDOM INSERTS FINDS
Runs a race between a BTree<int, int> of order ORDER against an
std::map<int, int> for N inserts / finds. Outputs CSVs into "results".
ORDER specifies the order of the BTree
N specifies the max number of insert / finds to do
STEP specifies the intervals to split N into. E.g. N = 10, STEP = 2 will make
points for 2 operations, 4 operations ... &c.
RANDOM specifies whether the data should be random or sequential.
INSERT specifies whether to benchmark the inserts.
FINDS specifies whether to benchmark the finds.


Results can be plotted with the simple python script generate_plot.py, e.g.

./generate_plot.py results/*.csv


For example, the following image was produced with the following commands on my laptop:

make dict_racer
mkdir results
./dict_racer 64 200000 1000 true true true
./generate_plot.py results/*.csv


std::map in this case is implemented with a form of self-balancing binary search tree called a red-black tree. As you can see, the difference in performance widens as we increase $n$. I would guess that this is mostly because the BTree keeps more of the data its processing in cache most of the time, which is faster than loading each key, value from memory during a traversal (which is what a binary search tree needs to do).

It’s worth experimenting with different orders, values for $n$, and step values. I wouldn’t recommend testing on EWS remotely as they’re shared machines and performance numbers are mostly meaningless. Also note that the Python script is very simple, so only keep CSVs around that have different values for order and step size, otherwise the plot will look pretty weird. Alternatively you can just remove the results directory each time.