.dsy:it. (http://www.dsy.it/forum/)
- Architettura degli elaboratori e delle reti (http://www.dsy.it/forum/forumdisplay.php?forumid=210)
-- Preparazione al Laboratorio F49 (http://www.dsy.it/forum/showthread.php?threadid=42442)

1) si n verrà salvato in $a0 e h in $a1 però lo stack lo devi preparare da 16 e non 12 perchè devi lasciare un altro spazio proprio per salvare i risultati parziali che come nel punto 3 dici di non saper dove mettere

2) io ho incrementato $a1 per il test. i registra $s non li ho mai usati per nessun esercizio

3) come detto prima, per salvare i risultati parziali devi mettere il contenuto di $v0 nello stack così: sw $v0, 0($sp) in questo caso è zero perchè l'ultimo spazio libero per esempio..poi dipende da dove salvi i vari $a0,$ra ecc..

poi per ricaricare quel valore per fare il conto usi lw $t0, 0($sp)

vai a ricaricarlo in una variabile temporanea $t0 recuperandola dallo spazio 0 dello stack

Ma devo caricare $v0 nello stack al'inizio della procedura quando carico gli altri registri, oppure solo quando ho il risultato parziale? Madò che confusione

Una cosa..se io per eseguire il test incremento direttamente $a1 ($a1 = h), quando poi vado a chiamare P(n-1, h) , h non avrà più il suo valore originario ma sarà h = h+1 no? quindi in teoria è sbagliato..

Ho fatto due modifiche ma non sono ancora sicuro!

P(n, h) = P(n-1, h) + P(n-h-1, h) se n > h+1
P(n, h) = n+1 altrimenti


P: addi $sp, $sp, -16 #spazio per 3 variabili
sw $ra, 0($sp) #salvo il registro di ritorno
sw $a0, 4($sp) #$a0 = n
sw $a1, 8($sp) #$a1 = h
sw $v0, 12($sp) #salvo reg $v0 <------

addi $a1, $a1, 1 #$s0 = h + 1 <--------
bgt $a0, $a1, calc_P #se n > h+1 salta a calc_P
addi $a0, $a0, 1 # n = n + 1
move $v0, $a0 #metto n+1 in $v0 <------------
jr $ra

calc_P: subi $a0, $a0, 1 #n = n-1
jal P #chiamo P(n-1, h)
lw $t0, 12($sp) #risultato parziale in $t0 <-----------------
sub $a0, $a0, $a1 #n = n - h
subi $a0, $a0, 1 #n = n -1
jal P #chiamo P(n-h-1, h)
add $v0, $v0, $t0 #sommo i risultati parziali <--------------
lw $a0, 4($sp) #ripristino reg $a0
lw $ra, 0($sp) #ripristino return address
lw $a1, 8($sp) #ripristino reg $a1
lw $v0, 12($sp) #ripristino reg $v0 <-----------------
addi $sp, $sp, 16 #ripristino stack
jr $ra

no $v0 è un registro non devi preparare lo stack salvandolo xkè all inizio è vuoto..

fai così
addi $sp, $sp, -16 #spazio per i 2 val passati, 1 per i ris temp, e 1 per il reg di ritorno
sw $ra, 0($sp) #salvo il registro di ritorno
sw $a0, 4($sp) #$a0 = n
sw $a1, 8($sp) #$a1 = h

lasi la posizione 12 dello stack pointer per salvare il valore contenuto in $v0 successivamente dopo che avrai fatto i calcoli e $v0 conterrà qualcosa

ah ok ho capito grazie, sempre gentilissimo! per quanto rigurada $t0 invece posso usarlo tranquillamente senza doverlo mettere nello stack perchè è un registro temporaneo giusto?

si esatto $t0 usalo come vuoi, ma ricorda che dura solo fino alla prima jal poi perde il valore...quindi ti conviene caricare un valore in $t0 per poi usarlo subito per un calcolo..

quando o se hai tempo puoi postare la tua soluzione? o comunque come lo risolveresti?

io l'ho risolto così, non è prefetto perchè se no avrei preso 30 ma comunque almeno la base c'è :

P: addi $a1,$a1,1 #h+1
blt $a0,$a1,fine #salto se n<h a fine

addi $sp,$sp,-16
sw $ra,12($sp)
sw $a0,8($sp)
sw $a1,4($sp)

addi $a0,$a0,-1 #n-1
jal P
sw $v0,0($sp) #salvo il risultato nello stack
lw $a0,8($sp) #ricarico n originale
lw $a1,4($sp) #ricarico h
addi $a1,$a1,-1 #h-1
sub $a0,$a0,$a1 #n-h
lw $a1,4($sp) #ricarico h originale
jal P
lw $t0,4($sp) #carico il ris della prima parte di procedura
add $v0,$v0,$t0 #effettuo la somma conclusiva
lw $ra,12($sp)
addi $sp,$sp,16
jr $ra

fine: addi $a0,$a0,1 #n+1
jr $ra

Sperando sia utile a qualcuno, posto il testo dell'esame di oggi 27/02:

M(n) = 3*M(n-1) - 2*M(n-2) se n > 3
M(n) = 2^(n+4) - 20 altrimenti