Sei sulla pagina 1di 116

Architettura degli Elaboratori

e delle Reti
Pagina lasciata intenzionalmente bianca
______________________________________________________________________________i

Indice
9 Marzo 2006 .................................................................................................................................. 1
Insiemi......................................................................................................................................... 1
Funzioni booleane....................................................................................................................... 1
Mintermini .................................................................................................................................. 4
14 Marzo 2006 ................................................................................................................................ 5
Logica proposizionale................................................................................................................. 5
Porte logiche AND, OR, NOT.................................................................................................... 5
Leggi di DeMorgan..................................................................................................................... 6
Proprietà degli operatori logici ................................................................................................... 7
NAND come porta logica universale.......................................................................................... 8
Circuito Multiplexer o Selettore ............................................................................................... 10
Circuito Demultiplexer ............................................................................................................. 11
Ritardo di commutazione.......................................................................................................... 11
16 Marzo 2006 .............................................................................................................................. 12
Circuito Decoder....................................................................................................................... 13
Teorema delle Somme di Prodotti Completi (SPC) – 1a Forma Canonica............................... 14
Programmable Logic Array – PLA........................................................................................... 15
Circuito Sommatore Completo o Full Adder............................................................................ 16
Esercizi...................................................................................................................................... 17
21 Marzo 2006 .............................................................................................................................. 18
Multiplexer come porta logica universale................................................................................. 18
Maxtermini................................................................................................................................ 18
Teorema del Prodotto di Somme Complete (PSC) – 2a Forma Canonica ................................ 19
Porta logica XOR...................................................................................................................... 19
Circuito Comparatore................................................................................................................ 20
Circuito Shifter.......................................................................................................................... 21
Circuito Sommatore Completo o Full Adder con XOR............................................................ 22
Circuito Moltiplicatore.............................................................................................................. 23
Prima versione di Moltiplicatore .......................................................................................... 23
28 Marzo 2006 .............................................................................................................................. 24
Seconda versione di Moltiplicatore ...................................................................................... 24
Terza versione di Moltiplicatore........................................................................................... 25
Costo della moltiplicazione utilizzando somme e shift ............................................................ 26
Numeri Naturali ........................................................................................................................ 28
Conversione di base .................................................................................................................. 29
Da base B a base 10 .............................................................................................................. 29
Da base 10 a base B .............................................................................................................. 29
Numeri Interi – Notazione in complemento a 2........................................................................ 30
Addizione e Sottrazione............................................................................................................ 31
Overflow ................................................................................................................................... 32
Circuito Sommatore in complemento a 2 ................................................................................. 33
Esercizi...................................................................................................................................... 33
30 Marzo 2006 .............................................................................................................................. 34
______________________________________________________________________________
ii

Estensione del segno ................................................................................................................. 34


Circuiti Sequenziali................................................................................................................... 35
Circuito RS................................................................................................................................ 36
Circuito LATCH D – Bistabile Asincrono Trasparente (BAT)................................................ 37
Circuito LATCH D – Edge triggered (Flip Flop – FF)............................................................. 37
4 Aprile 2006 ................................................................................................................................ 38
Circuito Registro o Register...................................................................................................... 38
Circuito Shift Register o Registro a Scorrimento ..................................................................... 38
Automi a stati finiti nei circuiti sequenziali.............................................................................. 39
Esempio di progettazione di circuito sequenziale..................................................................... 40
6 Aprile 2006 ................................................................................................................................ 42
Formalizzazione degli automi a stati finiti................................................................................ 42
Register File – RF ..................................................................................................................... 43
I sistemi di memoria: SRAM DRAM ....................................................................................... 45
La macchina di Von Neumann ................................................................................................. 46
20 Aprile 2006 .............................................................................................................................. 47
Program Counter e Instruction Register ................................................................................... 47
Esempio didattico di CPU a 16 bit............................................................................................ 48
Circuito per realizzare ADD, SUB, AND e OR ....................................................................... 49
Diagramma temporale di un’istruzione ................................................................................ 50
Circuito per realizzare LOAD e STORE .................................................................................. 51
Circuito per realizzare tutte le istruzioni................................................................................... 52
La ALU ..................................................................................................................................... 54
MAR (Memory Address Register) e MDR (Memory Data Register) ...................................... 56
RISC vs CISC ........................................................................................................................... 57
2 Maggio 2006 .............................................................................................................................. 59
Linguaggio macchina didattico................................................................................................. 59
Istruzioni con 3 registri ......................................................................................................... 59
Istruzioni con 2 registri ......................................................................................................... 59
Istruzioni con 1 registro ........................................................................................................ 60
Istruzioni senza registri ......................................................................................................... 60
Esempio di programma ......................................................................................................... 61
4 Maggio 2006 .............................................................................................................................. 62
Il processore MIPS.................................................................................................................... 62
Istruzioni aritmetiche ............................................................................................................ 63
Istruzioni di accesso alla memoria (load/store) .................................................................... 65
Istruzioni di controllo (salto) ................................................................................................ 67
9 Maggio 2006 .............................................................................................................................. 69
Gestione dell’Input/Output ....................................................................................................... 69
Polling ................................................................................................................................... 69
Interrupt drivern .................................................................................................................... 69
Direct Memory Access - DMA............................................................................................. 69
Pipeline ..................................................................................................................................... 70
16/23 Maggio 2006 ....................................................................................................................... 75
Conflitto nelle pipeline (hazard) ............................................................................................... 75
Conflitto sui dati ................................................................................................................... 75
______________________________________________________________________________
iii

Soluzioni alla conflitto sui dati ............................................................................................. 76


Inserimento NOP (soluzione software)............................................................................. 76
Riorganizzazione del codice (soluzione software) ........................................................... 77
Data forwarding (soluzione hardware) ............................................................................. 78
Stallo (soluzione hardware) .............................................................................................. 79
Rilevazione delle dipendenze ........................................................................................... 80
Conflitto sugli indirizzi ......................................................................................................... 82
Soluzioni alla conflitto sugli indirizzi................................................................................... 82
Stallo (soluzione hardware) .............................................................................................. 82
Delayed branch (soluzione software)................................................................................ 83
Branch prediction.............................................................................................................. 84
Static branch prediction (soluzione software)................................................................... 84
Dynamic branch prediction (soluzione hardware)............................................................ 85
29 Maggio 2006 ............................................................................................................................ 86
Cache......................................................................................................................................... 86
La struttura della memoria cache del MIPS.......................................................................... 87
Calcolare la dimensione di una cache................................................................................... 88
Write Through e Write Back................................................................................................. 88
Write through .................................................................................................................... 88
Write back......................................................................................................................... 88
1 Giugno 2006............................................................................................................................... 89
Memoria virtuale....................................................................................................................... 89
Memoria virtuale paginata ........................................................................................................ 89
Memoria virtuale segmentata.................................................................................................... 91
5 Giugno 2006............................................................................................................................... 93
Rete di elaboratori..................................................................................................................... 93
Internet Protocol Suite - Architettura TCP/IP........................................................................... 94
Local Area Network – LAN ..................................................................................................... 96
Mezzi trasmissivi .................................................................................................................. 97
Doppino in rame ............................................................................................................... 97
Cavo coassiale................................................................................................................... 97
Fibre ottiche ...................................................................................................................... 97
Codifica dei dati.................................................................................................................... 99
Protocollo di accesso al servizio ......................................................................................... 100
Struttura del frame .............................................................................................................. 101
Internet Protocol – IP .............................................................................................................. 102
Stuttura del pacchetto.......................................................................................................... 103
Indirizzamento .................................................................................................................... 104
Classless Inter-Domain Routing (CIDR) ............................................................................ 105
Prefazione
Questo documento è un riassunto delle lezioni del corso “Architettura degli
Elaboratori e delle Reti” del prof. Ottavio Mario D’Antona, anno accademico
2005-2006.
Questo documento è distribuito nella speranza che possa essere utile.
L’autore non si assume nessuna responsabilità sulla veridicità e validità di
quanto scritto e consente la distribuzione gratuita totale o parziale del
contenuto.

Fabio Angelini
f_angelini@tiscali.it

16 Giugno 2006
Architettura degli Elaboratori e delle Reti 1

9 Marzo 2006
Insiemi
Quanti sono i sottoinsiemi di un insieme di N elementi ?

Dato un insieme {a, b, c}.


I suoi sottoinsiemi sono {a, b, c} {a, b} {a, c} {b, c} {a} {b} {c} {∅}.
Ad un insieme di 3 elementi corrispondono, dunque, 8 sottoinsiemi.

Dato un insieme {a, b}.


I suoi sottoinsiemi sono {a, b} {a} {b} {∅}.
Ad un insieme di 2 elementi corrispondono, dunque, 4 sottoinsiemi.

Dato un insieme {a}


I suoi sottoinsiemi sono {a} {∅}
Ad un insieme di 1 elemento corrispondono, dunque, 2 sottoinsiemi.

Deduciamo dunque che ad un insieme di N elementi corrispondono 2 N sottoinsiemi.

Funzioni booleane
a) La funzione booleana è un’applicazione dall’insieme dei numeri, le cui cifre sono composte di 0 e
1, all’insieme contenente le cifre 0 e 1.

b) La funzione booleana è una legge tale per cui, per ogni sequenza (stringa) di n bit corrisponde un
valore logico 0 oppure 1.

f : { 0,1}n → { 0,1}

Il dominio della funzione è la sequenza (stringa) di n bit, mentre il codominio è il valore 0 oppure 1.

Una funzione booleana può essere scritta sotto forma di tabella, detta tabella della verità, nel seguente
modo:

1a ennupla 1o risultato
2a ennupla 2o risultato
3a ennupla 3o risultato
... ...
... ...
ultima ennupla ultimo risultato

Il problema che ci poniamo è quello di conoscere quanto spazio occupa questa tabella.
Torniamo indietro al concetto d’insiemi e sottoinsiemi.
Architettura degli Elaboratori e delle Reti 2

Dato un insieme {a, b, c} posso stabilire una convenzione tale per cui una sequenza di 3 bit rappresenta
un sottoinsieme dell’insieme dato, stabilendo che 1 indica la presenza di un elemento e 0 la sua
assenza. i

a b c sottoinsiemi
1 1 1 ~ {a, b, c}
1 0 1 ~ {a, c}
1 1 0 ~ {a, b}
0 1 0 ~ {b}

Le possibili terne ii di bit, dunque, sono tante quanti sono i sottoinsiemi dell’insieme {a, b, c}

Deduciamo dunque che le possibili combinazioni di una stringa a n cifre di bit sono pari a 2n

Tornando alla domanda iniziale su quanto spazio occupa la tabella di una funzione booleana.
Lo spazio occupato da una tabella di una funzione booleana è pari a 2n × (n + 1)

x1 x2 x3 y
0 0 0 0
0 0 1 1
0 1 0 1
2n 0 1 1 1
1 0 0 0
1 0 1 0
1 1 0 1
1 1 1 1

n+1
Quante sono le funzioni booleane di 2 variabili ?

x y f1 f2 f3 f4 .. .. .. fn
0 0 0 0 0 0 1
0 1 0 0 0 1 1
2n 1 0 0 0 1 0 1
1 1 0 1 0 0 1

n
22
Il numero di funzioni di 2 variabili è dato da tutte le possibili combinazioni che possono assumere le
uscite, in corrispondenza dei 4 stati ( 2 2 ) delle variabili d’ingresso. Come già visto le possibili
2
combinazioni di una stringa a n cifre di bit sono pari a 2n ; quindi il numero di funzioni è pari a 2 2 .

i
il simbolo ~ deve essere letto come: associa
ii
terne o sequenze o stringhe
Architettura degli Elaboratori e delle Reti 3

In generale il numero di funzioni è pari alle possibili combinazioni che possono assumere le uscite, in
corrispondenza dei 2n stati delle variabili d’ingresso, vale a dire:
n
Numero funzioni booleane = 2 2

1
Se n=1 il numero di funzioni booleane è pari a 2 2 = 4.
Queste funzioni sono:
f1 ( x) = 0 Attenzione, qualunque sia il bit in ingresso l’uscita è 0.
f 2 ( x) = 1 Attenzione, qualunque sia il bit in ingresso l’uscita è 1.
f 3 ( x) = x Funzione identità.
f 4 ( x) = x Funzione invertente.
Architettura degli Elaboratori e delle Reti 4

Mintermini
I mintermini sono funzioni booleane che assumono il valore 1 (vero, asserito) in corrispondenza di
un’unica configurazione d’ingressi.

x y m1 m2 m3 m4
0 0 1 0 0 0
0 1 0 1 0 0
1 0 0 0 1 0
1 1 0 0 0 1

Seguendo la definizione di mintermine si deduce che il numero di mintermini corrisponde al numero di


combinazioni o ennuple delle n variabili d’ingresso, quindi:

Numero mintermini = 2n

E’ possibile stabilire un nome del mintermine associandoli il numero decimale espresso dalla
combinazione degli ingressi (#).

# x y z
0 0 0 0
1 0 0 1
2 0 1 0
3 0 1 1
4 1 0 0
5 1 0 1
6 1 1 0
7 1 1 1

P3 ( x, y, z ) è il mintermine della combinazione 011.


P6 ( x, y, z ) è il mintermine della combinazione 110.

Un mintermine può essere scritto come:

Pi ( x1 , x2 , x3 , x4 ,..., xn ) con 0 ≤ i ≤ 2n − 1

oppure:
P2 n −1 ( x1 , x2 , x3 , x4 ,..., xn )

Attenzione, un mintermine Pi ( x, y, z ) può essere diverso da uno stesso mintermine ma con numero
d’ingressi diverso Pi ( x, y )
Esempio: P4 ( x, y, z ) può essere diverso da P4 ( x, y )
Architettura degli Elaboratori e delle Reti 5

14 Marzo 2006
Logica proposizionale
Esiste un’analogia fra logica booleana e logica proposizionale.
Infatti, la proposizione: “Oggi c’è il sole” può essere vera o falsa così come vero e falso è lo stato di un
bit.
Nel calcolo proposizionale non esistono solo proposizioni vere o false.
Le proposizioni, infatti, possono essere combinate mediante operatori logici che sono:
− la congiunzione o prodotto logico
− la disgiunzione o somma logica
− la negazione
Ecco un esempio di congiunzione o prodotto logico.

PIOVE CATTIVE PREVISIONI OMBRELLO ?


NO NO NO
NO SI NO
SI NO NO
SI SI SI

Utilizzo l’ombrello se piove e ci sono cattive previsioni, se dunque entrambe le preposizioni sono vere.

Porte logiche AND, OR, NOT


Le stesse operazioni, per analogia, sono presenti nella logica booleana.
Le tre principali funzioni booleane sono descritte dalle seguenti tabelle della verità.

AND – prodotto logico OR – somma logica NOT – negazione


x y x⋅ y x y x+ y x x
0 0 0 0 0 0 0 1
0 1 0 0 1 1 1 0
1 0 0 1 0 1
1 1 1 1 1 1

Vediamo un esempio di funzione booleana f1 nelle tre variabili x, y, z .


f1 ( x, y, z ) = ( x + x ⋅ y ) ⋅ z
x y z y x ⋅ y x + x ⋅ y ( x + x ⋅ y) ⋅ z
0 0 0 1 0 0 0
0 0 1 1 0 0 0
0 1 0 0 0 0 0
0 1 1 0 0 0 0
1 0 0 1 1 1 0
1 0 1 1 1 1 1
1 1 0 0 0 1 0
1 1 1 0 0 1 1
Architettura degli Elaboratori e delle Reti 6

La rappresentazione grafica delle operazioni logiche elementari AND, OR e NOT è la seguente:


a a _
a•b a+b a a
b b

Definizione. L’insieme dei tre connettivi (operatori) AND, OR, NOT è funzionalmente completo, cioè
è sufficiente ad esprimere qualunque funzione booleana.

Definizione. L’insieme dei tre connettivi (operatori) AND, OR, NOT non è tuttavia necessario ad
esprimere qualunque funzione booleana cioè non sono necessari tutti e tre i connettivi per esprimere
qualunque funzione booleana.

Leggi di DeMorgan
Le leggi di DeMorgan affermano che un prodotto logico può essere trasformato in una somma logica e
viceversa.

x⋅ y = x + y x+ y = x⋅y

Verifichiamo quest’uguaglianza con la tabella di verità.

x y x⋅ y x y x+y x+y
0 0 0 1 1 1 0
0 1 0 1 0 1 0
1 0 0 0 1 1 0
1 1 1 0 0 0 1

La conseguenza delle leggi di DeMorgan è che possiamo utilizzare la coppia AND, NOT oppure OR,
NOT per esprimere qualunque funzione booleana. Possiamo dunque affermare che:
L’insieme {AND, NOT} è funzionalmente completo
L’insieme {OR, NOT} è funzionalmente completo
Architettura degli Elaboratori e delle Reti 7

Proprietà degli operatori logici


Le proprietà principali di questi operatori logici sono:

PROPRIETA’ AND OR
Identità x ⋅1 = x x+0 = x
Elemento nullo – Assorbimento x⋅0 = 0 x +1 = 1
Idempotenza x⋅x = x x+ x= x
Inverso – Assorbimento x⋅x = 0 x + x =1
Commutativa x⋅ y = y⋅x x+ y = y+x
Associativa ( x ⋅ y) ⋅ z = x ⋅ ( y ⋅ z) ( x + y) + z = x + ( y + z)

PROPRIETA’ AND rispetto OR OR rispetto AND


Distributiva x ⋅ ( y + z) = x ⋅ y + x ⋅ z x + y ⋅ z = ( x + y) ⋅ ( x + z )
Assorbimento x ⋅ ( x + y) = x x + x⋅ y = x

DeMorgan (1) x⋅ y = x + y x+ y = x⋅y


DeMorgan (2) x⋅ y = x + y x+ y = x⋅y

PROPRIETA’
Doppia negazione – Idempotenza x=x

Attenzione che nell’algebra booleana al contrario della matematica esiste la proprietà distributiva della
somma rispetto al prodotto.

Dimostriamo le proprietà di assorbimento:


x + x⋅ y = x raccogliamo x
x ⋅ (1 + y ) sapendo che 1 + y = 1 , abbiamo dimostrato l’uguaglianza

x ⋅ ( x + y) = x proprietà distributiva del prodotto rispetto alla somma


( x ⋅ x) + ( x ⋅ y ) proprietà di idempotenza x ⋅ x = x
x + ( x ⋅ y) otteniamo la stessa funzione precedentemente dimostrata
Architettura degli Elaboratori e delle Reti 8

NAND come porta logica universale


Utilizzando una sola porta logica possiamo esprimere qualsiasi funzione booleana.
Questa porta logica si chiama NAND e la sua rappresentazione grafica è la seguente:
a
a NAND b
b

Tabella della verità della porta NAND.

a b a NAND b
0 0 1
0 1 1
1 0 1
1 1 0

Come possiamo dimostrare che la porta NAND da sola basta ?


Dovremmo riuscire a realizzare le porte logiche AND e NOT che sappiamo essere funzionalmente
complete.

NOT realizzata utilizzando solo porte NAND


_
a a

AND realizzata utilizzando solo porte NAND (due versioni)


a
b a
a•b a•b
b
a
b

OR realizzata utilizzando solo porte NAND


a

a+b

Possiamo dunque affermare che:

L’insieme {NAND} è funzionalmente completo


Architettura degli Elaboratori e delle Reti 9

Dimostriamo, applicando le proprietà dell’algebra booleana, perchè la porta NAND è insieme di


connettivi funzionalmente completa.
Sapendo che a NAND b = a ⋅ b (1) possiamo dimostrare che:

NOT Æ a = a NAND a
a = a⋅a a = a ⋅ a per idempotenza
a ⋅ a = a NAND a per la definizione (1)

AND Æ a ⋅ b = (a NAND b) NAND (a NAND b)


a ⋅b = a ⋅b per idempotenza
a ⋅ b = a NAND b per la definizione (1)
per la definizione di NOT utilizzando
a NAND b = (a NAND b) NAND (a NAND b)
NAND

OR Æ a + b = (a NAND a) NAND (b NAND b)


a+b = a+b per idempotenza

a +b = a ⋅b per la legge di DeMorgan

a ⋅ b = a ⋅b per idempotenza
per la definizione di NOT utilizzando
a ⋅ b = a NAND b
NAND
per la definizione di NOT utilizzando
a NAND b = (a NAND a) NAND (b NAND b)
NAND
Architettura degli Elaboratori e delle Reti 10

Circuito Multiplexer o Selettore


Il Multiplexer è un circuito combinatorio cha ha la funzione di selezionare in uscita (Z) uno solo di n
ingressi (a, b), in base ad un segnale di selezione (S).
Più segnali di ingresso ci sono, più segnali di selezione saranno necessari per scegliere il segnale da
mandare in uscita. Nell’esempio sotto riportato abbiamo un Multiplexer a 2 vie, con simbolo grafico.
Multiplexer

a
a 1
Z
Z
b 0
b
S
Il valore 1 vicino all’ingresso a
indica che questo ingresso viene
selezionato quando S è uguale a 1
S

Tabella della verità del circuito Multiplexer.

a b S Z
0 0 0 0
0 0 1 0
0 1 0 1
0 1 1 0
1 0 0 0
1 0 1 1
1 1 0 1
1 1 1 1

Riduzione algebrica del circuito Multiplexer.


Z = a bS + ab S + abS + abS raccolgo aS e bS
Z = aS (b + b) + bS (a + a) sapendo che a + a = 1 e b + b = 1
Z = aS + bS

Possiamo dunque dire che quando S=1, Z=a mentre quando S=0, Z=b
Il Multiplexer è associabile all’istruzione if...then..else di un linguaggio di programmazione ad alto
livello come Java, C++, C, etc...
Architettura degli Elaboratori e delle Reti 11

Circuito Demultiplexer
Il Demultiplexer è un circuito combinatorio che utilizza n segnali di selezione per incanalare un
segnale di ingresso verso una delle 2 n uscite (n = numero di selettori)
Nell’esempio sotto riportato abbiamo un Demultiplexer con relativo simbolo grafico.

Demultiplexer

Z
a a
1
Z

b
0

b
S

Ritardo di commutazione
Bisogna sempre ricordare che i segnali impiegano un certo tempo per attraversare le porte logiche che
attraversano.

x
z
_
x

ritardo del NOT spike

Anche se teoricamente z = x ⋅ x = 0
Architettura degli Elaboratori e delle Reti 12

16 Marzo 2006
Vediamo ora come realizzare un Multiplexer per selezionare 3 ingressi.
Multiplexer a 3 vie

a
a 11
b 10 Z
b c
Z 01

c
S1 S2

S1 S2

La funzione booleana del Multiplexer a 3 vie è:


Z = a ⋅ S1 ⋅ S 2 + b ⋅ S1 ⋅ S 2 + c ⋅ S1 ⋅ S 2

Quindi per realizzare un Multiplexer utilizziamo tante porte AND quanti sono gli ingressi, in ogni
porta AND entra un differente ingresso e tutti i selettori ( S1 , S 2 ,..., S n ). Questi ultimi, asseriti o negati,
abilitano la porta AND dell’ingresso da selezionare.

Il problema che ci poniamo è quello di calcolare quanti selettori sono necessari per n ingressi.
In generale il numero di selettori necessari a selezionare n ingressi è uguale a:
Ns = ⎡log 2 n⎤ , Ns = Numero selettori

La funzione ⎡x ⎤ (ceiling) restituisce il più piccolo numero intero ≥ x


La funzione ⎣x ⎦ (floor) restituisce il più grande numero intero ≤ x
Architettura degli Elaboratori e delle Reti 13

Circuito Decoder
Il Decoder è un componente che converte un numero booleano di n cifre in ingresso in 2n uscite in cui
solo l’uscita che rappresenta il numero di ingresso è ad 1.
Decoder

S1
U0 U0
S2
S1 U1
U1
S2 U2

U2
U2

U3

Tabella della verità del circuito Decoder.


S2 S1 U0 U1 U2 U3
0 0 1 0 0 0
0 1 0 1 0 0
1 0 0 0 1 0
1 1 0 0 0 1

E’ possibile realizzare un Multiplexer con un decoder.


Multiplexer a 4 vie con decoder

Z
c

U0 U1 U2 U2

Decoder

S1 S2
Architettura degli Elaboratori e delle Reti 14

Teorema delle Somme di Prodotti Completi (SPC) – 1a Forma Canonica


Definiamo Prodotto Completo, il prodotto logico (AND) di tutte le variabili d’ingresso, asserite o
negate, che danno come risultato 1.

Qualunque funzione booleana può essere espressa come Somma di Prodotti Completi e tale scrittura è
unica.

m
⎛ n ±⎞
f ( x1 , x2 ,..., xn ) = ∑ ⎜⎜ ∏ xi ⎟⎟
j =1 ⎝ i=1 ⎠j

L’indice j cicla tra tutte le combinazioni degli ingressi che come risultato in uscita danno 1 (ricordiamo
che il numero massimo di m = 2n ).
L’indice i rappresenta la posizione della singola variabile d’ingresso del circuito e varia da 1 a n.
Il simbolo ± indica che l’ingresso può essere asserito o negato.

In altre parole, ogni termine che sommiamo logicamente (OR) è sempre composto dal prodotto logico
(AND) di tutte le variabili d’ingresso, asserite quando valgono 1 e negate quando valgono 0.

La definizione di Prodotto Completa altro non è che la definizione di mintermine.


Possiamo, quindi, affermare che ogni funzione booleana può essere espressa univocamente come
somma di mintermini.

Applichiamo il teorema SPC al circuito Multiplexer, partendo dalla tabella della verità.
x1 x2 x2 f
# a b S Z
0 0 0 0 0
1 0 0 1 0
2 0 1 0 1 Å a ⋅b⋅ S
3 0 1 1 0
4 1 0 0 0
5 1 0 1 1 Å a ⋅b ⋅ S
6 1 1 0 1 Å a ⋅b⋅ S
7 1 1 1 1 Å a ⋅b⋅ S

Possiamo scrivere la funzione in due modi.


1) Funzione dipendente dalle variabili d’ingresso a, b, S
f (a, b, S ) = a ⋅ b ⋅ S + a ⋅ b ⋅ S + a ⋅ b ⋅ S + a ⋅ b ⋅ S
2) Sommatoria di mintermini:
∑ (2,5,6,7) = a ⋅ b ⋅ S + a ⋅ b ⋅ S + a ⋅ b ⋅ S + a ⋅ b ⋅ S
Riduciamo la funzione trovata applicando i teoremi degli operatori booleani.
Z = a b S + ab S + ab S + ab S raccolgo a S e b S
Z = a S (b + b) + b S (a + a ) sapendo che a + a = 1 e b + b = 1
Z = aS + bS
Architettura degli Elaboratori e delle Reti 15

Programmable Logic Array – PLA


Sfruttando la caratteristica delle funzioni booleane che consente loro di essere rappresentate come
somme di mintermini, si sono creati dei componenti, chiamati PLA – Programmable Logic Array, che
opportunamente programmati possono realizzare una qualsiasi funzione booleana complessa.
S b a Un componente PLA
internamente è composto da
Multiplexer a 4 vie con PLA una griglia di ingressi
asseriti e negati, incrociati
_ _ _ con i segnali di ingresso ad
S S b b a a una serie di porte AND, la
_ cui uscita confluisce in
a
un’unica porta OR di
b
_ somma logica.
S
Per utilizzarla basterà
a
_ “programmare” (saldare)
b l’intersezione tra i segnali
S d’ingresso e le porte AND
Z
secondo la funzione
a booleana da implementare.
b
_ Le PLA hanno tempi di
S propagazione bassi e sono
a quindi l’ideale per costruire
b logiche combinatorie
S complesse e veloci.

L’esempio riportato in figura si riferisce alla tabella di verità del Multiplexer a 2 vie descritto nelle
precedenti pagine:
Z = a b S + ab S + ab S + ab S
Architettura degli Elaboratori e delle Reti 16

Circuito Sommatore Completo o Full Adder


Questo circuito combinatorio riceve in input due bit (a, b) da sommare con il riporto (C) ricevuto da
una precedente somma in cascata e restituisce la somma (S) comprensiva dell’eventuale riporto (R).

C C=riporto in ingresso
a R=riporto in uscita
S
b
+

Applichiamo il teorema SPC al circuito Sommatore, partendo dalla tabella della verità.

a b C S R
0 0 0 0 0
0 0 1 1 0
0 1 0 1 0
0 1 1 0 1
1 0 0 1 0
1 0 1 0 1
1 1 0 0 1
1 1 1 1 1

S = a b C + a bC + ab C + abc
R = a bC + ab C + abC + abC
R = a bC + ab C + abC + abC + abC + abC per idempotenza x = x + x
R = b C (a + a) + a C (b + b) + a b (C + C ) per assorbimento x + x = 1
R = bC + aC + ab

Questo circuito è un sommatore aritmetico da non confondere con quello logico (OR) !!!
Architettura degli Elaboratori e delle Reti 17

Utilizzando n sommatori in cascata è possibile realizzare un sommatore ad n bit.

b0 a0 b1 a1

...
+ +
...
C0 R0 C1 R1

S0 S1

Questa connessione essendo in cascata induce un ritardo dei segnali di uscita.


Il segnale R1 deve attendere che sia valido il segnale in ingresso R0, in altre parole che il primo
sommatore abbia terminato di commutare.

Esercizi
1. Calcolare quanti selettori sono necessari per selezionare 100 ingressi.
S = ⎡log 2 100⎤ = ⎡6.64⎤ = 7

2. Come realizzare un decoder con un ingresso ? Sappiamo che il numero di uscite è pari a 2i = 21 = 2
Quindi:

S1 U0
U1

3. Dimostrare che:
x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 = x1 x2 + x1 x3 + x2 x3
per idempotenza scrivo 2 volte x1 x2 x3
x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3
(x+x=x)
x1 x2 ( x3 + x3 ) + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 + x1 x2 x3 raccolgo x1 x2
x1 x2 ( x3 + x3 ) + x1 x3 ( x2 + x2 ) + x1 x2 x3 + x1 x2 x3 raccolgo x1 x3
x1 x2 ( x3 + x3 ) + x1 x3 ( x2 + x2 ) + x2 x3 ( x1 + x1 ) raccolgo x2 x3
x1 x2 + x1 x3 + x2 x3 per assorbimento ( x1 + x1 = 1)

4. Definire una funzione booleana di 4 variabili che vale 1 se e sole se 3 ingressi valgono 1
f ( x1 , x2 , x3 , x4 ) = x1 x2 x3 + x1 x2 x4 + x1 x3 x4 + x2 x3 x4
Architettura degli Elaboratori e delle Reti 18

21 Marzo 2006
Multiplexer come porta logica universale
Il multiplexer opportunamente configurato può essere utilizzato per realizzare qualsiasi porta logica
(AND, OR, NOT).

Ricordiamo che la funzione booleana di un Multiplexer a due vie è Z = aS + bS

AND ( b = S )
Z = ab + bb bb = 0
Z = ab

OR ( a = S )
Z = aa + ba aa = a
Z = a + ba distributiva della somma rispetto al prodotto
Z = (a + b) (a + a ) a + a =1
Z =a+b OR

NOT ( a = 0 e b = 1 )
Z = 0 S + 1S 0 S = 0 e 1S = S
Z =S NOT

Questo approccio può avere un senso se durante la progettazione/realizzazione di un circuito non


abbiamo a disposizione integrati con porte AND, OR, NOT ma solo integrati con circuiti multiplexer.

Maxtermini
I maxtermini sono funzioni booleane che assumono il valore 0 (falso, negato) in corrispondenza di
un’unica configurazione di ingressi.

x y m1 m2 m3 m4
0 0 0 1 1 1
0 1 1 0 1 1
1 0 1 1 0 1
1 1 1 1 1 0
Architettura degli Elaboratori e delle Reti 19

Teorema del Prodotto di Somme Complete (PSC) – 2a Forma Canonica


Definiamo Somma Completa, la somma logica (OR) di tutte le variabili d’ingresso, asserite o negate,
che danno come risultato 0.

Qualunque funzione booleana può essere espressa come Prodotto di Somme Complete e tale scrittura è
unica.

m
⎛ n ±⎞
f ( x1 , x2 ,..., xn ) = ∏ ⎜ ∑ xi ⎟
j =1 ⎝ i =1 ⎠j

L’indice j cicla tra tutte le combinazioni degli ingressi che come risultato in uscita danno 0 (ricordiamo
che il numero massimo di m = 2n ).
L’indice i rappresenta la posizione della singola variabile d’ingresso del circuito e varia da 1 a n.

In altre parole, ogni termine che moltiplichiamo logicamente (AND) è sempre composto dalla somma
logica (OR) di tutte le variabili d’ingresso, negate quando valgono 1 e asserite quando valgono 0.

La definizione di Somma Completa altro non è che la definizione di maxtermine.


Possiamo, quindi, affermare che ogni funzione booleana può essere espressa univocamente come
prodotto di maxtermini.

Porta logica XOR


Un’altra porta logica utile nella realizzazione di circuiti è lo XOR o eXclusive OR.

a b a XOR b
a 0 0 0
a XOR b 0 1 1
b
1 0 1
1 1 0
analizzando la tabella della verità notiamo che l’operatore XOR restituisce 0 quando i suoi ingressi
sono uguali. E’ dunque ideale per realizzare un comparatore digitale.
Architettura degli Elaboratori e delle Reti 20

Circuito Comparatore
Un Comparatore è un circuito combinatorio la cui uscita assume valore 1 quando le due stringhe di bit
in ingresso sono uguali fra loro.
Nell’esempio sotto riportato abbiamo un Comparatore di 3 bit.

a0
b0

a1
y/n
b1

a2
b2

Analizzando il circuito notiamo che gli ingressi dell’OR assumono il valore 0 quando gli ingressi a, b
sono uguali fra loro. Ma se gli ingressi dell’OR assumono il valore 0, l’uscita dello stesso assume
valore 0 che negata diventa 1. Quindi quando gli ingressi sono uguali, l’uscita assume valore 1.
Architettura degli Elaboratori e delle Reti 21

Circuito Shifter
Uno Shifter è un circuito combinatorio che ha la funzione di spostare a destra o a sinistra (traslare) i
segnali di ingresso in base ad un segnale di controllo (C).
Nell’esempio sotto riportato abbiamo uno Shifter di 4 bit.

D0 D1 D2 D3

A0 A1 A2 A3 A4 A5

Shifter

S0 S1 S2 S3

Le funzioni booleane di questo circuito sono:


S 0 = C ⋅ D1
S1 = C ⋅ D0 + C ⋅ D 2
S 2 = C ⋅ D1 + C ⋅ D3
S 3 = C ⋅ D2
Analizziamo il circuito supponendo C=1.

S0 = 0 S1 = 1 ⋅ D0 + 0 ⋅ D 2 S 2 = 1 ⋅ D1 + 0 ⋅ D3 S 3 = 1 ⋅ D2
S0 = 0 S1 = D0 S 2 = D1 S 3 = D2

Quando C=1, gli ingressi D0, D1, D2, D3 vengono traslati di una posizione.
Analogamente si dimostra che con C=0 gli ingressi vengono traslati nel senso opposto.
Architettura degli Elaboratori e delle Reti 22

Circuito Sommatore Completo o Full Adder con XOR


Abbiamo già visto come realizzare un sommatore completo, ora vediamo un esempio di sommatore
completo realizzato utilizzando le porte logiche XOR.
C

a S
b

R
Architettura degli Elaboratori e delle Reti 23

Circuito Moltiplicatore
Innanzitutto rivediamo la moltiplicazione di due numeri binari, con l’obiettivo di ricordare i passi ed i
nomi degli operandi. Proviamo a moltiplicare 100 × 100
1 0 0 Moltiplicando
1 0 0 × Moltiplicatore
0 0 0
0 0 0 / +
1 0 0 / / +
1 0 0 0 0 = Prodotto

Il primo operando e chiamato moltiplicando ed il secondo moltiplicatore. Il risultato finale è chiamato


prodotto. Come si ricorderà, l’algoritmo imparato alle elementari consiste nel prendere le cifre del
moltiplicatore una alla volta da destra a sinistra, nel moltiplicare il moltiplicando per la singola cifra
del moltiplicatore, e nello scalare il prodotto intermedio una cifra alla volta verso sinistra rispetto ai
precedenti prodotti intermedi. La prima osservazione riguarda il numero di cifre del prodotto, che è
considerevolmente più ampio rispetto sia al moltiplicando che al moltiplicatore. Infatti, se si ignorano i
bit di segno, la lunghezza del prodotto di un moltiplicando su n bit e di un moltiplicatore su m bit è un
numero lungo n+m bit. Sono quindi necessari n+m bit per rappresentare tutti i possibili prodotti.
Con due sole possibilità, ciascun passo della moltiplicazione è semplice:
1. Si mette una copia del moltiplicando (1 x moltiplicando) nella posizione
opportuna se la cifra del moltiplicatore è 1, oppure
2. Si mette 0 (0 x moltiplicando) nella posizione opportuna se il moltiplicatore è 0.

Prima versione di Moltiplicatore


Vediamo ora un primo circuito per eseguire le moltiplicazioni fra numeri a 32 bit.

63 0
Moltiplicando (64 bit)

Shift Left

31 0
Sommatore (64 bit) Moltiplicatore (32 bit)
+ Shift Right
Controllo

M0 = 0/1

63 0
Risultato (64 bit)
Write

Il moltiplicando su 32 bit risiede inizialmente nella metà destra del registro Moltiplicando ed è traslato
a sinistra di 1 bit ad ogni passo. Il moltiplicatore è traslato a destra di 1 bit ad ogni passo. L’algoritmo
parte con il prodotto inizializzato a 0. La logica di controllo decide quando scalare i registri
Moltiplicando e Moltiplicatore e quando scrivere i nuovi valori nel registro Risultato.
Architettura degli Elaboratori e delle Reti 24

Algoritmo
Risultato=0
Ripeti per 32 volte
M0 = Bit Meno Significativo (Moltiplicatore)
Se M0 uguale a 1
Risultato = Risultato + Moltiplicatore
Shift Left (Moltiplicando)
Shift Right (Moltiplicatore)

Questo circuito però presenta un problema: è necessario utilizzare 3 registri a 64 bit con conseguente
complicazione della logica del processore.

28 Marzo 2006
Seconda versione di Moltiplicatore
Vediamo ora un secondo circuito per eseguire le moltiplicazioni fra numeri a 32 bit in cui vengono
utilizzati solo registri a 32 bit.

31 0
Moltiplicando (32 bit)

31 0
Sommatore (32 bit) Moltiplicatore (32 bit)
+ Shift Right
32
Controllo

M 0 = 0/1

63 32 31 0
Risultato (64 bit)
Shift Right

L’algoritmo del precedente circuito esegue una traslazione verso sinistra del moltiplicando inserendo
degli 0 nelle nuove posizioni, così che il moltiplicando non può influenzare i bit meno significativi del
risultato. Questo nuovo circuito utilizza il procedimento inverso. Le somme intermedie risiedono nella
parte alta del Risultato (63-32) che viene traslato verso destra ad ogni passo.

Algoritmo
Risultato=0
Ripeti per 32 volte
M0 = Bit Meno Significativo (Moltiplicatore)
Se M0 uguale a 1
Risultato63-32 = Risultato63-32 + Moltiplicatore
Shift Right (Risultato)
Shift Right (Moltiplicatore)
Architettura degli Elaboratori e delle Reti 25

Terza versione di Moltiplicatore


Vediamo ora un terzo circuito per eseguire le moltiplicazioni fra numeri a 32 bit.

31 0
Moltiplicando (32 bit)

Sommatore (32 bit)


+
32

Controllo
M 0 = 0/1
63 32 31 0
Risultato Parz. Moltiplicatore
Shift Right
Risultato (64 bit)

Questo circuito nasce dall’osservazione che il registro Risultato spreca uno spazio che corrisponde
esattamente alla dimensione del Moltiplicatore. I 32 bit meno significativi del Risultato vengono ora
utilizzati per memorizzare il Moltiplicatore.

Algoritmo
Risultato63-32=0
Risultato31-0= Moltiplicatore
Ripeti per 32 volte
M0 = Bit Meno Significativo (Risultato)
Se M0 uguale a 1
Risultato63-32 = Risultato63-32 + Moltiplicatore
Shift Right (Risultato)
Architettura degli Elaboratori e delle Reti 26

Costo della moltiplicazione utilizzando somme e shift


Il sistema classico per moltiplicare due numeri è quello che abbiamo già visto.
Supponiamo di volere moltiplicare m × f
dove f = d n −1 d n − 2 ... d 0

m ×
d3 d2 d1 d0 =
d0 × m + Æ d0 × m
d1 × m + Æ Shift1 (d1 × m)
d2 × m + Æ Shift 2 (d 2 × m)
d3 × m + Æ Shift3 (d 3 × m)
m× f =

La moltiplicazione sopra riportata può essere espressa come:


n −1
m × f = ∑ Shifti (d i × m)
i =0

Il problema che ci poniamo è quello di voler calcolare quante somme e shift dovremo eseguire per
effettuare la moltiplicazione.
Calcoliamo quanti shift dobbiamo eseguire.
Nell’esempio abbiamo moltiplicato 4 cifre ( d 0 ... d 4 ) e abbiamo eseguito 1 shift per la seconda
moltiplicazione, 2 shift per la terza moltiplicazione e 3 shift per la quarta moltiplicazione.
Il numero di shift è dunque uguale alla somma dei primi N-1 numeri (1+2+3).
n −1
S = ∑i
i =0
La somma dei primi N numeri interi sappiamo essere uguale a:
n (n + 1)
S= (Gauss)
n
sostituendo n con n-1 otteniamo:
(n − 1) (n − 1 + 1) n (n − 1)
S= =
n n
Notiamo che il costo degli shift è quadratico.

Calcoliamo quante somme dobbiamo eseguire.


Per conoscere il numero delle somme dobbiamo esprimere la moltiplicazione n × m sotto forma di
somme ripetute.
n × m = m1 + m2 + ... + mn
Vediamo un esempio 3 × m = m + m + m
Il numero di addizioni per eseguire una qualsiasi moltiplicazione è uguale a n − 1 .
Quindi il numero totale di addizioni della nostra formula è:
An = d 0 − 1 + d1 − 1 + d 2 − 1 + ... + d n −1 − 1 + n − 1
l’ultimo n − 1 è il numero di addizioni eseguite per i prodotti parziali.
Architettura degli Elaboratori e delle Reti 27

An = d 0 + d1 + d 2 + ... + d n −1 − n + n − 1 = d 0 + d1 + d 2 + ... + d n −1 − 1
Notiamo che il costo delle addizioni è lineare.

Quale è il caso peggiore ? (quello che implica più somme)


E’ quello dove la generica cifra d i della generica base B vale B − 1 (nel sistema decimale è 9).
di = B − 1
allora
An = ( B − 1) 0 + ( B − 1)1 + ( B − 1) 2 + ... + ( B − 1) n −1 − 1 = n × ( B − 1) − 1
Architettura degli Elaboratori e delle Reti 28

Numeri Naturali
Il sistema numerico che utilizziamo comunemente è chiamato posizionale perchè ogni cifra che
compone la stringa dei numeri assume un peso in corrispondenza della posizione che occupa.
Un numero γ di n cifre viene rappresentato nel modo seguente:
γ = cn −1 cn − 2 ... c2 c1 c0

e il numero naturale che rappresenta è uguale all’espressione:

n −1
V = ∑ ci × B i
i =0

i = posizione della cifra


c = cifra appartenente ad un alfabeto Ω di B simboli distinti
B = base del numero
n = numero di cifre che compongono il numero

Ad esempio, nel sistema decimale (B=10, Ω=0,1,..9), la sequenza γ = 284 può essere espressa come:
2 × 102 + 8 × 101 + 4 × 100

La numerazione naturale in base B di un numero composto da n cifre, rappresenta numeri da 0 a B n − 1

Gli elaboratori digitali utilizzano, per rappresentare le informazioni al proprio interno, il codice binario
costituito dai simboli 0 ed 1.
Una numero naturale binario di n bit può essere rappresentato mediante:

n −1 Min = 0
V = ∑ bi × 2i , b ∈ {0,1}
i =0
Max = 2 n − 1

Oltre alla numerazione binaria, spesso si utilizzano la numerazione in base 8 (ottale) ed in base 16
(esadecimale).
Insieme dei simboli in base 8 = {0, 1, 2, 3, 4, 5, 6, 7}
Insieme dei simboli in base 16 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 , A, B, C, D, E, F}
Architettura degli Elaboratori e delle Reti 29

Conversione di base
Da base B a base 10
Per effettuare la conversione da base B a base 10 di un numero naturale si procede in modo diretto, con
il metodo polinomiale già definito.
n −1
V(10) = ∑ ci × B i
i =0

Quindi per convertire la stringa 1101 in base 2 nell’equivalente numero in base 10:
1101( 2) = 1 × 23 + 1 × 2 2 + 0 × 21 + 1 × 20 = 12(10)

Da base 10 a base B
Per effettuare la conversione da base 10 a base B, si utilizza un metodo iterativo:
1) si divide il numero V(10 ) per la base B
2) il resto costituisce la cifra meno significativo di V( B )
3) il quoziente costituisce il nuovo numero V(10 )
4) il metodo viene iterato finché si ottiene quoziente = 0

Proviamo a convertire il numero 26 in base 10 nell’equivalente numero in base 2

Numero 26 :
2
Quoziente = 13 : Resto = 0
2
direzione di lettura

Quoziente = 6 : Resto = 1
2
Quoziente = 3 : Resto = 0
2
Quoziente = 1 : Resto = 1
2
Quoziente = 0 Resto = 1

Quindi 26(10 ) = 11010( 2)


Architettura degli Elaboratori e delle Reti 30

Numeri Interi – Notazione in complemento a 2


La rappresentazione dei numeri interi nei calcolatori si chiama rappresentazione in complemento a
due.

Per ottenere il complemento a due di un numero binario V se ne invertono, o negano, i singoli bit infine
si somma 1 al valore del numero trovato con questa operazione.
Facciamo un esempio con la rappresentazione a 8 bit del numero 00101101( 2) = 45 (10 )
b7 b6 b5 b4 b3 b2 b1 b0
0 0 1 0 1 1 0 1 V( 2 )
1 1 0 1 0 0 1 0 + V ( 2)
1 + 1
1 1 0 1 0 0 1 1 = − V( 2 )

Quindi − 45 (10) = 11010011( 2) con 8 bit


Cerchiamo di dimostrare la validità del procedimento sopra descritto.
Dobbiamo verificare che la somma di un numero V con il suo complemento a due è uguale a 0.
Sappiamo infatti che V − V = 0
V = bn −1 bn − 2 ... b0 − V = bn −1 bn − 2 ... b0 + 1
1 1 1 1 Riporto
bn −1 bn − 2 ... b1 b0 V
bn −1 bn − 2 ... b1 b0 + V
1 + 1
1 0 0 0 0 0 0 Risultato
Ricordiamoci che bi + bi = 1

Per ottenere il complemento a due di un numero decimale V con la rappresentazione a n bit, si sottrae a
2 n il numero V e si converte in binario il risultato ottenuto mediante il metodo iterativo.
− V( 2) = dec 2bin(2 n − V(10 ) )

Facciamo un esempio con la rappresentazione a 8 bit del numero 45 (10 ) = 00101101( 2)


− V(10 ) = 2 8 − 45 = 256 − 45 = 211 ⇒ − V( 2 ) = 11010011

Nella rappresentazione in complemento a due, il bit iniziale (più a sinistra) del numero ne indica il
segno: se è 0, il numero è positivo; se è 1, il numero è negativo.
Architettura degli Elaboratori e delle Reti 31

Una numero intero binario di n bit può essere rappresentato mediante:

n−2
Min = − 2n −1
V = −bn −1 2n −1 + ∑ bi 2i , b ∈ {0,1}
i =0 Max = 2n −1 − 1

Facciamo un esempio di rappresentazione in decimale del numero binario 11010011( 2) in complemento


a due .
n−2
V = −bn −1 2n −1 + ∑ bi 2i = −1 × 27 + 1 × 26 + 1 × 24 + 1 × 21 + 1 × 20 = −128 + 64 + 16 + 2 + 1 = −45
i =0

E’ importante notare che quando viene rappresentato un numero binario deve essere specificato il
numero massimo di bit e il tipo di notazione (naturale o in complemento a due).

Addizione e Sottrazione
Iniziamo con la somma di due bit:
0 0 1 1
0 + 1 + 0 + 1 +
0 = 1 = 1 = 1 0 =

L’addizione di due numeri avviene nel modo consueto.


Proviamo ad eseguire questa operazione: 15 + 2
1 1 1 Riporto
0 0 0 0 1 1 1 1 15
1 0 + 2
0 0 0 1 0 0 0 1 = 17

La sottrazione di due numeri avviene convertendo in complemento a due il sottraendo


(differenza=minuendo-sottraendo).
Proviamo ad eseguire questa operazione: 15 – 2 = 15 + (-2)
1 1 1 1 1 1 1 Riporto
0 0 0 0 1 1 1 1 15
1 1 1 1 1 1 1 0 + -2
(1) 0 0 0 0 1 1 0 1 = 13

Questo processo gioca sulla lunghezza fissa di 8 bit della rappresentazione: viene ignorato un riporto di
1 che causerebbe un’overflow, e rimane il risultato corretto dell’operazione.
Architettura degli Elaboratori e delle Reti 32

Overflow
Nella notazione dei numeri naturali, l’overflow è rappresentato dal superamento del numero di bit che
un calcolatore utilizza. Supponiamo di eseguire una somma con 8 bit.

1 Riporto
1 1 0 0 0 0 0 0 192
0 1 1 0 0 0 0 0 + 64
1 0 0 1 0 0 0 0 0 = 288 > 2n − 1

Nella notazione in complemento a due, l’overflow è rappresentato dall’incongruenza fra il segno del
risultato e il segno del risultato atteso.
Si verifica un overflow nella addizione di interi in complemento a due se e solo se:
− la somma di due interi positivi dà come risultato un intero negativo
− la somma di due interi negativi dà come risultato un intero positivo

Come è possibile rilevare l’overflow in un sommatore ?


Scriviamo la tabella della verità del bit più significativo dei due addendi e del risultato in uscita (Un).
(ricordiamoci che il bit più significativo indica il segno del numero)

Tipo an bn Un Overflow
P+P 0 0 0 0
P+P 0 0 1 1
P+N 0 1 0 0
P+N 0 1 1 0
N+P 1 0 0 0
N+P 1 0 1 0
N+N 1 1 0 1
N+N 1 1 1 0
P=Positivo, N=Negativo

O = an ⋅ bb ⋅ U n + an ⋅ bb ⋅ U n

Esempio P+P con risultato di segno incongruente (vedi bit più significativo del risultato)
1 1 1 Riporto
0 1 1 1 0 0 0 0 112
0 1 1 1 0 0 0 0 + 112
1 1 1 0 0 0 0 0 = -32 (risultato atteso 224)

Esempio N+N con risultato di segno incongruente (vedi bit più significativo del risultato)
1 Riporto
1 0 0 1 0 0 0 0 -112
1 0 0 1 0 0 0 0 + -112
1 0 0 1 0 0 0 0 0 = 32 (risultato atteso -224)
Architettura degli Elaboratori e delle Reti 33

Circuito Sommatore in complemento a 2


Questo circuito sfrutta il sommatore già incontrato ma utilizza un segnale S per eseguire l’operazione
a+b oppure a-b.

Mux a±b
b 0
+

S C R

S a b C OP
0 a b 0 a+b
1 a b 1 a-b

Il circuito rappresenta il bit meno significativo ( b0 ) di un sommatore in complemento a due.


In un sommatore a cascata i restanti sommatori ( bn −1 bn − 2 ...b1 ) hanno il solo circuito multiplexer per
negare l’ingresso b, mentre i riporti seguono lo schema già visto.

Esercizi
1. Quanto vale 100 in base 2, 10, 16 ?
100( 2 ) = 1 × 2 2 + 0 × 21 + 0 × 20 = 4
100(10 ) = 1 × 10 2 + 0 × 101 + 0 × 100 = 100
100(16 ) = 1 × 16 2 + 0 × 161 + 0 × 160 = 256

2. Convertire il numero 13 da base 10 a base 2


13 2
6 1
3 1
1 0
0 1
13(10) = 1011
Architettura degli Elaboratori e delle Reti 34

30 Marzo 2006
Estensione del segno
Un numero in complemento a due non cambia valore se viene esteso di una cifra a sinistra pari al
valore della cifra più significativa.

b3 b2 b1 b0 ≡ b3 b3 b2 b1 b0

Verifichiamo quanto affermato dimostrando che i due numeri sono equivalenti


2 3
− b3 23 + ∑ bi 2i ≡ − b3 24 + ∑ bi 2i
i =0 i =0
2 2
− b3 23 + ∑ bi 2i ≡ − b3 24 + b2 23 + ∑ bi 2i esplicito l’ultimo addendo
i =0 i =0
elimino le sommatorie che sono uguali
− b3 23 ≡ − b3 2 4 + b2 23 da entrambe le parti

Sostituendo b3 = 1 (ricordiamo che siamo in complemento a due, quindi la cifra più significativa vale 1)
− 8 = −16 + 8 = −8

A cosa serve l’estensione del segno ?


Supponiamo di avere un sommatore a 16 bit che riceve in ingresso un numero in complemento a due a
8 bit.

b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0


+512 (16 bit) 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
-1 (8 bit) ? ? ? ? ? ? ? ? 1 1 1 1 1 1 1 1
risultato ? ? ? ? ? ? ? ? 1 1 1 1 1 1 1 1

L’estensione del segno del numero a 8 bit ci consente di eseguire l’operazione.

b15 b14 b13 b12 b11 b10 b9 b8 b7 b6 b5 b4 b3 b2 b1 b0


+512 (16 bit) 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
-1 (8 bit) 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
risultato 511 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
Architettura degli Elaboratori e delle Reti 35

Circuiti Sequenziali
I Circuiti Sequenziali sono circuiti i cui segnali di uscita dipendono non solo dai segnali di ingresso ma
anche dallo stato all’interno del circuito stesso:

O = f ( I , S ) I = ingressi, S = stati

In questi circuiti si introduce il concetto di stato del sistema e di tempo.

Lo stato del sistema è dato dalla capacità del circuito di memorizzare e preservare un valore che
influisce sui segnali di ingresso.

Il tempo acquista valore perchè la funzione di uscita dovrà tener conto dello stato del sistema al tempo
t e utilizzarlo per calcolare il proprio stato al tempo t + 1.

Una circuito sequenziale è costituito da blocchi di logica combinatoria collegati da segnali di


“feedback” (retroazione). I valori logici ad un certo tempo di alcune delle variabili intermedie o finali
di uno o più blocchi, sono riportati in ingresso allo stesso blocco o ad un altro, in tempi successivi.

Il circuito sequenziale è il circuito base che realizza l’elemento fondamentale dei sistemi dinamici: la
memoria.
Architettura degli Elaboratori e delle Reti 36

Circuito RS
Il circuito sequenziale RS , Reset and Set, realizza un circuito di memoria e ha la caratteristica di avere
due ingressi, uno per affermare l’uscita Q, l’altro per negarla. Gli altri valori di ingresso lasciano
inalterato il valore dell’uscita Q mentre la combinazione di ingressi R = 1 e S = 1 non è consentita.

Tabella transazioni di stato


R R S Q(t ) Q( t +1) Q( t +1)
Q
0 0 0 0 1
0 0 1 1 0
0 1 0 1 0
_
0 1 1 1 0
Q
S 1 0 0 0 1
1 0 0 0 1
1 1 – – –

Se esprimiamo in forma algebrica il legame tra ingressi ed uscita e teniamo presente che le due
equazioni devono essere simultaneamente verificate, otteniamo un sistema di due equazioni, in cui Q
che chiameremo Qa e Q che chiameremo Qb sono le incognite ed R ed S le costanti:
⎧⎪ Qa = R + Qb

⎪⎩ Qb = S + Qa
Possiamo risolvere questo sistema di equazioni nei 4 casi possibili per le costanti R ed S:
1) S = 0; R = 0 2) S = 0; R = 1
⎧⎪ Qa = 0 + Qb = Qb ⎧⎪ Qa = 1 + Qb = 1 = 0
⎨ ⎨
⎪⎩ Qb = 0 + Qa = Qa ⎪⎩ Qb = 0 + Qa = Qa = 0 = 1
vi sono due possibili soluzioni: evidentemente la soluzione è unica:
Qa = 0; Qb = 1 oppure Qa = 1; Qb = 0 Qa = 0; Qb = 1
3) S = 1; R = 0 4) S = 1; R = 1
⎧⎪ Qa = 0 + Qb = Qb = 0 = 1 ⎧⎪ Qa = 1 + Qb = 1 = 0
⎨ ⎨
⎪⎩ Qb = 1 + Qa = 1 = 0 ⎪⎩ Qb = 1 + Qa = 1 = 0
evidentemente la soluzione è unica: evidentemente la soluzione è unica:
Qa = 1; Qb = 0 Qa = 0; Qb = 0

La configurazione S=R=1 va però scartata per evitare le difficoltà che nascono, non quando la
condizione è in atto, ma quando da essa si passa alla combinazione in cui entrambi gli ingressi sono a
“0”. Se, dalla condizione S=R=1, si passa al caso S=1 e R=0, oppure S=0 ed R=1 non nascono
particolari problemi. Se, però, si passa alla condizione S=R=0, lo stato di arrivo è indefinito, perché, se
le porte NOR hanno tempi di propagazione esattamente uguali, il circuito entra in oscillazione
Nell’ipotesi, più vicina alla realtà, che le due porte logiche abbiamo ritardi anche lievemente differenti,
il circuito si mette in uno dei due stati possibili. Anche in questo caso, però, lo stato finale non è
predicibile e questa situazione di uso del circuito va quindi evitata.
Architettura degli Elaboratori e delle Reti 37

Circuito LATCH D – Bistabile Asincrono Trasparente (BAT)


Questo circuito è composto da un circuito sequenziale RS con gli ingressi R e S pilotati da un bit di
dato D e abilitati da un segnale di controllo C (o clock)

FlipFlop D Tabella transizioni di stato


FlipFlop RS C Q(t +1)
D
R Qt
Q 0
1 D
C

_
Q
S

Quando C = 0, gli ingressi D e D non hanno significato ( D ⋅ 0 = 0 e D ⋅ 0 = 0 )


R = 0, S = 0 Æ il circuito mantiene lo stato precedente

Quando C = 1, gli ingressi D e D diventano gli ingressi del circuito RS ( D ⋅ 1 = D e D ⋅ 1 = D )


R = D , S = D Æ l’uscita Q è uguale al segnale D in ingresso

Questo tipo di circuito è detto bistabile. Il termine bistabile deriva dal fatto che tale elemento è stabile
in due stati (0 e 1) e che le transizioni di stato sono forzate da un segnale di controllo.

Circuito LATCH D – Edge triggered (Flip Flop – FF)


Questo circuito è composto da due Latch D in cascata, pilotati da un segnale di controllo C.
Il cambiamento del segnale di uscita Q avviene solo in presenza del fronte di discesa del segnale di
controllo, realizzando così un dispositivo sincronizzato.

E’ il componente fondamentale di ogni calcolatore col quale si realizzano per esempio i registri della
CPU.

FlipFlop D edge triggered

Latch D Latch D
D Q' D' Q

Master Slave
Architettura degli Elaboratori e delle Reti 38

4 Aprile 2006
Circuito Registro o Register
Un Registro è un circuito in grado di memorizzare un insieme di bit.
Per realizzarlo possiamo utilizzare un numero di flip-flop di tipo D pari al numero di bit che si
vogliamo memorizzare. Il segnale di controllo C viene riportato su tutti i bistabili in quanto la
memorizzazione avviene in parallelo.

Dn-1 Dn-2 D2 D1 D0
C

Q n-1 Q n-2 Q2 Q1 Q0

Circuito Shift Register o Registro a Scorrimento


Uno Shift Register è un circuito in grado di convertire una sequenza seriale di bit in ingresso in un
stringa di bit in uscita (conversione seriale Æ parallela).
Il segnale D in ingresso viene traslato (shift) da flip-flop a flip-flop ad ogni cambio di stato del segnale
di controllo C.
Questo tipo di circuito è un registro, quindi le sue uscite sono stabili e permanenti.
b0 b1 b2 b3

Flip Flop Flip Flop Flip Flop Flip Flop

D D Q D Q D Q D Q

C C C C
d3 d2 d1

Ogni rettangolo dn indica un ritardo di valore n, per consentire agli ultimi flip-flop di commutare prima
in modo tale che sia rispettata la traslazione b2 → b3 , b1 → b2 , b0 → b1 , D → b0 ,
Architettura degli Elaboratori e delle Reti 39

Automi a stati finiti nei circuiti sequenziali


Il modello concettuale che si utilizza nella progettazione dei circuiti sequenziali si chiama automa a
stati finiti.
Il comportamento di un automa può essere rappresentato mediante un grafo in cui gli archi
rappresentano le transizioni fra stati e i cerchi rappresentano gli stati. Gli stati finali sono evidenziati
da cerchi doppi. I simboli sugli archi sono gli input del sistema.

Gli automi a stati finiti ci consentono di formalizzare solo una parte del circuito sequenziale, quella
dotata di memoria (flip-flop). Infatti, la struttura generale di una macchina sequenziale, è la
seguente:
I 0 D0 U0

memorizzazione
I 1
Circuito di D1 U1

Circuito di
pilotaggio
I 2 D2 U2

I n-1 D n-1 U n-1

Dobbiamo, dunque, progettare una circuito di pilotaggio (combinatorio) che attivi il circuito di
memorizzazione affinché il sistema finale (circuito) sia realizzato.
Questo circuito combinatorio ha come ingressi, gli ingressi del sistema e uno o più segnali di
retroazione (feedback) necessari a conoscere lo stato corrente del circuito di memorizzazione.
La procedura da seguire nella progettazione di reti sequenziali è la seguente:
1) disegnare l’automa che rappresenta il circuito
2) calcolare il numero di bistabili necessari a realizzare il circuito di memorizzazione
3) scrivere la tabella di verità del circuito (meglio dire tabella di transazione di stato)
4) progettare il circuito di pilotaggio utilizzando la prima forma canonica (SPC)

Il numero di bistabili necessari a realizzare il circuito di memorizzazione è il seguente:


Nb = log 2 Ns , Nb = Numero bistabili Ns = Numero stati

Descriviamo con questo modello il comportamento di un flip-flop Latch D, partendo dalla tabella delle
transizioni di stato.
D C Qt +1 Qt +1
0 0 Qt Qt D = segnale in ingresso
0 1 0 D C = segnale di controllo (clock)
1 0 Q t Qt

1 1 1 D
Architettura degli Elaboratori e delle Reti 40

L’automa che rappresenta il circuito Latch D è il seguente:


00 00

start
11

10 0 1 10

01

01 11
Ad ogni stato dell’automa associamo un numero binario sequenziale (S0=0, S1=1) e partendo dallo
stato iniziale S0 tracciamo un arco ogni qualvolta riceviamo una coppia di nuovi valori in ingresso che
conduce ad un nuovo stato o allo stato attuale.

Esempio di progettazione di circuito sequenziale


Progettiamo un circuito che riconosca tutte le sequenze binarie che contengono consecutivamente 3 bit
a 1 (010100111, 11000111, etc...).
Il seguente diagramma mostra l’automa a stati finiti che realizza il circuito.
0 1

1 1 1

00 01 10 11
0

start 0

Ad ogni stato dell’automa associamo un numero binario sequenziale (S0=00, S1=01, S2=10, S3) e
partendo dallo stato iniziale S0 tracciamo un arco ogni qualvolta riceviamo un nuovo valore in ingresso
che conduce ad un nuovo stato o allo stato attuale.
L’automa che realizza il nostro progetto è composto da 4 stati quindi necessita di 2 circuiti bistabili
( log 2 4 = 2 ).
Per riassume i segnali del circuito di pilotoggio sono:
− un ingresso I che rappresenta l’ingresso dell’intero circuito.
− due ingressi U1 e U2 che rappresentano la retroazione dei due bistabili.
− due uscite D1 e D2 che pilotano i due bistabili.
Architettura degli Elaboratori e delle Reti 41

Tabella della verità di questo automa a stati finiti, riduzione algebrica e circuito che lo implementa.

U1 U2 I D1 D2
0 0 0 0 0 D1 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 ⋅ U 2
0 0 1 0 1 D1 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 ⋅ (U 2 + U 2 )
0 1 0 0 0 D1 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1
0 1 1 1 0
1 0 0 0 0 D2 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 ⋅ U 2
1 0 1 1 1 D2 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1 (U 2 + U 1 )
1 1 0 0 0 D2 = I ⋅ U 1 ⋅ U 2 + I ⋅ U 1
1 1 1 1 0

Circuito di pilotaggio

Latch D
D1 U1

Latch D
D2 U2
Architettura degli Elaboratori e delle Reti 42

6 Aprile 2006
Formalizzazione degli automi a stati finiti
L’ automa a stati finiti è un modello astratto per rappresentare un circuito sequenziale.
Formalmente un automa a stati finiti è una quintupla:

A = < I , S , s0 , F , f >

dove:
I = un insieme (finito) di simboli dell’alfabeto (nel caso binario 0 e 1)
S = un insieme (finito) di stati in cui si trova il sistema
s0 = stato iniziale ( s0 ⊂ S )
F = un insieme di stati finali ( F ⊆ S ), non stati di terminazione ma di successo
f = una funzione di transizione ( f : I × S → S ) che dato in ingresso la coppia I, S restituisce
in uscita lo stato successivo

Il comportamento di un automa può essere rappresentato mediante un grafo in cui gli archi
rappresentano le transizioni fra stati, i cerchi rappresentano stati. Gli stati finali sono evidenziati da
cerchi doppi. I simboli sugli archi sono gli input del sistema, ed appartengono all’alfabeto I.

Progettiamo un automa che riconosca tutte le sequenze di stringhe binarie che contengono almeno due
bit a 1 e il cui numero di bit a 0 è pari.
Lo stato iniziale s0 assume che la seconda condizione è vera in quanto non avendo letto nulla, il
numero di bit a 0 è 0 (ricordiamo che 0 è pari).
1 1
start

s0 s2 s4 1

0 0 0 0 0 0

s1 s3 s5
0 0
Architettura degli Elaboratori e delle Reti 43

Register File – RF
La struttura intorno alla quale è costruita l’unità di elaborazione è il Register File: esso consta di un
insieme di registri che possono essere letti o scritti fornendo il numero del registro a cui fare accesso.

Nr
Nr = numero registro da leggere
n
Nw = numero registro da scrivere
Nw Register O
D = dato a m bit in ingresso
n File m O = dato a m bit in uscita
D RegW = comando di scrittura (Register Write)
m n = numero bit di selezione
m = numero bit per i dati
RegW

Il numero di registri di un Register File è dipendente dal numero n di segnali di selezione dei registri e
più precisamente:

Numero registri = 2n

Vediamo il funzionamento interno di un Register File con 4 registri da 8 bit.


Il circuito di lettura è realizzato nel seguente modo:
Nr Il funzionamento è piuttosto semplice:
gli ingressi Nr pilotano il multiplexer
2
che seleziona uno dei 4 registri. Il
circuito presenta un solo multiplexer
Registro 0
8
che in realtà è composto da una batteria
di 8 multiplexer, ognuno dei quali,
Registro 1
8 O responsabile di selezionare un singolo
Mux bit di ogni registro. Avremo dunque un
8
Registro 2
8
multiplexer per il bit b0 di ogni registro,
uno per il bit b1 di ogni registro, fino al
Registro 3
8
bit b7.

Il circuito di scrittura è realizzato nel seguente modo:


RegW L’implementazione della porta di scrittura
e lievemente più complessa: gli ingressi
D
C
Registro 0 Nw pilotano il decodificatore che abilita
la scrittura in un solo registro.
D
Registro 1
L’abilitazione di un registro è il risultato
Nw
C
della congiunzione fra l’uscita del
2
Decoder D
decodificatore e il segnale comando di
scrittura RegW.
Registro 2
C

D
Registro 3
C

D
8
Architettura degli Elaboratori e delle Reti 44

Il circuito di lettura del Register File collegato ad una ALU (Arithmetic Logical Unit) è leggermente
diverso da quello visto finora.
Nr1 Sono presenti due uscite, ognuna delle
2 quali è un operando dell’operazione
matematica che la ALU deve svolgere.
Registro 0
8 Nr1 seleziona il registro del primo
Registro 1
operando O1, mentre Nr2 selezione il
O1
8
Mux1
8
registro del secondo operando O2.
Registro 2
8

Registro 3
8
R
Nr2 ALU
8
2

O2
Mux2
8
Architettura degli Elaboratori e delle Reti 45

I sistemi di memoria: SRAM DRAM


Abbiamo già visto come realizzare componenti di memorizzazione, ma per quantità maggiori di
memoria è necessario ricorrere alle SRAM (Static Random Access Memory) o alle DRAM (Dynamic
Random Access Memory).

Una SRAM è concettualmente simile a una matrice di flip-flop.


Ogni flip-flop ha il compito di preservare un singolo bit dell’intera memoria.
Tipicamente per la realizzazione di un flip-flop si utilizzano 5-6 transistor.

Una DRAM è concettualmente simile a una matrice di condensatori (e un transistor).


Un condensatore è come un piccolo secchio che può immagazzinare gli elettroni.
Per immagazzinare un 1 nella cella di memoria, il secchio viene riempito di elettroni. Per
immagazzinare uno 0, viene invece svuotato. Il problema del condensatore è che ha una perdita
(figurativo). Nel giro di alcuni millisecondi quindi il secchio da pieno diventa vuoto. Di conseguenza,
affinché la memoria dinamica funzioni, la CPU o il controller della memoria devono intervenire e
ricaricare tutti i condensatori che contengono elettroni (ovvero il valore 1) prima che essi si scarichino.
Per fare questo, il controller legge la memoria e la riscrive, migliaia di volte al secondo.

Ricapitolando quindi la RAM statica è più veloce ma costosa, quella dinamica è più
economica ma più lenta. Le RAM statiche vengono usate per creare la velocissima
cache della CPU mentre la RAM dinamica per gestire la maggior parte della memoria.

Tipo di Tempo di Numero transistor per


memoria accesso singolo bit
SRAM 8-10 ns 5-6
DRAM 80-100 ns 1
Architettura degli Elaboratori e delle Reti 46

La macchina di Von Neumann


La macchina di Von Neumann è un modello per progettare i calcolatori, reso operativo all’Università
di Princeton sotto la guida del matematico John Von Neumann (1945).
Le idee di base di questo modello sono ancor oggi dietro la progettazione e la realizzazione dei
moderni calcolatori.

La macchina di Von Neumann è composta principalmente da tre elementi: CPU, Memoria e Bus.

BUS
Bus indirizzi

Bus dati
CPU Memoria
Bus controllo

La CPU è un circuito molto complesso in grado di eseguire calcoli elementari (addizioni, sottrazioni,
etc...) e operare delle scelte (comparazioni). Essa è composta da un insieme di registri, una unità
aritmetica e una unità di controllo.

La Memoria, come abbiamo già visto, è un circuito che preserva informazioni (dati binari)

Il Bus permette la comunicazione tra la CPU e la memoria ed è generalmente composto da tre


sottosistemi:
− Bus dati, comprende le linee per trasferire dati e istruzioni da/verso la memoria. In generale, la
dimensione del bus dati è tale da garantire il trasferimento contemporaneo di una o più parole di
memoria.
− Bus indirizzi, indica la sorgente o la destinazione dei dati che transitano sul bus dati.
− Bus di controllo, dove transitano le informazioni ausiliarie per la corretta definizione delle
operazioni da compiere (per esempio l’indicazione che si vuole effettuare una lettura piuttosto che
una scrittura) e per la sincronizzazione tra CPU e memoria

Le caratteristiche principali dell’architettura di Von Neumann sono:


− Dati e istruzioni sono memorizzati in una memoria unica che consente sia lettura che scrittura.
− I contenuti della memoria sono indirizzati in base alla loro posizione, indipendentemente dal tipo di
informazione contenuta.
− Le istruzioni vengono eseguite in modo sequenziale.

L’esecuzione di una istruzione avviene in due distinte fasi:


1) Fetch: legge l’istruzione dalla memoria e la decodifica
2) Execute: realizza l’istruzione e torna ad eseguire la fase di Fetch.
Architettura degli Elaboratori e delle Reti 47

20 Aprile 2006
Program Counter e Instruction Register
Per continuare la nostra analisi sul funzionamento di una CPU dobbiamo prima vedere con maggiore
dettaglio come avviene la fase di Fetch di un’istruzione.
Durante la fase Fetch l’unità di controllo:
− preleva dalla memoria l’istruzione che deve essere eseguita, il cui indirizzo è contenuto nel registro
Program Counter
− scrive l’istruzione nel registro Instruction Register
− modifica il valore del registro Program Counter in modo che contenga l’indirizzo della prossima
istruzione da eseguire.

Formalmente diciamo che:


− Il Program Counter (PC) è un registro interno al processore che contiene l’indirizzo di memoria
della prossima istruzione da eseguire.
− L’Instruction Register (IR) è un registro interno alla processore che contiene l’ultima istruzione
prelevata dalla memoria.

Indirizzi
PC

MEMORIA

Dati
IR
(Istruzioni)
Architettura degli Elaboratori e delle Reti 48

Esempio didattico di CPU a 16 bit


Lo scopo che ci prefiggiamo è quello di capire il funzionamento interno di una CPU.
Questo dispositivo non esiste nella realtà ma è un esempio didattico di come è realizzato un
processore.
Le caratteristiche principali della nostra CPU sono:
− Le istruzioni hanno lunghezza fissa a 16 bit.
− Le istruzioni hanno un formato tale che i 4 bit più significativi (b15-b12) contengono sempre il tipo di
istruzione da eseguire e i restanti bit (b11-b0) indicano su quali registri verrà eseguita l’istruzione o
una locazione di memoria.
− Le istruzioni che deve eseguire sono: addizione, sottrazione, AND, OR, caricamento di un registro
e scrittura di un registro.
− Le istruzioni matematiche operano esclusivamente sui registri.
− Le istruzioni di accesso alla memoria usano la ALU per il calcolo dell’indirizzo
4
− Il Register File dispone di 16 registri (2 ) a 16 bit.

Formato delle istruzioni ADD (addizione), SUB (sottrazione), AND e OR.

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
OpCode Rs Rt Rd

Formato dell’istruzione LOAD (caricamento di un registro da memoria) e STORE (scrittura di un


registro nella memoria)

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
OpCode Rb Rt Ofs

Opcode = codice dell’istruzione


Rs = numero del registro sorgente (Register Source)
Rt = numero del registro target (Register Target)
Rd = numero del registro destinazione (Register Destination)
Rb = registro utilizzato per comporre l’indirizzo di memoria
Ofs = offset dell’indirizzo di memoria

L’indirizzo di memoria è calcolato sommando al contenuto del registro Rb il valore di Ofs.

Il codice dell’istruzione (OpCode) è codificato nel seguente modo:


Opcode IR15 IR14 IR13 IR12
AND 0 0 0 0
OR 0 1 0 0
ADD 1 0 0 0
SUB 1 1 0 0
LOAD 0 0 1 0
STORE 0 1 1 1
Architettura degli Elaboratori e delle Reti 49

Circuito per realizzare ADD, SUB, AND e OR


Il circuito per eseguire le operazioni matematiche è composto dall’Istruction Register, il Register File,
la ALU e una unità di controllo.
Il Register File prevede tre ingressi per l’indirizzamento dei registri, due per i registri da leggere (Nr1,
Nr2) e uno per il registro da scrivere (Nw). Chiaramente ci sono due uscite dati (O1, O2) per i dati che
vengono letti e un ingresso dati (D) per il dato che deve essere scritto.
Le uscite del Register File sono connesse agli ingressi ALU mentre l’uscita della stessa è collegata
all’ingresso dati D del Register File.

KAlu

UC
RegW

IR
Op

Rs Nr1 O1
4 16

Rt Nr2
4
RF ALU
Rd Nw
4

O2
D 16

16

Durante l’esecuzione di un’istruzione matematica:


− i bit Rs dell’IR selezionano il primo registro dell’operazione; il contenuto è posto sull’uscita O1
− i bit Rt dell’IR selezionano il secondo registro dell’operazione; il contenuto è posto sull’uscita O2
− i bit Rd dell’IR selezionano il registro dove depositare il risultato dell’operazione
− il circuito combinatorio UC genera i segnali di controllo opportuni; gli ingressi di questo circuito
sono rappresentati dai bit Op dell’IR,
− la ALU esegue l’operazione matematica associata alla combinazione dei bit KAlu (3 bit)
− sull’ingresso dati D viene posto il risultato dell’operazione
− viene generato un segnale RegW (1 bit) per abilitare la scrittura del dato D nel Register File

Il segnale RegW deve essere opportunamente sincronizzato con il clock di sistema per abilitare la
scrittura al momento giusto.
Architettura degli Elaboratori e delle Reti 50

Diagramma temporale di un’istruzione


Questo è il diagramma temporale dei dati e dei segnali durante un’istruzione di tipo matematico:

La scrittura avviene La scrittura avviene


sul fronte di discesa sul fronte di discesa
del clock del clock

CLOCK

Tempo di accesso all’Instruction Register

Rs,Rt,Rd

Ritardo introdotto dalla logica di controllo

KAlu

RegW

Tempo di accesso al Register File

O1,O2

Ritardo introdotto dalla ALU

tempo
Architettura degli Elaboratori e delle Reti 51

Circuito per realizzare LOAD e STORE i


Il circuito per eseguire le operazioni LOAD e STORE è composto dall’Istruction Register, il Register
File, la ALU, la memoria e una unità di controllo.
Il Register File è lo stesso utilizzato nel precedente circuito con la differenza che i bit Rt
dell’Instruction Register sono utilizzati una volta per indirizzare il secondo registro da leggere (Nr2) e
un’altra volta per indirizzare il registro da scrivere (Nw).
La prima uscita del Register File è connessa alla ALU, la seconda uscita è connessa al bus dati della
memoria mentre l’uscita della ALU è collegata al bus degli indirizzi della memoria.

MemR
MemW
UC KAlu
RegW

IR Dato in
Op scrittura
16

Rb Nr1 O1
4

Rt Nr2
4
RF ALU Indirizzo
16
Ofs
O2 MEMORIA
Nw
4
D

Estensione
del segno
4 16
Dato in
16
lettura

Durante l’esecuzione di un’istruzione LOAD (da memoria a registro):


− i bit Rb dell’IR selezionano il primo registro; il contenuto è posto sull’uscita O1
− i bit Rt dell’IR selezionano il registro dove depositare il contenuto delle cella di memoria
− la ALU, per calcolare l’indirizzo di memoria, esegue l’addizione fra il primo registro in lettura O1
ed i bit Ofs dell’IR
− viene generato un segnale MemR (1 bit) per abilitare la lettura dalla memoria
− sull’ingresso dati D viene posto il contenuto della cella di memoria
− viene generato un segnale RegW (1 bit) per abilitare la scrittura del dato D nel Register File

L’ esecuzione di un’istruzione STORE (da registro a memoria):


− i bit Rb dell’IR selezionano il primo registro; il contenuto è posto sull’uscita O1
− i bit Rt dell’IR selezionano il secondo registro; il contenuto è posto sull’uscita O2 connessa al bus
dati delle memoria
− la ALU, per calcolare l’indirizzo di memoria, esegue l’addizione fra il primo registro in lettura O1
ed i bit Ofs dell’IR
− viene generato un segnale MemW (1 bit) per abilitare la scrittura in memoria

i
questa parte non è stata spiegata a lezione ma è stata inserita per completezza
Architettura degli Elaboratori e delle Reti 52

Circuito per realizzare tutte le istruzioni


Analizzando i circuiti precedenti, si nota che per far “convivere” tutte le istruzioni in un’unica unità
servono dei multiplexer, con i relativi segnali di controllo, che consentano di selezionare il percorso
desiderato.
Nel caso di istruzioni matematiche e LOAD, STORE abbiamo che:
− il secondo ingresso della ALU nel caso delle istruzioni matematiche è un registro mentre nelle
istruzioni LOAD, STORE è la parte “offset” dell’indirizzo.
− il dato da memorizzare nel Register File può arrivare dalla ALU o dalla memoria (LOAD).

MemR
MemW
KAlu
UC ALUSrc
MemToReg
RegW

IR RegDst
Dato in
Op scrittura
16

Rs
Nr1 O1
Rb 4

Rt Nr2
4
RF ALU Indirizzo
Rd 16
Ofs MEMORIA
1 O2 1
MUX Nw MUX
4
0 D 0

Estensione
del segno
4 16
Dato in
1
lettura
MUX
16
0
16
Architettura degli Elaboratori e delle Reti 53

Per completare la CPU dobbiamo definire l’unità di controllo cioè dobbiamo realizzare un’unità che,
dato in input il codice operativo dell’istruzione, sia in grado di valorizzare correttamente tutti i segnali.
L’unità di controllo è una rete combinatoria la cui realizzazione può essere progettata utilizzando il
teorema SPC. A titolo esemplificativo proviamo a realizzare i circuiti di controllo dei segnali RegW e
MemToReg (MTR) partendo con lo scrivere la tabella della verità.

Opcode IR15 IR14 IR13 IR12 RegW MTR


AND 0 0 0 0 1 0
OR 0 1 0 0 1 0
ADD 1 0 0 0 1 0
SUB 1 1 0 0 1 0
LOAD X X 1 0 1 1
STORE X X 1 1 0 0

RegW = IR15 ⋅ IR14 ⋅ IR13 ⋅ IR12 + IR15 ⋅ IR14 ⋅ IR13 ⋅ IR12 + IR15⋅ ⋅ IR14 ⋅ IR13 ⋅ IR12 + IR15 ⋅ IR14 ⋅ IR13 ⋅ IR12 + IR13 ⋅ IR12
RegW = IR13 ⋅ IR12 ⋅ ( IR15 ⋅ IR14 + IR15 ⋅ IR14 + IR15⋅ ⋅ IR14 + IR15 ⋅ IR14 ) + IR13 ⋅ IR12
RegW = IR13 ⋅ IR12 ⋅ ( IR15 ⋅ ( IR14 + IR14 ) + IR15⋅ ⋅ ( IR14 + IR14 )) + IR13 ⋅ IR12
RegW = IR13 ⋅ IR12 ⋅ ( IR15 + IR15⋅ ) + IR13 ⋅ IR12
RegW = IR13 ⋅ IR12 + IR13 ⋅ IR12
RegW = IR12 ⋅ ( IR13 + IR13 ) = IR12

MemToReg = IR13 ⋅ IR12


Architettura degli Elaboratori e delle Reti 54

La ALU
Per i nostri scopi didattici analizzeremo una ALU a 16 bit che esegue le operazioni aritmetiche:
somma, sottrazione, le operazioni logiche: AND e OR e l’operazione SLT. Abbiamo già realizzato un
circuito sommatore in complemento a due e conosciamo le porte logiche AND e OR, quindi siamo in
grado di progettare una cella elementare, che ripetuta per quanti sono i bit in uso dalla CPU (nel nostro
caso 16), realizzi una ALU completa.
Nell’ unità ALU0, C = KAlu2
Nelle altre unità ALU15-ALU1, C = bit di Carry I segnali KAlu0 e KAlu1
dell’unità precedente
sono responsabili di
C
selezionare quale risultato
la ALU deve emettere.
Il segnale di controllo
a
KAlu2 è chiamato anche
00 “inverti b” e serve sia per
b
selezionare il segnale b
negato in ingresso al
sommatore, sia per
impostare ad 1 il bit di
01
carry dell’unità ALU0.

Mux S
a

a±b
0 + 10
±b
Mux

less
11

KAlu2
KAlu1
KAlu0

La sottrazione è ottenuta applicando la formula valida per i numeri binari in complemento 2:


a − b = a + b +1
L’istruzione SLT (Set Less Than), che genera un 1 quando a < b , è ottenuta eseguendo la sottrazione
fra i due ingressi dell’ALU, forzando a 0 il segnale less delle unità ALU15-ALU1 e collegando il bit più
significativo in uscita dell’ALU sul segnale less dell’unità ALU0. L’idea è quella di eseguire la
sottrazione e riportare come primo bit in uscita dell’ALU il bit più significativo, che rappresenta il
segno dell’operazione. Ricordiamo, infatti, che a < b → a − b < 0
Architettura degli Elaboratori e delle Reti 55

Di seguito riportiamo il simbolo dell’ALU e la tabella delle combinazioni dei 3 bit di controllo
calcolati dalla CPU e forniti in input per controllare l’operazione aritmetico/logica richiesta:

A [31-0]
Opcode KAlu2 KAlu1 KAlu0
AND 0 0 0 Zero
OR 0 0 1
ADD 0 1 0 ALU
SUB 1 1 0 Risultato
SLT 1 1 1
B [31-0]

KAlu [2-0]

E’ possibile rappresentare l’ALU come un insieme di celle di un bit in cascata anche se non è la
soluzione adottata nelle CPU a causa dei tempi di propagazione delle somme ai bit successivi
(problema della profondità dei circuiti booleani).

Zero

a0
b0
S0
ALU0

a1
b1
S1
ALU1
0

a15
b15
S15
ALU15
0

KAlu

Il bit Zero è impostato quando tutti i bit del risultato dell’operazione sono a zero ed è utilizzato per
eseguire i salti condizionati, infatti l’esecuzione di una beq rs, rt, label (salta se i due registri sono
uguali), è ottenuta sottraendo al primo registro il secondo e utilizzando il valore del bit di Zero come
abilitazione del circuito di salto.
Architettura degli Elaboratori e delle Reti 56

MAR (Memory Address Register) e MDR (Memory Data Register)


La connessione fra il processore (CPU) e il bus non è diretta ma avviene per mezzo di due registri
speciali: MAR (Memory Address Register) e MDR (Memory Data Register)

Il MAR è il registro che contiene l’indirizzo di una locazione di memoria, dove può risiedere
un’istruzione o una qualsiasi informazione. Questo registro rappresenta l’interfaccia hardware verso il
bus degli indirizzi.

Il MDR è il registro che contiene il dato trasferito verso o dalla memoria. Questo registro rappresenta
l’interfaccia hardware verso il bus dei dati.

Fase di lettura di un dato da memoria. L’unità di controllo scrive nel registro MAR l’indirizzo e legge
dall’MDR il dato.
Fase di scrittura un dato in memoria. L’unità di controllo scrive nel registro MAR l’indirizzo e scrive
nell’MDR il dato.

Le due fasi, lettura e scrittura, non differenziano le istruzioni del programma da altri tipi di
informazioni (come previsto dall’architettura di Von Neumann).

UC

PC

Bus Indirizzi
MUX MAR Indirizzo

IR RF ALU
MEMORIA

MUX
Bus Dati
MAR Dato
Architettura degli Elaboratori e delle Reti 57

RISC vs CISC
Bisogna fare un salto indietro nel tempo per capire dove e come sono nate le tecnologie di
progettazione dei processori.

Iniziamo direttamente dagli anni `70, da quando cioè furono introdotti i primi calcolatori basati su
transistor altamente integrati, ed esaminiamo la situazione hardware/sofware dell’epoca:
1) le memorie erano lente, grosse e costose.
2) esistevano i compilatori, ma facevano acqua da tutte le parti: il codice da questi prodotto era poco
ottimizzato e spesso talmente inefficiente che conveniva lavorare direttamente in assembler.

I progettisti di quel epoca decisero dunque di realizzare processori sempre più “intelligenti” in grado di
eseguire istruzioni anche molto complesse.
A quei tempi, proprio perchè si scrivevano i programmi in assembler avere un set d’istruzioni molto
vasto e articolato era il sogno degli sviluppatori di software che, vuoi per risparmiare memoria, vuoi
per semplificare il loro lavoro, desideravano che le istruzioni fossero estremamente complesse.
Intel per prima si fece carico di ovviare alle carenze nei set d’istruzioni dei processori rilasciando il
primo processore con microcodice.
Il microcodice è un programma messo all’interno della CPU che si limita a leggere le istruzioni e
svolgerle come un sottoinsieme di istruzioni più semplici.
La filosofia di progettazione di questo tipo di processori è nota come CISC (Complex Instruction Set
Computer).

Alla fine degli anni Settanta e nei primi anni Ottanta la situazione era cambiata: i compilatori erano
divenuti molto più efficienti, le memorie meno costose. Si cominciò allora a pensare ad un modo
diverso di progettare un processore e le linee guida di progetto possono essere così riassunte:
1) il processore deve eseguire un numero limitato di istruzioni semplici, infatti sulla base di una
analisi statistica dei programmi, si scopre che per il 90% del tempo il processore utilizza sempre un
ristretto sottoinsieme di istruzioni.
2) le istruzioni devono avere lunghezza fissa, con pochi operandi e pochi metodi di indirizzamento
per rendere la decodifica più veloce.
3) il processore deve avere registri general-purpose in abbondanza
3) le istruzioni devono principalmente usare argomenti contenuti in registri interni al processore e
mettere il risultato dell’esecuzione di una istruzione di nuovo in un registro.
4) il processore deve accedere alla RAM il meno possibile
5) in principio, ogni fase di una certa istruzione può essere eseguita in parallelo con un’altra fase di
un’altra istruzione: è il principio della pipeline

La filosofia di progettazione di questo tipo di processori è nota come RISC (Reduced Instruction Set
Computer).
Architettura degli Elaboratori e delle Reti 58

Caratteristiche CISC Caratteristiche RISC


Pochi registri Molti registri
Istruzione a lunghezza variabile: Istruzione a lunghezza fissa:
- difficile decodifica - semplice decodifica
- incremento del Program Counter variabile - incremento del Program Counter fisso
Modalità di indirizzamento: Modalità di indirizzamento:
- memoria-registro - memoria-registro
- memoria-memoria
Qualche centinaia di istruzioni molto compatte Qualche decina di istruzioni
Presenza di una ROM di decodifica Esecuzione diretta delle istruzioni
Esecuzione sequenziale delle istruzioni Esecuzione parallela delle istruzioni

L’architettura interna dei processori general-purpose odierni, quali appunto il Pentium4 e l’Athlon, ha
poco o nulla a che vedere con l’approccio CISC descritto in precedenza. Infatti, essi sono ancorati al
passato solo perchè devono essere retrocompatibili con i vecchi programmi.
Il Pentium4 può essere considerato come un processore che offre un’ interfaccia CISC al codice che
deve eseguire ma, una volta decodificate le istruzioni, il risultato di tale decodifica viene “digerito” da
una serie di stadi di elaborazione che nel loro insieme costituiscono in tutto e per tutto un processore
RISC. Le istruzioni decodificate sono RISC-like, nel senso che appartengono ad un “alfabeto” meno
ricco del codice nativo x86 ma altamente ottimizzato per essere convenientemente compreso dalla
circuiteria preposta al suo trattamento. Queste istruzioni Risc-like possono allora essere manipolate
secondo quanto di meglio la tecnologia RISC possa offrire.

Dopo quanto detto è abbastanza evidente come nello scontro CISC vs RISC sia stata quest’ultima
filosofia ad aver avuto la meglio.
Architettura degli Elaboratori e delle Reti 59

2 Maggio 2006
Linguaggio macchina didattico
Lo scopo che ci prefiggiamo è quello di progettare, a scopo didattico, un linguaggio macchina
(Assembly) a 32 bit.
Le caratteristiche principali del nostro linguaggio sono:
− Le istruzioni hanno lunghezza fissa a 32 bit.
− Le istruzioni hanno un formato tale che i 6 bit più significativi (b31-b26) contengono sempre il tipo di
istruzione da eseguire, il codice operativo.
− I primi due bit del codice operativo (b31-b30) indicano quanti registri sono utilizzati dall’istruzione
stessa.
5
− Il Register File dispone di 32 registri (2 ) a 32 bit.

Istruzioni con 3 registri


Le istruzioni che utilizzano 3 registri hanno il seguente formato:

OpCode Rs Rt Rd 00000000000
31 26 25 21 20 16 15 11 10 0

OpCode Istruzione
11x000 or Rs Rt Rd
OR logico
Rd Å Rs or Rt
11x001 and Rs Rt Rd
AND logico
Rd Å Rs and Rt
11x010 add Rs Rt Rd
Somma Rs ed Rt e scrive il risultato in Rd
Rd Å Rs + Rt
11x011 sub Rs Rt Rd
Sottrae Rs ed Rt e scrive il risultato in Rd
Rd Å Rs – Rt
11x100 slt Rs Rt Rd
Se Rs è minore di Rt, scrive il valore 1 nel registro Rd altrimenti scrive 0
if Rs < Rt then Rd Å 1 else Rd Å 0

Istruzioni con 2 registri


Le istruzioni che utilizzano 2 registri hanno il seguente formato:

OpCode Rs Rt OFFSET
31 26 25 21 20 16 15 0

OpCode Istruzione
10x000 beq Rs Rt OFFSET
Se Rs è uguale a Rt salta alla locazione PC + (OFFSET x 4)
Architettura degli Elaboratori e delle Reti 60

if Rs = Rt then PC = PC + ( OFFSET x 4 )
11x001 bne Rs Rt OFFSET
Se Rs è diverso da Rt salta alla locazione PC + (OFFSET x 4)
if Rs ≠ Rt then PC = PC + ( OFFSET x 4 )
11x010 load Rt (Rs)
Carica in Rt i la cella di memoria all’indirizzo Rs
Rt Å Memory[Rs]
11x011 sto (Rs) Rt
Memorizza Rs nella cella di memoria all’indirizzo Rt ii
Memory[Rt] Å Rs
11x100 blt Rs Rt OFFSET
Se Rs è minore di Rt salta alla locazione PC + (OFFSET x 4)
if Rs <Rt then PC = PC + ( OFFSET x 4 )

Istruzioni con 1 registro


Le istruzioni che utilizzano 1 registro hanno il seguente formato:

OpCode Rs 000000000000000000000
31 26 25 21 20 0

OpCode Istruzione
01x000 mtt Rs
Move-to-test, scrive il valore di Rs nel registro implicito TEST iii
TEST Å Rs
01x001 inc Rs
Incrementa Rs di uno
Rs Å Rs + 1
01x010 nloc Rs
Incrementa Rs di quattro
Rs Å Rs + 4

Istruzioni senza registri


Le istruzioni che utilizzano 1 registro hanno il seguente formato:

OpCode IND
31 26 25 0

OpCode Istruzione
00x000 jump IND
Salta alla locazione IND x 4
PC Å 0000 IND x 4
00x001 pcall IND

i
nelle specifiche originali è stato utilizzato Rd al posto di Rt
ii
nelle specifiche originali è stato utilizzato Rd al posto di Rt
iii
altri registri impliciti PC, IR, MAR, MDR, RA (Return Address)
Architettura degli Elaboratori e delle Reti 61

Salta alla locazione IND x 4 preservando il PC nel registro speciale Return Address
RA Å PC ; PC = 0000 IND x 4
00x010 ret
Ripristina il valore del PC precedentemente scritto nel Return Address
PC Å RA
00x011 nop
Nessuna operazione
00x100 stop
Termina il programma
Le istruzioni di salto incondizionato jump e pcall calcolano l’indirizzo finale di memoria della
prossima istruzione da eseguire moltiplicando per 4 il valore di IND. Ogni istruzione è presente in
memoria ad un indirizzo che è un multiplo di 4 (allineamento a word) questo perchè le istruzioni, come
abbiamo stabilito, hanno un lunghezza fissa di 4 byte (32 bit).
Lo stesso ragionamento è applicato alle istruzioni di salto condizionato beq e bne.
Inoltre dobbiamo sottolineare che il campo IND è un numero in complemento a 2: se positivo il salto
avviene in avanti, se negativo il salto avviene all’indietro.

Esempio di programma
Proviamo a scrivere un programma, con il nostro linguaggio macchina, che somma i primi 5 elementi
di un vettore memorizzato all’indirizzo VETT.
Supponiamo che R2 contenga VETT e che R5 contenga il numero di elementi da sommare, cioè 5.
Useremo R3 per accumulare il risultato, R4 per contare le iterazioni e R6 come registro temporaneo.

Linguaggio ad alto livello Linguaggio assembly


azzera R3 sub R3 R3 R3
azzera R4 sub R4 R4 R4
CICLO: R6 = MEM[R2] CICLO: load R6 (R2)
R3 = R6 + R3 add R3 R6 R3
R2 = R2 + 4 nloc R2
R4 = R4 + 1 inc R4
if R4 ≠ R5 goto CICLO bne R4 R5 CICLO
stop stop

Il programma compilato dall’assemblatore produce in uscita il seguente codice binario:

Indirizzo Istruzione binaria Istruzione


31…26 25 21 20 16 15 0
1024 11x111 00011 00011 00011 00000000000 sub R3 R3 R3
1028 11x111 00100 00100 00100 00000000000 sub R4 R4 R4
1032 10x010 00010 00110 00000 00000000000 load R6 (R2)
1036 11x010 00011 00110 00011 00000000000 add R3 R6 R3
1040 01x100 00010 00000 00000 00000000000 nloc R2
1044 01x001 00100 00000 00000 00000000000 inc R4
1048 10x001 00100 00100 11111 11111111100 bne R4 R5 -4
1052 00x100 00000 00000 00000 00000000000 stop

L’etichetta CICLO è stata sostituita dall’assemblatore con lo spiazzamento, rispetto al PC, dove si
trova l’istruzione da eseguire se il confronto ha successo.
Architettura degli Elaboratori e delle Reti 62

4 Maggio 2006
Il processore MIPS
Abbiamo già progettato alcuni circuiti per la realizzazione di un processore a 16 bit e realizzato un
linguaggio macchina a 32 bit ora analizzeremo l’architettura del processore MIPS, di alcune sue
istruzioni e dei circuiti che le implementano.
Elenchiamo le principali caratteristiche di questo processore:
− architettura RISC a 32 bit
− capacità di indirizzare 232 locazioni di memoria pari a 4 Gbyte
− istruzioni a lunghezza fissa e codice operativo nei 6 bit più significativi (31-26)
− 32 registri da 32 bit contenuti nel Register File
− modello architetturale orientato ai registri con istruzioni di accesso alla memoria di tipo load/store

Le istruzioni di cui ci occuperemo sono quelle aritmetiche (and, or, add, sub), di accesso alla memoria
(lw, sw) e di salto condizionato (beq):

add Rd, Rs, Rt

31 26 25 21 20 16 15 11 10 6 5 0
OpCode Rs Rt Rd Shamt Funct
6 bit 5 bit 5 bit 5 bit 5 bit 6 bit

lw Rt, Offset (Rs)


sw Rt, Offset (Rs)

31 26 25 21 20 16 15 0
OpCode Rs Rt Offset
6 bit 5 bit 5 bit 16 bit

beq Rs, Rt, Offset

31 26 25 21 20 16 15 0
OpCode Rs Rt Offset (PC-relative)
6 bit 5 bit 5 bit 16 bit
Architettura degli Elaboratori e delle Reti 63

Istruzioni aritmetiche
Le istruzioni aritmetiche sono quel insieme di istruzioni che comprendono: l’addizione (add), la
sottrazione (sub), l’AND logico (and) e l’OR logico (or).
Sono caratterizzate dall’avere il codice operativo dell’istruzione (31-26) con i 6 bit tutti a 0 e il codice
dell’operazione aritmetica da eseguire nei primi 6 bit (5-0).
Ogni istruzione opera su 3 registri: 2 utilizzati come operandi e 1 come risultato dell’operazione.

add Rd, Rs, Rt


Schema per le
istruzioni aritmetiche

31 26 25 21 20 16 15 11 10 6 5 0
OpCode Rs Rt Rd Shamt Funct
6 bit 5 bit 5 bit 5 bit 5 bit 6 bit

Unità di
ALUOp
controllo
della ALU
Unità di
controllo RegW

KAlu

Nr1
O1
Zero
Nr2
RF ALU
Risultato
Nw
O2

Campo Significato
OpCode Codice operativo (sempre 0)
Rs Registro con il primo operando (Register source)
Rt Registro con il secondo operando (Register target)
Rd Registro con il risultato (Register destination)
Shamt Quantità di cui shiftare il risultato
Funct Tipo di operazione da eseguire (and, or, add, sub)
Architettura degli Elaboratori e delle Reti 64

Fasi dell’istruzione i
add Rd, Rs, Rt Descrizione
PC Å PC + 4 Il Program Counter è incrementato
RegW Å 1 Attivazione del segnale di controllo RegWrite
ALU1 Å RF[ IR.Rs ] 1° Operando ALU – Registro Rs
ALU2 Å RF[ IR.Rt ] 2° Operando ALU – Registro Rt
Risultato Å ALU1 + ALU2 Somma di ALU1 e ALU2
RF[ IR.Rd ] Å Risultato Scrittura del Risultato nel registro Rd sul fronte del
Clock “0” Å Clock “1” segnale di clock

i
l’esecuzione delle altre istruzioni aritmetiche (sub, and, or) non viene riportata perchè del tutto simile a questa
Architettura degli Elaboratori e delle Reti 65

Istruzioni di accesso alla memoria (load/store)


Le istruzioni di accesso alla memoria si occupano di:
− load: prelevare il contenuto di una locazione di memoria e trasferirlo in un registro dell’RF
− store: prelevare il contenuto di un registro dell’RF e trasferirlo in una locazione di memoria
Queste istruzioni sono caratterizzate dall’utilizzare il registro Rs + Offset di 16 bit per determinare
l’indirizzo di memoria dal quale leggere/scrivere e dall’utilizzare il campo Rt dell’istruzione per
stabilire in quale registro dell’RF scrivere (load) o leggere (store).
Il bit Rt assumono un doppio significato: registro destinazione quando viene eseguita una load, registro
sorgente quando viene eseguita una store.

lw Rt, Offset (Rs)


sw Rt, Offset (Rs) Schema per le
istruzioni aritmetiche
e di accesso alla
memoria

31 26 25 21 20 16 15 0
OpCode Rs Rt Offset
6 bit 5 bit 5 bit 16 bit
15 11 5 0
Rd Funct
5 bit 6 bit

Estensione
del segno

Unità di
ALUOp
controllo
ALUSrc della ALU
MemToReg
Unità di MemW
controllo MemR
RegW

RegDst KAlu

Nr1
O1

Zero
Nr2
RF
ALU
Nw Risultato Indirizzo
O2 0

D MUX
MEMORIA
1
DATI
Dato in Dato in
1
ingresso uscita
MUX

MUX

Campo Significato
OpCode Codice operativo
Rs Registro con la base dell’indirizzo di memoria (Register source)
Rt Registro dove leggere/scrivere (Register target)
Offset Indice o spiazzamento dell’indirizzo di memoria
Architettura degli Elaboratori e delle Reti 66

Fasi dell’istruzione
lw Rt, Rs, Offset Descrizione
PC Å PC + 4 Il Program Counter è incrementato
MemR Å 1 Attivazione del segnale di controllo MemRead
ALUSrc Å 1 Attivazione del segnale di controllo ALUSrc
RegDst Å 1 Attivazione del segnale di controllo RegDst
RegW Å 1 Attivazione del segnale di controllo RegWrite
MemToReg Å 1 Attivazione del segnale di controllo MemToReg
ALU1 Å RF[ IR.Rs ] 1° Operando ALU – Registro Rs
ALU2 Å SignExtension( RF[ IR.Offset ] ) 2° Operando ALU – Est. di segno a 32 bit dell’Offset
Risultato Å ALU1 + ALU2 L’indirizzo è dato dalla somma di ALU1 e ALU2
MAR Å Risultato L’indirizzo da leggere è posto sul bus degli indirizzi
MDR Å MEM[ MAR ] Lettura del dato all’indirizzo MAR
RF[ IR.Rt ] Å MDR Scrittura del contenuto di MDR nel registro Rt sul
Clock “0” Å Clock “1” fronte del segnale di clock
.
sw Rt, Rs, Offset Descrizione
PC Å PC + 4 Il Program Counter è incrementato
MemW Å 1 Attivazione del segnale di controllo MemWrite
ALUSrc Å 1 Attivazione del segnale di controllo ALUSrc
RegDst Å 0 Attivazione del segnale di controllo RegDst
RegW Å 0 Attivazione del segnale di controllo RegWrite
MemToReg Å 0 Attivazione del segnale di controllo MemToReg
ALU1 Å RF[ IR.Rs ] 1° Operando ALU – Registro Rs
ALU2 Å SignExtension( RF[ IR.Offset ] ) 2° Operando ALU – Est. di segno a 32 bit dell’Offset
Risultato Å ALU1 + ALU2 L’indirizzo è dato dalla somma di ALU1 e ALU2
MAR Å Risultato L’indirizzo da leggere è posto sul bus degli indirizzi
MDR Å RF[ IR.Rt ] Scrittura del contenuto di Rt nel registro MDR
MEM[ MAR ] ÅMDR Scrittura del contenuto di MDR all’indirizzo MAR
Clock “0” Å Clock “1” sul fronte del segnale di clock
Architettura degli Elaboratori e delle Reti 67

Istruzioni di controllo (salto)


Le istruzioni di salto condizionato sono caratterizzate dall’utilizzare i registri Rs e Rt per eseguire il
confronto, mentre i bit da 0..15, che normalmente contengono di valori di Rd, Shamt e Funct,
contengono un offset che rappresenta il numero di istruzioni da saltare in avanti o indietro rispetto al
Program Counter (PC). Il campo Offset è un numero in complemento a 2: se positivo il salto avviene
in avanti, se negativo il salto avviene all’indietro.
Il confronto è realizzato mediante la sottrazione di Rs con Rt. Se i due registri sono uguali, il bit di
Zero dell’ALU è posto a 1 e insieme al segnale Branch abilita la somma PC + 4 + (Offset x 4).

beq Rs, Rt, Offset

31 26 25 21 20 16 15 0
OpCode Rs Rt Offset (PC-relative)
6 bit 5 bit 5 bit 16 bit
5 0
Funct
6 bit

Unità di
ALUOp
controllo
della ALU

Unità di Branch
controllo

RegW Estensione
del segno
KAlu
PcWrite

Nr1
O1
Zero
Nr2
RF ALU
Risultato Shift
Nw sinistra
O2
di 2
D

PC
+
+

+4

MUX

Campo Significato
OpCode Codice operativo
Rs Registro con il primo operando (Register source)
Rt Registro con il secondo operando (Register target)
Offset Indice o spiazzamento della successiva istruzione
Architettura degli Elaboratori e delle Reti 68

Fasi dell’istruzione
beq Rs, Rt, Offset Note
PC Å PC + 4 Il Program Counter è incrementato
Branch Å 1 Attivazione del segnale di controllo Branch
ALU1 Å RF[ IR.Rs ] 1° Operando ALU – Registro Rs
ALU2 Å RF[ IR.Rt ] 2° Operando ALU – Registro Rt
if (ALU1-ALU2==0) Se la differenza fra ALU1 e ALU è uguale a 0 allora
Zero Å 1 il segnale Zero viene attivato
OFFSET i Å SignExtension( RF[ IR.Offset ] ) Estensione di segno a 32 bit dell’Offset
OFFSET Å OFFSET << 2 Moltiplicazione dell’Offset per 4 (shift 2 sinistra)
if (Zero AND Branch) Se Zero e Branch sono entrambi a 1, il PC viene
PC Å PC + 4 + OFFSET aggiornato con il valore del PC + 4 + OFFSET
else altrimenti viene aggiornato col il valore del PC + 4
PC Å PC + 4
Clock “0” Å Clock “1” Attivazione della scrittura del PC sul fronte del
segnale di clock

i
OFFSET non è un registro e non esiste nel circuito, viene utilizzato unicamente a scopo descrittivo
Architettura degli Elaboratori e delle Reti 69

9 Maggio 2006
Gestione dell’Input/Output
Una delle principali funzioni svolte da un processore è quella di interagire e di scambiare
informazioni con periferiche esterne quali tastiera, mouse, disco fisso, etc...
Tale funzione viene svolta attraverso il sottosistema di I/O.
Le principali tecniche per la gestione dei dispositivi di I/O sono:
− Polling
− Interrupt drivern
− Direct Memory Access

Polling
Il processore interroga continuamente il dispositivo per controllare se un dato è pronto per essere
trasferito. Verificata la disponibilità di un nuovo dato, il processore provvede a trasferire il dato e a
controllare nuovamente lo stato del dispositivo.
Il processore ha il controllo completo ed esegue tutto il lavoro. Lo svantaggio del polling sta nel fatto
che potenzialmente esso è in grado di far sprecare molto tempo al processore. Dal momento che i
processori sono molto più veloci dei dispositivi di I/O, può succedere che il processore legga tante
volte lo stato del dispositivo, soltanto per scoprire che quest’ultimo non è ancora pronto.
Il processore è coinvolto durante tutta l’operazione di I/O per svolgere il ruolo di controllore.

Interrupt drivern
Il dispositivo informa, attraverso un segnale di interrupt, al processore se un dato è pronto per essere
trasferito. La ricezione di questo segnalo attiva una funzione asincrona al programma corrente che si
occupa di trasferire il dato. Il segnale di interrupt può essere condiviso da molti dispositivi ed è
responsabilità della funzione di interrupt stabilire quali fra i dispositivi ha generato l’interrupt.
La gestione dell’I/O con meccanismi basati su interruzione solleva il processore dal peso di attendere,
magari inutilmente, la disponibilità di dati da parte di un dispositivo ma lo impegna comunque nel
trasferimento dati tra dispositivo e memoria.
Questo metodo diventa inaccettabile per il trasferimento di dati di dimensioni relativamente elevate
(centinaia di migliaia di byte). Il processore sarebbe continuamente occupato nella gestione del
trasferimento dati.

Direct Memory Access - DMA


Il trasferimento dati tra dispositivo e memoria viene gestito attraverso un controllore apposito
indipendentemente dal lavoro svolto dal processore. Il controllore di DMA diviene il master del bus e
comanda le operazioni di lettura (e scrittura) tra il dispositivo e la memoria.
Il meccanismo delle interruzioni viene comunque usato dal dispositivo per comunicare con il
processore, ma soltanto al completamento del trasferimento dati o quando si verifica un errore.
Architettura degli Elaboratori e delle Reti 70

Pipeline
Nell’architettura MIPS che stiamo analizzando è possibile pensare ad un’ istruzione come la
composizione di in un numero variabile di operazioni eseguite in sequenza.

Nello specifico un’istruzione è composta da 5 operazioni dette fasi o stadi.

Le fasi di un’istruzione sono:


− Fetch: Lettura dell’istruzione dalla memoria e sua memorizzazione nel registro IR; incremento del
PC
− Decode: Scomposizione dell’istruzione in campi (codice operativo, registro, costante, ecc) a
seconda del formato e delle modalità di indirizzamento, e generazione degli opportuni segnali di
controllo
− Execute: Esecuzione delle operazioni aritmetico-logiche oppure calcolo dell’indirizzo di
destinazione di un salto
− Memory access: Accesso in lettura o scrittura alla memoria.
− Write back: Salvataggio del risultato prodotto dall’istruzione nel registro destinazione

Per convenzione stabiliamo una nomenclatura delle fasi nel modo seguente:
Fetch Decode Execute Memory access Write back
IF i DEC ALU ii MEM WB

E’ importante ricordare che le istruzioni non sono necessariamente attive in tutte le fasi.

Le istruzioni hanno latenza iii variabile, a seconda delle azioni effettivamente compiute (fasi
effettivamente eseguite):

ADD Somma due registri e deposita il risultato in un terzo registro.


La fase MEM non è presente in quanto questa istruzione non accede alla memoria

IF DEC ALU MEM WB

LOAD Preleva un dato dalla memoria e lo deposita in un registro.


E’ l’istruzione “più lunga” (massima latenza - tutte e cinque le fasi sono attive)

IF DEC ALU MEM WB

JUMP Salto incondizionato.


E’ l’istruzione “più breve” (nessun accesso a memoria né Write back nel Register File).

IF DEC ALU MEM WB

i
IF=Instruction Fetch
ii
usiamo l’abbreviazione ALU perchè questo componente è sempre utilizzato in questa fase, in alcuni testi questa fase viene
abbreviata come EX
iii
latenza= tempo impiegato per la completa elaborazione di una operazione esterna, durata
Architettura degli Elaboratori e delle Reti 71

Nella progettazione del processore possiamo fare corrispondere a ogni fase un sottosistema fisico che
viene utilizzato una volta sola durante il ciclo di un’istruzione.

IF: Instruction Fetch DEC: Instruction decode/ ALU: Execute/ MEM: Memory access WB: Write back
Register file read Address calculation

Jump

MUX

PC

Shift +
sinistra
MUX
di 2
+ IR[25-0] Shift
sinistra
di 2

+4
Branch

RegW

IR[25-21]
Nr1
O1
Indirizzo
IR[20-16] Zero
Nr2 MemR MemW
RF ALUSrc

Istruzioni
ALU
Nw Risultato Indirizzo
O2

MEMORIA D MUX
MEMORIA MemToReg
ISTRUZIONI
KAlu
DATI
Dato in Dato in
ingresso uscita
MUX
IR[15-0] IR[5-0] Unità di
Le linee con freccia Estensione controllo
indicano un insieme del segno della ALU
di segnali.
Le linee senza
freccia indicano un ALUOp
solo segnale. IR[20-16]

MUX
IR[15-11]

RegDst

Assumendo che ogni sottosistema è autonomo funzionalmente, possiamo pensare il processore come
una catena di montaggio in cui ogni sottosistema esegue una singola operazione e passa il risultato al
sottosistema successivo. Nello stesso istante ogni sottosistema elabora in parallelo i diversi stadi delle
successive istruzioni.

Un’architettura in cui le istruzioni sono eseguite da circuiti elementari autonomi con la


sovrapposizione temporale di diverse istruzioni, è detta pipeline.
Architettura degli Elaboratori e delle Reti 72

Supponiamo che tutte le fasi abbiano latenza pari a 10ns. Vediamo il flusso e i tempi di esecuzione di
tre istruzioni (LOAD) in una architettura senza e con pipeline.
10ns 20ns 30ns 40ns 50ns 60ns 70ns 80ns 90ns 100ns 110ns 120ns 130ns 140ns 150ns
tempo
istruzione

1a istruzione 2a istruzione 3a istruzione

IF DEC ALU MEM WB IF DEC ALU MEM WB IF DEC ALU MEM WB

50ns 50ns 50ns

100ns

150ns

10ns 20ns 30ns 40ns 50ns 60ns 70ns


tempo
istruzione

1a IF DEC ALU MEM WB

2a IF DEC ALU MEM WB

3a IF DEC ALU MEM WB

50ns

60ns

70ns

Nel processore sono attive e presenti simultaneamente più istruzioni (idealmente, una per ogni stadio
della pipeline): si realizza una forma di parallelismo intrinseco.
La tecnica delle pipeline migliora le prestazioni aumentando il throughput delle istruzioni cioè la
quantità di operazioni nell’unità di tempo.

Un’architettura a fasi autonome può essere trasformata in un’architettura con pipeline se fra ogni
coppia di stadi adiacenti si inserisce un registro di interfaccia. Lo scopo di questo registro è quello di
memorizzare i risultati intermedi prodotti dello stadio “a monte” e tutte le informazioni che possono
essere utili in stadi successivi (anche quelle che non servono allo stadio stesso).
In generale il registro di interfaccia deve memorizzare almeno le seguenti informazioni prodotte dallo
stadio precedente:
− risultato
− numero dei registri “rs”, “rt” ed “rs” (vedi Instruction Register)
− segnali di controllo
− indirizzo di memoria della prossima istruzione

Il numero di registri di interfaccia necessario a realizzare un’architettura con pipeline è uguale a:


Numero registri interfaccia = Numero fasi – 1
Architettura degli Elaboratori e delle Reti 73

Uno schema semplificato della pipeline MIPS è il seguente:

IF/DEC DEC/ALU ALU/MEM MEM/WB

IF DEC ALU MEM WB

Il nome di un registro di interfaccia è rappresentato dal nome delle fasi che esso separa.
IF/DEC Fetch/Decode
DEC/ALU Decode/ALU
ALU/MEM ALU/Memory access
MEM/WB Memory access/Write back

In condizioni ideali, a ogni ciclo di clock nello stadio più a sinistra “entra” una nuova istruzione mentre
da quello più a destra “esce” (viene portata a compimento) l’istruzione “più vecchia” fra quelle
presenti nella pipeline.

In un’architettura a pipeline, per consentire un utilizzo parallelo dei 5 sottosistemi, tutte le istruzioni
hanno la stessa latenza ed devono attraversare tutti e cinque gli stadi di esecuzione, anche se non
necessario.

L’istruzione ADD esegue la fase MEM, passa dal registro ALU/MEM al registro MEM/WB, anche se
non utilizza la memoria.
L’istruzione STORE esegue la fase WB a vuoto, poiché tutte le istruzioni che seguono la STORE sono
ancora in fase di completamento, non vi e alcun modo per accelerarle e l’istruzione deve passare
attraverso lo stadio WB anche se non vi e nulla da fare.

Questo evidenzia che il pipeline aumenta la cadenza di esecuzione delle istruzioni ma le allunga.
Architettura degli Elaboratori e delle Reti 74

Jump

MUX

DEC/ALU

PC WB
ALU/MEM

IR[31-26] Unità di
M WB
controllo MEM/WB

ALU M WB
ID/DEC

+
Shift +
sinistra
MUX
di 2
+4 IR[25-0] Shift
sinistra
di 2

Branch

ALUSrc
RegW

IR[25-21]
Nr1
O1
Indirizzo
IR[20-16]
Zero
Nr2
MemR MemW
RF
Istruzioni
ALU
Nw Risultato

MemToReg
Indirizzo
O2

MEMORIA D MUX
MEMORIA
ISTRUZIONI KAlu DATI
Dato in Dato in
ingresso uscita
MUX
IR[15-0] IR[5-0] Unità di
Le linee con freccia Estensione controllo
indicano un insieme del segno della ALU
di segnali.
Le linee senza ALUOp
freccia indicano un
solo segnale. IR[20-16]

MUX
IR[15-11]

RegDst

E’ da notare come lo stadio finale dell’esecuzione di un’istruzione, il Write back, si “porta a dietro”
tutti i dati che gli servono per modificare il registro destinazione qualora sia necessario.
Anche i segnali di controllo, generati nello stadio di decodifica dell’istruzione, attraversano i registri di
interfaccia.
Architettura degli Elaboratori e delle Reti 75

16/23 Maggio 2006


Conflitto nelle pipeline (hazard)
In un’architettura pipeline, possono sorgere delle situazioni in cui l’istruzione successiva non può
essere eseguita nel ciclo di clock immediatamente seguente;tali eventi sono definiti conflitti (hazard)
nelle pipeline.

Conflitto sui dati


Il conflitto sui dati si verifica quando un’istruzione dipende dal risultato di una istruzione che si
trova ancora nella pipeline.
Si consideri la sequenza di istruzioni:
add R1, R2, R3
sub R4, R1, R5

E si esamini la situazione della pipeline al ciclo C2:


tempo C0 C1 C2 C3 C4 C5
ordine di esecuzione

La fase MEM è presente


ma inattiva perchè le
add R1, R2, R3 IF DEC ALU MEM WB istruzioni add e sub non
accedono alla memoria

sub R4, R1, R5 IF DEC ALU MEM WB

conflitto

Nel ciclo C2, l’istruzione sub, nello stadio DEC, legge il valore del registro R1, che è uno dei due
registri sorgente. Il valore creato dalla precedente add , però, verrà scritto nel registro R1 solamente al
termine del ciclo C4: la sub legge quindi un valore errato e il programma non viene eseguito in modo
corretto.
L’errore nasce dalla dipendenza di dati fra le due istruzioni (la seconda “consuma” il risultato prodotto
dalla prima) e dal fatto che la distanza fra le due operazioni non è tale da garantire che il risultato
prodotto dalla prima sia disponibile quando la seconda lo richiede.
Architettura degli Elaboratori e delle Reti 76

Soluzioni alla conflitto sui dati


La soluzione per risolvere il problema della conflitto sui dati può essere di tipo software oppure di tipo
hardware.

Inserimento NOP (soluzione software)


La soluzione software più semplice consiste nell’inserire delle istruzione nop fra due istruzioni
successive in cui vi sia dipendenza sui dati (nop=nessuna operazione). L’assemblatore produce un
codice assembly, differente da quello originale, che con tante nop quanti sono i cicli necessari affinchè
la prima istruzione abbia generato un risultato coerente con lo svolgimento della successiva istruzione .

Istruzioni originali Istruzioni modificate dall’assemblatore


add R1, R2, R3 add R1, R2, R3
sub R4, R1, R5 nop
nop
nop
sub R4, R1, R5

tempo C0 C1 C2 C3 C4 C5 C6 C7

Le istruzioni nop non


add R1, R2, R3 IF DEC ALU MEM WB alterano lo stato del
sistema, non modificano
registri e memoria

nop IF DEC ALU MEM WB


ordine di esecuzione

nop IF DEC ALU MEM WB

nop IF DEC ALU MEM WB

sub R4, R1, R5 IF DEC ALU MEM WB

Vengono sprecati 3 cicli di clock, in modo che la fase IF dell’istruzione sub R4, R1, R5 coincida con
la fase di WB della add R1, R2, R3
L’inserimento delle nop risolve il problema ma diminuisce il throughput (prestazioni) e questa
situazione è troppo frequente perchè sia accettabile.
Architettura degli Elaboratori e delle Reti 77

Riorganizzazione del codice (soluzione software)


La soluzione più complessa ma efficiente consiste nella riorganizzazione del codice originale.
L’assemblatore cerca di inserire tra le istruzioni correlate (che presentano conflitti) delle istruzioni
indipendenti dal risultato delle precedenti istruzioni.
Si consideri la sequenza di istruzioni:
add R1, R2, R3
sub R4, R1, R5
and R6, R7, R7
and R6, R7, R7
and R6, R7, R7

L’istruzione sub dipende dal risultato prodotto dall’istruzione add (dal registro R1) mentre le istruzioni
and non hanno alcuna dipendenza.
Un assemblatore ottimizzato potrebbe riorganizzare il codice inserendo le istruzioni and fra le
istruzioni add e sub in modo tale che la add possa finire i 5 stati di pipeline e il registro R1 possa
essere disponibile per l’istruzione sub.
Questa ottimizzazione produrrebbe il seguente codice:
add R1, R2, R3
and R6, R7, R7
and R6, R7, R7
and R6, R7, R7
sub R4, R1, R5

Il principio è lo stesso adottato introducendo le istruzioni nop ma senza riduzione del throughput
(prestazioni).
Architettura degli Elaboratori e delle Reti 78

Data forwarding (soluzione hardware)


L’unità di controllo riconosce la presenza del conflitto (vedremo successivamente) e modifica il flusso
dei dati. Il principio è quello di prelevare un risultato non appena è disponibile (all’uscita dell’unità che
lo genera) e di trasferirlo all’ingresso dell’unità che ne fa uso. Questa tecnica è detta data forwarding.
Si consideri la sequenza di istruzioni:
add R1, R2, R3
sub R4, R1, R5

Il risultato dell’istruzione add è disponibile già all’uscita dell’ALU quando l’istruzione sub ha
terminato la fase DEC. In questo modo, con la tecnica del forwarding, l’uscita dell’ALU (del registro
ALU/MEM) viene reindirizzata in ingresso al posto del valore del registro letto dal Register File.
Una rappresentazione grafica del data forwarding:
tempo C0 C1 C2 C3 C4 C5
ordine di esecuzione

add R1, R2, R3 IF DEC ALU MEM WB

sub R4, R1, R5 IF DEC ALU MEM WB

In generale, la tecnica del data forwarding prevede la redirezione delle uscite dei registri ALU/MEM e
MEM/WB sugli ingressi della ALU quando si verifica una dipendenza sui dati.

Il controllo della propagazione si svolge nello stadio ALU. Di conseguenza, per determinare la
dipendenza e propagare i valori è necessario passare i numeri dei registri usati come operandi
attraverso il registro di interfaccia DEC/ALU. Dunque il motivo per il quale vengono riportati sino al
registro DEC/ALU le porzioni dell’Instruction register “rs”, “rt” ed “rd” è dovuto alla necessità di
disporre in questa fase di tali informazioni.
Architettura degli Elaboratori e delle Reti 79

Stallo (soluzione hardware)


Il forwarding non permette di risolvere un conflitto sui dati determinato da un’istruzione che utilizza il
registro scritto dalla precedente istruzione di load (conflitto load/use).
Infatti in presenza di una load, il registro destinazione non è caricato fino a quando il dato non è letto
dalla memoria fisica (al termine della fase MEM).
In tal caso, l’unità di controllo riconosce la presenza del conflitto e “mette in stallo” i la seconda
istruzione (già letta) fino a quando il valore desiderato non è disponibile nel registro sorgente della
seconda istruzione. Si dice che l’unità di controllo “inserisce delle bolle” nella pipeline ovvero blocca
il flusso di istruzioni nella pipeline finché il conflitto non è risolto.
Si consideri la sequenza di istruzioni:
load R1, mem[R2]
sub R4, R1, R5

Lo stato della pipeline sarà il seguente:


tempo C0 C1 C2 C3 C4 C5 C6 C7 C8
ordine di esecuzione

add R1, R2, R3 IF DEC ALU MEM WB

sub R4, R1, R5 IF Bubble Bubble Bubble DEC ALU MEM WB

Lo stallo di un’istruzione si ottiene forzando tutti i bit di controllo a 0, impedendo di fatto ogni
modifica su memoria e registri.

i
mettere in stallo=sospendere
Architettura degli Elaboratori e delle Reti 80

Rilevazione delle dipendenze


La rilevazione delle dipendenze avviene verificando l’uguaglianza fra i registri destinazione
dell’istruzione in ALU/MEM e MEM/WB e i registri sorgente dell’istruzione in DEC/ALU e
ALU/MEM.
Una notazione che assegni dei nomi ai campi dei registri di pipeline permetterà di formalizzare le
dipendenze con maggiore precisione.
Sapendo che ogni registro di pipeline memorizza anche il contenuto dell’Instruction Register,
possiamo utilizzare una notazione tipo DEC/ALU.IR[rs] per indicare il registro di pipeline DEC/ALU
e la parte dell’Instruction Register dedicata al valore di “rs”.

I conflitti sui dati gestibili mediante “data forwarding” sono rilevati dalle seguenti condizioni:
a) ALU/MEM.IR[rd] = DEC/ALU.IR[rs]
b) ALU/MEM.IR[rd] = DEC/ALU.IR[rt]
c) MEM/WB.IR[rd] = DEC/ALU.IR[rs]
d) MEM/WB.IR[rd] = DEC/ALU.IR[rt]

I conflitti sui dati (load/use) gestibili mediante “stallo” sono rilevati dalle seguenti condizioni:
e) DEC/ALU.IR[rt] = IF/DEC.IR[rs]
f) DEC/ALU.IR[rt] = IF/DEC.IR[rt]

Si consideri la sequenza di istruzioni:


add R1, R2, R3
sub R4, R1, R1

La condizione a) verifica che il campo registro destinazione “rd” dell’istruzione add coincide con il
registro sorgente “rs” dell’istruzione sub e consente la propagazione del risultato della add con la
tecnica del data forwarding.

Si consideri la sequenza di istruzioni:


load R1, mem[R2]
sub R4, R1, R1

La condizione e) verifica che il campo registro destinazione “rt” dell’istruzione load coincide con il
registro sorgente “rs” dell’istruzione sub e consente la messa in stallo dell’istruzione sub.
Le rilevazioni del conflitto sui dati implica anche la verifica dei segnali di controllo RegW e MemR
che sono stati tralasciati per semplificare la comprensione del problema.
Architettura degli Elaboratori e delle Reti 81

DEC/ALU ALU/MEM MEM/WB

Nr1
O1

Zero
Nr2
RF ALU
Risultato Indirizzo
Nw
O2

D MEMORIA

Dato in Dato in
ingresso uscita
MUX

MUX

senza data forward

DEC/ALU ALU/MEM MEM/WB

Nr1
O1 MUX

Zero
Nr2
RF ALU
Risultato Indirizzo
Nw
O2 MUX

D MEMORIA

Dato in Dato in
ingresso uscita
MUX

IF/DEC.IR[rs]

IF/DEC.IR[rt]

MUX
IF/DEC.IR[rd]

Unità di
propagazione

con data forward

Il controllo della propagazione si svolge nello stadio ALU, di conseguenza, per determinare la
dipendenza e propagare i valori è necessario passare i numeri dei registri usati come operandi
attraverso il registro di interfaccia DEC/ALU. Dunque il motivo per il quale vengono riportati sino al
registro DEC/ALU le porzioni dell’Instruction Register “rs”, “rt” ed “rd” è dovuto alla necessità di
disporre in questa fase di tali informazioni.
Architettura degli Elaboratori e delle Reti 82

Conflitto sugli indirizzi


Il conflitto sugli indirizzi si verifica quando un’istruzione di salto viene eseguita (condizionato,
incondizionato, chiamate a procedura e ritorni da procedura).
Si consideri la sequenza di istruzioni:
beq R1, R2, label_1
add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]
label_1: and R9, R10, R10

Se non si prendono provvedimenti particolari, le istruzioni che seguono il salto vengono avviate lungo
la pipeline prima che si sappia se il salto deve essere eseguito. Il rischio è quello di eseguire istruzioni
(quelle dopo l’istruzione di salto) che non devono essere eseguite e che potrebbero modificare i registri
o la memoria.

Soluzioni alla conflitto sugli indirizzi


La soluzione per risolvere il problema della conflitto sugli indirizzi può essere di tipo software oppure
di tipo hardware.

Stallo (soluzione hardware)


La soluzione più semplice a questo problema consiste nel “mettere in stallo” la CPU, per il numero
necessario di cicli di clock, nel momento in cui si decodifica un’istruzione di salto.

Salti incondizionati:
− l’istruzione di salto viene riconosciuta nello stadio DEC.
− l’istruzione precedente, nello stadio IF, viene eliminata.
− viene calcolato l’indirizzo di salto e aggiornato il Program Counter.

Salti condizionati:
− l’istruzione di salto viene riconosciuta nello stadio DEC.
− l’istruzione precedente, nello stadio IF, viene bloccata.
− vengono inserite delle “bolle” fino a quando la condizione di salto non viene verificata (ALU).
− se il salto viene effettuato l’istruzione nello stadio IF viene eliminata, calcolato l’indirizzo di salto e
aggiornato il Program Counter.
− se il salto non viene effettuato l’istruzione nello stadio IF viene “rilasciata” e continua l’esecuzione
attraverso la pipeline.

Questo tipo di approccio necessita di un intervento hardware (circuiti aggiuntivi) per riconoscere le
istruzioni di salto nello stadio DEC e per attuare le conseguenti azioni.
Evidenziamo come i salti incondizionati siano più semplici da gestire perchè già nella fase DEC
sappiamo che il salto è di tipo incondizionato e conosciamo la locazione di salto.
In presenza di salti condizionati, al contrario, non sappiamo se il salto verrà eseguito e dobbiamo
attendere il termine dell’esecuzione dell’istruzione di salto (fase MEM) per conoscere la locazione di
salto (successivamente vedremo che il riconoscimento ed esecuzione dell’istruzione di salto può essere
anticipata alla fase DEC).
Architettura degli Elaboratori e delle Reti 83

Delayed branch (soluzione software)


Questo metodo consiste nell’inserire dopo l’istruzione di salto tante istruzioni (indipendenti) quanti
sono i cicli necessari affinché istruzione di salto sia completata.
Le locazioni delle istruzioni immediatamente successive al salto prendono il nome di delay slot.
Questo tipo di soluzione è detta delayed branch (salto ritardato) perchè ha effetto quando le istruzioni
nel delay slot hanno terminato l’esecuzione, quindi con un certo ritardo.

Si consideri la sequenza di istruzioni:


add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]
jump label_1
and R9, R10, R10

L’istruzione add viene inserita nel ciclo di esecuzione della pipeline anche se il salto incondizionato
sposta il flusso del programma alla locazione label_1.
L’assemblatore inserisce tre nop dopo l’istruzione jump riorganizzando il flusso nella pipeline e
producendo il seguente codice:
add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]
jump label_1
nop
nop
nop
and R9, R10, R10

Un assemblatore ottimizzato potrebbe riorganizzare il codice spostando nel delay slot le tre istruzioni
che precedono la jump senza dover inserire inutili nop.
Questa ottimizzazione produrrebbe il seguente codice:
jump label_1
add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]
and R9, R10, R10

Il principio è lo stesso adottato introducendo le istruzioni nop ma senza riduzione del throughput
(prestazioni).
Questa soluzione e anche le successive possono essere migliorate se l’esecuzione del salto viene
spostata dallo stadio MEM allo stadio DEC.
Il risultato ci consente di ridurre a uno il numero di istruzioni nel delay slot e in generale di anticipare
azioni correttive in caso di salto condizionato, avendo una sola istruzione nello stadio IF.
Spostare l’esecuzione del salto nello stadio DEC significa anticipare:
− il confronto di uguaglianza fra i registri (utilizzando un comparatore)
− il calcolo dell’indirizzo di salto
− l’aggiornamento del Program Counter
Architettura degli Elaboratori e delle Reti 84

Branch prediction
L’idea base delle tecniche di predizione (statiche o dinamiche) dei salti condizionati è quella di
scegliere a priori quali istruzioni eseguire dopo l’istruzione di salto scommettendo sul futuro flusso del
programma.
Il motto potrebbe essere così riassunto: “Piuttosto che andare in stallo meglio fare una scelta”.

I metodi di branch prediction vengono suddivisi in statici e dinamici.

Static branch prediction (soluzione software)


L’assemblatore analizza il programma e sulla base di schemi (pattern) noti, stabilisce quali
cambiamenti apportare.
Si consideri la sequenza di istruzioni (slot delay = 1):
label_1: and R9, R10, R10


beq R1, R2, label_1
add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]

L’istruzione beq esegue il salto (taken) se i registri R1 e R2 sono uguali altrimenti non esegue il salto
(not taken) e continua ad eseguire le istruzioni successive (add, sub, load)
Se fossimo certi che la maggior parte delle volte l’istruzione beq salta (taken) potremmo riscrivere il
codice in questo modo:
label_1:


beq R1, R2, label_1
and R9, R10, R10
add R3, R4, R4
sub R5, R6, R6
load R8, mem[R7]

L’istruzione and che si trovava all’indirizzo di salto verrebbe spostata nel delay slot seguendo lo
schema del delayed branch.

Gli schemi di predizione statici sono schemi che vengono applicati prima dell’esecuzione stessa del
programma ed indipendentemente dal flusso dinamico delle istruzioni.
Fra questi possiamo indicare alcuni metodi che, sebbene molto semplici e privi di costi aggiuntivi,
rappresentano comunque una efficace alternativa al non avere nessuna sorta di predizione.
− Always Taken: si basa sul fatto che è statisticamente più probabile avere un’istruzione di salto che
esegue il salto (taken) rispetto ad un’istruzione che non esegue il salto (not taken).
− Backward taken, Forward not taken (BTFN): se l’indirizzo del salto è posto prima di quello del
branch si effettua il salto, altrimenti non si effettua. La base teorica che giustifica questo
comportamento è che i salti ad indirizzi anteriori sono, la maggior parte delle volte, appartenenti a
dei cicli e spesso devono essere effettuati.
Architettura degli Elaboratori e delle Reti 85

Dynamic branch prediction (soluzione hardware)


Gli schemi di predizione dinamica sono schemi che vengono applicati durante l’esecuzione stessa del
programma e dipendono dal flusso dinamico delle istruzioni.
Questo approccio necessita di circuiti aggiuntivi il cui scopo è quello di memorizzare la storia di
ciascun salto e di attuare le azioni correttive qualora la predizioni del salto sia errata.
In una tabella, detta Branch History Table (BHT), vengono salvati gli ultimi n indirizzi delle
istruzioni di branch condizionato e uno (o 2) bit che indicano se l’ultima volta si è verificato il salto
oppure no.
Quando un’istruzione di salto è presente nella BHT e il bit di storia è 1, il processore inizia
l’esecuzione delle istruzioni successive all’indirizzo di salto (non all’istruzione di salto) ritenendo
probabile l’esecuzione del salto stesso. Quando la predizione si rivela errata il bit di storia della BHT
viene azzerato e le istruzioni inserite nella pipeline vengano “scaricate” in modo da non alterare lo
stato del sistema (registri-memoria).

Branch history (1 bit)

Branch address/Tag (32 bit)

Lo schema di previsione ad 1 bit ha un difetto in termini di prestazioni: anche se il salto fosse quasi
sempre eseguito, si otterrebbe una previsione scorretta due volte (anziché una sola) quando il salto non
è eseguito.

Gli schemi di previsione a due bit al contrario permettono di avere un’accuratezza pari alla frequenza
di esecuzione dei salti. Infatti, la previsione deve essere sbagliata per due volte prima di essere
modificata. Utilizzando due bit, un salto condizionato sarà oggetto di una previsione errata soltanto una
volta. I due bit sono utilizzati per codificare i 4 stati del sistema:

wrong prediction

Predict Predict
right prediction
branch branch
one more time
(11)
(10)
right prediction

wrong prediction wrong prediction

right prediction

Predict Predict
no branch no branch right prediction
one more time
(00)
(01)
wrong prediction
Architettura degli Elaboratori e delle Reti 86

29 Maggio 2006
Cache
La memoria cache è un tipo di memoria piccola e molto veloce, montata all’interno del processore, che
mantiene copia dei dati/istruzioni ai quali si accede più frequentemente.
Finché la maggior parte degli accessi alla memoria avviene su dati/istruzioni caricati nella cache, la
latenza media dell’accesso alla memoria sarà più vicina alla latenza della cache piuttosto che a quella
della memoria principale.

La memoria cache sfrutta il principio empirico di località spaziale e temporale durante l’esecuzione
dei programmi:
− località spaziale: quando si fa riferimento a un elemento di memoria, con alta probabilità si farà
entro breve tempo riferimento a elementi vicini (es.: istruzioni in una sequenza; dati organizzati in
vettori o matrici e cui si accede sequenzialmente, etc.).
− località temporale: quando si fa riferimento a un elemento di memoria, con alta probabilità si farà di
nuovo riferimento allo stesso elemento entro breve tempo (caso tipico: ripetuto accesso alle
istruzioni e alle variabili entro un ciclo).

Le dimensioni ridotte della memoria cache (4, 8, 16, 32K) non consentono la memorizzazione di
grosse porzioni di memoria centrale. L’unità minima di informazione che può essere trasferita fra le
due memoria è chiamata blocco (a volte detto anche linea).
Quando il processore vuole leggere o scrivere in una data locazione in memoria principale,
inizialmente controlla se il contenuto di questa locazione è caricato in cache. Se il processore trova
che la locazione di memoria è in cache, si parla di cache hit (accesso avvenuto con successo),
altrimenti di cache miss (fallimento d’accesso). Nel caso di un cache hit, il processore legge o scrive
immediatamente il dato sulla linea di cache, nel caso di cache miss, il controllore della cache deve
accedere alla memoria di livello inferiore per reperire il blocco che contiene l’informazione richiesta.
Il rapporto tra cache hit e accessi totali è chiamato anche hit rate ed è una misura dell’efficacia della
cache stessa.

Per poter fare spazio a nuovi dati nel caso di un cache miss, la cache generalmente deve eliminare il
contenuto di una blocco. L’euristica che utilizza per scegliere quale dato eliminare è chiamata politica
di rimpiazzamento. Il problema fondamentale di ogni politica di rimpiazzamento è quello di dover
predire il dato della cache che verrà richiesto nel futuro con minor probabilità. Predire il futuro è
difficile, soprattutto per le cache hardware che devono sfruttare regole facilmente implementabili in
circuiteria, perciò esistono una serie di politiche di rimpiazzamento e nessuna di esse può essere
ritenuta perfetta.
Architettura degli Elaboratori e delle Reti 87

La struttura della memoria cache del MIPS


Lo schema della cache del processore MIPS è il seguente:

Indirizzo 32 bit
Tag Indice Word N.u.
18 bit 10 bit 2 bit 2 bit

Cache

Index V Tag W0 W1 W2 W3

2
Decoder

...

Demux

Data

Hit=1 / Miss=0

L’indirizzo è logicamente suddiviso in 4 porzioni:


− i 2 bit di posizione A1-A0 sono inutilizzati perché l’indirizzamento è sempre allineato a multipli di
4 byte (una word o parola).
− i 2 bit di posizione A3-A2 servono per individuare quale word si vuole caricare.
− i 10 bit di posizione A13-A4 sono utilizzati come indice e selezionano mediante un decoder una riga
della cache.
− i 18 bit di posizione A31-A14 sono utilizzati come tag e rappresentano i bit piu significativi
dell’indirizzo di un blocco di memoria.

La riga di cache è composta da un bit di validità della riga di cache, 18 bit di tag da confrontare con
l’ultima porzione dell’indirizzo (A31-A14) e i 16 byte di dati, suddivisi in quattro word da 32 bit.

L’indice dunque abilita l’uscita delle 6 informazioni. Le quattro word di dati entrano in un
memultiplexer pilotato dai bit A3-A2 dell’indirizzo. Il tag entra in un comparatore insieme al tag
dell’indirizzo. Il risultato è posto in AND con il bit di validità della riga di cache ed indicherà una
lettura valida (cache hit) o non valida (cache miss).
Architettura degli Elaboratori e delle Reti 88

Calcolare la dimensione di una cache


La dimensione, in bit, di una cache si calcola nel modo seguente:
Cache Sizebit = 2index ⋅ [ 1 + ( NPL ⋅ WS ) + (WS − Index − 2 − log 2 NPL) ]

dove:
WS = word size (es. 32)
Index = numero di bit utilizzati come indice (es. 10)
NPL = numero di parole per linea di cache (es. 4)

Nel caso del MIPS abbiamo che:


Cache Sizebit = 210 ⋅ [ 1 + (4 ⋅ 32) + (32 − 10 − 2 − log 2 4)] = 1024 ⋅ (1 + 128 + 18) = 150528 bit =
18816 byte ≅ 18 Kbyte

Write Through e Write Back


Se prendiamo in considerazione la memoria cache dei dati, abbiamo un problema importante da
risolvere: il dato letto dalla memoria centrale e copiato nella memoria cache del processore può essere
modificato, lasciando le due locazioni di memoria temporaneamente inconsistenti.
Per risolvere questo problema ci sono due tecniche: write through e write back.

Write through
La scrittura avviene contemporaneamente in cache e in memoria centrale.
Per evitare che il tempo di scrittura nella memoria centrale generi un ritardo, si introduce un write
buffer che memorizza i dati provenienti dal processore in attesa di trasferirli alla memoria centrale
(simultaneamente, vengono scritti in cache). Se le scritture sono relativamente rare, la
scrittura nel buffer avviene alla velocità del processore, dal buffer alla memoria centrale alla velocità
della memoria centrale (si disaccoppiano memoria centrale e processore).
Il write buffer è piccola memoria first in – first out (FIFO) gestita come un registro a scorrimento.

Write back
La scrittura avviene solo in cache. Il blocco modificato viene copiato nella memoria centrale solo nel
momento in cui deve essere sostituito da un altro blocco.
Questa soluzione può dare migliori prestazioni perché, grazie alla località, è probabile che si scriva più
volte nello stesso blocco prima che questo venga sostituito. La scrittura in memoria centrale avviene
quindi con minore frequenza che nel caso precedente, peraltro qui si scrive l’intero blocco invece di
una parola.
Per migliorare l’efficienza dello schema write back e non riscrivere in memoria centrale tutte le volte
che si fa una sostituzione ma solo se c’è stata una scrittura. La cache tiene traccia delle linee che
contegono dati da aggiornare settando opportunamente quello che viene chiamato dirty bit. Il dato
viene effettivamente scritto in memoria centrale solo quando esso deve essere eliminato dalla cache per
far spazio a nuove informazioni. Per questa ragione, una cache miss in una cache write-back spesso
genera due accessi alla memoria: uno per leggere il nuovo dato, l’altro per scrivere la vecchia
informazione (se indicato dal dirty bit).
Architettura degli Elaboratori e delle Reti 89

1 Giugno 2006
Memoria virtuale
La memoria RAM, agli inizi era utilizzata caricando interamente i programmi al suo interno prima di
eseguirli. Se la memoria non era sufficiente per contenerli tutti, bisognava scegliere quali programmi
dovevano aspettare. Più tardi fu introdotta la tecnica di overlay che consisteva nel caricare in memoria
solo la “radice di un programma” e, mediante comandi specifici, scaricare e caricare in memoria di
volta in volta le routine necessarie alla sua esecuzione. Questa gestione diminuì l’occupazione di
memoria dei programmi da caricare in memoria e quindi aumentò il numero dei programmi eseguibili
contemporaneamente.
Finalmente giungiamo alla memoria virtuale che può essere definita così: un sistema dispone della
memoria virtuale quando la somma delle dimensioni di tutti i programmi rappresentati in memoria può
eccedere la dimensione della memoria fisica.
Gli indirizzi dei programmi sono detti logici, mentre gli indirizzi della memoria sono detti fisici.
Nella gestione della memoria virtuale, i programmi non sono più caricati in modo sequenziale ma a
“pagine” o “segmenti”.

Memoria virtuale paginata


Nella gestione paginata della memoria virtuale, la memoria RAM è suddivisa in blocchi di dimensione
fissa, la stessa con la quale il sistema operativo suddivide in pagine il codice del programma da
eseguire.
Un blocco di memoria = Una pagina di codice

Le dimensioni tipiche di un blocco di memoria sono di 4K, 8K, 16K byte.

L’indirizzo logico di ogni singola istruzione all’interno del programma è individuato da una coppia:
pagina P e spiazzamento D, cioè numero della pagina e spiazzamento all’interno della pagina stessa.

Indirizzo logico = Page , Displacement

L’associazione fra il numero di pagina e il blocco di memoria corrispondente risiede in una tabella
detta Page Map Table (PMT).
Il numero di pagina indica la posizione nella tabella dove è contenuto l’indirizzo fisico del blocco di
memoria corrispondente.
Indirizzo fisico = PMT[P] + D

Nella tabella PMT sono inoltre presenti:


− un bit YN (YesNo) che segnala se la pagina è stata caricata in memoria oppure no.
− un bit D (Dirty Bit) che indica se la pagina presente in memoria è stata modificata (pagina dati); in
tal caso la pagina deve essere salvata su disco nel momento in cui viene “scaricata” dalla memoria
centrale
Architettura degli Elaboratori e delle Reti 90

L’unità preposta alle operazioni di memoria è il coprocessore MMU, Memory Manager Unit.

In ambiente multitasking, dove diversi programmi devono risiedere in memoria, è necessaria una PMT
per ogni programma. All’interno della MMU è, dunque, presente un registro: il Page Map Table
Address Register (PMTAR), che contiene l’indirizzo fisico della tabella PMT del programma
correntemente in esecuzione. Ogni qual volta un sistema operativo assegna l’utilizzo della CPU ad un
programma, imposterà il nuovo valore di PMTAR caricando la PMT del programma da eseguire in
memoria cache, per velocizzare le operazioni di indirizzamento.

CPU MMU RAM

Indirizzo logico PMTAR


Page Displacement

PMT

Page Blocco YN D
0 61850 1 1
1 28050 1 0
2 44004 0 1
.. ... .. ..
N 96034 0 0

PMT

Page Blocco YN D
0 18508 0 1
1 80502 1 0
2 40034 1 0
.. ... .. ..
N 60340 0 1

Quando la pagina indirizzata non viene trovata nella memoria RAM, viene generato un page fault. Il
blocco di memoria viene dunque caricato da disco fisso a memoria RAM, il bit YN nella PMT viene
impostato a 1 e si prosegue con la lettura della cella fisica di memoria.
Se la memoria RAM è completamente utilizzata, il sistema operativo deve “liberare” un blocco di
memoria utilizzato dal programma stesso o da un altro e sovrascriverlo con quello nuovo.
Ma quale tecnica si usa per scegliere il blocco di memoria da riassegnare ?
La tecnica più utilizzata per scegliere i blocchi di memoria da riutilizzare è la LRU, Least Recently
Used. La tecnica LRU si basa sulla gestione di una coda puntata (doppio link) di blocchi di memoria.
Ogni qual volta un blocco di memoria è indirizzato, viene spostato all’inizio della coda. Così facendo il
blocco meno indirizzato (meno usato recentemente) rimarrà in fondo alla coda e sarà quello che sarà
riassegnato per contenere un nuovo blocco di memoria, prima di essere spostato a sua volta in cima
alla coda.
Architettura degli Elaboratori e delle Reti 91

Questa tecnica comunque garantisce una buona probabilità di avere in memoria le pagine di codice e di
conseguenza i blocchi di memoria necessari all’esecuzione di un programma.
Questo sempre in base al principio empirico di località spaziale e temporale dell’esecuzione di un
programma.

Page
E’ secondo questo principio che in memoria
Fault tende ad esserci un working set di pagine di
dimensione limitato rispetto alla dimensione di
un programma, che consente la sua esecuzione
senza conseguenze sulle performance.
E’ dimostrato empiricamente che
all’aumentare dei numeri di blocchi di
memoria assegnati ad un programma per la sua
esecuzione (il working set), dopo una certa
dimensione, il numero dei page fault non
cambia.
Working Memory Quella dimensione è pertanto il working set
Set Size Block Size size ideale per il programma.

La gestione della memoria virtuale paginata è di gran lunga la tecnica più utilizzata.
La sua performance però dipende molto da com’è scritto un programma. Pensiamo a quando
accediamo ad una grande tabella di interi in memoria. A seconda di come leggiamo le celle, per righe o
per colonne, potremo caricare tutte le pagine dati in sequenza o saltare da una pagina all’altra,
generando continuamente page fault.

Memoria virtuale segmentata


Nella gestione segmentata della memoria virtuale, la memoria RAM è suddivisa in blocchi di
dimensione variabile, la stessa con la quale il sistema operativo suddivide in segmenti il codice del
programma da eseguire. Il vantaggio principale consiste nel suddividere i programmi in segmenti a cui
attribuire un significato e che dunque provocano un numero minore di page fault.

Il problema principale tuttavia rimane la frammentazione della memoria che si viene a creare man
mano che programmi di differenti dimensioni vengono caricati e scaricati dalla memoria lasciando
lacune di dimensioni casuali che possono essere troppo piccole per essere assegnate al caricamento
sequenziale del successivo programma.
Questa gestione necessita quindi di una strategia di ricerca e assegnazione delle “lacune” ai programmi
da eseguire, nonché una politica chiamata di garbage collection, ovvero il recupero della memoria
frammentata accorpandola.
Le tre tecniche di assegnazione della memoria in presenza di frammentazione sono:
− First Fit: prima allocazione possibile che riesca a contenere il programma da eseguire.
− Best Fit: prima allocazione simile che riesca a contenere il programma da eseguire.
− Worst Fit: prima allocazione più grande possibile che riesca a contenere il programma da eseguire.
Architettura degli Elaboratori e delle Reti 92

Ogni tecnica presenta vantaggi e svantaggi:

First Fit è la tecnica più veloce perché l’algoritmo di ricerca si ferma alla prima lacuna
sufficientemente grande da contenere il programma da eseguire. Non esegue, tuttavia, ottimizzazioni
lasciando al caso l’utilizzo della memoria.

Best Fit è più lenta di First Fit perché questa tecnica deve confrontare le dimensioni di tutte le lacune
presenti e scegliere quella simile a quella del programma da eseguire. Minimizza però lo spreco di
memoria lasciando lacune molto piccole.

Worst Fit applica l’approccio complementare a First Fit perché questa tecnica deve confrontare le
dimensioni di tutte le lacune presenti e scegliere quella più grande rispetto a quella del programma da
eseguire. Massimizza lo spreco di memoria lasciando lacune molto grandi, tuttavia aumenta
notevolmente la probabilità che la lacuna sia abbastanza grande da contenere un nuovo programma,
contrariamente al Best Fit, la cui allocazione tende a generare lacune non più utilizzabili.
Architettura degli Elaboratori e delle Reti 93

5 Giugno 2006
Rete di elaboratori
Una rete di elaboratori è un insieme di nodi di calcolo indipendenti e interconnessi (Tanenbaum).
Per ridurre la complessità di progetto, le reti sono in generale organizzate a livelli, ciascuno costruito
sopra il precedente. Lo scopo di un livello è offrire certi servizi ai livelli più alti, nascondendo i dettagli
sul come tali servizi siano implementati.
Il livello n su un host porta avanti una conversazione col livello n su di un’altro host. Le regole e le
convenzioni che governano la conversazione sono collettivamente indicate col termine di protocollo di
livello n.

HOST 1 HOST 2
Protocollo
di livello 5
Livello 5 Livello 5

Interfaccia liv. 4/5 Interfaccia liv. 4/5


Protocollo
di livello 4
Livello 4 Livello 4

Interfaccia liv. 3/4 Interfaccia liv. 3/4


Protocollo
di livello 3
Livello 3 Livello 3

Interfaccia liv. 2/3 Interfaccia liv. 2/3


Protocollo
di livello 2
Livello 2 Livello 2

Interfaccia liv. 1/2 Interfaccia liv. 1/2


Protocollo
di livello 1
Livello 1 Livello 1

Mezzo fisico

In realtà non c’è un trasferimento diretto dal livello n di host 1 al livello n di host 2. Ogni livello di
host 1 passa i dati, assieme a delle informazioni di controllo, al livello sottostante.

Fra ogni coppia di livelli adiacenti è definita una interfaccia, che caratterizza:
− le operazioni primitive che possono essere richieste al livello sottostante;
− i servizi che possono essere offerti dal livello sottostante.

L’insieme dei livelli e dei relativi protocolli è detto architettura di rete.

L’insieme dei protocolli utilizzati su un host e relativi ad una specifica architettura di rete va sotto il
nome di pila di protocolli (protocol stack).
Architettura degli Elaboratori e delle Reti 94

Internet Protocol Suite - Architettura TCP/IP


L’architettura più nota e utilizzata al mondo è la Internet Protocol Suite o architettura TCP/IP, dal
nome dei suoi due protocolli principali. Essa non è un modello standard nel senso stretto del termine,
in quanto include protocolli che sono specificati per mezzo di documenti detti RFC (Request For
Comments).

I livelli TCP/IP hanno questa relazione con quelli OSI i:

OSI Tcp/Ip

Application Application
Presentation
Session

Tranport Transport
Network Internet

Data Link
Host-to-Network
Fisico

Livello host-to-network
Il livello più basso non è specificato nell’architettura, che prevede di utilizzare quelli disponibili per le
varie piattaforme HW e conformi agli standard.
Tutto ciò che si assume è la capacità dell’host di inviare pacchetti IP sulla rete.

Livello Internet
E’ il livello che tiene insieme l’intera architettura. Il suo ruolo è permettere ad un host di iniettare
pacchetti in una qualunque rete e fare il possibile per farli viaggiare, indipendentemente gli uni dagli
altri e magari per strade diverse, fino alla destinazione, che può essere situata anche in un’altra rete.
E’ definito un formato ufficiale dei pacchetti ed un protocollo, Internet Protocol (IP). Esso è
responsabile del routing e del controllo congestione.

Livello Transport
E’ progettato per consentire la conversazione dei programmi sugli host sorgente e destinazione (end-
to-end). Sono definiti due protocolli in questo livello:
TCP (Transmission Control Protocol): è un protocollo connesso ed affidabile (ossia tutti i pacchetti
arrivano, e nell’ordine giusto). Frammenta il flusso in arrivo dal livello superiore in messaggi separati
che vengono passati al livello Internet. In arrivo, i pacchetti vengono riassemblati in un flusso di output
per il livello superiore.
UDP (User Datagram Protocol): è un protocollo non connesso e non affidabile, i pacchetti possono
arrivare in ordine diverso o non arrivare affatto.

i
OSI (Open Systems Interconnection) Reference Model è il frutto del lavoro della ISO (International Standard
Organization)
Architettura degli Elaboratori e delle Reti 95

Livello Application
Nell’architettura TCP/IP non ci sono i livelli session e presentation (non furono ritenuti necessari;
l’esperienza col modello OSI ha mostrato che questa visione è condivisibile).

Sopra il livello transport c’è direttamente il livello application, che contiene tutti i protocolli di alto
livello vengono usati dalle applicazioni reali.

Alcuni protocolli sono:


Telnet: terminale virtuale;
FTP (File Transfer Protocol): file transfer;
SMTP (Simple Mail Transfer Protocol) e POP (Post Office Protocol): posta elettronica.
DNS (Domain Name Service): mapping fra nomi di host e indirizzi IP numerici;
NNTP (Network News Transfer Protocol): trasferimento di articoli per i newsgroup;
HTTP (HyperText Transfer Protocol): alla base del Word Wide Web.

I vari protocolli nell’architettura TCP/IP si collocano come segue:

Application Telnet Ftp Smtp Http Nntp

Transport Tcp Udp

Internet IP

Host-to-Network Vari standard per LAN e WAN


Architettura degli Elaboratori e delle Reti 96

Local Area Network – LAN


Le reti locali (Local Area Network, LAN), hanno generalmente le seguenti caratteristiche:
− sono possedute da una organizzazione (reti private).
− hanno un’estensione che arriva fino a qualche km.
− si distendono nell’ambito di un singolo edificio o campus.
− sono usatissime per connettere PC o workstation.

Sono possibili diverse topologie di rete, le più diffuse sono il bus ed il ring:
− topologia bus: in ogni istante solo un elaboratore può trasmettere, gli altri devono astenersi;
è necessario un meccanismo di arbitraggio per risolvere i conflitti quando due o più elaboratori
vogliono trasmettere contemporaneamente (Ethernet);
− topologia ring: in un ring ogni bit circumnaviga l’anello in un tempo tipicamente inferiore a quello
di trasmissione di un pacchetto; anche qui è necessario un meccanismo di arbitraggio spesso basato
sul possesso si un gettone (token) che abilita alla trasmissione (Token Ring);

Ring

Bus

La rete Ethernet è una delle reti locali più diffuse a livello mondiale e possiede le seguenti
caratteristiche:
− topologia: a bus
− mezzi trasmissivi: doppino di rame, cavo coassiale, fibra ottica
− velocità di trasmissione: da 10 Mbit/s a 1Gb/s in banda base con codifica di tipo Manchester
− protocollo di accesso al mezzo: CSMA/CD
Architettura degli Elaboratori e delle Reti 97

Mezzi trasmissivi
Doppino in rame
Il doppino in rame consiste di una coppia di conduttori in rame intrecciati l’uno coll’altro in forma
elicoidale (Twisted Pair). Ciò fa si che si minimizzino le interferenze fra coppie adiacenti (due fili
paralleli costituiscono un’antenna; se sono intrecciati no). E’ usato, in particolare, per le connessioni
terminali del sistema telefonico (da casa alla centrale più vicina).

Cavo coassiale
Il cavo coassiale offre un miglior isolamento rispetto al doppino e quindi consente velocità di
trasmissione maggiori su distanze superiori.
E’ costituito da un conduttore centrale in rame circondato da uno strato isolante all’esterno del quale vi
è una calza metallica.
Conduttore di rame
Strato isolante

Rivestimento esterno

Calza metallica

Era molto usato nel sistema telefonico per le tratte a lunga distanza, ma in tale ambito è ormai
sostituito quasi ovunque dalla fibra ottica. Rimane in uso per la TV via cavo e in molte LAN.

Fibre ottiche
Le fibre ottiche sono fatte di un sottilissimo cilindro centrale in vetro, (core) circondato da uno strato
esterno (cladding) di vetro avente un diverso indice di rifrazione e da una guaina protettiva. Sono
quindi raggruppate insieme in una guaina contenitrice esterna.
Core Cladding
Rivestimento

Guaina esterna
Architettura degli Elaboratori e delle Reti 98

Le fibre ottiche sfruttano il principio della deviazione che un raggio di luce subisce quando attraversa il
confine fra due materiali diversi (core e cladding nel caso delle fibre). La deviazione dipende dagli
indici di rifrazione dei due materiali. Oltre un certo angolo, il raggio rimane intrappolato all’interno del
materiale.

Aria

Silicio

Cladding
Core

Le fibre ottiche hanno elevate prestazioni: con le correnti tecnologie è raggiungibile una velocità di
trasmissione di 50.000 Gbps (50 Tbps) con un bassissimo tasso d’errore. La pratica attuale di usare
velocità dell’ordine dei Gbps dipende dall’incapacità di convertire più velocemente segnali elettrici in
luminosi. Infatti, nelle fibre ottiche, il mezzo fisico utilizzato è ovviamente la luce, e un impulso
luminoso rappresenta un 1 mentre la sua assenza uno zero.

Vantaggi delle fibre ottiche rispetto al rame:


− leggerezza a parità di banda (due fibre sono più capaci di 1.000 doppini, 100 kg/km contro 8.000
kg/km);
− totale insensibilità a disturbi elettromagnetici;
− difficile l’inserimento di intrusi per spiare il traffico.

Svantaggi delle fibre ottiche rispetto al rame:


− costo delle giunzioni;
− comunicazione unidirezionale (due fibre sono necessarie per una comunicazione two-way).
Architettura degli Elaboratori e delle Reti 99

Codifica dei dati


Le rete Ethernet non usa una codifica diretta dei dati (ad esempio, zero volt per lo zero e cinque volt
per l’uno), perché sarebbe difficile rilevare le collisioni.
Questa rete utilizza una codifica, detta Manchester, che prevede una transizione del valore del segnale
nel mezzo di ogni bit, zero o uno che sia.

Codifica Codifica
di Zero di Uno

+ 0,85 V

0V

- 0,85 V

Durata Durata
del bit del bit

Fra i vantaggi di tale codifica:


− facilità di sincronizzazione fra mittente e destinatario;
− il codice trasmissivo è bilanciato, cioé vi è uguale energia per lo zero e per l’uno, e quindi la
trasmissione di dati, anche se genera diverse quantità di zeri e uni, non produce componenti in
corrente continua, molto dannose perché ostacolano la trasmissione dei segnali;
− è facile rilevare le collisioni.

Si noti però che tale codifica richiede, a parità di velocità di trasmissione, una banda doppia rispetto
alla codifica diretta (ogni bit richiede la trasmissione di due valori distinti).
Architettura degli Elaboratori e delle Reti 100

Protocollo di accesso al servizio


La rete Ethernet usa il protocollo 802.3 di tipo CSMA/CD (Carrier Sense Multiple Access
/Collision Detection):
− prima di trasmettere, la stazione aspetta che il canale sia libero (Carrier Sense);
− appena è libero inizia a trasmettere ma resta in ascolto per rivelare eventuali collisioni;
− se c’è una collisione, la stazione notifica a tutti della collisione, aspetta una certa quantità di tempo e
riprova a trasmettere.

Posto uguale a T il tempo di propagazione del segnale da un capo all’altro della rete, è necessario che
trascorra un tempo pari a 2T perché una stazione possa essere sicura di rilevare una collisione.

Infatti, se una stazione A posta ad una estremità della rete inizia a trasmettere al tempo t0, il suo
segnale arriva a B (posta all’altra estremità della rete) dopo al tempo t0 + T; se un attimo prima di tale
istante anche B inizia a trasmettere, la collisione conseguente viene rilevata da B quasi
immediatamente, ma impiega una ulteriore quantità T di tempo per giungere ad A, che la può quindi
rilevare solo un attimo prima dell’istante t0 + 2T.

A Collisione
B
T

La quantità di tempo che si lascia passare tra due tentativi di trasmissione è regolata da un apposito
algoritmo, il binary backoff exponential algorithm:
− dopo una collisione, il tempo si considera discretizzato (slotted) con uno slot time pari a 51,2
microsecondi (corrispondenti al tempo di trasmissione di 512 bit, ossia 64 byte, pari alla lunghezza
minima di un frame senza contare il preambolo ed il delimiter);
− il tempo di attesa prima della prossima ritrasmissione è un multiplo intero dello slot time, e viene
scelto a caso in un intervallo i cui estremi dipendono da quante collisioni sono avvenute;
− dopo n collisioni, il numero r di slot time da lasciar passare è scelto a caso nell’intervallo 0 <= r <=
2k-1, con k = min (n, 10);
− dopo 16 collisioni si rinuncia (inviando un messaggio di errore al livello superiore).

La crescita esponenziale dell’intervallo garantisce una buona adattabilità ad un numero variabile di


stazioni, infatti:
− se il range fosse sempre piccolo, con molte stazioni si avrebbero praticamente sempre collisioni;
− se il range fosse sempre grande, non ci sarebbero quasi mai collisioni ma il ritardo medio causato da
una collisione sarebbe molto elevato.
Architettura degli Elaboratori e delle Reti 101

Struttura del frame


La struttura di un frame Ethernet è il seguente:

No byte 7 1 6 6 2 0-1500 4

Start of Destination Source


Preamble Length Data Checksum
frame address address

I campi del frame hanno le seguenti funzioni:

Preamble 7 byte tutti uguali a 10101010. Producono, a 10 Mbps, un’onda quadra a 10


Mhz per 5,6 microsecondi, che consente al ricevitore di sincronizzare il suo
clock con quello del trasmettitore.
Start of frame un byte delimitatore, uguale a 10101011.
Destination/Source gli indirizzi usati sono sempre a 6 byte, e sono univoci a livello mondiale
address (sono cablati dentro l’interfaccia di rete). E’ possibile specificare un singolo
destinatario, un gruppo di destinatari (multicast) oppure un invio in
broadcast a tutte le stazioni (indirizzo costituito da una sequenza di uni).
Length indica quanti byte ci sono nel campo dati (da 46 a 1500).
Data contiene il payload del livello superiore; minimo 46 byte.
Checksum è un codice CRC per la rilevazione di errore.

Vediamo ora perché esiste un limite minimo di 46 byte per la lunghezza del campo dati e di
conseguenza un limite minimo di 72 byte per la lunghezza di un frame.

Abbiamo già visto che, perché una collisione possa essere certamente rilevata da chi trasmette, deve
passare un tempo non inferiore a due volte il tempo di attraversamento dell’intera rete.

Nel caso di IEEE 802.3, che prevede 2,5 km di lunghezza massima totale e l’interposizione di un
massimo di quattro ripetitori, si ha che il tempo massimo di attraversamento dell’intera rete
moltiplicato per due è pari a 57,6 microsecondi.

E’ essenziale che la collisione venga rilevata durante la trasmissione e non dopo, altrimenti il mittente
dedurrà erroneamente che la sua trasmissione è andata a buon fine.

Dunque, la trasmissione di un frame non deve durare meno di 57,6 microsecondi, che sono il tempo
necessario per trasmettere (a 10 Mbps) proprio 72 byte (e cioé 576 bit, ciascuno dei quali viene
trasmesso in un decimo di microsecondo). Dunque, il frame non può essere costituito da meno di 72
byte, 8 dei quali sono costituiti dal preambolo e dal delimitatore, 12 dagli indirizzi, 2 dal campo
lunghezza, 2 dal campo checksum e per concludere 46 dal campo dati.
Architettura degli Elaboratori e delle Reti 102

Internet Protocol – IP
L’Internet Protocol (IP, RFC 791) è il livello, all’interno dello stack di comunicazione Internet,
incaricato di muovere i pacchetti dalla sorgente fino alla destinazione finale, attraversando tanti sistemi
intermedi (router) della rete di comunicazione quanti è necessario.

Ciò è molto diverso dal compito del livello sottostante (data link), che è di muovere informazioni solo
da un capo all’altro di un singolo canale di comunicazione.

Le funzioni principali di questo livello sono:


− conoscere la topologia della rete;
− scegliere di volta in volta il cammino migliore (routing);
− gestire il flusso dei dati e le congestioni (flow control e congestion control);

IP è un protocollo non connesso e non affidabile che opera come segue:


− in trasmissione
ƒ incapsula i dati provenienti dallo strato di trasporto (TCP/UDP) in pacchetti di
dimensione massima pari a 64 Kbyte
ƒ aggiunge l’intestazione di strato (indirizzi sorgente e destinaz ione , …)
ƒ realizza l’instradamento (routing) dei pacchetti, eventualmente frammentandoli lungo il
viaggio
ƒ invia i dati verso l’opportuna interfaccia di rete

− in ricezione
ƒ verifica la validità dei pacchetti in arrivo
ƒ estrae da questi i dati del livello transport;
ƒ consegna al livello transport i dati nell’ordine in cui sono arrivati (che non è
necessariamente quello in cui sono partiti).

L’unita informativa trattata dallo strato IP viene detta datagram.


Architettura degli Elaboratori e delle Reti 103

Stuttura del pacchetto


La struttura di un pacchetto IP è costituita da un header e da una parte dati.
L’header ha una parte fissa di 20 byte e una parte, opzionale, di lunghezza variabile.

32 bit

Version HLen Type Of Service Total Length


(4 bit) (4 bit) (8 bit) (16 bit)

Identification Flag Fragment Offset


(16 bit) (3 bit) (13 bit)

20 byte
Time To Live Protocol Header Checksum
(8 bit) (8 bit) (16 bit)

Source address
(32 bit)

Destination address
(32 bit)

Options
(32 bit)

Data

I campi dell’header hanno le seguenti funzioni:

Version il numero di versione del protocollo (attualmente è 4)


HLen lunghezza dell’header in parole di 32 bit (minimo 5, massimo 15)
Type Of Service caratterizza affidabilità e velocità richieste
Total Length lunghezza del pacchetto (inclusi dati), massimo 65.535 byte
Identification tutti i frammenti di uno stesso pacchetto hanno lo stesso valore
Flag è un campo di 3 bits usato per la frammentazione: X, DF e MF
X : Non usato e posto a zero
DF : Don’t Fragment; se uguale a 1 non si deve frammentare il pacchetto
MF : More Fragment; se uguale a 1 il pacchetto non è ancora finito
Fragment Offset indice del frammento nel pacchetto
Time To Live indica il numero massimo di salti residui che il datagram può effettuare in
rete. E’ aggiornato da ogni router attraversato
Protocol codice del protocollo di livello transport a cui consegnare i dati (i codici
sono definiti in RFC 1700).
Header Checksum checksum di controllo del solo header
Source/Destination indirizzi di mittente e destinatario
address
Options opzioni
Architettura degli Elaboratori e delle Reti 104

Indirizzamento
Un indirizzo IP è formato da 32 bit e codifica due cose:
− network number, cioé il numero assegnato alla rete IP (detta network) su cui si trova l’elaboratore;
in questo contesto una network è caratterizzata dal fatto di essere costituita da un unico canale di
comunicazione cui sono connessi tutti gli host della network stessa (e quindi, ad esempio, una LAN
oppure una linea punto punto fra due router);
− host number, cioé il numero assegnato all’elaboratore.

La combinazione è unica: non possono esistere nell’intera rete Internet due indirizzi IP uguali.

Si noti che solitamente si ritiene che ogni host sulla rete abbia un singolo indirizzo IP. In realtà gli
indirizzi sono assegnati alle interfacce di rete, quindi:
− se un host ha un’unica interfaccia di rete (come è il caso di un PC in LAN) allora ha un unico
indirizzo IP;
− se un host ha N interfacce di rete (come è il caso di un router connesso ad una LAN) ha N indirizzi.

Gli indirizzi IP sono assegnati da autorità nazionali (NIC, Network Information Center) coordinate a
livello mondiale.

Sono state inizialmente definite 5 classi di indirizzi (classful addressing):

32 bit

8 bit 8 bit 8 bit 8 bit

Classe A 0 Network Host


(0.x.x.x - 127.x.x.x) (7 bit) (24 bit)

Classe B Network Host


(128.x.x.x - 191.x.x.x) 1 0
(14 bit) (16 bit)

Classe C 1 1 0 Network Host


(192.x.x.x - 223.x.x.x) (21 bit) (8 bit)

Classe D 1 1 1 0 Multicast address (indirizzo di gruppo)


(224.x.x.x - 239.x.x.x) (28 bit)

Classe E 1 1 1 1 0 Reserved
(240.x.x.x - 225.x.x.x) (27 bit)
Architettura degli Elaboratori e delle Reti 105

Gli indirizzi sono usualmente espressi nella dotted decimal notation, cioè i valori dei singoli byte sono
espressi in decimale e sono separati da un punto, come nell’indirizzo:

141.192.140.37

In tale notazione, è possibile rappresentare separatamente il network number e l’host number. Per
distinguerli, il primo è seguito da un punto. Ad esempio, nel caso dell’indirizzo IP precedente (che è
relativo ad una network di tipo B), si ha:
− il network number è 141.192. (notare il punto finale);
− l’host number è 140.37 (non c’è il punto finale).

Inoltre, esistono alcuni indirizzi con un significato speciale.

127.0.0.1 loopback (localhost)


255.255.255.255 broadcast locale
Network.255.255.255 broadcast sulla rete Network

Quando si utilizza il loopback, il pacchetto non viene inviato sulla rete ma viene elaborato come se
fosse in arrivo: questo è molto utile, ad esempio, per effettuare localmente dei test su un software di
rete in fase di sviluppo.

Poiché alcune configurazioni binarie sono impegnate per gli indirizzi speciali, possono esistere:
− 126 network di classe A, le quali possono contenere 16 milioni di host ciascuna;
− 16382 network di classe B, con circa 64.000 host ciascuna;
− 2 milioni di network di classe C, con 254 host ciascuna.

Classless Inter-Domain Routing (CIDR)


Il Classless Inter-Domain Routing (CIDR) è un nuovo schema di indirizzamento introdotto nel 1993
per sostituire lo schema classfull secondo il quale tutti gli indirizzi IP appartengono ad una specifica
classe (classe A, B e C).

Questo nuovo schema di indirizzamento consente una migliore gestione degli indirizzi di rete che
diventano sempre più scarsi con il crescere di Internet ed inoltre migliora le prestazioni
dell’instradamento IP grazie ad una più efficiente organizzazione delle tabelle di routing.

Permette, in un indirizzo IP, di definire quale parte indichi la rete e quale gli host.

La notazione usata per esprimere indirizzi CIDR è la seguente:

a.b.c.d/x

dove x è il numero di bit (contati partendo da sinistra) che compongono la parte di indirizzo della rete.
I rimanenti (32-x) indicano gli host.
Architettura degli Elaboratori e delle Reti 106
Diagramma MIPS senza pipeline

MUX

Jump

MemToReg
MemW
PC MemR
IR[31-26] Unità di Branch
controllo RegDst
ALUOp
ALUSrc

RegW
Architettura degli Elaboratori e delle Reti

Shift +
sinistra
MUX
di 2
+ IR[25-0] Shift
sinistra
di 2

+4

IR[25-21]
Nr1
O1
Indirizzo
IR[20-16] Zero
Nr2
RF
Istruzioni
ALU
Nw Risultato Indirizzo
O2

MEMORIA D MUX
MEMORIA
ISTRUZIONI
KAlu
DATI
Dato in Dato in
ingresso uscita
MUX
IR[15-0] IR[5-0] Unità di
Le linee con freccia Estensione controllo
indicano un insieme del segno della ALU
di segnali.
Le linee senza
freccia indicano un
solo segnale. IR[20-16]

MUX
IR[15-11]
107
Diagramma MIPS con pipeline

Jump

MUX

DEC/ALU

PC WB
ALU/MEM

IR[31-26] Unità di
M WB
controllo MEM/WB

ALU M WB
ID/DEC

+
Architettura degli Elaboratori e delle Reti

Shift +
sinistra
MUX
di 2
+4 IR[25-0] Shift
sinistra
di 2

Branch

ALUSrc
RegW

IR[25-21]
Nr1
O1
Indirizzo
IR[20-16]
Zero
Nr2
MemR MemW
RF
Istruzioni
ALU
Nw Risultato Indirizzo
O2

MEMORIA D MUX
MEMORIA
MemToReg

ISTRUZIONI KAlu DATI


Dato in Dato in
ingresso uscita
MUX
IR[15-0] IR[5-0] Unità di
Le linee con freccia Estensione controllo
indicano un insieme del segno della ALU
di segnali.
Le linee senza ALUOp
freccia indicano un
solo segnale. IR[20-16]

MUX
IR[15-11]
108

RegDst
Architettura degli Elaboratori e delle Reti 109

Diagramma MIPS con pipeline per esercizio


Architettura degli Elaboratori e delle Reti 110