Appunti Architettura degli elaboratori 2

OBJREF;

OBJREF viene indicato come costante nel caso in cui si vuole utilizzare una

costante che è stata definita in precedenza nel programma

ad esempio se si vuole utilizzare una costante k il cui valore è già stato definito nel

programma le costanti del programma IJVM saranno 20

CONSTANT

OBJREF 0x40 (0x40 è a caso ma rappresenta l’indirizzo che contiene il valore di k)

K

END-CONSTANT

…

Successivamente il chiamante inserisce sullo stack i parametri del metodo che , in

questo caso, sono parametro 1 parametro 2 e parametro 3

Infine viene eseguita l’istruzione INVOKEVIRTUAL

Quest’istruzione include uno spiazzamento che indica una posizione all’interno della

porzione costante di memoria che contiene l’indirizzo dell’area dei metodi in cui

inizia il metodo che si sta invocando; tuttavia i primi 4 byte nell’area dei metodi

contengono dati speciali, i primi 2 sono interpretati come un intero a 16 bit che

indica il numero di parametri del metodo; in questo conteggio OBJREF viene

considerato come un parametro, parametro 0

Questo intero a 16 bit fornisce insieme al valore di SP, la locazione di OBJREF

LV punta a OBJREF invece che al primo parametro

Anche i successivi 2 byte dell’area dei metodi sono interpretati come un intero a 16

bit, che però indica la dimensione del blocco delle variabili locali per il metodo

invocato

Infine il quinto byte dell’area dei metodi contiene il primo codice operativo da

eseguire 21

Nella figura soprastante viene rappresentata l'effettiva sequenza di operazioni che si

verificano quando viene eseguita l’istruzione INVOKEVIRTUAL

I 2 byte senza segno che seguono il codice operativo sono utilizzati per costruire un

indice relativo alla porzione costante di memoria

L’istruzione calcola l’indirizzo base del nuovo blocco delle variabili locali sottraendo il

numero di parametri dal puntatore allo stack e impostando LV in modo che punti a

OBJREF;

In questa locazione sovrascrivendo OBJREF viene memorizzato l’indirizzo della

locazione in cui si trova il vecchio PC

Questo indirizzo è calcolato sommando la dimensione del blocco delle variabili locali

all’indirizzo contenuto in LV

Sopra l’indirizzo in cui memorizzare il vecchio PC c’è l’indirizzo in cui deve essere

memorizzato il vecchio LV; al di sopra di questo indirizzo inizia lo stack per la

procedura che è stata appena richiamata

Se lo stack è vuoto allora punta alla prima locazione sotto la fine dello stack 22

L’ultima operazione richiesta per terminare l’esecuzione di INVOKEVIRTUAL è

impostare PC in modo che punti al quinto byte nell’area del codice del metodo

L’istruzione IRETURN inverte la sequenza delle operazioni compiute da

INVOKEVIRTUAL, essa dealloca lo spazio utilizzato dal metodo che sta restituendo

il controllo e riporta lo stack nel suo precedente stato, tranne per il fatto che la

parola OBJREF e tutti parametri sono estratti dallo stack e che il valore restituito dal

metodo è stato inserito in cima allo stack nella locazione occupata precedentemente

da OBJREF;

Per memorizzare il vecchio stato l’istruzione IRETURN deve essere in grado di

riportare i puntatori PC e LV ai loro precedenti valori

Per fare ciò accede al puntatore di collegamento (link pointer) ovvero alla parola

identificata dal puntatore LV corrente

Questa parola e quella presente al di sopra vengono recuperate e utilizzate per

restituire a PC e a LV i loro precedenti valori

Il valore fornito dal metodo memorizzato OBJERF e SP viene reinpostato in modo

da puntare a questa locazione. 23

//Chiamate di procedura IJVM in MIC-1

1.​ Il codice del metodo chiamante (solitamente main) carica sullo stack una

costante che ha un ruolo di “place order” per il primo elemento del record di

attivazione (destinato a memorizzare il puntatore alle celle dove sono salvati i

valori di PC e LV)

2.​ Il codice del metodo chiamata carica sullo stack i parametri attuali della

chiamata

3.​ Il codice del metodo chiamante invoca l’istruzione INVOKEVIRTUAL la cui

esecuzione realizza la fase di prologo (alloca lo spazio per la memorizzazione

delle variabili locali e salva le informazioni necessarie per riprendere

l’esecuzione del chiamante dopo il termine dal metodo (ovvero SP e LV)

4.​ Al termine dell’esecuzione del codice del metodo chiamato invoca l’istruzione

IRETURN (la cui esecuzione realizza la fase di epilogo della chiamata) che

ripristina lo stack (mettendo in cima il risultato del metodo) ed i valori di PC e

LV del chiamante precedentemente salvati 24

//Compilazione da java a IJVM

(non so se serve)

Nella figura è presente come appare un codice in java(a), in java assemblativo (b) e

in IJVM esadecimale(c)

Inizialmente j e k vengono inseriti in cima allo stack, vengono sommati e il risultato

viene memorizzato in i

Successivamente i e la costante 3 vengono messi nello stack e confrontati; se sono

uguali si effettua una diramazione che porta in LI, dove k è impostato al valore 0; se

invece sono differenti il test da esito negativo e viene eseguito il codice che segue

l’istruzione IF_ICMEQ

Dopo alcune istruzioni si effettua una diramazione che porta in L2, ovvero nel punto

in cui i rami then e else si riuniscono 25

Nella figura è mostrato come varia lo stack degli operandi durante l’esecuzione del

programma IJVM precedente:

Prima che cominci l’esecuzione del codice lo stack è vuoto

Dopo la prima istruzione ILOAD, j si trova sullo stack

Dopo la seconda istruzione ILOAD nello stack ci sono 2 parole

Dopo l’istruzione IADD nello stack c’è soltanto una parola che contiene la somma

j+k

Quando la parola in cima allo stack viene estratta e memorizzata in i lo stack è

vuoto

L’istruzione 5, ILOAD, inizia il costrutto if inserendo i nello stack (in 5)

Successivamente (in 6) arriva la costante 3

Dopo il confronto lo stack è nuovamente vuoto (7)

L’istruzione 8 rappresenta l’inizio del ramo else del frammento di programma java

La parte else continua fino all’istruzione 12, punto in cui c’è la diramazione che porta

a L2 e che permette di saltare il codice relativo a then

//

quando si vuole sapere cosa contengono i primi 6 byte di un metodo IJVM:

-​ i primi 3 byte contengono i parametri+objref

-​ 2 byte contengono le 2 variabili ( se non presenti entrambi nulli)

-​ 2 byte per la codifica della prima istruzione del metodo con un offset di 1 se è

un istruzione che utilizza un parametro/una variabile

Es: 26

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//Microistruzioni e notazione

Come nei linguaggi di programmazione è molto vantaggioso introdurre una

notazione che esprime l’essenza dei problemi da trattare e lasciare che i dettagli

vengano gestiti in automatico.

L'obiettivo, oltre ad essere quello di illustrare i concetti del linguaggio, è quello di

definire un’ implementazione veloce dove ogni ciclo ha importanza; risparmiare cicli

ha un importante impatto sulle prestazioni.

Si suppone che in un ciclo si voglia incrementare il valore di SP ed oltre a dare inizio

ad un'operazione di lettura si vuole che l’istruzione successiva sia quella che risiede

nella locazione 122 della memoria di controllo

ReadRegister=SP,ALU=INC,WSP,Read;NEXT_ADDRESS=122

dove WSP significa scrivere il registro SP; Questa notazione è completa ma è

difficile da leggere, quindi è preferibile combinare le operazioni in modo naturale e

intuitivo

SP=SP+1;rd

Questo linguaggio è chiamato Micro Assembly Language, MAL; è definito per

rispecchiare le caratteristiche della microarchitettura

Durante ogni ciclo è possibile scrivere qualsiasi registro, anche se di norma ne

viene scritto solo uno, soltanto un registro può essere collegato al lato B della ALU

mentre sul lato A le scelte possibili sono +1,0,-1 e il registro H

Inoltre è possibile usare un semplice costrutto di assegnamento, come in java, per

indicare l’operazione da eseguire

per copiare un dato da SP a MDR

MDR=SP

per indicare che si intende utilizzare funzioni della ALU diverse dal semplice

passaggio verso il bus B 27

MDR=H+SP

che somma il contenuto del registro H a SP e scrive il risultato in MDR

L’operatore + è commutativo, quindi l’istruzione può essere scritta anche:

MDR=SP+H

Bisogna fare attenzione ad utilizzare delle operazioni lecite, le più importanti sono

elencate nella tabella sottostante

SOURCE indica il registro in cui è contenuto il dato che può essere: MDR, PC,

MBR, MBRU, SP, LV, CPP, TOS, OPC

DEST indica il registro di destinazione che può essere:

MAR, MDR, PC, SP, LV, CPP, TOS, OPC e H

Registri importanti

TOS: contiene il valore puntato da SP all’inizio e alla fine dell’istruzione, in alcuni

casi come per l’operazione POP richiede molte operazioni, può essere utilizzato

come destinazione dei valori in uscita dalla ALU 28

OPC: si utilizza come registro temporaneo per salvare l’opcode delle istruzioni di

diramazione per esempio quando il PC viene incrementato

LV: punta alla base del record di attivazione della funzione attiva. Subito sotto vi è il

record di attivazione della funzione chiamante ed è il registro implicito del blocco

delle variabili

SP: punta in cima allo stack ed è il registro implicito dello stack degli operandi

MAR: contiene l’indirizzo della memoria in cui si vuole leggere o scrivere

MDR: ospita la parola letta-da scrivere

MBR: contiene il byte letto

MBRU: è la versione di MBR senza segno (quindi consente di memorizzare

solamente numeri positivi)

Questo formato è insidioso visto che esistono costrutti apparentemente corretti ma

in realtà sbagliati;

per esempio

MDR=SP+MDR

non può in alcun modo essere eseguito in un unico ciclo sul percorso dati,

restrizione causata dal fatto che in un’addizione (apparte per l’incremento) uno degli

operandi deve essere il registro H

Analogamente

H=H-MDR

dato che l’unica sorgente per il sottraendo è il registro H

La notazione MAL consente assegnamenti multipli

per esempio per sommare 1 a SP, memorizzare il risultato nuovamente in SP e

scriverlo anche all’interno di MDR

SP=MDR=SP+1 29

Per indicare letture e scritture di parole di dati da 4 byte si andrà ad aggiungere rd e

wr nella microistruzione

Il prelievo di un byte attraverso la porta a 1 byte si indica con fetch

Gli assegnamenti e le operazioni della memoria possono svolgersi durante lo stesso

ciclo, il che è indicato scrivendoli