1. CSE 332 Data Abstractions B-Trees
Richard Anderson
Spring 2016

2. Announcements Next two weeks: Hashing and sorting Upcoming dates
Friday, April 29. Midterm 2

3. Caches = SRAM (faster, more expensive) Memory = DRAM (slower, cheaper)
Cycles to access:
CPU
Registers 1
L1 Cache 2
L2 Cache 30
Main memory
250
[ ,000]
Caches = SRAM (faster, more expensive)
Memory = DRAM (slower, cheaper)
Idea: Keep your working set in the cache.
Draw arrow: faster, more expensive $$
Mov eax, [a]
Add ecx, [a]
What happens when you start a program?
bring in from disk into meory
execute first instruction – copy into L2 cache, then L1 cache, finally into the IR
This accesses variable a
Execute SECOND instruction, also accesses variable a.
It can use the COPY of [a] that is in the L1 cache.
Disk
Random: 30,000,000
Streamed: 5000 3

4. M-ary Search Tree Consider a search tree with branching factor M:
Complete tree has height:
# hops for find:
Runtime of find:
So, we’ll try to solve this problem as we did with heaps.
Here’s the general idea. We create a search tree with a branching factor of M.
Each node has M-1 keys and we search between them.
What’s the runtime?
O(logMn)?
That’s a nice thought, and it’s the best case. What about the worst case? 4

5. B+ Trees (book calls these B-trees)
Each internal node has (up to) M-1 keys:
Order property:
subtree between two keys x and y
contain leaves with values v such that x ≤ v < y
Note the “≤”
Leaf nodes have up to L
sorted keys. 3 7 12 21
To address these problems, we’ll use a slightly more structured M-ary tree: B-Trees.
As before, each internal node has M-1 keys.
To manage memory problems, we’ll tune the size of a node (or leaf) to the size of a memory unit. Usually, a page or disk block.
x<3
3≤x<7
7≤x<12
12≤x<21
21≤x 5

6. B+ Tree Structure Properties
Internal nodes
store up to M-1 keys
have between ⎡M/2⎤ and M children
Leaf nodes
where data is stored
all at the same depth
contain between ⎡L/2⎤ and L data items
Root (special case)
has between 2 and M children (or root could be a leaf)
The properties of B-Trees (and the trees themselves) are a bit more complex than previous structures we’ve looked at.
Here’s a big, gnarly list; we’ll go one step at a time.
The maximum branching factor, as we said, is M (tunable for a given tree).
The root has between 2 and M children or at most L keys.
(L is another parameter)
These restrictions will be different for the root than for other nodes. 6

7. B+ Tree: Example B+ Tree with M = 4 (# pointers in internal node)
and L = (# data items in leaf)
Data objects…
which I’ll ignore
in slides 12 44 6 20 27 34 50
1, AB.. 6 8 9 10 12 20 27 34 44 47 49 50
This is just an example B-tree. Notice that it has 24 entries with a depth of only 2.
A BST would be 4 deep.
Notice also that the leaves are at the same level in the tree. I’ll use integers as both key and data, but we all know that that could as well be different data at the bottom, right?
2, GH.. 14 22 28 38 60
All leaves
at the same
depth
4, XY.. 16 24 32 39 70 17 41 19 7
Definition for later: “neighbor” is the next sibling to the left or right.

8. Disk Friendliness What makes B+ trees disk-friendly?
Many keys stored in a node
All brought to memory/cache in one disk access.
Internal nodes contain only keys; Only leaf nodes contain keys and actual data
Much of tree structure can be loaded into memory irrespective of data object size
Data actually resides in disk 8

9. B+ trees vs. AVL trees Suppose again we have n = 230 ≈ 109 items:
Depth of AVL Tree
Depth of B+ Tree with M = 256, L = 256
Great, but how to we actually make a B+ tree and keep it balanced…?
x = 2^30
1.44 log_phi x = 43
Log_128 x = 4.3
Wow!!! 9 12

10. Building a B+ Tree with Insertions
The empty B-Tree
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem?
M = 3 L = 3 10

11. 3 3 Insert(30) 14 14 18 18 Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem?
M = 3 L = 3 11

12. 18 18 18 3 18 3 18 3 18
Insert(32)
Insert(36) 14 30 14 30 14 30 18
Insert(15)
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 3 18 14 30
M = 3 L = 3 12

13. 18 32 18 32 3 18 32 3 18 32
Insert(16) 14 30 36 14 30 36 15 15 18 32
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 18 32 30 36 13
M = 3 L = 3

14. Insert(12,40,45,38) 18 18 15 32 15 32 40 3 15 18 32 3 15 18 32 40 14 16 30 36 12 16 30 36 45
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 14 38 14
M = 3 L = 3

15. Insertion Algorithm Insert the key in its leaf in sorted order
If the leaf ends up with L+1 items, overflow!
Split the leaf into two nodes:
original with ⎡(L+1)/2⎤ smaller keys
new one with ⎣(L+1)/2⎦ larger keys
Add the new child to the parent
If the parent ends up with M+1 children, overflow!
3. If an internal node ends up with M+1 children, overflow!
Split the node into two nodes:
original with ⎡(M+1)/2⎤ children with smaller keys
new one with ⎣(M+1)/2⎦ children with larger keys
Add the new child to the parent
If the parent ends up with M+1 items, overflow!
Split an overflowed root in two and hang the new nodes under a new root
Propagate keys up tree.
OK, here’s that process as an algorithm.
The new funky symbol is floor; that’s just like regular C++ integer division.
Notice that this can propagate all the way up the tree. How often will it do that?
Notice that the two new leaves or internal nodes are guaranteed to have enough items (or subtrees).
Because even the floor of (L+1)/2 is as big as the ceiling of L/2.
This makes the tree deeper! 15

16. And Now for Deletion… 18 Delete(32) 18 15 32 40 15 40 3 18 32 40 3 18
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 12 16 30 36 45 12 16 30 45 14 38 14
M = 3 L = 3 16

17. 18
Delete(15) 18 15 36 40 36 40 3 15 18 36 40 3 18 36 40 12 16 30 38 45 12 16 30 38 45
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 14
M = 3 L = 3 17

18. 18
Delete(16) 18 14 36 40 36 40 3 14 18 36 40 18 36 40 12 16 30 38 45 30 38 45
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem?
M = 3 L = 3 18

19. 18
Delete(16) 36 40 3 18 36 40 3 12 30 38 45 12
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 14 14
M = 3 L = 3 19

20. Delete(14) 36 36 18 40 18 40 3 18 36 40 3 18 36 40 12 30 38 45 12 30 38 45
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 14
M = 3 L = 3 20

21. Delete(18) 36 36 18 40 40 3 18 36 40 3 36 40 12 30 38 45 12 38 45
Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem?
M = 3 L = 3 21

22. 36 40 3 36 40 12 38 45 30 Alright, how do we insert and delete?
Let’s start with the empty B-Tree. That’s one leaf as the root.
Now, we’ll insert 3 and 14. Fine…
What about inserting 1. Is there a problem? 30
M = 3 L = 3 22

23. Deletion Algorithm Remove the key from its leaf
2. If the leaf ends up with fewer than ⎡L/2⎤ items, underflow!
Adopt data from a neighbor; update the parent
If adopting won’t work, delete node and merge with neighbor
If the parent ends up with fewer than ⎡M/2⎤ children, underflow!
Alright, that’s deletion.
Let’s talk about a few of the details.
Why will dumping keys always work?
If the neighbors were too low on keys to loan any, they must have L/2 keys, but we have one fewer. Therefore, putting them together, we get at most L, and that’s legal. 23

24. Deletion Slide Two This reduces the height of the tree!
3. If an internal node ends up with fewer than ⎡M/2⎤ children, underflow!
Adopt from a neighbor; update the parent
If adoption won’t work, merge with neighbor
If the parent ends up with fewer than ⎡M/2⎤ children, underflow!
If the root ends up with only one child, make the child the new root of the tree
Propagate keys up through tree.
The same applies here for dumping subtrees as on the previous slide for dumping keys.
This reduces the height of the tree! 24

25. Thinking about B+ Trees
B+ Tree insertion can cause (expensive) splitting and propagation up the tree
B+ Tree deletion can cause (cheap) adoption or (expensive) merging and propagation up the tree
Split/merge/propagation is rare if M and L are large (Why?)
Pick branching factor M and data items/leaf L such that each node takes one full page/block of memory/disk.
B*-Trees fix thrashing.
Propagation is rare because (in a good case) only about 1/L inserts cause a split and only about 1/M of those go up even one level!
30 million’s not so big, right?
How about height 5?
2 billion 25

26. Complexity Find: Insert: Claim: O(M) costs are negligible find:
Insert in leaf:
split/propagate up:
Claim: O(M) costs are negligible 26

27. Tree Names You Might Encounter
“B-Trees”
More general form of B+ trees, allows data at internal nodes too
Range of children is (key1,key2) rather than [key1, key2)
B-Trees with M = 3, L = x are called 2-3 trees
Internal nodes can have 2 or 3 children
B-Trees with M = 4, L = x are called trees
Internal nodes can have 2, 3, or 4 children
Why would we use these?
Not to fit disk blocks, most likely.
We might use them just to get the log n bound, however. 27