B+

 Review  
 B+  Tree:  Most  Widely  Used  Index  
•  Insert/delete  at  log  F  N  cost;  keep  tree  height-­‐
balanced.      (F  =  fanout,  N  =  #  leaf  pages)  
•  Minimum  50%  occupancy  (except  for  root).    Each  
node  contains  d  <=    m    <=  2d  entries.    The  
parameter  d  is  called  the  order  of  the  tree.  
•  Supports  equality  and  range-­‐searches  efficiently.  
Index Entries
(Direct search)

Data Entries
("Sequence set")
 Example  B+  Tree  
•  Search  begins  at  root,  and  key  comparisons  
direct  it  to  a  leaf  (as  in  ISAM).  
•  Search  for  5*,  15*,  all  data  entries  >=  24*  ...  
Root

13 17 24 30

2* 3* 5* 7* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39*

☛  Based on the search for 15*, we know it is not in the tree!

 Inser[ng  a  Data  Entry  into  a  B+  Tree  
•  Find  correct  leaf  L.    
•  Put  data  entry  onto  L.  
–  If  L  has  enough  space,  done!  
–  Else,  must  split    L  (into  L  and  a  new  node  L2)  
•  Redistribute  entries  evenly,  copy  up  middle  key.  
•  Insert  index  entry  poin[ng  to  L2  into  parent  of  L.  
•  This  can  happen  recursively  
–  To  split  index  node,  redistribute  entries  evenly,  but  
push  up  middle  key.    (Contrast  with  leaf  splits.)  
•  Splits  “grow”  tree;  root  split  increases  height.      
–  Tree  growth:  gets  wider  or  one  level  taller  at  top.  
 Inser[ng  8*  into  Example  B+  Tree  
Entry to be inserted in parent node.
•  Observe  how   5 (Note that 5 is
s copied up and
minimum   continues to appear in the leaf.)
occupancy  is  
guaranteed  in   2* 3* 5* 7* 8*
both  leaf  and  
index  pg  splits.  
•  Note  difference  
between  copy-­‐up  
Entry to be inserted in parent node.
and  push-­‐up;  be   17 (Note that 17 is pushed up and only
sure  you   appears once in the index. Contrast
this with a leaf split.)
understand  the  
reasons  for  this.   5 13 24 30
 Example  B+  Tree  
•  We’re  going  to  insert  8.  

Root

13 17 24 30

2* 3* 5* 7* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39*

☛  Based on the search for 15*, we know it is not in the tree!

 Example  B+  Tree  Afer  Inser[ng  8*  
Root
17

5 13 24 30

2* 3* 5* 7* 8* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39*

v  Notice that root was split, leading to increase in height.

v  In this example, we can avoid split by re-distributing
entries; however, this is usually not done in practice.
 Dele[ng  a  Data  Entry  from  a  B+  Tree  
•  Start  at  root,  find  leaf  L  where  entry  belongs.  
•  Remove  the  entry.  
–  If  L  is  at  least  half-­‐full,  done!    
–  If  L  has  only  d-­‐1  entries,  
•  Try  to  re-­‐distribute,  borrowing  from  sibling  (adjacent  node  with  
same  parent  as  L).  
•  If  re-­‐distribu[on  fails,  merge  L  and  sibling.  
•  If  merge  occurred,  must  delete  entry  (poin[ng  to  L  
or  sibling)  from  parent  of  L.  
•  Merge  could  propagate  to  root,  decreasing  height.  
Delete  
 Example  B+  Tree  Afer  Inser[ng  8*  
Root
17

5 13 24 30

2* 3* 5* 7* 8* 14* 16* 19* 20* 22* 24* 27* 29* 33* 34* 38* 39*

v  We’re going to delete 19 and 20

 Example  Tree  Afer  (Inser[ng  8*,  
Then)  Dele[ng  19*  and  20*  ...  
Root

17

5 13 27 30

2* 3* 5* 7* 8* 14* 16* 22* 24* 27* 29* 33* 34* 38* 39*

•  Dele[ng  19*  is  easy.   Next,  we  delete  24  

•  Dele[ng  20*  is  done  with  re-­‐distribu[on.  

No[ce  how  middle  key  is  copied  up.  
                ...  And  Then  Dele[ng  24*  
•  Must  merge.   30

•  Observe  `toss’  of  

index  entry  (on  right),   22* 27* 29* 33* 34* 38* 39*

and  `pull  down’  of  

index  entry  (below).  
Root
5 13 17 30

2* 3* 5* 7* 8* 14* 16* 22* 27* 29* 33* 34* 38* 39*

 Example  of  Non-­‐leaf  Re-­‐distribu[on  

•  Tree  is  shown  below  during  dele>on  of  24*.  

(What  could  be  a  possible  ini[al  tree?)  
•  In  contrast  to  previous  example,  can  re-­‐
distribute  entry  from  lef  child  of  root  to  right  
child.       Root

22

5 13 17 20 30

2* 3* 5* 7* 8* 14* 16* 17* 18* 20* 21* 22* 27* 29* 33* 34* 38* 39*
 Afer  Re-­‐distribu[on  
•  Entries  are  re-­‐distributed  by  `pushing  through’  
the  splilng  entry  in  the  parent  node.  
•  It  suffices  to  re-­‐distribute  index  entry  with  key  
20;  we’ve  re-­‐distributed  17  as  well  
Root

17

5 13 20 22 30

2* 3* 5* 7* 8* 14* 16* 17* 18* 20* 21* 22* 27* 29* 33* 34* 38* 39*
B+  Concurrency  
 Model  
•  We  consider  page  lock(x)/unlock(x)  of  pages  
(only  for  writes!)  

•  We  copy  into  our  memory  and  then  atomically  

update  pages.  
 P1  
P2  
Simple   Approach  
…   15   …  

P1  

P2  
P2  
8   10   12   15  

•  P1  searches  for  15  

•  P2  inserts  9  
 Afer  the  Inser[on  

…   10   15  

P1  

P2   P1   P2  
8   9   10   12   15  

•  P1  searches  for  15  

P1  Finds  no  15!  
•  P2  inserts  9  
How  could  we  fix  this?  
B-­‐Link  Trees  
 Two  important  Conven[ons  

•  Search  for  B-­‐link  trees  root  to  leaf,  lef-­‐to-­‐right  

in  nodes  

•  Inser[ons  for  B-­‐link  trees  proceed  bopom-­‐up.    

 Internal  Nodes  
•  Parameter  d  =  the  degree  
Internal  Node  has  
s  >=  d  and  <=  2d  keys  
30 120 240 280  

Keys   240<=280  
Keys   240<=k  
Keys  k  <  30  
Keys  30<=k<120   Keys  120<=k<240  

Add  right  pointers.   We  add  a  High  key  

Idea:  If  we  get  to  this  page,  looking  for  

300.  What  can  we  conclude  happened?  
 Valid  Trees  &  Safe  Nodes  
•  A  node  may  not  have  a  parent  node,  but  it  
must  have  a  lef  twin.  

•  We  introduce  the  right  links  before  the  

parent.  

•  A  node  is  safe  if  it  has  [k,2k-­‐1]  pointers.  

 Scannode  

scannode(u,    A)  :  examine  the    tree    node    in  A    for    

value    u    and    return    the    appropriate    pointer    
from    A.  

 Appropriate  pointer  may  be  the  right  pointer.    

 Searching  for  v  
current  =  root;  
A  =  get(current);  
while  (current  is  not  a  leaf)  {  
               current  =  scannode(v,  A);   Find  the  leaf  w/  v  
               A  =  get(current);}  
while  ((t  =  scannode(v,A))  ==  link  pointer  of  A)  {  
               current  =  t;  
Find  the  leaf  w/  v  
               A  =  get(current);}  
Return  (v  is  in  A)  ?  success  :    failure;  

Only  modify  scannode  –  No  locking?!?  

Insert  
 High  Key  Omiped    
Revised  
P1  
P2  
Approach  
…   15   …  

P1  

P2  
P2  
8   10   12   15  

•  P1  searches  for  15  

•  P2  inserts  9  
 Revised  Approach:  Build  new  page  
…   15   …  

P1  

P2  
8   10   12   15  

•  P1  searches  for  15  

•  P2  inserts  9  
12   15  
 Revised  Approach:  Build  new  page  
…   15   …  

P1  

P2  
8   9   10  

•  P1  searches  for  15  

•  P2  inserts  9  
12   15  
How  did  P1  know  
to  con[nue?  
 Start  Insert  
ini[alize  stack;  current  =  root;   Keep  a  stack  of  the  
rightmost  node  we  
A  =  get(current);   visited  at  each  level:    
while  (current  is  not  a  leaf)  {  
               t  =  current;  
               current  =  scannode(v,A);  
               if  (current  not  link  pointer  in  A)  
                               push  t;  
               A  =  get(current);}  
 A  subrou[ne:  move_right  
While  t  =  scannode(v,A)  is  a  link  pointer  of  A  do  
 Lock(t)  
       Unlock(current)   How  many  locks  held  
       Current  =  t   here?  

       A  =  get(current);  
end  
  The  move_right  procedure  scans  right  
across  the  leaves  with  lock  coupling.    
 Easy  case:  
DoInsert:  
 
if  A  is  safe  {  
               insert  new  key/ptr  pair  on  A;  
               put(A,  current);  
               unlock(current);  
}  
 Fun  Case:  Must  split  
u  =  allocate(1  new  page  for  B);  
redistribute  A  over  A  and  B  ;  
y  =  max  value  on  A  now;  
make  high  key  of  B  equal  old  high  key  of  A;  
make  right-­‐link  of  B  equal  old  right-­‐link  of  A;  
make  high  key  of  A  equal  y;  
make  right-­‐link  of  A  point  to  B;              
 Insert  
put  (B,  u);  
put  (A,  current);  
oldnode  =  current;  
new  key/ptr  pair  =  (y,  u);  //  high  key  of  new  page,  
new  page  
current  =  pop(stack);  
lock(current);  A  =  get(current);  
move_right();     may  have  3  locks:  oldnode,  and  
unlock(oldnode)   two  at  the  parent  level  while  
goto  Doinser[on;   moving  right  
Deadlock  Free  
 Total  Order  <  on  Nodes  
Consider  pages  a,b    define  a  total  order  <  
1.  a  <  b  if  b  is  closer  to  the  root  than  a  (different  
height)  
2.  If  a  and  b  are  at  the  same  height,  then  a  <  b  if  
b  is  reachable.  

“Order  is  bopom-­‐up”  

Observa[on:  Insert  process  only  puts  down  locks  

sa[sfying  this  order.  Why  is  this  true?  
 Deadlock  Free  

Since  the  locks  are  placed  by  every  process  in  a  

total  order,  there  can  be  no  deadlock.  Why?  

 Is  it  possible  to  get  the  cycle:  

T1(A)  T2(B)  T1(B)  T2(A)?  
Tree  Modifica[on  
 Tree  Modifica[ons  

Thm:  All  opera[ons  correctly  modify  the  tree  

structure.  

Observa[on  1:  put(B,u)  and  put(A,  current)  are  one  opera[on  

(since  put(B,u)  doesn’t  change  tree.  Proof  by  pictures  (again).  
 Revised  Approach:  Build  new  page  
…   15   …  

P1  

P2  
8   10   12   15  

•  P1  searches  for  15  

•  P2  inserts  9  
12   15  
 Revised  Approach:  Build  new  page  
…   15   …  

P1  

P2  
8   9   10  

•  P1  searches  for  15  

•  P2  inserts  9  
12   15  
How  did  P1  know  
to  con[nue?  
Correct  Interac[on  of    
Readers  and  Writers  
 Correct  Interac[on  

Thm:  Ac[ons  of  an  inser[on  process  do  not  impair  

the  correctness  of  the  ac[ons  of  other  processes.  
 Type  1:  No  split  
…   15   …  

P1  

P2  
8   10  
9   15  
10   15  

•  P1  searches  for  15   P2  reads  the  page.  

•  P2  inserts  9    What  schedule  is  this?    
Why  can’t  P1,P2  conflict  again?  

What  if  P2  reads  afer  P1?    

Type  2:  Split.  insert  into  lef  Node  
 Type  2:  Split.  Insert  LHS.  
…   15   …  

P1  

P2  
7   10   12   15  

•  P1  searches  for  8   12   15  
•  P2  inserts  9  
No[ce  that  P1  would  have  
followed  9s  pointer!   How  will  P1  find  8?  
Livelock  
 Livelock  problem  
P2   P3  
P6  
P5  
P4  

P1  

Poor  P1  never  gets  its  value!  

P1  is  livelocked!  
Chaining  Example  
 Can  we  get  down  below  3  locks?  
Consider  the  Alterna[ve  Protocol    
(without  lock  coupling)  
read  A;  
Large  #  of  inserts.  A  splits  
find  out  that  there  is  room;   and  afer  there  is  room!  
lock  and  re-­‐read  A;   What  prevents  this  in  Blink?  
find  there  is  s[ll  room,  and  insert  9  
unlock  A;  
5   6   12   15  
A  
 Further  Reading  
•  Recent  HP  Tech  Report  is  great  source  
(Graefe)  
hpp://www.hpl.hp.com/techreports/2010/
HPL-­‐2010-­‐9.pdf  

•  Extensions:   R-­‐trees  and  GiST  

Marcel  Kornacker,  Douglas  Banks:  High-­‐Concurrency  
Locking  in  R-­‐Trees.  VLDB  1995:  134-­‐145  
Marcel  Kornacker,  C.  Mohan,  Joseph  M.  Hellerstein:  
Concurrency  and  Recovery  in  Generalized  Search  
Trees.  SIGMOD  Conference  1997:  62-­‐72