Architettura Appunti

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
... ...
... ...
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.
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
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.
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 )
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
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
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
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

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
a ⋅ b = a NAND b
NAND
a NAND b = (a NAND a) NAND (b NAND b)
NAND
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...
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
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
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
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
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
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) !!!
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
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
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.
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.
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.
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
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.
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
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)
Terza versione di Moltiplicatore

Vediamo ora un terzo circuito per eseguire le moltiplicazioni fra numeri a 32 bit.
31 0
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)
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.
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
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}
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
2
2
2
Quoziente = 0 Resto = 1
Quindi 26(10 ) = 11010( 2)

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.
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.
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)
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
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
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.
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.
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
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 ,
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
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.
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
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
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
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
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
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.
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)
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
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.
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
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
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
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

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
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.
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
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).
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.
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)
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)
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.
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)
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)
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
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
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
Fasi dell’istruzione
lw Rt, Rs, Offset Descrizione
MemR Å 1 Attivazione del segnale di controllo MemRead
ALUSrc Å 1 Attivazione del segnale di controllo ALUSrc
RegDst Å 1 Attivazione del segnale di controllo RegDst
MemToReg Å 1 Attivazione del segnale di controllo MemToReg
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
MemW Å 1 Attivazione del segnale di controllo MemWrite
ALUSrc Å 1 Attivazione del segnale di controllo ALUSrc
RegDst Å 0 Attivazione del segnale di controllo RegDst
MemToReg Å 0 Attivazione del segnale di controllo MemToReg
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
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)
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
Fasi dell’istruzione
beq Rs, Rt, Offset Note
Branch Å 1 Attivazione del segnale di controllo Branch
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
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.
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
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
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.
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
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
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.
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
di segnali.
Le linee senza ALUOp
freccia indicano un
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.
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.
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

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.
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.
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).
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.
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
add R1, R2, R3 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.
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.
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
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
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]

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.

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.
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.
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).
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).
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.

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
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.
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
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.
La struttura della memoria cache del MIPS

Lo schema della cache del processore MIPS è il seguente:
Indirizzo 32 bit
Tag Indice Word N.u.
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).
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).
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
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.
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.
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.
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

Protocollo
di livello 3
Livello 3 Livello 3

Protocollo
di livello 2
Livello 2 Livello 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).
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)
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

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
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
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).
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).
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.
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.
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.

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
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
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)
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.
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
O2
MEMORIA D MUX
MEMORIA
ISTRUZIONI
KAlu
DATI
Dato in Dato in
ingresso uscita
MUX
di segnali.
Le linee senza
freccia indicano un
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
O2
MEMORIA D MUX
MEMORIA
MemToReg
ISTRUZIONI KAlu DATI

Dato in Dato in
ingresso uscita
MUX
di segnali.
Le linee senza ALUOp
freccia indicano un
MUX
IR[15-11]
108
RegDst
Diagramma MIPS con pipeline per esercizio


Architettura Appunti

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Architettura Appunti

Transféré par

Droits d'auteur :

Formats disponibles

Architettura degli Elaboratori

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

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

Dato un insieme {a, b, c}.

Dato un insieme {a, b}.

Dato un insieme {a}

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

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

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

Un mintermine può essere scritto come:

PIOVE CATTIVE PREVISIONI OMBRELLO ?

Porte logiche AND, OR, NOT

AND – prodotto logico OR – somma logica NOT – negazione

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

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

Verifichiamo quest’uguaglianza con la tabella di verità.

Proprietà degli operatori logici

PROPRIETA’ AND rispetto OR OR rispetto AND

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

Dimostriamo le proprietà di assorbimento:

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

NAND come porta logica universale

Tabella della verità della porta NAND.

Come possiamo dimostrare che la porta NAND da sola basta ?

NOT realizzata utilizzando solo porte NAND

AND realizzata utilizzando solo porte NAND (due versioni)

OR realizzata utilizzando solo porte NAND

Possiamo dunque affermare che:

L’insieme {NAND} è funzionalmente completo

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

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

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

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

Circuito Multiplexer o Selettore

Tabella della verità del circuito Multiplexer.

Riduzione algebrica del circuito Multiplexer.

ritardo del NOT spike

La funzione booleana del Multiplexer a 3 vie è:

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

Tabella della verità del circuito Decoder.

E’ possibile realizzare un Multiplexer con un decoder.

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

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

Possiamo scrivere la funzione in due modi.

Programmable Logic Array – PLA

Circuito Sommatore Completo o Full Adder

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

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

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

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

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

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

Porta logica XOR

Le funzioni booleane di questo circuito sono:

Circuito Sommatore Completo o Full Adder con XOR

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

Prima versione di Moltiplicatore

Terza versione di Moltiplicatore

Sommatore (32 bit)

Costo della moltiplicazione utilizzando somme e shift

La moltiplicazione sopra riportata può essere espressa come:

Calcoliamo quante somme dobbiamo eseguire.

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