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 [email protected] 16 Giugno 2006

mailto:[email protected]


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 N2 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. Il dominio della funzione è la sequenza (stringa) di n bit, mentre il codominio è il valore 0 oppure 1. Una funzione booleana può essere scritta sotto forma di tabella, detta tabella della verità, nel seguente modo:

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

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

1,01,0: →nf


2

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

a b c sottoinsiemi1 1 1 ~ a, b, c 1 0 1 ~ a, c 1 1 0 ~ a, b 0 1 0 ~ b

Le possibili terneii 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 n2 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 )1(2 +× nn

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 1 0 0 0 1 0 1 1 1 0 1 0 0 1

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

222 .

i il simbolo ~ deve essere letto come: associa ii terne o sequenze o stringhe

x1 x2 x3 y 0 0 0 0 0 0 1 1 0 1 0 1 0 1 1 1 1 0 0 0 1 0 1 0 1 1 0 1 1 1 1 1

n22

n + 1

n2

n2


3

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

122 = 4. Queste funzioni sono:

0)(1 =xf Attenzione, qualunque sia il bit in ingresso l’uscita è 0.

1)(2 =xf Attenzione, qualunque sia il bit in ingresso l’uscita è 1. xxf =)(3 Funzione identità.

xxf =)(4 Funzione invertente.

Numero funzioni booleanen22=


4

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

x y m1 m2 m3 m40 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: 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

),,(3 zyxP è il mintermine della combinazione 011. ),,(6 zyxP è il mintermine della combinazione 110.

Un mintermine può essere scritto come: oppure: Attenzione, un mintermine ),,( zyxPi può essere diverso da uno stesso mintermine ma con numero d’ingressi diverso ),( yxPi Esempio: ),,(4 zyxP può essere diverso da ),(4 yxP

12i0),...,,,,( n4321 −≤≤conxxxxxP ni

),...,,,,( 432112 nxxxxxP n −

Numero mintermini = n2


5

14 Marzo 2006

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

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

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

AND – prodotto logico OR – somma logica NOT – negazione x y yx ⋅ x y yx + 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 1f nelle tre variabili zyx ,, .

zyxxzyxf ⋅⋅+= )(),,(1 x y z y yx ⋅ yxx ⋅+ zyxx ⋅⋅+ )( 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


6

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

ba•b a+b a a

a

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. Verifichiamo quest’uguaglianza con la tabella di verità.

x y yx ⋅ x y yx + yx + 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:

yxyx +=⋅ yxyx ⋅=+

L’insieme AND, NOT è funzionalmente completo L’insieme OR, NOT è funzionalmente completo


7

Proprietà degli operatori logici Le proprietà principali di questi operatori logici sono: PROPRIETA’ AND OR Identità xx =⋅1 xx =+ 0 Elemento nullo – Assorbimento 00 =⋅x 11 =+x Idempotenza xxx =⋅ xxx =+ Inverso – Assorbimento 0=⋅ xx 1=+ xx Commutativa xyyx ⋅=⋅ xyyx +=+ Associativa )()( zyxzyx ⋅⋅=⋅⋅ )()( zyxzyx ++=++ PROPRIETA’ AND rispetto OR OR rispetto AND Distributiva zxyxzyx ⋅+⋅=+⋅ )( )()( zxyxzyx +⋅+=⋅+ Assorbimento xyxx =+⋅ )( xyxx =⋅+ DeMorgan (1) yxyx +=⋅ yxyx ⋅=+ DeMorgan (2) yxyx +=⋅ yxyx ⋅=+ PROPRIETA’ Doppia negazione – Idempotenza xx =

Attenzione che nell’algebra booleana al contrario della matematica esiste la proprietà distributiva della somma rispetto al prodotto. Dimostriamo le proprietà di assorbimento:

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

xyxx =+⋅ )( proprietà distributiva del prodotto rispetto alla somma )()( yxxx ⋅+⋅ proprietà di idempotenza xxx =⋅

)( yxx ⋅+ otteniamo la stessa funzione precedentemente dimostrata


8

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

ba NAND 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

b

aa•b

b

aa•b

OR realizzata utilizzando solo porte NAND a

b

a+b

Possiamo dunque affermare che:

L’insieme NAND è funzionalmente completo


9

Dimostriamo, applicando le proprietà dell’algebra booleana, perchè la porta NAND è insieme di connettivi funzionalmente completa. Sapendo che babNANDa ⋅= (1) possiamo dimostrare che: NOT aNANDaa =

aaa ⋅= aaa ⋅= per idempotenza aNANDaaa =⋅ per la definizione (1)

AND )()( bNANDaNANDbNANDaba =⋅

baba ⋅=⋅ per idempotenza

bNANDaba =⋅ per la definizione (1)

)()( bNANDaNANDbNANDabNANDa = per la definizione di NOT utilizzando NAND

OR )()( bNANDbNANDaNANDaba =+

baba +=+ per idempotenza

baba ⋅=+ per la legge di DeMorgan

baba ⋅=⋅ per idempotenza

bNANDaba =⋅ per la definizione di NOT utilizzando NAND

)()( bNANDbNANDaNANDabNANDa = per la definizione di NOT utilizzando NAND


10

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

a

b

S

Z

a

b

Z

S

0

1

Multiplexer

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.

abSSabSbaSbaZ +++= raccolgo aS e Sb )()( aaSbbbaSZ +++= sapendo che 1=+ aa e 1=+ bb

SbaSZ += 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...

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


11

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

a

b

S

Za

b

Z

S

0

1

Demultiplexer

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

zx

x

x_

z

ritardo del NOT spike Anche se teoricamente 0=⋅= xxz


12

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

a

b

S2

Z

a

b Z

S2

11

Multiplexer a 3 vie

S1

c

c

S1

10

01

La funzione booleana del Multiplexer a 3 vie è:

212121 SScSSbSSaZ ⋅⋅+⋅⋅+⋅⋅= 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 ( nSSS ,...,, 21 ). 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: La funzione ⎡ ⎤x (ceiling) restituisce il più piccolo numero intero x≥ La funzione ⎣ ⎦x (floor) restituisce il più grande numero intero x≤

⎡ ⎤ selettoriNumeroNsnNs == ,log2


13

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

S1

S1

S2

Decoder

S2U0

U1

U2

U3

U0

U1

U2

U2

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.

a

S1 S2

Multiplexer a 4 vie con decoder

U0 U1 U2 U2

b

c

d

Z

Decoder


14

Teorema delle Somme di Prodotti Completi (SPC) – 1a Forma Canonica Definiamo Prodotto Completo, il prodotto logico (AND) di tutte le variabili d’ingresso, asserite o negate, che danno come risultato 1. Qualunque funzione booleana può essere espressa come Somma di Prodotti Completi e tale scrittura è unica. L’indice j cicla tra tutte le combinazioni degli ingressi che come risultato in uscita danno 1 (ricordiamo che il numero massimo di nm 2= ). 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à. 1x 2x 2x f # a b S Z 0 0 0 0 0 1 0 0 1 0 2 0 1 0 1 Sba ⋅⋅ 3 0 1 1 0 4 1 0 0 0 5 1 0 1 1 Sba ⋅⋅ 6 1 1 0 1 Sba ⋅⋅ 7 1 1 1 1 Sba ⋅⋅

Possiamo scrivere la funzione in due modi.

1) Funzione dipendente dalle variabili d’ingresso a, b, S SbaSbaSbaSbaSbaf ⋅⋅+⋅⋅+⋅⋅+⋅⋅=),,(

2) Sommatoria di mintermini: SbaSbaSbaSba ⋅⋅+⋅⋅+⋅⋅+⋅⋅=∑ )7,6,5,2(

Riduciamo la funzione trovata applicando i teoremi degli operatori booleani.

SbaSbaSbaSbaZ +++= raccolgo Sa e Sb )()( aaSbbbSaZ +++= sapendo che 1=+ aa e 1=+ bb

SbSaZ +=

∑ ∏= =

±⎟⎟⎠

⎞⎜⎜⎝

⎛=

m

j j

n

iin xxxxf

1 121 ),...,,(


15

Programmable Logic Array – PLA Sfruttando la caratteristica delle funzioni booleane che consente loro di essere rappresentate come somme di mintermini, si sono creati dei componenti, chiamati PLA – Programmable Logic Array, che opportunamente programmati possono realizzare una qualsiasi funzione booleana complessa.

Multiplexer a 4 vie con PLA

a

Z

_a ab

_

b

b

S

SS_

_abS_

ab_

S

abS_

abS

Un componente PLA internamente è composto da una griglia di ingressi asseriti e negati, incrociati con i segnali di ingresso ad una serie di porte AND, la cui uscita confluisce in un’unica porta OR di somma logica. Per utilizzarla basterà “programmare” (saldare) l’intersezione tra i segnali d’ingresso e le porte AND secondo la funzione booleana da implementare. Le PLA hanno tempi di propagazione bassi e sono quindi l’ideale per costruire logiche combinatorie complesse e veloci.

L’esempio riportato in figura si riferisce alla tabella di verità del Multiplexer a 2 vie descritto nelle precedenti pagine:

SbaSbaSbaSbaZ +++=


16

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

a

b

C

R

S+

C=riporto in ingressoR=riporto in uscita

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

cbaCbaCbaCbaS +++=

CbaCbaCbaCbaR +++=

CbaCbaCbaCbaCbaCbaR +++++= per idempotenza xxx +=

)()()( CCbabbCaaaCbR +++++= per assorbimento 1=+ xx baCaCbR ++=

Questo circuito è un sommatore aritmetico da non confondere con quello logico (OR) !!!


17

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

C0 R0

S0

+

a0b0

S1

+

C1 R1

...

...

a1b1

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.

⎡ ⎤ ⎡ ⎤ 764.6100log2 ===S 2. Come realizzare un decoder con un ingresso ? Sappiamo che il numero di uscite è pari a 222 1 ==i Quindi: S1 U0

U1

3. Dimostrare che:

323121321321321321 xxxxxxxxxxxxxxxxxx ++=+++

321321321321321321 xxxxxxxxxxxxxxxxxx +++++ per idempotenza scrivo 2 volte 321 xxx (x+x=x)

3213213213213321 )( xxxxxxxxxxxxxxxx +++++ raccolgo 21xx

32132122313321 )()( xxxxxxxxxxxxxx +++++ raccolgo 31xx

)()()( 113222313321 xxxxxxxxxxxx +++++ raccolgo 32xx

323121 xxxxxx ++ per assorbimento )1( 11 =+ xx 4. Definire una funzione booleana di 4 variabili che vale 1 se e sole se 3 ingressi valgono 1

4324314213214321 ),,,( xxxxxxxxxxxxxxxxf +++=


18

21 Marzo 2006

Multiplexer come porta logica universale Il multiplexer opportunamente configurato può essere utilizzato per realizzare qualsiasi porta logica (AND, OR, NOT). Ricordiamo che la funzione booleana di un Multiplexer a due vie è SbaSZ += AND ( Sb = )

bbbaZ += 0=bb baZ =

OR ( Sa = )

abaaZ += aaa = abaZ += distributiva della somma rispetto al prodotto

)()( aabaZ ++= 1=+ aa baZ += OR

NOT ( 0=a e 1=b )

SSZ 10 += 00 =S e SS =1 SZ = 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 m40 0 0 1 1 1 0 1 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1 0


19

Teorema del Prodotto di Somme Complete (PSC) – 2a Forma Canonica Definiamo Somma Completa, la somma logica (OR) di tutte le variabili d’ingresso, asserite o negate, che danno come risultato 0. Qualunque funzione booleana può essere espressa come Prodotto di Somme Complete e tale scrittura è unica. L’indice j cicla tra tutte le combinazioni degli ingressi che come risultato in uscita danno 0 (ricordiamo che il numero massimo di nm 2= ). 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 XOR ba

b

a b a XOR b 0 0 0 0 1 1 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.

j

m

j

n

iin xxxxf ∏ ∑

= =

± ⎟⎠

⎞⎜⎝

⎛=

1 121 ),...,,(


20

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

a0

b0

a1

b1

a2

b2

y/n

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.


21

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

D0

C

D1 D2 D3

S0 S1 S2 S3

A0 A1 A2 A3 A4 A5

Shifter

Le funzioni booleane di questo circuito sono:

10 DCS ⋅= 201 DCDCS ⋅+⋅= 312 DCDCS ⋅+⋅=

23 DCS ⋅= Analizziamo il circuito supponendo C=1.

00 =S 20011 DDS ⋅+⋅= 30112 DDS ⋅+⋅= 213 DS ⋅= 00 =S 01 DS = 12 DS = 23 DS =

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.


22

Circuito Sommatore Completo o Full Adder con XOR Abbiamo già visto come realizzare un sommatore completo, ora vediamo un esempio di sommatore completo realizzato utilizzando le porte logiche XOR.

a

b

C

R

S


23

Circuito Moltiplicatore Innanzitutto rivediamo la moltiplicazione di due numeri binari, con l’obiettivo di ricordare i passi ed i nomi degli operandi. Proviamo a moltiplicare 100100 ×

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.

Risultato (64 bit)Write

Sommatore (64 bit)

Moltiplicando (64 bit)

Moltiplicatore (32 bit)

Con

trollo

Shift Left

Shift Right+

063

63 0

031

M0 = 0/1

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.


24

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

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

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

Shift Right

Sommatore (32 bit)


Moltiplicatore (32 bit)

Con

trollo

Shift Right+

63 0

031

M0 = 0/1

031

3132Risultato (64 bit)

32

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)


25

Terza versione di Moltiplicatore Vediamo ora un terzo circuito per eseguire le moltiplicazioni fra numeri a 32 bit.

Shift Right

Sommatore (32 bit)


Con

trollo

+

63 0

031

3132

Risultato (64 bit)

32

M0 = 0/1

MoltiplicatoreRisultato Parz.

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)


26

Costo della moltiplicazione utilizzando somme e shift Il sistema classico per moltiplicare due numeri è quello che abbiamo già visto. Supponiamo di volere moltiplicare fm × dove 021 ... dddf nn −−=

La moltiplicazione sopra riportata può essere espressa come: 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 ( 40 ...dd ) 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).

∑−

=

=1

0

n

i

iS

La somma dei primi N numeri interi sappiamo essere uguale a:

nnnS )1( +

= (Gauss)

sostituendo n con n-1 otteniamo:

nnn

nnnS )1()11()1( −

=+−−

=

Notiamo che il costo degli shift è quadratico. Calcoliamo quante somme dobbiamo eseguire. Per conoscere il numero delle somme dobbiamo esprimere la moltiplicazione mn × sotto forma di somme ripetute.

nmmmmn +++=× ...21 Vediamo un esempio mmmm ++=×3 Il numero di addizioni per eseguire una qualsiasi moltiplicazione è uguale a 1−n . Quindi il numero totale di addizioni della nostra formula è:

11...111 1210 −+−++−+−+−= − nddddA nn l’ultimo 1−n è il numero di addizioni eseguite per i prodotti parziali.

m ×

3d 2d 1d 0d = md ×0 + md ×0 md ×1 + )( 11 mdShift × md ×2 + )( 22 mdShift ×

md ×3 + )( 33 mdShift × fm × =

∑−

=

×=×1

0

)(n

iii mdShiftfm


27

1...1... 12101210 −++++=−+−++++= −− nnn ddddnnddddA Notiamo che il costo delle addizioni è lineare. Quale è il caso peggiore ? (quello che implica più somme) E’ quello dove la generica cifra id della generica base B vale 1−B (nel sistema decimale è 9).

1−= Bdi allora

1)1(1)1(...)1()1()1( 1210 −−×=−−++−+−+−= − BnBBBBA nn


28

Numeri Naturali Il sistema numerico che utilizziamo comunemente è chiamato posizionale perchè ogni cifra che compone la stringa dei numeri assume un peso in corrispondenza della posizione che occupa. Un numero γ di n cifre viene rappresentato nel modo seguente: e il numero naturale che rappresenta è uguale all’espressione: 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:

012 104108102 ×+×+× La numerazione naturale in base B di un numero composto da n cifre, rappresenta numeri da 0 a 1−nB 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: 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

01221 ... ccccc nn −−=γ

∑−

=

×=1

0

n

i

ii BcV

1,0,21

0∈×= ∑

−

=

bbVn

i

ii

Min = 0 Max = 12 −n


29

Conversione di base

Da base B a base 10 Per effettuare la conversione da base B a base 10 di un numero naturale si procede in modo diretto, con il metodo polinomiale già definito. Quindi per convertire la stringa 1101 in base 2 nell’equivalente numero in base 10:

)10(0123

)2( 12212021211101 =×+×+×+×=

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 )10(V per la base B 2) il resto costituisce la cifra meno significativo di )(BV 3) il quoziente costituisce il nuovo numero )10(V 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 Quoziente = 6 : Resto = 1 2 Quoziente = 3 : Resto = 0 2 Quoziente = 1 : Resto = 1 2 Quoziente = 0 Resto = 1

Quindi )2()10( 1101026 =

dire

zion

e di

lettu

ra

∑−

=

×=1

0)10(

n

i

ii BcV


30

Numeri Interi – Notazione in complemento a 2 La rappresentazione dei numeri interi nei calcolatori si chiama rappresentazione in complemento a due. Per ottenere il complemento a due di un numero binario V se ne invertono, o negano, i singoli bit infine si somma 1 al valore del numero trovato con questa operazione. Facciamo un esempio con la rappresentazione a 8 bit del numero )10()2( 4500101101 =

7b 6b 5b 4b 3b 2b 1b 0b 0 0 1 0 1 1 0 1 )2(V

1 1 0 1 0 0 1 0 + )2(V 1 + 1

1 1 0 1 0 0 1 1 = )2(V− Quindi )2()10( 1101001145 =− 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 0=−VV

021 ... bbbV nn −−= 1... 021 +=− −− bbbV nn 1 1 1 1 Riporto 1−nb 2−nb ... 1b 0b V 1−nb 2−nb ... 1b 0b + V 1 + 1 1 0 0 0 0 0 0 Risultato

Ricordiamoci che 1=+ ii bb Per ottenere il complemento a due di un numero decimale V con la rappresentazione a n bit, si sottrae a

n2 il numero V e si converte in binario il risultato ottenuto mediante il metodo iterativo. )2(2 )10()2( VbindecV n −=−

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

1101001121145256452 )2(8

)10( =−⇒=−=−=− VV 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.


31

Una numero intero binario di n bit può essere rappresentato mediante: Facciamo un esempio di rappresentazione in decimale del numero binario )2(11010011 in complemento a due .

45121664128212121212122 014672

0

11 −=++++−=×+×+×+×+×−=+−= ∑

−

=

−−

n

i

ii

nn bbV

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.

1,0,222

0

11 ∈+−= ∑

−

=

−− bbbV

n

i

ii

nn Min = 12 −− n

Max = 12 1 −−n


32

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

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

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)

P=Positivo, N=Negativo

nbnnbn UbaUbaO ⋅⋅+⋅⋅= 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)

Tipo na nb nU 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


33

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

1

0+b

Mux a ± b

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 ( 0b ) di un sommatore in complemento a due. In un sommatore a cascata i restanti sommatori ( )... 121 bbb nn −− 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 ?

4202021100 012)2( =×+×+×=

100100100101100 012)10( =×+×+×=

256160160161100 012)16( =×+×+×=

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

13 2 6 1 3 1 1 0 0 1

101113 )10( =


34

30 Marzo 2006

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

012330123 bbbbbbbbb ≡ Verifichiamo quanto affermato dimostrando che i due numeri sono equivalenti

∑=

+−2

0

33 22

i

iibb ≡ ∑

=

+−3

0

43 22

i

iibb

∑=

+−2

0

33 22

i

iibb ≡ ∑

=

++−2

0

32

43 222

i

iibbb esplicito l’ultimo addendo

33 2b− ≡ 3

24

3 22 bb +− elimino le sommatorie che sono uguali da entrambe le parti

Sostituendo 13 =b (ricordiamo che siamo in complemento a due, quindi la cifra più significativa vale 1)

88168 −=+−=− 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


35

Circuiti Sequenziali I Circuiti Sequenziali sono circuiti i cui segnali di uscita dipendono non solo dai segnali di ingresso ma anche dallo stato all’interno del circuito stesso: 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.

statiSingressiISIfO === ,),(


36

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

R

S

Q

Q_

Tabella transazioni di stato R S )(tQ )1( +tQ )1( +tQ

0 0 0 0 1 0 0 1 1 0 0 1 0 1 0 0 1 1 1 0 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 aQ e Q che chiameremo bQ sono le incognite ed R ed S le costanti:

⎪⎩

⎪⎨⎧

+=

+=

ab

ba

QSQ

QRQ

Possiamo risolvere questo sistema di equazioni nei 4 casi possibili per le costanti R ed S: 1) 0;0 == RS

⎪⎩

⎪⎨⎧

=+=

=+=

aab

bba

QQQ

QQQ

0

0

vi sono due possibili soluzioni: 0;11;0 ==== baba QQoppureQQ

2) 1;0 == RS

⎪⎩

⎪⎨⎧

===+=

==+=

100

011

aab

ba

QQQ

QQ

evidentemente la soluzione è unica: 1;0 == ba QQ

3) 0;1 == RS

⎪⎩

⎪⎨⎧

==+=

===+=

011

100

ab

bba

QQ

QQQ


4) 1;1 == RS

⎪⎩

⎪⎨⎧

==+=

==+=

011

011

ab

ba

QQ

QQ


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.


37

Circuito LATCH D – Bistabile Asincrono Trasparente (BAT) Questo circuito è composto da un circuito sequenziale RS con gli ingressi R e S pilotati da un bit di dato D e abilitati da un segnale di controllo C (o clock)

R

S

Q

Q_

FlipFlop RSD

C

FlipFlop D

Tabella transizioni di stato

C )1( +tQ

0 tQ 1 D

Quando C = 0, gli ingressi D e D non hanno significato ( 00 =⋅D e 00 =⋅D ) R = 0, S = 0 il circuito mantiene lo stato precedente Quando C = 1, gli ingressi D e D diventano gli ingressi del circuito RS ( DD =⋅1 e DD =⋅1 )

DSDR == , 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.

D

C

Q'Latch D Latch D

Q

FlipFlop D edge triggered

D'

Master Slave


38

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

CDn-1 Dn-2 D2 D1 D0

Q2 Q1 Q0Qn-2Qn-1 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.

b 0

QDD

C

Flip Flop

b 1

QD

C

Flip Flop

b 2

QD

C

Flip Flop

b 3

QD

C

Flip Flop

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 ,,,, 0102132 bDbbbbbb →→→→


39

Automi a stati finiti nei circuiti sequenziali Il modello concettuale che si utilizza nella progettazione dei circuiti sequenziali si chiama automa a stati finiti. Il comportamento di un automa può essere rappresentato mediante un grafo in cui gli archi rappresentano le transizioni fra stati e i cerchi rappresentano gli stati. Gli stati finali sono evidenziati da cerchi doppi. I simboli sugli archi sono gli input del sistema. Gli automi a stati finiti ci consentono di formalizzare solo una parte del circuito sequenziale, quella dotata di memoria (flip-flop). Infatti, la struttura generale di una macchina sequenziale, è la seguente:

I 0

I 1

I 2

I n-1

D 0

D 1

D 2

D n-1

U 0

U 1

U 2

U n-1

Circ

uito

di

pilo

tagg

io

Circ

uito

di

mem

oriz

zazi

one

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: Descriviamo con questo modello il comportamento di un flip-flop Latch D, partendo dalla tabella delle transizioni di stato.

D C 1+tQ 1+tQ

0 0 tQ tQ D = segnale in ingresso 0 1 0 D C = segnale di controllo (clock) 1 0 tQ tQ 1 1 1 D

statiNumeroNsbistabiliNumeroNbNsNb === ,log2


40

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

0

00

01

10

11

01

10

00

11

start

1

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.

00 01

0

1

0

10

1

0

0

1 1

11

start

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 ( 24log2 = ). 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.


41

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

U1 U2 I D1 D2 0 0 0 0 0

2121211 UUIUUIUUID ⋅⋅+⋅⋅+⋅⋅= 0 0 1 0 1 )( 221211 UUUIUUID +⋅⋅+⋅⋅= 0 1 0 0 0

1211 UIUUID ⋅+⋅⋅= 0 1 1 1 0

1 0 0 0 0 2121212 UUIUUIUUID ⋅⋅+⋅⋅+⋅⋅=

1 0 1 1 1 )( 121212 UUUIUUID +⋅+⋅⋅= 1 1 0 0 0

1212 UIUUID ⋅+⋅⋅= 1 1 1 1 0

I

Latch D

Circuito di pilotaggio

D1

Latch D

U1

D2 U2


42

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

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

0s = stato iniziale ( Ss ⊂0 ) F = un insieme di stati finali ( SF ⊆ ), non stati di terminazione ma di successo f = una funzione di transizione ( SSIf →×: ) 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).

s0 s2

1

0

1

1

s4

start

s1

0

s3

0

s5

0

0

0 00

><= fFsSIA ,,,, 0


43

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

RegisterFile

m

Nr

n

n

m

Nw

D

O

RegW

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

Il numero di registri di un Register File è dipendente dal numero n di segnali di selezione dei registri e più precisamente: Vediamo il funzionamento interno di un Register File con 4 registri da 8 bit. Il circuito di lettura è realizzato nel seguente modo:

8Registro 0

Registro 1

Registro 2

Registro 3

8

8

8

8Mux

O

Nr2

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

Il circuito di scrittura è realizzato nel seguente modo:

Registro 0

Registro 1

Registro 2

Registro 3

8

2

Nw

D

RegW

Decoder

C

C

C

C

D

D

D

D

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

Numero registri n2=


44

Il circuito di lettura del Register File collegato ad una ALU (Arithmetic Logical Unit) è leggermente diverso da quello visto finora.

8Registro 0

Registro 1

Registro 2

Registro 3

8

8

8

8Mux1

O1

Nr1

2

8Mux2

O2

Nr2

28

RALU

Sono presenti due uscite, ognuna delle quali è un operando dell’operazione matematica che la ALU deve svolgere. Nr1 seleziona il registro del primo operando O1, mentre Nr2 selezione il registro del secondo operando O2.


45

I sistemi di memoria: SRAM DRAM Abbiamo già visto come realizzare componenti di memorizzazione, ma per quantità maggiori di memoria è necessario ricorrere alle SRAM (Static Random Access Memory) o alle DRAM (Dynamic Random Access Memory). Una SRAM è concettualmente simile a una matrice di flip-flop. Ogni flip-flop ha il compito di preservare un singolo bit dell’intera memoria. Tipicamente per la realizzazione di un flip-flop si utilizzano 5-6 transistor. Una DRAM è concettualmente simile a una matrice di condensatori (e un transistor). Un condensatore è come un piccolo secchio che può immagazzinare gli elettroni. Per immagazzinare un 1 nella cella di memoria, il secchio viene riempito di elettroni. Per immagazzinare uno 0, viene invece svuotato. Il problema del condensatore è che ha una perdita (figurativo). Nel giro di alcuni millisecondi quindi il secchio da pieno diventa vuoto. Di conseguenza, affinché la memoria dinamica funzioni, la CPU o il controller della memoria devono intervenire e ricaricare tutti i condensatori che contengono elettroni (ovvero il valore 1) prima che essi si scarichino. Per fare questo, il controller legge la memoria e la riscrive, migliaia di volte al secondo. Ricapitolando quindi la RAM statica è più veloce ma costosa, quella dinamica è più economica ma più lenta. Le RAM statiche vengono usate per creare la velocissima cache della CPU mentre la RAM dinamica per gestire la maggior parte della memoria. Tipo di memoria

Tempo di accesso

Numero transistor per singolo bit

SRAM 8-10 ns 5-6 DRAM 80-100 ns 1


46

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

MemoriaCPUBus controllo

Bus indirizzi

Bus dati

BUS

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.


47

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

Program Counter − scrive l’istruzione nel registro Instruction Register − modifica il valore del registro Program Counter in modo che contenga l’indirizzo della prossima

istruzione da eseguire. Formalmente diciamo che: − Il Program Counter (PC) è un registro interno al processore che contiene l’indirizzo di memoria

della prossima istruzione da eseguire. − L’Instruction Register (IR) è un registro interno alla processore che contiene l’ultima istruzione

prelevata dalla memoria.

PC

IR

MEMORIA

Indirizzi

Dati

(Istruzioni)


48

Esempio didattico di CPU a 16 bit Lo scopo che ci prefiggiamo è quello di capire il funzionamento interno di una CPU. Questo dispositivo non esiste nella realtà ma è un esempio didattico di come è realizzato un processore. Le caratteristiche principali della nostra CPU sono: − Le istruzioni hanno lunghezza fissa a 16 bit. − Le istruzioni hanno un formato tale che i 4 bit più significativi (b15-b12) contengono sempre il tipo di

istruzione da eseguire e i restanti bit (b11-b0) indicano su quali registri verrà eseguita l’istruzione o una locazione di memoria.

− Le istruzioni che deve eseguire sono: addizione, sottrazione, AND, OR, caricamento di un registro e scrittura di un registro.

− Le istruzioni matematiche operano esclusivamente sui registri. − Le istruzioni di accesso alla memoria usano la ALU per il calcolo dell’indirizzo − Il Register File dispone di 16 registri (24) 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


49

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

RF

UC

Op

Rs

Rd

Rt

RegW

Nr1

Nr2

NwALU

IR

KAlu

O1

O2D

4

4

4

16

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.


50

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

CLOCK

Rs,Rt,Rd

KAlu

RegW

O1,O2

D

tempo

Tempo di accesso all’Instruction Register

Ritardo introdotto dalla logica di controllo

Tempo di accesso al Register File

Ritardo introdotto dalla ALU

La scrittura avviene sul fronte di discesa

del clock

La scrittura avviene sul fronte di discesa

del clock


51

Circuito per realizzare LOAD e STOREi 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.

RF

UC

Op

Rb

Ofs

Rt

RegW

Nr1

Nr2

Nw

16

16ALU

MEMORIA

IR

KAlu

O1

O2

D

MemW

4

4

4

16

MemR

Dato in scrittura

Indirizzo

Dato in lettura

4 16

Estensione del segno

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


52

Circuito per realizzare tutte le istruzioni Analizzando i circuiti precedenti, si nota che per far “convivere” tutte le istruzioni in un’unica unità servono dei multiplexer, con i relativi segnali di controllo, che consentano di selezionare il percorso desiderato. Nel caso di istruzioni matematiche e LOAD, STORE abbiamo che: − il secondo ingresso della ALU nel caso delle istruzioni matematiche è un registro mentre nelle

istruzioni LOAD, STORE è la parte “offset” dell’indirizzo. − il dato da memorizzare nel Register File può arrivare dalla ALU o dalla memoria (LOAD).

RF

MUX MUX

MUX

UC

Op

RsRb

RdOfs

Rt

RegW

Nr1

Nr2

Nw

16

16ALU

MEMORIA

IR

KAlu

O1

O2

D

RegDst

ALUSrcMemToReg

MemW

4

4

4

4

16

16

MemR

Dato in scrittura

Indirizzo

Dato in lettura1

0

1

0

1

0

16

Estensione del segno


53

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

RegW 121312131415121314151213141512131415 IRIRIRIRIRIRIRIRIRIRIRIRIRIRIRIRIRIR ⋅+⋅⋅⋅+⋅⋅⋅+⋅⋅⋅+⋅⋅⋅= ⋅ RegW 121314151415141514151213 )( IRIRIRIRIRIRIRIRIRIRIRIR ⋅+⋅+⋅+⋅+⋅⋅⋅= ⋅ RegW 12131414151414151213 ))()(( IRIRIRIRIRIRIRIRIRIR ⋅++⋅++⋅⋅⋅= ⋅ RegW 121315151213 )( IRIRIRIRIRIR ⋅++⋅⋅= ⋅ RegW 12131213 IRIRIRIR ⋅+⋅= RegW 12131312 )( IRIRIRIR =+⋅= MemToReg = 1213 IRIR ⋅


54

La ALU Per i nostri scopi didattici analizzeremo una ALU a 16 bit che esegue le operazioni aritmetiche: somma, sottrazione, le operazioni logiche: AND e OR e l’operazione SLT. Abbiamo già realizzato un circuito sommatore in complemento a due e conosciamo le porte logiche AND e OR, quindi siamo in grado di progettare una cella elementare, che ripetuta per quanti sono i bit in uso dalla CPU (nel nostro caso 16), realizzi una ALU completa.

Mux

a

+

b

a ± b

KAlu2

C

R

S

± b

a

KAlu1

KAlu0

00

01

10

11less

Mux

1

0

Nell’ unità ALU0, C = KAlu2 Nelle altre unità ALU15-ALU1, C = bit di Carry dell’unità precedente

I segnali KAlu0 e KAlu1 sono responsabili di selezionare quale risultato la ALU deve emettere. Il segnale di controllo KAlu2 è chiamato anche “inverti b” e serve sia per selezionare il segnale b negato in ingresso al sommatore, sia per impostare ad 1 il bit di carry dell’unità ALU0.

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

1++=− baba L’istruzione SLT (Set Less Than), che genera un 1 quando ba < , è 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 0<−→< baba


55

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

Opcode KAlu2 KAlu1 KAlu0 AND 0 0 0 OR 0 0 1 ADD 0 1 0 SUB 1 1 0 SLT 1 1 1

A [31-0]

B [31-0]

Zero

Risultato

KAlu [2-0]

ALU

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

ALU0

ALU1

ALU15

a0b0

a1b1

a15b15

0

0

KAlu

S0

S1

S15

Zero

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.


56

MAR (Memory Address Register) e MDR (Memory Data Register) La connessione fra il processore (CPU) e il bus non è diretta ma avviene per mezzo di due registri speciali: MAR (Memory Address Register) e MDR (Memory Data Register) Il MAR è il registro che contiene l’indirizzo di una locazione di memoria, dove può risiedere un’istruzione o una qualsiasi informazione. Questo registro rappresenta l’interfaccia hardware verso il bus degli indirizzi. Il MDR è il registro che contiene il dato trasferito verso o dalla memoria. Questo registro rappresenta l’interfaccia hardware verso il bus dei dati. Fase di lettura di un dato da memoria. L’unità di controllo scrive nel registro MAR l’indirizzo e legge dall’MDR il dato. Fase di scrittura un dato in memoria. L’unità di controllo scrive nel registro MAR l’indirizzo e scrive nell’MDR il dato. Le due fasi, lettura e scrittura, non differenziano le istruzioni del programma da altri tipi di informazioni (come previsto dall’architettura di Von Neumann).

RF

MUX

MEMORIA

Indirizzo

MAR

MAR

IR

PC

ALU

MUX

Dato

UC

Bus Dati

Bus Indirizzi


57

RISC vs CISC Bisogna fare un salto indietro nel tempo per capire dove e come sono nate le tecnologie di progettazione dei processori. Iniziamo direttamente dagli anni `70, da quando cioè furono introdotti i primi calcolatori basati su transistor altamente integrati, ed esaminiamo la situazione hardware/sofware dell’epoca: 1) le memorie erano lente, grosse e costose. 2) esistevano i compilatori, ma facevano acqua da tutte le parti: il codice da questi prodotto era poco ottimizzato e spesso talmente inefficiente che conveniva lavorare direttamente in assembler. I progettisti di quel epoca decisero dunque di realizzare processori sempre più “intelligenti” in grado di eseguire istruzioni anche molto complesse. A quei tempi, proprio perchè si scrivevano i programmi in assembler avere un set d’istruzioni molto vasto e articolato era il sogno degli sviluppatori di software che, vuoi per risparmiare memoria, vuoi per semplificare il loro lavoro, desideravano che le istruzioni fossero estremamente complesse. Intel per prima si fece carico di ovviare alle carenze nei set d’istruzioni dei processori rilasciando il primo processore con microcodice. Il microcodice è un programma messo all’interno della CPU che si limita a leggere le istruzioni e svolgerle come un sottoinsieme di istruzioni più semplici. La filosofia di progettazione di questo tipo di processori è nota come CISC (Complex Instruction Set Computer). Alla fine degli anni Settanta e nei primi anni Ottanta la situazione era cambiata: i compilatori erano divenuti molto più efficienti, le memorie meno costose. Si cominciò allora a pensare ad un modo diverso di progettare un processore e le linee guida di progetto possono essere così riassunte: 1) il processore deve eseguire un numero limitato di istruzioni semplici, infatti sulla base di una

analisi statistica dei programmi, si scopre che per il 90% del tempo il processore utilizza sempre un ristretto sottoinsieme di istruzioni.

2) le istruzioni devono avere lunghezza fissa, con pochi operandi e pochi metodi di indirizzamento per rendere la decodifica più veloce.

3) il processore deve avere registri general-purpose in abbondanza 3) le istruzioni devono principalmente usare argomenti contenuti in registri interni al processore e

mettere il risultato dell’esecuzione di una istruzione di nuovo in un registro. 4) il processore deve accedere alla RAM il meno possibile 5) in principio, ogni fase di una certa istruzione può essere eseguita in parallelo con un’altra fase di

un’altra istruzione: è il principio della pipeline La filosofia di progettazione di questo tipo di processori è nota come RISC (Reduced Instruction Set Computer).


58

Caratteristiche CISC Caratteristiche RISC Pochi registri Molti registri Istruzione a lunghezza variabile: - difficile decodifica - incremento del Program Counter variabile

Istruzione a lunghezza fissa: - semplice decodifica - incremento del Program Counter fisso

Modalità di indirizzamento: - memoria-registro - memoria-memoria

Modalità di indirizzamento: - memoria-registro

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.


59

2 Maggio 2006

Linguaggio macchina didattico Lo scopo che ci prefiggiamo è quello di progettare, a scopo didattico, un linguaggio macchina (Assembly) a 32 bit. Le caratteristiche principali del nostro linguaggio sono: − Le istruzioni hanno lunghezza fissa a 32 bit. − Le istruzioni hanno un formato tale che i 6 bit più significativi (b31-b26) contengono sempre il tipo di

istruzione da eseguire, il codice operativo. − I primi due bit del codice operativo (b31-b30) indicano quanti registri sono utilizzati dall’istruzione

stessa. − Il Register File dispone di 32 registri (25) 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)


60

if Rs = Rt then PC = PC + ( OFFSET x 4 ) 11x001 bne Rs Rt OFFSET

Se Rs è diverso da Rt salta alla locazione PC + (OFFSET x 4) if Rs ≠ Rt then PC = PC + ( OFFSET x 4 )

11x010 load Rt (Rs) Carica in Rti la cella di memoria all’indirizzo Rs

Rt Memory[Rs] 11x011 sto (Rs) Rt

Memorizza Rs nella cella di memoria all’indirizzo Rtii 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 TESTiii 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)


61

Salta alla locazione IND x 4 preservando il PC nel registro speciale Return Address RA PC ; PC = 0000 IND x 4

00x010 ret Ripristina il valore del PC precedentemente scritto nel Return Address PC RA

00x011 nop Nessuna operazione

00x100 stop Termina il programma

Le istruzioni di salto incondizionato jump e pcall calcolano l’indirizzo finale di memoria della prossima istruzione da eseguire moltiplicando per 4 il valore di IND. Ogni istruzione è presente in memoria ad un indirizzo che è un multiplo di 4 (allineamento a word) questo perchè le istruzioni, come abbiamo stabilito, hanno un lunghezza fissa di 4 byte (32 bit). Lo stesso ragionamento è applicato alle istruzioni di salto condizionato beq e bne. Inoltre dobbiamo sottolineare che il campo IND è un numero in complemento a 2: se positivo il salto avviene in avanti, se negativo il salto avviene all’indietro.

Esempio di programma Proviamo a scrivere un programma, con il nostro linguaggio macchina, che somma i primi 5 elementi di un vettore memorizzato all’indirizzo VETT. Supponiamo che R2 contenga VETT e che R5 contenga il numero di elementi da sommare, cioè 5. Useremo R3 per accumulare il risultato, R4 per contare le iterazioni e R6 come registro temporaneo. Linguaggio ad alto livello Linguaggio assembly azzera R3 azzera R4 CICLO: R6 = MEM[R2] R3 = R6 + R3 R2 = R2 + 4 R4 = R4 + 1 if R4 ≠ R5 goto CICLO stop

sub R3 R3 R3 sub R4 R4 R4 CICLO: load R6 (R2) add R3 R6 R3 nloc R2 inc R4 bne R4 R5 CICLO 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.


62

4 Maggio 2006

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

OpCode6 bit

Rs5 bit

Rt5 bit

Rd5 bit

Shamt5 bit

Funct6 bit

31 26 25 21 20 16 15 11 10 6 5 0

OpCode6 bit

Rs5 bit

Rt5 bit

Offset16 bit

31 26 25 21 20 16 15 0

OpCode6 bit

Rs5 bit

Rt5 bit

Offset (PC-relative)16 bit

31 26 25 21 20 16 15 0

add Rd, Rs, Rt

lw Rt, Offset (Rs)sw Rt, Offset (Rs)

beq Rs, Rt, Offset


63

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

Funct6 bit

OpCode6 bit

Rs5 bit

Rt5 bit

31 26 25 21 20 16

RF

Unità di controllo

della ALU

ALU

Zero

Risultato

KAlu

Nr1

Nr2

Nw

O1

O2

D

Unità di controllo RegW

Rd5 bit

15 11 5 0

ALUOp

Schema per le istruzioni aritmetiche

Shamt5 bit

10 6

add Rd, Rs, Rt

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)


64

Fasi dell’istruzionei add Rd, Rs, Rt Descrizione PC PC + 4 RegW 1 ALU1 RF[ IR.Rs ] ALU2 RF[ IR.Rt ] Risultato ALU1 + ALU2 RF[ IR.Rd ] Risultato Clock “0” Clock “1”

Il Program Counter è incrementato Attivazione del segnale di controllo RegWrite 1° Operando ALU – Registro Rs 2° Operando ALU – Registro Rt Somma di ALU1 e ALU2 Scrittura del Risultato nel registro Rd sul fronte del segnale di clock

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


65

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

Rd5 bit

Funct6 bit

OpCode6 bit

Rs5 bit

Rt5 bit

Offset16 bit

31 26 25 21 20 16 15 0

lw Rt, Offset (Rs)sw Rt, Offset (Rs)

RF

Unità di controllo

della ALU

ALU

Zero

Risultato

KAlu

Nr1

Nr2

Nw

O1

O2

D

Unità di controllo

RegW

Estensionedel segno

MUX

MUX

MEMORIADATI

Indirizzo

Dato in ingresso

Dato in uscita

MUX

15 11 5 0

ALUOp

MemToReg

RegDst

MemRMemW

ALUSrc

Schema per le istruzioni aritmetiche e di accesso alla memoria

1

0

1

0

0

1

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


66

Fasi dell’istruzione lw Rt, Rs, Offset Descrizione PC PC + 4 MemR 1 ALUSrc 1 RegDst 1 RegW 1 MemToReg 1 ALU1 RF[ IR.Rs ] ALU2 SignExtension( RF[ IR.Offset ] ) Risultato ALU1 + ALU2 MAR Risultato MDR MEM[ MAR ] RF[ IR.Rt ] MDR Clock “0” Clock “1”

Il Program Counter è incrementato Attivazione del segnale di controllo MemRead Attivazione del segnale di controllo ALUSrc Attivazione del segnale di controllo RegDst Attivazione del segnale di controllo RegWrite Attivazione del segnale di controllo MemToReg 1° Operando ALU – Registro Rs 2° Operando ALU – Est. di segno a 32 bit dell’Offset L’indirizzo è dato dalla somma di ALU1 e ALU2 L’indirizzo da leggere è posto sul bus degli indirizzi Lettura del dato all’indirizzo MAR Scrittura del contenuto di MDR nel registro Rt sul fronte del segnale di clock

. sw Rt, Rs, Offset Descrizione PC PC + 4 MemW 1 ALUSrc 1 RegDst 0 RegW 0 MemToReg 0 ALU1 RF[ IR.Rs ] ALU2 SignExtension( RF[ IR.Offset ] ) Risultato ALU1 + ALU2 MAR Risultato MDR RF[ IR.Rt ] MEM[ MAR ] MDR Clock “0” Clock “1”

Il Program Counter è incrementato Attivazione del segnale di controllo MemWrite Attivazione del segnale di controllo ALUSrc Attivazione del segnale di controllo RegDst Attivazione del segnale di controllo RegWrite Attivazione del segnale di controllo MemToReg 1° Operando ALU – Registro Rs 2° Operando ALU – Est. di segno a 32 bit dell’Offset L’indirizzo è dato dalla somma di ALU1 e ALU2 L’indirizzo da leggere è posto sul bus degli indirizzi Scrittura del contenuto di Rt nel registro MDR Scrittura del contenuto di MDR all’indirizzo MAR sul fronte del segnale di clock


67

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

OpCode6 bit

Rs5 bit

Rt5 bit

Offset (PC-relative)16 bit

31 26 25 21 20 16 15 0

beq Rs, Rt, Offset

RF ALU

Zero

Risultato

KAlu

Nr1

Nr2

Nw

O1

O2

D

Unità di controllo

RegW Estensionedel segno

ALUOp

PcWrite

Branch

Unità di controllo

della ALU

Funct6 bit

5 0

Shift sinistra

di 2

+

+4

PC

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


68

Fasi dell’istruzione beq Rs, Rt, Offset Note PC PC + 4 Branch 1 ALU1 RF[ IR.Rs ] ALU2 RF[ IR.Rt ] if (ALU1-ALU2==0) Zero 1 OFFSETi SignExtension( RF[ IR.Offset ] ) OFFSET OFFSET << 2 if (Zero AND Branch) PC PC + 4 + OFFSET else PC PC + 4 Clock “0” Clock “1”

Il Program Counter è incrementato Attivazione del segnale di controllo Branch 1° Operando ALU – Registro Rs 2° Operando ALU – Registro Rt Se la differenza fra ALU1 e ALU è uguale a 0 allora il segnale Zero viene attivato Estensione di segno a 32 bit dell’Offset Moltiplicazione dell’Offset per 4 (shift 2 sinistra) Se Zero e Branch sono entrambi a 1, il PC viene aggiornato con il valore del PC + 4 + OFFSET altrimenti viene aggiornato col il valore del PC + 4 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


69

9 Maggio 2006

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

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

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

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


70

Pipeline Nell’architettura MIPS che stiamo analizzando è possibile pensare ad un’ istruzione come la composizione di in un numero variabile di operazioni eseguite in sequenza. Nello specifico un’istruzione è composta da 5 operazioni dette fasi o stadi. Le fasi di un’istruzione sono: − Fetch: Lettura dell’istruzione dalla memoria e sua memorizzazione nel registro IR; incremento del

PC − Decode: Scomposizione dell’istruzione in campi (codice operativo, registro, costante, ecc) a

seconda del formato e delle modalità di indirizzamento, e generazione degli opportuni segnali di controllo

− Execute: Esecuzione delle operazioni aritmetico-logiche oppure calcolo dell’indirizzo di destinazione di un salto

− Memory access: Accesso in lettura o scrittura alla memoria. − Write back: Salvataggio del risultato prodotto dall’istruzione nel registro destinazione Per convenzione stabiliamo una nomenclatura delle fasi nel modo seguente:

Fetch Decode Execute Memory access Write back IFi DEC ALUii MEM WB

E’ importante ricordare che le istruzioni non sono necessariamente attive in tutte le fasi. Le istruzioni hanno latenzaiii 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


71

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

RF

Unità di controllo

della ALUEstensionedel segno

Shift sinistra

di 2

+4

PC

MUX

MUX

MUX

MUX

ALU

Zero

Risultato

KAlu

ALUOp

Branch

MemToReg

RegDst

MemR MemW

Nr1

Nr2

Nw

O1

O2

IR[25-21]

IR[20-16]

IR[15-0]

IR[20-16]

IR[15-11]

IR[5-0]

D

ALUSrc

RegW

Le linee con freccia indicano un insieme di segnali.Le linee senza freccia indicano un solo segnale.

+

Shift sinistra

di 2

MUX

IR[25-0]

Jump

MEMORIADATI

Indirizzo

Dato in ingresso

Dato in uscita

MEMORIAISTRUZIONI

Indirizzo

Istruzioni

+

IF: Instruction Fetch DEC: Instruction decode/Register file read

ALU: Execute/Address calculation

MEM: Memory access WB: Write back

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.


72

Supponiamo che tutte le fasi abbiano latenza pari a 10ns. Vediamo il flusso e i tempi di esecuzione di tre istruzioni (LOAD) in una architettura senza e con pipeline.

DECIF MEMALU WB DECIF MEMALU WB

1a istruzione 2a istruzione

50ns 50ns

100ns

DECIF MEMALU WB

3a istruzione

50ns

150ns

istru

zion

e

10ns 20ns 30ns 40ns 50ns 60ns 70ns 80ns 90ns 100nstempo 110ns 120ns 130ns 140ns 150ns

DECIF MEMALU WB

DECIF MEMALU WB

DECIF MEMALU WB

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

50ns

60ns

70ns

1a

2a

3a

istru

zion

e

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


73

Uno schema semplificato della pipeline MIPS è il seguente:

ALUDECIF MEM WB

IF/DEC DEC/ALU ALU/MEM 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.


74

RF

Unità di controllo

della ALUEstensionedel segno

+4

PC

MUX

MUX

MUX

MUX

ALUZero

Risultato

KAlu

ALUOp

Branch

Mem

ToR

eg

RegDst

MemR MemW

MEM/WB

ALU/MEM

DEC/ALU

ID/DEC

Nr1

Nr2

Nw

O1

O2

IR[25-21]

IR[20-16]

IR[15-0]

IR[20-16]

IR[15-11]

IR[5-0]

D

Unità di controllo

ALU

WB

M WB

M

ALUSrc

WB

IR[31-26]

RegW

Le linee con freccia indicano un insieme di segnali.Le linee senza freccia indicano un solo segnale.

MEMORIAISTRUZIONI

Indirizzo

Istruzioni

+Shift

sinistra di 2

+

Shift sinistra

di 2

MUX

IR[25-0]

MEMORIADATI

Indirizzo

Dato in ingresso

Dato in uscita

Jump

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.


75

16/23 Maggio 2006

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

Conflitto sui dati Il conflitto sui dati si verifica quando un’istruzione dipende dal risultato di una istruzione che si trova ancora nella pipeline. Si consideri la sequenza di istruzioni:

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

E si esamini la situazione della pipeline al ciclo C2:

ALUDECIF MEMadd R1, R2, R3

sub R4, R1, R5ordi

ne d

i ese

cuzi

one

tempo C0 C1 C2 C3 C4

conflitto

ALUDECIF WB

La fase MEM è presente ma inattiva perchè le istruzioni add e sub non accedono alla memoria

WB

C5

MEM

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.


76

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

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

Istruzioni originali Istruzioni modificate dall’assemblatore add R1, R2, R3

sub R4, R1, R5

add R1, R2, R3 nop nop nop

sub R4, R1, R5

add R1, R2, R3

nop

ordi

ne d

i ese

cuzi

one

tempo

nop

nop

ALUDECIF WB

C0 C1 C2 C3 C4 C5 C6

MEM

sub R4, R1, R5

ALUDECIF WBMEM

ALUDECIF WBMEM

ALUDECIF WBMEM

ALUDECIF WBMEM

C7

Le istruzioni nop non alterano lo stato del sistema, non modificano registri e memoria

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.


77

Riorganizzazione del codice (soluzione software) La soluzione più complessa ma efficiente consiste nella riorganizzazione del codice originale. L’assemblatore cerca di inserire tra le istruzioni correlate (che presentano conflitti) delle istruzioni indipendenti dal risultato delle precedenti istruzioni. Si consideri la sequenza di istruzioni:

add R1, R2, R3 sub R4, R1, R5 and R6, R7, R7 and R6, R7, R7 and R6, R7, R7

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

add R1, R2, R3 and R6, R7, R7 and R6, R7, R7 and R6, R7, R7 sub R4, R1, R5

Il principio è lo stesso adottato introducendo le istruzioni nop ma senza riduzione del throughput (prestazioni).


78

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


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:

add R1, R2, R3

sub R4, R1, R5ordi

ne d

i ese

cuzi

one

tempo

ALUDECIF WB

C0 C1 C2 C3 C4 C5

MEM

ALUDECIF WBMEM

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.


79

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

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

Lo stato della pipeline sarà il seguente:

add R1, R2, R3

sub R4, R1, R5ordi

ne d

i ese

cuzi

one

tempo

Bubble

ALUDECIF WB

C0 C1 C2 C3 C4 C5 C6

MEM

ALUDECIF WBMEM

C7 C8

Bubble Bubble

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


80

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

a) ALU/MEM.IR[rd] = DEC/ALU.IR[rs] b) ALU/MEM.IR[rd] = DEC/ALU.IR[rt] c) MEM/WB.IR[rd] = DEC/ALU.IR[rs] d) MEM/WB.IR[rd] = DEC/ALU.IR[rt]

I conflitti sui dati (load/use) gestibili mediante “stallo” sono rilevati dalle seguenti condizioni:

e) DEC/ALU.IR[rt] = IF/DEC.IR[rs] f) DEC/ALU.IR[rt] = IF/DEC.IR[rt]

Si consideri la sequenza di istruzioni:


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

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

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


81

RF

MEMORIA

MUX

Indirizzo

Dato in ingresso

Dato in uscita

MEM/WBALU/MEMDEC/ALU

Nr1

Nr2

Nw

O1

O2

D

ALUZero

Risultato

MUX

RF

MEMORIA

MUX

Indirizzo

Dato in ingresso

Dato in uscita

MEM/WBALU/MEMDEC/ALU

Nr1

Nr2

Nw

O1

O2

D

ALUZero

Risultato

MUX

MUX

MUX

IF/DEC.IR[rs]

IF/DEC.IR[rt]

IF/DEC.IR[rd]

Unità dipropagazione

con data forward

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


82

Conflitto sugli indirizzi Il conflitto sugli indirizzi si verifica quando un’istruzione di salto viene eseguita (condizionato, incondizionato, chiamate a procedura e ritorni da procedura). Si consideri la sequenza di istruzioni:

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

label_1: and R9, R10, R10

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

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

Stallo (soluzione hardware) La soluzione più semplice a questo problema consiste nel “mettere in stallo” la CPU, per il numero necessario di cicli di clock, nel momento in cui si decodifica un’istruzione di salto. Salti incondizionati: − l’istruzione di salto viene riconosciuta nello stadio DEC. − l’istruzione precedente, nello stadio IF, viene eliminata. − viene calcolato l’indirizzo di salto e aggiornato il Program Counter. Salti condizionati: − l’istruzione di salto viene riconosciuta nello stadio DEC. − l’istruzione precedente, nello stadio IF, viene bloccata. − vengono inserite delle “bolle” fino a quando la condizione di salto non viene verificata (ALU). − se il salto viene effettuato l’istruzione nello stadio IF viene eliminata, calcolato l’indirizzo di salto e

aggiornato il Program Counter. − se il salto non viene effettuato l’istruzione nello stadio IF viene “rilasciata” e continua l’esecuzione

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


83

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

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

L’istruzione add viene inserita nel ciclo di esecuzione della pipeline anche se il salto incondizionato sposta il flusso del programma alla locazione label_1. L’assemblatore inserisce tre nop dopo l’istruzione jump riorganizzando il flusso nella pipeline e producendo il seguente codice:

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

Un assemblatore ottimizzato potrebbe riorganizzare il codice spostando nel delay slot le tre istruzioni che precedono la jump senza dover inserire inutili nop. Questa ottimizzazione produrrebbe il seguente codice:

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

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


84

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

Static branch prediction (soluzione software) L’assemblatore analizza il programma e sulla base di schemi (pattern) noti, stabilisce quali cambiamenti apportare. Si consideri la sequenza di istruzioni (slot delay = 1):

label_1: and R9, R10, R10

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

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

label_1:

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

L’istruzione and che si trovava all’indirizzo di salto verrebbe spostata nel delay slot seguendo lo schema del delayed branch. Gli schemi di predizione statici sono schemi che vengono applicati prima dell’esecuzione stessa del programma ed indipendentemente dal flusso dinamico delle istruzioni. Fra questi possiamo indicare alcuni metodi che, sebbene molto semplici e privi di costi aggiuntivi, rappresentano comunque una efficace alternativa al non avere nessuna sorta di predizione. − Always Taken: si basa sul fatto che è statisticamente più probabile avere un’istruzione di salto che

esegue il salto (taken) rispetto ad un’istruzione che non esegue il salto (not taken). − Backward taken, Forward not taken (BTFN): se l’indirizzo del salto è posto prima di quello del

branch si effettua il salto, altrimenti non si effettua. La base teorica che giustifica questo comportamento è che i salti ad indirizzi anteriori sono, la maggior parte delle volte, appartenenti a dei cicli e spesso devono essere effettuati.


85

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

Branch 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:

Predictbranch

(11)

Predictbranch

one more time(10)

right prediction

wrong prediction

Predictno branchone more time

(01)

Predictno branch

(00)

wrong prediction

right prediction

wrong predictionwrong prediction

right prediction

right prediction

Branch history (1 bit)


86

29 Maggio 2006

Cache La memoria cache è un tipo di memoria piccola e molto veloce, montata all’interno del processore, che mantiene copia dei dati/istruzioni ai quali si accede più frequentemente. Finché la maggior parte degli accessi alla memoria avviene su dati/istruzioni caricati nella cache, la latenza media dell’accesso alla memoria sarà più vicina alla latenza della cache piuttosto che a quella della memoria principale. La memoria cache sfrutta il principio empirico di località spaziale e temporale durante l’esecuzione dei programmi: − località spaziale: quando si fa riferimento a un elemento di memoria, con alta probabilità si farà

entro breve tempo riferimento a elementi vicini (es.: istruzioni in una sequenza; dati organizzati in vettori o matrici e cui si accede sequenzialmente, etc.).

− località temporale: quando si fa riferimento a un elemento di memoria, con alta probabilità si farà di nuovo riferimento allo stesso elemento entro breve tempo (caso tipico: ripetuto accesso alle istruzioni e alle variabili entro un ciclo).

Le dimensioni ridotte della memoria cache (4, 8, 16, 32K) non consentono la memorizzazione di grosse porzioni di memoria centrale. L’unità minima di informazione che può essere trasferita fra le due memoria è chiamata blocco (a volte detto anche linea). Quando il processore vuole leggere o scrivere in una data locazione in memoria principale, inizialmente controlla se il contenuto di questa locazione è caricato in cache. Se il processore trova che la locazione di memoria è in cache, si parla di cache hit (accesso avvenuto con successo), altrimenti di cache miss (fallimento d’accesso). Nel caso di un cache hit, il processore legge o scrive immediatamente il dato sulla linea di cache, nel caso di cache miss, il controllore della cache deve accedere alla memoria di livello inferiore per reperire il blocco che contiene l’informazione richiesta. Il rapporto tra cache hit e accessi totali è chiamato anche hit rate ed è una misura dell’efficacia della cache stessa. Per poter fare spazio a nuovi dati nel caso di un cache miss, la cache generalmente deve eliminare il contenuto di una blocco. L’euristica che utilizza per scegliere quale dato eliminare è chiamata politica di rimpiazzamento. Il problema fondamentale di ogni politica di rimpiazzamento è quello di dover predire il dato della cache che verrà richiesto nel futuro con minor probabilità. Predire il futuro è difficile, soprattutto per le cache hardware che devono sfruttare regole facilmente implementabili in circuiteria, perciò esistono una serie di politiche di rimpiazzamento e nessuna di esse può essere ritenuta perfetta.


87

La struttura della memoria cache del MIPS Lo schema della cache del processore MIPS è il seguente:

Cache

Indirizzo 32 bit

V Tag

=

W0 W1 W2 W3

Tag18 bit

Indice10 bit

Word2 bit

N.u.2 bit

Dec

oder

Index

0

1

2

3

...

N

Demux

Hit=1 / Miss=0

Data

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


88

Calcolare la dimensione di una cache La dimensione, in bit, di una cache si calcola nel modo seguente: 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:

[ ]Kbytebyte

bitSizeCache bit

1818816150528)181281(1024)4log21032()324(12 2

10

≅==++⋅=−−−+⋅+⋅=

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

[ ])log2()(12 2 NPLIndexWSWSNPLSizeCache indexbit −−−+⋅+⋅=


89

1 Giugno 2006

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

Memoria virtuale paginata Nella gestione paginata della memoria virtuale, la memoria RAM è suddivisa in blocchi di dimensione fissa, la stessa con la quale il sistema operativo suddivide in pagine il codice del programma da eseguire. 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. 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. 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

Un blocco di memoria = Una pagina di codice

Indirizzo logico = Page , Displacement

Indirizzo fisico = PMT[P] + D


90

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

CPU MMU RAM

Indirizzo logico

PMT

Page Displacement

Page Blocco YN

0 61850 1

1 28050 1

2 44004 0

.. ... ..

N 96034 0

PMT

Page Blocco YN

0 18508 0

1 1

2 40034 1

.. ... ..

N 60340 0

PMTAR

+

80502

D

1

0

1

..

0

D

1

0

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.


91

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

PageFault

MemoryBlock Size

WorkingSet Size

E’ secondo questo principio che in memoria 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. Quella dimensione è pertanto il working set 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.


92

Ogni tecnica presenta vantaggi e svantaggi: First Fit è la tecnica più veloce perché l’algoritmo di ricerca si ferma alla prima lacuna sufficientemente grande da contenere il programma da eseguire. Non esegue, tuttavia, ottimizzazioni lasciando al caso l’utilizzo della memoria. Best Fit è più lenta di First Fit perché questa tecnica deve confrontare le dimensioni di tutte le lacune presenti e scegliere quella simile a quella del programma da eseguire. Minimizza però lo spreco di memoria lasciando lacune molto piccole. Worst Fit applica l’approccio complementare a First Fit perché questa tecnica deve confrontare le dimensioni di tutte le lacune presenti e scegliere quella più grande rispetto a quella del programma da eseguire. Massimizza lo spreco di memoria lasciando lacune molto grandi, tuttavia aumenta notevolmente la probabilità che la lacuna sia abbastanza grande da contenere un nuovo programma, contrariamente al Best Fit, la cui allocazione tende a generare lacune non più utilizzabili.


93

5 Giugno 2006

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

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

Livello 5 Livello 5

Livello 4 Livello 4

Livello 3 Livello 3

Livello 2 Livello 2

Livello 1 Livello 1

Protocollo di livello 5





Interfaccia liv. 4/5








HOST 1 HOST 2

Mezzo fisico


94

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

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)

OSI Tcp/Ip

Fisico

Data Link

Network

Tranport

Session

Presentation

Application

Host-to-Network

Internet

Transport

Application


95

Livello Application Nell’architettura TCP/IP non ci sono i livelli session e presentation (non furono ritenuti necessari; l’esperienza col modello OSI ha mostrato che questa visione è condivisibile). Sopra il livello transport c’è direttamente il livello application, che contiene tutti i protocolli di alto livello vengono usati dalle applicazioni reali. Alcuni protocolli sono: Telnet: terminale virtuale; FTP (File Transfer Protocol): file transfer; SMTP (Simple Mail Transfer Protocol) e POP (Post Office Protocol): posta elettronica. DNS (Domain Name Service): mapping fra nomi di host e indirizzi IP numerici; NNTP (Network News Transfer Protocol): trasferimento di articoli per i newsgroup; HTTP (HyperText Transfer Protocol): alla base del Word Wide Web. I vari protocolli nell’architettura TCP/IP si collocano come segue:

Telnet Ftp Smtp Http Nntp

Tcp Udp

IP

Vari standard per LAN e WAN

Application

Transport

Internet

Host-to-Network


96

Local Area Network – LAN Le reti locali (Local Area Network, LAN), hanno generalmente le seguenti caratteristiche: − sono possedute da una organizzazione (reti private). − hanno un’estensione che arriva fino a qualche km. − si distendono nell’ambito di un singolo edificio o campus. − sono usatissime per connettere PC o workstation. Sono possibili diverse topologie di rete, le più diffuse sono il bus ed il ring: − topologia bus: in ogni istante solo un elaboratore può trasmettere, gli altri devono astenersi;

è necessario un meccanismo di arbitraggio per risolvere i conflitti quando due o più elaboratori vogliono trasmettere contemporaneamente (Ethernet);

− topologia ring: in un ring ogni bit circumnaviga l’anello in un tempo tipicamente inferiore a quello di trasmissione di un pacchetto; anche qui è necessario un meccanismo di arbitraggio spesso basato sul possesso si un gettone (token) che abilita alla trasmissione (Token Ring);

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

Bus

Ring


97

Mezzi trasmissivi

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

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

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 CladdingRivestimento

Guaina esterna

Conduttore di rame Strato isolante

Calza metallica

Rivestimento esterno


98

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

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

Silicio

Aria

Cladding

Core


99

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

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

+ 0,85 V

- 0,85 V

Durata del bit

Durata del bit

Codificadi Zero

Codifica di Uno

0 V


100

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

riprova a trasmettere. Posto uguale a T il tempo di propagazione del segnale da un capo all’altro della rete, è necessario che trascorra un tempo pari a 2T perché una stazione possa essere sicura di rilevare una collisione. Infatti, se una stazione A posta ad una estremità della rete inizia a trasmettere al tempo t0, il suo segnale arriva a B (posta all’altra estremità della rete) dopo al tempo t0 + T; se un attimo prima di tale istante anche B inizia a trasmettere, la collisione conseguente viene rilevata da B quasi immediatamente, ma impiega una ulteriore quantità T di tempo per giungere ad A, che la può quindi rilevare solo un attimo prima dell’istante t0 + 2T.

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.

T

T

CollisioneA B


101

Struttura del frame La struttura di un frame Ethernet è il seguente:

Preamble Start of frame

Destinationaddress

Sourceaddress Length Data Checksum

7 1 6 6 2 0-1500 4No byte

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 address

gli indirizzi usati sono sempre a 6 byte, e sono univoci a livello mondiale (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.


102

Internet Protocol – IP L’Internet Protocol (IP, RFC 791) è il livello, all’interno dello stack di comunicazione Internet, incaricato di muovere i pacchetti dalla sorgente fino alla destinazione finale, attraversando tanti sistemi intermedi (router) della rete di comunicazione quanti è necessario. Ciò è molto diverso dal compito del livello sottostante (data link), che è di muovere informazioni solo da un capo all’altro di un singolo canale di comunicazione. Le funzioni principali di questo livello sono: − conoscere la topologia della rete; − scegliere di volta in volta il cammino migliore (routing); − gestire il flusso dei dati e le congestioni (flow control e congestion control); IP è un protocollo non connesso e non affidabile che opera come segue: − in trasmissione

incapsula i dati provenienti dallo strato di trasporto (TCP/UDP) in pacchetti di dimensione massima pari a 64 Kbyte

aggiunge l’intestazione di strato (indirizzi sorgente e destinaz ione , …) realizza l’instradamento (routing) dei pacchetti, eventualmente frammentandoli lungo il

viaggio invia i dati verso l’opportuna interfaccia di rete

− in ricezione

verifica la validità dei pacchetti in arrivo estrae da questi i dati del livello transport; consegna al livello transport i dati nell’ordine in cui sono arrivati (che non è

necessariamente quello in cui sono partiti). L’unita informativa trattata dallo strato IP viene detta datagram.


103

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

Version(4 bit)

HLen(4 bit)

Type Of Service(8 bit)

Total Length(16 bit)

Identification(16 bit)

Flag(3 bit)

Fragment Offset(13 bit)

Time To Live(8 bit)

Protocol(8 bit)

Header Checksum(16 bit)

Source address(32 bit)

Destination address(32 bit)

Options(32 bit)

32 bit

Data

20 byte

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 address

indirizzi di mittente e destinatario

Options opzioni


104

Indirizzamento Un indirizzo IP è formato da 32 bit e codifica due cose: − network number, cioé il numero assegnato alla rete IP (detta network) su cui si trova l’elaboratore;

in questo contesto una network è caratterizzata dal fatto di essere costituita da un unico canale di comunicazione cui sono connessi tutti gli host della network stessa (e quindi, ad esempio, una LAN oppure una linea punto punto fra due router);

− host number, cioé il numero assegnato all’elaboratore. La combinazione è unica: non possono esistere nell’intera rete Internet due indirizzi IP uguali. Si noti che solitamente si ritiene che ogni host sulla rete abbia un singolo indirizzo IP. In realtà gli indirizzi sono assegnati alle interfacce di rete, quindi: − se un host ha un’unica interfaccia di rete (come è il caso di un PC in LAN) allora ha un unico

indirizzo IP; − se un host ha N interfacce di rete (come è il caso di un router connesso ad una LAN) ha N indirizzi. Gli indirizzi IP sono assegnati da autorità nazionali (NIC, Network Information Center) coordinate a livello mondiale. Sono state inizialmente definite 5 classi di indirizzi (classful addressing):

0 Network(7 bit)

Host(24 bit)

32 bit

1 0 Network(14 bit)

Host(16 bit)

1 1 0 Network(21 bit)

Host(8 bit)

1 1 1 0

1 1 1 1 0

Multicast address (indirizzo di gruppo)(28 bit)

Reserved(27 bit)

8 bit 8 bit 8 bit 8 bit

Classe A(0.x.x.x - 127.x.x.x)

Classe B(128.x.x.x - 191.x.x.x)

Classe C(192.x.x.x - 223.x.x.x)

Classe D(224.x.x.x - 239.x.x.x)

Classe E(240.x.x.x - 225.x.x.x)


105

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

141.192.140.37

In tale notazione, è possibile rappresentare separatamente il network number e l’host number. Per distinguerli, il primo è seguito da un punto. Ad esempio, nel caso dell’indirizzo IP precedente (che è relativo ad una network di tipo B), si ha: − il network number è 141.192. (notare il punto finale); − l’host number è 140.37 (non c’è il punto finale). Inoltre, esistono alcuni indirizzi con un significato speciale. 127.0.0.1 loopback (localhost) 255.255.255.255 broadcast locale Network.255.255.255 broadcast sulla rete Network

Quando si utilizza il loopback, il pacchetto non viene inviato sulla rete ma viene elaborato come se fosse in arrivo: questo è molto utile, ad esempio, per effettuare localmente dei test su un software di rete in fase di sviluppo. Poiché alcune configurazioni binarie sono impegnate per gli indirizzi speciali, possono esistere: − 126 network di classe A, le quali possono contenere 16 milioni di host ciascuna; − 16382 network di classe B, con circa 64.000 host ciascuna; − 2 milioni di network di classe C, con 254 host ciascuna.

Classless Inter-Domain Routing (CIDR) Il Classless Inter-Domain Routing (CIDR) è un nuovo schema di indirizzamento introdotto nel 1993 per sostituire lo schema classfull secondo il quale tutti gli indirizzi IP appartengono ad una specifica classe (classe A, B e C). Questo nuovo schema di indirizzamento consente una migliore gestione degli indirizzi di rete che diventano sempre più scarsi con il crescere di Internet ed inoltre migliora le prestazioni dell’instradamento IP grazie ad una più efficiente organizzazione delle tabelle di routing. Permette, in un indirizzo IP, di definire quale parte indichi la rete e quale gli host. La notazione usata per esprimere indirizzi CIDR è la seguente:

a.b.c.d/x

dove x è il numero di bit (contati partendo da sinistra) che compongono la parte di indirizzo della rete. I rimanenti (32-x) indicano gli host.


106


107

D

iagr

amm

a M

IPS

senz

a pi

pelin

e

RF

Uni

tà d

i co

ntro

llo

della

ALU

Este

nsio

nede

l seg

no

Shift

si

nist

ra

di 2

+4

PC

MU

X

MU

X

MU

X

MU

X

ALUZe

ro

Ris

ulta

to

KAl

u

ALU

Op

Bra

nch

Mem

ToR

eg

Reg

Dst

Mem

RM

emW

Nr1

Nr2

Nw

O1

O2

IR[2

5-21

]

IR[2

0-16

]

IR[1

5-0]

IR[2

0-16

]

IR[1

5-11

]

IR[5

-0]

D

Uni

tà d

i co

ntro

llo

ALU

Src

IR[3

1-26

]

Reg

W

Le li

nee

con

frecc

ia

indi

cano

un

insi

eme

di s

egna

li.Le

line

e se

nza

frecc

ia in

dica

no u

n so

lo s

egna

le.

+

Shift

si

nist

ra

di 2

MU

X

IR[2

5-0]

Jum

p

ME

MO

RIA

DA

TI

Indi

rizzo

Dat

o in

in

gres

soD

ato

in

usci

ta

ME

MO

RIA

ISTR

UZI

ON

I

Indi

rizzo

Istru

zion

i+


108

Dia

gram

ma

MIP

S co

n pi

pelin

e

RF

Uni

tà d

i co

ntro

llo

della

ALU

Est

ensi

one

del s

egno

+4

PC

MU

X

MU

X

MU

X

MU

X

ALUZe

ro

Ris

ulta

to

KA

lu

ALU

Op

Bra

nch

MemToReg

Reg

Dst

Mem

RM

emW

MEM

/WB

ALU

/ME

M

DE

C/A

LU

ID/D

EC

Nr1

Nr2

Nw

O1

O2

IR[2

5-21

]

IR[2

0-16

]

IR[1

5-0]

IR[2

0-16

]

IR[1

5-11

]

IR[5

-0]

D

Uni

tà d

i co

ntro

llo

ALUWB M

WB M

ALU

Src

WB

IR[3

1-26

]

Reg

W

Le li

nee

con

frecc

ia

indi

cano

un

insi

eme

di s

egna

li.Le

line

e se

nza

frecc

ia in

dica

no u

n so

lo s

egna

le.

ME

MO

RIA

ISTR

UZI

ON

I

Indi

rizzo

Istru

zion

i+S

hift

sini

stra

di

2

+

Shi

ft si

nist

ra

di 2

MU

X

IR[2

5-0]

ME

MO

RIA

DA

TI

Indi

rizzo

Dat

o in

in

gres

soD

ato

in

usci

ta

Jum

p


109

Dia

gram

ma

MIP

S co

n pi

pelin

e pe

r ese

rciz

io


110

Documents

architettura appunti