Scarica Progettazione Risc-v e più Schemi e mappe concettuali in PDF di Calcolatori Elettronici solo su Docsity!
Domande che potrebbero essere fatte sul progetto RISC-V.
- perché nel progetto il Program Counter è un registro e non un semplice filo. Qual è il motivo architetturale per cui il PC deve essere memorizzato e aggiornato solo a determinati istanti del clock.
- cosa succede nel datapath quando viene eseguita un’istruzione di tipo add, chiedendoti di seguire l’intero percorso del dato dall’Instruction Memory fino al Write Back.
- Potrebbe chiederti perché nel tuo progetto esistono due memorie distinte, Instruction Memory e Data Memory, e cosa succederebbe se fossero invece una sola memoria condivisa.
- Potrebbe chiederti cosa succede se il Program Counter raggiunge un indirizzo di memoria dove non è stata caricata alcuna istruzione.
- Potrebbe chiederti come fa la Control Logic a capire quale operazione deve essere eseguita dalla ALU.
- Potrebbe chiederti perché le istruzioni RISC-V sono lunghe tutte esattamente 32 bit e quale vantaggio architetturale comporta questa scelta.
- Potrebbe chiederti cosa succede nel tuo circuito quando viene eseguita un’istruzione store e quale differenza c’è rispetto a una load dal punto di vista del datapath.
- Potrebbe chiederti se il Register File può leggere e scrivere nello stesso ciclo di clock e come viene gestita questa situazione
- Potrebbe chiederti perché hai usato un immediato con sign extension e non semplicemente il valore immediato così com’è.
- Potrebbe chiederti che cosa rappresentano i segnali RS1, RS2 e RD e come vengono utilizzati dal Register File.
- Potrebbe chiederti perché nel tuo progetto la ALU non riceve direttamente l’opcode dell’istruzione ma utilizza segnali derivati dalla Control Logic.
- Potrebbe chiederti cosa succede nel circuito se il clock viene fermato mentre il programma è in esecuzione.
- Potrebbe chiederti se il blocco OUTPUT fa parte dell’architettura della CPU oppure se è solo un componente utilizzato per il debugging e la visualizzazione dei risultati.
- Potrebbe chiederti quale sarebbe il primo componente del circuito da modificare se volessi aggiungere una nuova istruzione al tuo processore. Se volessi trasformare il tuo processore da esecuzione sequenziale a processore pipelined, quali modifiche architetturali principali dovresti introdurre nel circuito?
- Nel tuo Register File ci sono due porte di lettura ma una sola porta di scrittura. Perché servono due letture simultanee?
- se due istruzioni consecutive scrivono nello stesso registro, succede qualcosa di problematico?
Risposte:
- Il program counter è un registro considerato 'speciale', non indica uno specifico indirizzo statico, ma è un componente che tiene conservato al suo interno il valore dell'indirizzo della prossima istruzione da eseguire. Il PC viene aggiornato ad ogni fronte di clock infatti viene eseguita l'operazione PC + 4 se stiamo trattando un'operazione sequenziale, PC + offset se stiamo trattando istruzioni di salto o branch. Se fosse un filo, quindi avendo una logica combinatoria e senza memoria, avremmo dei 'glitch' continui, perché il valore verrebbe incrementato continuamente e senza fermarsi all'indirizzo dell'istruzione corrente.
- Durante la fase di fetch i componenti che svolgono un lavoro fondamentale sono due: instruction memory e program counter. Quando viene caricato il file con le istruzione, l’IMEM quindi viene inizializzata l'instruction memory con la sequenza di istruzioni, mentre il PC è uguale a zero, poichè stiamo inizializzando. PC = 0 significa, PC = indirizzo della prima istruzione, successivamente si passa alla fase di Decode.Nel mio progetto la decodifica è realizzata tramite due blocchi, DecodeLogic1 e DecodeLogic2. DecodeLogic1 analizza i campi opcode, funct3 e funct dell’istruzione per identificare il tipo di operazione, che in questo caso è una addizione. DecodeLogic2 invece estrae i campi operativi dell’istruzione, cioè i registri sorgente RS1 e RS2 e il registro destinazione RD. In questo caso RS1 corrisponde al registro x2, RS2 al registro x8 e RD al registro x6. Contemporaneamente la Control Logic analizza l’opcode e genera i segnali di controllo necessari per il datapath, tra cui l’abilitazione della ALU e il segnale RegWrite che sarà utilizzato nella fase finale.
Gli indirizzi dei registri sorgente RS1 e RS2 vengono inviati al Register File, che possiede due porte di lettura e quindi può leggere simultaneamente i valori contenuti nei due registri. I valori letti vengono poi inviati alla ALU come operandi.
Nella fase di Esecuzione, l'add quindi arriverà al componente ALU che produce il risultato dell'operazione. Nonostante nella mia CPU la ALU contenga diversa unità operative che lavorano in parallelo, alla fine tutte le operazioni appunto, vengono completate ma solo il multiplexer finale seleziona il risultato. Nella fase di memoria, non viene effettuata nessuna operazione sulla DMEM e quindi il risultato passa attraverso questa fase senza modifiche, il risultato però viene utilizzato nella fase di WB dove appunto il risultato dell'operazione add verrà scritto nel registro di destinazione.
- L'instruction Memory e la Data memory svolgono due compiti diversi, essendo anche due tipi di memorie diverse. L'IMEM è il luogo in cui risiede il codice eseguibile del programma(istruzioni da eseguire), la DMEM è lo spazio utilizzato per memorizzare le variabili e le informazioni su cui il programma opera. Questa divisione permette di lavorare in parallelo permettendo al processore di leggere una nuova istruzione e scrivere contemporaneamente, se avessero una unica memoria condivisa il processore dovrebbe aspettare creando un hazard strutturale. (architettura Harvard)
- Se il Program Counter raggiunge un indirizzo della Instruction Memory dove non è stata caricata alcuna istruzione, la memoria restituisce semplicemente il valore presente in quella cella, spesso pari a zero o al valore di default della memoria. Il processore tenterà comunque di decodificare quei bit come se fossero un’istruzione. Nel progetto realizzato in Logisim non è presente un meccanismo di gestione delle eccezioni, quindi il comportamento dipende dal valore letto dalla memoria.
- La Control Logic determina quale operazione deve essere eseguita dalla ALU analizzando i campi dell’istruzione ottenuti durante la fase di decode. In particolare vengono utilizzati i campi opcode, funct3 e funct7. L'Opcode identifica la categoria dell’istruzione, mentre funct3 e funct7 permettono di distinguere tra operazioni specifiche come addizione, sottrazione o operazioni logiche. Sulla base di questi campi la Control Logic genera i segnali di controllo che configurano la ALU affinché esegua l’operazione corretta.
dell’operazione è pronto, l’indirizzo RD seleziona quale registro del Register File deve essere aggiornato. Tuttavia la scrittura avviene solo se il segnale di controllo RegWrite è attivo. In questo modo il processore evita di scrivere nei registri quando l’istruzione non lo richiede, come nel caso di store o branch.
- Nel progetto la ALU non riceve direttamente l’opcode dell’istruzione perché la decodifica dell’istruzione è responsabilità della Control Logic. Quando l’istruzione viene letta dalla Instruction Memory, i campi opcode, funct3 e funct7 vengono analizzati dalla logica di decodifica. La Control Logic utilizza queste informazioni per generare i segnali di controllo necessari per il datapath. Tra questi segnali c’è anche il codice di controllo della ALU, spesso chiamato ALU Control, che indica quale operazione specifica deve essere eseguita, come addizione, sottrazione o operazioni logiche. In questo modo la ALU rimane un’unità di calcolo generica che esegue operazioni aritmetiche e logiche, mentre la complessità della decodifica delle istruzioni è gestita separatamente dalla Control Logic. Questa separazione tra unità di controllo e datapath rende l’architettura più modulare e più semplice da progettare.
- Se il clock viene fermato mentre il programma è in esecuzione, il processore smette di avanzare nell’esecuzione delle istruzioni. Questo avviene perché tutti i registri del sistema, come il Program Counter e il Register File, vengono aggiornati solo al fronte di clock. Se il clock non genera nuovi impulsi, questi registri mantengono il loro valore corrente. Di conseguenza il Program Counter non viene aggiornato e il processore continua a mantenere lo stesso stato interno. Le parti combinatorie del circuito, come la Control Logic e la ALU, continuano ad avere gli stessi ingressi e quindi producono gli stessi segnali, ma nessun nuovo stato viene memorizzato. Quando il clock riprende a funzionare, il processore continua l’esecuzione esattamente dal punto in cui era stato interrotto.
- Il blocco OUTPUT non fa parte dell’architettura della CPU vera e propria, ma è un componente utilizzato solo per la visualizzazione dei risultati durante la simulazione. È collegato ai segnali interni del datapath, ad esempio ai bus provenienti dal Register File o dall’uscita della ALU, ma non partecipa in alcun modo al processo di esecuzione delle istruzioni. Il suo scopo è semplicemente permettere di osservare l’evoluzione dei valori prodotti dal processore. Nel circuito il valore a 32 bit viene inviato al blocco OUTPUT, dove uno splitter lo divide in gruppi da 4 bit. Ogni gruppo viene poi convertito da un decoder per pilotare i display esadecimali, consentendo di visualizzare il valore calcolato dal processore. Se questo blocco venisse rimosso, la CPU continuerebbe comunque a funzionare correttamente, ma non sarebbe più possibile osservare facilmente i risultati.
- Se si volesse aggiungere una nuova istruzione al processore, il primo componente da modificare sarebbe la logica di decodifica, cioè la Control Logic insieme ai moduli di decode. Questo perché il processore deve essere in grado di riconoscere la nuova istruzione analizzando i campi dell’istruzione, come opcode, funct3 e funct7. La logica di decodifica deve quindi essere aggiornata per associare a quella combinazione di bit i corretti segnali di controllo del datapath. Una volta riconosciuta l’istruzione, la Control Logic deve generare i segnali necessari per pilotare i vari componenti del processore, come l’abilitazione della ALU, la selezione degli operandi tramite multiplexer, l’eventuale accesso alla Data Memory e il segnale RegWrite per il Register File.
Solo nel caso in cui la nuova istruzione richiedesse un operazione aritmetica o logica non ancora supportata sarebbe necessario modificare anche la ALU per aggiungere una nuova unità operativa o un nuovo codice di controllo. In molti casi però è sufficiente modificare solo la logica di decodifica dei segnali di controllo.
Per quanto riguarda la trasformazione del processore da esecuzione sequenziale a processore pipelined, sarebbe necessario introdurre alcune modifiche architetturali importanti. In primo luogo bisognerebbe separare chiaramente le varie fasi del ciclo di esecuzione, cioè Fetch, Decode, Execute, Memory e Write Back. Tra ciascuna di queste fasi dovrebbero essere inseriti dei registri di pipeline, che memorizzano temporaneamente i dati e i segnali di controllo prodotti da una fase prima di passare alla fase successiva nel ciclo di clock successivo. In questo modo più istruzioni possono trovarsi contemporaneamente in fasi diverse del datapath. Inoltre sarebbe necessario gestire i problemi tipici della pipeline, come le dipendenze tra istruzioni e i conflitti sulle risorse hardware. Questo richiederebbe l’introduzione di meccanismi di gestione degli hazard, come unità di forwarding o logiche di stallo della pipeline. Infine la Control Logic dovrebbe essere adattata per generare e propagare correttamente i segnali di controllo attraverso i registri di pipeline. In questo modo il processore potrebbe iniziare l’esecuzione di una nuova istruzione ad ogni ciclo di clock, aumentando significativamente il throughput del sistema.
- Il Register File possiede due porte di lettura perché molte istruzioni dell’architettura RISC-V utilizzano due registri sorgente. Ad esempio un’istruzione aritmetica come add x6, x2, x8 richiede di leggere contemporaneamente i valori contenuti nei registri x2 e x8 per poterli inviare alla ALU. Le due porte di lettura permettono quindi di ottenere entrambi gli operandi nello stesso ciclo di clock. Questo consente alla ALU di eseguire l’operazione senza dover effettuare accessi sequenziali ai registri, rendendo il datapath più efficiente.
- Se due istruzioni consecutive scrivono nello stesso registro di destinazione non si verifica alcun problema nel processore. Ogni istruzione esegue la propria fase di Write Back in un ciclo di clock separato e il risultato viene scritto nel registro indicato da RD quando il segnale RegWrite è attivo. Se una seconda istruzione scrive nello stesso registro, il nuovo valore semplicemente sovrascrive quello precedente. Poiché il processore esegue una istruzione per volta e dispone di una sola porta di scrittura nel Register File, non si verificano conflitti tra le due operazioni di scrittura.
Ulteriori domande
1. Flusso iniziale del programma
Quando apri il circuito Main, carichi il file fibo.txt nella Instruction Memory e poi attivi il clock. Puoi spiegare cosa succede nei primi due cicli di clock nel tuo processore?
Risposta : Quando il programma viene caricato nella Instruction Memory tramite il comando Load Image , la memoria viene inizializzata con la sequenza di istruzioni del programma Fibonacci. A questo punto il Program Counter viene inizializzato a zero tramite il segnale di reset.
Nel primo ciclo di clock il valore del Program Counter, che è pari a zero, viene inviato alla Instruction Memory. La memoria utilizza questo indirizzo per restituire la prima istruzione del programma, che entra nel datapath. Questa è la fase di Fetch , in cui il processore recupera l’istruzione dalla memoria.
L’istruzione recuperata passa quindi alla fase di Decode , dove i blocchi DecodeLogic1 e DecodeLogic analizzano i campi dell’istruzione. DecodeLogic1 esamina i campi opcode, funct3 e funct7 per identificare il tipo di operazione, mentre DecodeLogic2 estrae i campi operativi come RS1, RS2 e RD. Contemporaneamente la Control Logic genera i segnali di controllo necessari per il datapath.
Nel secondo ciclo di clock il Program Counter viene aggiornato, normalmente con l’operazione PC + 4 nel caso di esecuzione sequenziale. Questo nuovo valore permette di accedere alla seconda istruzione del programma nella Instruction Memory. Nel frattempo la prima istruzione continua il suo percorso nel datapath attraversando le fasi successive, cioè Execute, Memory e Write Back.
Spiegazione funzionamento progetto:
Il progetto consiste nella realizzazione di una CPU a 32 bit che implementa l’architettura RISC-V RV32I all’interno dell’ambiente Logisim. Il processore è in grado di eseguire istruzioni aritmetiche, logiche, di load/store e di controllo del flusso come branch e jump. L’obiettivo del progetto è stato progettare un datapath completo con la relativa logica di controllo, in modo da permettere l’esecuzione di un programma reale, nel nostro caso il calcolo della sequenza di Fibonacci.
Il funzionamento della CPU segue il classico ciclo di esecuzione delle istruzioni composto dalle fasi di Fetch, Decode, Execute, Memory e Write Back.
Nella fase di Fetch il Program Counter contiene l’indirizzo della prossima istruzione da eseguire e lo invia alla Instruction Memory, che restituisce l’istruzione a 32 bit memorizzata a quell’indirizzo. Poiché le istruzioni RISC-V hanno lunghezza fissa di 32 bit, il Program Counter viene normalmente aggiornato con l’operazione PC + 4, oppure con un offset nel caso di istruzioni di branch o jump.
L’istruzione passa poi alla fase di Decode, dove i blocchi DecodeLogic1 e DecodeLogic2 analizzano i campi dell’istruzione. In particolare vengono estratti i registri sorgente RS1 e RS2, il registro di destinazione RD e gli eventuali campi immediati. Contemporaneamente la Control Logic analizza opcode, funct3 e funct7 per generare i segnali di controllo necessari per il datapath.
Durante la fase di Execute il Register File fornisce i valori dei registri sorgente che vengono utilizzati come operandi dalla ALU. Nel caso di istruzioni con immediato, un multiplexer seleziona tra il valore del registro RS2 e l’immediato generato dall’Immediate Generator. La ALU esegue quindi l’operazione richiesta, come addizione, confronto o calcolo di indirizzo.
Nella fase Memory, se l’istruzione è di tipo load o store, la Data Memory viene utilizzata per leggere o scrivere dati all’indirizzo calcolato dalla ALU. Se invece l’istruzione è aritmetica, questa fase viene semplicemente attraversata senza operazioni sulla memoria.
Infine nella fase di Write Back il risultato prodotto dalla ALU o dalla Data Memory viene scritto nel registro di destinazione RD del Register File, se il segnale RegWrite è attivo.
Per osservare il funzionamento del processore è stato inoltre collegato un blocco di output al datapath che permette di visualizzare i valori calcolati tramite display esadecimali durante l’esecuzione del programma Fibonacci.
Domande sul codice assembly
1. Può spiegarmi cosa fa questo programma Fibonacci?
Risposta : Il programma calcola i primi N numeri della sequenza di Fibonacci e li salva in memoria all’interno dell’array array. Il valore di N viene letto dalla memoria dati, poi vengono inizializzati i primi due valori della sequenza (F0 = 0 , F1 = 1 ) e salvati nell’array. Successivamente un ciclo calcola iterativamente i valori successivi usando la relazione F(n) = F(n-1) + F(n-2) e li memorizza in memoria.
2. Quale istruzione realizza il ciclo?
Risposta : bnez t1, loop
Questa istruzione controlla se il contatore t1 è diverso da zero e, in tal caso, salta all’etichetta loop.
Questo genera un branch condizionale nel tuo processore.
3. Quando viene eseguita l’istruzione add t5, t3, t4 cosa succede nel datapath?
Risposta :
● Fetch → PC legge istruzione ● Decode → RS1=t3, RS2=t4, RD=t ● Register File legge t3 e t ● ALU esegue addizione ● WriteBack scrive risultato in t
4. Quali istruzioni del programma utilizzano la Data Memory?
Risposta : le istruzioni sono:
lw t1, 0(t0)
sw t3, 0(t2)
sw t4, 4(t2)
sw t5, 0(t2)
lw a0, 0(t2)
● lw → MemRead ● sw → MemWrite
Quindi attivano la fase MEM del datapath.
5. Come viene calcolato l’indirizzo nella istruzione sw t5, 0(t2)
Risposta : L’indirizzo di memoria viene calcolato dalla ALU come: indirizzo = registro base + offset In questo caso: indirizzo = t2 + 0
● RS1 = t ● RS2 = t ● RD = t
Gli indirizzi dei registri sorgente vengono inviati al Register File, che possiede due porte di lettura e può quindi leggere simultaneamente i contenuti dei registri t3 e t4. I valori letti diventano gli operandi della ALU.
Nella fase di Execute, la ALU riceve i due operandi provenienti dal Register File e attiva l’unità di addizione. Nella tua implementazione la ALU contiene diverse unità operative in parallelo (addizione, operazioni logiche, confronti e shift). Tutte queste unità producono un risultato, ma un multiplexer finale seleziona quello corretto in base ai segnali di controllo generati dalla Control Logic durante la fase di decode. In questo caso il multiplexer seleziona il risultato dell’addizione.
La fase Memory in questo caso non viene utilizzata, perché l’istruzione non richiede accessi alla Data Memory. Il valore prodotto dalla ALU attraversa quindi questa fase senza modifiche.
Infine nella fase di Write Back, il risultato dell’addizione viene scritto nel registro di destinazione t5. L’indirizzo del registro è fornito dal campo RD e la scrittura avviene solo se il segnale di controllo RegWrite è attivo. Il valore viene quindi memorizzato nel Register File e potrà essere utilizzato dalle istruzioni successive.
Nel programma Fibonacci questo valore rappresenta il nuovo numero della sequenza, cioè la somma dei due valori precedenti.
Dove viene selezionato se il secondo operando della ALU è RS2 oppure un immediato?
La risposta : Il segnale viene generato dalla Control Logic, che controlla un multiplexer prima dell’ingresso della ALU. Questo multiplexer sceglie tra il valore del registro RS2 e l’immediato prodotto dall’Immediate Generator.
