B-alberi dizionari in memoria secondaria

ASD - B-tree2 dizionari su memoria secondaria la memorizzazione su memoria secondaria risponde a due esigenze –permanenza dellinformazione la RAM è volatile –grande quantità di dati la RAM è limitata memoria secondaria: disco

ASD - B-tree3 modello di costo il costo in termini di tempo per accedere al disco (scrittura/lettura) domina in maniera sostanziale il costo di elaborazione in RAM –parti meccaniche in movimento con costanti di tempo dellordine delle decine di millisecondi –una CPU esegue unistruzione elementare in pochi colpi di clock –ad es., copia di un dato dalla RAM a un registro supp. 10 colpi di clock, CPU a 1GHz 10 ns per copia RAM->registro 20 ns per unassegnazione

ASD - B-tree4 modello di costo/2 Occorre considerare modelli di costo diversi dal modello RAM se il costo dominante della computazione è costituito dagli accessi in memoria secondaria. Ex: # di accessi a disco x seek time + tempo di trasferimento dei dati da disco a memoria principale

ASD - B-tree5 modello di costo/3 laccesso al disco avviene per blocchi (o pagine fisiche ) –tutti i blocchi hanno la stessa dimensione (da 512B ad alcuni KB) –ciascun blocco è definito da tre coordinate: cilindro (o traccia ), settore, faccia cilindro settoretraccia faccia

ASD - B-tree6 modello di costo/4 tempo di accesso al disco = somma di tre componenti –seek time per posizionare la testina sul cilindro corretto –latency time attesa necessaria affinché il settore desiderato transiti sotto la testina –tempo di trasferimento dati scambiati fra RAM e disco

ASD - B-tree7 esempio seek time –~15-20ms latency time –valore atteso: 50% del tempo di rotazione in un disco a 7200rpm, poco più di 4ms tempo di trasferimento –velocità: alcuni MB/s blocco di 4KB, seek 15 ms, 10000rpm, velocità di trasferimento 2MB/s tempo (ms) di accesso al blocco ms/blocco = 20ms/blocco costo (ammortizzato) per byte 20ms/4096B 4.9µs/B

ASD - B-tree8 esempio/2 nel caso di accesso a più blocchi contigui vengono pagati un solo seek e un solo latency la convenienza aumenta allaumentare del numero di blocchi contigui –bulk access vs. random access blocco di 4KB, seek 15 ms, 10000rpm, velocità di trasferimento 2MB/s tempo (ms) di accesso a due blocchi contigui ·2 ms/blocco = 22ms/blocco costo (ammortizzato) per byte 22ms/8192B 2.7µs/B

ASD - B-tree9 esempio/3

ASD - B-tree10 ammortizzazione la contiguità premia

ASD - B-tree11 modello di costo/5 costo (tempo): # di I/O su disco –blocco ha dimensione B –RAM ha dimensione M –disco ha dimensione tempo di CPU trascurabile –buona approssimazione in molti casi

ASD - B-tree12 1 dizionari in memoria secondaria idea: paginare un albero di ricerca

ASD - B-tree13 BST paginato lalbero non è più binario si può definire un albero di ricerca m -ario?

ASD - B-tree14 B-tree di ordine m radice con 0 o p > 1 figli ogni nodo interno (non radice) con k – 1 chiavi e k figli, m /2 k m –non lo stesso k per ciascun nodo! foglie con k-1 chiavi, m /2 k m albero di ricerca –ad ogni chiave è associato un sottoalbero destro di chiavi inferiori ed uno sinistro di chiavi superiori m è il max numero di figli Nota: le foglie contengono puntatori a blocchi di elementi

ASD - B-tree15 B-tree di ordine / è anche un B-tree di ordine 3? Nota: si sono indicate solo le chiavi

ASD - B-tree16 scelte progettuali un nodo = un blocco chiave c bit riferimento a sottoalbero r bit in ogni nodo rm + c (m - 1) bit m = (B + c )/(r + c ) –se B = 4KB, c = r = 32 bit m 64 Ogni blocco di elementi è memorizzato in un blocco su disco (dim. B) –Se max. L bit per elemento al più B/L elem./blocco Obiettivo: avere alberi di altezza piccola (es. 4)

ASD - B-tree17 Altezza di un B-tree quali sono le altezze minime e massime di un B-tree di ordine m con n chiavi? –altezza max ottenuta quando ogni nodo interno ha il min numero di figli (albero spoglio) la radice ha 2 figli ed ogni altro nodo interno ha m /2 figli –altezza min quando ogni nodo interno ha il max numero (m ) di figli (albero frondoso)

ASD - B-tree18 altezza di un B-tree spoglio sia q = m /2 1 chiave nella radice q - 1 chiavi in ogni altro nodo livello 2: 2 nodi livello 3: 2q nodi livello 4: 2q 2 nodi livello i : 2q i –2 nodi

ASD - B-tree19 altezza di un B-tree spoglio/2 # chiavi in un B-tree spoglio di altezza h >= D.: qual è laltezza di un B-tree frondoso?

ASD - B-tree20 Scelte progettuali/2 un nodo = un blocco chiave c bit riferimento a sottoalbero r bit in ogni nodo rm + c (m - 1) bit m = (B + c )/(r + c ) –se B = 4KB, c = r = 32 bit m 64 –con n = 10ML chiavi h 6 E possibile avere alberi con altezza piccola in casi di interesse pratico –radice spesso mantenuta in RAM

ASD - B-tree21 rappresentazione nodi (RAM) class BTreeNode { int m; boolean leaf; /* true se nodo è foglia */ int keyTally; /* No. di chiavi presenti */ int keys = new int[m-1]; BTreeNode references[] = new BTreeNode[m]; BtreeNode(int key) {…} /* Costruttore */ } /* Nota: si assumono chiavi intere */ /* keys può essere un array di oggetti contenenti coppie */

ASD - B-tree22 Rappresentazione con riferimenti

ASD - B-tree23 cenno alla rappresentazione dei nodi su disco file a sé stanti, ciascuno di un blocco –più semplice da realizzare –i riferimenti ai sottoalberi sono nomi di file –overhead per il sistema operativo tutti in un unico file –soluzione compatta, ma più complessa –riferimenti ai sottoalberi offset relativi allinizio di un file (file frammentato, solo accessi random) indirizzi assoluti (cilindro+settore+faccia, file non portatili)

ASD - B-tree24 ricerca in un B-tree public BTreeNode BTReeSearch(int key) { return BTreeSearch(key, root) } protected BTreeNode BTreeSearch(int key, BTreeNode node) { if (node != null) { int i=1; while ((i<=node.keyTally)&&(node.keys[i-1]< key)) { i++; if ((i>node.keyTally) || (node.keys[i-1]>key)) return BTreeSearch(key, nodereferences[i-1]; else return node; } else return null; }

ASD - B-tree25 Ricerca chiave di valore /465144

ASD - B-tree26 inserimento in B-tree come nei BST, si effettua una ricerca della chiave da inserire si tenta dapprima di inserire la chiave in una foglia (appropriata) –se la foglia non è piena il processo termina –se la foglia è piena (ha già m – 1 chiavi) abbiamo una situazione di overflow e possiamo scinderla in due la scissione può determinare altre scissioni

ASD - B-tree27 Inserimento in foglia non piena Un albero B prima (a) e dopo (b) linserimento della chiave 7 in una foglia avente celle disponibili

ASD - B-tree28 Inserimento in foglia piena Inserimento della chiave 6 in una foglia piena

ASD - B-tree29 gestione degli overflow gestione delloverflow tramite scissione (o divisione o split) –allocazione di un nuovo nodo (foglia) –le m chiavi vengono così ripartite: (m – 1) / 2 nella foglia in overflow, (m – 1) / 2 nella nuova e una (la mediana fra le m ) viene inserita nel genitore per separare le due foglie (nellesempio, m=5) se il genitore va in overflow si usa la stessa tecnica

ASD - B-tree30 gestione degli overflow/2 gli overflow si possono propagare verso lalto fino a coinvolgere la radice se la radice va in overflow questa deve venire scissa ed occorre creare una nuova radice, che conterrà la chiave mediana fra le m coinvolte nelloperazione –in questo caso lalbero aumenta la propria altezza Animazione a tml

ASD - B-tree31 Inserimento Algorithm BTreeInsert(k) { /* Sia essa node */ if (<nodo non pieno) { return; } else { ; } /* Continua prossima slide */

ASD - B-tree32 Inserimento /* Continua da slide precedente */ if ( ) { root.keyTally=1; return; } else }

ASD - B-tree33 costo inserimento discesa radice – foglia –O(log m/2 n ) I/O split –O(1) I/O (3 o 4) #split –O(log m/2 n ) costo totale: O(log m/2 n )

ASD - B-tree34 eliminazione da un B-tree si effettua una ricerca della chiave da inserire se la chiave è in una foglia, la si elimina dalla stessa e si verifica se il numero di chiavi rimanenti sia comunque non inferiore a m / –se rimangono troppe poche chiavi si ha underflow, che richiede una gestione specifica se la chiave è in un nodo interno la si sostituisce con il predecessore (o il successore), che è in una foglia, e ci si riconduce al caso precedente –simile alla tecnica usata nei BST

ASD - B-tree35 Azioni eseguite dopo leliminazione del numero 6

ASD - B-tree36 gestione degli underflow un nodo in underflow ha m / chiavi si tenta dapprima una ridistribuzione delle chiavi fra nodo e un fratello, coinvolgendo la chiave che li separa nel genitore –occorre un fratello con almeno m / 2 chiavi se non è disponibile un fratello per operare la ridistribuzione occorre effettuare la fusione (o merge) fra nodo in underflow e un fratello –richiede una gestione specifica

ASD - B-tree37 fusione di nodi due nodi fratelli possono essere fusi se uno di essi è in underflow e laltro ha il numero di chiavi minimo m / la fusione consiste nellinserire in un solo nodo tutte le chiavi presenti nei due nodi, oltre a quella del genitore che separava i due nodi –la fusione permette di liberare risorse precedentemente allocate a un nodo –richiede leliminazione di una chiave dal genitore, che a sua volta, può andare in underflow, divenendo oggetto di attenzione da parte del gestore dellunderflow

ASD - B-tree38 fusione di nodi/2 se i nodi oggetto di fusione sono i due unici figli della radice, questa scompare e il risultato della fusione diviene la nuova radice –in tal caso vengono liberate risorse allocate a due nodi –lalbero diminuisce laltezza Animazione a tmlAnimazione a tml

ASD - B-tree39 algoritmo di eliminazione Algorithm BTreeDelete(k) { node = BTreeSearch(k) if(node != null) { if( ) { } else

ASD - B-tree40 algoritmo di eliminazione/2 while(true) { if( ) return; else if ( ) { return; } else if ( ) { if ( )

ASD - B-tree41 algoritmo di eliminazione/3 else return; } /* End else if */ else } } /* End while */ } /* End if */ } /* End algoritmo */

ASD - B-tree42 costo eliminazione discesa radice – foglia –O(log m/2 n ) I/O redistribuzione –O(1) I/O (3 o 4) fusione –O(1) I/O (3 o 4) #fusioni –O(log m/2 n ) costo totale: O(log m/2 n )

ASD - B-tree43 B + -tree chiavi solo nelle foglie nodi interni contengono solo informazioni di branching e costituiscono un vero e prorpio indice le foglie sono collegate orizzontalmente algoritmi di gestione simili a quelli per il B- tree –una differenza notevole è nello split di una foglia: la chiave separatrice viene copiata (e non spostata) nel genitore