Riassunto Architettura dei calcolatori elettronici

A*M(Y));

• DIV,0,Y – divide il contenuto dell'accumulatore con il valore di indirizzo Y

(A←A/M(Y)); 2

8

• ALS,0,Y –shift di una posizione a sinistra del valore

contenuto nell'accumulatore (A ← A*2);

• ARS,0,Y - shift di una posizione a destra del valore contenuto nell'accumulatore

(A←[A/2]);

• NEG,-,- - cambia il segno del dato contenuto nell'accumulatore (A ← -A). Accesso alla

Memoria

• LDA,0,Y – carica il contenuto della posizione di indirizzo Y nell'accumulatore

(A←M(Y));

• STA,0,Y – carica il contenuto dell'accumulatore in RAM all'indirizzo Y(M(Y) ←A).

Controllo di Flusso

• JUMP,0,Y – esegue l'istruzione del programma corrente all'indirizzo Y (salto

condizionato: PC

• ← Y);

• JZA,0,Y–comeJUMP,ma solo se l'accumulatore contiene “0” (salto condizionato:

IFA=0PC ← Y);

• JPA,0,Y – come JUMP, ma solo se l'accumulatore contiene un valore maggiore di 0

(salto condizionato: IF A>0 PC ←-1);

• JNA,0,Y – come JUMP, ma solo se l'accumulatore contiene un valore minore di 0 (salto

condizionato: IF A<0 PC ←-1);

• HLT,0,0 – arresto dell'elaborazione (PC ←-1).

• Set di Istruzioni RAM

• LOAD – carica dalla memoria in accumulatore (R0) STORE – salva il contenuto di R0

in memoria

• ADD, SUB, MULT, DIV – operazioni di somma, sottrazione, moltiplicazione e divisione

• READ – legge un dato in input WRITE – scrive un dato in output JUMP –

salto non condizionato

• JGTZ – salto se l'accumulatore contiene un valore maggiore di “0” JZERO – salto

se l'accumulatore contiene il valore“0”

• HALT – termine del programma

Microsequenze

L’esecuzione di istruzioni di programma comporta una sequenza di trasferimenti di informazioni tra

gli elementi di memoria. Le specifiche delle attività identificabili, a livello hardware, che realizzano

tali trasferimenti/elaborazioni di informazioni sono dette microsequenze.

L'esecuzione si realizza in due fasi: fetch e execute. Nella fase FETCH l'istruzione indicata dal

2

9

Program Counter viene importata dalla ram e in quella EXECUTE viene eseguita. Mentre la prima

è identica per ogni tipo di istruzione, la seconda varia in funzione dell'istruzione stessa.

La fase FETCH si sviluppa a sua volta in due momenti: nel primo l'indirizzo contenuto nel P.C.

viene posto nel bus indirizzi permettendo alla CPU di identificare la cella di memoria

contenente l'istruzione da eseguire; nel secondo i dati vengono inseriti nel bus e trasferiti nel

Registro Istruzioni della CPU (I.R.). Il decodificatore di istruzioni provvede alla decodifica

permettendo alla logica di controllo di generare i segnali necessari per eseguire effettivamente

l'istruzione. Durante questa fase il contenuto del P.C. viene aggiornato per passare all’istruzione

successiva. Questa pratica viene chiamata Address Modification e consente alle istruzioni (con

codice operativo LDA, STA, ADD, SUB, MUL e DIV) di indicizzare gli indirizzi di memoria

attraverso i contenuti dei registri R0-R7 (per default il contenuto di R0 è sempre 0).

Architettura MIPS

Un’architettura di tipo differente, che più si adatta a descrivere i modelli di architetture attuali, è

un’architettura di tipo MIPS. L’architettura MIPS

(Microprocessor without Interlocked Pipeline Stages) viene progettata nei prim ianni ’80 e prodotta

da MIPS Technologies negli anni’90. Mentre l’architettura di Von Neumann era formata da 8

registri di CPU, l’architettura MIPS ha 32 registri di CPU da 32 bit e come per l’architettura vista in

precedenza il registro zero contiene sempre 0. Per denotare i registri si usano nomi simbolici

preceduti da $. Alcuni registri sono riservati: 3

0

I registri della RAM dell’architettura MIPS sono formati da 32 bit per l’indirizzo del registro e 32

bit (4 byte contigui) per i dati. Inoltre supporta la codifica in virgola mobile con singola e doppia

precisione (rispettivamente 32 bit e 64 bit). Ulteriore differenza con l’architettura semplificata è che

supporta molte più istruzioni, divise in tre formati.

Istruzioni in formato R

Formato per le operazioni algebriche R:

• add $1, $2, $3 – somma il contenuto dei registri 2 e 3 e salva il risultato nel registro 1;

• sub $1, $2, $3 – sottrae il contenuto del registro 3 dal contenuto del registro 2 e salva il

risultato nel registro 1;

• slt $1, $2, $3 – predispone un salto condizionato settando il registro 1 se il contenuto del

registro 2 è minore del contenuto del registro 3, altrimenti effettua il reset del registro 1.

Istruzioni in formato I

• Formato per le istruzioni di salto condizionato e di trasferimento dati dalla RAM e dai

registri CPU. I dati a 32 bit sono divisi in 4 campi:

• lw $1, 100($2) – (load word) salva il contenuto della locazione di memoria di indirizzo

100+

• $2 nel registro 1;

• sw $1, 100($2) – (store word) salva il contenuto del registro 1 nella locazione di

memoria di indirizzo 100 +$2;

• beq $1, $2, L – salta all’istruzione con etichetta L se I contenti dei registry 1 e 2 sono

uguali;

• bne $1 , $2, L – salta all’istruzione con etichetta L se I contenuti dei registry 1 e 2 sono

distinti.

Istruzioni in formato J

Formato per le istruzioni di salto non condizionato. I dati a 32 bit sono divisi in 2 soli campi:

-- OP;

-- ADDRESS. Esempi di Istruzioni 3

1

Formato R

add $1,$2,$3

Salva nel registro 1 la somma dei contenuti dei registri 2 e 3.

mul $1,$2,$3

Salva nel registro 1 il prodotto dei contenuti dei registri 2 e 3.

Formato I

beq $1,$2,L1

Va all'istruzione con etichetta L1 se i contenuti dei registri 2 e 3 sono uguali.

bne $1,$2,L1

Va all'istruzione con etichetta L1 se i contenuti dei registri 2 e 3 sono diversi.

Formato J

j L

Salta all'istruzione con etichetta L.

Allocazione di Memoria

La memoria di un programma MIPS viene suddivisa in segmenti, ognuno dei quali viene utilizzato

per un particolare scopo. Quelli principali sono:

I. segmento testa: è collocato nella zona inferiore, contiene I codici dei programmi

II. segmento dati: contiene i dati globali dei programmi ed è suddiviso in dati statici, contenenti

strutture dati e dati dinamici, allocati durante l'esecuzione

III. segmento stack: è collocato nella zona superiore e contiene i dati locali delle funzioni 3

2

Le dimensioni delle aree di memoria riservate ai dati dinamici posso arrivare a occupare tutto lo

spazio libero, motivo per cui è difficile dimensionarle a priori.

Convenzioni di Utilizzo dei Registri

Le convenzioni sull'utilizzo dei registri sono seguite (e definite) dai programmatori di comune

accordo, con lo scopo di standardizzare nomi e funzioni attribuiti a determinati registri:

• I registri $at($1), $k0($26) e $k1($27) sono riservati all’ assemblatore ed al sistema

operativo e non andrebbero mai usati dai programmi

• I registri $a0-$a3($4-$7) sono usati per passare fino a quattro argomenti ad un

sottoprogramma

• I registri $v0 e $v1 ($2 e $3) sono usati per restituire argomenti al programma chiamante

• I registri $t0-$t9 ($8-$15 ed $24-$25) sono di salvataggio temporaneo

• I registri$s0-$s7 ($16e$23) sono di salvataggio permanente e servono per memorizzare

dati la cui vita non èlimitata

• Il registro $gp ($28) è un puntatore globale che fa riferimento ad un blocco di memoria

da 64 K

• Il registro $sp ($29) è il puntatore allo stack e fa riferimento alla prima cella libera

• Il registro $fp ($30) è il puntatore all’ area di attivazione di procedura

• Il registro $ra ($31) viene aggiornato in modo da contenere l’indirizzo di rientro

I/O MIPS

Il programma MIPS accede a due unità di ingresso uscita, un’unità di ricezione che legge i caratteri

introdotti da tastiera ed una di trasmissione che scrive caratteri sullo schermo. Le operazioni di

ingresso/uscita sono gestite dal sistema operativo i cui contenuti sono allocati in memoria

principale. Attraverso l’utilizzo di un programma si possono leggere i caratteri inseriti dall’utente e

visualizzare eventuali uscite sulla finestra di console. Si usano chiamate di sistema (syscall) per

scrivere su o leggere da console. Il programma deve caricare il codice della chiamata di sistema nel

registro $v0 e gli argomenti nei registri $a0-$a3. Le chiamate di sistema che forniscono un valore in

uscita mettono il risultato in $v0, e se si usano le chiamate di sistema occorre disabilitare l’opzione

3

3

mapped I/O. Esempio di traduzione Assembler MIPS

Procedura in C:

int power (int base, int

n) { int i, p;

i = 0; p = 1;

while (i < n) {

p = p *

base; i = i

+ 1;

}

}

Procedura in Assembler

Assumiamo: $a0 = base; $a1 = n; $t0 = i;

$t1 = flag; $s0 = p

Salvataggio registri: 3

4

sub $sp, $sp, 12

sw $s0, 0($sp)

sw $t1, 4($sp)

sw $t0, 8($sp)

add $t0, $0, $0

addi $s0, $0, 1

Corpo del programma:

LOOP:

slt $t1, $t0, $a1 # i >= n esco dal ciclo

beq $t1, $0, EXIT

mul $s0, $s0, $a0

# p = p * base;

addi $t0, $t0, 1 # i = i + 1;

j LOOP

EXIT:

add $v0, $s0, $0 # p nel registro di ritorno

lw $s0, 0($sp)

# ripristino dei registri l w $t1, 4($sp) lw

$t0, 8($sp) add

$sp, $sp, 12 jr,

$ra Planimetria MIPS

La planimetria MIPS consiste di PC, memoria istruzioni, ALU, CU (separata dall'ALU), banco

registri e memoria dati.

L’istruzione [31-26] è l’input della CU e rappresenta il campo a 6 bit che contiene il codice

operativo.

L’istruzione [25-21] rappresenta il registro sorgente RS per le istruzioni in formato R e per le

istruzioni beq (branch on equal) e sw (store word) e rappresenta il registro di base per le istruzioni

lw (load word) e sw.

L’istruzione [20-16] rappresenta il registro sorgente RT per le istruzioni in formato R e per le

3

5

istruzioni beq e sw e, inoltre, rappresenta il registro destinazione dell’istruzione lw.

L’istruzione [15-11] rappresenta il registro destinazione RD per le istruzioni in formato R.

L’istruzione [15-0] rappresenta l’offset per le istruzioni beq, lw e sw. L’offset è detto anche

spaziamento ed è dato dalla costante nell’istruzione di trasferimento moltiplicata per quattro (ciò

perché nell’architettura MIPS vige il vincolo di allineamento: le parole devono iniziare con indirizzi

multipli di quattro). Per ottenere l’