B trees 1 Memoria principale Piccola e silicio

B trees 1

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

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

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

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

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ò. . . 6

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 Disk. Read(x) copia l’oggetto in memoria (Disk. Write(x) lo ricopia su disco) 7

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

B-tree If leaf[x]= false (x è un nodo interno) c 1[x], c 2[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: k 1≤key 1[x] ≤ k 2≤key 2[x] ≤. . . ≤keyn[x][x]≤ kn[x]+1 Ogni foglia ha la stessa profondità, che è quindi anche l’altezza dell’albero. 9

B-tree c 1 key 1 c 2 key 2 c 3 key 3 c 4 ai bi di ei ai ≤ key 1 ≤ bi ≤ key 2 ≤ di ≤ key 3 ≤ 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] ≤ 2 t-1 x = root n[x] ≥ 1 Un nodo x è pieno se n[x] = 2 t-1 10

B-tree root[T] 1 nodo 1. 000 chiavi 1000 . . . 1000 1. 001 nodi 1. 000 chiavi 1. 002. 001 nodi 1. 002. 001. 000 chiavi Più di un miliardo di chiavi! h=2 num. accessi ≤ 2 !!! 11

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 B, C F, G Q, T, X J, K, L N, P R, S V, W Y, Z 12

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: livello 1 t-1 t t-1 #di nodi 0 1 1 2 2 2 t t t-1 … t-1 13

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

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 (Disk. Write) • Qualsiasi nodo venga passato come parametro deve già essere in memoria centrale, a seguito di una Disk-Read. 15

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) 16

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 (leaf[x]) then return(nil) else DISK-READ(ci[x]) return(B-tree-Search(ci[x], k) 17

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 = Allocate. Node() leaf[x]=true n[x]=0 Disk. Write(x) root[T]=x num accessi a pagina: O(1) tempo CPU: O(1) 18

Divisione di un nodo I nodi si riempiono e raggiungono la loro capacità massima di 2 t – 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. 19

Split di un nodo 1 [x y i+ ] ke ke y . . . N S W. . . y = ci[x] pieno P Q R S T V W. . . - x . . . N W. . . T 1 yi e k i [x - ke y yi e k x ] [1 x ] non pieno i [x ] [x 1 ] t=4, 2 t-1=7 P Q R z = ci+1[x] T V W T 8 Mediano! 20

B-Tree-Split-Child ] x i - y[ yi e k [x 1 x] x: nodo padre y: nodo da spezzare (figlio di x) i: indice in x z: nuovo nodo ke B-Tree-Split-Child(x, i, y) z = Allocate. Node() 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 Disk. Write(y) Disk. Write(z) Disk. Write(x) . . . N W. . . y = ci[x] P Q R S T V W T 1 . . . T 8 21

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 22

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 2 t – 1 elementi 23

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

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

Inserimento di elementi BInsert. Tree. Non. Full cerca di inserire un elemento k in un nodo x, che si assume essere non pieno quando la procedura viene chiamata BTree. Insert e la ricorsione in BTree. Insert. Non. Full garantiscono che l’assunzione sia vera. 26

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 Disk. Write(x) else while i ³ 1 and k < keyi[x] i = i + 1 Disk. Read ci[x] if n[ci[x]] = 2 t – 1 then BTree. Split. Child(x, i, ci[x]) if k > keyi[x] then i = i + 1 BTree. Insert. Non. Full(ci[x], k) inserimento di una foglia i = i - 1 nodo interno: attraversamento dell’albero 27

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

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

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 BTree. Insert. Non. Full CPU: O(th) = O(t logtn) In ogni momento sono presenti O(1) pagine disco in memoria principale 30

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 elementi (mentre per l’inserimento < 2 t – 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 31

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

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 successore 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 2 t-1 chiavi. Ricorsivamente, si elimina k da y. 33

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

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). 35

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

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 ci[x] . . . l’ k m’. . . m… . . . l A B x . . . l’ m’. . . l k m. . . A B 37

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

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 verso 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) 39

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 40