B alberi. dizionari in memoria secondaria

Transcript

1 B alberi dizionari in memoria secondaria

2 dizionari su memoria secondaria la memorizzazione su memoria secondaria risponde a due esigenze permanenza dell informazione la RAM è volatile grande quantità di dati la RAM è limitata memoria secondaria: disco ASD B tree 2

3 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 dell ordine delle decine di millisecondi una CPU esegue un istruzione 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 un assegnazione ASD B tree 3

4 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 tree 4

5 l accesso 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 modello di costo/3 faccia cilindro traccia settore ASD B tree 5

6 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 tree 6

7 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 tree 7

8 esempio/2 nel caso di accesso a più blocchi contigui vengono pagati un solo seek e un solo latency la convenienza aumenta all aumentare 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 ms/blocco = 22ms/blocco costo (ammortizzato) per byte 22ms/8192B 2.7µs/B ASD B tree 8

9 esempio/3 tempo accesso (ms) ms 120,00 100,00 80,00 60,00 40,00 20,00 0, #blocchi contigui ASD B tree 9

10 ammortizzazione tempo (microsec.) ammortizato per byte la contiguità premia microsec. 6000, , , , , ,00 0, #blocchi contigui ASD B tree 10

11 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 tree 11

12 dizionari in memoria secondaria idea: paginare un albero di ricerca ASD B tree 12

13 BST paginato l albero non è più binario si può definire un albero di ricerca m ario? ASD B tree 13

14 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 tree 14

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

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

17 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 tree 17

18 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 tree 18

19 altezza di un B tree spoglio/2 # chiavi in un B tree spoglio di altezza h >= 1 2 q 1 2 q q 1 2 q 2 q 1 2 q h 2 q 1 = h 2 =1 2 q 1 i=0 q i =1 2 q 1 qh 1 1 =2 q h 1 1=n q 1 n 1 h=log q 1 2 D.: qual è l altezza di un B tree frondoso? p i =0 q i = q p 1 1 q 1 ASD B tree 19

20 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 tree 20

21 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 <chiave. rif. a mem. secondaria> */ ASD B tree 21

22 Rappresentazione con riferimenti ASD B tree 22

23 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 all inizio di un file (file frammentato, solo accessi random) indirizzi assoluti (cilindro+settore+faccia, file non portatili) ASD B tree 23

24 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 tree 24

25 Ricerca chiave di valore / ASD B tree 25

26 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 tree 26

27 Inserimento in foglia non piena Un albero B prima (a) e dopo (b) l inserimento della chiave 7 in una foglia avente celle disponibili ASD B tree 27

28 Inserimento in foglia piena Inserimento della chiave 6 in una foglia piena ASD B tree 28

29 gestione degli overflow gestione dell overflow 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 (nell esempio, m=5) se il genitore va in overflow si usa la stessa tecnica ASD B tree 29

30 gestione degli overflow/2 gli overflow si possono propagare verso l alto 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 nell operazione in questo caso l albero aumenta la propria altezza Animazione a ASD B tree 30

31 Inserimento Algorithm BTreeInsert(k) { <trova foglia in cui inserire k> /* Sia essa node */ <trova pos. adeguata per k nell array keys> if (<nodo non pieno) { <inserisci k ed incrementa keytally> return; } else { <suddividi node in node1 e node2>; <distribuisci chiavi e rif. equamente tra node1 e node2> <aggiorna node1.keytally e node2.keytally> <k = ultima chiave in node1> } /* Continua prossima slide */ ASD B tree 31

32 Inserimento /* Continua da slide precedente */ if (<node era la radice>) { <crea nuova radice con figli node1 e node2> <inserisci k e rif. a node1 e node2 nella radice> root.keytally=1; return; } else <genitore di node2 = genitore di node> } ASD B tree 32

33 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 ) costo inserimento ASD B tree 33

34 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 / 2 1 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 tree 34

35 Azioni eseguite dopo l eliminazione del numero 6 ASD B tree 35

36 gestione degli underflow un nodo in underflow ha m / 2 2 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 tree 36

37 fusione di nodi due nodi fratelli possono essere fusi se uno di essi è in underflow e l altro ha il numero di chiavi minimo m / 2 1 la fusione consiste nell inserire 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 l eliminazione di una chiave dal genitore, che a sua volta, può andare in underflow, divenendo oggetto di attenzione da parte del gestore dell underflow ASD B tree 37

38 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 l albero diminuisce l altezza Animazione a html ASD B tree 38

39 algoritmo di eliminazione Algorithm BTreeDelete(k) { node = BTreeSearch(k) if(node!= null) { if(<node non è foglia>) { <trova foglia con successore s di k> <copia s su k in node> <node = foglia contenente s> <elimina s da node> } else <elimina k da node> ASD B tree 39

40 algoritmo di eliminazione/2 while(true) { if(<node non in underflow>) return; else if (<c è un fratello di node con abbastanza chiavi>) { } <redistribuisci chiavi fra node e fratello> return; else if (<genitore(node) è radice>) { if (<radice ha una sola chiave>) <fondi node, fratello e genitore, formando nuova radice> ASD B tree 40

41 algoritmo di eliminazione/3 else <fondi node e suo fratello> return; } /* End else if */ else <fondi node e suo fratello> <node = genitore(node)> } } /* End while */ } /* End if */ } /* End algoritmo */ ASD B tree 41

42 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 tree 42

43 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 ASD B tree 43