Upload: EduMips64_first_draft

== EduMIPS64 - Draft one ==
=== by Massimo Trubia (max83t) ===
last update: 22-04-2006

Come al solito editate tutto ciò che è scorretto...

Abbiamo essenzialmente diviso il progetto in 5 moduli:

{{{
        MAIN----GUI------CPU ---------  INSTRUCTION SET ------  PARSER
                          _________________________________________ 
}}}

=== GUI ===
L'interfaccia grafica sarà simile a Winmips64 a meno che non si decida una struttura tabbed (linguette
cliccabili mediante cui si cambia l'oggetto osservato). Quest'ultimo cambiamento potrebbe anche essere
effettuato successivamente dal momento che il gruppo di sviluppo della GUI progetterà i singoli jpanel.
La GUI è completamente indipendente dal kernel, ma essa dovrà fornire alla CPU un'interfaccia che
permetta di agire sui singoli componenti.

Per esempio la pipeline dovrà essere rappresentata da rettangoli
colorati a seconda dello step eseguito, per cui dovranno esistere dei metodi che agiscano sul singolo
rettangolo cambiandone gli attributi.I JPanel rappresentanti i dati, i registri e la memoria,come anche la pipeline devono essere aggiornati man mano che le istruzioni vengono eseguite, dunque per esse vale quanto detto prima.

=== SIMULAZIONE E MAIN ===
Riguarda l'aspetto d'insieme del software e la modalità d'interazione utente-programma. In questo ambito
sono sviluppate utilità per l'utente finalizzate al miglioramento dell'usabilità e si  effettua la coordinazione tra tutti i moduli di EDUMips64.

=== CPU ===
Implementa una macchina a stati che si occuperà di eseguire le istruzioni.
Essa fornisce all'IS l'interfaccia che permette a quest'ultimo di agire sui
meccanismi interni della CPU. 

La CPU deve ad esempio disporre dei metodi setReg(num registro,valore) e getReg(num registro)
per far si che ogni istruzione dell'instruction set possa agire sui registri.
Le singole istruzioni sono viste come black box. La CPU ignora la loro implementazione
interna e può soltanto eseguirle mediante un metodo exec() che ognuna di esse 
dovrà fornire. La CPU subira' dunque le modifiche che le istruzioni richiedono con 
l'invocazione dei metodi anzidetti.

=== PARSER e INSTRUCTION SET ===
Il parser si occupa di preparare il programma utente (es. il classico file con estensione
.s del Winmips64) ad essere eseguito nella CPU, ovvero deve costruire il codice oggetto del programma da "dare in pasto alla CPU". 

Può comportarsi in soli due modi:
 *creare il codice oggetto
 *generare un'eccezione dovuta a un'istruzione errata

'''Come agisce?'''
La materia prima su cui opera il parser è il programma utente. Lo legge riga per riga
e controlla se l'istruzione corrispondente è "definita corretta".In caso contrario,se ad esempio 
la riga letta è "DADD R10,R5", si accorgerà dell'errore lessicale/sintattico operando
un controllo sul numero di parametri da passare alla DADD. 

Ogni istruzione dell'instruction set deve dunque fornire al parser 
un'interfaccia che gli permetta di verificare tale correttezza. Nel nostro esempio,
appena il parser legge la riga "DADD R10,R5,R2" dovrebbe creare un oggetto Instruction e invocare su esso
dei metodi del tipo  `Instruction.getType()`, `Instruction.getSyntax()` i quali restituiscono il tipo di istruzione letto dal parser e la sintassi che essa deve avere.
Il parser in altre parole usa l'instruction set per risolvere i propri problemi:
effettuare le analisi di correttezza. 

'''ESEMPIO DI POSSIBILE IMPLEMENTAZIONE'''

 //il parser, dopo aver letto "DADD R10,R5,R2" estrae l'opcode (DADD) e crea un oggetto sul quale
 //può invocare i metodi anzidetti per istruirsi
 Instruction i=new Instruction("DADD");
 type=i.getType();
 syntax=i.getSyntax();
 confronto tra istruzione letta dal parser e sintassi corretta proposta dall'instruction set ;

Dopo averne verificato la correttezza, il parser può finalmente creare l'istruzione DADD passando ad essa i relativi parametri.Da questo momento in poi la DADD è impacchettata insieme alla codifica binaria delle operazioni da svolgere ("Leggere dai registri R5 ed R2, sommare i valori e memorizzarli in R10") e inviata alla CPU. 

L'oggetto DADD viene aggiunto dalla CPU  nella pipeline e, all'avanzare degli step fetch,decode,execute,mem,writeback, invoca su esso i corrispondenti metodi ID(),EX(),MEM(),WB().

L'invocazione dei metodi anzidetti fa sì che l'istruzione
DADD operi sui registri dell'oggetto CPU o in altri casi dell'oggetto Memoria (nelle istruzioni di tipo Load/Store). 
L'oggetto DADD si comporterà in questo modo:

-AZIONE DELLA PIPELINE FATTA AVANZARE DALLA CPU CON SUCCESSIVE INVOCAZIONI DEL METODO step()
  CPU          PIPELINE
 step()  =>   DADD.ID();
 step()  =>   DADD.EX();
 ....

-METODI DELL'OGGETTO DADD 
ID() generaeccezione RegistroGiaBloccato{
   //blocco registro R10
   CPU.lockReg(10);
} 

EX(){
     op1=CPU.getReg(5);
     op2=CPU.getReg(2);
     res=somma a 64 bit dei due operandi con controllo di overflow;
 }
MEM(){}
WB(){
     setReg(10, res);
     //sblocco registro R10
     CPU.unlockReg(10);
}

Un'altra importante azione effettuata dal parser è il monitoring dello stato della memoria e dei salti
compiuti in essa, infatti sappiamo che l'esecuzione delle istruzioni è governata dalla politica 
PC-relative e PC-region, un salto illegale deve dunque generare un'eccezione.

Infine l'INSTRUCTION SET e' composto da una libreria di classi facilmente estensibile che raggruppa le istruzioni del MIPS64 dal punto di vista funzionale. 

{{{
                           Instruction
                                 
                ---------------------------------
                                                 
              ALU            LoadStore       FlowControl
                                                 
                 _DADD           _LB             _JAL
                 _DSUB           _LD             _BNEZ
                 ...             ...             ...
}}}