Corso di MAL (Micro Assembly Language) Architettura degli

1 Architetture degli Elaboratori

Corso diCorso diArchitettura degli ElaboratoriArchitettura degli Elaboratori

Il livello della microarchitettura:il microprogramma per il Mic-1

che implementa IJVM (un esempio)

Matteo Baldoni

Dipartimento di InformaticaUniversità degli Studi di Torino

C.so Svizzera, 185 – I-10149 [email protected]

http:/ /www.di.unito.it/ ~baldoni


MAL (Micro Assembly Language)MAL (Micro Assembly Language)

� Una notazione sintatticamente piu ̀leggibile degli 0 e 1, esempio:

� SP = SP + 1; rd

� Z = TOS; if (Z) goto L1; else goto L2 (nasconde TOS = TOS)

� Sono possibili assegmaneti multipli (in coerenza con l'uso del bus C)

� SP = MDR = SP + 1

xxxxxxxxx 000 00 110101 000001000 010 0100

xxxxxxxxx 000 00 110101 000001010 000 0100

xxxxxxxxx 001 00 010100 001000000 000 0111



� Ancora notazione

� MDR = H + SP

� MDR = SP + H è equivalente ma è preferibile che “H” sia l'operando di sinistra

� MDR = SP + MDR non è legale (le operazioni binarie hanno necessariamente H come operandodi sinistra)

xxxxxxxxx 000 00 111100 000000000 000 0100



� Per realizzare questa presentazione ho utilizzato il simulatore presente a questa pagina http:/ /www.ontko.com/mic1/

� L'esempio che vedremo (assegnamento.jas) mostra solo alcune delle istruzioni (forse le piu ̀semplici) ma da un'idea del funzionamento generale del microprogramma

� Comando:java -classpath classes.zip:. mic1sim mic1ijvm.mic1 assegnamento.ijvm


MAL vs IJVMMAL vs IJVM

� Il microinterprete (livello 1) interpreta, pilotando il data-path, il programma scritto in IJVM (livello 2)

� Sia MAL che IJVM sono assemblati da opportuni programmi (l'assemblatore e il microassemblatore)

AssemblatoreIJVM

Programmain IJVM

Programmabinario

Microinterpretecaricato in ROM

OutputdelprogrammaIJVM

Micro-Assemblatore

MAL

Microinterpretescritto in MAL

Compilatore(es. javacc)

Programma inlinguaggio di alto livello (es. java)


Un esempioUn esempio

� Vediamo l'esecuzione del calcolo dell'espressione a lato, si supponga che i e j abbiano offset 0 e 1 rispettivamente all'interno della procedura

� Si noti che l'espressione 3 + j e ̀in pratica riportata in RPN

� Il risultato dell'espressione si trovera ̀sul top dello operand stack, da qui prelevato e memorizzato in i

BIPUSH3

ILOADj

IADDISTORE

i

...i = 3 + j...

0x00x10x20x30x40x50x6

0x100x3

0x150x1

0x600x360x0


Cycle 1: Via!Cycle 1: Via!

-----------------Start cycle 1----------------------goto 0x2MDR: Put 0x0H: Put 0x0ALU: 0 AND 0 = 0x0Goto ADDR: 0x2

BIPUSH3

ILOADj

IADDISTORE

i

In realta ̀questa istruzionesi trova all'indirizzo 0x0!


Cycle 2: esegue Main1Cycle 2: esegue Main1BIPUSH

3ILOAD

jIADD

ISTOREi

richiesta la lettura di-----------------Start cycle 2----------------------PC=PC+1;fetch;goto (MBR)PC: Put FFFFFFFFH: Put 0x0ALU: 0 + B + 1 = 0x0PC: Store 0PC: Fetch byte 0MEM: Fetch from byte# 0x0 requested. Processing...Goto MBR: 0x0


Cycle 3Cycle 3BIPUSH

3ILOAD

jIADD

ISTOREi

-----------------Start cycle 3----------------------goto 0x2MDR: Put 0x0H: Put 0x0ALU: 0 AND 0 = 0x0MEM: Fetch value 0x10 from address 0x0MBR: Store 0x10Goto ADDR: 0x2

memorizzato sul fronte di salita!


Cycle 4: torna a Main1Cycle 4: torna a Main1BIPUSH

3ILOAD

jIADD

ISTOREi

-----------------Start cycle 4----------------------PC=PC+1;fetch;goto (MBR)PC: Put 0H: Put 0x0ALU: 0 + B + 1 = 0x1PC: Store 1PC: Fetch byte 1MEM: Fetch from byte# 0x1 requested. Processing...Goto MBR: 0x10

richiesta la lettura di


Salto a più vie: goto (MBR)Salto a più vie: goto (MBR)

� La prima microistruzione della microprocedura che interpreta una determinata istruzione IJVM è memorizzata nel control store a partire dalla posizione data dal suo opcode che la rappresenta

Main1 goto (MBR)

0x10 microcodice della BIPUSH ....

0x60 microcodice della IADD ....

0x64 microcodice della ISUB ....

Control store


Cycle 5: inizia la BIPUSHCycle 5: inizia la BIPUSHBIPUSH

3ILOAD

jIADD

ISTOREi

-----------------Start cycle 5----------------------SP=MAR=SP+1;goto 0x16SP: Put 0x8000H: Put 0x0ALU: 0 + B + 1 = 0x8001MAR: Store 0x8001SP: Store 0x8001MEM: Fetch value 0x3 from address 0x1MBR: Store 0x3Goto ADDR: 0x16

memorizzato sul fronte di salita!



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 6----------------------PC=PC+1;fetch;goto 0x17PC: Put 1H: Put 0x0ALU: 0 + B + 1 = 0x2PC: Store 2PC: Fetch byte 2MEM: Fetch from byte# 0x2 requested. Processing...Goto ADDR: 0x17

richiesta la lettura di



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 7----------------------TOS=MDR=MBR;wr;goto 0x2MBR: Put 0x3H: Put 0x0ALU: 0 OR B = 0x3MDR: Store 0x3TOS: Store 0x3MAR: Write to word 0x8001MDR: Write 0x3MEM: Write value 0x3 to word# 0x20004 requested. Processing...MEM: Fetch value 0x15 from address 0x2MBR: Store 0x15Goto ADDR: 0x2

nota: MBR conterra ̀l'opcodedi ILOAD solo alla fine di questociclo

durante il ciclo

Su display compareil valore memorizzatoa fine ciclo, durante ilfronte di salita delclock


PC = PC + 1; fetchPC = PC + 1; fetch

� bipush2 è la microistruzione “PC = PC + 1; fetch”

� per microinterpretare la bipush sarebbero sufficienti le microistruzioni bipush1 e bipush3 ma...

� l'obiettivo è di arrivare al Main1 con memorizzato in MBR l'opcode dell'istruzione successiva in modo da non dover “perdere tempo” attraverso la microistruzione nop1 come durante lo start-up: è importante precaricare MBR durante la microinterpretazione di una istruzione con l'opcode dell'istruzione successiva

� pc = pc + 1; fetch non potrebbe essere la prima istruzione (perderei l'operando della bipush) né l'ultima (non ci sarebbe il tempo di attendere l'opcode dalla memoria prima di andare nuovamente a Main1)


Cycle 8: torna a Main1Cycle 8: torna a Main1BIPUSH

3ILOAD

jIADD

ISTOREi

-----------------Start cycle 8----------------------PC=PC+1;fetch;goto (MBR)PC: Put 2H: Put 0x0ALU: 0 + B + 1 = 0x3PC: Store 3PC: Fetch byte 3MEM: Write value 0x3 to address 0x20004MEM: Fetch from byte# 0x3 requested. Processing...Goto MBR: 0x15

Nota: qui io salto a 0x15(attuale valore di MBR)e ho richiesto di caricareMBR (attendo il valore j)


Cycle 9: inizia la ILOADCycle 9: inizia la ILOADBIPUSH

3ILOAD

jIADD

ISTOREi

-----------------Start cycle 9----------------------H=LV;goto 0x18LV: Put 0xC000H: Put 0x0ALU: 0 OR B = 0xC000H: Store 0xC000MEM: Fetch value 0x1 from address 0x3MBR: Store 0x1Goto ADDR: 0x18

e ̀un offset! va sommatoa LV per recuperare ilvalore di j

a fine ciclo si hail valore di MBR dallamemoria



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 10----------------------MAR=H+MBRU;rd;goto 0x19MBR: Put 0x1H: Put 0xC000ALU: A + B = 0xC001MAR: Store 0xC001MAR: Read from word 0xC001MEM: Read from word# 0x30004 requested. Processing...Goto ADDR: 0x19

e ̀un offset! va sommatoa LV per recuperare ilvalore di j

MAR ora contienel'indirizzo di j e puo`quindi recuperarneil valore

MAR * 4!



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 11----------------------SP=MAR=SP+1;goto 0x1ASP: Put 0x8001H: Put 0xC000ALU: 0 + B + 1 = 0x8002MAR: Store 0x8002SP: Store 0x8002MDR: Read 0x0MEM: Read value 0x0 from address 0x30004Goto ADDR: 0x1A

In MDR, a fine ciclo,e ̀disponibile in valore di j

prepara lo spazio sul topdello stack per mettere ilvalore di MDR



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 12----------------------PC=PC+1;wr;fetch;goto 0x1BPC: Put 3H: Put 0xC000ALU: 0 + B + 1 = 0x4PC: Store 4PC: Fetch byte 4MAR: Write to word 0x8002MDR: Write 0x0MEM: Write value 0x0 to word# 0x20008 requested. Processing...MEM: Fetch from byte# 0x4 requested. Processing...Goto ADDR: 0x1B

Ordina il caricamento dellaprossima istruzione e lascrittura del valore in MDR sultop dello stack



3ILOAD

jIADD

ISTOREi

-----------------Start cycle 13----------------------TOS=MDR;goto 0x2MDR: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0TOS: Store 0x0MEM: Write value 0x0 to address 0x20008MEM: Fetch value 0x60 from address 0x4MBR: Store 0x60Goto ADDR: 0x2

Aggiorna il valore del registro TOS(Top Of the Stack) e torna al cicloprincipale (in MBR addento per fineciclo la prossima istruzione)

opcode di IADD


Cycle 14: torna al Main1Cycle 14: torna al Main1

-----------------Start cycle 14----------------------PC=PC+1;fetch;goto (MBR)PC: Put 4H: Put 0xC000ALU: 0 + B + 1 = 0x5PC: Store 5PC: Fetch byte 5MEM: Fetch from byte# 0x5 requested. Processing...Goto MBR: 0x60

richiede la prossimaistruzione

BIPUSH3

ILOADj

IADDISTORE

i


Cycle 15: inizia IADDCycle 15: inizia IADD

-----------------Start cycle 15----------------------SP=MAR=SP-1;rd;goto 0x3SP: Put 0x8002H: Put 0xC000ALU: NOT 0 + B = 0x8001MAR: Store 0x8001SP: Store 0x8001MAR: Read from word 0x8001MEM: Read from word# 0x20004 requested. Processing...MEM: Fetch value 0x36 from address 0x5MBR: Store 0x36Goto ADDR: 0x3

in MBR e ̀arrivatol'opcode di ISTORE

BIPUSH3

ILOADj

IADDISTORE

i

Richiede in memoria il valoredel top dello stack - 1 (il secondoaddendo, il primo e ̀gia ̀in TOS)


Cycle 16Cycle 16

-----------------Start cycle 16----------------------H=TOS;goto 0x4TOS: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0H: Store 0x0MDR: Read 0x3MEM: Read value 0x3 from address 0x20004Goto ADDR: 0x4

BIPUSH3

ILOADj

IADDISTORE

i

Sposta TOS in H mentre attende il secondo addendo che sara ̀inMDR a fine di questo ciclo

Il valore in top dellostack - 1


Cycle 17Cycle 17

-----------------Start cycle 17----------------------TOS=MDR=H+MDR;wr;goto 0x2MDR: Put 0x3H: Put 0x0ALU: A + B = 0x3MDR: Store 0x3TOS: Store 0x3MAR: Write to word 0x8001MDR: Write 0x3MEM: Write value 0x3 to word# 0x20004 requested. Processing...Goto ADDR: 0x2

BIPUSH3

ILOADj

IADDISTORE

i

Somma il valore in MDR a H, lorimette in MDR e ordina la scritturae quindi torna a Main1

Nota: MAR contenevagia ̀l'indice correttoper la memorizzazionedel risultato


Cycle 18: torna a Main1Cycle 18: torna a Main1

-----------------Start cycle 18----------------------PC=PC+1;fetch;goto (MBR)PC: Put 5H: Put 0x0ALU: 0 + B + 1 = 0x6PC: Store 6PC: Fetch byte 6MEM: Write value 0x3 to address 0x20004MEM: Fetch from byte# 0x6 requested. Processing...Goto MBR: 0x36

Richiede l'operando di ISTORE esalta al suo codice

BIPUSH3

ILOADj

IADDISTORE

i


Cycle 19: inizia ISTORECycle 19: inizia ISTORE

-----------------Start cycle 19----------------------H=LV;goto 0x1CLV: Put 0xC000H: Put 0x0ALU: 0 OR B = 0xC000H: Store 0xC000MEM: Fetch value 0x0 from address 0x6MBR: Store 0x0Goto ADDR: 0x1C

Mi preparo a sommare a LV l'offsetche sto attendendo per la fine diquesto ciclo

BIPUSH3

ILOADj

IADDISTORE

i

A fine ciclo e ̀arrivatol'offset della variabile i


Cycle 20Cycle 20

-----------------Start cycle 20----------------------MAR=H+MBRU;goto 0x1DMBR: Put 0x0H: Put 0xC000ALU: A + B = 0xC000MAR: Store 0xC000Goto ADDR: 0x1D

Sommo a H (base del record di attivazione) il valore dell'offsetdella variabile i

BIPUSH3

ILOADj

IADDISTORE

i


Cycle 21Cycle 21

-----------------Start cycle 21----------------------MDR=TOS;wr;goto 0x1ETOS: Put 0x3H: Put 0xC000ALU: 0 OR B = 0x3MDR: Store 0x3MAR: Write to word 0xC000MDR: Write 0x3MEM: Write value 0x3 to word# 0x30000 requested. Processing...Goto ADDR: 0x1E

Preparo in MDR il valore dascrivere nella variabile i, quindirichiedo la scrittura

BIPUSH3

ILOADj

IADDISTORE

i

Nota: TOS mi fa risparmiarequi una lettura in memoria!


Cycle 22Cycle 22

-----------------Start cycle 22----------------------SP=MAR=SP-1;rd;goto 0x1FSP: Put 0x8001H: Put 0xC000ALU: NOT 0 + B = 0x8000MAR: Store 0x8000SP: Store 0x8000MAR: Read from word 0x8000MEM: Write value 0x3 to address 0x30000MEM: Read from word# 0x20000 requested. Processing...Goto ADDR: 0x1F

Richiedo in memoria il nuovo valoredel top dello stack

BIPUSH3

ILOADj

IADDISTORE

i

L'ALU fa semplicementepassare non modificato il valore


Cycle 23Cycle 23

-----------------Start cycle 23----------------------PC=PC+1;fetch;goto 0x20PC: Put 6H: Put 0xC000ALU: 0 + B + 1 = 0x7PC: Store 7PC: Fetch byte 7MDR: Read 0x0MEM: Read value 0x0 from address 0x20000MEM: Fetch from byte# 0x7 requested. Processing...Goto ADDR: 0x20

Carico il prossimo opcode mentreattendo che il valore richiesto in memoria arrivi alla fine di questo ciclo

BIPUSH3

ILOADj

IADDISTORE

i...


Cycle 24Cycle 24

-----------------Start cycle 24----------------------TOS=MDR;goto 0x2MDR: Put 0x0H: Put 0xC000ALU: 0 OR B = 0x0TOS: Store 0x0MEM: Fetch value 0x0 from address 0x7MBR: Store 0x0Goto ADDR: 0x2

Salvo il valore del top dello stackattuale in TOS e torno a Main1

BIPUSH3

ILOADj

IADDISTORE

i...


Cycle 25Cycle 25

-----------------Start cycle 25----------------------PC=PC+1;fetch;goto (MBR)PC: Put 7H: Put 0xC000ALU: 0 + B + 1 = 0x8PC: Store 8PC: Fetch byte 8MEM: Fetch from byte# 0x8 requested. Processing...Goto MBR: 0x0

Parte per nuove frontiere... di microinterpretazione!!

BIPUSH3

ILOADj

IADDISTORE

i...


Il microprogramma Mic-1Il microprogramma Mic-1

� Main1: microistruzione che si occupa di effettuare un salto multiplo alla parte di microprogramma che microinterpreta le varie istruzioni del livello ISA

� NOP: nessuna operazione



� IADD: pop di due parole dallo stack; push della loro somma

� ISUB: pop due parole dallo stack; push la loro differenza

� IAND: pop di due parole dallo stack; push dell'AND logico

� IOR: pop di due parole dallo stack; push dell'OR logico


Il microprogramma Mic-1Il microprogramma Mic-1� DUP: copia della prima parola sullo stack e push

� POP: cancella una parola

� SWAP: scambia le due parole in cima allo stack

� BIPUSH byte: push di un byte sullo stack



� ILOAD varnum: push di una variabile locale sullo stack

� ISTORE varnum: pop una parola dallo stack; push la loro differenza

� IINC varnum const: somma una costante a una variabile locale



� WIDE: prefisso; l'istruzione seguente ha un indirizzo di 16 bit



� LDCW index: push di una costante dalla constant pool sullo stack

� Analoga allaILOAD ma:

� carica dal constant pool

� usa un offset di 16 bit


Il microprogramma Mic-1Il microprogramma Mic-1� GOTO offset: branch non condizionato

L'offset e ̀relativo all'istruzione di GOTO, quindi devo prelevare tale indirizzo, il microprogrammasalta a questa microproceduraabbiamo gia ̀ordinato la lettura del prossimo byte (che sara ̀disponibile a fine di questa istruzione)

offset con segno!



� IFEQ offset: pop di una parola e branch se e ̀zero

� IFLT offset: pop di una parola e branch se e ̀negativa

passa nell'ALU senzaessere memorizzata(attiva solo l'opportunobit di controllo)

stesso di goto1



� IFICMPEQ offset: pop di due parole dallo stack; branch se sono uguali



� INVOKEVIRTUAL disp: chiama un metodo

2 byte!


Dettaglio della INVOKEVIRTUALDettaglio della INVOKEVIRTUAL

...

SP

LV

objrefpar1par2

disp e ̀memorizzatosu due byte, carica ilsecondo byte, il primosara ̀disponibile allafine di questo ciclo



...

SP

LV

objrefpar1par2

In H e ̀ora presentedisp, si carica quindiil valore dallamemoria con offset disp nel constant pool



...

SP

LV

objrefpar1par2

In OPC abbiamo l'indirizzodi ritorno (l'istruzionesuccessiva al valoredi disp appena caricato



...

SP

LV

objrefpar1par2

I primi due byte delcodice del metodocontiene l'indicazionedel numero di parametriche viene caricato nel registro H (compresoobjref!), nel nostro caso 3



...

SP

LV

objrefpar1par2

I secondi due byte contengono il numero diparametri locali, siincomincia a caricare ilprimo byte



...

SP

LV

objrefpar1par2

I secondi due byte contengono il numero diparametri locali, siincomincia a caricare ilprimo byte

SP-3SP-3+1



...

SP

LV

objrefpar1par2

I secondi due byte contengono il numero diparametri locali, sicarica il secondo, quindisi pone il risultato nelregistro H, nel nostro caso 1

loc1

MAR



...

SP

LV

SP+1+1par1par2

I secondi due byte contengono il numero diparametri locali, sicarica il secondo, quindisi pone il risultato nelregistro H, nel nostro caso 1

loc1SP+1+1

MAR

MDR



...LV

linkpar1par2

Viene salvato l'indirizzodi ritorno sopra le variabililocali che era statomemorizzato su OPC

loc1ind ritorno SP

MDR

MAR



...LV

linkpar1par2

Viene salvato il basepointer del metodochiamante

loc1ind ritorno

SPMAR

LV



...LV

linkpar1par2

Si carica l'opcodesuccessivo, vienefatto ora perche ̀siadisponibile alla finedella prossima micro-istruzione per andarepoi a Main1

loc1ind ritorno

SPMAR

LV



...

LVlinkpar1par2

Viene aggiornato il base pointeralla base delnuovo recod diattivazione e si puo`procedere per lamicrointerpretazionedel codice del metodo

loc1ind ritorno

SPMAR

LV


Il microprogramma Mic-1Il microprogramma Mic-1� IRETURN: ritorno da un metodo con un valore intero


IRETURN: dettaglioIRETURN: dettaglio

...

LVlinkpar1par2loc1

ind ritorno

SPLV

Sul top dello stack c'e ̀ilvalore di ritorno calcolatodal metodo

valore rit.



...

LVlinkpar1par2loc1

ind ritorno

SP

LV

Si ripristina lo stackpointer alla base delloattuale record diattivazione e si carica l'indirizzo che puntaall'indirizzo di ritorno

valore rit.

MAR



...

LV

linkpar1par2loc1

ind ritorno

SP

LV

Carica l'indirizzodi ritorno in MDR

valore rit.

MARMDR



...

LV

linkpar1par2loc1

ind ritorno

SP

LV

Carica in PC l'indirizzodi ritorno e leggel'opcode cosi ̀puntato,legge il vecchio basepointer che si trovasopra l'indirizzo diritorno e prepara lascrittura sul top dellostack del vare di ritorno

valore rit.

MAR



...LV

linkpar1par2loc1

ind ritorno

SP

LV

Ripristina il vecchiovalore di LV

valore rit.

MAR



...LV

valore rit SP

Mette sul top dellostack il valore diritorno del metodoche era stato memorizzatosu TOS e torna quindi aMain1 (in MBR ho gia`il nuovo opcode)

MAR

Documents

Corso di MAL (Micro Assembly Language) Architettura degli