Procedure: esempi. Esempi: ricorsione fattoriale Fibonacci ordinamenti

Transcript

1 Procedure: esempi Esempi: ricorsione fattoriale Fibonacci ordinamenti 1 Fattoriale ricorsivo PH p. 83 e A27 main(int argc, char *argv[]) { int n; printf( Inserire un numero intero\n"); scanf("%d", &n); printf( Fattoriale: %d\n", fact(n)); int fact(int m) { if (m < 1) return(1); else return( m*fact(m-1) ); 2 1

2 Fattoriale ricorsivo: main # programma per il calcolo ricorsivo di n!.data prompt:.asciiz Inserire un numero intero:" output:.ascii Fattoriale: main:.text li $v0, 4 # $v0 <- codice print_string la $a0, prompt # $a0 <- indir. della stringa syscall # stampa della stringa li $v0, 5 # $v0 <- codice della read_int syscall # legge l intero n in $v0 3 Fattoriale ricorsivo (main: cont.) move $a0, $v0 # $a0 <- n jal fact # chiama fact(n) move $s0, $v0 # $s0 <- n! li $v0, 4 # $v0 <- codice print_string la $a0, output # $a0 <- indirizzo della stringa syscall # stampa della stringa di output move $a0, $s0 # $a0 <- n! li $v0, 1 # $v0 <- codice della print_int syscall # stampa n! li $v0, 10 # $v0 <- codice della exit syscall # esce dal programma 4 2

3 Fattoriale ricorsivo (fact... ) fact: addi $sp, $sp,-8 # alloca stack sw $ra, 4($sp) # salvo return address sw $a0, 0($sp) # salvo l argomento m slti $t0, $a0, 1 # se m >= 1 salta a core beq $t0, $zero, core li $v0, 1 # $v0 <- 1 j end core: addi $a0, $a0,-1 # decremento m-> (m 1) jal fact # chiama fact(m-1)-> $v0 lw $a0, 0($sp) # ripristino m in $a0 mul $v0, $a0, $v0 # ritorno m * fact (m-1) int fact(int m) { if (m < 1) return(1); else return(m*fact(m-1)); 5 Fattoriale ricorsivo (fact cont.) end: lw $ra, 4($sp) # ripristino return address addi $sp, $sp, 8 # dealloca stack jr $ra # ritorno al chiamante 6 3

4 Fibonacci ricorsivo Fibonacci: 0, 1, 1, 2, 3, 5, 8, 13,..... F(n) = F(n-1) + F(n-2) 7 Fibonacci ricorsivo (in C) main(int argc, char *argv[]) { int n; printf( Inserire un intero\n"); scanf("%d", &n); printf( Numero di Fibonacci %d\", fib(n)); int fib(int m) { if (m <= 1) return(m); else return( fib(m-1) + fib(m-2) ); 8 4

5 Fibonacci ricorsivo: main.data prompt:.asciiz Inserire un numero intero: \n" output:.asciiz Numero di Fibonacci: ".text.globl main main: li $v0, 4 la $a0, prompt syscall # stampa la stringa li $v0, 5 syscall # legge l intero 9 Fibonacci ricorsivo: main (cont.) # calcola fibonacci(m) move $a0, $v0 jal fib # stampa il risultato move $t1, $v0 # $t1 <= valore restituito da fib1 li $v0, 4 # print_string la $a0, output syscall move $a0, $t1 li $v0, 1 syscall # print_int li $v0, 10 syscall # exit 10 5

6 Fibonacci ricorsivo: fib fib: addi $sp, $sp,-12 sw $ra, 8($sp) sw $a0, 4($sp) # salva il parametro in input sw $s1, 0($sp) # $s1 per il risultato della # chiamata precedente di fib li $t0, 1 bgt $a0, $t0, core # se m > 1, continua, # altrimenti restituisci m move $v0,$a0 # return (m); j return 11 Fibonacci ricorsivo: fib (cont) core: addi $a0, $a0,-1 # m -> m-1 jal fib # chiama fib(m-1) move $s1, $v0 # salva fib(m-1) nello stack addi $a0, $a0,-1 # $a0 diventa m-2 jal fib # esegue fib(m-2) add $v0, $v0, $s1 # somma fib(m-1) e fib(m-2) 12 6

7 Fibonacci ricorsivo (cont.) return: lw $ra, 8($sp) lw $a0, 4($sp) lw $s1, 0($sp) addi $sp, $sp, 12 jr $ra 13 Esempio Procedura per l'ordinamento di un vettore PH

8 Procedura Scambia // da Patt. Hen. p. 122 static void scambia (int v[], int k) { int temp; temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; 15 Procedura Ordina ( Insertion Sort ) // da Patterson, Hennessy, p. 124 static void ordina(int v[], int n) { int i,j; for (i=0; i<n; i=i+1) for (j=i-1; j>=0 && v[j] > v[j+1]; j=j-1) scambia(v,j); i n j j

9 Procedura Ordina ( Insertion Sort ) for (i=0; i<n; i=i+1) for (j=i-1; j>=0 && v[j] > v[j+1]; j=j-1) scambia(v,j); i n j j+1 i n j j+1 i n Traduzione di Scambia # void scambia (int v[], int k) scambia: sll $t1, $a1, 2 # arg1 k add $t1, $a0, $t1 # t1= &v[k] lw $t0, 0($t1) # t0 = v[k] lw $t2, 4($t1) # t2 = v[k+1] sw $t2, 0($t1) # v[k] = t2 sw $t0, 4($t1) # v[k+1] = t0 jr $ra $t1 = &v[k] n

10 Ordina - prologo ordina: addi $sp, $sp, -20 # stack frame sw $ra, 16($sp) # salva i registri sw $s3, 12($sp) sw $s2, 8($sp) sw $s1, 4($sp) # j in $s1 i in $s0 j in $s1 v in $s2 sw $s0, 0($sp) # i in $s0 n in $s3 move $s2, $a0 # v in $s2 move $s3, $a1 # n in $s3 19 Ordina - ciclo esterno move $s0, $zero # i = 0 for1tst: slt $t0, $s0, $s3 # $t0 = 0 se i >= n beq $t0, $zero, fine # for (j=i-1; j>=0 && v[j]>v[j+1]; j=j-1) add $s1, $s0, -1 # j = i-1 i in $s0 j in $s1 v in $s2 n in $s

11 Ordina - ciclo interno for2tst: i in $s0 j in $s1 v in $s2 n in $s3 # for (j=i-1; j>=0 && v[j]>v[j+1]; j=j-1) slti $t0, $s1, 0 # $t0 = 1 se j < 0 bne $t0, $zero, cont2 # -> se j < 0 sll $t1, $s1, 2 # $t1 = j * 4 add $t2, $s2, $t1 lw $t3, 0($t2) lw $t4, 4($t2) slt $t0, $t4, $t3 # $t2 = &v[j] # $t3 = v[j] # $t4 = v[j+1] # $t0=1 se v[j+1]<v[j] beq $t0, $zero, cont2 # se v[j+1] >= v[j] # go to cont2 21 Ordina - ciclo interno i in $s0 j in $s1 v in $s2 n in $s3 move $a0, $s2 move $a1, $s1 jal scambia # s2 = &v # s1 = j # scambia(v,j); addi $s1, $s1, -1 # j = j - 1 j for2tst cont2: addi $s0, $s0, 1 # i = i + 1 j for1tst for (i=0; i<n; i=i+1) for (j=i-1; j>=0 && v[j] > v[j+1]; j=j-1) scambia(v,j); 22 11

12 Ordina - epilogo fine: lw $s0, 0($sp) lw $s1, 4($sp) lw $s2, 8($sp) lw $s3, 12($sp) lw $ra, 16($sp) addi $sp, $sp, 20 jr $ra i in $s0 j in $s1 v in $s2 n in $s