Valerio Battaglia

http://www.ce.uniroma2.it/~lopresti/Did ... .htm#Esami

Cosa si intende per

caratteristiche e relativi vantaggi delle tecniche di programmazione dei dispositivi di I/O???

vantaggi e svantaggi tra:

-programmato con attesa
-controllato da interruzioni
-con accesso diretto alla memoria

altro dubbio:

nel file di soluzione del prof, relativamente all'istruzione jal:
poichè bisogna implementare R[31]= PC +4 aggiunge una linea che va da PC a nuovo ingresso del mux comandato da MemtoReg.

Ora facendo questo lui fa R[31]=PC (non addiziona il PC con 4) quando dovrebbe fare R[31]=PC

Infatti svolgendolo per conto mio, senza vedere la soluzione mi veniva uno stato in + sull'automa, proprio quello stato che si calcolava il PC+4 (dato che dopo la fase di ID l'aluout viene sovrascritto con l'indirizzo del branch).

Sbaglio??

= PC +4 aggiunge una linea che va da PC a nuovo ingresso del mux comandato da MemtoReg.

Ora facendo questo lui fa R[31]=PC (non addiziona il PC con 4) quando dovrebbe fare R[31]=PC

Infatti svolgendolo per conto mio, senza vedere la soluzione mi veniva uno stato in + sull'automa, proprio quello stato che si calcolava il PC+4 (dato che dopo la fase di ID l'aluout viene sovrascritto con l'indirizzo del branch).

Sbaglio??

[edit]
sostituire questa frase:

Ora facendo questo lui fa R[31]=PC (non addiziona il PC con 4) quando dovrebbe fare R[31]=PC

con questa:

Ora facendo questo lui fa R[31]=PC (non addiziona il PC con 4) quando dovrebbe fare R[31]=PC + 4

dopo la fase di fetch in PC c'è PC+4, quindi è corretto

si è vero me ne sono accorto anche io e stavo per scrivere il mea culpa ma mi hai preceduto....thx cmq!!!

Chi ha fatto il 2° esonero oggi?
Io per risolvere il loop ho reinterpretato la semantica
Era così:

R[rs] = R[rs] - 1;
if (rs == 0) PC = PC + 4 + [sign_extended(address) << 2]
else PC = PC + 4

e io l'ho pensata così:

R[rs] = R[rs] - 1;
PC = (PC + 4) + [sign_extended(address) << 2] * ZERO

In questo modo quando RS > 1 ZERO è = 0 e PC = PC + 4
Quando invece RS = 1 il risultato della sottrazione è zero, quindi ZERO = 1 e PC = (PC + 4) + [sign_extended(address) << 2]

Il tutto implementato con un multiplexer dopo lo shift left prima di entrare in alusrcb.

Spero gli piaccia :|

Questo va bene per la prima parte (hai quindi aggiunti un 1 al mux di ALUSrcB per fare la sottrazione con R(rs)), poi però dovevi scrivere il risultatato della sottrazine in R(rs), e per quello dovevi fare un'altra modifica al MUX del RegDst per farci arrivare rs. Questo richiedeva un ulteriore ciclo. Io l'ho fatto così

Questo va bene per la prima parte (hai quindi aggiunti un 1 al mux di ALUSrcB per fare la sottrazione con R(rs)), poi però dovevi scrivere il risultatato della sottrazine in R(rs), e per quello dovevi fare un'altra modifica al MUX del RegDst per farci arrivare rs. Questo richiedeva un ulteriore ciclo. Io l'ho fatto così

sì vabè, quella parte era bbastanza ovvia non l'ho scritta. anche io ho fatto così però il tutto alla fine mi pare condensato in 2 stati
nel primo fai RS-1
nel secondo aggiorni il PC e RS

Ora che lo scrivo però mi sa che il 2° stato erano in realtà 2 stati perchè PC è comunque un registro e posso fare max un'operazione di scrittura sui registri.
Amen, un errore per me.

nel secondo stato scrivevi solo Alu OUT nel registro R(rs), solo questo facevi

PC lo imposto al primo ciclo che progetti, quello dove fai la sottrazione. Il secondo ciclo scrive solo AluOUT in R(rs) perciò dovrebbe essere fattibile e corretto.

In pratica era una BEQ il primo stato, solo che al posto di fare la differenza fra A e B, la facevi fra A e 1. Il secondo passo era la scrittura del risultato in R(rs), almeno ...per me è così! :?

io l'ho vista diversa: dato che al punto di fetch già faccio PC+4 (e visto che lui tra le sue pseudoistruzioni non lo mette come prima operazione) in ogni caso dopo il primo giro avrò PC+4 contenuto in PC. A questo punto salvo rs-1 nel registro, lo estraggo e confronto con 0.

Ora che succede, che se rs-1=0 e devo fare il salto l'indirizzo sta in aluout (dove avevo salvato pc+4+sign_extend(add) ), mentre se rs!=0 allora ho già pc+4 nel registro PC.

Poi boh, come va va :wink:

Questa è la soluzione migliore.

In pratica era una BEQ il primo stato, solo che al posto di fare la differenza fra A e B, la facevi fra A e 1. Il secondo passo era la scrittura del risultato in R(rs), almeno ...per me è così!

Scusi professore,
spero che non ce ne sia bisogno ma, con sincerità, il compito sulla seconda parte al secondo appello ha la stessa struttura e difficoltà di quello di oggi?

La ringrazio!

io l'ho vista diversa: dato che al punto di fetch già faccio PC+4 (e visto che lui tra le sue pseudoistruzioni non lo mette come prima operazione) in ogni caso dopo il primo giro avrò PC+4 contenuto in PC. A questo punto salvo rs-1 nel registro, lo estraggo e confronto con 0.

Ora che succede, che se rs-1=0 e devo fare il salto l'indirizzo sta in aluout (dove avevo salvato pc+4+sign_extend(add) ), mentre se rs!=0 allora ho già pc+4 nel registro PC.

Poi boh, come va va :wink:

Attento, se salvi nel registro subito rs-1 al ciclo dopo non avrai più in ALUout pc+4+sign_extend(add)<<2, ma hai il risultato di rs-1!!

Questa è la soluzione migliore.

In pratica era una BEQ il primo stato, solo che al posto di fare la differenza fra A e B, la facevi fra A e 1. Il secondo passo era la scrittura del risultato in R(rs), almeno ...per me è così!

E vai!!!!!!!!!!!!!!! :-)

io l'ho vista diversa: dato che al punto di fetch già faccio PC+4 (e visto che lui tra le sue pseudoistruzioni non lo mette come prima operazione) in ogni caso dopo il primo giro avrò PC+4 contenuto in PC. A questo punto salvo rs-1 nel registro, lo estraggo e confronto con 0.

Ora che succede, che se rs-1=0 e devo fare il salto l'indirizzo sta in aluout (dove avevo salvato pc+4+sign_extend(add) ), mentre se rs!=0 allora ho già pc+4 nel registro PC.

Poi boh, come va va :wink:

Attento, se salvi nel registro subito rs-1 al ciclo dopo non avrai più in ALUout pc+4+sign_extend(add)<<2, ma hai il risultato di rs-1!!

sisi lo so, non l'ho specificato ma era quello che ho fatto: dato che dopo la differenza il valore di aluout viene modificato, faccio un altro ciclo di clock dove faccio di nuovo la somma tra pc+4 e il sign_extend(add)<<2.

Praticamente perdo tempo rifacendo una cosa già fatta, ma al compito si sa la strizza è tanta e dato che non era specificato di ottimizzarlo mi è uscito cosi: perdo tempo, ma almeno son sicuro che l'indirizzo di salto è giusto e sono sicuro di scrivere nel registro. :wink:

Grazie per la segnalazione comunque!

Questa è la soluzione migliore.

In pratica era una BEQ il primo stato, solo che al posto di fare la differenza fra A e B, la facevi fra A e 1. Il secondo passo era la scrittura del risultato in R(rs), almeno ...per me è così!

E vai!!!!!!!!!!!!!!! :-)

grandem, sei sempre il meglio . Bella questa implementazione, non ci avevo pensato ^^ :cry: , bella davvero :wink: