calcolatori elettronici (biasi - narracci - albano)

7/23/2019 Calcolatori Elettronici (Biasi - Narracci - Albano)

1/216


2/216

i

Autori:

Albano Teodoro, Luigi Biasi, Giuseppe Narracci

Titolo Originale:

Calcolatori Elettronici, 1a edizione 2012

opyrightC 2012Tutti i diritti sono riservati a norma di legge e a norma delle convenzioni

internazionali. Nessuna parte di questo libro pu essere riprodotta consistemi elettronici, meccanici o altri, senza lautorizzazione degli autori.


3/216

ii

Nessun calcolatore 9000 ha mai commesso un errore o alterato uninformazione.

Noi siamo, senza possibili eccezioni di sorta, a prova di errore, e incapaci

di sbagliare. (CALCOLATORE HAL 9000)

2001: Odissea nello spazio


4/216

iii


5/216

iv

Sommario

CAPITOLO 1

LA VALUTAZIONE DELLE PRESTAZIONI DI UN PROCESSORE .............................................................................. 1

1. Filosofia Risc E Cisc................................................................................................................................ 2

2. La Legge Di Amdahl............................................................................................................................... 3

CAPITOLO 2

CARATTERISTICHE DELLE ISTRUZIONI DI UN CALCOLATORE ............................................................................. 7

1. Ciclo Istruzione...................................................................................................................................... 7

2. Categorie Di Formati Istruzione............................................................................................................ 8

3. Struttura Dell'istruzione....................................................................................................................... 8

CAPITOLO 3

CLASSIFICAZIONE DEI PROCESSORI ................................................................................................................... 9

1. Classificazione per istruzione............................................................................................................... 9

2. Classificazione per parola..................................................................................................................... 9

3. Classificazione per la gestione della memoria interna...................................................................... 10

4. Classificazione per modi di indirizzamento........................................................................................ 16

CAPITOLO 4

MODI DI INDIRIZZAMENTO ............................................................................................................................. 17

1. Indirizzamento Diretto........................................................................................................................ 172. Indirizzamento con Immediato.......................................................................................................... 17

3. Indirizzamento con Scostamento (displaycement)........................................................................... 18

4. Indirizzamento con registro auto-incrementato o auto-decrementato........................................... 19

5. Indirizzamento per le operazioni di salto........................................................................................... 22

6. Operazioni Nellinsieme Di Istruzioni................................................................................................. 26

CAPITOLO 5

ISTRUZIONI DEL PROCESSORE MIPS ................................................................................................................ 29

1. Istruzioni di tipo J................................................................................................................................ 29

2. Istruzioni di tipo R............................................................................................................................... 30

3. Istruzioni di tipo I................................................................................................................................ 30

4. Le istruzioni del calcolatore MIPS...................................................................................................... 31

4.1. Istruzioni di trasferimento dati.................................................................................................. 31

4.2. Istruzioni per operazioni logico-aritmetiche.............................................................................. 33

4.3. Istruzioni di controllo.................................................................................................................. 36

Esercizi ......................................................................................................................................................... 39


6/216

v

CAPITOLO 6

ARCHITETTURA CALCOLATORE PER LE OPERAZIONI CON DATI INTERI ........................................................... 41

1. Fasi Di Una Istruzione......................................................................................................................... 41

2. Architettura Calcolatore Per La Gestione Di Dati Interi.................................................................... 42

2.1. Istruzione Di Tipo R..................................................................................................................... 45

2.2. Istruzione di tipo I....................................................................................................................... 45

3. Meccanismo Di Funzionamento Interno Dell'ALU:............................................................................ 50

CAPITOLO 7

LA PIPELINE ...................................................................................................................................................... 53

1. Introduzione alla Pipeline................................................................................................................... 53

2. Architettura Pipeline........................................................................................................................... 57

2.1. La Tipica Vita Di Unistruzione In Pipeline.............................................................................. 60

3. Microcodice o Microistruzioni............................................................................................................ 61

3.1. IF (ISTRUCTION FETCH)............................................................................................................... 62

3.2. ID (ISTRUCTION DECODE)........................................................................................................... 63

3.3. EX (EXECUTE)............................................................................................................................... 64

3.4. MEM............................................................................................................................................ 65

3.5. WB............................................................................................................................................... 65

CAPITOLO 8

PRESTAZIONI PROCESSORE PIPELINE .............................................................................................................. 67

1. Miglioramento prestazioni: super pipeline........................................................................................ 67

2. Miglioramento prestazioni: parallelismo........................................................................................... 68

CAPITOLO 9

CONFLITTI NELLA PIPELINE .............................................................................................................................. 71

1. Conflitti di Dato................................................................................................................................... 72

2. Conflitti sulle Diramazioni.................................................................................................................. 79

Esercizi ......................................................................................................................................................... 87

CAPITOLO 10

IL COSTO DI UN CIRCUITO INTEGRATO ........................................................................................................... 95

1. La progettazione................................................................................................................................. 95

2. La produzione...................................................................................................................................... 96

CAPITOLO 11

IL PROCESSORE FLOATING POINT

1. Operazioni Floating Point................................................................................................................... 99


7/216

vi

1.1. Addizione................................................................................................................................... 100

1.2. Moltiplicazione.......................................................................................................................... 101

2. Architettura Processore Floating Point............................................................................................ 101

CAPITOLO 12

GERARCHIA DI MEMORIA .............................................................................................................................. 109

1. Panoramica sulle memorie............................................................................................................... 109

2. Principi generali................................................................................................................................ 111

CAPITOLO 13

MEMORIA CACHE

1. Cenni storici sulle memorie cache.................................................................................................... 115

2. Strategie di allocazione dei blocchi.................................................................................................. 115

2.1. Memoria Completamente Associativa..................................................................................... 116

2.2. Indirizzamento Diretto.............................................................................................................. 116

2.3. Set Associativa.......................................................................................................................... 116

3. Strategia di ricerca e identificazione del blocco.............................................................................. 116

4. Sostituzione di un blocco.................................................................................................................. 117

5. Scrittura e lettura di un blocco......................................................................................................... 118

CAPITOLO 14

PRESTAZIONI DELLA CACHE ........................................................................................................................... 123

1. Analisi delle prestazioni della cache................................................................................................ 123

2. Cache dal punto di vista tecnologico................................................................................................ 125

2.1. Memoria statica SRAM............................................................................................................. 125

2.2. Memoria dinamica DRAM........................................................................................................ 125

3. Dimensionamento della memoria dal punto di vista del tempo.................................................... 125

CAPITOLO 15

STRUTTURA ELETTRONICA DELLA CACHE ...................................................................................................... 127

1. Analisi elettronica della cache.......................................................................................................... 128

2. Struttura delle memorie................................................................................................................... 132

Esercizi ....................................................................................................................................................... 133

CAPITOLO 16

DIVERSE ARCHITETTURE DI MEMORIE .......................................................................................................... 135

1. Aumentare la banda aumentando i dati letti o scritti: banchi paralleli......................................... 136

2. Aumentare la banda diminuendo il tempo: banchi interlacciati.................................................... 137

CAPITOLO 17


8/216

vii

POLITICHE DI GESTIONE DELLE MEMORIE .................................................................................................... 141

1. Interazione con i dispositivi di I/O................................................................................................... 141

2. Interazione con pi processori......................................................................................................... 144

CAPITOLO 18

TECNICHE DI COMPILAZIONE EFFICIENTI ...................................................................................................... 147

1. Srotolamento del loop...................................................................................................................... 147

2. Pipeline da programma.................................................................................................................... 149

CAPITOLO 19

PARALLELISMO A LIVELLO DI ISTRUZIONI ..................................................................................................... 153

1. Processore VLIW............................................................................................................................... 153

2. Processore superscalare................................................................................................................... 157

CAPITOLO 20

PROCESSORE VETTORIALE ............................................................................................................................. 159

1. Architettura processore vettoriale cray-1........................................................................................ 160

2. Modello di programmazione vettoriale........................................................................................... 162

3. Vantaggi del processore vettoriale.................................................................................................. 163

4. Processori a registri vettoriali vs processori memory-memory...................................................... 166

5. Vettorializzazione del codice............................................................................................................ 167

6. Vector Stripmining............................................................................................................................ 168

7. Parallelismo delle istruzioni vettoriali............................................................................................. 170

8. Alcune tipiche operazioni con i vettori............................................................................................ 173

9. Riduzione a scalare dei vettori......................................................................................................... 174

10. Set istruzioni del processore VMIPS............................................................................................. 175

CAPITOLO 21

TASSONOMIA DI FLYNN ................................................................................................................................. 185

1. Classificazione dei processore secondo Flynn................................................................................. 185

2. Concetti base..................................................................................................................................... 185

CAPITOLO 22

INFRASTRUTTURE DI COMUNICAZIONE ........................................................................................................ 187

1. Bus..................................................................................................................................................... 187

2. Rete punto-punto............................................................................................................................. 187

3. Rete ad anello................................................................................................................................... 188

4. Rete a centro stella........................................................................................................................... 189

5. Reti ibride.......................................................................................................................................... 189


9/216

viii

6. Ipercubo............................................................................................................................................ 189

6.1. Trasferimento dei dati allinterno dellipercubo..................................................................... 190

CAPITOLO 23

PREDIZIONE DINAMICA ................................................................................................................................. 195

1. Predittore a un bit............................................................................................................................. 197

2. Predittore a due bit........................................................................................................................... 197

CAPITOLO 24

ALGORITMO DI TOMASULO .......................................................................................................................... 201

1. Buffer di Riordino.............................................................................................................................. 201

2. Fasi dellistruzione............................................................................................................................ 203

3. Esecuzione fuori ordine.................................................................................................................... 206


10/216

ix


11/216

1

CAPITOLO 1LA VALUTAZIONEDELLE PRESTAZIONI DI UN PROCESSORE

Le prestazioni di un processore sono state storicamente valutate da una serie di parametri che nel temposono stati sostituiti da altri. Per esempio un modo stato il numero di colpi di clock per unit di tempo, cio

la frequenza di clock. Prendiamo come esempio un processore da 60 MHz: il clock nel processore, emette

un impulso ogni 60milionesimo di secondo. In un secondo ci sono quindi 60 milioni di colpi di clock. Magari

questo processore viene considerato migliore di un altro che ne emette 45 milioni al secondo. Questa

distinzione per non ha senso se non indichiamo cosa avviene in un colpo di clock.

Il colpo di clock come il colpo di tamburo che il capo vogatore dava sulle galee romane. Gli schiavi

remavano e a ogni colpo di tamburo dovevano dare un certo numero di vogate. Se la vogata legata alla

battuta, una vogata per battuta, e chiaro che con 50 battute al minuto, ci sono 50 vogate al minuto. Ma si

pu benissimo pensare di legare una vogata ogni 5 battute, ogni 5 battute bisogna dare quindi una vogata.Per cui lasciando da parte il singolo colpo di clock, ci si pu concentrare sul CONTO ISTRUZIONI. Mi

interessa sapere, in 1 secondo quante istruzioni processa un processore? E anche con il contro istruzioni

non avr molto senso se non mettiamo dei paletti. Questo viene ricavato da un altro parametro che si

chiama CLOCK PER INSTRUCTIONS (CPI). Se io so i colpi di clock e il clock per instruction allora ho il conto

istruzioni. Ad esempio sapendo che un processore con una frequenza pari ad 1 GHz e che esegue un

istruzione per colpo di clock(CPI = 1), ottengo che in 1 secondo eseguir 1 miliardo di istruzioni. Un altro

processore da 1 GHz che invece ha bisogno di 1,3 clock per istruzione, cio ha bisogno di 1,3 colpi di clock

per eseguire una istruzione, allora in 1 secondo il processore eseguir 1 miliardo/1,3 istruzioni.

Sapere che un processore esegue N istruzioni/sec e un altro ne esegue M istruzioni/sec ci aiuta a definirequale tra questi due processori migliore? Solitamente saremmo portati a dire che quello che ne esegue di

pi dovrebbe essere migliore. Ma in realt questo non ci aiuta molto o meglio ci sarebbe di aiuto solo

nellipotesi in cui entrambi i processori abbiamo lo stesso SET DI ISTRUZIONI (INSTRUCTION SET).

Ora vediamo con accuratezza di cosa si tratta. Quando un processore effettua una operazione, esegue e

traduce tale compito in una sequenza di istruzioni macchina. Ad esempio quando bisogna eseguire un

operazione come A*B*C e scrivere il risultato in memoria allallocazione D il processore attraverso una

serie di istruzioni del SET DI ISTRUZIONI realizza questo compito:

MULT3 A, B, C, D (1)

Con questa istruzione del processore vengono presi i valori dagli indirizzi di A, di B e di C, vengono

moltiplicati e il risultato salvato nellindirizzo D. Il processore prende il dato allindirizzo di ognuno , fa il

prodotto tra questi e scrive il risultato in D, con una sola istruzione.

Un secondo processore diverso dal primo per eseguire la stessa operazione magari dovr utilizzare pi

istruzioni del suo SET DI ISTRUZIONI(diverso dallaltro processore), e quindi avr bisogno di fare:

- A (istruzione per prelevare A dalla memoria)

-

B (istruzione per prelevare B dalla memoria)

-

C (istruzione per prelevare C dalla memoria)- D1 = A*B ( istruzione per fare il prodotto tra A e B e salvarlo in D1)


12/216

2

-

D=D1*C ( istruzione per fare il prodotto tra D1 e C e salvarlo in D)

-

D (istruzione per scrivere D in memoria)

Sapendo che entrambi i processori eseguono 1 istruzione/sec mi da un idea per confrontare i due

processori. Il primo processore che compie loperazione con una sola is truzione necessiter di 1 secondo a

differenza del secondo processore, che ha bisogno di 6 istruzioni e quindi di 6 secondi. E chiaro che inqueste ipotesi il primo processore migliore.

Lultimo processore analizzato non ha nel suo SET DI ISTRUZIONI ,istruzioni cos potenti come MULT3

dellaltro processore . Questo processore ha bisogno di 6 istruzioni per eseguire quelloperazione.

Allora il CONTO ISTRUZIONI pi significativo del colpo di clock che un parametro che descrive

veramente poco e ci indica solamente la frequenza del treno di impulsi trenodi impulsi. Allora pu avere

pi senso sapere effettivamente quante sono le istruzioni che vengono eseguite in un istante di tempo, e

comparare in questo modo due macchine a patto che esse abbiano lo stesso SET DI ISTRUZIONI. Quello che

realmente interessa allutente il tempo che deve aspettare affinch un problema venga risolto. Ora il

problema nella valutazione comparativa dei processori che un problema risolto da un sistema di calcolo

in un unit di tempo , mi porta a dare una valutazione estremamente orientata a quel problema (PROBLEM

ORIENTED) perch nessuno mi garantisce che cambiando il problema la macchina A resti pi veloce della

macchina B. Nella risoluzione di un algoritmo vengono messi in evidenza aspetti che sono differenti dalla

risoluzione di un altro algoritmo.

Quindi fare una valutazione comparativa tra due processori, e quindi sapere quali aspetti andare a

migliorare su un progetto, diventa un compito non banale.

1. Filosofia Risc E Cisc

Si presentano due filosofie di architettura di un processore per quanto riguarda il SET Di ISTRUZIONI: RISCe

CISC.

Un set di istruzioni RISC (Reduced Instruction Set Computing, calcolatore con insieme ridotto di istruzioni)

un tipo di architettura di microprocessore che si concentra sull'elaborazione rapida ed efficiente di una

serie relativamente piccola di istruzioni che comprende la maggior parte delle istruzioni che un calcolatore

codifica ed esegue. L'architettura RISC ottimizza le istruzioni di modo che possano venire seguite molto

rapidamente, in genere in un solo ciclo di clock. I chip RISC eseguono cos le istruzioni semplici pi

velocemente dei microprocessori CISC(Complex Instruction Set Computing) progettati per gestire una serie

pi vasta di istruzioni. Sono tuttavia pi lenti dei chip CISC quando si tratta di seguire istruzioni complesse

che, per poter essere eseguite da microprocessori RISC, devono essere suddivise in molte istruzioni

macchina.

Allora scegliere il tipo di filosofia assumer un senso quando si utilizzer un processore che prevede che

tutte le istruzioni siano molto simili tra di loro in modo da semplificare una parte non trascurabile di un

processore: lUNITA DI CONTROLLO. Progettare ununit di controllo che piloti ogni transistor del

processore per lesecuzione di ogni singola istruzione ha una certa complessit. Questa complessit pu


13/216

3

essere ridotta se le istruzioni sono molto simili tra di loro(RISC). Al contrario pilotare ogni transistor del

processore per eseguire tante diverse istruzioni(CISC), comporta un unit di controllo un po pi

complicata. Venuto meno il problema della memoria costruita con nuclei di ferrite, da tanti anni i

calcolatori CISC non esistono pi.

Tornando al discorso sulla valutazione delle prestazioni, quello che interessa vedere il tempo in cui un

problema viene svolto. Come abbiamo gi detto, se una macchina risolve un problema in un tempo minore

di un'altra macchina non vuole che con problemi diversi ha sempre caratteristiche di performance che la

portano a prevalere sullaltra macchina. Esistono dei programmi che hanno lo scopo di valutare le

prestazioni di un sistema. Questi programmi si chiamano BENCHMARK (banco di prova). Per mettere in

evidenza vari aspetti si crea un paniere di benchmark in cui c un programma che testa come quel sistema

gestisce gli accessi in memoria, un altro che testa come quel sistema fa i calcoli in virgola mobile, un altro

ancora che testa come quel sistema gestisce laccesso a grandi quantit di dati e cos via. Quindi in base a

questo paniere di benchmark, si riescono a valutare le prestazione di una macchina.

In fase di progettazione quando si ottengono delle prestazioni dal sistema e si individuano dei punti critici,

si pone il problema se ha senso o meno migliorare il sistema riguardo quel punto critico.

Tornando allesempio di (1), ammettiamo che il progettista del secondo processore (RISC) non abbia

problemi a inserire istruzioni di tipo CISC, ad esempio come MULT3. Questo ampliamento del set di

istruzioni avr un certo costo, bisogna fare in modo che lunit di controllo sappia gestire anche quella

istruzione, e supponiamo di aver quantificato questo costo, es. 2 transistor. Bisogna per tenere in

considerazione il beneficio che si trae rispetto al costo. Quindi scoprire che questa istruzione dopo averla

inserita mi consente di eseguire questo obiettivo in un secondo piuttosto che in 1,2 secondi quindi con unaumento delle mie prestazioni del 20% pu essere utile a fronte del fatto che ho dovuto inserire 2

transistor su un unit di controllo che ne prevedeva 1000 con un costo dello 0,2 %. Questo per deve va in

relazione con il numero di volte in cui verr utilizzata nella vita di questo calcolatore listruzione , ad

esempio MULT3. Perch se questa istruzione viene utilizzata spesso allora effettivamente si

guadagnato, ma se quel calcolatore lavora con questa istruzione una volta su mille, questo 20% che mi ho

guadagnato non stato guadagnato in assoluto ma una volta su mille e quindi diventato 0,02%.

2. La Legge Di Amdahl

In questo discorso assume molta importanza la LEGGE DI AMDAHL.

Usando la legge di Amdahl si pu calcolare il guadagno in termini di prestazioni che si pu ottenere

migliorando una parte di un calcolatore. Questa legge afferma che il miglioramento di prestazioni che pu

essere ottenuto usando qualche modalit di esecuzione pi veloce limitato dalla percentuale di tempo in

cui pu essere utilizzata tale modalit. La legge di Amdahl definisce laumento di velocit (speedup) che si

pu ottenere usando una particolare caratteristica. Cos laumento di velocit? Immaginiamo di poter

apportare un miglioramento a un calcolatore in modo che le sue prestazioni migliorino. Laumento di

velocit il rapporto


14/216

4

Oppure equivalentemente

Speedup =( Tempo di esecuzione complessivo senza usare il miglioramento) /( Tempo di esecuzione

complessivo usando il miglioramento).

Il valore di Speedup ci dice quanto pi velocemente verr eseguito un programma usando il calcolatore

migliorato, rispetto al calcolatore originale. La legge di Amdhal fornisce un mezzo rapido per misurare lo

Speedup conseguente a un determinato miglioramento, che dipende da due fattori:

1.

La frazione del tempo di esecuzione sul calcolatore originale che pu trarre vantaggio dal

miglioramento. Per esempio, se il miglioramento pu essere usato in 20 dei 60 secondi totali

richiesti per l'esecuzione di un programma, la frazione di cui parliamo 20 /60. Questo valore, che

chiameremofrazione migliorata, sempre inferiore al pi uguale a 1.

2.

Il miglioramento di prestazioni che si ottiene nel modo di esecuzione migliorato, cio quanto

verrebbe seguito pi velocemente il programma se il modo di esecuzione migliorato potesse essere

utilizzato per l'intero programma. Questo valore uguale al tempo di esecuzione nella modalit

originaria diviso il tempo di esecuzione nella modalit migliorata. Se nella modalit migliorata

occorrono, per esempio, due secondi per eseguire una parte del programma che richiede invece 5secondi nella modalit originaria, il miglioramento 5/2. Chiamiamo speedup miglioratoquesto valore,

che sempre maggiore di 1.

Il tempo di esecuzione con il calcolatore originario a cui viene apportato il miglioramento sar pari al tempo

impiegato dalla porzione non soggetta a miglioramento sommato al tempo della porzione che si

avvantaggia del miglioramento:


15/216

5

Lo Speedup complessivo il rapporto tra i tempi di esecuzione:


16/216

6


17/216

7

CAPITOLO 2CARATTERISTICHEDELLE ISTRUZIONI DI UN CALCOLATORE

I linguaggi con cui noi riusciamo a dialogare con il processore sono stratificati. Esistono una serie di livellistratificati. Nello strato pi interno, quello pi vicino al processore, il linguaggio incomprensibile da un

essere umano(linguaggio macchina), invece man mano che ci si avvicina agli strati pi esterni,il linguaggio

diventa sempre pi comprensibile per l'essere umano(linguaggi di alto livello).

I linguaggi ad alto livello sono stati introdotti per codificare gli algoritmi in un modo pi semplice e intuibile

da parte dell'essere umano. Ci che viene realmente eseguito da una CPU sono le istruzioni del programma

tradotte in un linguaggio pi intuibile da parte del processore costituito da stringhe di 1 e 0(linguaggio

macchina).

Il linguaggio "appena superiore" al linguaggio macchina il linguaggio ASSEMBLER. Questo linguaggio una

traduzione 1:1 di ogni istruzione del linguaggio macchina con una sintassi pi comprensibile per luomo.

I livelli d'istruzione che operano sulla CPU fondamentalmente sono di 3 tipi:

- Istruzioni aritmetico-logiche(somma, and logico, ecc..)

-

Istruzioni per accedere alla memoria(istruzioni per scrivere e leggere dalla memoria)

Lettura(LOAD)

Scrittura(STORE)

-

Istruzioni di controllo (o di diramazione)

Salti incondizionati(JUMP)

Salti condizionati(BRANCH)

I JUMP ad esempio possono essere confrontati con le chiamate di funzioni di qualsiasi linguaggio ad alto

livello, visto che, in questo caso, avviene un salto incondizionato da una istruzione ad un altra. Alla fine si fa

ritornare l'esecuzione all'istruzione successiva a quella chiamante.

1. Ciclo Istruzione

L'istruzione una sequenza di bit che il processore legge caricando dalla memoria. Una volta lette le

istruzioni verranno eseguite sempre una dopo l'altra. Lesecuzione di una istruzione avviene grazie ad un

ciclo, chiamato CICLO D'ISTRUZIONE.

Il Ciclo di Istruzione composto da:

- FETCH dellistruzione:e' la fase di prelievo dell'istruzione. Questa fase avviene grazie al PROGRAM

COUNTER che contiene l'indirizzo dell'istruzione da eseguire. Questa viene prelevata e poi caricata

nel processore pronta per essere decodificata ed eseguita.

- DECODE dellistruzione:' la fase di riconoscimento dell'istruzione che avviene grazie all'unit di

controllo che legge listruzione e riconosce quale operazione bisogna eseguire. Ovviamente queste


18/216

8

operazioni sono state definite secondo rigide convenzioni. Ogni famiglia di processori ha delle

proprie convenzioni.

- EXECUTE dell'istruzione: la fase di esecuzione dell'istruzione.

Queste fasi sono sequenziali e sono arbitrate dal clock.

2. Categorie Di Formati Istruzione

Le istruzioni si distinguono per il numero di bit di cui sono composte, inoltre possono esserci due categorie

di formato istruzione:

- Formato a lunghezza fissa (numero di bit fisso)

-

Formato a lunghezza variabile (numero di bit variabile)

Il formato a lunghezza variabile prevista maggiormente nelle macchine di tipo CISC. Le macchine di questo

tipo quindi hanno bisogno di un' unit di controllo molto complessa per poter leggere ogni tipo di

lunghezza delle istruzioni. Invece le macchine di tipo RISC che hanno l'obbiettivo di semplificare l'unit di

controllo, prevedono un formato d'istruzione a lunghezza fissa.

3. Struttura Dell'istruzione

Un istruzione costituita essenzialmente dal codice operativo (OPCODE): tra i bit che compongono

l'istruzione ce ne saranno un certo numero che servono a specificare l'operazione dell'istruzione corrente. Il

codice operativo formato da log2n bit, arrotondato per eccesso, dove n il numero delle istruzioni

possibili. Ad esempio se ho bisogno di implementare un processore che necessita di 100 tipi di istruzioni,

servirebbero per eccesso 7 bit per codificare il codice operativo di ogni istruzione, che pu definire fino a

128 istruzioni (27). In genere i 28 tipi di istruzione rimanenti non vengono implementate proprio per non

incorrere in complicanze dell'unit di controllo. Per queste istruzioni rimanenti, in futuro, potrebbero

essere utilizzate per delle nuove frontiere tecnologiche, in modo tale da poter effettuare un semplice

upgrade invece di riprogettare tutta l'unit di controllo da zero.

Oltre ai bit del codice operativo ci sono inoltre delle sequenze di bit che identificano gli operandi su cuilistruzione effettua le operazioni.


19/216

9

CAPITOLO 3CLASSIFICAZIONEDEI PROCESSORI

Si possono caratterizzare i processori in base a diversi aspetti.

1. Classificazione per istruzione

Un aspetto la tipologia di lunghezza fissa o variabile delle istruzioni affrontata nel capitolo precedente: le

istruzioni a lunghezza fissa tipiche di una architettura con filosofia RISC e istruzioni con lunghezza variabile

tipiche di una architettura con filosofia CISC. Inoltre le istruzioni fondamentalmente si dividono in tre

famiglie:

o istruzioni di accesso a memoria

o

istruzioni che modificano il flusso del programma

o istruzioni che codificano operazioni logico-aritmetico

2. Classificazione per parola

Un altro aspetto con cui possibile caratterizzare i processori attraverso il tipo di dati che essi trattano. Ci

sono una serie di dati che si differenziano sia per il formato(numero bit) e sia per il tipo di dati che questo

formato va a interpretare. Ad esempio i dati di tipo numerico si codificano con o senza la virgola(interi o

reali) e questo presuppone una codifica in binario puro con o senza segno o con una codifica che tieneconto di potenze di due sia positive e sia negative in modo da poter compattare i numeri in diversi formati

come anche la virgola fissa o mobile. Standard pi efficienti prevedono luso della virgola mobile( vedi

floating point). Bisogna precisare quindi se il processore elabora dati in floating point o in virgola fissa. Anni

fa non tutti i processori elaboravano dati floating point poich non prevedevano al loro interno hardware

sufficiente per effettuare queste operazioni, e quando era necessario fare calcoli in virgola mobile questi

venivano eseguiti da un software. Se cera bisogno di fare molti di questi calcoli si comprava il co -

processore matematico che implementava al suo interno in hardware questo tipo di calcoli. Ora possibile

integrare nello stesso chip degli hardware per effettuare calcoli matematici in floating point, infatti la

maggior parte dei processori del giorno doggi gestiscono dati in floating point, contengono al loro interno

un set istruzioni che permette la gestione di questi. Per anni questo non stato possibile poich iprocessori, avendo un hardware limitato, avevano a disposizione quindi un set di istruzioni che prevedeva

la gestione dei soli numeri interi.

Una volta scelta la possibilit di utilizzare dati piuttosto che altri(floating point piuttosto che numeri interi)

bisogno stabilire la grandezza di questi dati, di quanti bit devo essere questi dati. I processori dunque si

differenziano per i tipi di dati che possono gestire e la loro dimensione, dati da 4 byte intero, 8 byte intero,

16 byte intero oppure 32bit floating point(singola precisione) o 64bit floating point e cos via.

Un ulteriore aspetto che differenzia i processori rappresentato anche della profondit della parola.

Lunit il bit che viene elevato a byte(1byte = 8bit) con 1 byte posso esprimere informazioni in un rangetra 0 e 255(28). Se linformazione che voglio descrivere rappresentabile con un singolo byte sufficiente la


20/216

10

parola di un byte, ad esempio le lettere dellalfabeto, 26 lettere entrano in un byte(256 lettere) posso

ancora codificare le lettere maiuscole e minuscole, numeri, simboli di punteggiatura. Con un byte si

possono benissimo rappresentare caratteri alfanumerici e attraverso una codifica(in questo caso la codifica

ASCII) a associa ad un numero tra 0 e 255 un simbolo. Quel byte invece non pi sufficiente per indicare

quanti sono gli spettatori al concerto di Vasco Rossi. Non pi sufficiente perch non riesco a esprimere

con un byte questa informazione. Bisogna quindi definire una quantit che verr usata come riferimento

standard dellarchitettura: la parola(WORD). La parola diviene lunit. Un architettura definisce una parola

con un certo numero di byte che tratta come nucleo del dato pi frequentemente adoperato. Le parole

solitamente sono di 4byte, tutto il traffico nel processore avviene usando dati di 4 byte. I dati sono nel

formato definito dalla WORD.

3. Classificazione per la gestione della memoria interna

Possiamo differenziare i processori anche in base a come i dati allinterno di questo vengono gestiti. Lamacchina secondo Von Neumann strutturata con una cpu, una memoria centrale, periferiche di

input/output e i canali di comunicazione tra questi. Si pu immaginare ad un modello in cui il processore

quando ha bisogno di un dato in una istruzione lo va a reperire ogni volta direttamente dalla memoria

centrale e il risultato lo scrive sempre in memoria. Ma si pu pensare ad un processore che abbia al suo

interno unarea di memoria in cui i dati quando servono vengono letti dalla memoria centrale scritti in

questa area e ogni volta che servono vengono letti da questa e non dalla memoria centrale, purch al

termine di tutto questi dati vengano scritti in memoria centrale.

Sono stati sviluppati tre modelli per la gestione per questa memoria intima del processore.


21/216

11

i

1. Una soluzione semplice era il processore ad accumulatore, che prevedeva al suo interno una sola

area di memoria, laccumulatore,utile a contenere un solo dato.

Nellaccumulatore veniva caricato un operando dalla memoria e quando il processore doveva

effettuare delle operazioni, che di solito necessitano di due operandi sorgente, ad esempio la


22/216

12

somma (SUM), listruzione intendeva fare la somma di due operandi, uno letto dalla memoria e

laltro quello che risiede nellaccumulatore. Il risultato andava scritto sempre nellaccumulatore.

Le istruzioni nella loro strutturazione sono semplici in quanto sono costituiti dal codice operativo e

un indirizzo di memoria.

SUM 2730

Loperando nellaccumulatore veniva sommato alloperando che si trovava nellindirizzo di memoria

2730, e il risultato veniva scritto nellaccumulatore. Dopo loperazione quello che cera prima

nellaccumulatore veniva perso, cera il risultato della somma.

Per scrivere il risultato nella memoria centrale ad un certo indirizzo:

STORE 3256

Il valore nellaccumulatore veniva scritto in memoria allindirizzo 3256.

Esercizio:

Supponiamo di avere degli indirizzi di memoria A B C D e di voler mettere nellindirizzo di memoria

E la somma di quello che c nellindirizzo A e nellindirizzo B: E=A+B; e invece in F: F = A*C+D

Istruzione Valori nell

accumulatore

LOAD A A

SUM B A+B

STORE E A+BLOAD A A

MULT C A*C

SUM D A*C+D

STORE F A*C+D

2.

Un'altra tipologia di processore era quella a stack, processori a stack. In questi non cuna sola

area di memoria, ma una struttura di memoria con pi locazioni a cui non si pu accedere in

maniera casuale, ma si pu aver accesso solo a chi in testa allo stack(come una pila LIFO LastInput First Output), lultimo dato inserito il primo adessere prelevato. C un meccanismo che

prevede uno STACK POINTER (SP) che mi indica larea dello stack a cui posso accedere, e che

contiene quindi il dato in questione. Nelle operazioni aritmetico logiche non bisogna specificare

nellistruzione lindirizzo degli operandi, perch questi sono i primi due che si trovano al top dello

stack e sono questi che verranno utilizzati nelle operazioni. Le operazioni di tipo LOAD vengono

chiamate in questo contesto push, mentrequelle di STORE pop


23/216

13

Bisogna per stabilire delle convenzioni sullo stack pointer: lo stack pointer punta alla prima vuota

o allultima piena. Lo stack pointer pu puntare alla prima area dello stack vuota o allultima piena.

Ipotizzando che SP punti alla prima vuota.

LOAD (push):

M[indirizzo] ->S[SP]

SP+1->SP

Letto il dato dalla memoria(indirizzo) viene memorizzo nello stack, nellarea di questo puntata dallo

stack pointer(questa area dello stack vuota visto che SP indica proprio larea vuota per la

convenzione adottata). Bisogna per incrementare SP per farlo puntare nuovamente alla prima

vuota.

STORE (pop):

SP-1->SP

S[SP]->M[indirizzo]

SP punta alla prima vuota(garbage, valore dellultimo dato scritto e non ha nessun valore utile),

bisogna farlo puntare allultima piena e poi scrivere ci che puntato dallo stack pointer in

memoria(nellindirizzo di memoria).

Utilizzando invece la convenzione in cui SP punta allultima piena.


24/216

14

LOAD (push):

SP+1->SP

M[indirizzo] -> S[SP]

Bisogna far puntare prima SP alla prima vuota(altrimenti perdo il dato che avevo in precedenza), e

caricare poi il dato dalla memoria.

STORE (pop):

S[SP]->M[indirizzo]

SP-1->SP

Lultimo pieno (quello puntato da SP) proprio il dato da salvare in memoria. Per ades so bisogna

decrementare lo stack pointer.

E essenziale stabilire la convenzione. Nella strutturazione pipeline(che vedremo successivamente

nel corso) si prevede che prima si eseguono dei calcoli e poi si accede a memoria. Potrebbe essere

utile questa scelta per stabilire quale convenzione usare per lo stack pointer, per le dueconvenzioni non vanno comunque bene(perch nella LOAD di una convenzione si eseguono prima

le operazioni e poi si accede a memoria ma nella STORE il contrario, e viceversa con laltra

convenzione), allora si pu ipotizzare di fare una ibridazione e scegliere di eseguire le load secondo

una convenzione e le store secondo un'altra, ma non va bene comunque. Bisogna scegliere una di

queste due convenzioni in base a quale operazione faccio pi frequentemente load o store.

Intuitivamente si portati a dire che le load e le store sono effettuate lo stesso numero di volte,

per le load sono pi numerose, perch si sale lungo lo stack con le load e si scende con le store ma

anche con le operazioni che prevedono la memorizzazione di un operando nella memoria.

3.

Un'altra famiglia di processori quella dei processori a registri, che utilizzano un certo numero dilocazioni (come lo stack) a cui per si pu accedere a piacere, si pu accedere a qualsiasi locazione

senza vincoli. Queste celle assumono tutte la stessa dignit.C un area di memoria costituita da

dei registri che si indirizzano autonomamente. Non si legati alla cima della pila. Per questa

comodit si paga sia un hardware pi complesso per gestire questo sistema, e soprattutto si paga

un discorso che obbliga a inserire nellistruzione la specifica degli indirizzi degli operandi.


25/216

15

Nel caso del processore ad accumulatore un operando era sempre laccumulatore quindi

nellistruzione si indicava un solo indirizzo per loperando da prelevare dalla memoria; nel

processore a stack gli operandi erano sempre i primi due dello stack e nelle istruzioni non si

specificava nessun indirizzo. Nei processori a registri invece necessario specificare il primo

operando(che si trova in un determinato registro), il secondo operando(che si trova in un altroregistro), il terzo operando(che si trova in unaltro registro ancora). Quindi listruzione oltre al

codice operativo prevede tre campi per gli operandi, e questi campi contengono un numero di bit

pari al log2(num. registri). Si pu sempre pensare di dare una ulteriore flessibilit e oltre a prelevare

gli operandi dai registri si vuole dare la possibilit di prendere operandi dalla memoria, ad esempio

si vuole effettuare la somma di due dati in cui uno si trova in un registro, mentre il secondo si trova

in una certa locazione della memoria centrale(indirizzo di memoria). Oppure la locazione dellarea

di memoria di un operando scritta addirittura in un registro. In questi casi il formato si complica

perch il numero dei bit dei campi per la specifica degli operandi deve poter contenere anche gli

indirizzi di memoria, bisogna prevedere la gestione di questi meccanismi.

La maggior parte dei processore di oggi sono della tipologia a registri. Tipicamente le macchine a registro si

suddividono in LOAD/STORE piuttosto che no. Una macchina a registro si dice che una macchina

LOAD/STORE nel momento in cui le uniche istruzioni di questa macchina che fanno riferimento alla

memoria sono solo le istruzioni LOAD e STORE, significa che nellesecuzione di una istruzione aritmetica, la

somma per esempio, il processore non pu accedere alla memoria, gli operandi devono essere stati gi tutti

preventivamente caricati nei registri. Non possibile con questa tipologia di macchina prendere un

operando dalla memoria direttamente con la istruzione aritmetico logica, SUM per esempio, passando

lindirizzo della locazione di memoria, ma tutti gli operandi sono stati gi tutti preventivamente caricati nei

registri, e il risultato di questa operazione deve essere ancora scritto in un registro, non pu essere scritto

in una locazione di memoria. Nelle macchine di tipo LOAD/STORE le uniche operazioni che permettono di

caricare o scrivere da/in memoria sono solo e soltanto le operazioni di LOAD e di STORE. Osserviamo nella

figura che quando c da usare lALU la memoria scollegata


26/216

16

4. Classificazione per modi di indirizzamento

Un altro modo di caratterizzare i processori il modo con cui questi gestiscono laccesso a memoria, cio il

modo con cui lindirizzo, dove andare a leggere o scrivere, pu essere fornito al processore. Il modo pi

semplice scrivere un indirizzo nellistruzione stessa(modalit con indirizzo immediato); un altro modo

quello conindirizzo direttodove lindirizzo dellarea di memoria scritto in un registro. Lindirizzo dellareadi memoria va prelevato da un registro.


27/216

17

CAPITOLO 4MODI DI INDIRIZZAMENTO

Nel capitolo precedente abbiamo distinto le macchine a registri in due categorie:

1. Larchitettura Load-Storeche consente di fare operazioni di tipo aritmetico logico solo fra operandi

che sono nei registri, quindi non si pu fare la somma fra un dato che in un registro e un dato che

in memoria, o ancor peggio la somma di due dati che sono in memoria. Bisogna solo fare

operazioni aritmetico logiche che riguardano due operandi che sono gi presenti nei registri. In

sostanza si acceder alla memoria solo attraverso operazioni tipiche della memoria. Quindi questo

tipo di macchina sar una macchina a registri LOAD-STORE per significare che la memoria sar

usata solo con istruzioni di tipo LOAD STORE. Quindi per fare un operazione aritmetica fra due dati

che sono in memoria prima bisogna eseguire la LOAD di questi due dati , per esempio prendere il

primo dato e inserirlo nel registro R1 , leggere un secondo dato e inserirlo nel registro R2 e solo ora possibile fare le operazioni fra R1 ed R2; il risultato andr in un altro registro che pu anche

essere uno dei due che si appena usato, ma non si pu scrivere il dato in memoria se non

attraverso loperazione di STORE

2. Larchitettura Registro-Memoriainvece prevede di usare lALU per fare calcoli ma nellambito della

stessa istruzione anche di accedere a memoria. Questo tipo di struttura per preveder un codice

operativo che dovr contenere sia la specifica di un registro (per loperando) sia la specifica di un

registro del risultato e sia un indirizzo. Quindi siccome per indirizzare un registro tipicamente

bastano pochi bit, con 32 registri sufficiente un insieme di 5 bit. Con 5 bit infatti si possono

codificare numeri compresi tra 0 e 31; scrivendo il numero 7 si intende il registro R7. Per specificareun indirizzo non bastano 5 bit, attraverso 5 bit si indirizza solo una porzione della memoria.

Tipicamente per specificare un indirizzo si necessitano di pi bit, almeno che per specificare un

indirizzo non si utilizza un artefatto: scrivere lindirizzo di memoria in un registro. Quindi

nellistruzione si andr solamente a specificare lindirizzo del registro, che contiene lindirizzo di

memoria, attraverso i 5 bit.

1. Indirizzamento Diretto

La modalit di indirizzamento appena mostrata si chiama INDIRIZZAMENTO DIRETTO. C un registro che

direttamente contiene lindirizzo dellarea di memoria. Nellistruzione si andr a specificare solamente

lindirizzo del registro che contiene lindirizzo di memoria a cui accedere.

2. Indirizzamento con Immediato

possibile scrivere lindirizzo direttamente nellistruzionestessa. Quindi listruzione dovr contenere oltre

anche varie altre informazioni fra cui una di queste lindirizzo.


28/216

18

3. Indirizzamento con Scostamento (displaycement)

Lindirizzo con displaycement viene calcolato sommando al contenuto di un registro un numero (INDIRIZZO

BASE) codificato nellistruzionestessa. Nellistruzione verr specificato quindi un registro per esempio R9 e

un immediato(indirizzo base), e lindirizzo di memoria verr calcolato sommando questo indirizzo base che

e il contenuto di R9. Ci si pu chiedere, ma non era meglio inserire tutto limmediato di per s? Si per sequesta istruzione va eseguita allinterno di un loop e ad ogni ciclo si ha la necessit di accedere a un dato

diverso bisogna avere un indirizzo diverso. Con lindirizzamento con scostamento listruzione contiene una

un immediato e un registro da sommare cos che nel loop ogni volta verr cambiato il valore dellimmediato

Ci sono anche altre modalit che sono usate nellambito deiprogrammi in maniera diversa. Cio quando un

programma usa una modalit di indirizzamento si pu vedere se questa modalit frequente perch in tal

caso si pu pensare di potenziare lesecuzione di un istruzione che usa quel tipo di modalit di

indirizzamento.

Questo diagramma prende in considerazione 5 modalit diverse di indirizzamento:

1. Indiretto in memoria

2.

Scalato

3.

Indiretto con registro

4. Immediato

5. Scostamento

e per ciascuna di queste usando 3 programmi standard che vengono considerati come benchmark, si pu

vedere, quando si esegue una compilazione, come funziona luso di tali indirizzamenti. Dopodich se si

vuole provvedere a come potenziare larchitettura di un sistema che dovrebbe essere usato

prevalentemente per fare calcolo scientifico si studia il comportamento di quello che fa il sistema quando

usa un programma di tipo scientifico come SPICE, e si scopre che oltre la met degli accessi in memoria

avvengono attraverso uno SCOSTAMENTO (displaycement). Questo il tipico modo con cui si accede ai dati

dei vettori. Quindi capiamo bene come in SPICE questo il modo pi frequente perch quando si fa una


29/216

19

simulazione di una rete elettrica si risolvono sistemi che fanno uso di calcolo vettoriale e per questo per

accedere a elementi di un vettore si ha bisogno di accedere con indirizzamenti codificati in questo modo.

Per cui se si vuole migliorare qualcosa di questo processore, relativamente agli accessi in memoria

converr migliorare il modo con cui il processore accede a memoria dopo aver calcolato lindirizzo in

maniera di spiazzamento.

Se invece si vuole realizzare un sistema che fa tipicamente editoria, (TeX) ci si accorge che quando il

compilatore accede a memoria utilizza indirizzi immediati cio nella esecuzione si fa riferimento a un

indirizzo codificato in maniera diretta nellistruzione stessa.

Invece lindirizzamento che prende il nome di REGISTRO INDIRETTO un indirizzamento secondo il quale il

registro contiene un indirizzo che non lindirizzo del dato di destinazione ma ancora un altro indirizzo e

quindi si va due volte in memoria.

4. Indirizzamento con registro auto-incrementato o auto-decrementato

In questo diagramma non presente un altro modo abbastanza frequente di accedere alla memoria che

quello con auto-incremento o auto-decremento del registro, in cui listruzione di accesso a memoria

ingloba in s anche loperazione di aggiungere o togliere una quantit al registro usato per conoscere

lindirizzo. Ad esempio in R8 c un certo indirizzo, si pu avere o meno limmediato da sommare al registro

per avere lindirizzo di memoria; si effettua la somma nel caso sia necessario fra limmediato e il registro, e

si ottiene lindirizzo di memoria. Oltre a questo il registro viene aumentato o diminuito di 4 o comunque di

una quantit che rappresenta il numero di byte letti dalla memoria in maniera tale che questo registro in

automatico adesso punter al prossimo dato. C la operazione con indirizzamento auto incrementanteo

auto decrementante prefisso a significare che prima verr incrementato o decrementato il registro e poi

verr usato per accedere in memoria.

Questo meccanismo utile per la gestione di uno stack, non si intende lo stack interno al processore, la

macchina sempre a registri, ma si intende uno stack come un area di memoria che il processore gestisce.

Valgono le due convenzioni su SP che punta alla prima vuota o allultima piena.

Ad esempio vediamo la gestione dello stack. D la dimensione della cella dello stack, ed R6 il registro su

cui avvengono le operazioni.

Consideriamo il caso in cui SP punti allultima piena (1).

POP (1):

M[SP] R6

SP D SP

PUSH (1):

SP + D SP

R6M[SP]


30/216

20

Consideriamo il caso in cui SP punti allultima vuota (2).

POP (2):

SP D SP

M[SP] R6

PUSH (2):

R6 M[SP]

SP + D SP

Supponiamo che R31 il registro che contiene lo stack pointer che un indirizzo di memoria. Posso fare

uso dellindirizzamento con auto-incremento o auto-decremento, si scrive un +( o un -) a destra o a

sinistra del registro per indicare rispettivamente un incremento( o decremento) postfisso o prefisso.

Le istruzioni scritte prima diventano:

POP (1):

LOAD R6 R31-

Scrivo in R6 il dato letto dalla memoria puntata da R31. Il segno indica che dopo aver scritto nel registro

R6, R31 viene decrementato: R31 = R31 D

PUSH (1)

STORE R6 +R31

R1 viene prima incrementato, e poi viene scritto nellarea di memoria puntata il valore di R6.

Con laltra convenzione

POP (2):

LOAD R6 -R31

PUSH (2):

STORE R6 R31+

E importante precisare che quando si accede a uno stack con le operazioni di PUSH e POP, bisogna prima

verificare che lo stack non sia pieno, altrimenti si scrive su una zona di memoria che magari stata riservata

per contenere altri dati; e che non sia vuoto.

Ipotizziamo che R30 e R29 sono due registri che contengono rispettivamente R30 il TOP(ultima locazione

accessibile) ed R29 il BOTTOM(la prima cella accessibile).


31/216

21

Con la convenzione dellultima piena, per effettuare una push bisogna verificare che:

SP < TOP

Invece per effettuare una pop bisogna verificare che:

SP >= BOTTOM

Con la convenzione dellultima vuotainvece, per effettuare una push deve essere verificato che:

SP BOTTOM

Tipicamente lindirizzamento con spiazzamento (pi usato nel calcolo scientifico) ha questa struttura:

Il codice operativo ad indicare un operazione di LOAD o STORE, e un registro destinazione o sorgente: nel

caso di una LOAD il registro di destinazione, nel registro verr scritto il risultato; altrimenti nel caso di una

STORE il registro sorgente, contiene un dato che verr scritto in memoria. Infine ci c un altro registro

che contiene lo spiazzamento e un indirizzo per limmediato, questi ultimi sommati vanno a formare

lindirizzo di memoria. Questo immediato da prendere come indirizzo a cui sommare il contenuto del

registro di spiazzamento per ottenere lindirizzo finito. E normale che questo immediato ha un numero di

bit che minore del numero di bit del listruzione. Se considero un processore con N istruzioni, sono

necessari almeno Log2N bit per il codice operativo. Ad esempio 6 bit per il codice operativo. Considerando

inoltre un processore con 32 registri, sono necessari 5 bit per specificare un registro. Nella struttura fornita

prima dellistruzione in cui compaiono oltre al codice operativo due registri e considerando ancora che leistruzioni sono di 32 bit rimangono per limmediato solamente 16 bit. Tipicamente uno spazio di

indirizzamento nella memoria, ha la dimensione del BUS del processore. Quindi se il processore traffica con

dati da 32 bit anche gli indirizzi saranno di 32 bit perch allinterno del processore gli indirizzi che si

possono gestire (per esempio somma tra immediato e registro di spiazzamento) sono indirizzi scritti in un

registro. Quindi non si vincolati ad avere una memoria solo di 232 byte = 4 gigabyte, significa per che in

un momento storico della vita di quel programma ci sar una memoria di 4 gigabyte. Molto probabilmente

la memoria sar effettivamente di diversi terabyte, per si sta facendo riferimento a uno spazio di

indirizzamento che una fetta(4 gigabyte) di questa memoria. Per cui quando si accede a memoria, questo

indirizzo sar un indirizzo che andr a consultare un SUBSETdella memoria di 4 gigabyte.

Allora questo immediato di 16 bit (ad esempio) ipotizzando 32 bit per questa istruzione, va utilizzato come

se fosse di 32. Quindi questi immediati vengono tipicamente espansi a 32 bit. A partire da questo numero

di 16 bit verr creato un numero di 32 bit facendo un espansione in segno, perch questo numero pu

essere positivo o negativo ad indicare uno spostamento in avanti o indietro rispetto al registro di

spiazzamento. Se positivo o negativo lespansione in segno preveder la replica dei bit pi significativi.

Dato un numero di N bit e lo si vuole espandere a N+K bit, si andranno ad aggiungere K bit alla sua sinistra.


32/216

22

Esempio: consideriamo il numero 18 e lo si vuole scrivere con 4 cifre. Bisogner scrivere 0018, poich

questo un numero positivo si andranno ad aggiungere gli zeri a sinistra.

Se il numero invece binario con segno in complemento a 2: i numeri negativi avranno il primo bit uguale a

1. Per scrivere -7 usando 5 bit binari, si pu scrivere -7 in complemento a 2.

00111 (7) in 5 bit

11000 C.A. 1

11001 C.A. 2 (-7)

Se si vogliono usare 8 bit per rappresentare -7:

00000111 (7) in 8 bit

11111000 C.A.1

11111001 C.A. 2 (-7)

Per leggere questi risultati dovr verificare il primo bit se esso uguale a zero allora il numero in binario

puro e lo si pu leggere normalmente. Se invece il primo bit uguale a 1 non si pu legge il numero in

binario e bisogner fare un operazione che di nuovo in complemento a 2. Si scriver il segno meno e si

effettua il complemento a 2 sul numero:

11111001 -

00000110 C.A. 1

00000111 C.A. 2 (7)

Il risultato 7, con il segno negativo poich il primo bit era 1: -7.

Bisogna chiedersi per se questi 16 bit (per esempio) sono sufficienti piuttosto che no a indirizzare la

memoria. In realt con 16 bit, rispetto un valore scritto in un registro, ci si pu spostare 215locazioni prima

o 215locazioni dopo. Per cui se si sta spaziando su una memoria a partire dal valore puntato dal registro di

spiazzamento, sommando questo immediato positivo o negativo ci si pu muovere su 215locazioni sopra o

215locazioni sotto rispetto a questo registro. Questi 16 bit sono sufficienti o sono pochi?. Se per esempio

questi sono pochi ci sono dei problemi, perch bisognerebbe pensare a un istruzione che sia pi lunga di 32

bit. Allora prima di capire se questi bit sono pochi o molti, si pu fare uno studio statistico e vedere quandosi effettua un accesso a memoria questo displaycement , di solito, quanto grande? Di solito lo quanto

lungo lo spostamento richiesto? E lo stesso, a maggior ragione, quando si dovranno eseguire delle istruzioni

di salto di tipo JUMP e di tipo BRANCH i quali prevedranno un codice operativo diverso.

5. Indirizzamento per le operazioni di salto

Un istruzioneJUMP effettua un salto ad un nuovo indirizzo di memoria senza nessuna condizione, non si

dovr codificare altro. Si avr a disposizione oltre al codice operativo una serie di bit per scrivere il valore di

quanto saltare.


33/216

23

Un istruzione BRANCHinvece necessita di una serie di bit oltre al codice operativo per codificare i termini

delloperazione logica da fare. Ad esempio se si vuole codificare un istruzione, un branch se R2 > R6,

bisogner mettere da parte tanti bit per scrivere R2 e tanti per scrivere R6. Quindi nei branch, solitamente i

bit che restano per specificare di quanto saltare sono di meno a differenza del JUMP dove si ha a

disposizione praticamente tutta listruzione a meno del codice operativo per codificare la lunghezza del

salto. Nei branch, invece, parte dellistruzione , oltre al codice operativo, deve essere sacrificata per

codificare su quali registri si sta facendo il test se saltare o meno.

E quindi anche qui avrebbe senso studiare quanto sono lunghi solitamente i salti di un istruzione JUMP o di

una istruzione BRANCH quando si usano software come SPICE, GCC o altri. Se per esempio ci si accorge di

avere salti di 266 locazioni bisogna trovare una soluzione! Una potrebbe essere quella di utilizzare un

istruzione di 71 bit, 5 per il codice operativo e 66 per fare il salto, per poi questi 71 bit sono uno spreco

quando le istruzioni rientrano in un numero pi ridotto. Per cui uno studio senzaltro utile quello che

viene in mente nel verificare questi numeri di bit di spiazzamento.

Un istruzione CALL effettua un salto incondizionato come la Jump, per a differenza della Jump che saltasemplicemente le istruzioni, la Call effettua un salto ma con un meccanismo di salvataggio della posizione

da dove si effettuato il salto. Viene memorizzato lindirizzo da dove viene eseguito il salto. Questo il

meccanismo per gestire le procedure, le subroutine. Quando si esegue una Call, viene chiamata una

procedura, vengono eseguite le istruzioni di questa, e quando termina lesecuzione del programma ritorna

allistruzione successiva alla Call.

Pu capitare che in un codice si possono avere pi chiamate a quella subroutine, bisogna prevedere una

istruzione di Call che funziona come una Jump, ma non si limita al semplice salto, dev e salvare lindirizzo

successivo dellistruzione di Call eseguita prima e che dovr essere gestito al termine della procedura

dallistruzione return. Lultima istruzione di una procedura la return che anchessa effettua un saltoincondizionato, salta allindirizzo che salvato quando stata eseguita la Call. Bisogna scrivere in un certo

registro speciale lindirizzo successivo allistruzione di Call.

Il problema di questo meccanismo nasce quando anche nella subroutine avviene un'altra chiamata ad

un'altra subroutine o quella subroutine stessa(ricorsione). Nella subroutine c una nuova Call ad un'altra

procedura che va a modificare nel registro lindirizzo di ritorno, quindi ora nel registro viene scritta la nuova

posizione dove ritornare dopo questa Call ma si perde la posizione precedente. Bisogna quindi, per ovviare

a questo problema, vincolare la subroutine a non fare altre chiamate a subroutine.

Un metodo migliore per gestire le Call/return scrivere i diversi indirizzi di ritorno in un area di memoria,

questarea di memoria, lo stack, deve essere organizzata con tipologia LIFO. Quando viene chiamata una

subroutine nello stack si va a memorizzare lindirizzo di ritorno, quando nella subroutine avviene un'altra

chiamata ad un'altra procedura viene salvato lindirizzo di ritorno nella cima dello stack, e cos via se ci sono


34/216

24

altre chiamate. Nelle operazioni di return, viene effettuato il salto allindirizzo in cima allo stack(lultimo

inserito) e cos via nelle return delle subroutine.

Possiamo avere anche 1000 registri in un processore, ma di questi se ne visualizzano 32 o 64 e gli altri

servono per gestire un meccanismo che viene chiamato Finestra di Registri. Per individuare un singolo

registro, tra 1000, avrei bisogno di 10 bit, e un istruzione che fa uso di 3 registri, avrebbe bisogno di soli 30bit per specificare 1000 registri. Non se ne utilizzano mai 1000 registri, di solito il valore di un registro viene

sovraccaricato dopo una operazione. Accedere a 1000 registri pi lento, bisogna connettere per esempio

un dato registro allALU(con un selettore multiplexer). Il cammino critico , il percorso che deve fare un

segnale in un circuito, dalla sorgente alla destinazione in un colpo di clock, se bisogna attraversare un

numero di gate di un selettore che ha molti ingressi molto pi lungo e si impiega pi tempo rispetto ad

uno che ne ha di meno. Si possono spezzettare i cammini critici in pi tappe e avere un clock che pu

andare pi velocemente, ma la latenza quella di attraversare un sistema: cercare una cosa tra poche cose

pi veloce che cercarla tra molte.

La Jump come la Call o come la return sono salti incondizionati. I branch sono invece salti condizionati chevengono effettuati quando sono verificate delle condizioni. Condizioni logiche su cui vengono impostati in

BRANCH. Queste condizioni da codificare sono istruzioni che possono essere calcolate molto velocemente.

Bisogna capire subito se si deve saltare una istruzione o meno. Le istruzioni di salto vanno gestite in

maniera molto pi veloce rispetto allesecuzione di un calcolo . Normalmente le istruzioni devono essere

eseguite uno dopo laltra, al termine di una viene eseguita la successiva. Per si pu pensare ad un

meccanismo in cui non si necessariamente vincolati a eseguire una istruzione dopo aver terminato la

precedente(parallelizzazione delle operazioni, pipeline). Istruzioni di questo genere possono essere iniziate

non necessariamente al termine dellistruzione precedente. Quando viene decodificata listruzione di

calcolo, questa pu durare del tempo intanto viene eseguita la successiva e nella peggiore delle ipotesi si

pu avere una dipendenza di questa istruzione con loperazione precedente. Nellistruzione di salto questo

calcolo sulla condizione deve essere fatto velocemente, perch finch non si deciso se saltare o meno non

possono essere eseguite le istruzione successive o quella nella posizione da saltare. Bisogna verificare le

condizioni nel modo pi velocemente possibile.

Set di istruzioni che codificano condizioni logiche:

EQUAL TO ==

NOT EQUAL TO !=

LESS THAN =

Una politica potrebbe essere quella di non implementare Greather Than perch questa operazione

effettuata da Less Than Or Equal To. Si possono implementare diverse situazioni per semplificare le

istruzioni.


35/216

25

Osservando la figura pag. 507, stata tracciata la frequenza dove certi bit di spiazzamento sono richiesti.

Per esempio 5 bit di spiazzamento nel 10 % dei casi e via dicendo. Il grafico arriva fino a 16 perch i

programmi alla fine considerano le istruzioni di salto realmente implementate solo con 16 bit. Questo non

significa che si possono fare dei salti da una locazione a N locazioni pi in l dove log 2N superiore a 16.

Una volta affidato al campo immediato un numero di bit , 16 come abbiamo detto, come si risolve il

problema di saltare invece che di 215locazioni in avanti (16 significa 215locazioni pi avanti e 215locazioni

indietro) ma di 228locazioni pi in l ad esempio? Servirebbero altri 13 bit che non possono essere inseriti

perch non si posso fare istruzioni pi lunghe. Per risolvere questo problema possiamo pensare a llatletica!

Se si vogliono saltare pi di 8 metri e mezzo bisogna fare un salto triplo! Quindi qualora serve realmente

spostarsi di 228locazioni pi in l, bisogna fare un salto di 215locazioni, e inserire nellistruzione 215 un'altra

istruzione di salto fino alla locazione di destinazione. Questultima istruzione di salto non condizionata.

Perch la condizione stata verificata, se era necessaria, nella prima istruzione di salto(quella di 215).

Essendo una jump questultima istruzione di salto potrebbe avere uno spiazzamento per indicare il salto ad

esempio di 26 bit. Quindi sufficiente nellistruzione di salto che vuole saltare di 228 locazionipi in l, fare

un salto di 2

15

e scrivere in questultima locazione un istruzione di salto anche incondizionato che ci proiettain un altro punto dellesecuzione. Nasce un secondo problema con questa soluzione, a seconda istruzione

di salto che inserita (dopo le 215 locazioni) viene raggiunta non solo dal primo salto ma potrebbe essere

raggiunta anche con il normale corso delle istruzioni (passo passo). Prima o poi verr raggiunta listruzione

questa istruzione di salto che effettuer un salto pi avanti senza volerlo. Si dovr inserire un altro jump,

esattamente prima dellistruzione di salto in questione , che salti questultima e quindi evitandola e che ci

riporti esattamente allistruzione successiva in modo da permettere la regolare esecuzione delle istruzioni.

Questo un altro studio che invece prende in considerazione le istruzioni, le divide in due categorie: le

LOAD e le operazioni della ALU. Verifica pi o meno com landamento relativamente a un programma che

fa uso sia di numeri floating point che ad aritmetica intera perch quando studieremo il processore

ampliando lorizzonte alla parte del processore che opera sui dati floating point ci accorgeremo che il

processore pu essere diviso in due moduli:

- Uno che opera sulle istruzioni che fanno riferimento a dati interi

-

Uno che opera sulle istruzioni che fanno riferimento a dati floating point

Le parti di logica che fanno i calcoli sono diverse, lhardware che permette di eseguire la somma di due

interi non la stessa che permette la somma di due floating point. La somma floating point prevede un

confronto fra le mantisse, lallineamento ecc. ecc. . Per cui lhardware fisicamente distinto allora

prendendo in esame le istruzioni che hanno a che fare con le operazioni floating point e le istruzioni che

hanno a che fare con i dati ad aritmetica fissa vediamo questo tipo di statistica di un benchmark che fa uso


36/216

26

di floating point. Se si osserva la figura, e ci si focalizza sulle operazioni che hanno a che fare con i dati ad

aritmetica intera, un quarto sono operazioni aritmetico logico.

Quando si effettua una LOAD, il 23% di queste usano un dato immediato che per esempio l indirizzo.

Nelle operazioni ALU, il 25% usano un dato immediato, quindi loperazione che prevede due operandi: un

operando un registro, laltro non in un registro ma in un immediato. Il compilatore quando ha tradottoquellistruzione gi sapeva qualera un operando, non doveva prenderlo da un registro. Ad esempio

tipicamente in un contatore di un loop ,i++, non ha senso mettere 1 in un registro, ad esempio R6, mettere

i in un altro registro, ad esempio R7, e ogni volta fare R7+R6 cos occupo un registro R6. Sapendo invece

che a R7 va sommato sempre 1, il compilatore nello scrivere quellistruzione scriver unistruzione di

somma con immediato, quindi scriver nellistruzione stessa il numero 1 come operando immediato ed R6.

Quindi scriver unistruzione che fatta da un codice operativo che non significa somma ma significa

somma con immediato. E poi ci sar per esempio R6, e poi limmediato 1, a significare che R6 va sommato

al numero 1 e il risultato va sempre in R6.

6. Operazioni Nellinsieme Di Istruzioni

Abbiamo accennato che i dati sono anchessi nel loro formato una caratteristica che diversifica il

processore. Quindi per esempio abbiamo dati che a partire dal singolo byte possono essere raggruppati in

categorie che comprendono le wordda 4 byte e le doppie wordda 8 byte. Esiste anche una via di mezzo le

half wordda 16 byte. Questi dati vengono effettivamente usati. Osservando la figura pag. 510, per quanto

riguarda i dati floating point, la gran parte delle operazioni riguarda dati floating point di tipo doppia word

per una certa applicazione. Questo studio serve a definire se importante considerare un ALU a 64 bit

perch per esempio se si fa in modo di trattare i dati da 64 bit come dati da 32 bit si pu pensare ad unaALU da 32 bit(prima fa il calcolo su 32 della parola e poi sugli altri 32 bit). Se invece si deve fare la somma di

due dati da 64 bit ma lALU da 32 bit si pu decidere che tutte le volte bisogna fare somme di dati da 64

bit si divide il dato in due parti da 32 e 32, e si esegue la somma di una parte e poi dellaltra e precisamente

si far la somma ovviamente prima delle due parti meno significative. Questa somma eventualmente

generer un riporto che si aggiunger alla somma delle due parti pi significative. Avendo un ALU di 32 bit

necessario eseguire in pratica due calcoli. Questa soluzione ottima fintantoch mi accorgo che dati da 64

bit con cui fare i calcoli non sono molti. Purtroppo si nota dalla figura che nel 60 % dei casi bisogna fare

calcoli con dati da 64 bit, allora ci si pone la domanda se ha senso progettare un ALU da 64 bit per fare in un

colpo solo quello che si effettuava in due colpi. Si ha senso.

Le stesse considerazioni fatte per lALU si possono fare per i registri: devono essere di 32 bit o 64 bit? Se si

pensa a una aritmetica(ALU) di 32 bit che alloccorrenza fa anche calcoli da 64 bit, i registri saranno di 32 bit

e quando si ha bisogno di dati da 64 bit verranno utilizzati due registri contigui. Ma questa coppia di registri

pu essere R7 e R17 per esempio? Teoricamente si, per comporta dei problemi;

Nellistruzione bisogner specificare R7 e R17, che contengono le due parti di un dato, poi si avr bisogno di

specificare altri due registri che contengono le parti del secondo dato, esempio R5 ed R19, ed infine si

bisogner specificare i due registri per contenere le due parti del risultato, R8 e R21 ad esempio. Sono

necessari 6 slot per indicare gli operandi. Se i registri sono contigui invece baster specificare R7, perch il

secondo pezzo sar R8; baster specificare R9, perch la seconda parte si trova in R10; ed infine per ilrisultato baster specificare R2 perch la seconda parte sar R3.


37/216

27

Un altro problema che si verifica utilizzando registri non contigui nasce quando bisogna connettere alla

parte che fa i calcoli, i due registri. Lunit di controllo diviene molto complessa.

Quindi a fronte di una massima flessibilit, che porterebbe a desiderare la libert di mettere quei 64 bit in

due registri a piacere, le cose si complicano sia dal punto di vista delle connessioni verso le unit di calcolo

e soprattutto nella strutturazione di un istruzione che dovr prevedere 6 specifiche.


38/216

28


39/216

29

CAPITOLO 5ISTRUZIONI DEL PROCESSORE MIPS

Il processore di riferimento il processore MIPS. sviluppato con filosofia RISC, ha un numero ridotto diistruzioni ma che hanno tutte una struttura molto simile tra di loro. Inoltre un processore di tipo Load-

Store, le uniche operazioni che possono accedere a memoria sono le istruzioni LOAD e STORE.

Il processore MIPS costituito da 32 registri interi da 64bit di utilizzo generale ( GPR, general-purpos

register), denominati R0, R1,, R31. Ci sono inoltre registri per numeri in virgola mobile (FPR, floating-point

register), denominati F0,F1,,F31.E infine c anche un piccolo numerodi registri speciali.

I tipi di dati presenti sono: byte(8bit), half word(16bit), word(32bit) e double word (64bit).

Esistono solo due modalit di indirizzamento, immediato e con scostamento.

Le istruzioni di questo processore sono di 32 bit e presentano tutte un codice operativo costituito da 6 bit.

Le istruzioni sono fondamentalmente di tre tipi: tipo R, tipo Ie tipo J.

1. Istruzioni di tipo J

Le istruzioni di tipoJprevedono una struttura semplice, oltre ai 6 bit del codice operativo, i rimanenti 26 bit

codificano un immediato, lindirizzo dove saltare. Larchitettura prevede indirizzi di 32 bit, quei 26 bit non

sono un indirizzo assoluto, ma sono un offset ovvero uno spiazzamento che va sommato al Program

Counter(PC).

Oltre ai comuni registri di un processore, ne esistono degli altri, chiamati registri speciali o dedicati perchnon contengono dati generici, ma dati che hanno un determinato significato. Uno di questi il PROGRAM

COUNTER (PC). Il PC un registro che contiene lindirizzo dellistruzione da eseguire. Quando viene eseguita

una istruzione serve sapere lindirizzo di questa per prelevarla e il processore conosce questo indirizzo

attraverso il PC. Quando termina una istruzione e se ne deve prelevare un'altra, il PC contiene listruzione

successiva a quella eseguita grazie a un aggiornamento che viene fatto durante lesecuzione di una

istruzione. Se PC=16byte, viene eseguita listruzione al byte 16, e considerando istruzioni istruzione di 4

byte (32bit), al termine di questa istruzione, viene incrementato il PC, PC=PC+4=16+4 = 20byte, verr

eseguita listruzione al byte 20. Durante lesecuzione di una istruzione oltre a fare quello che listruzione

richiede bisogna aggiornare il Program Counter. Necessariamente ogni volta che verr eseguita una

istruzione oltre a essere compiuto quello che listruzione richiede bisogna aggiornare il PC. Se le istruzioni

hanno tutte la stessa lunghezza, lunghezza fissa, loperazione facilitata. Un conto aggiornare il PC senza

sapere dove listruzione successiva, perch quella in corso ora ad esempio di 8 byte, e quindi bisogna

aggiornare di 8byte questa volta il PC, mentre listruzione successiva magari di 15 byte e quindi bisogner

aggiornare di 12 byte il PC.

Ritornando allistruzione di salto, questa scrive un nuovo valore nel PC, scrive il valore del nuovo indirizzo

dove saltare nel PC. Listruzione non pu contenere tutti i 32 bit dellindirizzo dove saltare perch se ne

hanno a disposizione al massimo 26 di bit nel caso di una jump. I 26 bit contengono uno spiazzamento di

quanto bisogna spostarsi dallistruzione attuale, dal PC. Ad esempio se listruzione corrente si trova

allindirizzo 90 e bisogna saltare allistruzione 150, bisogner scrivere nei 26 bit il valore 60, scopriremo chebisogner scrivere 56 perch si dar per scontato che il PC si gi incrementato di 4 byte. I salti che


40/216

30

vengono effettuati sono tutti multipli di 4 gli indirizzi si spostano di 4 in 4, visto che le istruzioni sono di 4

byte. I multipli di 4 in binario terminano con 2 zeri, gli ultimi due bit valgono zero. Si pu pensare che quei

26 bit contengono lindirizzo privato dei due zeri finali(risparmio 2 bit): 12 = 1100 => 11 = 3, scrivendo 3 (11)

ci si sta riferendo a 12(1100). Si hanno a disposizione quindi 28bit. Inoltre se il valore positivo il salto

avviene in avanti, altrimenti indietro.

2. Istruzioni di tipo R

Le istruzioni di tipo Rsono istruzioni che prevedono luso di 3 operandi di tipo registro, due operandi sono

di input e 1 operando di output: due sorgenti e una destinazione. Ricordiamo che questa una macchina

Load-Store in cui le uniche operazioni che accedono a memoria sono le Load e le Store, mentre le

operazioni aritmetiche non accedono a memoria. Larchitettura ha un certo numero di registri, ma la

visibilit solo su 32 registri, gli altri servono per la Finestra di Registro. Sono necessari allora 5 bit per

codificare un registro, poich listruzione specifica 3 registri, servono 15 bit per i registri, in sostanza 6 + 3*5= 21, gli altri 11 bit sono utilizzati per altre informazioni, se i dati sono con segno senza segno.

3. Istruzioni di tipo I

Il tipo Iprevede una struttura in cui un operando un immediato e gli altri due sono registri: 6 + 2*5 = 16bit

i restanti 16bit sono utilizzati per limmediato. Uno scenario quello in cui degli operandi sono noti.

Essendo la macchina Load-Store non si pu prelevare un operando dalla memoria attraverso un operazione

aritmetico logica, quindi gli operandi o sono tutti nei registri o qualcuno un termine noto. Solo un

operando per deve essere un termine un noto(due operandi termini noti non ha senso). Deve esisterequindi un solo immediato come sorgente non come destinazione(altrimenti si sta risolvendo una

equazione!). Il codice operativo della somma con immediato diverso dallistruzione somma senza

immediato. E il codice operativo che indica se listruzione di tipo R o di tipo I

calcolatori elettronici (biasi - narracci - albano)

Documents