B trees

Memoria Memoria principale “Piccola” e “veloce” (chips, silicio) Mb 10-8 / 10-9 sec. Memoria secondaria “Grande” e “lenta” (dischi magnetici) Gb 10-3 / 10-4 sec.

Blocchi di memoria Memoria principale Un blocco contiene k bytes, k=1, ... , 64 Memoria secondaria Un blocco contiene k Kb (kiloBytes = 1024 bytes) k=64, ... , 1024

Problema Minimizzare il numero di accessi alla memoria secondaria Soluzione Strutture dati ad hoc, specifiche per questo problema.

Dischi magnetici I dischi memorizzano molti dati ma sono lenti. Trovare una pagina richiede tempo (posizionamento testina più tempo di rotazione, 5-10ms), la lettura è veloce Conviene leggere i dati in pagine (blocchi) di 2-16 Kb ciascuno. Dall’alto rotazione traccia settore testina di lettura/scrittura cilindri

Tempo di esecuzione Spesso il tempo necessario per accedere ad una pagina su disco è superiore al tempo necessario all’elaboratore per esaminare tutta l’informazione letta. Tempo di esecuzione: numero di accessi a disco tempo (di calcolo) della CPU Il num. di accessi a disco è misurato in numero di pagine lette/scritte. Non è costante, però ...

Operazioni sui dati Per accedere alle strutture dati non si fa riferimento a indirizzi in memoria centrale ma a locazioni su file. Sia x è un puntatore ad un oggetto: se x è nella memoria principale, gli si accede ad es. con key[x] se è su disco, la procedura DiskRead(x) copia l’oggetto in memoria (DiskWrite(x) lo ricopia su disco)

B-tree Un B-tree è un albero di radice root(T) in cui ogni nodo x è strutturato come segue: X= n[x] = numero delle chiavi (key) del nodo x leaf[x]: booleano, vero se x è foglia Chiavi memorizzate in ordine non-decrescente key1 ≤ key2 ≤ key3 ≤ ... ≤ keyn n key1 key2 ... keyn leaf

B-tree If leaf[x]= false (x è un nodo interno) c1[x], c2[x], ... , cn[x]+1[x] sono puntatori ai nodi figli I campi keyi[x] definiscono gli intervalli delle chiavi memorizzate in ciascun sottoalbero: se ki è una chiave memorizzata nel sottoalbero di radice ci[x] allora si ha che: k1≤key1[x] ≤ k2≤key2[x] ≤... ≤keyn[x][x]≤ kn[x]+1 Ogni foglia ha la stessa profondità, che è quiandi anche l’altezza dell’albero.

B-tree ai ≤ key1 ≤ bi ≤ key2 ≤ di ≤ key3 ≤ ei c1 key1 c2 key2 c3 key3 c4 ai bi di ei ai ≤ key1 ≤ bi ≤ key2 ≤ di ≤ key3 ≤ ei Il num. di chiavi memorizzabili in un nodo è limitato in funzione di un intero t, t ≥ 2, chiamato grado minimo x ≠ root n[x] ≥ t-1 n[x] ≤ 2t-1 x = root n[x] ≥ 1 Un nodo x è pieno se n[x] = 2t-1

B-tree ... Più di un miliardo di chiavi! h=2 num. accessi ≤ 2 !!! root[T] 1000 ... 1 nodo 1.000 chiavi 1.001 nodi 1.001.000 chiavi 1.002.001 nodi 1.002.001.000 chiavi Più di un miliardo di chiavi! h=2 num. accessi ≤ 2 !!!

B-tree Alberi di ricerca bilanciati (balanced search tree, BST) I nodi dei B-tree possono avere molti figli (migliaia) Profondità = O(log n) Generalizzano naturalmente i BST M D,H Q,T,X B,C F,G J,K,L N,P R,S V,W Y,Z

Altezza di un B-tree Se n ≥ 1, allora per ogni B-tree T (con n chiavi) di altezza h, di grado minimo t ≥ 2, vale che: h ≤ logt((n+1)/2) livello #di nodi 1 2 2t 1 t - 1 t - 1 t t t - 1 t - 1 … t - 1 t - 1 t - 1 … t - 1

Analisi tempi di esecuzione trovato trovato non trovato numero di accessi a disco: O(logt n) CPU time: O(t logt n)

Operazioni sui B-tree Assunzioni: La radice di un B-tree è sempre in memoria centrale Quando si modifica la root bisogna effettuare una scrittura su disco (DiskWrite) Qualsiasi nodo venga passato come parametro deve già essere in memoria centrale, a seguito di una Disk-Read.

Operazioni sui B-tree Le operazioni da realizzare sono: Ricerca di una chiave (semplice) Creazione di un nuovo albero vuoto (semplice) Inserimento di nuove chiavi (complessa) Cancellazione di chiavi (complessa)

B-tree search(x,k) Operazione di ricerca su B-tree, parametri: x: radice di un sottoalbero k: chiave da cercare B-Tree-Search(x,k) i=1 while i ≤ n[x] and k>keyi[x] do i=i+1 if i ≤ n[x] and k=keyi[x] then return(x,i) if (foglia[x]) then return(nil) else DISK-READ(ci[x]) return(B-tree search(ci[x],k)

Creazione di un B-tree vuoto Inizialmente si crea un nodo radice vuoto con la B-Tree-Create, poi lo si riempie con la B-Tree-Insert. Entrambe utilizzano la Allocate-Node che crea un nuovo nodo e gli assegna una pagina di disco in tempo O(1). B-Tree-Create(T) x = AllocateNode() leaf[x]=true n[x]=0 DiskWrite(x) root[T]=x num accessi a pagina: O(1) tempo CPU: O(1)

Divisione di un nodo I nodi si riempiono e raggiungono la loro capacità massima di 2t – 1 chiavi. Per poter inserire una nuova chiave è necessario “fare spazio”, cioè dividere (split) il nodo. La divisione avviene in corrispondenza della sua chiave mediana. Risultato: una chiave di x sale di un livello + 2 nodi con t-1 chiavi.

Split di un nodo t=4, 2t-1=7 non pieno pieno T1 ... T8 Mediano! keyi-1[x] keyi[x] keyi-1[x] keyi[x] keyi+1[x] x x ... N W ... ... N S W ... y = ci[x] y = ci[x] z = ci+1[x] pieno P Q R S T V W P Q R T V W T1 ... T8 Mediano!

B-Tree-Split-Child T1 ... T8 B-Tree-Split-Child(x,i,y) z = AllocateNode() leaf[z] = leaf[y] n[z] = t-1 for j = 1 to t-1 keyj[z] = keyj+t[y] if not leaf[y] then for j = 1 to t cj[z] = cj+t[y] n[y] = t-1 for j = n[x]+1 downto i+1 cj+1[x] = cj[x] ci+1[x] = z for j = n[x] downto i keyj+1[x] = keyj[x] keyi[x] = keyt[y] n[x] = n[x]+1 DiskWrite(y) DiskWrite(z) DiskWrite(x) x: nodo padre y: nodo da spezzare (figlio di x) i: indice in x z: nuovo nodo keyi-1[x] keyi[x] x ... N W ... y = ci[x] P Q R S T V W T1 ... T8

Split: tempo di CPU Lo split è un’operazione locale che non percorre l’albero Tempo di CPU Q(t): I due loop vengono eseguiti t volte 3 operazioni di I/O

Inserimento di elementi Inserimento effettuato ricorsivamente: si inizia dalla radice e si percorre ricorsivamente l’albero fino al livello delle foglie E’ necessario scendere ad un livello inferiore se il nodo corrente contiene 2t – 1 elementi

Inserimento di elementi (2) Caso particolare: la radice è piena (BtreeInsert) B-Tree-Insert(T) r = root[T] if n[r] == 2t – 1 then s = AllocateNode() root[T] = s leaf[s] = FALSE n[s] = 0 c1[s] = r B-Tree-Split-Child(s,1,r) B-Tree-Insert-Non-Full(s,k) else B-Tree-Insert-Non-Full(r,k)

Split della radice Lo split della radice richiede la creazione di nuovi nodi L’albero cresce (verso l’alto invece che verso il basso). A D F H L N P T1 T8 ... root[T] r A D F L N P H s

Inserimento di elementi BInsertTreeNonFull cerca di inserire un elemento k in un nodo x, che si assume essere non pieno quando la procedura viene chiamata BTreeInsert e la ricorsione in BTreeInsertNonFull garantiscono che l’assunzione sia vera.

Inserimento di elementi: Pseudo Codice B-Tree-Insert-Non-Full(x,k) i = n[x] if leaf[x] then while i ³ 1 and k < keyi[x] keyi+1[x] = keyi[x] i = i - 1 keyi+1[x] = k n[x] = n[x] + 1 DiskWrite(x) else while i ³ 1 and k < keyi[x] i = i + 1 DiskRead ci[x] if n[ci[x]] = 2t – 1 then BTreeSplitChild(x,i,ci[x]) if k > keyi[x] then BTreeInsertNonFull(ci[x],k) inserimento di una foglia nodo interno: attraversamento dell’albero

Inserimento: esempio albero iniziale (t = 3) inserimento di B G M P X A C D E J K N O R S T U V Y Z inserimento di B G M P X A B C D E J K N O R S T U V Y Z inserimento di Q G M P T X A B C D E J K N O Q R S U V Y Z

Inserimento: esempio (2) inserimento di L G M T X A B C D E J K L N O Q R S U V Y Z inserimento di F P C G M T X A B D E F J K L N O Q R S U V Y Z

Inserimento: tempo di CPU I/O su disco: O(h), dato che vengono eseguiti solo O(1) accessi a disco durante le chiamate ricorsive a BTreeInsertNonFull CPU: O(th) = O(t logtn) In ogni momento sono presenti O(1) pagine disco in memoria principale

Cancellazione di elementi Effettuata ricorsivamente, iniziando dalla radice e percorrendo l’albero ricorsivamente fino al livello delle foglie Si scende ad un nuovo livello dell’albero se il nodo corrente contiene t-1 elementi (mentre per l’inserimento 2t – 1 elem.) B-tree-Delete gestisce tre diversi casi: Caso 1: elemento k trovato in una foglia Caso 2: elemento k trovato in un nodo interno Caso 3: elemento k probabilmente in un nodo di livello inferiore

Cancellazione (2) albero iniziale Caso 1: se l’elemento k è nel nodo x, e x è una foglia, cancella k da x albero iniziale P C G M T X A B D E F J K L N O Q R S U V Y Z F cancellato: caso 1 P C G M T X A B D E J K L N O Q R S U V Y Z x

cancellazione (3) Caso 2: se la chiave k è nel nodo x, e x non è una foglia, cancella k da x a) Sia y il figlio di x che precede k. Se y ha almeno t chiavi, trova il predecessore k’’ di k nel sottoalbero di radice in y. Ricorsivamente cancella k’’ e sostituisci k con k’’ in x. b) Simmetricamente per il nodo sucessore z c) se sia y che z hanno t-1 chiavi, si inserisce in y sia k che tutti i figli di z (che diventano figli di y). Il nodo y ha 2t-1 chiavi. Ricorsivamente, si elimina k da y.

Cancellazione (4) M cancellato: caso 2a x y G cancellato: caso 2c P x C G L T X A B D E J K N O Q R S U V Y Z y G cancellato: caso 2c P C L x - k T X A B D E J K N O Q R S U V Y Z y = k + z - k

Cancellazione - distribuzione Caso 3: se k non è nel nodo interno x, trova il sottoalbero di radice ci[x] che potrebbe contenere k. Se ci[x] ha solo t – 1 elementi, ci si assicura di scendere in un nodo che abbia almeno dimensione t; poi si chiama ricorsivamente l’operazione sul sottoalbero scelto. Possibili due casi. a) se ci[x] ha solo t-1 chiavi, ma ha un fratello con almeno t chiavi, aggiungi a ci[x] un altra chiave prendendola da x, poi sposta una chiave dal fratello immediatamente a destra o a sinistra di ci[x] in x e sposta l’opportuno figlio dal fratello in ci[x] (distribuzione).

Cancellazione – distribuzione (2) x x ... k’ ... ... k ... ci[x] ci[x] ... k ... k’ A B A B C L P T X cancella B ci[x] A B E J K N O Q R S U V Y Z fratello B cancellato: E L P T X A C J K N O Q R S U V Y Z

Cancellazione - fusione b) Se ci[x] e tutti i suoi fratelli hanno t – 1 elementi, allora fondi (merge) ci con un fratello, spostando un elemento da x nel nuovo nodo unione e facendolo così diventare il mediano di quel nodo x x ... l’ k m’... ... l’ m’ ... ci[x] ... l m … ...l k m ... A B A B

Cancellazione – fusione (2) P ci[x] cancella D fratello C L T X A B D E J K N O Q R S U V Y Z D cancellato: C L P T X A B E J K N O Q R S U V Y Z l’altezza dell’albero diminuisce

Cancellazione: tempo di CPU La maggior parte degli elementi sono nelle foglie, quindi la cancellazione avviene più spesso nelle foglie. In questo caso la cancellazione avviene in un’unica discesa verso il livello delle foglie La cancellazione di un nodo interno può richiedere un ritorno verso l’alto (caso 2) I/O su disco: O(h), dato che si effettuano solo O(1) operazioni su disco durante le chiamate ricorsive Tempo di CPU: O(th) = O(t logtn)

Altri metodi di accesso Varianti dei B-tree: B+-tree, B*-tree B+-tree: usati nei data base management systems (DBMS) Schema generale dei metodi di accesso (comune ai B+-tree): Gli elementi contenenti dati sono memorizzati solo nelle foglie Gli elementi sono raggruppati in nodi foglie Ogni elmento in un nodo interno memorizza: un puntatore a un sottoalbero una descrizione compatta dell’insieme di elementi memorizzati nel sottoalbero