Valerio Battaglia

è quello che indica anche la soluzione, ma per te 00011001 è -0xE7, per me è semplicemente +25 quindi 0x19. come fai a distinguere i due numeri se hanno la stessa rappresentazione con 8 cifre? per me E7 non si può rappresentare con 8 cifre in complemento a 2, nè positivo nè negativo, ma almeno con 9 (il motivo l'ho già spiegato prima, sempre per come ho capito io).

Nel testo del compito non si parla di numeri ma di numerali in CP2 quindi i valori esadecimali sono da intendersi come rappresentazione compatta di numerali ad 8 bit in CP2. non c'e' nessum problema di range o simili. diverso era se parlavo di numeri...

non so se la cosa è già stata afforntata, perchè si riferisce alla codifica in CP2, comunque:
sul compito del 12-07-2006 il primo esercizio secondo è sbagliato come impostazione, perchè chiede di rappresentare in CP2 con 8 cifre numeri come 0xE7, 0xDE, 0xA2, 0xE1, cosa impossibile: con 8 bit il range ...

Buongiorno...
vorrei sapere un paio di cosette...
La prima: fino a dove si deve studiare per l'esame del 14???

La seconda...
In questo codice, quello dell'esame, come in tanti altri...

proc: addi $sp, $sp, -20
sw $s0, 16($sp)
sw $s1, 12($sp)
sw $s2, 8($sp)
sw $s3, 4($sp)
sw $ra, 0($sp)

addi $s0, $a0, 0
addi $s1, $a1, 0
addi $s2, $a2, 0
addi $s3, $zero, 0 # result=0;

if1: beq $s0, $zero, ret # if (n==0) goto ret
else1: addi $a0, $s0, -1
addi $a1, $s1, 0
addi $a2, $s2, 0
jal proc

L'istruzione jump and link salva PC+ 4 in $ra e poi va a proc, chiamando ricorsivamente.
La cosa che non riesco a capire è questa. In questo esercizio, la prima volta che si incontra jal, cosa succede?
Quand'è che si eseguono le istruzioni dopo Jal? Se non esco da if1, poi vado sempre indietro ricorsivamente.
Stesso dicasi per i vari esercizi di procedure ricorsive sul libro. Non so cosa succeda quando si incontra jal....

Poi un'altra domanda...
C'è da qualche parte il primo esonero dello scorso anno???

Trovati...
Ma sta maledetta jal rimane li e mi sbeffeggia...

scusate, come si codifica l'istruzione C

if(n==0) {} ?

Grazie

ipotizzando che dal main chiami una funzione, io la codificherei cosi:

[code type="markup"]
main:
add $a0, $zero, $s0 # se in $s0 avevo il valore n, lo metto in $a0
jal func


func:
bne $a0, 0, L1 # se $a0!=0 goto L1 (mai chiamata)
jr $ra # torno perchè l'istruzione era vuota

L1:
[/code]

magari non è elegante ma fa il suo dovere, altrimenti potevi implementarla cosi

[code type="markup"]
main:
add $a0, $zero, $s0 # se in $s0 avevo il valore n, lo metto in $a0
jal func


func:
beq $a0, 0, L1 # se $a0!=0 goto L1 (mai chiamata)
jr $ra # torno perchè l'istruzione era vuota

L1:
jr $ra
[/code]

scusate, come si codifica l'istruzione C

if(n==0) {} ?

Grazie

Cioè, nel senso, se n==0 non fare nulla?!?
(premettendo che di Assembler mi ricordo solo qualcosa, e me lo sto rivedendo in questi giorni...)
Assumiamo che n sia $x...

beq $x, $zero, IF
ELSE: Codice else...
IF: Codice if (o niente, in questo caso)


Penso si possa realizzare in questo modo, chiedo conferma a chiunque ne sappia di più (prof. compreso, ovviamente :wink: )...
Almeno vedo anche se ricordo bene :P

Poi un'altra domanda...
C'è da qualche parte il primo esonero dello scorso anno???

rispondo anche alle altre.

Dunque:
1) credo bisognerà fare fino alla ALU (dispense sul sito)

2) Con jal praticamente chiami un'altra funzionee una volta finita questa, usando $ra, torni al punto in cui l'avevi chiamata. Molto utile perchè con le altre istruzioni di salto si slata e basta perdendo il riferimento al quale ero arrivato.

quindi se hai il main con 7 istruzioni (con la 4 il jal verso un'altra pcodura) farà cosi:

main 1
main 2
main 3
main 4 -> jal

procedura 1
procedura 2
...
procedura n -> jr $ra che mi fa tornare al punto iniziale

main 5
main 6
main 7

3) li trovi sul sito del professore dell'anno scorso, ci arrivi cercando nella pagina personale del professore

nel seguente codice preso dal sito del prof non riesco a capire quando vengono eseguite le istruzioni 1, 2 e 3...

Massimo_r:
addi $sp,$sp,-16
sw $ra,0($sp)
sw $s0,4($sp)
sw $s1,8($sp)
sw $s2,12($sp)

add $s0,$a0,$zero # $s0=&A
add $s1,$a1,$zero # $s1=n

lw $s2,0($s0) # massimo=A[0]
ori $t1,$zero,1 # $t1=1

beq $a1,$t1,Exit_r # if (n!=1) goto Exit_r
addi $a0,$s0,4 # $a0=&(A[1])
addi $a1,$s1,-1 # $a1=n-1
jal Massimo_r # max_i=max resto array
1 slt $t0,$s2,$v0 # $t0= massimo<max_i ? 1 : 0
2 beqz $t0,Exit_r # if (massimo>=max_1) goto Exit_r
3 add $s2,$v0,$zero # massimo=max_i
Exit_r: add $v0,$s2,$zero # restituisci $v0=massimo

lw $s2,12($sp)
lw $s1,8($sp)
lw $s0,4($sp)
lw $ra,0($sp)
addi $sp,$sp,16
jr $ra

Le consiglio di eseguire il codice con un piccolo esempio (un array con soli tre elementi). E' l'unico modo per chiarirsi le idee.
Osservo, tuttavia, che la sua domanda è indice di poca dimestichezza con le funzioni ricorsive in generale. La invito pertanto a svolgere tutti gli esercizi dati sulla ricorsione (compreso quello sulla torre di Hanoi che vedremo domani)

nel seguente codice preso dal sito del prof non riesco a capire quando vengono eseguite le istruzioni 1, 2 e 3...

Grazie professore, mi rendo conto che il problema deve essere proprio la.

Eseguiro' gli esempi su SPIM.

Per Nightmare...
Allora nell'esempio che ho scritto, mi dici la jal quali linee di codice esegue?

int procedura (int n,int *A, int m) {
int result;

if (n==0)
return 0;
else {
result=procedura(n-1,A,m)+1;
if (is_in(n,A,m))
return 2*result+1;
else
return result+2;
}
}

# $a0=n, $a1=A, $a2=m
proc: addi $sp, $sp, -20
sw $s0, 16($sp)
sw $s1, 12($sp)
sw $s2, 8($sp)
sw $s3, 4($sp)
sw $ra, 0($sp)

addi $s0, $a0, 0
addi $s1, $a1, 0
addi $s2, $a2, 0
addi $s3, $zero, 0 # result=0;

if1: beq $s0, $zero, ret # if (n==0) goto ret
else1: addi $a0, $s0, -1
addi $a1, $s1, 0
addi $a2, $s2, 0
jal proc # RILOCARE
addi $s3, $v0, 0 # result=procedura(n-1,A,m)+1

addi $a0, $s0, 0
addi $a1, $s1, 0
addi $a2, $s2, 0
jal is_in # RILOCARE
beq $v0, $zero, else2

if2: sll $s3, $s3, 1 # result=result*2
addi $s3, $s3, 1 # +1
j ret
else2: addi $s3, $s3, 2 # result=result+2

ret: addi $v0, $s3, 0 # $v0=result

lw $ra, 0($sp)
lw $s3, 4($sp)
lw $s2, 8($sp)
lw $s1, 4($sp)
lw $s0, 0($sp)
addi $sp, $sp, 20

jr $ra

# $a0=x, $a1=B, $a2=n

is_in: addi $t0, $zero, 0 # j=0
addi $t1, $zero, 0 # return=0

while: slt $t2, $t0, $a2 # $t2=j<n
beq $t2, $zero, end # if (j>=n) goto end
sll $t3, $t0, 2 # $t3=j*4
add $t3, $a1, $t3 # $t3=&(B[j])
lw $t4, 0($t3) # $t4=B[j]
bne $t4, $a0, inc # if (x~=B[j]) goto inc
addi $t1, $zero, 1 # return=1
j end # RILOCARE
inc: addi $t0, $t0, 1 # j++
j while # RILOCARE
end : addi $v0, $t1, 0 # $v0=return

jr $ra

Posto tutta la funzione...
- Salva 5 registri ($s0, 1, 2, 3 e $ra) e si copia i parametri che serviranno con gli addi più il valore di result inizializzato a 0.
- Scrive l'istruzione col primo if.
- Passando al primo else, copia nei parametri $a della procedura i valori per la chiamata successiva, praticamente decrementando solo un parametro ($s0).
- Esegue jal... (e qui che succede praticamente???) che è linkato a proc...

Per il primo esonero ALU compresa o no?!
grazie per eventuali risposte

int procedura (int n,int *A, int m) {
int result;

if (n==0)
return 0;
else {
result=procedura(n-1,A,m)+1;
if (is_in(n,A,m))
return 2*result+1;
else
return result+2;
}
}

# $a0=n, $a1=A, $a2=m
proc: addi $sp, $sp, -20
sw $s0, 16($sp)
sw $s1, 12($sp)
sw $s2, 8($sp)
sw $s3, 4($sp)
sw $ra, 0($sp)

addi $s0, $a0, 0
addi $s1, $a1, 0
addi $s2, $a2, 0
addi $s3, $zero, 0 # result=0;

if1: beq $s0, $zero, ret # if (n==0) goto ret
else1: addi $a0, $s0, -1
addi $a1, $s1, 0
addi $a2, $s2, 0
jal proc # RILOCARE
addi $s3, $v0, 0 # result=procedura(n-1,A,m)+1

addi $a0, $s0, 0
addi $a1, $s1, 0
addi $a2, $s2, 0
jal is_in # RILOCARE
beq $v0, $zero, else2

if2: sll $s3, $s3, 1 # result=result*2
addi $s3, $s3, 1 # +1
j ret
else2: addi $s3, $s3, 2 # result=result+2

ret: addi $v0, $s3, 0 # $v0=result

lw $ra, 0($sp)
lw $s3, 4($sp)
lw $s2, 8($sp)
lw $s1, 4($sp)
lw $s0, 0($sp)
addi $sp, $sp, 20

jr $ra

# $a0=x, $a1=B, $a2=n

is_in: addi $t0, $zero, 0 # j=0
addi $t1, $zero, 0 # return=0

while: slt $t2, $t0, $a2 # $t2=j<n
beq $t2, $zero, end # if (j>=n) goto end
sll $t3, $t0, 2 # $t3=j*4
add $t3, $a1, $t3 # $t3=&(B[j])
lw $t4, 0($t3) # $t4=B[j]
bne $t4, $a0, inc # if (x~=B[j]) goto inc
addi $t1, $zero, 1 # return=1
j end # RILOCARE
inc: addi $t0, $t0, 1 # j++
j while # RILOCARE
end : addi $v0, $t1, 0 # $v0=return

jr $ra

Posto tutta la funzione...
- Salva 5 registri ($s0, 1, 2, 3 e $ra) e si copia i parametri che serviranno con gli addi più il valore di result inizializzato a 0.
- Scrive l'istruzione col primo if.
- Passando al primo else, copia nei parametri $a della procedura i valori per la chiamata successiva, praticamente decrementando solo un parametro ($s0).
- Esegue jal... (e qui che succede praticamente???) che è linkato a proc...

Premetto che sto di fretta, poi me lo riguardo (anche se molte cose non le ho capite): a prima vista posso dirti che sono sbagliate le lw di $s0, s1 etc perchè in più registri ricarichi lo stesso valore (mi sembra).

Per il primo esonero ALU compresa o no?!
grazie per eventuali risposte

lo sapremo domani

scusate tanto, io il codice in assembler della torre di hanoi lo farei molto volentieri.. solo che in rete non riesco a trovare un codice c++ che sia comprensibile da cui partire.. qualcuno lo ha?? ringrazio anticipatamente

forse questo potrebbe aiutarti

http://it.wikipedia.org/wiki/Torre_di_Hanoi

Con riferimento all'esercizio 4 della prima prova in itinere dell'altr'anno, qualcuno mi sa dire se la risposta al primo quesito è

0000000000001100

e alla secoda è

nessuno?