Valerio Battaglia

si è giusto e puoi vederlo da te, infatti il risulatto che hai scritto tu è 48 (decimale) che corrisponde proprio all'indirizzo dell'istruzione end (12esima istruzione)

mmm voglio baciarti. Quindi son giuste anche i jump? Perchè sulle slide dice di:

1) prendere l'indirizzo dell'etichetta
2) aggiungere a destra due zeri -> indirizzo(00)
3) aggiungere a sinistra i 4 bit meno significativi del PC -> (0000)indirizzo(00)

però non mi torna così

-> 0000 0000 0000 0000 0000 0000 0011 0100 per END

è un indirizzo assoluto. io farei così
conti a che numero di riga si trova END, togli 1 (perchè parti da zero), moltiplichi per 4 e sommi al PC INIZIALE (il punto di inizio del programma), togli le 2 cifre meno significative e le 4 più significative, e voilat.

oppure se ti piace di più
{ [ (numero di riga -1 ) * 4 ] + PC_iniziale } / 4

Se provi con PCSPIM l'esempio di prima vedi che torna con entrambi i metodi.

grazie mille! Ora mi sento più tranquillo

E viene anche almeno cosi sembra

Grazie!

-> 0000 0000 0000 0000 0000 0000 0011 0100 per END

è un indirizzo assoluto. io farei così
conti a che numero di riga si trova END, togli 1 (perchè parti da zero), moltiplichi per 4 e sommi al PC INIZIALE (il punto di inizio del programma), togli le 2 cifre meno significative e le 4 più significative, e voilat.

ci siamo!

Scusate ma le jump come le avete trovate,visto che:

-> 0000 0000 0000 0000 0000 0000 0011 0100 per END

non è 48 in decimale ma 52. Come contate il numero delle istruzioni? L'istruzione end non è la 12? Qundi dovrebbe essere 12*4=48 che in binario e con l'aggiunta dei due zeri diventa:

0000 0000 0000 0000 0000 0000 0011 0000

Mi fate capire............grazie!

Salve ragazzi a voi com'è parso il compito? Francamente non me lo aspettavo così, nel senso, non è che sia difficilissimo, ma il programma era veramente lungo...

anche io non me l'aspettavo così: ero preparato ad affrontare una parte teorica più ampia. comunque non c'era niente di strano, l'unica cosa che non mi è piaciuta è il fatto che gli esercizi 2 e 3 fossero vincolati in modo così stretto al primo: di fatto non c'era molta scelta sull'ordine di esecuzione. comunque, rispetto alla confusione, all'ambiguità, alla disorganizzazione di altri esami recenti, finalmente un esame normale, il che non è poco.

farlo durare una mezz'ora in piu' non avrebbe fatto male a nessuno...

si?!...quindi ero io poco preparato evidentemente...a me è sembrato mOOolto più difficile dell'esonero delle scorso hanno (scemo io che non ho fatto quello)..e oltre tutto..volenti o nolenti la parte assembler comprometteva 26 punti su 30...il che (visto che come è stato ripetuto + volte non è un corso di assembler) mi sembra eccessivo..
Nel senso..se uno (tipo me) spende + di 1 ora per fare il primo esercizio..e poi (come spesso accade anche ai migliore..quindi altri non me ) uno si accorge che ha traslaciato un particolare importante..e se deve rimette a fa tutto..insomma diventa proibitivo raccapezzarvici(si) ..e se uno ha sbagliato anche una stupidaggine lì..sbagli a catena anche gli altri 2 esercizi..questo quindi non permette di valutare la preparazione complessiva di tutti gli argomenti del primo esonero...cosa che invece è stata garantita lo scorso anno..secondo me è poco corretto..ma quest'è..oh beati a voi che nn avete avuto problemi..studierò meglio

"Scuse me, while I kiss the sky!"

AMEN FRATELLO!

rispetto allo scorso anno è stato molto più difficile o quanto meno con degli esercizi diversi, tutti puramente pratici.
Inoltre il fatto di vincolarlo strettamente all'assembler non permette di "salvare" una persona che lo sa poco o che per esempio non riesce nel primo esercizi.
Cmq se volessimo confrontare: l'assembler dell'anno scorso era una procedura standard , mentre oggi avevamo la ricorsione (doppia) che l'anno scoro la mise all'appello. L'anno scorso c'erano dei calcoli sulla rappresentazione in binario, una domanda di teoria e l'ultimo esercizio uguale a quello nostro di oggi solo più facile.
Io francamente mi sono trovato spiazzato....poi boh!

Mi unisco a voi adedip maken............parole sante!

la rappresentazione dello stack per esempio era strettamente vincolato al primo esercizio, e come lo avevi svolto senza considerare che nelle esercitazioni l'argomento è stato trattato poco....mah

Davvero senza parole...anzichè essere un esame su architettura dei calcolatori era un esame su assembler..poi assembler lo abbiamo visto solo per due settimane e mezzo - tre e si pretendeva già che in un ora potessimo fare quelle cose mostruose...io non lo so...non dico che erano impossibili..ma questo mi sembra un pretesto bello e buono per bloccare molti studenti..non ho parole veramente..e la cosa che più mi ha lasciato senza speranze sono stati gli esercizi 2 e 3 riferiti al primo..proprio per dirti che se non eri in grado di fare completamente il primo sicuramente non saresti passato...boh...che schifo..solo questo dico..che schifo

diciamo che l'esercizio sullo stack era relativo al codice che avevi scritto. quindi anche se il codice era errato, potevi far bene lo stack sul codice errato. la cosa antipatica è che per fare l'esercizio 2 dovevi aver finito il codice, quando si poteva benissimo dare un codice apparte, volendo anche diverso da compito a compito e simulare la rilocazione con quello. insomma per fare l'esercizio 2 e 3 dovevi aver FINITO il codice e con finito intendo che devi sbrigarti a fare il codice sennò non puoi fare i 2 esercizi successivi. E se lo sbrigarti a fare il codice ti comporta un errore nel codice.. non puoi correggerlo a compito finito perchè gli esercizi dopo non corrisponderebbero più al codice.. più tempo avrebbe giovato.

"Scuse me, while I kiss the sky!"

AMEN FRATELLO!

Ahaha..grande SRV

Davvero senza parole...anzichè essere un esame su architettura dei calcolatori era un esame su assembler..poi assembler lo abbiamo visto solo per due settimane e mezzo - tre e si pretendeva già che in un ora potessimo fare quelle cose mostruose...io non lo so...non dico che erano impossibili..ma questo mi sembra un pretesto bello e buono per bloccare molti studenti..non ho parole veramente..e la cosa che più mi ha lasciato senza speranze sono stati gli esercizi 2 e 3 riferiti al primo..proprio per dirti che se non eri in grado di fare completamente il primo sicuramente non saresti passato...boh...che schifo..solo questo dico..che schifo

quoto e aggiungo che tutto quello che dici è confermato dal fatto che il primo esercizio valeva 15 punti quindi nel bene o nel male se vuoi prendere un voto sufficiente devi farlo, mentre l'anno scorso oltre ad esserci degli esercizi che interessavano tutto il programma svolto, l'esercizio in assembler valeva 12 punti, quindi anche non farlo ti permetteva di raggiungere la sufficienza....

Davvero senza parole...anzichè essere un esame su architettura dei calcolatori era un esame su assembler..poi assembler lo abbiamo visto solo per due settimane e mezzo - tre e si pretendeva già che in un ora potessimo fare quelle cose mostruose...io non lo so...non dico che erano impossibili..ma questo mi sembra un pretesto bello e buono per bloccare molti studenti..non ho parole veramente..e la cosa che più mi ha lasciato senza speranze sono stati gli esercizi 2 e 3 riferiti al primo..proprio per dirti che se non eri in grado di fare completamente il primo sicuramente non saresti passato...boh...che schifo..solo questo dico..che schifo

Io avrei preferito avere 1 solo esercizio: l'esercizio in assembler appunto.

... da quello che sento, penso di aver fatto bene a passare la mano, per questa volta... :|

Salve,

cerco di rispondere ad alcuni delle vostre osservazioni:

Confronto con il compito dell'anno scorso

la media esercizio per esercizio nel compito dell'anno scorso (considerando una scala 1-10 per ciascuna domanda è stata) è stata:

domanda 1 (architettura a livelli 7 punti): 3.18/10
domanda 2 (operazioni binarie 3 punti): 8.2/10
domanda 3 (calcolo indirizzo beq e j 3 punti): 3.32/10
domanda 4 (contenuto campo address nel beq 3 punti): 2.88/10
domanda 5 (calcolo tempo di esecuzione codice): 5.04/10
domanda 6 (esercizio assembler): 6.82/10

Quindi, facile il 2, più che fattibile l'esercizio assembler (che ha salvato la media generale), pessima performance sulle domande di teoria (e dopo 6 anni che insegno corso diversi tra loro posso confermarvi che il livello medio di risposta alle domande teoriche da qunado esiste il nuovo ordinamento è sempre più scarso).

Allora se nel preparare il compito di oggi ho dato maggiore enfasi all'esercizio di programmazione era (secondo le statistiche dell'anno scorso calcolate sui 58 studenti che hanno consegnato) a vostro vantaggio o meno?

veniamo adesso all'esercizio di oggi.

Per fare il 2 ed il 3 bisognava aver risolto la funzione ricorsiva del primo e non l'intero esercizio.
domanda: Quanto era difficile questa temibile doppia ricorsione?

Per rispondere, vi invito a confrontare la mia soluzione all'esercizio di oggi sotto riportata con la soluzione della procedura ricorsiva di Fibonacci (assegnata per casa, risolta e commentata a lungo in aula, caricata sul sito con l'invito a studiarne le caratteristiche in quanto la doppia ricorsione deve essere ben gestita in assembler etc. etc., quindi dal mio punto di vista qualcosa che dovreste conoscere più che bene(altrimenti a che servono gli esercizi svolti in classe?))

soluzione parte ricorsiva del compito
fun_T:addi $sp,$sp, -12
sw $ra, 0($sp)
sw $s0, 4($sp)
sw $s1, 8($sp)

slti $t0, $a0, 3 # $t0=1 iff m<=2
beq $t0, $0, Else # if(m>2) goto Else
addi $v0, $0, 1 # return $v0=1
j End
Else:add $s0, $0, $a0 # $s0=m
srl $a0, $s0, 1 # $a0=m/2
jal fun_T
add $s1, $0 $v0 # $s1=T(m/2)
sll $s1, $s1, 1 # $s1=2*T(m/2)
add $s1, $s1, $v0 # $s1=3*T(m/2)
srl $a0, $s0, 2 # $a0=m/4
jal fun_T
sll $v0, $v0, 1 # $v0=2*T(m/4)
add $v0, $v0, $s1 # return $v0=3*T(m/2)+2*T(m/4)

End: lw $s1, 8($sp)
lw $s0, 4($sp)
lw $ra, 0($sp)
addi $sp, $sp, 12
jr $ra

soluzione fibonacci


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

add $s0, $0, $a0 # $s0=n
slti $t0, $s0, 2 # $t0=1 iff n<2
beq $t0, $0, Else # if n>=2 goto Else
add $v0, $0, $s0 # return n
j End
Else: addi $a0, $s0, -1 # $a0=n-1
jal fib # calcola fib(n-1)
add $s1, $0, $v0 # $s0=fib(n-1)
addi $a0, $s0, -2 # $a0=n-2
jal fib # calcola fib(n-2)
add $v0, $v0, $s1 # $v0=fib(n-1)+fib(n-2)

End: lw $s1, 8($sp)
lw $s0, 4($sp)
lw $ra, 0($sp)
addi $sp, $sp, 12
jr $ra

...non trovate delle similarità? si è vero invece di -1 e -2 c'e' /2 e /4, poi bisognava moltiplicare per 3 e per 2 prima di sommare...chiedo troppo
a dei potenziali ingegneri?

quindi dal mio punto di vista, un compito lungo ma elementare (e chi si ricorda ai miei tempi un compito con esercizi quasi identici a quelli svolti in classe la settimana prima).

Certo, come studenti universitari non siete tenuti a seguire, a svolgere gli esercizi, a seguire le spiegazione passo passo di un codice particolare come fibonacci o hanoi (altra doppia ricorsione), a scaricarla dal sito per riguardarla con comodo a casa, etc. etc., ma allora, cosa mi dovrei aspettare da voi?