Laboratorio di architettura degli elaboratori Progetto finale AA 2005/2006 Esercizio 1 - Heapsort Si consideri la seguente struttura dati, chiamata heap. Essa è un albero binario semi-completo (ossia un albero completo in cui l ultimo livello può avere alcuni nodi mancanti, da destra verso sinistra) che soddisfa la seguente proprietà: il valore (detto chiave) contenuto in ciascun nodo è maggiore o uguale di tutte le chiavi dei suoi discendenti (si veda l esempio in figura). 16 14 10 8 7 9 3 2 4 1 Figura 1: Una heap. Una heap può essere agevolmente memorizzata in un array, come di seguito descritto. La prima posizione (offset 0) dell array contiene la chiave del nodo radice (16 in riferimento all esempio sopra riportato). Inoltre, data una posizione i nell array che identifica un generico nodo della heap, le posizioni del suo figlio sinistro e destro sono rispettivamente 2(i + 1) 1 e 2(i + 1). Ad esempio, la heap della figura sopra può essere rappresentata come un array di 10 interi: 16,14,10,8,7,9,3,2,4,1. Definiamo ora la seguente operazione Heapify, che riceve in input un array A, la sua dimensione n e una posizione i compresa fra 0 e n 1: Heapify(A,n,i) left := 2*(i+1)-1 right := 2*(i+1) if left<n and A[left]>A[i] then largest := left 1
else largest := i if right<n and A[right]>A[largest] then largest := right if largest<>i then scambia il contenuto di A[i] e A[largest] chiama ricorsivamente Heapify(A,n,largest) Si implementi la procedura Heapify in linguaggio Assembly MIPS: per l input usare i tre registri a0, a1, a2, contenenti rispettivamente l indirizzo base dell array A, la dimensione n, e la posizione i; ipotizzare che le chiavi contenute nella heap (ossia i valori dell array A) siano interi a 32 bit; ricordarsi di salvare opportunamente i registri nello stack prima di eseguire una chiamata ricorsiva. Infine, si implementi in Linguaggio Assembly MIPS il seguente algoritmo di ordinamento, basato sulla procedura Heapify: HeapSort(A,n) for i := n/2-1 downto 0 richiama Heapify(A,n,i) end for for i := n-1 downto 0 scambia il contenuto di A[0] e A[i] richiama Heapify(A,i,0) end for Nota: l espressione n/2-1 alla prima riga della procedura dev essere valutata su interi (ossia n/2 denota la divisione di n per 2 arritondata per difetto). Verificare la correttezza dell algoritmo di ordinamento con alcuni esempi di array. Esercizio 2 - String matching Data due stringhe T[1...n] (testo) e P[1...m] (pattern), si vogliono cercare tutte le occorrenze di P all interno di T. In particolare si dirà che che il pattern P occorre nel testo T con shift s (equivalentemente: a partire dalla posizione s+1) se 0 s n m e T[s+1...s+m] = P[1...m] (ovvero se T[s+j] = P[j] per 1 j m). L algoritmo più semplice per la ricerca delle occorrenze è il seguente: 2
NAIVE-MATCHER(T,P) n = length(t) m = length(p) s = 0 while s <= n - m j = m while j > 0 and P[j] = T[s+j] j = j - 1 if j == 0 print( Pattern occurs at shift, s) endif s = s + 1 In questo algoritmo, ad ogni iterazione del ciclo while più esterno il pattern P viene traslato di 1 e si controlla se è stato trovato un match con T allo shift s. Si noti che il controllo viene fatto da destra verso sinistra. Boyer e Moore hanno proposto una variante di tale algoritmo che, con l aggiunta di due semplici euristiche, risolve il problema dello string matching in maniera particolarmente efficiente. In questo esercizio verrà presa in considerazione solo la prima delle due euristiche, conosciuta come bad-character heuristic. Per spiegarne il funzionamento è utile considerare il seguente esempio:... mi ritrovai per una selva oscura... T ---------s--------->allietava P in questo caso è sato trovato un match con shift s per le lettere a e v, ma non per la lettera l del testo, che non coincide con la e trovata nel pattern. L euristica del bad-character prevede in questo di caso di aumentare lo shift finché la lettera del testo che ha causato il mismatch (la l in questo caso) non trovi un match nella stringa di pattern. In altre parole, mentre l algoritmo naive tenterebbe un nuovo match con lo shift s + 1:... mi ritrovai per una selva oscura... T ---------s+1-------->allietava P l euristica proposta da Boyer e Moore cerca un match con lo shift s+4, necessario per trovare un match tra due lettere l :... mi ritrovai per una selva oscura... T ---------s+4----------->allietava P Naturalmente questa non è una condizione sufficiente per garantire il match completo tra pattern e testo, ma è sicuramente una condizione necessaria. L algoritmo di Boyer e Moore semplificato si può quindi scrivere in pseudo-codice nel seguente modo: 3
SIMPLIFIED-BOYER-MOORE-MATCHER(T,P) n = length(t) m = length(p) l[] = LAST-OCCURRENCE(P,m) s = 0 while s <= n - m j = m while j > 0 and P[j] = T[s+j] j = j - 1 if j == 0 print( Pattern occurs at shift, s) s = s + 1 else s = s + MAX(1, j - l[t[s+j]]) endif LAST-OCCURRENCE(P,m) for each character a l[a] = 0 for j = 1 to m l[p[j]] = j return l In questo caso l array precalcolato l viene utilizzato per trovare efficacemente lo shift da utilizzare quando viene applicata la bad-character heuristic. Si realizzi un programma in assembly MIPS che implementi l algoritmo semplificato di Boyer-Moore. Il programma deve ricevere in input due stringhe (testo e pattern da cercare) e deve dare in output tutti gli shift per i quali è stato trovato un match. Esercizio 3 - Permutazioni Si consideri il problema di stampare tutte le permutazioni di una stringa fornita in input. Ad esempio, le permutazioni della parola TUO sono: TUO, TOU, UTO, UOT, OTU, OUT. Nota: alcune permutazioni possono essere stampate più volte, come accade, ad esempio, quando scambiamo il terzo e il quarto (o il secondo e il quinto) carattere nella parola COLLO. La stampa delle permutazioni di una stringa può essere effettuata da un opportuna procedura ricorsiva che riceve in input una stringa A da permutare, assieme a un prefisso B non variable da stampare prima di ciascuna permutazione. Tale procedura può essere schematizzata come segue: Permutazioni(A,B) 4
n := lunghezza di A if n<2 then stampa B concatenato ad A else for i := 0 to n-1 C := A[0..i-1] concatenato con A[i+1..n-1] D := B concatenato con A[i] chiama ricorsivamente Permutazioni(C,D) end for Ad esempio, per stampare tutte le permutazioni della parola TUO sarà sufficiente richiamare Permutazioni( TUO, ) (il secondo argomento è la stringa vuota). In tal caso, la procedura stamperà prima tutte le permutazioni di UO, ciascuna preceduta dalla stringa T, poi tutte le permutazioni di TO, ciascuna preceduta dalla stringa U, e infine tutte le permutazioni di TU, ciascuna preceduta dalla stringa O. Si implementi la procedura Permutazioniin linguaggio Assembly MIPS: per l input usare due registri a0 e a1 contenenti rispettivamente l indirizzo base della stringa A e l indirizzo base della stringa B; ipotizzare che le stringhe siano terminate dal simbolo terminatore (codice ASCII 0); ricordarsi di salvare opportunamente i registri nello stack prima di eseguire una chiamata ricorsiva. Esercizio 4 - Calcolatrice RPN La notazione polacca inversa (reverse polish notation, RPN) è una notazione per la scrittura di espressioni aritmetiche in cui gli operatori binari, anziché utilizzare la tradizionale notazione infissa, usano quella postfissa; ad esempio, l espressione 5 + 2 in RPN verrebbe scritta 5 2 +. La RPN è particolarmente utile perché non necessita dell utilizzo di parentesi. Si considerino ad esempio le due espressioni 2 5 + 1 e 2 (5 + 1). Nel secondo caso le parentesi sono necessarie per indicare che l addizione va eseguita prima della moltiplicazione. In RPN questo non è necessario perché le due espressioni vengono scritte in maniera diversa: mentre la prima corrisponde a 2 5 1 +, la seconda viene scritta come 2 5 1 +. Un altro vantaggio della RPN è quello di essere facilmente implementabile utilizzando uno stack. Per calcolare il valore di un espressione, è sufficiente scandirla da sinistra verso destra: quando viene letto un numero lo si salva nello stack, quando viene letta un operazione binaria si prelavano due numeri dallo stack, si esegue l operazione tra tali numeri e si salva nuovamente il risultato nello stack. Ad esempio, volendo valutare il valore dell espressione 2 5 1 +, si procede nel seguente modo: 5
metto il valore 2 nello stack stack: 2 metto il valore 5 nello stack stack: 2 5 metto il valore 1 nello stack stack: 2 5 1 estraggo i primi due valori memorizzati in cima allo stack (5 e 1), faccio la somma e salvo il risultato nello stack: stack: 2 6 estraggo i primi due valori memorizzati in cima allo stack (2 e 6), faccio la moltiplicazione e salvo il risultato: stack: 12 A questo punto l intera stringa è stata elaborata e nello stack è memorizzato il risultato finale. Si scriva un programma in assembly MIPS che legga in input una stringa rappresentante un espressione ben formata in RPN (si considerino solo gli operatori + - /) e scriva in output il risultato ottenuto dalla valutazione dell espressione. 6