Indice - Università di Romaberaldi/LIBRO33.pdf · mediante ruote dentate, a Leibniz con il...

Indice

1 Introduzione 31.1 Architettura di von Neumann . . . . . . . . . . . . . . . . . . . . . . . 41.2 Descrizione di base di un calcolatore . . . . . . . . . . . . . . . . . . . 7

1.2.1 Unita centrale di calcolo, CPU . . . . . . . . . . . . . . . . . . 71.2.2 Bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.2.3 Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.2.4 Ingresso uscita . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.3 Evoluzioni architetturali . . . . . . . . . . . . . . . . . . . . . . . . . . 111.3.1 Gerarchia di memoria . . . . . . . . . . . . . . . . . . . . . . . 121.3.2 Sistema di interconnessione . . . . . . . . . . . . . . . . . . . . 141.3.3 Accesso diretto alla memoria, DMA . . . . . . . . . . . . . . . 151.3.4 Pipeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.4 Microprogrammazione . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.5 Macchine astratte e livelli di programmazione . . . . . . . . . . . . . . 171.6 Domande di ricapitolazione . . . . . . . . . . . . . . . . . . . . . . . . 19

2 Codifica dell’informazione 212.1 Sistema di numerazione posizionale . . . . . . . . . . . . . . . . . . . . 212.2 Sistema di numerazione posizionale in base 2 . . . . . . . . . . . . . . 22

2.2.1 Conversione dalla base 2 alla base 10 . . . . . . . . . . . . . . . 222.2.2 Conversione da base 10 a base 2 . . . . . . . . . . . . . . . . . 232.2.3 Numeri periodici in base 2 . . . . . . . . . . . . . . . . . . . . . 26

2.3 Sistemi di numerazione posizionale in base 8 e 16 . . . . . . . . . . . . 272.3.1 Conversione da base 2 alle basi 8,16 e viceversa . . . . . . . . . 272.3.2 Conversione dalle basi 8,16 alla base 10 . . . . . . . . . . . . . 292.3.3 Conversione da base 10 alle basi 8,16 . . . . . . . . . . . . . . . 292.3.4 Conversione da base 8 a 16 e viceversa . . . . . . . . . . . . . . 292.3.5 Esempi aggiuntivi . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.4 Numeri naturali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.4.1 Codifica naturale . . . . . . . . . . . . . . . . . . . . . . . . . . 312.4.2 Aritmetica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2.5 Numeri relativi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342.5.1 Codifica in modulo e segno . . . . . . . . . . . . . . . . . . . . 342.5.2 Codifica in eccesso M . . . . . . . . . . . . . . . . . . . . . . . 35

1

2 INDICE

2.5.3 Codifica in complemento a 2 . . . . . . . . . . . . . . . . . . . 352.5.4 Aritmetica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.6 Numeri reali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.6.1 Rappresentazione in virgola mobile . . . . . . . . . . . . . . . . 412.6.2 Precisione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412.6.3 Standard IEEE 754 . . . . . . . . . . . . . . . . . . . . . . . . 432.6.4 Aritmetica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

2.7 Codifica ASCII . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3 Funzioni binarie 513.1 Definizione di funzione binaria . . . . . . . . . . . . . . . . . . . . . . 51

3.1.1 Tabella di verita’ . . . . . . . . . . . . . . . . . . . . . . . . . . 513.1.2 Numero di funzioni . . . . . . . . . . . . . . . . . . . . . . . . . 52

3.2 Algebra di Boole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.2.1 Assiomi dell’algebra . . . . . . . . . . . . . . . . . . . . . . . . 543.2.2 Algebra di commutazione . . . . . . . . . . . . . . . . . . . . . 55

3.3 Espressioni booleane . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.3.1 Espressioni equivalenti . . . . . . . . . . . . . . . . . . . . . . . 563.3.2 Mintermini e maxtermini . . . . . . . . . . . . . . . . . . . . . 57

3.4 Espressioni canoniche . . . . . . . . . . . . . . . . . . . . . . . . . . . 593.4.1 Forma canonica Somma di Prodotti (SP) . . . . . . . . . . . . 603.4.2 Forma canonica Prodotto di Somme (PS) . . . . . . . . . . . . 63

3.5 Operatori universali . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643.6 Espressioni minime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3.6.1 Mappe di Karnaugh . . . . . . . . . . . . . . . . . . . . . . . . 653.7 Domande di ricapitolazione . . . . . . . . . . . . . . . . . . . . . . . . 69

4 Reti combinatorie 714.1 Porte logiche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

4.1.1 Collegamento fra porte elementari . . . . . . . . . . . . . . . . 764.1.2 Scala di integrazione . . . . . . . . . . . . . . . . . . . . . . . . 774.1.3 Caratteristiche delle porte . . . . . . . . . . . . . . . . . . . . . 77

4.2 Sintesi di funzioni binarie . . . . . . . . . . . . . . . . . . . . . . . . . 784.2.1 Struttura AND-OR, Somma di Prodotti (SP) . . . . . . . . . . 784.2.2 Struttura NAND-NAND . . . . . . . . . . . . . . . . . . . . . . 784.2.3 Struttura OR-AND, Prodotto di Somme (PS) . . . . . . . . . . 794.2.4 Struttura NOR-NOR . . . . . . . . . . . . . . . . . . . . . . . . 794.2.5 Sintesi ottima a due livelli . . . . . . . . . . . . . . . . . . . . . 80

4.3 Circuiti aritmetici binari . . . . . . . . . . . . . . . . . . . . . . . . . . 804.3.1 Half adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 804.3.2 Full Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 814.3.3 Ripple Carry Adder (RCA) . . . . . . . . . . . . . . . . . . . . 824.3.4 Carry Look-ahead Adder (CLA) . . . . . . . . . . . . . . . . . 834.3.5 Addizionatori/Sottrattori . . . . . . . . . . . . . . . . . . . . . 85

4.4 Altri moduli combinatori di base . . . . . . . . . . . . . . . . . . . . . 854.4.1 Codificatori/ Decodificatori . . . . . . . . . . . . . . . . . . . . 85

INDICE 3

4.4.2 Multiplexer/Demultipler . . . . . . . . . . . . . . . . . . . . . . 87

4.5 Memoria ROM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

4.5.1 Varianti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

4.6 Unita’ Aritmetico Logica (ALU) . . . . . . . . . . . . . . . . . . . . . 93

4.6.1 Una ALU ad un bit . . . . . . . . . . . . . . . . . . . . . . . . 94

4.6.2 Una ALU a 4 bit . . . . . . . . . . . . . . . . . . . . . . . . . . 95

4.7 Domande di ricapitolazione . . . . . . . . . . . . . . . . . . . . . . . . 95

5 Reti sequenziali 97

5.1 Modello generale di rete sequenziale . . . . . . . . . . . . . . . . . . . 97

5.1.1 Definizione di automa . . . . . . . . . . . . . . . . . . . . . . . 98

5.2 Elementi di memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

5.2.1 Latch SR (Set Reset) . . . . . . . . . . . . . . . . . . . . . . . 101

5.2.2 Il Latch D con abilitazione a livello . . . . . . . . . . . . . . . . 104

5.2.3 Flip flop D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

5.3 Registri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

5.3.1 Registri a caricamento parallelo . . . . . . . . . . . . . . . . . . 106

5.3.2 Registri a caricamento parallelo con ingressi di controllo . . . . 107

5.3.3 Registri a scorrimento (shift register) . . . . . . . . . . . . . . . 109

5.4 Realizzazione di un automa mediante rete LLC . . . . . . . . . . . . . 109

5.5 Memorie RAM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

6 Microarchitettura 117

6.1 Modello funzionale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

6.2 Operazioni elementari . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

6.2.1 Trasferimento dati fra due registri . . . . . . . . . . . . . . . . 119

6.2.2 Impiego di una ALU . . . . . . . . . . . . . . . . . . . . . . . . 121

6.3 Sequenza di operazioni elementari . . . . . . . . . . . . . . . . . . . . 122

6.3.1 Impiego della ALU mediante un banco registri . . . . . . . . . 123

6.4 Operazioni elementari condizionate . . . . . . . . . . . . . . . . . . . . 124

6.5 L’unita’ di controllo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

6.5.1 Unita’ di controllo cablata . . . . . . . . . . . . . . . . . . . . . 125

6.5.2 Unita’ di controllo microprogrammata . . . . . . . . . . . . . . 125

6.6 Esempio: calcolo del prodotto fra naturali . . . . . . . . . . . . . . . . 128

6.7 Microarchitettura di una CPU ad accumulatore . . . . . . . . . . . . . 134

6.7.1 La CPU come un interprete . . . . . . . . . . . . . . . . . . . . 134

6.7.2 Il set istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

6.7.3 Unita’ operativa . . . . . . . . . . . . . . . . . . . . . . . . . . 136

6.7.4 Unita’ di controllo . . . . . . . . . . . . . . . . . . . . . . . . . 137

6.7.5 Il ciclo istruzione . . . . . . . . . . . . . . . . . . . . . . . . . . 138

6.7.6 Unita’ di controllo microprogrammata . . . . . . . . . . . . . . 141

6.7.7 Discussione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

6.7.8 Logica cablata . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

6.8 Microarchitettura di un processore didattico, il PD32 . . . . . . . . . . 146

4 INDICE

7 Esempi di microarchitetture 1497.1 CPU con registro accumulatore . . . . . . . . . . . . . . . . . . . . . . 149

7.1.1 Caratteristiche esterne . . . . . . . . . . . . . . . . . . . . . . . 1507.1.2 Caratteristiche interne, la microarchitettura . . . . . . . . . . . 1527.1.3 Simulazione in CPU Sim . . . . . . . . . . . . . . . . . . . . . . 1557.1.4 Esempi di programmi assembly . . . . . . . . . . . . . . . . . . 1567.1.5 Osservazioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

7.2 WB2 una cpu registro-registro a due indirizzi . . . . . . . . . . . . . . 1597.2.1 Caratteristiche esterne . . . . . . . . . . . . . . . . . . . . . . . 1607.2.2 Caratteristiche interne . . . . . . . . . . . . . . . . . . . . . . . 1607.2.3 Microarchitettura . . . . . . . . . . . . . . . . . . . . . . . . . . 1607.2.4 Costruzione in CPU Sim . . . . . . . . . . . . . . . . . . . . . . 1617.2.5 Esempi di programmi . . . . . . . . . . . . . . . . . . . . . . . 162

8 Architettura livello istruzioni (ISA) 1678.1 Il set istruzioni . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

8.1.1 Trasferimento dati . . . . . . . . . . . . . . . . . . . . . . . . . 1688.1.2 Istruzioni logico aritmetiche . . . . . . . . . . . . . . . . . . . . 1688.1.3 Controllo del flusso di esecuzione . . . . . . . . . . . . . . . . . 1708.1.4 Istruzioni ingresso uscita . . . . . . . . . . . . . . . . . . . . . . 172

8.2 Una ISA didattica, il PD32 . . . . . . . . . . . . . . . . . . . . . . . . 1738.2.1 Caratteristiche . . . . . . . . . . . . . . . . . . . . . . . . . . . 1738.2.2 Linguaggio Assembly . . . . . . . . . . . . . . . . . . . . . . . . 174

8.3 Esempi di programmi assembly PD32 . . . . . . . . . . . . . . . . . . 1758.3.1 Modi di indirizzamento . . . . . . . . . . . . . . . . . . . . . . 1768.3.2 Istruzioni aritmetiche . . . . . . . . . . . . . . . . . . . . . . . 1798.3.3 Costrutti di controllo . . . . . . . . . . . . . . . . . . . . . . . . 1798.3.4 La traduzione di un programma . . . . . . . . . . . . . . . . . 1828.3.5 Subroutine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1848.3.6 Altri esempi di programmi per il PD32 . . . . . . . . . . . . . . 190

8.4 Esempi di ISA reali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1918.4.1 Memoria logica . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

9 Laboratori 2019.1 Breve introduzione al simulatore DSCH . . . . . . . . . . . . . . . . . 2019.2 Porte logiche elementari . . . . . . . . . . . . . . . . . . . . . . . . . . 203

9.2.1 Inverter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2039.2.2 Altre porte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

9.3 Reti combinatorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2059.3.1 Full Adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2059.3.2 Ripple Carry Adder . . . . . . . . . . . . . . . . . . . . . . . . 2069.3.3 ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

9.4 Reti sequenziali . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2089.4.1 Latch con porte NOR . . . . . . . . . . . . . . . . . . . . . . . 2089.4.2 Registro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2089.4.3 Contatore UP-DOWN . . . . . . . . . . . . . . . . . . . . . . . 209

INDICE 5

9.5 Microarchitettura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2109.5.1 Trasferimento fra due registri . . . . . . . . . . . . . . . . . . . 210

9.6 Introduzione al Simulatore CPU-SIM . . . . . . . . . . . . . . . . . . . 212

6 INDICE

Capitolo 1

Introduzione

Un calcolatore e un sistema elettronico digitale in grado di essere programmato. E’un sistema in quanto composto da piu parti interagenti fra loro, elettronico digita-le, poiche le parti sono realizzate mediante la tecnologia digitale (circuiti elettroniciche lavorano su grandezze binarie, o bit, i cui valori possono essere 0 oppure 1) pro-grammabile poiche il suo comportamento e determinato da un programma, ossia uninsieme di istruzioni che indicano di volta in volta cosa il sistema debba fare.

La motivazione che ha condotto alla realizzazione di questi sistemi e stato l’inte-resse, ma spesso la necessita, di disporre di un aiuto per eseguire i calcoli, soprattuttose lunghi e noiosi, necessari per risolvere un problema, come ad esempio sommare unalunga sequenza di valori. La soluzione del problema viene prima espressa medianteun algoritmo, poi codificata mediante un programma, e poi eseguita dal calcolatore,che la applica ad un particolare insieme di valori (input) per produrre la soluzione(output), vedi Figura 6.21.

Calcolatore

Programma

Input Output

Figura 1.1: Ruolo del calcolatore come esecutore di programmi.

Senza disporre di un supporto per il calcolo, molti algoritmi avrebbero un valoresolamente teorico. Avere a disposizione la ricetta per cucinare una pietanza, ma nonavere nessun cuoco a disposizione in grado di esegurla in tempo utile avrebbe pocovalore.

7

8 CAPITOLO 1. INTRODUZIONE

Col passare del tempo le applicazioni del calcolatore sono diventate numerose eper molti versi inaspettate, facendolo diventare non solo un mezzo per la risoluzione diproblemi “difficili”, ma piuttosto un oggetto interattivo e di comunicazione. Sebbenelo scopo dei programmi eseguiti sia divenuto piu generale, la natura del calcolatore erimasta invariata. Un calcolatore e un esecutore (molto veloce) di programmi.

In questo capitolo studieremo il modello fondamentale di realizzazione di un cal-colatore e, per grosse linee, le sue principali varianti realizzative. Questa discussioneintroduttiva ci permettera di acquisire le principali idee ed il lessico di base utili poiper il approfondire il nostro studio.

1.1 Architettura di von Neumann

Gli attuali calcolatori elettronici sono realizzati seguendo un modello architetturaledovuto al matematico ungherese von Neumann, che per primo lo descrisse in Fir-st Draft of Report on the EDVAC, un documento scritto nel 1945 e relativo allacostruzione del calcolatore EDVAC.

Prima di descrivere questa architettura e interessante ricostruire, per grosse li-nee, la storia delle due principali idee che ne costituiscono il fondamento, quella diprogramma e di memoria.

Programmazione e memorizzazione L’idea di costruire una macchina per ese-guire calcoli e molto antica e risale all’invenzione dell’abaco, descritto in un librocinese del 190 a.c., un telaio di legno, con piu fili orizzontali che guidano i movimentidi sfere anch’esse di legno, grazie al cui movimento si compiono le quattro operazioniaritmetiche. L’abaco era manuale, non c’era ne idea di programma ne di memoria.

I primi tentativi di realizzazione di un vero automatismo per il calcolo sono le-gati invece a molti nomi illustri del passato, da Blaise Pascal con la realizzazionedella Pascalina (1645), in grado di eseguire le operazioni di addizione e sottrazionemediante ruote dentate, a Leibniz con il contatore a gradini (1671), che permettevadi eseguire anche la moltiplicazione e la divisione mediante tamburi rotanti, fino aCharles Babbage con la sua difference engine ma soprattutto con l’analytical engine,macchina che, per la concezione della sua architettura ed il modo di funzionamentopuo essere considerata l’antesignana del moderni calcolatori.

L’idea innovativa di Babbage era una macchina, il cui progetto fu avviato nel1834, in grado di eseguire qualunque tipo di calcolo. Questa capacita sarebbe statadovuta a due fattori (la macchina non fu mai realizzata). Da un lato la macchinadoveva modificare il proprio assetto durante il calcolo, dall’altro memorizzare i risul-tati prodotti da una fase del calcolo in modo che essi potessero essere impiegati comepartenza per la fase successiva. Questa macchina doveva quindi poter essere modifi-cata, o programmata, nonche in grado di organizzare il calcolo come sequenza di fasi,mediante una funzione di memorizzazione, un’assoluta novita rispetto alle macchineprecedenti. L’organo esecutore della macchina, Figura 1.2, era chiamato mill (mu-lino) e corrisponde al moderno processore. Il controllo (control) era in sostanza ilprogramma, mentre la memoria venne chiamata il magazzino (store).

1.1. ARCHITETTURA DI VON NEUMANN 9

MILLINPUT OUTPUT

CONTROL

STORE

Figura 1.2: Schema della macchina analitica di Babbage.

Dobbiamo ricordare che la tecnologia di quel tempo era meccanica, e quindi lamodifica del comportamento di una macchina poteva sembrare molto ardua. Tutta-via esisteva gia un brillante esempio dovuto a Joseph Marie Jacquard che, intornoall’inizio del 1800 invento un telaio “programmabile”, che portera poi il suo nome.Il telaio Jacquard eseguiva tessiture molto articolate leggendo una scheda metalli-ca perforata, i cui fori guidavano il telaio nell’incrociare i fili1. La scheda perforataera (conteneva) cioe il programma che controllava il telaio indicando quali azioni in-traprendere. L’effetto dell’esecuzione di questo programma era la produzione di untessuto ricamato, appunto codificato dal disegno che appariva sulla scheda. Lo stessotelaio poteva quindi creare disegni differenti a seconda del tipo di scheda usata.

Una cosa importante da sottolineare e che nell’architettura di Babbage, cosi co-me nelle macchine di calcolo costruite anche molti anni dopo, la programmazioneavveniva dall’esterno. La novita principale nell’idea di von Neumann fu quella di me-morizzare nella macchina non solo dati (intermedi) di calcolo, ma anche il programma,aumentando cosi la flessibilita del sistema.

Descrizione dell’architettura L’architettura di von Neumann si basa su un’u-nica memoria per contenere sia il programma da eseguire (sotto forma di sequenzadi istruzioni poste adiacenti nella memoria) sia i dati su cui il programma agisce.L’architettura prevede una unita di controllo che coordina tutte le attivita necessarieaffinche il programma venga eseguito, un’unita di calcolo che esegue operazioni edinfine unita di ingresso/uscita, per l’interazione con l’esterno. Per eseguire i calco-

1L’idea delle schede perforate fu ripresa da Herman Hollerith, professore al MIT, che nel 1882 laadatto alle macchine per il calcolo, usando carta anziche metallo; le schede perforate sono poi divenute- e rimaste per molto tempo - un supporto fondamentale per la memorizzazione di informazioni. Illinguaggio di programmazione FORTRAN (FORmula TRANslator) poneva, fino all’estensione delFortran 90, il vincolo di scrivere istruzioni lunghe non piu di 80 caratteri (compresi i commenti),valore pari proprio alla dimensione massima di una scheda perforata.


li, l’unita di calcolo usava un registro interno, detto accumulatore (Figure 1.3). Unregistro e un dispositivo per memorizzare un gruppo di bit2.

Unità

di calcolo

Unità

di controllo

Memoria Unità I/O

accumulatore

Figura 1.3: Architettura di von Neumann.

Il fatto di impiegare un’unica memoria per dati e programma era annoverato fra ivantaggi dell’architettura. Un programma puo in questo modo automodificarsi, ossiascrivere nuove istruzioni oppure modificare quelle gia in memoria.

Puo risultare ironico il fatto che, sebbene la tecnica dei programmi automodificantisia ormai abbandonata, gli attuali calcolatori continuino ad essere costruiti seguendoquesta architettura, ma facendosi carico di mettere in atto meccanismi di protezioneper evitare interferenze accidentali fra dati e istruzioni, separando quindi la memoriain due parti logiche, quella predisposta per memorizzare dati e quella invece dedicataai programmi, opzione prevista esplicitamente da un’altra architettura, “rivale’ diquella di von Neumann, nota come architettura Harvard.

Per comprendere il funzionamento dell’ architettura di von Neumann e importan-te sottolineare il fatto che essa definisce un sistema a tempo e spazio discreti. Pertempo discreto si intende esprimere il fatto che ogni azione compiuta nell’architetturaviene portata a compimento entro un intervallo di tempo prefissato. Per esemplifica-re, durante un intervallo di tempo si puo decidere di copiare un dato dalla memoriaall’accumulatore, in un altro di far eseguire una somma etc. La demarcazione dell’i-nizio di un nuovo intervallo e unica nel sistema ed e stabilita da un segnale periodico(clock). Questi intervalli possono essere quindi numerati, per cui il modello del tempoe discreto.

Spazio discreto vuol dire invece che la capacita di memorizzazione e finita e cheogni luogo, o locazione di memoria, e individuata anch’esso da un numero o indirizzodi memoria.

2Al tempo di von Neumann la tecnologia sfruttata per la costruzione delle macchine di calcolonon era piu quella meccanica, bensi quella delle valvole termoioniche. E questo aveva consentito dicostruire dispositivi per la memorizzazione di gruppi di bit.

1.2. DESCRIZIONE DI BASE DI UN CALCOLATORE 11

Consideriamo, a titolo di esempio, come si potrebbe programmare un calcolatorealla von Neumann per addizionare due numeri, contenuti nelle locazioni di memoriax ed y, e memorizzare la somma nella locazione con indirizzo z. Sono necessarie treistruzioni. La prima copia il contenuto di x nell’accumulatore

LOAD x

la seconda, somma il contenuto dell’accumulatore con y

ADD y

mentre l’ultima copia il contenuto dell’accumulatore (il risultato) in z

STORE z

Poiche devono essere poste in memoria, queste 3 istruzioni devono essere tradotte(codificate) in gruppi di bit. Ogni gruppo deve individuare univocamente un’istruzio-ne. Il modo piu ovvio per far questo e usare un numero differente per istruzione (codiceoperativo) seguito dall’indirizzo in memoria delle variabili. Ammettiamo che gli in-dirizzi in memoria x, y, z siano, rispettivamente 100,101,111 e che i codici operatividelle istruzioni LOAD,ADD,STORE siano rispettivamente 00,01,10.

Nella memoria il programma diventa

00100

01101

10111

Dopo questo semplice esempio, vediamo adesso come l’architettura di von Neumanne stata recepita dai calcolatori attuali.

1.2 Descrizione di base di un calcolatore

La realizzazione classica dell’architettura di von Neuman prevede tre blocchi funzio-nali fondamentali. L’unita centrale di calcolo (Central Processing Unit, CPU), laMemoria e vari interfacce per l’ ingresso o uscita (I/O) di dati da/verso Periferi-che esterne. Tali elementi sono connessi mediante un bus, un insieme di conduttorisuddivisi in tre gruppi logici dedicati a trasferire indirizzi, segnali di controllo e dati,secondo il modello strutturale di Figura 1.4.

1.2.1 Unita centrale di calcolo, CPU

La CPU e realizzata mediante un circuito elettronico integrato detto microprocesso-re. Essa e in grado di eseguire un certo numero limitato di istruzioni, dette istruzionimacchina, indicato con il termine set istruzioni. All’interno di ogni CPU si distinguo-no tre parti fondamentali, l’Unita Aritmetico Logica (ALU), un insieme di registri,ed una Unita di controllo.

ALU. Il compito della ALU e eseguire operazioni aritmetiche (addizione, sottrazio-ne, etc.) e logiche (and,or,etc.) sui dati contenuti nei registri.


Memoria

Interfaccia

ingresso

Interfaccia

uscita

Bus di controllo

Bus dati

Bus indirizzi

Periferica

di input

Periferica

di output

ALU Registri

U. Controllo

CPU

Figura 1.4: Realizzazione classica dell’architettura di von Neumann.

Registri. Contengono i dati delle operazioni effettuate dalla ALU (registri generali)o informazioni specifiche (registri speciali), dedicate a specifiche funzioni, come adesempio il valore dell’indirizzo di memoria della prossima istruzione da eseguire. Altriancora sono invisibili al programmatore nel senso che nessuna istruzione li riferisceesplicitamente.

Unita di controllo. L’unita di controllo ha il compito di processare le istruzioniche preleva dalla memoria. Cio avviene mediante la generazione di un insieme dicomandi che essa invia all’interno della CPU (verso i registri e la ALU) e/o all’esterno,mediante il bus controllo. In generale, i comandi da inviare possono essere condizionatidai valori nei registri.

1.2.2 Bus

I bus consentono alla CPU di inviare e ricevere informazioni dalle altre unita fun-zionali del calcolatore. I bus sono classificati in base al tipo di informazione chetrasportano.

Bus indirizzi. Trasferisce gli indirizzi generati dalla CPU alla memoria o ai di-spositivi di I/O. Il bus indirizzi e quindi monodirezionale. La CPU invia sul bus unindirizzo col quale seleziona una locazione di memoria o un’interfaccia di un dispositi-vo esterno. La dimensione del bus, o ampiezza, specifica il numero di linee fisiche checompongono il bus e determina lo spazio di memoria cui il processore puo accedere.

Bus dati. E’ un bus bidirezionale che trasferisce dati dentro il processore o al suoesterno. L’ampiezza del bus determina quanti bit e possibile trasferire contempora-

1.2. DESCRIZIONE DI BASE DI UN CALCOLATORE 13

neamente. Nei bus di tipo sincrono un altro parametro importante e la frequenza delbus, che determina il ritmo con cui possono essere inviati i dati.

Bus controllo. Questo bus serve al processore per coordinare l’interazione con lealtre unita. Ad esempio, il bus controllo trasferisce i segnali che indicano alla memoriaquando memorizzare il dato presente sul bus dati. Le unita usano il bus per informareil processore circa il verificarsi di particolari eventi (ad esempio, un dispositivo diingresso la pressione di un tasto, la memoria il completamento di un’operazione dilettura).

1.2.3 Memoria

La memoria serve per conservare dati ed istruzioni, espressi mediante una rappresen-tazione binaria composta da gruppi di bit. E’ possibile inserire e recuperare dallamemoria k bit contemporaneamente. Un gruppo di k bit si chiama parola di memo-ria. Ogni memoria ha la capacita di conservare fino ad n parole distinte; quindi, lamemoria puo essere immaginata come un contenitore di n parole da k bit ciascuna.Ogni parola e conservata in un luogo, o locazione, individuato mediante un indirizzoche varia da 0 ad n− 1.

La tecnologia di realizzazione delle memorie subisce di continuo variazioni checonsentono di ottenere miglioramenti in termini sia di capacita che velocita. Per inostri scopi ci limiteremo a dire - per il momento - che le memorie sono disponibili informa di chip (circuiti integrati) dotati di linee di controllo - lettura (RD), scrittura(RW ) selezione del chip (CS) - per specificare l’indirizzo (address lines, A), e perinviare o ricevere dati (data lines, D).

Per esempio la Figura 1.5 mostra un chip con 6 linee di indirizzo e 4 linee per idati. Questo vuol dire che la memoria e composta da n = 26 = 64 parole da k = 4bit ciascuna. In modo succinto diremo che la forma di questo chip e 64× 4.

A0A1A2A3A4A5

D0D1D2D3

WRRDCS

Controllo

Indirizzo

Dati

Figura 1.5: Un esempio di chip di memoria.

La Figura 1.6.(a) riporta il principio di funzionamento di un’operazione di lettura,riferita alla locazione 3 in una memoria 8 × 4 (per semplicita gli indirizzi non sonostati numerati in binario). In ingresso al chip sono forniti l’indirizzo ed il tipo dioperazione (RD = 1).


Dopo un tempo caratteristico dipendente dalla tecnologia, detto tempo d’accesso,e possibile osservare sulle linee dati il contenuto della locazione, nel nostro esempiola parola 1101. La Figura 1.6.(b) mostra invece l’operazione di scrittura, nella stessalocazione di memoria.

1000

0000

1011

0010

0101

0011

1111

1000 0

1

2

3

4

5

6

7

A = 3

RD=1

1011(a)

1000

0000

0000

0010

0101

0011

1111

1000 0

1

2

3

4

5

6

7

A = 3

WR=1

0000(b)

Figura 1.6: Una memoria 8×4. (a) Operazione di lettura; (b) operazione di scrittura.

1.2.4 Ingresso uscita

Un calcolatore deve poter interagire con l’esterno. Per acquisire un dato provenientedal mondo esterno (p.e., la tastiera) la CPU deve in qualche modo trasferirlo inmemoria; in modo analogo, una periferica di uscita (ad esempio un video) deve esserein grado di mostrare all’esterno i risultati di un calcolo.

La scambio di dati fra un dispositivo esterno ed il calcolatore avviene facendocondividere alla CPU ed all’interfaccia associata al dispositivo in questione un’ areadi memoria, composta tipicamente da uno o piu registri. Questo principio e riprodottoin Figura 1.7.

registro condiviso

CPU Periferica

write

dato

dato

read

registroInterfaccia

Figura 1.7: Principio di funzionamento dell’interazione fra CPU e periferica esternadi uscita.

Per trasferire un dato all’esterno, la CPU scrive il dato nel registro; subito dopola periferica legge il dato dal registro e lo riproduce all’esterno. Il registro in cui

1.3. EVOLUZIONI ARCHITETTURALI 15

scrivere e individuato da un indirizzo e puo o essere indistinguibile da quelli dellamemoria (I/O mappato in memoria, memory mapped I/O), oppure no (I/O isolatodalla memoria, isolated I/O). La stessa tecnica e usata al contrario per trasferire datidall’esterno all’interno. Opportuni segnali di controllo possono essere sfruttati persegnalare alla CPU la disponibilita del dato.

Spazio di memoria

Spazio di I/O

Registri generaliregistri speciali

Registro nascosto

....

....

....

....

CPU

Memoria I/O

0

2

3

m-1

0

2

3

n-1

Figura 1.8: Risorse di un calcolatore dal punto di vista della programmazione inlinguaggio macchina.

La Figura 1.8 riporta un modello funzionale di quanto esposta finora. In questoschema, gli indirizzi degli m registri per l’I/O sono separati da quelli di memoria.

1.3 Evoluzioni architetturali

I primi calcolatori realizzati completamente con tecnologia allo stato solido - dalPDP-8 della DEC(1965), fino ai primi Personal Computer - erano realizzati seguendoil modello strutturale di Figura 1.4. Nel tempo questo modello ha subito diversevariazioni sotto la spinta di fattori puramente tecnologici. Il motivo principale eche i miglioramenti tecnologici delle varie parti (la memoria, la CPU , le periferiche)seguono ritmi differenti.

Ad esempio, si e potuto empiricamente constatare che mentre le CPU raddoppianola velocita di esecuzione di almeno il 50% all’anno, la velocita della memoria consenteun aumento annuo di solo il 7%. Inoltre le periferiche sono nel tempo aumentate innumero e variabilita in termini di velocita.

Vediamo per sommi capi quali sono state le soluzioni architetturali usate per farfronte a questa disomogeneita e che hanno avuto l’obbiettivo di trarre - da questimiglioramenti - il massimo vantaggio, in termini di prestazioni del sistema di calcolo.


1.3.1 Gerarchia di memoria

Il sistema di memorizzazione degli attuali calcolatori e strutturato secondo una ge-rarchia, detta appunto gerarchia di memoria. Il sistema e composto da elementi dimemorizzazione realizzati con diverse tecnologie. Salendo di livello nella gerarchia sitrovano elementi di memorizzazione con capacita via via inferiore, ma piu veloci erealizzati con tecnologie piu costose. Il livello puo essere inteso anche come vicinanzaalla CPU (Figura 1.9).

Registri

Cache

Memoria principale

Memoria secondaria

volatile

permanente

CPU

Figura 1.9: La funzione di memorizzazione nei moderni calcolatori e ottenutamediante un sistema gerarchico.

Il livello piu alto e occupato dai registri, fisicamente collocati dentro la CPU (tipi-camente 32). I tempi di accesso sono di qualche ns. Segue la memoria cache, divisa dinorma in sottolivelli (2 o 3) posti dentro o fisicamente molto vicino al processore. Sitratta di una memoria di prestazione comparabile con quella dei registri. Le dimen-sioni sono dell’ordine di qualche MB. Ad un gradino piu basso troviamo la memoriaprincipale, la cui dimensione tipica e 512 MB o 1 GB; i tempi di accesso sono dell’or-dine delle decine di ns. Segue la memoria secondaria, caratterizzata da dimensionimolto maggiori (centinaio di GB), ma tempi piu lenti (ad esempio Hard Disk, HD).

I primi tre gradini del sistema danno vita ad una memoria volatile. I dati sonoconservati fino a che si fornisce energia dall’esterno. Viceversa, la memoria secondariae di tipo permanente, cioe non soggetta a questo vincolo.

I livelli della gerarchia lavorano in modo sinergico duplicando le informazioni dicui la CPU ha imminente bisogno (sia dati che istruzioni) nei livelli piu alti.

Per capire questo principio consideriamo il legame fra cache e memoria principale,Figura 1.10 (un’analisi simile vale per ogni coppia di livelli adiacenti). La cache abbiacapacita C0 e la memoria principale C1. I tempi di accesso alle singole memorie sianoinoltre t0 e t1. Ammettiamo che la CPU voglia leggere (read) un dato dalla memoriaprincipale ed ammettiamo che la cache abbia gia la copia di una parte dei dati chesono in memoria.

Se il dato richiesto e presente in cache, esso viene restituito dopo un tempo t0,altrimenti si verifica un evento di miss. Il dato deve essere recuperato dalla memoria,copiato nella cache - sovrascrivendo se necessario un altro dato - e fornito quindialla CPU . Il tempo di accesso in questo caso e αt1, dove α > 1 e un coefficiente


read dato

miss

C0,t0

C1,t1

Figura 1.10: Il principio di funzionamento della memoria cache; lo stesso principiovale per due livelli della gerarchia di memoria adiacenti.

di penalizzazione che tiene conto delle operazioni aggiuntive (penalita) rispetto alsemplice recupero del dato dalla memoria principale.

Il tempo medio di accesso al dato e

t = ht0 + (1− h)αt1

dove h e la probabilita che il dato sia in cache (hit probability, o hit ratio). Per avereun effettivo guadagno del sistema a due livelli, rispetto al sistema che utilizzi il sololivello della memoria principale, h deve essere elevato (tipicamente > 0.9), in modoche

ht0 + (1− h)αt1 < t1

Se sia i dati in cache che (le posizioni dei) dati richiesti fossero completamente casuali,avremmo che

h =C0

C1

E questo renderebbe la soluzione poco utile. Tuttavia, come mostrato empiricamente,gli accessi in memoria sono fortemente correlati fra loro sia temporalmente (la stessainformazione e richiesta piu volte), sia spazialmente (e molto probabile che dopoun accesso ad una locazione di memoria si acceda ad una vicina), e questo porta adavere hit ratio molto elevati anche con rapporti C0/C1 bassi (la correlazione spaziale esfruttata copiando in cache non solo il dato richiesto ma anche quelli ad esso adiacenti).Per fissare le idee, supponiamo che t0 = 2ns, t1 = 10ns, α = 3 e che, a seguito dellecorrelazioni spazio-temporali, con le capacita scelte per C0 e C1 si abbia h = 0.9.Abbiamo allora

t = 0.9× 2 + 0.1× 3× 10 = 4.8ns

ossia il tempo di accesso medio risulta pari a meno della meta del tempo di accessodella memoria.


1.3.2 Sistema di interconnessione

Le periferiche connesse ad un calcolatore sono diverse e di velocita differente. Adesempio, HD, CD-ROM, mouse, video, modem, schede di rete, etc. Per poter impie-gare in modo efficiente tutte queste periferiche, si usano tipicamente vari tipi di bus,caratterizzati da velocita e capacita di trasferimento differenti. Ad esempio, il sistemadi interconnessione di un tipico Personal Computer basato su Pentium IV e riportatoin Figura 1.11.

Northbridge

Southbridge

bus interno

chipset

bus alta velocità

(AGP)

CPU

bus memoria

PCI

slot PCI

cache

slot per memoria(DIMM)

slot per schedagrafica

TastieraParta parallela porta infrarossi

LPCI

USBMouse

HD esterno

Super I/OATA

controller

HDCD-ROMDVD

PCI-X

Figura 1.11: Sistema di connessione in un personal computer basato su CPU Intel.

Il collegamento fra le varie unita e mediato da un insieme di circuiti integrati(chip) riferiti globalmente come chipset, i cui chip principali sono chiamati northbridge e south bridge e svolgono il ruolo di hub (concentratori). Il north bridge serveper connettere la CPU alla memoria al video, entrambi dispositivi molto veloci. Ognitipo di memoria richiede uno specifico north bridge. Il bus che collega la CPU al northbridge e detto bus di sistema (system bus oppure Front Side Bus, FSB), mentre il busche collega la scheda grafica al chip e tipicamente di tipo AGP (Accelerated GraphicsPort); in pratica si tratta di un collegamento bidirezionale dedicato. Il south bridge eimpiegato per collegare dispositivi piu lenti. Da esso si diramano diversi tipi bus usatiper connettere altre periferiche - con l’eventuale supporto di altri chip (controllori).Fra i piu comuni il bus PCI (Peripheral Component Interconnect) o l’estensione PCI-X ed il bus Low Pin Count (LPC), mediante cui e possibile collegare dispositivi moltolenti, come la tastiera o dispositivi a raggi infrarossi. Dispositivi per la memoriadi massa (DVD, Hard Disck, CD-ROM) sono collegati mediante un controller ATA(Advanced Technology Attachment).


1.3.3 Accesso diretto alla memoria, DMA

Nella realizzazione classica del modello di von Neumann la CPU e l’unico elementoattivo. Se per esempio una periferica di ingresso deve trasferire dati in memoria allo-ra la CPU deve essere chiamata in causa per ogni singolo dato. La CPU trasferisceprima il dato in un registro interno; poi, da questi in una locazione di memoria. Seun calcolatore ha molte periferiche e la quantita di dati da trasferire e elevata, comead esempio quando si vuole trasferire un blocco di dati dalla memoria secondaria allaprincipale, allora la CPU viene pesantemente utilizzata. Con la tecnica del DMA,Direct Memory Access, le periferiche hanno accesso diretto alla memoria, ossia posso-no trasferire dati in memoria indipendentemente dalla CPU, il cui intervento rimanelimitato ad un’azione di inizializzazione del trasferimento indicata ad un apposito di-spositivo detto DMA controller. La CPU si limita cioe a dare avvio al trasferimento,mentre il trasferimento vero e proprio e svolto dal controller.

In questo modo l’attivita della CPU puo proseguire in parallelo con il trasferimentodei dati, con un evidente vantaggio sui tempi di esecuzione dei programmi. La tecnicadel DMA richiede una coordinazione adeguata sull’uso dei bus dati, poiche una solaentita per volta puo trasmette i dati. Il bus viene gestito in muta esclusione da unarbitro, un dispositivo che ne concede l’uso ad un richiedente per volta (CPU o DMAcontroller).

1.3.4 Pipeline

Probabilmente l’elemento funzionale soggetto a maggiori miglioramenti nel tempo estato la CPU. E cio non deve meravigliare, visto che e il cuore di ogni calcolato-re. E’ bene sottolineare comunque che questi miglioramenti hanno tutti lo scopo diaumentare le prestazioni del sistema di calcolo o, come spiegheremo nella prossimasezione, facilitare la scrittura di programmi; non porta invece ad alcun aumento della“capacita” di calcolo.

Il metodo principale per aumentare le prestazioni della CPU si fonda sulla lapipeline. In modo molto sintetico, la pipeline si ispira all’idea di catena di montaggio,un metodo introdotto sin dal secolo XX nelle fabbriche per aumentare la produttivita(numero di manufatti prodotti per unita di tempo). Supponiamo che per completarel’esecuzione di una istruzione la CPU impieghi un tempo unitario. Con la pipelinel’esecuzione di ogni istruzione viene suddivisa in una sequenza di k fasi elementari,ognuna delle quali richiede un tempo 1/k. Le fasi sono portate avanti mediantealtrettanti stadi di elaborazione, che usano risorse di calcolo (ad esempio registri,ALU, etc) in modo esclusivo. Nel caso ideale, ad ogni istante di tempo, i k stadielaborano una diversa fase di k istruzioni diverse. In questo modo, la CPU terminal’esecuzione di una nuova istruzione ogni 1/k unita di tempo, dando vita ad un amento(speed-up) di throughput (produttivita), in termini di istruzioni eseguite per unita ditempo, pari proprio a k. La Figura 5.16 mostra il principio di funzionamento di unapipeline a 3 stadi.


I1I1

I1I2I2

I1I2I3I3 I1

I2I3I4I4 I2

I3I4I5I5 I3

Figura 1.12: Principio di funzionamento di una pipeline a 3 stadi.

1.4 Microprogrammazione

Una CPU puo eseguire solamente programmi scritti in linguaggio macchina. Lascrittura di programmi di qualita (ossia privi di errori ed efficienti) direttamente inlinguaggio macchina ha da subito posto dei problemi, poiche da un lato impedisce difocalizzare in modo adeguato l’attenzione sul problema da risolvere, dall’altro richie-de di scrivere programmi molto lunghi e quindi soggetti ad errori. Per agevolare laproduzione di programmi eseguibili sono stati quindi inventati linguaggi di program-mazione dotati di istruzioni piu astratte, ognuna corrispondente ad un gruppo di piuistruzioni macchina. Tali linguaggii sono chiamati linguaggi di alto livello.

Affinche un programma scritto in un linguaggio di programmazione di alto li-vello possa essere eseguito dal calcolatore, esso deve essere tradotto nell’equivalenteprogramma in linguaggio macchina. E questa traduzione deve avvenire in modoautomatico, mediante cioe un altro programma, detto compilatore.

La software crisis e le macchine CISC La qualita del compilatore e fonda-mentale per avere una corretta ed efficiente traduzione del programma iniziale. Percui il problema della produzione di programmi di qualita si sposta sulla scrittura dicompilatori (ossia altri programmi) di qualita. Avere compilatori di qualita non fuinizialmente facile. Come si sarebbe dovuto scrivere un compilatore? Evidentementele alternative erano due. O direttamente in linguaggio macchina, o per mezzo di unaltro compilatore, il che ripone la prima domanda.

Questa situazione fu una delle cause della cosiddetta software crisis, termine co-niato intorno alla fine degli anni 60 per sottolineare la constatazione del fallimentosistematico, in termini di budget, tempi di consegna e qualita, di progetti per la pro-duzione di software. Durante tutti gli anni 60 e 70 si cerco di agevolare la scrittura dicompilatori, e quindi di uscire dalla crisi, producendo CPU con un set istruzioni piuvicino ai linguaggi di alto livello e per questo sempre piu sofisticate; il culmine fu rag-giunto dalla serie di calcolatori VAX della DEC, che prevedevano finanche istruzioniper la valutazione di polinomi.

1.5. MACCHINE ASTRATTE E LIVELLI DI PROGRAMMAZIONE 21

Questo ricco set di istruzioni avrebbe dovuto cosi colmare il cosiddetto semanticgap, la distanza “semantica” fra i linguaggi di basso ed alto livello. Le CPU costrui-te in accordo a questa filosofia sono state, a posteriori, chiamate CISC (ComplexInstruction Set Computer). Per realizzare macchine CISC, la CPU viene realizza-ta mediante un tecnica detta di microprogrammazione. L’organizzazione interna diuna CPU viene per assonanza chiamata, anche per macchine che non usano questatecnica, microarchitetttura.

In sostanza, l’unita di controllo della CPU esegue un (micro)programma cheinterpreta il set istruzioni della CPU. Per ogni istruzione complessa, sono eseguitevarie (micro)istruzioni piu elementari.

Interprete (microprogramma)

esegueusa

microarchitettura

Unita’ dicontrollo

esegueusa

CPU

Programma linguaggio macchina

Figura 1.13: Realizzazione di una CPU mediante microprogrammazione.

Con il tempo si e poi constatato che le macchine CISC ponevano forti limitazionial raggiungimento di elevate prestazioni. E cio a condotto alla costruzione di CPUdotate, al contrario, di un set ridotto di istruzioni; i calcolatori che seguono questoprincipio sono chiamati macchine RISC (Reduced Instruction Set Computer).

1.5 Macchine astratte e livelli di programmazione

Abbiamo definito un calcolatore elettronico come un sistema in grado di essere pro-grammato. Cerchiamo adesso di estrarre i concetti di fondo di questa idea ed usarlapoi come strumento concettuale per rintracciare un’ulteriore visione funzionale di ungenerico sistema di calcolo.

Definiamo a questo scopo macchina M un ente in grado di essere programmatomediante un linguaggio di programmazione L(M). Questa macchina esegue tutti iprogrammi scritti in L. D’altra parte, ad ogni linguaggio L e associata la macchinaM(L) che e in grado di eseguire i programmi in L (avrebbe poco interesse definirelinguaggi i cui programmi non possono essere eseguiti, per esempio perche ambigui).Per indicare che una macchina M di linguaggio L esegue un programma P scriviamo

[M(L)].P


Ammettiamo adesso di avere a disposizione M(L). Fra tutti i possibili programmiscritti in L ce ne sono alcuni speciali. La prima classe e composta dai cosiddettiinterpreti di altri linguaggi, la seconda dai compilatori.

Un interprete I(L,L′) di un linguaggio L′ e un programma scritto in L in gradodi eseguire ogni programma scritto in L′ o, in breve, di interpretare L′. A benevedere, questo e un modo per realizzare la macchina M(L′) avendo a disposizionegia la macchina M(L). Basta infatti che M(L) esegua l’interprete I(L,L′). In modosimbolico potremmo indicare questa possibilita nel seguente modo

M(L′) = [M(L)].I(L,L′)

A questo punto nulla vieta di progettare e scrivere un altro programma, interprete diun nuovo linguaggio, L′′, scritto in L′, I(L′′, L′), e costruire cosi la macchina

M(L′′) = [[M(L)].I(L,L′)].I(L′, L′′)

In questo modo si instaura una relazione gerarchica fra macchine. Per mettere inevidenza questa relazione gerarchica fra macchine si usa anche il termine livello. Lamacchina di livello piu basso nella gerarchia, M0, dovra essere realizzata mediante un(complesso) circuito elettronico, che globalmente agisce come un interprete, mentre lealtre possono essere realizzate sfruttando interpreti software. In un sistema di calcolo

MICROARCHITETTURA

ISA

Sistema operativo

Programma utente

CPU

Software

Hardware

Sistema di calcolo

Figura 1.14: Un sistema di calcolo si puo decomporre in diverse macchine (o livelli)programmabili, che sono in relazione gerarchica fra loro.

si possono riconoscere i seguenti livelli (Figura 1.14)

• Macchina M0 (microarchitettura) con linguaggio L0 detto linguaggio di micro-programmazione.

• Macchina M1 (macchina ISA, Instruction Set Architecture) con linguaggio L1

detto linguaggio ISA (o, tout court linguaggio macchina)

• Macchina M2 (sistema operativo), il cui linguaggio e composto da quello mac-china piu altre “istruzioni”, dette chiamate di sistema (system call).

1.6. DOMANDE DI RICAPITOLAZIONE 23

L’obiettivo sostanziale di questo libro e mostrare come costruire la macchina M0 apartire dai componenti elettronici di base e la macchina M1 a partire dalla macchinaM0. Lo studio della macchina M2 viene affrontato nei corsi di sistemi operativi.

Anche i compilatori possono essere visti come strumenti concettuali per realizzaremacchine. Un compilatore C(L,L1) e infatti un programma eseguibile su una mac-china M1 che traduce qualunque programma P scritto in un linguaggio L in un altroprogramma equivalente, P ′, scritto per girare su M1

3. Il termine equivalente significache se si avesse a disposizione la macchina M(L) allora il risultato ottenuto eseguendoP su M(L) sarebbe lo stesso di quello ottenuto P ′ su M1, per qualunque insieme didati in ingresso.

1.6 Domande di ricapitolazione

1. Cosa si intende esprimere dicendo che un calcolatore e un sistema digitaleprogrammabile ?

2. Quali sono i principi di base dell’architettura di von Neumann?

3. Qual e il modello strutturale di base di un calcolatore realizzato secondo l’ar-chitettura di von Neumann?

4. Cos’e la CPU ?

5. Cos’e la memoria principale ?

6. Cosa si intende per memoria volatile? e permanente?

7. Qual e il principio di funzionamento della memoria cache?

8. Qual e il principio di funzionamento della pipeline?

9. Quali sono le motivazioni che hanno condotto all’introduzione del concetto dimicroprogrammazione?

10. I programmi scritti in Java sono di norma eseguiti da un programma interpretedi una macchina (virtuale), detta java virtual machine (jvm); inserire la jvmnella struttura a livelli di figura 1.14

11. Le figure 1.3, 1.8 e 1.14 mostrano 3 diversi punti di vista per descrivere uncalcolatore. Quali sono gli aspetti tipici di questi ogni punti di vista?

3In generale non e necessario che il programma sia tradotto nel linguaggio di M1; nei cross-compilatori il programma tradotto viene eseguito su una macchina M ′

1 diversa da M1.

Capitolo 2

Codifica dell’informazione

Al suo interno, il calcolatore rappresenta sia i dati che le istruzioni, che globalmentecostituiscono l’informazione a disposizione, mediante gruppi di bit. In questo capi-tolo studieremo i principali metodi di rappresentazione (codifica) binaria di dati; inparticolare valori numerici (interi senza segno, interi con segno e reali) e caratteri.Studieremo inoltre le implicazioni derivanti dal fatto che il numero di cifre binarie adisposizione dei vari metodi di rappresentazione e limitato.

2.1 Sistema di numerazione posizionale

Un sistema di numerazione posizionale di base B e una coppia (A,B), dove

• A e un insieme di simboli distinti (le cifre) detto anche alfabeto

• B = |A| un intero positivo detto base (o radice) del sistema

In questo sistema ogni numero intero minore di B si esprime mediante una solacifra c dell’alfabeto, mentre un qualunque altro numero finito mediante una specificasequenza di cifre, detta allineamento, eventualmente separate da una virgola:

ck−1ck−2 . . . c0, c−1c−2 . . . c−p . . .

Il sistema e detto posizionale perche il valore rappresentato dalla cifra ci dipende allaposizione i, cui e associato il peso Bi.

Il valore rappresentato da un allineamento si trova mediante la seguente leggedi composizione. Il numero rappresentato dalla cifra che occupa il posto i-simo simoltiplica con il peso (valore) Bi. I prodotti dei pesi per le cifre, cosi ottenuti, siaddizionano. La somma di tali prodotti e il numero rappresentato dall’allineamento.In formule

V alore(ck−1ck−2 . . . c0, c−1c−2 . . . c−p) =k−1∑i=−p

V alore(ci)× V alore(Bi) (2.1)

25

26 CAPITOLO 2. CODIFICA DELL’INFORMAZIONE

E’ importante comprendere che numero ed allineamento sono due concetti distinti.Un numero e un’entita astratta (il significato) un allineamento e un simbolo cherappresenta il numero. Lo stesso numero puo essere rappresentato quindi medianteallineamenti differenti (Figura 2.1).

Numero

Allineamentoin (A,B)

Allineamentoin (A’,B’)

Rappresentazione

Interpretazione

Trasformazione fra Rappresentazioni

Entità astratta

Figura 2.1: Metodi di rappresentazione di dati numerici.

E’ chiaro che la distinzione sfugge fin quando si lavora in base dieci, usando cioe lecifre 0, 1, .., 9, poiche si effettua mentalmente un’immediata associazione fra allinea-mento e numero che esso rappresenta. Risulta pero importante tener conto di questadistinzione e trattare le cifre, quando serve, come puri elementi sintattici.

Un discorso analogo va fatto per l’Equazione 2.1. La parte destra dell’eguaglianzava espressa in modo simbolico. Useremo a tal fine il sistema a base dieci, con il qualeabbiamo familiarita, traducendo cosi immediatamente il simbolo nel valore che essorappresenta.

Per mettere in risalto la base di un sistema di numerazione sfruttata da un allinea-mento, l’allineamento verra circondato da parentesi tonde e la base dell’allineamento,espressa in base dieci, verra posta a destra della parentesi, come in

(10)3

che va letto come allineamento di cifre 1 e 0 in un sistema a base tre. Per indicareche due allineamenti in due basi differenti, B1 e B2 sono uguali, useremo la notazione

(. . .)B1 = (. . .)B2

2.2 Sistema di numerazione posizionale in base 2

Questo sistema impiega due sole cifre, 0 ed 1. Vediamo adesso come passare dallarappresentazione in base 2 a quella in base 10 e viceversa.

2.2.1 Conversione dalla base 2 alla base 10

Tale conversione si ottiene applicando direttamente relazione 2.1.

2.2. SISTEMA DI NUMERAZIONE POSIZIONALE IN BASE 2 27

Esempio 2.1 (valore intero). L’allineamento di cifre (1110)2 ha valore

1× 23 + 1× 22 + 1× 21 + 0× 20 = 14

per cui (1110)2 = (14)10.

Esempio 2.2 (valore frazionario). Il valore di (.101)2 in base 10 vale

1× 1

2+ 0× 1

22+ 1× 1

23= .625

ossia (.101)2 = (0.625)10

2.2.2 Conversione da base 10 a base 2

Distinguiamo vari casi

Conversione di numero intero n (metodo delle divisioni successive)

Per prima cosa osserviamo che con k cifre binarie, il massimo numero che possiamorappresentare vale

2k−1 + 2k−2 + . . . 1 =k−1∑i=0

2i = 2k − 1

per cui per esprimere n abbiamo bisogno di k(n) cifre, dove k(n) e il piccolo interoche soddisfa

2k(n) − 1 ≥ n

ossiak(n) = ⌈log2(n+ 1)⌉

Le cifre binarie incognite dell’allineamento in base 2

bk−1 . . . b1b0

si trovano agevolmente lavorando in base dieci. Deve essere

n = 2k−1bk−1 + . . .+ 2b1 + b0

Mettendo 2 in evidenza troviamo che

n = 2× (2k−2bk−1 + . . .+ b1) + b0

D’altra parte, per una qualunque coppia di interi, n e B, se 1 ≤ B ≤ n allora vale larelazione

n = B ×Q+R

dove Q < n e il quoziente della divisione intera fra n e B,

Q = n div B


ed 0 ≤ R < n il resto

R = n mod B

Pertanto, la cifra b0 altro non e che il resto della divisione intera fra n e 2. Ossia,

b0 = n mod 2

mentre

n′ = (2k−2bk−1 + . . .+ b1) = n div 2

La cifra b1 si ottiene con lo stesso procedimento applicato ad n′. Iterando il procedi-mento, finche il quoziente diventa nullo, si ottengono le rimanenti cifre incognite. Ilmetodo presentato viene chiamato metodo delle divisioni successive o dei resti.

Esempio 2.3 (valore intero). Vediamo come trovare la rappresentazione binaria di25.Applichiamo il metodo delle divisioni successive con l’ausilio di una tabella. Ogni rigacontiene il numero n, quoziente e resto della divisione per 2, nonche la cifra isolata.La riga successiva inizia con il quoziente della linea precedente.

n n div 2 n mod 2 cifra25 12 1 b0=112 6 0 b1=06 3 0 b2=03 1 1 b3=11 0 1 b4=1

Troviamo pertanto che (25)10 = (11001)2.

Conversione numero intero, metodo diretto

Questo metodo consiste nell’esprimere direttamente il numero da convertire comesomma di potenze di due. Se il contributo 2i appare nella somma, allora nellarappresentazione binaria la cifra i-sima vale 1, altrimenti 0.

Esempio 2.4. Per trovare la rappresentazione di 27 sfruttiamo il fatto che

27 = 16 + 8 + 2 + 1 = 24 + 23 + 21 + 20

da cui

27 = (11011)2

Conversione di un numero n < 1 (metodo dei prodotti successivi)

Lo schema e simile al precendente. Scriviamo n in modo che appaiano le cifre incognite

n = b−12−1 + b−22

−2 + . . . b−p2−p

2.2. SISTEMA DI NUMERAZIONE POSIZIONALE IN BASE 2 29

Come sara chiaro fra breve, in questo caso non sappiamo pero qual e il numero p dellecifre di cui abbiamo bisogno. Moltiplichiamo per 2 il primo ed il secondo membrodell’uguaglianza, ottenendo

2n = b−1 + b−22−1 + . . . b−p2

−p+1

Osserviamo che il prodotto2n = I + n′

dove I = ⌊2n⌋ e la parte intera di 2n e coincide con la nostra prima cifra incognita,mentre n′ < 1. Per ricavare b−2 applichiamo lo stesso metodo ad n′ = 2n− I, e cosivia. Questo metodo si chiama metodo dei prodotti successivi.

Esempio 2.5 (Numero finito di cifre). Trovare la rappresentazione binaria di n =0.8125. Applichiamo il metodo dei prodotti con l’ausilio di una tabella, come fattonell’esempio precedente. Tranne che per la prima riga, il valore della prima colonnain una data riga, e dato da quello in terza colonna della riga precedente.

n 2n 2n− ⌊2n⌋ cifra = ⌊2n⌋0.8125 1.625 0.625 b−1=10.625 1.25 0.25 b−2=10.25 0.5 0.5 b−3=00.5 1 0 b−4=1

pertanto (0.8125)10 = (0.1101)2.

Esempio 2.6 (Numero infinito di cifre). Trovare la rappresentazione binaria di 0.2.Applicando il metodo delle moltiplicazioni successive scopriamo che i valori si ripe-

tono periodicamente.

n 2n trunc(n) cifra0.2 0.4 0 b−1=00.4 0.8 0 b−2=00.8 1.6 1 b−3=10.6 1.2 1 b−4=10.2 0.4 0 b−5 = b−1.. .. .. ..

Quindi, n = (0.0011)2.

Conversione n < 1, metodo diretto Il metodo diretto si puo applicare anchea numeri inferiori all’unita. Bisogna esprimere il numero come somma di potenzenegative di 2. Questa espansione non e sempre agevole. Ad esempio il numero 0.625e pari a

0.625 =1

2+

1

23= (0.101)2


Conversione di numero frazionario n qualunque Per convertire un nume-ro n qualunque in binario si devono convertire le due parti, quella intera e quellafrazionaria, applicando i due metodi introdotti. Un esempio e riportato in Figura 2.2.

• 12 div 2 = 6 resto 0 → b0=0

• 6 div 2 = 3 resto 0 → b1=0• 3 div 2 = 1 resto 1 → b2=1

• 1 div 2 = 0 resto 1 → b3=1

• 0.25 x 2 = 0.50, parte intera 0 → b-1=0

• 0.50 x 2 = 1.0, parte intera 1 → b-2=1

(12.25)10 → (1100.01)2

Figura 2.2: Esempio di conversione di un numero frazionario da 10 a 2.

2.2.3 Numeri periodici in base 2

L’esempio 2.6 ci ha mostrato che la rappresentazione di 0.2 in base 2 e un allineamentoperiodico e pertanto richiede infinite cifre. Un valore n rappresentabile con un numerofinito p di cifre binarie ha infatti valore

n =b−121

+b−222

+ . . .+b−p2p

Mettendo 12p in evidenza troviamo

n =1

2p(2p−1b−1 + 2p−2b−2 + . . . b−p)

da cui n = m2p , dove m e un intero. Pertanto, i valori con numero finito di cifre

binarie sono solo quelli che possono esprimersi come rapporto fra un intero m ed unapotenza di 2. Questo ci spiega perche’ 0.2 non puo essere rappresentato mediante unallineamento finito di cifre.

Esempio 2.7. Possiamo rappresentare il numero x1 = 0.375 mediante un numerofinito di cifre binarie? Ed il numero x2 = 0.4?Scriviamo i valori in forma frazionaria e semplifichiamo, ottenendo x1 = 375

1000 = 38 ,

mentre x2 = 25 . Quindi per x1 la risposta e si, poiche 8 = 23, mentre per x2 no.

Relazione fra numeri periodici in base 2 e base 10

Se un numero n espresso in forma binaria non e periodico, allora non lo sara nemmenose espresso in base 10. Infatti, dovrebbe anzitutto essere chiaro che, seguendo unprocedimento analogo a quanto visto in precedenza, se n puo essere messo nella forma

n =m′

10p′ (2.2)

2.3. SISTEMI DI NUMERAZIONE POSIZIONALE IN BASE 8 E 16 31

dove p′ ed m′ sono interi, allora il suo allineamento in base 10 e finito. D’altra partepoiche 10 = 2× 5 questa condizione diventa

n =m′

2p′ × 5p′

Per ipotesi il numero n non e periodico in base 2, e quindi esistono m e p tale che

n =m

2p

Dall’equazione m′

2p′×5p′ = m2p troviamo che p′ = p e m′ = 5pm; quindi n puo essere

messo nella forma 2.2.

Esempio 2.8. Consideriamo il numero n = 34 . Poiche n = 3

22 tale numero none periodico in base 2 e, pertanto, nemmeno in base 10. Infatti, n = 75

100 . Lerappresentazioni sono (0.11)2 e (0.75)10

Si puo dimostrare che, una volta espresso n come frazione, se la base comparefra i fattori primi del denominatore della frazione allora l’allineamento ammette unantiperiodo.

Esempio 2.9. Trovare la rappresentazione in base 2 di n = 0.1.Poiche n = 1

10 = 12×5 , la rappresentazione binaria deve essere periodica con antipe-

riodo. Infatti, n = (0.00011)2

2.3 Sistemi di numerazione posizionale in base 8 e16

Il sistema si numerazione a base 8 e detto sistema ottale, quello a base 16 esadecimale.La tabella 2.1 riporta gli allineamenti dei valori da 0 a 15 nelle basi 2,8,16. In grassettosono riportate le cifre delle varie basi. Per la rappresentazione in base 16 e prassi porredavanti all’allineamento il simbolo ×, come in ×23.

2.3.1 Conversione da base 2 alle basi 8,16 e viceversa

Si puo dimostrare che l’allineamento nella base 2k si ottiene a partire da quello in base2, raggruppando le cifre binarie in gruppi di k e rappresentando poi ogni gruppo conuna cifra dell’alfabeto del sistema con base 2k. Se l’allineamento non e un multiplodi k, si inseriscono cifre nulle a sinistra per la parte intera ed a destra per la partefrazionaria. Per le conversioni da base 2 in base 8 o 16 le cifre binarie si raggruppanoquindi, rispettivamente, in triple e quadruple; per ogni gruppo si usa poi la tabella diFigura 2.1.

Esempio 2.10 (da base 2 a 8). Troviamo la rappresentazione in base 8 di (1010110110)2.Raggruppiamo l’allineamento a gruppi di 3, ottenendo (le cifre sottolineate sono stateaggiunte)

001 010 110 110


B = 10 B = 2 B = 8 B = 160 0 0 01 1 1 12 10 2 23 11 3 34 100 4 45 101 5 56 110 6 67 111 7 78 1000 10 89 1001 11 910 1010 12 A11 1011 13 B12 1100 14 C13 1101 15 D14 1110 16 E15 1111 17 F

Tabella 2.1: Rappresentazioni dei primi 15 interni nelle basi 2,8,16. In neretto sonoriportate le cifre di ogni sistema.

da cui

(1010110110)2 = (1266)8

Esempio 2.11 (da base 2 a 16). Troviamo la rappresentazione in base 16 di (1010110110)2.Raggruppiamo l’allineamento a gruppi di 4, ottenendo (le cifre aggiunte sono statesottolineate)

0010 1011 0110

da cui(1010110110)2 = (2B6)16

Esempio 2.12 (da base 8 a 2). Convertiamo il numero ottale 773 in binario. Sosti-tuiamo ogni cifra ottale con le tre cifre binarie che la rappresentano in base 2. Ossia7 con 111 e 3 con 011. Pertanto,

(773)8 = (111111001)2

Esempio 2.13 (da base 16 a 2). Per trovare la rappresentazione di FFAB, sosti-tuiamo ogni cifra esadecimale con le quattro cifre binarie che la rappresentano in base2. Ossia F con 1111, A con 1010 e B con 1011. Pertanto,

FFAB = (1111111110101011)2

Da questo esempio deduciamo come il sistema esadecimale possa essere utilizzatoper rappresentare in modo piu compatto lunghe sequenze di cifre binarie.

2.3. SISTEMI DI NUMERAZIONE POSIZIONALE IN BASE 8 E 16 33

2.3.2 Conversione dalle basi 8,16 alla base 10

Come per la base 2, questa conversione si ottiene agevolmente usando la relazione 2.1Alcuni esempi di conversione dalle basi 8 e 16 alla base 10 sono riportati in Figura2.3

• (721)8� 7 x 82 + 2 x 81 + 1 x 80 = 7x64 + 16 + 1 = 448 +17=(465)10

• (0.1)8� 1/8 = (0.125)10

• (721)16 � 7 x 162 + 2 x 161+ 1 x 160 = 7 x 256 + 2 X 16+ 1 = (1825)10

• (0.1)16 � 1/16 = (0.0625)10

Figura 2.3: Esempi di conversione dalle basi 8,16 alla base 10.

2.3.3 Conversione da base 10 alle basi 8,16

Per questa trasformazione convertiamo il numero in base 2 e poi da 2 alla base finale.

Esempio 2.14. Rappresentare nelle basi 8,16 il valore n = 19.25. Troviamo che

n = 16 + 2 + 1 +1

4= (10011, 01)2

Per ottenere la rappresentazione in base 8 raggruppiamo le cifre binarie in triple (lecifre sottolineate sono state aggiunte),

010 011, 010

otteniamo

n = (23, 2)8

Analogamente per la rappresentazione in base 16 raggruppiamo le cifre in quadruple,

0001 0011, 0100

ottenendo cosi

n = (13, 4)16

2.3.4 Conversione da base 8 a 16 e viceversa

Come per il caso precedente, questa trasformazione si ottiene passando da una rap-presentazione intermedia in base 2 (Figura 2.4).


(E54)16

(1110 0101 0100)2

(621)8

(110 010 001)2

(E54)16

(1110 0101 0100)2

(111 001 010 100)2

(7124)8

Da base 16(2) a 2(16)

Da base 8(2) a 2(8)

Da base 16(8) a 8(16)

Figura 2.4: Esempi di conversioni fra basi multiplo di 2

2.3.5 Esempi aggiuntivi

Esempio 2.15 (*). Trovare la rappresentazione decimale di x = (0, 01)2. Poiche ilvalore 1 occupa le posizioni −2,−4, ..,−2i, .. possiamo sfruttare la somma della seriegeometrica

x =

∞∑i=1

2−2i =

∞∑i=1

( 1

22

)i

=14

1− 14

=1

3.

Si noti che in base 3, x non e periodico; infatti, x = (0, 1)3.

Esempio 2.16 (*). Trovare la rappresentazione binaria di 23 .

Per trovare la rappresentazione di 23 , si puo sfruttare il fatto che 1

3 + 23 = 1 e che

(0, 11 . . . 1 . . .)2 = (0, 11)2 converge ad 1. Quindi 23 = (0, 10)2. Un altro modo consiste

nel moltiplicare per 2 la rappresentazione di 13 . Cio sposta le cifre a sinistra di una

posizione.

Esempio 2.17 (*). Trovare la rappresentazione decimale di x = (0, 0011)2. Laregolarita della ripetizione suggerisce di scrivere

x = (2−3 + 2−4) + (2−7 + 2−8) + . . . (2−4i+1 + 2−4i) . . .

da cui

x =∞∑i=1

(2−4i + 2−4i+1

)=∞∑i=1

(1 + 2)2−4i = 3∞∑i=1

( 1

24

)i

= 3116

1− 116

=1

5.

2.4 Numeri naturali

Una volta stabiliti i metodi di conversione di un numero qualunque da una base adun’altra, vediamo come sono espressi (codificati) in base 2 i numeri naturali.

2.4. NUMERI NATURALI 35

2.4.1 Codifica naturale

I numeri naturali sono rappresentati mediante k cifre binarie in accordo al sistema dinumerazione posizionale a base 2. Questa rappresentazione e detta codifica naturale.L’intervallo di valori che possono essere espressi e qundi

IN(k) = [0, 2k − 1]

Alcuni esempi numerici sono riportati in Figura 2.5, nella quale sono stati indicati,per alcuni valori di k, gli estremi superiori dell’intervallo.

15 31 63 127 2550

Figura 2.5: Esempi di intervalli numerici rappresentabili mediante k bit, k =4, 5, 6, 7, 8. Ad ogni cifra in piu corrisponde il raddoppio dell’intervallo.

2.4.2 Aritmetica

L’aritmetica per la codifica naturale e analoga a quella ben nota per il sistema dinumerazione a base dieci. A causa della limitazione sulle cifre disponibili pero nonsempre il risultato di un’operazione di somma o prodotto puo essere espresso corret-tamente. Se il risultato dell’operazione e un numero che non appartiene all’intervalloIN, diremo che si e verificato un traboccamento della capacita di rappresentazione, osemplicemente overflow.

Addizione

Le regole per addizionare due cifre sono 0+0 = 0, 0+1 = 1+0 = 1, 1 + 1 = (1)0.La cifra tra parentesi e il riporto, o carry. Piu cifre si addizionano “in colonna’, conforma generale

cout ← cin ← +a +b =d

dove cin indica il riporto dalla colonna precedente, cout il riporto generato dalla co-lonna attuale. I possibili casi sono elencati nella seguente tabella


cin a b cout d

0 0 0 0 00 0 1 0 10 1 0 0 10 1 1 1 01 0 0 0 11 0 1 1 01 1 0 1 01 1 1 1 1

Si noti che l’unico caso in cui cin = cout si ha per a = b = 1 oppure quando a = b = 0.Questa osservazione sara utile per rilevare errori nell’addizione fra due numeri incomplemento a 2 (vedi dopo).

Esempio 2.18. Eseguire in binario l’addizione 111000+011101 su k = 6 cifre.Discutere la condizione di overflow.

1← 1← 1← 0← 0← 0←

1 1 1 0 0 0 +0 1 1 1 0 1 =

(1) 0 1 0 1 0 1

vediamo che il riporto generato in ultima colonna non trova spazio per essere rappre-sentato mediante sei cifre. Si verifica cioe un overflow. Il risultato privo del riportofornisce un valore errato.

Sottrazione

Per la sottrazione fra due numeri naturali si puo adottare l’algoritmo di sottrazionein colonna. Le regole per sottrarre due cifre binarie sono

0-0 = 0, 1 - 0 = 1, 1 - 1 = 0, 0-1 = 1 (1)

dove la cifra fra parentesi significa che per eseguire l’operazione e necessario unprestito. Lo schema per la sottrazione in colonna e

bout ← bin ←a -b =d

dove la cifra bin indica il prestito (borrow) richiesto dalla colonna immediatamentea destra (bin = 1 significa che e stato richiesto un prestito), mentre bout il prestitorichiesto alla colonna di sinistra.

Se non e stato richiesto alcun prestito (bin = 0), allora si applica la regola descrittain precedenza, per cui

2.4. NUMERI NATURALI 37

bin a b d bout

0 0 0 0 00 0 1 1 10 1 0 1 00 1 1 0 0

Quando si e richiesto un prestito (bin = 1) se a = 1 allora esso diventa a = 0, ed ilprestito viene generato solo se b = 1 (questo prestito e necessario per poter proseguirela differenza). Se invece a = 0 viene richiesto il prestito a sinistra, dopodiche a diventa1. Si ha pertanto la seguente tabella

bin a b d bout

1 0 0 1 11 0 1 0 11 1 0 0 01 1 1 1 1

Esempio 2.19. Eseguiamo la sottrazione 111000− 011101.

0← 1← 1← 1← 1← 1←

1(0) 1(0) 1(0) 0(1) 0(1) 0 −0 1 1 1 0 1 =0 1 1 0 1 1

Fra parentesi tonde sono indicati i nuovi valori delle cifre dopo l’uso o la generazionedel prestito

Moltiplicazione

L’algoritmo per la moltiplicazione e analogo a quello elementare, illustrato in Figura6.12 mediante un esempio.

1 0 0 1 0 (18)1 0 1 0 (10)

---------------------

180

0 0 0 0 01 0 0 1 0

0 0 0 0 01 0 0 1 0----------------------

1 0 1 1 0 1 0 0

Figura 2.6: Esempio di moltiplicazione fra interi.


Divisione

La divisione fra due interi n e d (dividendo e divisore) e un po piu complessa dellamoltiplicazione, perche produce due risultati, il quoziente Q ed un resto R < d, taliche n = Qd + R. L’algoritmo di base per la divisione e una trasposizione del notoalgoritmo elementare usato in base dieci. Il quoziente Q viene costruito cercandoripetutamente quante volte il divisore “entra’ in parte del dividendo. L’algoritmo esemplificato dal fatto che il divisore entra o una sola volta in parte del dividendooppure nessuna, a seconda se il divisore e maggiore o minore della parte di dividendoche si sta analizzando.

Esempio 2.20. Eseguiamo la divisione (10011)2 : (11)2. 11 entra una volta in 100e fornisce resto 1. Abbassando la successiva cifra si compone il numero 11, che entraesattamente una volta in 11, senza resto. Poiche 1 e inferiore ad 11, il resto delladivisione e R = 1, mentre Q = 110.

10011 : 11011 |1100011001100001

Esercizio 2.1. Dimostrare che la rappresentazione della somma di due interi di kbit richiede al piu k + 1 bit.

Esercizio 2.2. Quante cifre binarie sono necessarie per rappresentare il prodotto fradue interi a k cifre binarie?

2.5 Numeri relativi

I numeri interi relativi possono essere codificati in tre modi differenti, modulo e segno,eccesso M e complemento a 2.

2.5.1 Codifica in modulo e segno

In questa rappresentazione il segno e codificato mediante un bit, tipicamente quello piusignificativo; di norma 1 indica il segno negativo. L’intervallo di valori rappresentabilimediante k bit e simmetrico rispetto allo zero e vale

IZ(k) = [−2k−1 − 1, 2k−1 − 1]

Ci sono quindi due rappresentazioni dello zero, -0 e +0.

Esempio 2.21. La seguente tabella riporta la codifica in modulo e segno su k = 3bit.

2.5. NUMERI RELATIVI 39

Numero Codifica0 0001 0012 0103 011-0 100-1 101-2 110-3 111

2.5.2 Codifica in eccesso M

In questo metodo il valore n viene rappresentato mediante il valore n+M , espresso incodifica naturale. Si tratta quindi di una traslazione dell’intervallo di rappresentabilitaverso destra. Se k e il numero di cifre a disposizione della rappresentazione, alloraM = 2k−1 e l’intervallo di valori e

IZ(k) = [−2k−1, 2k−1 − 1]

2.5.3 Codifica in complemento a 2

Il principale vantaggio di questa rappresentazione e che l’aritmetica su rappresentazio-ni in complemento risulta piu semplice da implementare mediante hardware rispetto aquella basata sul sistema posizionale vero e proprio. L’intervallo di rappresentazionee non simmetrico e vale

IZ(k) = [−2k−1, 2k−1 − 1]

Definizione Il complemento in base 2 su k bit di un numero n, Ck(n), e perdefinizione pari a

Ck(n) =

{n n ∈ [0,m− 1]2k − |n| n ∈ [−m,−1]

dove m = 2k−1. Questa funzione mappa i numeri nell’intervallo [−m,m − 1] su unacirconferenza, come riportato in Figura 2.7.

Il valore iniziale n si puo recuperare a partire dal complemento nel seguente modo

n =

{Ck(n) Ck(n) ∈ [0,m− 1]Ck(n)− 2k Ck(n) ∈ [m, 2m− 1]

Un modo alternativo per recuperare il valore n e il seguente. Siano

ck−1ck−2 . . . c0

le cifre del complemento Ck(n). Quando Ck(n) ≥ m = 2k−1, la precedente funzioneci dice che

n = Ck(n)− 2k =

k−1∑i=0

ci2i − 2k =

k−2∑i=0

ci2i + 2k−1 − 2k


0 m-1-m

m-1-m

numeri positivinumeri negativi

1

2m-1

-1

1

-n

2m-n

n

n

Figura 2.7: Corrispondenza fra numeri e rappresentazioni in complemento a 2.

poiche ck−1 = 1 (altrimenti non potrebbe mai essere Ck(n) ≥ 2k−1). Sfruttando ilfatto che 2k−1 − 2k = −2k−1, arriviamo alla forma

n = −2k−1 +k−2∑i=0

ci2i Ck(n) ≥ m

D’altra parte, per Ck(n) < m, ck−1 = 0, per cui

n =

k−2∑i=0

ci2i Ck(n) < m

Queste due espressioni possono allora essere unificate nel seguente modo

n = −ck−12k−1 +k−2∑i=0

ci2i (2.3)

L’equazione 2.3 ci da un modo per risalire al valore di una rappresentazione in com-plemento, a partire dalle sue cifre ci. Possiamo quindi affermare che il sistema dirappresentazione in complemento alla base e un sistema posizionale non puro, nelsenso che il peso della cifra piu significativa e negativo. Inoltre, il bit piu significativodel complemento fornisce informazione sul segno del valore rappresentato (non e unbit di segno poiche cambiandone il valore non si ottiene il numero opposto).

Calcolo del complemento

In questa sezione vedremo come calcolare il complemento n′, espresso in binario, diun numero n. L’osservazione chiave e la seguente. Supponiamo n < 0. A partiredalla rappresentazione del modulo di n, |n|, mediante k cifre

ck−1ck−2 . . . c0


costruiamo il numero|n|

sostituendo ogni cifra ci con ci, dove 0 = 1 e 1 = 0. La somma

|n|+ |n| = 11 . . . 1 = 2k − 1

quindi,n′ = 2k − |n| = |n|+ 1

Tutto cio giustifica il seguente metodo.

Primo metodo Per trovare il complemento in base 2 di un numero negativo n siesprime prima il modulo del numero mediante sistema posizionale; poi, si sostituisconole cifre 1 con 0 e 0 con 1 e si addiziona 1. Il numero ottenuto e il complemento.

Esempio 2.22. Per trovare il complemento di n = −4, n′, scriviamo il modulo di nin binario, |n| = (100)2. Affinche n appartenga al dominio di valori rappresentabilidobbiamo usare almeno 4 cifre. Aggiungendo una cifra di valore 0 a sinistra e negandotroviamo |n| = 1011. Sommando 1 si trova

0 1 1

1 0 1 1 +1 =

1 1 0 0

I riporti sono stati scritti in prima riga. Per cui, n′ = (1100)2

Nell’esempio precedente le cifre meno significative di n′ coincidono con le cifre di|n| fino al primo 1. Le rimanenti cifre, solo quella piu significativa nel nostro esempio,sono la negazione delle cifra che compaiono da quel momento in poi in |n|. Questaregola e generale e giustifica il seguente altro metodo.

Secondo metodo Il complemento di un intero negativo n, n′, si ottiene copiandole cifre di |n| in binario da sinistra verso destra fino al primo 1. Le rimanenti cifre delcomplemento si trovano scambiando 0 con 1 e viceversa.

Cambiamento del segno

Se applichiamo meccanicamente il metodo della calcolo del complemento ad n′ otte-niamo nuovamente |n|. Fa eccezione il caso in cui

(100...0)2

poiche e il piu grande valore negativo della rappresentazione ed il suo l’opposto, chee un valore positivo, non ricade nel dominio dei valori che possono essere espressi incomplemento (si ricordi che il dominio non e simmetrico). L’operazione di comple-mentazione, puo quindi essere interpretata, tout court, come operazione di cambio disegno. Un esempio e riportato in Figura 2.8.


01011

1248-16

-16 + 8 + 2 = -6

Peso

01100

Complementoinverti

4 + 2 = 6

01011

inverti

-16 + 8 + 2 = -6

Complemento

Figura 2.8: L’operazione di complementazione cambia il segno al numero.

Estensione del segno

Dalla relazione 2.3 deriva la seguente proprieta. Se si estende un allineamento cherappresenta un numero n in complemento a 2 su k bit, mediante una nuova cifra, ck,posta a sinistra, allora se ck = ck−1 questo nuovo allineamento rappresenta ancora n.

La validita di questa affermazione per ck−1 = 0 e ovvia, mentre per ck−1 = 1 bastaosservare che

−2k − 2k−1 = −2k−1

Per induzione, e vero anche che tale proprieta vale anche se si inseriscono ulterioricifre a sinistra, a patto che assumano lo stesso valore della cifra piu significativa dellarappresentazione di partenza.

Tale operazione di estensione del numero di cifre si chiama estensione del se-gno. Per cui, possiamo affermare che il valore di rappresentazione in complemento einvariante rispetto all’estensione del segno.

Esempio 2.23 (estensione del segno). Trovare il complemento di n = −4, su k = 8cifre.Rappresentiamo prima n su 4 cifre e poi estendiamo. Si ha, |n| = (0100)2 e C4(n) =(1100)2 da cui C8(n) = (11111100)2

2.5.4 Aritmetica

Una delle principali ragioni per l’uso della codifica in complemento a 2 e che conessa la sottrazione viene eseguita mediante un’addizione. Cio e dovuto alla seguenteproprieta (che non dimostriamo). Siano n1, n2 due numeri relativi e n′1, n

′2 i rispettivi

complementi espressi mediante k cifre binarie; se (n1+n2)′ puo essere espresso ancora

mediante k cifre, allora

(n1 + n2)′ = (n′1 + n′2) mod 2k


Si osservi che l’operazione modulo 2k corrisponde a cancellare la cifra in posizione k.

Addizione/sottrazione

Abbiamo visto che per trovare la rappresentazione in complemento di −b, (−b)′, notaquella di b, b′, e sufficiente applicare una semplice trasformazione sulle cifre di b′. Ossiainvertire (complementare) tutte le cifre e sommare 1. L’operazione di sottrazione sirealizza quindi mediante operazioni di somma e “complementazione”.

Esempio 2.24. Consideriamo gli interi a = 1, b = 2. Supponiamo di volere calcolarela rappresentazione in complemento di

s1 = a− b

Lavorando sulle rappresentazioni in complemento mediante 3 bit cifre binarie (minimovalore per esprimere i valori in complemento) si ha che

s′1 = [a′ + (−b)′] mod 23

Ora, a′ = a = (001)2, mentre per trovare (−b)′ trasformiamo b′ = b = (010)2applicando uno dei due metodi descritti nella precedente sezione; si trova (−b)′ =(110)2.

0 0 1 + a′

1 1 0 = (−b)′1 1 1 s′1

In modo analogo, per trovare la rappresentazione in complemento di

s2 = −a− b

la precedente proprieta ci autorizza a scrivere

s′2 = [(−a)′ + (−b)′] mod 23

poiche (−a)′ = (111)2 si ha

1 1 1

1 1 1 + (−a)′1 1 1 = (−b)′1 1 0 s′2

Overflow Se il risultato di un’operazione non rientra nel range di valori che possonoessere rappresentati diremo che il risultato ottenuto, applicando meccanicamente ilmetodo visto, e errato a causa di un overflow. Si puo dimostrare che questa circostanzadi errore puo verificarsi se e solo se entrambi gli operandi hanno lo stesso segno. Inoltreil valore - scorretto - che viene generato ha sempre segno opposto a quello, concorde,degli operandi. Quindi, si ha errore di overflow se e solo se la cifra piu significativadegli operandi e 0 mentre quella del risultato e 1, oppure tale cifra e 1 e quella delrisultato e invece 0.


Esempio 2.25. Consideriamo ora i numeri a = 2 = (010)2, b = 3 = (011)2 e lesomme algebriche s1 = a + a = 4 ed s2 = −a − b = −5. Per mostrare l’errore dioverflow scegliamo di usare solamente 3 bit in modo tale che ne s1 ne s2 possanoessere rappresentati (l’intervallo di rappresentabiiota vale [-4,3]). Troviamo anzituttoi complementi

(−2)′ = (110)2

e

(−3)′ = (101)2

Eseguendo ora la prima addizione

1←

0 1 0 + (2)′

0 1 0 = (2)′′

1 0 0 (−3)′ = (4)′

analogamente

1←

1 1 0 + (−2)′1 0 1 = (−3)′0 1 0 (2)′ = (−5)′

Quindi, entrambi i risultati sono errati. La condizione di errore si rileva osservandola generazione/assenza di riporto nell’ultima colonna. Se cin e il riporto in ingressoall’ultima colonna e cout quello in uscita, si ha overflow se e solo se cin = cout (vediSezione 2.4.2).

Moltiplicazione/Divisione

La moltiplicazione e la divisione in complemento a 2 non possono essere svolte usan-do gli algoritmi visti per la notazione in complemento, tranne nel caso speciale in cuientrambi gli operandi siamo positivi. Inoltre non vale neanche la regola per il molti-plicazione/divisione per una potenza di 2, secondo cui il risultato si ottiene traslandole cifre a destra o sinistra. Un algoritmo ampiamente usato per la moltiplicazionesi fonda sulla (ri)codifica di Booth. La sua discussione esula dall’obiettivo di questolibro; per una sua discussione si rimanda ad altri testi [PAHE].

2.6 Numeri reali

I numeri reali possono, in generale, essere rappresentati solamente in modo approssi-mato. A differenza dei numeri interi, la limitazione delle cifre a disposizione non solopone vincoli sul range di valori rappresentabili, ma anche sulla precisione. Il metododi rappresentazione usato in pratica in tutti i calcolatori e il metodo in virgola mobile.

2.6. NUMERI REALI 45

2.6.1 Rappresentazione in virgola mobile

Questo metodo di rappresentazione si basa sulla notazione scientifica. In questanotazione, un numero reale x e scritto nel seguente modo

x = f × 10E

Il valore f e dettomantissa ed E esponente. Il termine virgola mobile e dovuto al fattoche, per un fissato x, la virgola puo essere spostata di posizione agendo sull’esponente.Per mantenere x invariato, la virgola nella mantissa f si sposta a sinistra di un postose E aumenta di una unita e a destra di una posizione se E diminuisce. Ad esempio,

x = 12.34× 104 = (12.34× 104)10

10= 1.234× 105 = 123.4× 103.

La notazione scientifica consente di rappresentare valori molto ampi e molto piccoliin modo “compatto’. Ad esempio, al posto si scrivere x = 0, 000000001 si scrivex = 1 × 10−9. Facendo variare di poco il valore dell’esponente si riescono inoltre adesprimere valori anche molto diversi fra loro.

Vediamo come adattare questa notazione al caso binario. Stabiliamo anzituttouna forma normalizzata. Essa vale

f = 1.F

dove F e la parte frazionaria della mantissa.

Esempio 2.26. Rappresentiamo x = 34 in forma normalizzata. Possiamo usare il

metodo direttox = 3× 2−2 = (11)2 × 2(−10)2

Per trovare la forma normalizzata moltiplichiamo e dividiamo per 2.

x = 3× 2−22

2= 1.5× 2−1 = (1 +

1

2)× 2−1 = (1.1)2 × 2−1

2.6.2 Precisione

Il numero di cifre binarie utilizzabili nella notazione in virgola mobile e limitato.E’ importante quindi conoscere quale errore si commette quando si rappresenta unvalore reale mediante questa notazione. Dato un valore X ed una rappresentazionex, l’errore assoluto e per definizione

EA = X − x

mentre, per x = 0, si definisce errore relativo il rapporto

ϵr =EA

x

La precisione della rappresentazione e misurata dal massimo errore relativo che si puocommettere nel rappresentare X mediante x.


Vediamo come ricavare la precisione. Per prima cosa osserviamo che per un fissatoesponente E, il primo valore che si puo rappresentare vale

x0 = 1.0× 2E

e che i successivi valori si susseguono tutti a distanza

∆E = 2−p × 2E

dove p e il numero di cifre binarie di F . Infatti il successivo valore e

x1 = (1.0 . . . 01)2 × 2E = (1 + 2−p)× 2E = x0 +∆E

il terzo e

x2 = (1.0 . . . 11)2 × 2E = (1 + 2−p + 2−p)× 2E = x1 +∆E

cosi via.

Troncamento

La precisione dipende dal metodo usato per approssimare il valore X. Il metodopiu semplice e detto troncamento. In questo caso il valore esatto X e approssimatomediante il piu grande valore rappresentabile dal sistema che e inferiore ad X. L’er-rore assoluto massimo si ottiene quando X e molto vicino ad xi+1 ma viene invecerappresentato con xi, ossia EA = ∆E (Figura 2.9).

xi xi+1∆E

X = xi + ∆E- ε

xi

∆E

Figura 2.9: Calcolo della precisione nel caso di approssimazione per troncamento.

Per quanto riguarda l’errore relativo abbiamo allora

ϵr =2−p × 2E

(1.F )× 2E=

2−p

1.F

Il valore massimo dell’errore relativo, ossia la precisione, si ottiene quando ildenominatore e minimo (F=0)

ϵMAX = 2−p


Esempio 2.27. Nel caso di approssimazione per troncamento, quante cifre binariedeve avere F affinche la precisione sia almeno pari 10−9?Si ha

10−9 = 2−p

da cuip = 9× log210 ≈ 9× 3.31

e quindi p = 30

Arrotondamento

Questo metodo di approssimazione consiste nell’approssimare il valore esatto X me-diante il valore del sistema in virgola mobile ad esso piu vicino. In questo caso, l’erroreassoluto e massimo quando X si trova a meta fra xi ed xi+1 (Figura 2.10).

xi xi+1

∆E/2

2xi

X = xi + ∆E/2∆E

∆E/2

Figura 2.10: Calcolo della precisione nel caso di approssimazione per approssimazione.

Poiche il massimo errore assoluto vale ∆E

2 la precisione di questo metodo e

ϵMAX =2−p

2= 2−p−1

2.6.3 Standard IEEE 754

Lo standard IEEE 754 definisce il formato, operazioni di base, conversioni e condizionidi eccezione dell’aritmetica binaria in virgola mobile. In questa sezione verranno ripor-tate gli aspetti piu importanti dello standard. Per maggiori informazioni consultareil sito [IEEE754]. Lo standard IEEE 754 specifica 3 formati di crescente precisione:singola precisione, doppia precisione, doppia precisione estesa, ai quali si aggiunge unquarto formato, quadrupla precisione, che e uno standard de facto.

Forme normalizzata e denormalizzata

Nel forma normalizzata un numero x e codificato come

x = (−1)s × 1.F × 2Exp−bias

Il primo bit della mantissa e sempre 1 e non viene pertanto rappresentato (esso edetto bit nascosto o implicito) mentre bias e un valore costante, detto polarizzazione


o eccesso. Quindi x e codificato mediante la tripla di valori s, F,Exp. Un’altra formadefinita dallo standard e la forma Subnormale, o denormalizzata, che pone x nellaforma

x = (−1)s × 0.F × 2bias−1

Il valore Exp = 0 e riservato per indicare che x e espresso in forma denormalizzata.

La seguente tabella riporta i valori dei parametri dei due principali formati

Precisione bit segno bit Exp bit F bit totali BiasSingola 1 8 23 32 127Doppia 1 11 52 64 1023

La Figura 2.11 riporta la disposizione dei bit nei formati singola e doppia preci-sione.

S EXP F

Singola Precisione (32 bit)

31 30..............23 22...........................................................................0

S EXP F

Doppia Precisione (64 bit)31 30..............20 19...........................................................................0

F

31...................................................................................................................0

Lunghezza campi: 1,8,23

Lunghezza campi: 1,11,52

Figura 2.11: Formati in singola e doppia precisione.

Codifica di valori non numerici

Un aspetto interessante dello standard e che esso permette di esprimere i simboli ±∞piu un simbolo speciale, NaN (Not-a-Number), con il quale indicare che il risultatodi un’operazione non e un numero (ad esempio il risultato di 0

0 ). Per codificarequesti simboli lo standard ha riservato particolari valori di esponente e mantissa. ∞e codificato mediante il valore massimo dell’esponente e nullo per la mantissa, mentrela codifica di NaN si ottiene con esponente massimo ed F = 0.

Range di valori

Il range di valori e simmetrico rispetto allo zero. Il modulo del piu piccolo valorenormalizzato, xmin, si ottiene costruendo il numero con mantissa minima ed esponenteminimo. Per cui, per la singola precisione

xmin = 1.0× 2Expmin−127 = 2−126 ≈ 10−38


(il valore Exp = 0 e usato per codificare valori denormalizzati e lo zero), mentre perla doppia precisione

xmin = 1.0× 2Expmin−1023 = 2−1022 ≈ 10−308

Il modulo del massimo valore, xmax, si trova costruendo il numero con F ed esponentemassimi. In singola precisione

xmax = (1.11 . . . 1)2 × 2Expmax−127 = (2− 2−23)× 2127 ≈ 2128 ≈ 1038

Con un procedimento analogo si trova il massimo della doppia precisione, che valexmax ≈ 10308 (Figura 2.12).

Singola precisione 32 bit: 1 Segno, 8 Esponente, p=23 per F

0-(1+[1 – 2-23]) x 2127 -1 x 2-126 ≈≈≈≈ 2128

≈≈≈≈ 3.4x1038≈≈≈≈ 1.2 x 10-38

0-(1 + [1 – 2-52]) x 21023 -1 x 2-1022 ≈≈≈≈ 21024

≈≈≈≈ 1.7x10308

2-1022

Doppia precisione 64 bit: 1 Segno, 11 Esponente, p=52 per F

2-126

≈≈≈≈ 2.2 x 10-308

Figura 2.12: Range di valori per singola e doppia precisione.

Consideriamo ora i valori denormalizzati. Il piu piccolo valore in singola precisionee

x′min = 0.0 . . . 01× 2−126 = 2−23 × 2−126 = ×2−149 ≈ 10−45

ed il piu alto

x′max = 0.1 . . . 11× 2−126 = (1− 2−23)× 2−126 ≈ ×10−38

In modo del tutto simile si trovano i valori minino e massimo per la forma de-normalizzata della doppia precisione, che sono x′min = 2−1074 ≈ 10−323 e x′max =(1− 2−52)× 2−1022. Per il valore 0 lo standard riserva la codifica F = 0 e Exp = 0.

Precisione

Abbiamo gia visto che la precisione di una rappresentazione con p bit per la partefrazionaria della mantissa e, nel caso di troncamento, 2−p. La precisione del formatosingola precisione sara quindi 2−23 mentre nel formato doppia precisione 2−52. Nelcaso di approssimazione per arrotondamento i valori sono, rispettivamente, 2−24 e2−53.


Esempi di rappresentazioni

Un reale x in formato IEEE 754 consiste di tre informazioni, il segno della mantissa,s, la parte frazionaria della mantissa, F , e l’esponente polarizzato, Exp.

Esempio 2.28. La Figura 2.13 mostra come ottenere la codifica del numero 1 inSingola precisione. Si noti l’uso di cifre esadecimale per semplificare la scrittura delnumero.

– 23 bit mantissa (parte frazionaria F),

– 1 segno (S)

– 8 esponente (EXP)

– Forma normalizzata: 1.0 20 => s=1, F=0, EXP-127=0 (EXP=127)

– s=0, EXP=127=(0111111)2, F=0 = (000..0)2,

s exp F

0 01111111 00000000000000000000000

0x 3 F 8 0 0 0 0 0

3F/80/00/00

Figura 2.13: Rappresentazione del numero 1 in Singola Precisione.

Esempio 2.29. Trovare la codifica di x = 28.125 in singola precisione. Per primacosa esprimiamo il numero in binario, usando il sistema di numerazione posizionale.Scriviamo x = 28 + 0.125 e notiamo che

28 = 16 + 8 + 4 = 24 + 23 + 22 = (11100)2

e

0.125 =1

8= 2−3 = (0.001)2

Quindi x = (11100.001)2. Adesso riscriviamo x nella forma richiesta dallo standard.

x = (−1)0 × (1.1100001)2 × 24 = (−1)0 × (1.1100001)2 × 2131−127

da cui: s = 0, F = 1100001, Exp = 131 = 128 + 2 + 1 = (1000011)2. Giustapponendoi tre valori si ha

0 1100001 1000011 0...0

Raggruppando i bit in quadruple e sostituendo una quadrupla con una cifra esadeci-male, la codifica si puo scrivere nella forma compatta

0× 41E10000


Esercizio 2.3. Trovare la codifica in singola precisione di x = −7/6.Si noti che x = 7

3×2 e quindi in binario x e periodico con antiperiodo (la base comparefra i fattori primi del denominatore).

Esempio 2.30. Trovare il valore x codificato in singola precisione mediante (56700000)16

Precisione macchina

Per caratterizzare la capacita di rappresentazione di diversi sistemi in virgola mobile,viene a volte introdotto un parametro, EPS, chiamato precisione di macchina o epsilondi macchina (epsilon machine). Esso e per definizione la differenza fra 1 ed il piupiccolo valore maggiore di 1 che puo essere rappresentato nel sistema. La quantitaEPS indica la granularita di un sistema in virgola mobile.

Esempio 2.31. Trovare la precisione macchina per la rappresentazione in singolaprecisione.

In singola precisione 1 e codificato in forma normalizzata

1 = 1.0× 2127−127 = 1.0 . . . 0× 20

il valore successivo che si puo rappresentare e

1 + EPS = (1.0 . . . 01)2 × 20 = 1 + 2−23

Quindi, EPS = 2−23.

Esempio 2.32 (*). Il linguaggio C utilizza la singola precisione per rappresentarenumeri di tipo float. Per stampare la rappresentazione del numero 1 si puo usare ilseguente programma. Il programma assume la numerazione little-endian, ossia il bytepiu significativo ha offset +3 rispetto all’indirizzo del dato (vedi 8.19).

Figura 2.14: Programma in linguaggio C per stampare la rappresentazione di 1.


2.6.4 Aritmetica

Le operazioni tra due numeri in notazione scientifica, x1 = f1 × 2E1 e x2 = f2 × 2E2 ,con E2 < E1, si effettuano nel seguente modo

• x1x2 = (f1f2)2E1+E2

• x1

x2= f1

f22E1−E2

• x1 + x2 = (f1 × 2E1−E2)× 2E2 + f2 × 2E2 = (f1 × 2E1−E2 + f2)× 2E2

• x1 − x2 = (f1 × 2E1−E2)× 2E2 − f2 × 2E2 = (f1 × 2E1−E2 − f2)× 2E2

Per le operazioni di addizione/sottrazione, si agisce sulla mantissa del numero conesponente minore poiche in questo modo si limitano gli errori dovuti al numero limi-tato di cifre a disposizione. Nella trasposizione di queste regole nel formato in virgolamobile e, in generale, necessario effettuare operazioni di normalizzazione del risultato.

2.7 Codifica ASCII

Per rappresentare i caratteri all’interno dell’elaboratore e necessario associare ad ognu-no di essi un numero binario. Una codifica usata di frequente e la codifica ASCII(American Standard Code for Information Exchange) che adotta 7 bit per rappre-sentare 128 caratteri differenti. I caratteri ASCII sono suddivisi in 4 gruppi di 32caratteri.

I primi 32 caratteri, da 0 a ×1F (= 31), formano un insieme speciale di caratteri(detti caratteri di controllo), cui va aggiunto l’ultimo carattere ×7F (127) - il carattereper la cancellazione - utilizzati nella trasmissione di dati o come controllo di dispositividi stampa.

Il secondo gruppo di 32 caratteri, da ×20(= 32) a ×3F (= 63), comprende varisimboli di punteggiatura, caratteri speciali e cifre decimali. Il codice ASCII di unacifra decimale c e ×3c. Ad esempio, il codice della cifra 0 e ×30, di 1 ×31 etc; indecimale, 48, 49, etc.

Il terzo gruppo (da ×40 a ×5F ) contiene i caratteri alfabetici maiuscoli; il quartoed ultimo gruppo (da ×60 a ×7F ) i caratteri alfabetici minuscoli, ad eccezione - comevisto - dell’ultimo carattere.

Le stringhe di bit dei due codici ASCII relativi ad uno stesso carattere, minuscoloe maiuscolo, differiscono solamente per il bit in posizione 5. Ad esempio, il codicedella lettera E vale 0100 0101 (×45) ed il codice di e vale 0110 0101 (×65). In base10, tale differenza dei codici vale 32 = (00100000)2. La Figura 2.15 riporta la tabelladei codici ASCII.

La codifica ASCII estesa utilizza 8 bit. Essa raddoppia quindi i simboli rappre-sentabili, fra i quali compaiono semplici segni grafici e caratteri accentati.

2.7. CODIFICA ASCII 53

Figura 2.15: Codifica dei caratteri in codice ASCII.

Capitolo 3

Funzioni binarie

In questo capitolo studieremo le funzioni a valori binari di n variabili binarie. Unavariabile binaria e’ una variabile che assume 2 valori, 0 oppure 1. Le funzioni binariesono il modello matematico mediante cui esprimere la trasformazione di un gruppodi bit in un altro gruppo. Vedremo in particolare che tali funzioni possono essererappresentate mediante espressioni algebriche, secondo una particolare algebra, dettaalgebra di Boole. Le espressioni possono poi essere manipolate in modo simbolico;e questo consentira’ di esprimere ogni funzione mediante espressioni con particolarestruttura regolare (forma canonica), nonche’ di trovare le piu’ semplici espressionipossibili, secondo un certo criterio.

3.1 Definizione di funzione binaria

Si chiama funzione binaria (funzione booleana o funzione di commutazione) unaqualunque funzione f a valori binari di n variabili binarie

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

Ogni insieme di valori delle n variabili indipendenti e’ detto assegnazione di verita’.Questa nomenclatura e’ dovuta al fatto che storicamente questo tipo di variabili e’stato impiegato per rappresentare un valore di verita’, vero o falso.

3.1.1 Tabella di verita’

Per definire una funzione binaria si usa una tabella di verita’. Essa elenca, in formatabellare, il valore di f per ognuna delle 2n assegnazioni di verita’. Si tratta di unatabella composta da 2n righe ed n + 1 colonne (Figura 3.1). Le prime n colonnesono relative alle n variabili mentre l’ultima e’ la colonna di definizione; in essa sonoelencati i valori della funzione.

Esempio 3.1. La seguente tabella definisce la funzione di 3 variabili booleane chevale 1 se e solo se il numero delle variabili indipendenti che valgono 1 e’ dispari.

55

56 CAPITOLO 3. FUNZIONI BINARIE

2n assegnazioni di verità

n variabili valori della funzione

.

.

.

Figura 3.1: Tabella di verita’ di una funzione ad n variabili.

x2 x1 x0 f(x2, x1, x0)0 0 0 00 0 1 10 1 0 10 1 1 01 0 0 11 0 1 01 1 0 01 1 1 1

Per indicare in modo succinto il valore degli argomenti di una funzione si sostituiscel’elenco dei valori delle variabili indipendenti con il valore intero che si ottiene unavolta che si sia interpretato ogni valore come cifra binaria. Ad esempio, per unafunzione di n = 7 variabili al posto di scrivere

f(1, 0, 1, 1, 0, 1, 0)

possiamo scriveref(90)

poiche’ (1, 0, 1, 1, 0, 1, 0)2 = 90.

3.1.2 Numero di funzioni

Puo’ avere un qualche interesse sapere quante sono le possibili funzioni di n variabilie come possano essere generate1.

Funzioni unarie

Iniziamo con il considerare tutte le possibili funzioni booleane ad un solo argomento

y = f(x)

1Ad esempio, questo puo’ ritornarci utile quando si vuole realizzare un circuito elettronico cheimplementi tutte le funzioni.

3.1. DEFINIZIONE DI FUNZIONE BINARIA 57

0

0

0

0

y0

0

0

0

1

y1

0

0

1

0

y2

0

0

1

1

y3

0

1

0

0

y4

0

1

0

1

y5

0

1

1

0

y6

0

1

1

1

y7

1

0

0

0

y8

1

0

0

1

y9

1

0

1

0

y10

1

0

1

1

y11

1

1

0

0

Y12

1

1

0

1

y13

1

1

1

0

y14

1

1

1

1

y15

01

10

11

00

x2x1

x1

yx2

ANDOR

NOT x2 NOT x10 1

OR

AND

Figura 3.2: Elenco delle funzioni di due variabili.

Bisogna associare un valore di uscita, y, per ogni valore d’ingresso, x. Ora, duefunzioni sono diverse se le rispettive colonne di definizione nelle tabelle di verita’ sonodiverse. Questo vuol dire che se interpretiamo i valori che appaiono nella colonna didefinizione come numeri interi espressi in binario, allora affinche’ due funzioni sianodiverse questi numeri devono essere diversi. Poiche’ la colonna di definizione ha dueelementi, possiamo costruire 22 = 4 differenti numeri binari. Quindi le funzioni ad unsolo argomento sono 4 e sono quelle elencate nella seguente tabella.

x y0 y1 y2 y30 0 1 0 11 0 0 1 1

Funzioni binarie

Consideriamo ora le funzioni a due variabili

y = f(x1, x0)

La colonna di definizione nella tabella di verita’ e’ composta da 4 elementi; pertanto sipossono costruire 24 = 16 numeri binari differenti e definire cosi altrettante funzioni.Ogni funzione puo’ essere identificata proprio da questo numero, espresso in basedieci, letto secondo un ordine prestabilito - per esempio dall’alto verso in basso. Le16 funzioni sono elencate nella Figura 6.29. Per alcune funzioni sono stati inseriti iloro nomi convenzionali (si veda il Capitolo successivo)

E’ facile trovare, per generalizzazione, il numero di funzioni ad n variabili. Poiche’la colonna di definizione di una funzione ad n variabili e’ composta da m = 2n

elementi, ed i valori differenti che si possono esprimere mediante m cifre binarie sono2m, le possibili funzioni di n variabili binarie sono

22n


Nei prossimi paragrafi vedremo che una qualunque funzione booleana di n variabilipuo’ essere definita mediante un’espressione algebrica. L’algebra da utilizzare e’ unparticolare tipo di algebra di Boole, detta algebra di commutazione. L’ algebra di Boo-le e’ cosi chiamata in onore del matematico inglese George Boole (1815-1864) che l’haintrodotta per provare algebricamente la verita’ o la falsita’ di proposizioni complesseottenute combinando, mediante operatori logici, proposizioni piu’ semplici di cui sipostulava la verita’ o falsita’ (i circuiti elettronici elementari che realizzano operatorialgebrici sono detti porte logiche in relazione proprio alle origini dell’algebra).

3.2 Algebra di Boole

Cominciamo col dare una definizione assiomatica dell’algebra di Boole. Un’algebra diBoole e’ definita mediante un insieme di supporto, S, e due operatori binari indicatimediante i simboli + (somma) e · (prodotto) 2.

3.2.1 Assiomi dell’algebra

Gli operatori dell’algebra godono, per definizione, delle seguenti proprieta’

1. Le operazioni somma e prodotto sono commutative: per ogni a, b ∈ S,

a+ b = b+ a a · b = b · a

2. La somma e’ distributiva rispetto al prodotto ed il prodotto e’ distributivorispetto alla somma: per ogni a, b, c ∈ S,

a · (b+ c) = (a · b) + (a · c) a+ (b · c) = (a+ b) · (a+ c)

3. S possiede l’elemento neutro per la somma (indicato con 0) l’elemento neutroper il prodotto (indicato con 1), tali che per ogni a ∈ S

a+ 0 = a a · 1 = a

4. Ogni elemento a ∈ S ammette un elemento inverso, a′, tale che

a+ a′ = 1 a · a′ = 0

Principio di dualita’

I precedenti assiomi sono formati da coppie “duali”. Se in un assioma qualsiasi siscambiano fra loro, sintatticamente,

+ con ·1 con 0

2Affinche’ un’algebra possa esistere si puo’ dimostrate che il numero di elementi di S deve essereuna potenza di due.

3.3. ESPRESSIONI BOOLEANE 59

allora si ottiene l’altro assioma della coppia. Ad ogni proprieta’ che si puo’ dimostrareapplicando particolari assiomi ne corrisponde quindi un’ altra, chiamata duale, che siottiene con i suddetti scambi. Infatti, poiche’ la validita’ della proprieta’ si dimostraapplicando successivamente alcuni assiomi, allora l’applicazione degli assiomi dualiportera’ a dimostrare la proprieta’ duale.

3.2.2 Algebra di commutazione

Un’algebra di Boole sul supporto S = {0, 1} viene detta algebra di commutazione.La definizione degli operatori somma e prodotto discende direttamente dagli assiomi

a b a+ b a · b0 0 0 00 1 1 01 0 1 01 1 1 1

Inoltre, l’inverso di un elemento e’ definito mediante l’operatore not − (o complemen-to) secondo la seguente tabella di verita’

a a0 11 0

L’algebra di commutazione di presta bene a modellare sistemi i cui elementi posso-no assumere due soli stati; ad esempio, on/off (interruttore), luce spenta/ luce accesa,vero/falso. La Figura 3.3 riporta la descrizione di un semplice circuito elettrico, com-posto da due deviatori, A e B, ed una lampadina L. Se con L = 1 (L = 0) indichiamoche lampadina e’ accesa (spenta), e lo stato e’ indicato come in figura, allora

L = AB +A B

e’ un modello algebrico del circuito. La lampadina e’ accesso quando entrambi gliinterruttori sono nello stesso stato.

3.3 Espressioni booleane

In questa sezione studieremo le espressioni booleane. Vediamo come costruire, sintat-ticamente, espressioni booleane. Le costanti 0 ed 1 e le variabili booleane sono, perdefinizione, espressioni. Inoltre, se E ed F sono espressioni, allora lo sono anche

E E + F E · F

Nelle espressioni possono apparire le parentesi secondo le regole dell’algebra ele-mentare. Nel seguito per comodita’ l’operatore · verra’ omesso ed il prodotto indicatogiustapponendo i suoi operandi.


AB

0 0

11

L

L = AB + A B

Figura 3.3: Un semplice circuito elettrico i cui elementi sono binari (possono cioe’essere in due soli stati differenti). Il funzionamento del circuito puo’ essere espressomediante una funzione binaria.

Esempio 3.2. Se a, b, c, d, x, y, z sono variabili booleane, sono espressioni le seguenti

(x+ y)z

(ab) + (c+ d)

(ab) + b

mentre non lo sonoa+

e+c

3.3.1 Espressioni equivalenti

Come per l’algebra classica, due espressioni sono dette equivalenti se esse fornisco lostesso risultato per tutti i valori che le variabili possono assumere.

A partire da un’espressione E e’ quindi interessante capire come ricavarne un’al-tra equivalente, E′, ma che sia “semplice” nonche’ individuare, fra tutte le espressioniequivalenti, la migliore in assoluto, secondo un certo criterio di valutazione. La que-stione della semplificazione verra’ affrontata al termine del capitolo. Per il momentoaccetteremo la nozione intuitiva secondo la quale E′ e’ piu’ semplice di E se e’ piu’corta, contiene cioe’ meno varibili.

Esempio 3.3. Le espressioni E = a+ ab e E′ = a+ b sono equivalenti. Infatti

a b a E = a+ ab E′ = a+ b0 0 1 0+10=0 0+0=00 1 1 0+11=1 0+1=11 0 0 1+00=1 1+0=11 1 0 1+10=1 1+1 =1

3.3. ESPRESSIONI BOOLEANE 61

L’espressione E′ e’ pero’ piu’ semplice di E, perche’ il secondo termine contiene unavariabile in meno.

Esempio 3.4. Proviamo che ab+ ba = a. Applicando gli assiomi 2, 4 e 3, si ha

ab+ ab = a(b+ b) = a1 = a

Nella semplificazione delle espressioni torna spesso utile usare i seguenti teoremi.

Alcune teoremi dell’algebra di Boole

Per ogni coppia di variabili x ed y valgono i seguenti teoremix+ x = x xx = x Idempotenzax+ (xy) = x x(x+ y) = x Assorbimento

(x+ y) = x y (xy) = x+ y De Morganx = x Doppia negazione

Si noti che i teoremi sono duali, ad eccezione dell’ultimo che e’ autoduale.

Esempio 3.5. Semplificare l’espressione

(a+ ab)(c+ c)d

L’espressione puo’ essere semplificata tenendo presente che

a+ ab = a

per via del teorema dell’assorbimento; che

c+ c = 1

per via dell’assioma 4 , ed infine

a1 = a

per via dell’assioma 3. Per cui risulta

(a+ ab)(c+ c)d = a1d = ad

3.3.2 Mintermini e maxtermini

Introduciamo adesso due forme di espressioni particolarmente utili in seguito.

Definizione 1 (mintermine). Un mintermine (o prodotto fondamentale) su n varia-bili binarie, e’ un’espressione composta dal prodotto di tutte le n variabili dirette onegate.

Ad esempio, l’espressione

x3x2x1x0

e’ un mintermine su 4 variabili binarie.


Identificazione dei mintermini

Per come e’ stato definito, il valore di un mintermine vale 1 se e solo se le variabilidirette assumono il valore 1 e le negate il valore 0. Un modo comodo per identificareimmediatemente un mintermine e’ utilizzare proprio questa configurazione di variabilicome un indice. Piu’ precisamente il mintermine mi vale 1 solo quando le n variabiliindipendenti, interpretate come valore numerico, esprimono il valore intero i.

Ad esempio, e’ facile verificare che

x3x2x1x0

vale 1 solo sex3 = 1, x2 = 1, x1 = 0, x0 = 0

poiche’1100 = 1

Dal momento che (1100)2 rappresenta il valore 12, il precendente mintermine e’indicato succintamente mediante il simbolo

m12

Nell’usare questo metodo di identificazione e’ necessario conoscere il numero dellevariabili sulle quali e’ definito il mintermine.

Numero di mintermini

Il numero di mintermini di n variabili vale 2n. Questo e’ infatti il numero di indicidifferenti che possono essere espressi mediante n cifre.

Esempio 3.6. La Figura 6.29 riporta tutte le possibili funzioni di due variabili. I 4mintermi di due variabili corrispondono alle seguenti funzioni

m0 = y1,m1 = y2,m2 = y4,m3 = y8

Definizione 2 (maxtermine). Un maxtermine (o somma fondamentale) su n variablebinarie e’ un’espressione composta dalla somma di tutte le variabili dirette o negate

Ad esempiox3 + x2 + x1 + x0

e’ un maxtermine.

Identificazione dei maxtermini

Come per i mintermini, i maxtermini sono individuati succintamente mediante unindice i che codifica in binario l’unica configurazione d’ingresso che produce il valore0. Ad esempio, la precedente espressione altro non e’ che M4 poiche’ 4 = (0100)2 e

0 + 1 + 0 + 0 = 0

Si osservi che Mi = mi.

3.4. ESPRESSIONI CANONICHE 63

Esempio 3.7. Determinare i mintermi e maxtermini di una funzione di tre variabili.

x2 x1 x0 MINTERMINE MAXTERMINE0 0 0 m0 = x2x1x0 M0 = x2 + x1 + x0

0 0 1 m1 = x2x1x0 M1 = x2 + x1 + x0

0 1 0 m2 = x2x1x0 M2 = x2 + x1 + x0

0 1 1 m3 = x2x1x0 M3 = x2 + x1 + x0

1 0 0 m4 = x2x1x4 M0 = x2 + x1 + x0

1 0 1 m5 = x2x1x0 M5 = x2 + x1 + x0

1 1 0 m6 = x2x1x0 M6 = x2 + x1 + x0

1 1 1 m7 = x2x1x0 M7 = x2 + x1 + x0

Maschere

Un modo meccanico per scrivere il mintermine mi consiste nell’utilizzare la rappre-sentazione binaria di i come “maschera” di bit. Posta tale maschera sopra il prodottodelle variabili, si invertono tutte quelle cui e’ associato uno 0. Per il maxtermineMi questa regola va invertita (in questo caso il valore 1 provoca la negazione dellavariabile).

Ad esempio, i = 5 corrisponde alla maschera 101. Quindi m5 e’ dato da

1 0 1x2 x1 x0

mentre il maxtermine M5 e’

1 0 1x2 + x1 + x0

3.4 Espressioni canoniche

L’importanza dei mintermini e dei maxtermini risiede nel fatto che per una qualunquefunzione e’ possibile trovare un’espressione equivalente composta da soli mintermi o dasoli maxtermini. Prima di dare in modo formale questo risultato consideriamo comeesempio la funzione di parita’ y di tre variabili, che vale 1 solo quando il numero divariabili con valore 1 e’ pari. La Figura 3.4 riporta la tabella di verita’ della funzione.

A fianco alla colonna di definizione della funzione sono stati riportati alcuni min-termini. Un minermine appare solo quando la funzione vale 1 ed il suo indice codifical’assegnazione di verita’ per la quale la funzione vale 1. Possiamo adesso constatareche

y = m0 +m3 +m5 +m6

come riportato in Figura 3.5 nella quale la tabella di destra riporta le colonne didefinizione dei vari mintermini.

Vediamo ora come la stessa funzione sia equivalente ad un’espressione compostadal prodotto di maxtermini. I maxtermini da selezionare sono quelli il cui indice


m3

m0

m5

m6

0

1

2

3

4

5

6

7 0111

1011

1101

0001

1110

0010

0100

1000

x3 x2 x1 y

Figura 3.4: Funzione di parita’ definita su 3 variabili binarie.

m3m0m5 m6

0000

1000

0100

0000

0010

0000

0000

0001

0111

1011

1101

0001

1110

0010

0100

10000

1

2

3

4

5

6

7

x3 x2 x1 y

Figura 3.5: Verifica dell’equivalenza fra la funzione y e l’espressione algebrica ottenutacome somma di mintermini.

e’ l’assegnazione di verita’ che rende la funzione nulla (Figura 3.6). Nella figura e’riportata l’intera espressione. L’indice del maxtermine e’ sfruttato come maschera(vedi prima) per scrivere esplicitamente i maxtermini.

La Figura 3.7 mostra una dimostrazione grafica dell’equivalenza fra y e l’espres-sione costituita dalla somma dei maxtermini.

3.4.1 Forma canonica Somma di Prodotti (SP)

Teorema 3.1. Sia f una funzione binaria di n variabili. Vale la seguente eguaglianza

f(i) =∑

i:f(i)=1

mi

dove il simbolo∑

e’ da intendersi come somma booleana.

Grazie a questo teorema ogni funzione puo’ essere rappresentata algebricamentemediante somma di mintermini. Questa particolare forma prende il nome di Sommadi Prodotti (SP).

Dimostrazione Per la dimostrazione e’ sufficiente applicare iterativamente il se-guente risultato, noto come teorema di Shannon

f(x1, x2, . . . , xn) = xif(x1, x2, . . . , 1, . . . , xn) + xif(x1, x2, . . . , 0, . . . , xn)


M2

M1

M4

M7

y =M1M2M4M7

f(x1,x2,x3) =(x3+x2+ x1) (x3 + x2 + x1) ( x3 + x2 + x1 )) ( x3 + x2 + x1)

0111

1011

1101

0001

1110

0010

0100

10000

1

2

3

4

5

6

7

x3 x2 x1 y

001 010 100 111

Figura 3.6: Funzione di parita’ espressa come prodotto di Maxtermini.

M2M1 M4 M7

0111

1111

1111

1011

1111

1101

1110

1111

M2

M1

M4

M70111

1011

1101

0001

1110

0010

0100

10000

1

2

3

4

5

6

7

x3 x2 x1 y

Figura 3.7: Verifica dell’equivalenza fra la funzione y e l’espressione algebrica ottenutacome prodotto di maxtermini.

che puo’ essere dimostrato agevolmente verificando le due identita’ per xi = 1 edxi = 0 (induzione perfetta).

Esempio 3.8. Esprimere la funzione f(x2, x1, x0) = x2 + x1x0 in forma SP.Per far apparire tutte le variabili, moltiplichiamo il primo termine per

(x1 + x1)(x0 + x0)

ed il secondo per

(x2 + x2)

Questa operazione non altera la funzione, poiche’ in generale, se x e’ una variabilebinaria,

(x+ x) = 1

Pertanto

f(x2, x1, x0) = (x2 + x1)(x0 + x0)x2 + x1x0(x2 + x2)


applicando la proprieta’ distributiva

f(x2, x1, x0) = x2x1x0 + x2x1x0 + x2x1x0 + x2x1x0 + x2x1x0 + x2x1x0

da cui, eliminando la ripetizione del termine

x0x1x0

f(x2, x1, x0) = x2x1x0 + x2x1x0 + x2x1x0 + x2x1x0 + x2x1x0

Ossiaf(x2, x1, x0) = m7 +m6 +m5 +m4 +m1

dal momento che

m7 = x2x1x0,m6 = x2x1x0,m5 = x2x1x0,m4 = x2x1x0,m1 = x2x1x0

Un modo comodo per trovare la forma SP e’ sfruttare la tabella di verita’ chedefinisce la funzione, come fatto in Figura 3.4. Ispezionando la tabella, e’ immediatovedere le configurazioni di ingresso per le quali la funzione vale 1. Queste configurazio-ni, interpretate come numero intero, fornisco immediatamente l’indice dei minterminida inserire nella forma SP.

Esempio 3.9. Esprimere in forma SP la funzione

y = f(x2, x1, x0) = x2 + x1x0

Troviamo anzitutto la tabella di verita’ assegnando tutti i possibili valori alle variabilied eseguendo i calcoli algebrici (per comodita’ sono riportati anche calcoli intermedi)

x2 x1 x0 x1x0 x2 + x1x0 y0 0 0 0 00 = 0 0+0=0 01 0 0 1 01 = 1 1+1=1 12 0 1 0 10 = 0 0+0=0 03 0 1 1 11 = 0 0+0=0 04 1 0 0 00 = 0 1+0=1 15 1 0 1 01 = 1 1+1=1 16 1 1 0 10 = 0 1+0=1 17 1 1 1 11 = 0 1+0=1 1

Dopodiche’ selezioniamo gli assegnamenti per i quali y = 1; essi sono 1, 4, 5, 6, 7. Percui

y = m1 +m4 +m5 +m6 +m7

Applicando la tecnica della maschera

1 4 5 6 7︷︸︸︷001

︷︸︸︷100

︷︸︸︷101

︷︸︸︷110

︷︸︸︷111

y = x2x1x0 + x2x1x1 + x2x1x0 + x2x1x0 + x2x1x0


Un modo compatto per esprimere la funzione e’ scrivere

y = Σ4(1, 4, 5, 6, 7)

dove∑

indica il fatto che stiamo usando la forma canonica somma di prodotti e chei mintermini sono definiti su 4 variabili. L’indice puo’ essere omesso se il numero divariabili e’ noto dal contesto.

3.4.2 Forma canonica Prodotto di Somme (PS)

Si tratta della forma duale di SP.

Teorema 3.2. Sia f una funzione binaria di n variabili. Vale la seguente eguaglianza

f(i) =∏

i:f(i)=0

Mi

dove il simbolo∏

e’ da intendersi come prodotto booleano.

Dimostrazione Questo risultato si puo’ dimostrare nel seguente modo. Scriviamola funzione complementare di f , f , in forma SP

f(i) =∑

i:f(i)=1

mi =∑

i:f(i)=0

mi

I mintermini che appaiano della somma sono quelli che rendono f(i) = 1 e cioe’f(i) = 0. Applicando De Morgan,

f(i) = f(i) =∑

i:f(i)=0

mi =∏

i:f(i)=0

mi =∏

i:f(i)=0

Mi

Esempio 3.10. Scrivere in forma PS la funzione

y = f(x2, x1, x0) = x2 + x1x0

Abbiamo gia’ visto che

y =∑

(1, 4, 5, 6, 7)

Pertantoy =

∑(0, 2, 3)

da cuiy = M0M2M3

La notazione compatta per esprimere la forma PS e’

y = Π4(0, 2, 3)

dove l’indice indica il numero di variabili sulle quali si definisce il maxtermine. Quindi

f(x2, x1, x0) = (x2 + x1 + x0)(x2 + x1 + x0)(x2 + x1 + x0)


3.5 Operatori universali

Le forme SP e la duale PS consentono di scrivere una qualunque funzione median-te gli operatori {−,+, ·}. Per indicare questo fatto, l’insieme dei tre operatori sidice completo. Questo insieme e’ sovrabbondante. L’operatore + si puo’ otteneredall’operatore · e dalla negazione. Infatti, applicando De Morgan

(x1x2) = x1 + x2 = x1 + x2

In modo duale l’operatore · si puo’ ottenere dall’operatore + e dalla negazione

(x1 + x2) = x1 · x2

La coppia di operatori not e dell’operatore + oppure · forma quindi un altro insiemecompleto di operatori. Si puo’ dimostrare che questo insieme non e’ ridondante.

Esiste un operatore universale, ossia mediante il quale sia possibile definire qua-lunque funzione booleana? Se esso esiste e’ sufficiente che sia in grado di simulare uninsieme completo di operatori. La risposta e’ affermativa.

Il primo operatore universale e’ l’operatore “non entrambi”, o barra, definito nelseguente modo

x1|x2.= (x1x2)

da cui0|0 = 1 0|1 = 1 1|0 = 1 1|1 = 0

ossia, x1|x2 e’ 1 se e solo se non entrambi gli operandi x1 e x2 sono pari ad 1.Applicando De Morgan alla definizione dell’operando, troviamo che

x1|x2 = x1 + x2

e quindi chex1|x2 = x1 + x2

Il secondo operatore universale e’ l’operatore “nessuno”, o freccia, definito come segue

x1 ↓ x2.= (x1 + x2)

da cui0 ↓ 0 = 1 0 ↓ 1 = 0 1 ↓ 0 = 0 1 ↓ 1 = 0

ossia, x1 ↓ x2 e’ 1 se e solo se nessun operando vale 1. Applicando De Morgan,

x1 ↓ x2 = x1x2

e quindix1 ↓ x2 = x1x2

Gli operatori sono in grado di simulare il not

x|x = x+ x = x x ↓ x = xx = x

abbiamo cosi dimostrato che sono universali: per una data funzione f e’ possibilescrivere un’espressione equivalente composta da nella quale compare un solo operatoreuniversale.

3.6. ESPRESSIONI MINIME 69

1

3

1

0

1

0

0 1

0 1

1 0

1 0

x1 x0 y

12

00

0 1x0

x10

1

2

3

1

0

0 1x0

x1

1 1

(a) (b)

(c)

Figura 3.8: Relazione fra mappa di Karnaugh e tabella di verita’.(a) tabella di verita’;(b) disposizione delle celle; (c) definizione della stessa funzione mediante MK. E’ prassiindicare nella MK solo gli 1 della funzione.

3.6 Espressioni minime

Abbiamo visto come un’espressione algebrica possa essere semplificata sfruttando al-cuni teoremi dell’algebra. Lo scopo della semplificazione e’ trasformare l’espressionedi partenza in una equivalente, ma piu’ “corta”. Pervenire ad espressioni sempli-ci e’ importante poiche’, come vedremo nel prossimo capitolo, ad ogni espressionecorrisponde un diverso circuito digitale che la realizza; pertanto espressioni semplicicorrispondono a circuiti piu’ semplici.

Studiamo adesso un metodo per derivare, a partire dalla definizione di una funzionead n variabili, un’espressione booleana con forma

f = p1 + p2 + . . . pk (3.1)

dove il termine pi e’ dato dal prodotto di i ≤ n letterali ed un letterale e’ o unavariabile indipendente della funzione o il negato di una variabile. Il termine pi sichiama implicante, poiche’ se pi = 1 allora f = 1.

Il metodo, detto delle mappe di Karnaugh, consente di pervenire alla piu’ cortaespressione possibile che abbia la forma suddetta; in modo piu’ preciso il metodoconsente di trovare l’espressione con il minor numero possibile di implicanti e con ilminor numero totale di letterali.

3.6.1 Mappe di Karnaugh

Relazione fra MK e tabella di verita’

Una Mappa di Karnaugh (MK) e’ anzitutto un modo alternativo per rappresentarela tabella di verita’ di una funzione. Essa contiene cioe’ esattamente le stesse infor-mazioni della tabella, ma disposte in modo differente. Una mappa di una funzione adn variabili e’ composta da 2n caselle o celle.


11

10

10

00

X0

X1

X0

X1

(a) (b)

0

0 0

0 11

1

Figura 3.9: Le funzioni definite dagli operatori x1+x0 e x1x0 rappresentate mediantemappe di Karnaugh.

Nella MK, ogni riga della tabella di verita’ corrisponde ad una cella. La riga 0corrisponde alla cella numero 0, la riga 1 alla cella numero 1 etc (Figura 3.8).

La Figura 3.9 mostra come sono rappresentati nella mappa il maxtermine

x1 + x0

ed il mintermine

x1x0

Il primo pone nella mappa il numero massimo di caselle, ossia tutte meno una; ilsecondo il numero minino, ossia un solo 1. Proprio per tale motivo essi sono chiamatimaxtermine e mintermine. Per semplicita’, nel seguito nella mappa saranno indicatisolamente gli 1 della funzione.

Disposizione delle celle

Le celle delle MK sono disposte in modo da agevolare la semplificazione della funzionemediante una semplice ispezione grafica della mappa. Abbiamo visto che un minter-mine corrisponde nella mappa ad un solo 1. La caratteristica essenziale di una MK e’disporre le caselle in modo che caselle adiacenti orizzontalmente e verticalmente cor-rispondano a minermini che differiscono di una sola variabile, nel senso che se in unmintermine tale variabile appare diretta nell’altro appare negata e viceversa. Questaadiacenza grafica fra minermini simili e’ la chiave della semplificazione “ad occhio”,come spiegato in seguito.

Questo si ottiene facendo in modo che due celle adiacenti abbiano coordinate chedifferiscano per un solo bit. Infatti le coordinate di una casella sono la maschera dausare per formare il mintermine, e la maschera determina proprio se una variabileappare nel mintermine in forma diretta o negata.

La numerazione delle righe/colonne e’ riportata in Figura 3.10 per mappe fino a4 variabili, valore massimo che prenderemo in considerazione per mantenere il pregiodella semplicita’ di questa tecnica.

3.6. ESPRESSIONI MINIME 71

x0x1

x0

x2 x1

x1 x0

x3 x2

0 1

0

1

00

01

11

10

0 1

00

01

11

10

00 01 11 10

Figura 3.10: Esempi mappe di Karnaugh per funzioni di 2,3,4 variabili.

Semplificazione di una funzione

Le mappe di Karnaugh sono utili perche’ agevolano la semplificazione di una funzionemanualmente (di fatto sulla base dell’esperienza). La forma semplificata cui si arrivaattraverso la mappa e’ una somma di termini prodotto (Equazione 3.1).

L’osservazione chiave alla base della semplificazione e’ che, per come e’ costruitala mappa, le celle di due mintermini di forma Ax e Ax occupano posizioni adiacenti.Per cui se queste celle contengono un uno, si puo’ eseguire la seguente semplificazione.

Ax+Ax = A(x+ x) = A

Graficamente, questa semplificazione si denota cerchiando sulla mappa le caselle deidue mintermini.

Esempio 3.11. La figura 3.11 mostra alcune semplificazioni su mappa a 3 variabili.La prima mappa, quella piu’ a sinistra, e’ relativa ad una funzione con forma canonica

y = x2x1x0 + x2x1x0 = m6 +m7

Se si opera algebricamente si trova che

y1 = x2x1x0 + x2x1x0 = x2x1(x0 + x0) = x2x1

Questo procedimento e’ visualizzato sulla mappa con un ovale tratteggiato. La variabileche scompare nella forma semplificata, x0 nel nostro esempio, e’ quella il cui valoresulla mappa varia da 0 ad 1.

La figura di centro definisce la funzione di forma SP

y2 = m5 +m6 +m7

che e’ equivalente ay2 = m5 +m6 +m7 +m7

Essa mette in evidenza le due semplificazioni

m5 +m7 = x2x1x0 + x2x1x0 = x2x0

em6 +m7 = x2x1x0 + x2x1x0 = x2x1


00

10

11

00

x0

x2 x1

00

01

11

10

0 1

10

10

11

00

x0

x2 x1

00

01

11

10

0 1

00

00

11

00

x0

x2 x1

00

01

11

10

0 1

m6

m7

m6

m7

m5

m6

m5

m7

m1

Figura 3.11: Alcune semplificazioni su mappa di Karnaugh.

per cui:y2 = x2x0 + x2x1

Infine la mappa di destra mostra come semplificare

y3 = m1 +m5 +m6 +m7

L’espressione cui si perviene e’

y3 = x1x0 + x2x0 + x2x1

Abbiamo visto come e’ possibile raggruppare due caselle adiacenti in una mappacol risultato di ottenere un termine da cui e’ stata eliminata una variabile. Le duecelle sono fuse in un unico blocco; ed il temine trovato mette un 1 nel blocco fuso. Inmodo analogo si possono combinare 2n caselle adiacenti per ottenere un unico termineche mette un uno nel blocco. Nel termine sono state eliminate n variabili.

Esempio 3.12. La figura 3.12 mostra due semplificazioni guidate da mappe di Kar-naugh per una funzione a 4 variabili. In ogni mappa sono indicati mediante pi itermini prodotto associati alle aree circondate nella mappa.

Il prodotto p1 = x3x2x1x0 e p4 = x3x2x1x0 ricoprono una sola casella (si trattainfatti di mintermini); mentre p2 = x3x1 e p3 = x3x1 ne ricoprono 4 (ogni terminepi si ottiene costruendo un prodotto con le sole variabili che non variano nel bloccocoperto; le rimanenti variabili sono prese dirette o negate a seconda che il valore nellacolonna o riga sia 1 oppure 0);

La semplificazione migliore e’ riportata a destra. Essa consente di scrivere

y = x3 + x2x1x0 + x2x1x0

L’ultimo esempio ha messo in evidenza che conviene individuare nella mappa lecaselle piu’ ampie possibili, poiche’ ad esse corrispondono termini col minor numerodi letterali (implicanti primi).

Il procedimento di semplificazione guidato da una MK puo’ essere riassunto daiseguenti principi


1

1

0

0

1

1

1

0 01

11

11

00

x1 x0

x3 x2

00

01

11

10

00 01 11 10

1

1

0

0

1

1

1

0 01

11

11

00

x1 x0

x3 x2

00

01

11

10

00 01 11 10

p2p3 p1

p3 p2

p1p4

Figura 3.12: Due semplificazioni su mappa di Karnaugh da 4 variabili.

1. Bisogna ricoprire almeno una volta tutte le caselle della mappa che contengonoun 1

2. La copertura deve avvenire raggruppando blocchi di 1 adiacenti (dove un bloccoe’ costituito da una potenza di 2 di caselle) in modo tale che ciascun blocco sia ilpiu’ ampio possibile e ciascuna casella sia contenuto nel numero minore possibiledi blocchi


1. Cos’e’ una variabile binaria?

2. Cos’e’ un’assegnazione di verita’?

3. Cos’e’ una tabella di verita’?

4. Cosa si intende per principio di dualita’?

5. Cos’e’ un mintermine? ed un maxtermine?

6. Cosa si intende per espressioni equivalenti?

7. Cos’e’ la forma SP? e la forma PS?

8. Quali sono gli operatori universali?

9. Perche’ l’operatore somma non e’ universale?

10. Cos’e’ una mappa di Karnaugh?

Capitolo 4

Reti combinatorie

All’inizio del libro abbiamo definito un calcolatore come un sistema elettronico digi-tale, per sottolineare il fatto che la tecnologia sfruttata per realizzare il calcolatore e’la tecnologia dei circuiti elettronici digitali. Tali circuiti sono caratterizzati dal fattoche i segnali presenti nel circuito, cioe’ le varie tensioni e correnti elettriche, assumodue soli valori significativi, un valore alto (H, High) ed uno basso (L, Low); ossia sonobinari. Questi segnali binari cambiano valore, idealmente, in modo istantaneo.

Se conveniamo di interpretare un livello di tensione come rappresentazione delvalore logico 0 (di norma L) e l’altro come rappresentazione del livello logico 1 pos-siamo allora usare circuiti digitali per costruire le cosiddette reti logiche, sistemi chetrasformano un insieme di segnali binari applicati al loro ingresso in altro insieme disegnali binari1.

Questo capitolo e’ dedicato alle reti combinatorie, una particolare classe di retilogiche, in grado di realizzare le funzioni binarie discusse nel capitolo precedente.

Una rete combinatoria e’ dotata di n linee di ingresso x1, x2, . . . , xn ed m lineed’uscita, y1, y2, . . . , ym, vedi Figura 4.1.

.

.

.

.

.

.

x1x2

xn

y1y2

ym

RETE COMBINATORIA

Figura 4.1: Rete combinatoria con n linee di ingresso ed m di uscita.

La caratteristica di questo circuito consiste nel fatto che ciascun segnale di uscitadipende unicamente dagli n valori dei segnali di ingresso. Il circuito non ha memoria.La rete genera la medesima uscita ogni volta che gli stessi segnali sono applicati in

1La convenzione che rappresenta il valore logico 0 mediante L - e quindi 1 mediante H - e’ dettalogica positiva; se invece il valore 0 viene rappresentato mediante H si parla di logica negativa.

75

76 CAPITOLO 4. RETI COMBINATORIE

ingresso. La relazione fra i valori di ingresso e quelli di uscita puo’ quindi esseredescritta algebricamente mediante m funzioni binarie, una per ciascuna uscita, di nvariabili binarie.

Studieremo inizialmente gli elementi di base di una rete logica, ossia le cosiddetteporte logiche. Vedremo poi come realizzare una rete combinatoria collegando insiemepiu’ porte logiche. In particolare vedremo alcune reti combinatorie notevoli, cui da-remo il nome di moduli combinatori di base. Il Capitolo si conclude mostrando comerealizzare, mediante l’aggregazione di moduli di base e porte logiche, una sempliceALU.

4.1 Porte logiche

Le reti combinatorie sono realizzate mediante l’interconnessione di porte logiche. Unaporta realizza una funzione booleana di 2 o piu’ variabili, ad eccezione della portaNOT che realizza la negazione e dispone di un solo ingresso. Possiamo pensare alleporte logiche come alla materializzazione degli operatori dell’algebra booleana.

Porta NOT

La porta NOT, detta anche negatore o invertitore, e’ la piu’ semplice porta logica.Essa dispone di un solo ingresso ed una sola uscita. La porta realizza l’operatorecomplemento dell’algebra booleana. Il nome della porta e’ legato al fatto che, sesi interpretano 1 e 0 come valori di verita’, l’uscita della porta e’ pari alla negazione(logica) dell’ingresso. Il simbolo grafico e la tabella di verita’ della porta sono riportatiin Figura 9.6

01

10

yxx y

(a) (b)

Figura 4.2: (a) simbolo grafico della porta logica not; (b) tabella di verita’.

La porta realizza l’espressione booleana

y = x

Porta AND

La porta logica AND realizza l’operatore prodotto dell’algebra di Boole. La tabelladi verita’ ed il simbolo della porta sono riportati in Figura 4.3. La porta realizzal’espressione

y = x1x2

4.1. PORTE LOGICHE 77

001

010

1

0

x2

11

00

yx1

(a) (b)

x1

x2y

Figura 4.3: Simbolo grafico della porta logica AND (a) e tabella di verita’(b).

Questa porta e’ a volte sfruttata come porta di controllo. Mediante il valorepresente su un ingresso e’ possibile controllare il passaggio o meno del valore presentesull’altro ingresso in uscita (Figura 4.4)

x y

c

y =

x , c =1

0, c = 0

Figura 4.4: Porta logica AND sfruttata come elemento di controllo.

Nel caso di porta logica a piu’ di due ingressi, l’uscita della porta vale 1 soloquando tutti gli ingressi valgono 1.

Porta OR

La porta logica OR realizza l’operatore somma logica (Figura 4.5).

101

110

1

0

X2

11

00

yx1

(a) (b)

yx1

x2

Figura 4.5: (a) simbolo grafico della porta OR; (b) tabella di verita’.

Nel caso di porta a piu’ di due ingressi l’uscita della porta vale 0 solo se tutti gliingressi valgono 0.


La porta realizza l’espressione

y = x1 + x2

Porta XOR

La porta XOR realizza l’operatore logico or esclusivo (Figura 4.6). A differenza dellaporta OR, se entrambi gli ingressi sono 1 questa porta produce uno 0. La porta realizzauna funzione di disparita’, nel senso che l’uscita vale uno se e solo se il numero di 1in ingresso e’ dispari.

101

110

1

0

x2

01

00

yx1

(a) (b)

yx1

x2

Figura 4.6: (a) Simbolo grafico della porta logica XOR; (b) tabella di verita’.

L’espressione booleana che descrive la porta e’

y = x1 ⊕ x2

Una porta XOR a 2 ingressi puo’ essere vista come porta NOT con comando.Se un ingresso della porta, diciamo x1, vale 1 allora l’uscita e’ pari all’altro ingressonegato, y = x2. Se invece x1 = 0 allora y = x2.

Porta XNOR

L’uscita della porta XNOR e’ pari al valore negato della porta XOR (Figura 4.7). Laporta realizza quindi una funzione di parita’, nel senso che l’uscita vale 1 se e solo seil numero di 1 in ingresso e’ pari.

001

010

1

0

x2

11

10

yx1

(a) (b)

yx1

x2

Figura 4.7: (a) Simbolo grafico della porta logica XNOR e (b) tabella di verita’.

L’espressione che descrive la porta e’

y = x1 ≡ x2


Porte NAND e NOR

Nel capitolo precedente, abbiamo visto che esistono due operatori funzionalmentecompleti. Le porte logiche che li realizzano sono dette porte logiche universali.

La Figura 4.8 riporta il simbolo grafico e la tabella di verita’ della porta NAND,la cui espressione e’

x1|x2

101

110

1

0

x2

01

10

yx1

(a) (b)

x1

x2

y

Figura 4.8: (a) Simbolo grafico della porta NAND e (b) relativa tabella di verita.

La figura 5.5 riporta simbolo e tabella di verita’ della porta NOR, la cui espressionealgebrica e’

y = x1 ↓ x2

001

010

1

0

x2

01

10

yx1

(a) (b)

x1

x2

y

Figura 4.9: (a) Simbolo grafico della porta NOR e (b) relativa tabella di verita.

Stato di alta impedenza

Le porte logiche si dicono three state, tri-state o 3-state se la loro uscita puo’ es-sere messa ad alta impedenza. Quando l’uscita di una porta viene postta in altaimpendenza, essa risulta virtualmente scollegata dai circuiti cui e’ connessa.

La Figura 4.10 riporta un buffer tri-state. Si tratta di un elemento con due ingressi,di cui uno di controllo (OE, Output Enabled), ed un’uscita. Quando il segnale dicontrollo e’ attivo (OE=1, oppure OE=0) il segnale in ingresso viene riprodotto inuscita (OUT = IN); in caso contrario l’uscita viene posta in alta impedenza.

Il simbolo di sinistra indica un buffer attivo alto, il segnale fluisce cioe’ quandoil segnale di controllo, OE vale 1. Il simbolo di destra si riferisce ad un dispositivo


attivo basso. Il segnale di ingresso cioe’ fluisce in uscita solo quando il segnale dicontrollo e’ 0.

Per convenzione, si usa un piccolo cerchio per indicare che un segnale di controlloe’ attivo basso.

IN OUT

OE

IN OUT

OE

Figura 4.10: Buffer a tre stati attivo alto (sinistra) e basso (a destra).

4.1.1 Collegamento fra porte elementari

Le porte logiche elementari si possono collegare in modo da formare una rete logica.Le uscite di piu’ porte logiche non possono essere collegate insieme (a meno chenon possano essere messe in alta impedenza); una stessa uscita puo’, tuttavia, esserecollegata all’ingresso di piu’ porte, fino ad un numero massimo di porte, detto fan-out.Nel caso di reti combinatorie, la rete che si ottiene non deve avere anelli, il segnalefluisce dall’ingresso verso l’uscita senza cioe’ mai tornare indietro.

Analisi

Data una rete combinatoria, e’ possibile scrivere l’espressione algebrica che mette inrelazione l’uscita con gli ingressi percorrendo tutti i possibili percorsi dall’ingressodella rete fino all’uscita e usando, per ogni porta, la sua espressione algebrica. Inquesto modo si compie l’analisi del circuito. Un esempio di analisi e’ dato in Figura4.11.

X0

X1

X2

X3

X2X3

X0+ X1

(X2X3)

(X0+ X1) (X2X3)

Figura 4.11: Esempio di analisi di una rete combinatoria.

Esempio 4.1. Le porte NAND e NOR sono universali poiche’ riescono a simularequalunque altra porta. La Figura 4.12 mostra come sfrutture le porta universali persimulare i tre operatori NOT, AND, OR.


X y = x

y = xX

X1

X2

Y=X1X2

X1

X2

Y=X1X2

X1

X2

Y=X1+X2

X1

X2

Y=X1+X2

NOT AND OR

NA

ND

NO

R

Figura 4.12: Simulazione delle porte di base mediante porte universali.

Profondita’

Si chiama profondita’ di una rete combinatoria il numero massimo di porte elementariche bisogna attraversare per raggiungere l’uscita a partire dall’ingresso. La profondita’del circuito di figura 4.11 e’ 3. In gergo si usa dire anche che per attraversare la rete,il segnale d’ingresso deve attraversare 3 livelli di logica.

4.1.2 Scala di integrazione

La tecnologia impiegata per realizzare circuiti digitali consente la creazione, su unaunica piastrina di silicio (chip), di circuiti composti da varie porte elementari (circuitiintegrati) che nel loro complesso formano reti logiche anche complesse. In dipenden-za del numero di elementi che un chip puo’ contenere i circuiti integrati sono cosiclassificati

• SSI (Small Scale Integration), circuiti a bassa scala di integrazione, se sonopresenti non piu’ di 10 porte logiche

• MSI (Medium Scale of Integration), circuiti a media scala di integrazione, sesono presenti fino a 100 elementi per chip

• LSI (Large Scale of Integration), circuiti integrati a alta scala di integrazione secontengono fino a 1000 elementi per chip (primi microprocessori)

• VLSI (Very Large Scale of Integration), circuiti integrati ad altissima scala diintegrazione se contengono fino a 1000 elementi per chip (processori attuali)

4.1.3 Caratteristiche delle porte

Tecnologia

Esistono molte alternative tecnologiche per realizzare le porte logiche, raggruppate infamiglie logiche (DL,RTL,TTL,CMOS,ECL,etc.), ciascuna delle quali e’ caratterizzata


dallo schema circuitale fondamentale adottato. La trattazione di queste alternative,per la quale si rimanda ai testi di elettronica digitale, esula dagli obiettivi di questolibro. Ai nostri fini e’ sufficiente distinguere semplicemente le caratteristiche esterne diuna porta, espresse in termini dei tempi caratteristici cui essa risponde ai cambiamentidi segnale.

Tempi caratteristici di una porta

Da un punto di vista esterno, la bonta’ di una porta logica viene caratterizzata dallavelocita’ di commutazione (switching speed), misurata mediante il tempo di ritardodi propagazione (propagation delay).

Il tempo di propagazione e’ pari all’intervallo di tempo tra i due istanti in cui ilsegnale di ingresso diventa stabile e valido e quello in cui il segnale di uscita diventastabile e valido.

Il tempo di ritardo di propagazione e’ uno degli aspetti principali che caratteriz-zano una tecnologia realizzativa. Ad esempio, le porte della famiglia TTL hanno unritardo di propagazione che varia da 33 ns (TTL standard) a 4 ns (TTL Schottky),nella tecnologia CMOS il ritardo tipico sale a 70 ns, mentre in ECL e’ 2ns.

4.2 Sintesi di funzioni binarie

Si chiama sintesi il problema di determinare come realizzare una rete combinatoriail cui comportamento esterno sia definito formalmente; ad esempio, mediante unatabella di verita’. Le espressioni canoniche SP e PS, studiate nel precedente capitolo,indicano direttamente come sintetizzare una funzione di commutazione mediante duesoli livelli di logica.

Il primo livello serve per realizzare i mintermini o i maxtermini cha appaiono,rispettivamente, nelle espressioni. Il secondo livello somma o moltiplica questi termini.Nel caso di forma SP il primo livello e’ composto da porte AND ed il secondo da unaporta OR. La rete si dice per tale motivo di tipo AND-OR o Somma di Prodotti. Nelcaso di espressione PS, si dice anche che la rete ha una struttura OR-AND.

4.2.1 Struttura AND-OR, Somma di Prodotti (SP)

La Figura 4.13 riporta un esempio di sintesi in forma AND-OR. Dalla tabella di verita’si individuano i mintermini. Ognuno di essi e’ realizzato mediante una porta ANDa tre ingressi (primo livello di logica). I tre mintermini sono sommati mediante unaporta OR.

4.2.2 Struttura NAND-NAND

Dalla sintesi in forma SP si puo’ ottenere una rete che utilizza solamente porteNAND, nota come forma NAND-NAND. E’ sufficiente semplicemente sostituire tuttele porte che appaiono nella struttura AND-OR mediante porte NAND. Per convin-cersi che questa sostituzione lascia inalterata la relazione ingresso-uscita consideriamo

4.2. SINTESI DI FUNZIONI BINARIE 83

m4

m5

m6

Y

1011

0110

1001

1101

1

0

1

0

011

010

000

0000

1

2

3

4

5

6

7

A B C Y

Tabella di verità

A

\B

\C

A

\B

\C

A

B

\C

Figura 4.13: Esempio di sintesi a 2 livelli sfruttando la forma SP di una funzione.

l’espressione canonicay = m1 +m2 + . . .mk

posto m′i = mi, si ha

y = m′1 +m′2 + . . .m′k = m′1m′2 . . .m

′k

dove l’ultima eguaglianza e’ dovuta a De Morgan. Questa espressione e’ realizzabilemediante due livelli di porte NAND. Il primo livello calcola m′i; il secondo livello ilprodotto fra tali termini, negato.

La Figura 4.14 mostra come passare dalla forma AND-OR a quella NAND-NANDnel nostro esempio.

m’4

m’5

m’6

Y

A

\B

\C

A

\B

\C

A

B

\C

Figura 4.14: Struttura NAND-NAND corrispondente alla funzione di Figura 4.13.

4.2.3 Struttura OR-AND, Prodotto di Somme (PS)

La forma OR-AND corrisponde alla struttura “duale” della precendente e si ottienedirettamente dalla forma canonica PS. Il livello OR genera i maxtermini mentre quelloAND ne esegue il prodotto, come indicato in Figura 4.15.

4.2.4 Struttura NOR-NOR

Se dalla forma PS si sostituiscono le NOR si ottiene una struttura nota come NOR-NOR. La dimostrazione e’ analoga al caso precedente.


1011

0110

1001

1101

1

0

1

0

011

010

000

0000

1

2

3

4

5

6

7

A B C Y

Tabella di verità

M0

M1

M2

M3

M7

A

B

C

A

B

\C

A

\B

C

A

\B

\C

\A

\B

\C

Y=M0 M

1 M

2 M

3 M

7

Figura 4.15: Esempio di sintesi a 2 livelli sfruttando la forma PS di una funzione.

4.2.5 Sintesi ottima a due livelli

La semplificazione di una espressione mediante mappa di Karnaugh conduce, abbiamovisto, ad un’espressione algebricamente piu’ semplice. Questa semplicita’ si traducein una rete combinatoria a 2 livelli, avente il minimo numero di porte logiche con ilminimo numero totale di ingressi. Ad esempio, la funzione di Figura 4.15 puo’ esseresintetizzata seguendo la semplificazione di Figura 4.16 .

1011

0110

1001

1101

1

0

1

0

011

010

000

0000

1

2

3

4

5

6

7

A B C Y

1

11

A B

C00 01 11 10

0

1

A B C+ A B C A B

A B C+A B C A C

Y=A C+A B

A

B

C

Figura 4.16: Sintesi a 2 livelli guidata dalla semplificazione mediante MK

4.3 Circuiti aritmetici binari

In questa sezione descriveremo alcuni moduli combinatori elementari in grado dieseguire semplici operazioni aritmetiche su numeri binari.

4.3.1 Half adder

Si chiama Half-Adder (HA) o semi-sommatore la rete combinatoria che esegue l’addi-zione di due cifre binarie, A e B. Le uscite di un HA sono la cifra meno significativadella somma, S, ed il riporto C (Carry). La tabella di verita’ di un HA, vedi Figura

4.3. CIRCUITI ARITMETICI BINARI 85

4.17.(a), e’ determinata quindi dalle regole dell’addizione. Dall’ispezione della tabellasi trova che

C = AB

eS = A⊕B

Il simbolo di un HA e’ riportato in Figura 4.17.(b). La Figura 4.17.(c) riportal’implementazione di un HA usando due porte logiche.

HA

A B

S

C

(a) (b)

0111

1001

1010

0000

SCBA

S

C

A B

(c)

Figura 4.17: (a) Tabella di verita’ di un Half Adder, (b) simbolo grafico, (c)realizzazione con due porte logiche.

4.3.2 Full Adder

Si chiama Full Adder (FA) o sommatore completo, la rete combinatoria che eseguel’addizione di tre cifre binarie, A,B,Cin. Il risultato dell’addizione e’ fornito mediantela cifra meno significativa della somma, S, ed il riporto Cout. Come per un HA, latabella di verita’ di un FA e’ determinata dalle regole di addizione, vedi Figura 4.18:la coppia di valori CoutS codifica il risultato completo dell’addizione.

11111

01011

01101

10001

01110

10010

10100

00000

SCout

BACin

Cin + A + B = Cout S

Figura 4.18: Tabella di verita’ di un FA.

Il simbolo di un FA e’ riportato in Figura 4.19(a). Un FA puo’ essere realizzatoin vari modi. La Figura 4.19(b) mostra come realizzare un FA mediante 2 HA. Perverificare questa affermazione procediamo con l’analisi del circuito.


HA

A B

Cg

HACp

CinCout

S

Cin

A B

Cout

S

FA

(a) (b)

Figura 4.19: (a) simbolo grafico di un FA; (b) realizzazione di mediante due HA.

Il primo HA esegue l’addizione fra A e B; il riporto vale

Cg = AB

Se Cg = 1 diremo che A e B hanno generato un riporto. La somma in uscita dalprimo HA vale invece

A⊕B

Il riporto Cp, in uscita dal secondo HA, puo’ essere interpretato come la propagazionedel riporto Cin. Tale propagazione avviene se e solo se una delle due cifre A o B vale1. In questo caso diremo che i valori di A e B hanno propagato il riporto in ingresso,Cin.

Cp = Cin(A⊕B)

QuindiCout = AB + Cin(A⊕B)

Per quanto riguarda il bit S analizzando il circuito troviamo che

S = A⊕B ⊕ Cin

Le espressioni algebriche per S e Cout soddisfano la tabella di verita’ di Figura 4.18.

4.3.3 Ripple Carry Adder (RCA)

L’addizione fra due numeri binari ad n cifre puo’ essere realizzata collegando in cascatan FA, secondo la struttura di Figura 4.20; i dati entrano in parallelo nel circuito.Questa soluzione si chiama addizionatore a propagazione del riporto o Ripple CarryAdder, RCA.

Tempo di calcolo Un parametro importante delle reti combinatorie che eseguonol’addizione e’ il tempo richiesto per completare il calcolo. Il tempo di calcolo e’definito come l’intervallo di tempo che passa dal momento in cui il segnale in ingressoal circuito e’ stabile fino al momento in cui il segnale in uscita e’ stabile.

L’uscita che impiega piu’ tempo per diventare stabile e’ quella prodotta dall’ultimoFA, quello che addiziona le cifre piu’ significative. Questo perche’, per poter effettuare

4.3. CIRCUITI ARITMETICI BINARI 87

FAFAFAFA0

An-1

Bn-1 A

0 B0

A1

B1

A2

B2

Sn-1 S

2 S1

S0

C1

C2

Cn-1 ...

Cn

Figura 4.20: Ripple Carry Adder ad n stadi. Il primo stadio, quello piu’ a destra,potrebbe essere sostituito con un Half Adder

correttamente la somma e’ necessario che il riporto in ingresso all’ultimo FA sia noto.Nel caso peggiore il riporto puo’ essere generato dal primo FA (quello che addizionale cifre meno significative, A0 e B0) e deve essere propagato attraverso tutti i FAintermedi fino a giungere all’ultimo FA.

Abbiamo visto che un FA e’ implementato mediante 2 livelli di logica; quindi, setp indica il ritardo di una porta del FA, le uscite di un FA sono stabili dopo un tempo2tp a partire dal momento in cui sono stabili gli ingressi.

Quindi il riporto in uscita dallo stadio 0, che va in ingresso allo stadio 1, c1,e’ stabile dopo un tempo 2tp dal momento in cui i dati da addizionare, forniti iningresso al RCA, sono stabili. Il valore c2 e’ stabile dopo un tempo 2tp dal momentoin cui il FA riceve il valore stabile c1 e quindi dopo un tempo 4tp rispetto ai dati iningresso, e cosi via. In un RCA ad n stadi, l’uscita dell’ultimo FA, e quindi il risultatodell’operazione, diventa stabile dopo un ritardo 2ntp.

4.3.4 Carry Look-ahead Adder (CLA)

Il Carry Look-ahead Adder o sommatore a generazione anticipata del riporto, riduceil tempo di produzione del risultato, calcolando in anticipo tutti i riporti da fornire aivari FA. Mentre in un RCA il riporto in ingresso ad uno stadio ci dipende dal riportodello stadio precedente, ci−1, in un CLA ci e’ calcolato direttamente a partire daivalori degli operandi, Ai−1 . . . A0 e Bi−1 . . . B0.

L’idea centrale consiste quindi nel trovare una relazione che leghi ci direttamenteai valori degli operandi piuttosto che a ci−1. A tal fine scriviamo la relazione fra carryadiacenti nella seguente forma

ci+1 = Gi + Pici

doveGi = AiBi e’ detto termine Generazione e Pi = Ai⊕Bi Propagazione, in analogiaa quanto visto per il singolo FA. Da questa relazione vediamo che

c1 = G0 + P0c0

e che

c2 = G1 + P1c1 = G1 + P1(G0 + P0c0) = G1 +G0P1 + c0P0P1


Questo legame puo’ essere interpretato nel seguente modo. c2 puo’ essere generatodallo stadio 1 (se G1 = 1), oppure generato dalla stadio 0 (G0 = 1) e propagato dallostadio 1 (se P1 = 1), oppure generato dall’esterno e propagato dagli stadi 0 ed 1, seP0 = 1, P1 = 1. Il valore di c2 dipende, quindi, dagli operandi secondo la relazione

c2 = A1B1 + (A0B0)(A1 ⊕B1) + c0(A0 ⊕B0)(A1 ⊕B1)

Continuando ad espandere fino al quarto stadio (valore tipico per implementare questastruttura) troviamo che

c3 = G2 +G1P2 +G0P1P2 + c0P0P1P2

ec4 = G3 +G2P3 +G1P2P3 +G0P1P2P3 + c0P0P1P2P3

D’altra parte, poiche’ la cifra della somma dello stadio i vale si = Ai ⊕Bi ⊕ ci, si ha

si = Pi ⊕ ci

da cui deriva la struttura di Figura 4.21.

HA

Carry Look-ahead

c0

P0G0

A0B0

HA

c1

P1G1

A1B1

HA

c2

P2G2

A2B2

HA

c3

P3G3

A3B3

c0c4

s0s1s2s3

AiBi

Gi Pi

G0

c1

P0

c0

HA

Figura 4.21: Sommatore CLA a 4 bit.

Il blocco Carry Look-ahead e’ una rete combinatoria per il calcolo anticipato deiriporti, secondo le relazioni viste per i vari ci. Essa puo’ essere implementata mediante2 livelli di logica, come illustrato per c1 nella figura.

Tempo di calcolo Dall’analisi della struttura vediamo che i segnali di ingresso e diuscita sono separati da 4 livelli di logica. Il primo livello produce i termini P e G ede’ composto da HA. Il secondo e terzo livello generano i riporti mentre l’ultimo livelloe’ composto da porte XOR che calcolano si. Quindi il ritardo di questa struttura e’4tp, dove tp indica il ritardo di una porta, assunto lo stesso per tutte le porte.

4.4. ALTRI MODULI COMBINATORI DI BASE 89

4.3.5 Addizionatori/Sottrattori

Uno dei vantaggi della rappresentazione in complemento a 2 e’ che la sottrazione puo’essere eseguita sfruttando gli stessi circuiti impiegati per la somma. Vediamo come.Supponiamo di voler calcolare la differenza A − B usando un sommatore. A tal finedobbiamo sommare A al complemento di −B, ossia ad 1 + B′, dove B′ e’ il numeroottenuto da B invertendo le cifre binarie. Cio’ porta allo schema di Figura 4.22, chesfrutta la porta XOR per l’operazione di complementazione di B (vedi Sezione 4.6).

In questo schema e’ presente un segnale di controllo, D/S, che determina se cal-colare la Somma, A+ B o la Differenza, A− B, ed una porta XOR per segnalare lacondizione di overflow.

Abbiamo gia’ visto nel capitolo precedente che nelle operazioni in complemento a2, un overflow si verifica solo quando i due operandi hanno lo stesso segno e produceun risultato di segno opposto. Questo vuol dire che si ha overflow solo quando An−1 =Bn−1, ma An−1 = Sn−1. Ispezionando la tabella di verita’ di un FA, Figura 4.18,ci si accorge che questa circostanza accade solo se cin = cout. Condizione segnalataappunto dalla porta XOR.

A1 B1 A0B0An-1Bn-1

c0FAFAFA

OVF

D/S

sn-1 s1 s0

…

Figura 4.22: Un sommatore/sottrattore ad n bit. Il segnale D/S stabilisce se ilcircuito calcola la Differenza o la Somma. L’ultima porta XOR rileva la condizionedi overflow.

4.4 Altri moduli combinatori di base

In questa sezione saranno illustrati altri moduli combinatori di base.

4.4.1 Codificatori/ Decodificatori

Encoder Un codificatore o Encoder 2n : n e’ una rete combinatoria che codifical’informazione presente al suo ingresso. Il codificatore piu’ semplice dispone di 2n

linee di ingresso x2n−1 . . . x0, ed n linee di uscita yn−1 . . . y0.Il suo funzionamento e’ specificato solo quando uno solo degli ingressi, poniamo xj

vale 1, nel qual caso in uscita appare il numero binario della posizione dell’ingresso,


Y . Se j e’ la posizione, allora

Y = (j)2, X : xj = 1, xi = 0, i = j

dove X e’ il vettore dei valori in ingresso.La Figura 4.23 riporta un codificatore 4:2.

COD

X3

0

X0

Y0 = X1 + X3

Y0

Y1

X1

X2

X3

Y1 = X2+ X3

X2

0

X1

0

X0

1

0 0 1 0

0 1 0 0

1 0 0 0

Y1Y0

00

01

10

11

Figura 4.23: Simbolo e tabella di verita’ di un codificatore 4:2.

Priority Encoder Un codificatore con priorita’, o priority encoder, dispone di un’ulteriore uscita, z. Nel caso in cui tutti gli ingressi sono nulli, Y non ha significato,e z = 1. Negli altri casi z = 0 e l’uscita codifica la posizione della linea d’ingresso dimaggiore indice sulla quale e’ presente il valore 1.

Y = (j)2, X : xj = 1, xi = 0, i > j

Decoder Un decodificatore o decoder e’ una rete combinatoria che svolge la funzioneinversa del codificatore, ossia recuperare l’informazione presente in ingresso.

Esso dispone di n linee di ingresso, xn−1, . . . , x0, e 2n linee di uscita, y2n−1, . . . y0.

Le uscite di un decodifatore sono tutte nulle, ad eccezione di yj , dove (j)2 = X. LaFigura 4.24 mostra un esempio di decodificatore 2:4. Esso dispone di un ingresso diabilitazione.

Y0

0

1

X1X0

XX

00

En

0

1

Y1

0

0

Y2

0

0

Y3

0

0

0011 1 0 0

0101 0 1 0

0111 0 0 1

DEC

Y0

Y0 = En X1 X0

X0

X1

Y1

Y2

Y3

En

Y1 = En X1X0

Y2 = En X1 X0

Y3 = En X1X0

Figura 4.24: Esempio di decodificatore 2:4 e relativa tabella di verita’.

Per come e’ definita, l’uscita yi di un decodificatore non e’ altro che il minterminej-simo, mj , sulle n variabili d’ingresso, yj = mj . Pertanto, il decodificatore e’ utileper sintetizzare una funzione generica, f(xn−1, . . . , x0), di n variabili. Per far questo


si individuano gli indici dei mintermini che appaino della funzione espressa in formaSP e si collegano poi le uscite del decoder, aventi questi indici, mediante una portaOR.

Esempio 4.2. Si vuole sintetizzare mediante decodificatore, la funzione

f(A,B,C) = AB + C

La funzione vale 1 per gli ingressi

ABC = 001 + 011 + 101 + 111 + 110

da cui si deduce la forma SP

f(A,B,C) = Σ(1, 3, 5, 6, 7)

cui corrisponde lo schema di Figura 4.25

0

1

2

3

4

5

6

7

0

1

2

A

B

C

f(A,B,C)=AB+C=Σ(1,3,5,6,7)

000

001

010

011

100

101

110

111

Figura 4.25: Implementazione mediante Decoder della funzione f(A,B,C) = AB+C.

4.4.2 Multiplexer/Demultipler

Multiplexer Un selettore o multiplexer (mux) 2n : 1 e’ una rete combinatoriadotata di 2n ingressi di segnale, x2n−1, . . . , x0, n ingressi di controllo o selezione,sn−1, . . . , s0 ed 1 uscita, y (Figura 4.26).

Le linee di controllo stabiliscono quale fra i valori sulle linee di segnale debba essereriprodotto in uscita. La funzione di un mux puo’ essere succintamente descritta nelseguente modo

y = xS

dove S e’ il numero binario che appare sugli ingressi di controllo.

Esempio 4.3. La Figura 4.27 mostra come realizzare un semplice mux 2:1. A partiredalla specifica, espressa mediante MK, viene ricavata una forma SP semplificata.


S

Y

X0

…

S

0

…

0

2n-1

Y

X0

X2n-1

n

XiXi

Xi

i

….….

X2n -1

2n-1

Figura 4.26: Simbolo di un multiplexer e relativa tabella di verita’.

s

y = s’ x0 + s x1

01

00

x0x1

s 00 01

0

1

y

10

11

11 100

1

yx0

x1

x0

x1

s

y

s x1

s’ x0

(a)

(b)

(c)(d)

Figura 4.27: Sintesi del mux 2:1.(a) Simbolo grafico; (b) specifica mediante mappa diKarnaugh e semplificazione; (c) espressione semplificata; (d) realizzazione.

Un mux puo’ essere realizzato mediante un decodificatore che generi i segnali diabilitazione diretti verso un livello di porte AND alle quali sono applicati gli ingressidi segnale, come riprodotto in Figura 4.28 per un mux 4:1.

La realizzazione di un mux mediante decoder mostra che l’uscita y del mux e’ datada

y =2n−1∑

i

mixi

dove mi indica il mintermine i-simo definito sulle n variabili di selezione. Questarelazione fra l’uscita e gli ingressi al mux giustifica l’impiego del mux come elementoper realizzare funzioni.

Per realizzare una funzione f si devono usare gli ingressi di selezione al muxcome variabili indipendenti della funzione. Come nel caso del decoder, si esprimeprima f in forma SP, in modo da rendere evidenti i mintermini che la caratterizzano.Dopodiche’ si collegano ad 1 esattamente gli ingressi di segnale del mux la cui posizionecorrisponde ad un mintermine di f , mentre gli altri ingressi si collegano a 0.

Esempio 4.4. Consideriamo la funzione


x0

x1

x2

x3

0 1 2 3

y

s1 s0

Figura 4.28: Realizzazione di un multiplexer 4:1 mediante decoder.

y = Σ(7, 10, 11, 13, 14, 15)

Essa puo’ essere realizzata come riportato in Figura 4.29

x3x2x1x0

0

y

4

y=f(x3x2x1x0) =∑( 7, 10, 11, 13, 14, 15)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

Vhigh = 1

Vlow= 0

Figura 4.29: Esempio di utilizzo di un mux per realizzare una funzione di 4 variabili.

Esempio 4.5. Si vuole realizzare una rete combinatoria flessibile in grado di si-mulare qualunque funzione di due variabili, A e B. A tal fine la rete dispone di 4segnali di controllo, F3, F2, F1, F0 che determinano l’uscita. La figura 4.30 mostracome realizzare tale circuito - disegnato in (a)- mediante un mux 4:1, riprodotto in(b).

Ad esempio, la funzione A + B corrisponde ad [F3, F2, F1, F0] = [1110]. Si notiche in pratica gli ingressi di controllo sono la colonna di definizione della tabella di


F3 F2 F1 F0

A

By

3 2 1 0

0

1

A

B

y

F3 F2 F1 F0

(a) (b)

Figura 4.30: (a) Generatore universale di funzioni; (b) realizzazione mediante un mux4:1.

verita’ della funzione da realizzare, nel senso che Fi e’ il valore della funzione perl’assegnamento i (vedi anche Figura 6.29).

Esercizio 4.1. Quale valore devono avere gli ingressi di selezione per generare unmintermine?

Demultiplexer Un distributore o demultiplexer (demux) 1 : 2n svolge la funzio-ne inversa di in mux. Esso e’ dotato di 1 linea di ingresso,x, 2n linee di uscita,y2n−1, . . . , y0, ed n linee di selezione, sn−1, . . . , s0. Tutte le uscite del demux sononulle, ad eccezione dell’uscita i-sima, dove (i)2 = S, che riproduce l’ingresso. La Fi-gura 4.31.(a) riporta il simbolo di un demux; in Figura 4.31.(b) viene invece riportatolo schema di un demux 4:1. Analizzando la figura si nota che il demux e’ in sostanzaun decodificatore con una linea dati in comune in piu’.

S

0

2n-1

X

Y0

Y2n-1

n

S0

S1

I

Y0

Y1

Y2

Y3

(a) (b)

Figura 4.31: (a) Demultiplexer 1 : 2n; (b) Realizzazione di un demux 1:4.

4.5 Memoria ROM

Una memoria ROM (Read Only Memory) permette di memorizzare permanentementedati. Da un punto di vista funzionale una ROM e’ una rete combinatoria con n ingressi

4.5. MEMORIA ROM 95

ed m uscite. Ogni uscita yi della memoria e’ una funzione booleana del vettore degliingressi X, yi = fi(X).

La ROM, come ogni altra memoria, puo’ essere vista come un insieme di celleadiacenti, ognuna caratterizzata da un indirizzo e da un contenuto (il numero di celledi memoria e’ 2n, mentre ogni cella contiene m bit). L’ingresso X della ROM e’cioe’ interpretato come indirizzo della cella, mentre il valore Y come contenuto dellacella. La memoria ROM puo’ quindi solamente essere letta. La scrittura avvienein fase di fabbricazione. Alcune varianti tecnologiche, consentono di memorizzare idati semipermaentemente: il contenuto puo’ essere modificato solo mediante appositiaccorgimenti.

Le memorie ROM sono disponibili sotto forma di circuiti integrati (vedi Sezione4.1.2). La Figura 4.33.(a) riporta un tipico circuito integrato contenente al suo internouna ROM composta da 8 parole da 4 bit ciascuna (8 × 4). I pin CS (Chip Select)e WE indicano (Write Enable), servono per selezionare il chip e per leggere il dato.Queste due funzioni sono attivate quando i segnali di controllo assumono un valorebasso.

A0

A1

A2

A3

A4

A5

A6

A7

OE

D0

D1

D2

D3

__

CS

__

OE

__

CS

__

(a) (b)

Indirizzi DatiA0...

An-1

D0...

Dm-1

Figura 4.32: (a) Una ROM 8 × 4 realizzata come circuito integrato; (a) simbologenerico di un modulo ROM n×m.

Struttura di base La Figura 4.33 mostra l’organizzazione di principio di unasemplice ROM con n = 2 linee indirizzo, A1, A0 ed m = 2, linee dati(D1, D0).

La ROM e’ costituita da un decodificatore 2:4 e da una matrice di contatti. Leuscite del decodificatore rappresentano le righe della matrice, mentre le linee di uscitadella ROM le colonne. Nel nostro esempio la matrice e’ composta da 4 righe e 2colonne. Le righe della matrice sono anche chiamate word lines mentre le colonne bitlines.

Ogni incrocio di una riga con una colonna puo’ o meno essere elettricamentecollegato (pallino nero). Quando l’uscita i del decodificatore assume il valore 1, lacolonna che e’ collegata con tale riga assume il valore 1. Se invece tale connessionenon e’ presente, la colonna rimane ad un livello logico alto.

Pertanto, la scrittura permanente di un singolo valore logico nella ROM coincidecon l’effettuare o meno il collegamento fra riga e colonna. E’ facile rendersi conto


che l’uscita del circuito di Figura 4.33 e’ pari all’OR dei valori sulle righe alla qualel’uscita risulta collegata. Per indicare cio’, si dice che l’uscita realizza un OR cablato,e tale porta viene indicata come riportato a destra della stessa Figura.

DECODIFICATORE

A1

A0

riga 0

riga 1

riga 2

riga 3

D0

0

1

2

3

D1

colonna 1colonna 0

DECODIFICATORE

A1

A0

riga 0

riga 1

riga 2

riga 3

D0

0

1

2

3

D1

colonna 1colonna 0

Figura 4.33: Struttura di principio di una ROM (sinistra) e simbologia come ORcablato (destra)

Tempo di accesso La velocita’ di una ROM si esprime mediante un parametrodetto tempo di accesso, ta. Esso e’ definito come l’intervallo di tempo fra l’applicazionedi un indirizzo valido in ingresso, e l’apparizione in uscita di un dato valido.

4.5.1 Varianti

Esistono diverse varianti delle memorie ROM, vedi Figura 4.34. Le ROM descrittefinora sono anche dette Mask ROM; esse sono programmate permanentemente all’attodella produzione. Non c’e’ alcun modo di cambiare il loro contenuto. Le PROM(Programmable ROM) sono ROM programmabili, nelle quali il contenuto puo’ esserescritto una sola volta mediante opportune attrezzature.

ROM

UVPROM E2PROMEPROMPROMMASK

Figura 4.34: I vari tipi di memoria ROM.

La Figura 4.35 riporta lo schema di principio di una PROM. Ogni incrocio fra unalinea ed una colonna contiene un contatto elettrico programmabile. L’utente cioe’

4.6. UNITA’ ARITMETICO LOGICA (ALU) 97

puo’ eliminare i contatti elettrici degli incroci, inizialmente tutti presenti, in base alleproprie esigenze.

A1 A0

D1 D0

MATRICE DI AND MATRICE DI OR (programmabile)

Connessione

programmabile

Figura 4.35: Struttura di principio di una ROM programmabile.

Le memorie EPROM (Erasable PROM) possono essere cancellate (erased) e ri-programmate. La tecnologia impiegata per la riprogrammazione si basa sui raggiultravioletti (UV PROM) o mediante impulsi elettrici (Electrically Erasable ROM, oE2ROM).

4.6 Unita’ Aritmetico Logica (ALU)

L’Unita’ Aritmetico Logica (ALU) raggruppa le capacita’ di calcolo delle reti combi-natorie affiche’ siano utilizzabili in modo flessibile all’interno della CPU. La ALU e’in grado di calcolare diverse funzioni degli ingressi, sia di tipo Aritmetico (addizione,sottrazione, etc), sia di tipo logico (AND, OR, etc). La particolare funzione e’ stabi-lita da ulteriori ingressi di selezione. L’uscita della ALU puo’ quindi essere espressanel seguente modo (vedi figura 4.36)

Y = fS(A,B)

dove S e’ un indice indica la particolare funzione scelta, mentre A e B sono gli operandidella funzione. Ad esempio, f3(A,B) potrebbe indicare l’addizione degli operandi; nelqual caso con S = 3 si avrebbe Y = A+B (l’operatore + e’ da intendersi come sommain senso aritmetico).

Oltre che produrre un risultato, la ALU fornisce altre informazioni sulla natura delrisultato, indicate nella figura globalmente con C (Condizione). Queste informazioniindicano, ad esempio, se il risultato dell’operazione e’ o non e’ valido - per esempiose si e’ verificato un overflow - oppure caratteristiche del risultato, per esempio se ilrisultato dell’operazione e’ un numero negativo, etc.


A B

Y

ALU

C

S

Figura 4.36: Schema logico di una ALU.

4.6.1 Una ALU ad un bit

Al fine di approfondire il funzionamento di una ALU, vediamo adesso come costruireuna semplice ALU che agisca su operandi di un solo bit (Figura 4.37). L’unita’aritmetica (AU) e’ composta da un FA e da una porta XOR per negare, eventualmente,l’ingresso B. L’unita’ logica (LU) e’ invece composta da una porta AND e da unaporta OR.

Le unita’ aritmetica e logica lavorano in parallelo ed i risultati prodotti entranoin un MUX. Le linee di selezione in ingresso alla ALU (S0 ed S1) sono usate comesegnali di selezione del MUX 4:1. Pertanto, l’uscita y della ALU dipende dai segnalidi selezione secondo la tabella riportata nella figura.

A A A BB B B

S0

S1

S0

F.A.

A = By

A

0 1 2 3

A B01

A⊕B’⊕Cin10

A⊕B⊕Cin00

1

S0

A + B1

yS1

CinCout

MUX 4:1

LU

AU

Figura 4.37: Schema di una semplice ALU ad un bit.


4.6.2 Una ALU a 4 bit

Per ampliare la dimensione della nostra ALU, possiamo seguire la tecnica usata perrealizzare il sommatore a propagazione di riporto. Si ottiene cosi il circuito di Figura4.38.

S1

S0

cin

Y

A Bcout

S1

S0

cin

Y

A Bcout

S1

S0

cin

Y

A Bcout

S1

S0

cin

Y

A Bcout

A0A3 A2 A1B0B3 B2 B1

Y3 Y2

Y1 Y0

VZ

A=B OP0

OP1

A=B A=B A=B

Figura 4.38: Una ALU a 4 bit realizzata mediante 4 ALU ad 1 bit.

Con OP = 0 si seleziona la somma fra A e B, con OP = 1 la differenza, mentrecon OP = 2 ed OP = 3 le operazioni logiche AND ed OR eseguite bit a bit. La portaXOR serve per rilevare la condizione di overflow (condizione V=1), la porta AND perstabilire se A = B (condizione Z = 1).


1. Cos’e’ il ritardo di propagazione dei una porta logica?

2. Cos’e’ un buffer tri-state?

3. Perche’ la porta XOR puo’ essere usata come negatore con comando?

4. Cos’e’ la struttura canonica AND-OR?

5. Cos’e’ un Full Adder ?

6. Come funziona un Ripple Carry Adder?

7. Come funziona un Carry Look-ahead Adder?

8. Come mai un multiplexer puo’ essere usato come generatore universale di fun-zioni?

9. Cos’e’ una memoria ROM?

10. Cos’e’ una ALU?

Capitolo 5

Reti sequenziali

In questo capitolo introduciamo una nuova classe di reti logiche, chiamate reti logichesequenziali. La caratteristica principale di una rete sequenziale e’ che l’uscita dellarete al tempo t dipende dai valori applicati in ingresso alla rete fino a t. Si usa dire, pertale motivo, che una rete sequenziale ha memoria di cio’ che e’ accaduto in passato.Questa caratteristica puo’ essere giustificata ammettendo che la rete abbia un propriostato interno che serve per registrare la storia dei segnali applicati in ingresso finoad un certo momento. L’uscita della rete dipende dal valore dello stato interno, cheriassume le vicissitudini della rete fino a quel momento, e dall’ingresso attuale.

In questo capitolo studieremo alcune reti sequenziali il cui stato interno e’ diretta-mente esposto in uscita. Studieremo innanzi tutto reti sequenziali elementari (latche flip-flop) dotate di minima (1 bit) capacita’ di memorizzazione. Vedremo poi comeaumentare la capacita’ di memorizzazione riunendo k flip flop per formare i registri.Un registro e’ l’elemento di memorizzazione di base che si trova dentro una CPU; essopuo’ servire per accoppiare fra loro reti combinatorie diverse. I registri ci consentiran-no inoltre di introdurre una classe di reti sequenziali molto importante, le cosiddettereti Level Level output Clocked (LLC). Cosi come mediante reti combinatorie e’ pos-sibile implementare espressioni algebriche, le quali modellizzano matematicamente ilcomportamento esterno di un sistema senza memoria, le reti LLC rappresentano unpossibile modo per realizzare automi a stati finiti, che modellizzano matematicamentesistemi dinamici discreti. La descrizione mediante automi si rivelera’ fondamentaleper studiare la struttura funzionale interna delle CPU. Studieremo infine le memorieRAM, dispositivi progettati per offrire un’elevata capacita’ di memorizzazione.

5.1 Modello generale di rete sequenziale

Per descrivere il comportamento di un sistema che evolva in tempi discreti e possatrovarsi in un numero finito di stati differenti, si fa ricorso ad una descrizione astratta,detta Automa o macchina a Stati Finiti (ASF).

101

102 CAPITOLO 5. RETI SEQUENZIALI

5.1.1 Definizione di automa

Un automa a stati finiti, ASF , e’ definito mediante una quintupla, ASF = (I, 0, S, δ, ω),dove

• I = {i1, i2, . . . , in}, e’ un insieme finito di simboli, detto alfabeto di ingresso

• O = {o1, o2, . . . , om}, e’ un insieme finito di simboli, detto alfabeto di uscita

• S = {s1, s2, . . . , sk}, e’ un insieme finito di stati

• δ : S × I → S, e’ la funzione di stato prossimo (o successivo)

La funzione ω, detta funzione di uscita puo’ essere definita in due modi differenti,che individuano due tipi di automi, detti automa di Moore ed automa di Mealy. Nelprimo la funzione di uscita e’ cosi definita

• ω : S → O

mentre per un automa di Mealy

• ω : S × I → O

Negli automi a stati finiti il tempo e’ implicitamente considerato nel meccanismo dievoluzione dell’automa. Ogni volta che un nuovo ingresso viene avvertito dall’automa,l’automa cambia stato e produce - prima o dopo tale cambiamento - una nuova uscita.

Diagramma degli stati

Le funzioni ω e δ non si prestano di norma ad essere assegnate in forma chiusa. E’pertanto necessario elencare i valori delle funzioni per tutte le possibili combinazionidelle variabili d’ingresso.

A questo scopo si puo’ sfruttare un diagramma degli stati, una rappresentazioneintuitiva particolarmente efficace quando il numero di stati non e’ elevato. Si trattadi un grafo orientato etichettato composto da k nodi, uno per ogni stato interno, edun insieme di archi che collegano i nodi.

Se s′ = δ(s, i), allora dal nodo s parte un arco etichettato verso il nodo s′; nelcaso di automa di Moore l’etichetta dell’arco e’ i, mentre nel caso automa di Mealyl’etichetta sull’arco che collega s ad s′ e’ i/o, dove o = ω(s, i). Nel caso di automa diMoore, ogni nodo s ha per etichetta anche l’uscita o = ω(s).

Da un punto di vista temporale, l’uscita prodotta dall’automa di Moore e’ disalli-neata rispetto a quella di Mealy. Tuttavia, si puo’ dimostrare che, a patto di ignorarela prima uscita generata da un automa di Moore, gli automi di Moore e Mealy sonofra loro equivalenti, nel senso che a partire da un automa di un tipo se ne puo’ definireun altro di tipo differente che abbia lo stesso comportamento ingresso-uscita.

Esempio 5.1. La Figura 5.1 riporta i digrammi degli stati degli automi di Moore eMealy che riconoscono la parola ”ciao”. Quando la parola viene applicata in ingres-so, l’automa ne segnala in uscita il riconoscimento. A questo scopo l’automa devericordare i caratteri ricevuti.

5.1. MODELLO GENERALE DI RETE SEQUENZIALE 103

L’alfabeto di ingresso, per semplicita’, si e’ assunto sia pari a I = {a, c, i, o},mentre O = {0, 1}. Lo stato ha significato di attesa di un carattere. Per esempio,lo stato ”a” indica che l’automa e’ in attesa della lettera ”a” e che quindi finora haricevuto in ingresso la sequenza ”ci”.

1ccccfin

0finccco

0cocca

0ccaci

0cccic

oaic

USCITAINGRESSISTATO

INIZIALE

c,1c,0i,0c,0o

c,0o,0c,0c,0a

c,0c,0a,0c,0i

c,0c,0c,0i,0c

oaic

INGRESSISTATO

INIZIALE

Figura 5.1: Automi di Moore (sinistra) e Mealy (destra) che riconoscono la parolaciao.

Rispetto all’automa di Mealy, l’automa di Moore ha uno stato in piu’, indicatocon ”fin”. L’automa di Moore entra nello stato ”fin” dopo che ha ricevuto la correttasequenza di caratteri. La freccia tratteggiata indica lo stato iniziale.

Automa di

Mooreo ciaa 0 0001

5 4 3 2 1 5 4 3 2 1

I O

Automa di

Mealyo ciaa 1 0000

5 4 3 2 1 5 4 3 2 1

I O

Figura 5.2: Differenze fra comportamenti esterni degli automi di Moore e Mealy.

La Figura 5.2 riporta un esempio di riconoscimento.

Tabella di flusso

Un altro modo per assegnare le funzioni caratteristiche dell’automa e’ mediante tabelledi flusso. Per l’automa di Moore si tratta di una tabella con k righe (k= numero distati) ed n + 1 colonne (n= alfabeto di ingresso). Le righe elencano tutti gli statipossibili dell’automa, le colonne tutti gli ingressi, ad eccezione dell’ultima che definiscela funzione d’uscita. La casella che si trova all’incrocio della riga relativa allo stato scon la colonna relativa all’ingresso i contiene δ(s, i).


La descrizione mediante tabella di flusso per l’automa di Mealy usa una tabellacon k righe ed n colonne. La casella che si trova all’incrocio della riga relativa allostato s con la colonna relativa all’ingresso i contiene la coppia di valori δ(s, i), ω(s, i).

Esempio 5.2. La Figura 5.3 riporta le tabelle di flusso dei due automi del precedenteesempio.

iO

aO

oO

fin1

a,c,o

cO

c i a o

c,i,o

c

a,i,o

a,c,i

a,i,o

i a o

[a,c,o] /0

cc/0 i/0 a/0

[c,i,o]/0

o/1

[a,i,o]/0

[a,i]/0

c/0

Figura 5.3: Descrizione mediante tabella di flusso degli automi di Moore (sinistra) eMealy (destra) che riconoscono la parola ”ciao”.

Esempio 5.3. L’automa di Figura 5.4 riporta un automa a stati finiti di tipo Mealyin grado di eseguire la somma fra sequenze di bit. Il valore in uscita al tempo t,o(t), dipende dai valori allo stesso istante sui due ingressi, I1(t) e I2(t), nonche’ dalriporto generato dalla somma effettuata sui bit in ingresso al tempo precedente; valorerappresentato dallo stato dell’automa.

Sommatore

Seriale

1 0110

5 4 3 2 1

I1

0 0110

5 4 3 2 1

I2

0 0111

5 4 3 2 1

O

I1I2

I1I2 I1I2

I1I2

In

Stato

1,11,01,00,11

1,00,10,10,00

11100100 0 1

11/0

01/0

10/0

11/1

11/0

01/1

10/1

00/0

Figura 5.4: Automa di Mealy che esegue la somma di due interi, forniti in ingressocome sequenze di bit.

5.2 Elementi di memoria

In questa sezione studieremo alcune reti sequenziali elementari aventi esattamente duestati di stabilita’. Per tale motivo questi circuiti sono detti bistabili. Studieremo duerealizzazioni, una asincrona e l’altra sincrona. Nella realizzazione asincrona, la retereagisce ad un nuovo valore d’ingresso non appena viene applicato. Nella realizzazione

5.2. ELEMENTI DI MEMORIA 105

sincrona, la rete prevede un ingresso di sincronizzazione; la rete reagisce o ”sente”gli ingressi, solo in precisi momenti stabiliti da questo segnale di sincronizzazione.Esistono due varianti: la rete puo’ essere o sensibile ad un livello del segnale disincronizzazione, nel qual caso il segnale e’ anche detto di abilitazione, oppure al suocambiamento (transizione) da un livello ad un altro.

5.2.1 Latch SR (Set Reset)

La prima rete sequenziale che studieremo e’ una rete composta da 2 porte NOR col-legate in modo che formino un circuito con una retroazione. Per comprendere il fun-zionamento del circuito, il comportamento di una porta NOR deve essere immaginatoalla stregua di un invertitore con comando, si veda la Figura 5.5.

Uno dei due ingressi della porta, x2 nel nostro esempio, e’ considerato ingressodi controllo. Quando sull’ingresso di controllo e’ presente il valore logico 0, Figura5.5.(a), il valore dell’uscita, y, e’ pari a quello dell’altro ingresso negato, ossia y = x1,come e’ facile verificare dall’ispezione della tabella di verita’ della porta. Se invecex2 = 1, Figura 5.5.(b), allora l’uscita e’ pari a 0. Pertanto, il segnale di controllodetermina se la porta si comporta come un NOT, oppure come un generatore delvalore logico 0, Figura 5.5.(c).

00

01 X1

X2

X1

X2

0 1

0

1

Tabella verità NOR

Y

X1

1

0

X1

0

X1

0

X1

X2=0

X2=1

(a)

(b)

(c)

Figura 5.5: La porta NOR come porta NOT con comando.

La Figura 5.6 riporta lo schema della rete sequenziale che realizza il bistabile.Questo circuito e’ detto latch Set Reset; esso e’ dotato di due ingressi, S (Set) ed R(Reset), e due uscite, Q e Q′.

Analisi statica Cerchiamo ora di comprende la relazione che esiste fra i valori iningresso e quelli in uscita in termini statici. Analizzando il circuito di Figura 5.6, edusando l’espressione algebrica che lega l’uscita della porta agli ingressi, ricaviamo

Q = Q′ +R


S

RQ

Q’

Figura 5.6: Rete sequenziale che realizza un latch SR.

eQ′ = Q+ S

Quando R = 0 ed S = 0 troviamo

Q = Q′ + 0 = Q′

eQ′ = Q+ 0 = Q

Con questi valori in ingresso entrambe le porte NOR si comportano come una portaNOT e formano cosi il circuito di Figura 5.7. Le porte NOT danno vita ad un loopautorigenerativo lungo il quale possono persistere le coppie di valori Q = 0, Q′ = 1oppure Q = 1, Q′ = 0. In altri termini, gli ingressi R = S = 0 sono compatibili siacon l’uscita Q = 1, Q′ = 0 che Q = 0, Q′ = 1. Sono questi i due soli stati stabili checaratterizzano il circuito.

(a) (b)

Q

Q’

Figura 5.7: (a) Circuito formato dalle due porte NOR nel caso S = 0,R = 0. (b) lastessa configurazione ridisegnata per mettere meglio in evidenza l’anello formato daidue NOT.

Vediamo ora cosa succede quando S = 1 e R = 0; troviamo

Q′ = 1 +Q = 1 = 0

mentreQ = 0 + 0 = 0 = 1

Queste sono le uniche uscite compatibili con gli ingressi. Per simmetria, quando S = 0e R = 1 si avra’ chiaramente Q′ = 1 e Q = 0.


L’ultimo caso da esaminare e’ S = 1 e R = 1. Questa configurazione d’ingressonon e’ ammessa. Il motivo e’ che sarebbe poi impossibile stabilire, con certezza, lostato finale della rete quando questo ingresso viene modificato. Per comprenderne leragioni analizziamo il comportamento dinamico del circuito.

Analisi dinamica La Figura 5.8 riporta un diagramma temporale che mostra larelazione dei segnali in ingresso ed uscita al circuito. Le frecce che appaiano nel dia-gramma temporale indicano una relazione causa-effetto. Se la variazione di un segnaleprovoca la variazione di un altro segnale, allora questi due segnali sono collegati dauna freccia che ha origine dalla prima variazione e termina sulla seconda variazione.

Consideriamo il circuito al tempo t1. L’ingresso e’ S = 0, R = 0 e l’uscita Q =0, Q′ = 1. Al tempo t2, S passa da 0 ad 1 e causa una variazione dell’uscita Q′ da 1a 0. Questo e’ dovuto al fatto che l’uscita di una porta NOR, quando un ingresso e’1, e’ 0 - vedi Figura 5.5.(b); in altri termini, S = 1 forza Q′ ad assumere il valore 0.Quando pero’ Q′ diventa 0, la seconda porta NOR inverte il segnale al suo ingresso(R=0); circostanza e’ indicata dalla freccia che collega la transizione di Q′ con quelladi Q.

L’effetto finale del passaggio da S = 0, R = 0 ad S = 1, R = 0 e’ quindi che l’uscitafinale sara’ Q = 1, Q′ = 0. Si noti che i valori finali in uscita sono indipendenti daquelli iniziali; con S = 1, R = 0, l’unica uscita stabile (compatibile indefinitamentecon gli ingressi) e’ Q = 1, Q′ = 0.

Al tempo t3, S diventa 0 nuovamente. Questa variazione non comporta alcuncambiamento delle uscite; l’ingresso S = R = 0 e’ infatti compatibile con le usciteattuali, Q = 1, Q′ = 0.

Al tempo t4, R diventa 1. Per simmetria, il circuito reagisce in modo analogo aquanto visto per il passaggio di S ad 1. Alla fine del transitorio Q = 0, Q′ = 1.

R

S

Q

Q’

tempo

t1 t3t2 t4

Figura 5.8: Andamento temporale dei segnali in latch SR.

Memoria Da quanto detto finora si puo’ concludere che il circuito sequenziale diFigura 5.6 possiede una ”memoria”. Supponendo che ad un dato istante siano S =R = 0 e’ possibile, esaminando il valore delle uscite, determinare quali erano i valorilogici presenti in ingresso prima di quelli attuali.

Un modo equivalente per esprimere la proprieta’ di memoria del circuito e’ affer-mare che il valore delle uscite, a seguito dell’applicazione dell’ingresso S = R = 0,


dipende dal valore passato degli ingressi, quello cioe’ presente prima che i nuovi va-lori fossero applicati. Questo e’ anche il motivo per cui la configurazione d’ingressoS = R = 1 non e’ consentita. Infatti, supponiamo che il segnale in ingresso cambida 11 a 00. Tale transizione solo idealmente e’ istantanea1. Nella pratica si potrebbeavere sia la transizione

11→ 10→ 00

quanto quella11→ 01→ 00

e lo stato finale dipenderebbe da quale delle due evoluzioni si presentano in ingresso(race condition).

La Figura 5.9 riporta il simbolo utilizzato per indicare un Latch SR insieme conla tavola di verita’ che ne riassume le caratteristiche. Nella tavola, l’uscita Q′ e’rimpiazzata dal simbolo Q poiche’, come abbiamo visto, tale uscita acquisisce sempreil valore negato di Q. Inoltre l’indice n indica il tempo corrente ed n+1 quello futuro.

S

R

Q

Q1010

Non usata11

0101

QnQn00

Qn+1Qn+1RS

Figura 5.9: Simbolo standard per indicare un latch SR e relativa tabella di verita’.

Il latch e’ un elemento asincrono. Il circuito reagisce a nuovi valori d’ingresso nonappena questi sono applicati.

5.2.2 Il Latch D con abilitazione a livello

Il latch SR puo’ essere utilizzato per costruire un altro tipo di latch chiamato latch D.Il latch D ha un unico ingresso per i dati (D), ed un altro ingresso per l’abilitazione(Enable, E). Esso e’ l’elemento di base per memorizzare un singolo bit. Il latch D e’ottenuto dal latch SR come mostrato in Figura 5.10.

Quando E = 0, entrambi gli ingressi al latch SR sono nulli e quindi l’uscita di talelatch non cambia (Figura 5.9). Quando E = 1, il latch SR riceve S = D,R = D.L’uscita del latch e’ quindi Q = D. La Figura 5.11 riporta la descrizione del latch Din termini di automa di Moore.

5.2.3 Flip flop D

In molti casi, come vedremo, e’ fondamentale che il bistabile legga il dato in ingressoper il periodo strettamente necessario affiche’ esso possa cambiare stato. Il circuito cheesibisce questo comportamento si chiama flip-flop. Un flip flop di tipo D e’ particolare

1Nel caso teorico di cambiamento istantaneo il circuito entrerebbe in uno stato di metastabilita’.


S

R

Q

Q

D

E

D

E

Figura 5.10: Realizzazione di un Latch D e relativo simbolo.

0/0 1/1

D=1,E=1

E=0

E=1,D=1

E=0

E=1,D=0

D=0,E=1

Figura 5.11: Automa di Moore che descrive il latch D.

tipo di flip-flop dotato di un segnale di temporizzazione (clock) che abilita la lettura deldato solamente per un breve periodo di tempo a cavallo della transizione del segnaledi clock. Se la lettura (campionamento) del segnale avviene durante la transizionebasso/alto (fronte di salita del clock) il flip flop si dice sensibile al fronte di salita delclock; altrimenti sensibile al fronte di discesa.

La figura 5.12 riporta il simbolo grafico di un flip flop di tipo D. L’ingresso per ilsegnale di sincronizzzaione e’ indicato con C; il triangolo indica che si tratta di un flipflop, ossia un bistabile sensibile ad una transizione del clock. Se e’ presente (assente)il pallino, allora il campionamento del dato avviene durante la transizione alto/basso(basso/alto).

D

C

D

C

Figura 5.12: Simbolo grafico di un flip flop di tipo D.

Tempi caratteristici L’analisi approfondita di un flip flop porterebbe ad affermareche affinche’ esso funzioni correttamente e’ necessario che il segnale in ingresso sia


C

D

Q

valido non valido

valido

tp

tSETUP tHOLD

Figura 5.13: Vincoli temporali per un corretto campionamento de dato in ingresso adun flip-flop D.

costante per un periodo minimo, sia prima che dopo il fronte attivo del clock . Piu’precisamente si definiscono (Figura 5.13)

• tempo di set-up, tempo minimo durante cui l’ingresso deve rimanere costanteprima del fronte attivo del clock

• tempo di hold, tempo minimo durante cui l’ingresso deve rimanere costantedopo il fronte attivo del clock

Un altro tempo caratteristico dei flip-flop e’ il ritardo di propagazione, o propaga-tion delay (tp nella Figura 5.13). Esso indica l’intervallo di tempo che trascorre dalmomento in cui un nuovo valore in ingresso viene campionato (fronte attivo del clock)fino al momento in cui il nuovo valore e’ stabile in uscita.

5.3 Registri

Un registro e’ un elemento in grado di memorizzare n bit ed e’ realizzato sfruttandoaltrettanti flip-flop di tipo D. Esistono diversi tipi di registri caratterizzati dal modocon cui sono caricati i dati (serie o parallelo) e dalla presenza di segnali di controllo.

5.3.1 Registri a caricamento parallelo

La Figura 5.14 mostra un registro a caricamento parallelo. Il registro campiona i datiin ingresso ad ogni colpo di clock. Si dice anche che il registro viene scritto ad ognifronte attivo del clock.

La figura 5.15 riporta un diagramma temporale che ne schematizza il funziona-mento. Il registro ha ampiezza n = 4. Il valore in ingresso e’ indicato con IN(4:1),quello in uscita con OUT(4:1). L’uscita del registro segue le variazioni del segnale iningresso. Una nuova uscita viene dopo il caratteristico tempo di propagazione.

Registri di questo tipo sono interposti fra reti combinatorie e sono in grado digarantire il disaccoppiamento fra le reti collegate, nel senso che l’uscita di una retecombinatoria dipende solo dall’uscita della rete combinatoria che la precede.

5.3. REGISTRI 111

D

C

D

C

D

C

D

C

C

IN3 IN2 IN1 IN0

OUT0OUT1OUT2OUT3

Figura 5.14: Un registro da 4 bit realizzato mediante 4 flip flop di tipo D.

R

E

G

IN(4:1) OUT(4:1)

C

C

IN(4:1) 0xC 0xD 0xE 0xF

OUT(4:1) 0xC 0xD 0xE 0xF

Figura 5.15: Andamento temporale dei segnali in un registro da 4 bit.

5.3.2 Registri a caricamento parallelo con ingressi di controllo

La caratteristica di questi registri e’ che e’ possibile stabilire, mediante segnali dicontrollo, quando leggere il dato memorizzato nel registro o scriverne del registro unonuovo. L’uscita del registro puo’ essere messa ad alta impendenza. La cella elementaredel registro e’ riportata in Figura 5.17.

I segnali di controllo hanno il seguente ruolo.

• WR (Write). Controlla la scrittura del registro

– WR=1. Il registro puo’ essere scritto. La scrittura avverra’ sul prossimofronte attivo del clock.

– WR=0. Il segnale in uscita viene riproposto in ingresso e ”riscritto” alprossimo segnale di clock; l’uscita del registro cioe’ non cambia.

• RD (Read). Controlla la lettura del registro

– RD=1, il registro pone in uscita il valore memorizzato.

– RD=0, l’uscita viene posta in alta impedenza


RC2R

E

G

R

E

G

RC3RC1....

Figura 5.16: Collegamento di reti combinatorie mediante registri.

D

C

RD

WR

CLK

IN

OUT

Figura 5.17: Cella elementare di un registro ad un bit con controllo sulle operazionidi scrittura e lettura.

Un registro ad n bit si ottiene collegando n celle elementari. Le celle ricevono glistessi segnali di comando e lo stesso clock. I dati sono caricati e letti in parallelo.Questo registro verra’ indicato simbolicamente come riportato in Figura 5.18.

REGISTROclock

input

output

RD

WR

n

n

Figura 5.18: Un registro ad n bit a caricamento parallelo sincrono e controllo sulleoperazioni di lettura e scrittura.

Grazie ai segnali di controllo ed alla presenza dell’uscita ad alta impendenza,registri di questo tipo si possono collegare mediante un bus, come schematizzato inFigura 5.19. In questo modo e’ possibile trasferire il contenuto di un registro in altriregistri. Per il corretto funzionamento e’ ovviamente necessario che un solo registroinviare i propri dati sul bus (ossia solo puo’ essere asserito un solo segnale di lettura).

5.4. REALIZZAZIONE DI UN AUTOMA MEDIANTE RETE LLC 113

R3

BUS

RD3

WR3R2

RD2

WR2R1

RD1

WR1

Figura 5.19: Schema di collegamento di 3 registri tramite un bus. Il segnale ditemporizzazione.

5.3.3 Registri a scorrimento (shift register)

Un registro a scorrimento (shift register) accetta un solo bit in ingresso, I, e lo spostadi una posizione ad ogni nuovo ciclo clock. Uno shift register a 4 bit e’ riportato in Fi-gura 5.20. Ad ogni colpo di clock i dati in I,Q0,Q1,Q2 sono trasferiti, rispettivamente,in Q0, Q1, Q2, Q3. Il dato in Q3 viene perso.

D

C

D

C

D

C

D

C

C

I

Q0 Q1 Q2 Q3

Figura 5.20: Realizzazione di uno shift register a 4 bit mediante flip-flop elementari.

Uno shift register bidirezionale puo’ operare sia a destra (right shift) che a sinistra(left shift). Negli registri a scorrimento con caricamento in parallelo, e’ possibilecaricare i dati in parallelo. Nei registri circolari, l’ultimo bit non viene perso, mainserito al posto del primo.

5.4 Realizzazione di un automa mediante rete LLC

Siamo adesso in grado di affrontare il problema di come realizzare un automa a statifiniti. Prenderemo in considerazione un particolare tipo di realizzazione, molto diffusa,che sfrutta il modello strutturale dovuto ad Huffman (Figura 5.21).

Lo stato dell’automa e’ memorizzato in un registro sincrono, detto registro di sta-to, come quello descritto in Sezione 5.3.1. Le funzioni δ ed ω sono invece realizzatemediante reti combinatorie. La rete sequenziale che si ottiene seguendo questo mo-dello e’ detta di tipo LLC (Level Level Clocked). Questo indica che (i) tutti i segnalidi ingresso e di uscita alla rete sono a livelli, ossia il segnale di ingresso e’ mantenutoper un tempo sufficientemente lungo da garantire che l’uscita abbia terminato il tran-


Input

Output

StatoPresente

Stato Futuro

Registro di stato

Clock

δδδδ

ωωωωInput

Output

StatoPresente

Stato Futuro

Registro di stato

Clock

δδδδ

ωωωω

Modello strutturale per automa di Moore Modello strutturale per automa di Mealy

Figura 5.21: Modelli strutturali di Huffman.

sitorio; (ii) il cambiamento di stato e’ determinato da un segnale di sincronizzazione(clock), li ritmo della rete e’ cioe’ scandito dai fronti attivi del segnale di clock.

Tralasciando gli aspetti legati alla sintesi ottima, per il quale si rimanda ai testidi reti logiche, la sintesi di un automa seguendo il modello di Huffam non presenta -concettualmente - grosse difficolta’, ed avviene secondo i seguenti passi

1. Codifica dell’alfabeto d’ingresso: definire una corrispondenza fra gli n simbolid’ingresso ed il vettore binario dei segnali d’ingresso

2. Codifica dell’alfabeto d’uscita: definire una corrispondenza fra gli m simbolid’ingresso ed il vettore binario dei segnali d’uscita

3. Codifica dello stato: rappresentare i k stati mediante le variabili binarie registromemorizzate nel registro di stato

4. Scrittura delle tabelle di verita’ delle funzioni δ ed ω

5. Sintesi delle funzioni δ ed ω

Esempio 5.4. L’addizione seriale di due stringhe di bit puo’ essere descritta mediantel’automa di Mealy di Figura 5.4. La procedura di sintesi e’ semplificata dal fatto chel’alfabeto di ingresso e di uscita e’ {0, 1}. Per quanto riguarda la codifica dello stato,conviene numerare i due stati in modo che lo stato 0 indichi assenza di riporto ed 1,invece, la presenza di riporto. Per quanto riguarda il passo 4, dalla tabella di flussoe’ facile ricavare la definizione della funzione di stato prossimo (δ) e di uscita (ω);la figura 5.22 riporta la definizione mediante mappa Karnaugh e la relativa sintesi.Poiche’ le due mappe di Karnaugh definiscono l’uscita ed il riporto di un full adder(vedi Capitolo 4), la rete sequenziale puo’ essere realizzata come in Figura 5.23.

Esempio 5.5. Si vuole realizzare un contatore bidirezionale binario modulo 4. Ilcontatore modifica il proprio valore ad ogni impulso di clock (transizione basso-alto).La direzione del conteggio (avanti/indietro) e’ stabilita dall’ingresso (In). Se l’ingresso

5.4. REALIZZAZIONE DI UN AUTOMA MEDIANTE RETE LLC 115

1 0

0 1

1

0

0

1

SP 00 01 11 10

0

1

0 1

1 1

0

1

0

0

00 01 11 10

0

1

y = I0⊕⊕⊕⊕I1⊕⊕⊕⊕SP

I0I1

SP

I0I1

SF = I0I1+ I0SP + I1SP

I0

I1

SP

SF

δδδδ

I0

I1

SP

ωωωω

y

Figura 5.22: Sintesi delle funzioni di stato prossimo e di uscita.

FULL ADDER

φ

I0

I1

y

Riporto

futuro

Riporto

corrente

A

B

Cin

S

Cout

Figura 5.23: Implementazione dell’automa di Mealy per la somma seriale come reteLLC.

e’ U (Up) il valore viene incrementato mentre se l’ingresso e’ D (Down) il valore e’diminuito di una unita’.

Le descrizioni mediante automa di Moore e mediante tabella di flusso sono ripor-tate in Figura 5.24

Vogliamo realizzare il contatore seguendo il modello di Huffman.

Per la codifica dell’ingresso, scegliamo di far corrispondere ad U 1, e D a 0. Per lacodifica dello stato e dell’uscita conviene esprimere i valori che appaiono nella tabelladi flusso mediante due cifre binarie (usando cioe’ il sistema di numerazione in base2).

Con queste posizioni, possiamo procedere con la sintesi della funzione di tran-sizione di stato δ. Siano S1S0 le due cifre binarie che rappresentano lo stato cor-rente, S′1S

′0 quelle dello stato futuro ed I il valore dell’ingresso. Possiamo scrivere

S′0 = δ0(I, S1, S0) e S′1 = δ1(I, S1, S0).

La Figura 5.25 riporta le tabelle di verita’ di S′1 ed S′0 nonche’ le tabelle diKarnaugh, mediante le quali e’ possibile procedere alla semplificazione del circuitocombinatorio che le realizza.

Troviamo cosi che


0/0 1/1

3/3 2/2

D

D

D

D

U

U

U

U

Automa di Moore

12

01

23

30

U D

0

1

2

3

2

1

3

0

Out

Tabella di transizione

Figura 5.24: Specifica del contatore avanti/indietro.

111

110

101

100

011

010

001

000

11

00

01

10

10

00

01

11

IS1S0 S’1 S’0

0

0

1

1

10

10

00 01 11 10

0

1

S1S0

I

S’0

0

1

0

1

11

00

00 01 11 10

0

1

S1S0

I

S’1

(a)

(b)

(c)

Figura 5.25: La funzione di transizione di stato dopo la codifica degli stati (a). Ta-bella di Karnaugh per il bit meno significativo dello stato futuro (b) e di quello piu’significativo (c). Nel primo caso e’ possibile semplificare la rete combinatoria.

• S′0 = δ0(I, S1, S0) = S0

• S′1 = δ1(I, S1, S0) = IS1S0 + IS1S0 + IS1S0 + IS1S0

La Figura 5.26 riporta uno schema a blocchi dell’intera rete sequenziale. Glielementi di memoria sono flip-flop di tipo D.

5.5 Memorie RAM

Concludiamo questo capitolo con una panoramica sulle memorie RAM. Con il ter-mine memoria RAM si intende una memoria elettronica per la scrittura e letturadi dati il cui tempo di accesso non dipende dalla locazione di memoria acceduta(Random-Access Memory). Le memorie RAM possono essere di tipo statico o di-namico, chiamate rispettivamente Static RAM, SRAM, e Dynamic RAM (DRAM)(Figura 5.27).

Il tipo statico usa come elemento di memorizzazione un flip-flop, pertanto i datisono conservati fino a quando la memoria riceve alimentazione dall’esterno. Il tipodinamico usa invece come elemento di memorizzazione la capacita’ elettrica imma-gazzinata in un condensatore; pertanto affinche’ i dati possano essere mantenuti e’necessario un processo periodico di ricarica, chiamato refreshing.

5.5. MEMORIE RAM 117

δ1

δ0

S’0

S’1

S1

S0

In

Out1

Out0

Figura 5.26: Schema a blocchi della rete sequenziale che realizza l’automa.

Le SRAM hanno tempo di accesso inferiore alle DRAM. Tuttavia, le DRAM, pervia della lore semplicita’ di realizzazione, possono memorizzare piu’ bit per unita’ disuperficie.

I tipi principali di SRAM sono il tipo sincrono, ed il tipo asincrono. I tipi principalidelle memorie DRAM sono i tipi FPM (Fast Page Mode, EDO (Extented Data Out),BEDO (Burst EDO), ed i due tipi sincroni, SDRAM (Synchronous DRAM) e le DDR(Double Data Rate).

RAM

RAMStatiche

RAMDinamiche

SDRAM DDRBEDODRAM

EDODRAM

FPMDRAM

RAMAsincrone

SRAMSincrone

Sincrone

Figura 5.27: I principali tipi di memorie RAM.

Nei tipi sincroni le operazioni di lettura e scrittura sono sincronizzate medianteun clock, mentre questo non accade nel caso di RAM asincrone.

Memorie statiche

Le SRAM sono costruite mediante flip-flop di tipo D. Per questo motivo non si possonoraggiungere livelli di integrazione elevati; tuttavia i tempi di accesso sono piu’ bassirispetto alle DRAM. Le SRAM sono commercialmente disponibili in forma di chip


a media scala di integrazione. All’interno di un calcolatore le SRAM sono sfruttatecome memoria cache.

SRAM asincrone . La Figura 5.28 riporta un tipico chip di memoria 32K × 8.Questo vuol dire che il chip e’ in grado di memorizzare 215 = 32K locazioni di me-moria da 8 bit ciascuna. Le linee del chip servono per fornire in ingresso l’indirizzo(address lines), per selezionare il chip (CS, Chip Select), per comandare un’operazio-ne di lettura (OE, Output Enable) o di scrittura (WE, Write Enable) nonche’ perprelevare o inviare il dato (data lines) dalla memoria. Si noti che le linee dati sonobidirezionali (buffer three-states). Per convenzione, quando un segnale appare nellaforma negata (ad esempio CS), allora la funzione controllata da quel segnale vieneabilitata quando il valore del segnale e’ basso.

Figura 5.28: Un esempio di circuito integrato relativo ad una memoria 32k × 8.

La memoria e’ di tipo asincrono. Non ci sono cioe’ segnali di sincronizzazione iningresso al chip. Ad esempio, per leggere un dato e’ sufficiente fornire in ingresso l’in-dirizzo della locazione di memoria, selezionare il chip (CS=0) ed abilitare la memoriaalla lettura (OE=0). Il dato apparira’ in uscita dopo un certo intervallo di tempodalla richiesta di lettura, detto tempo di accesso.

SRAM sincrone Le SRAM sincrone usano internamente dei registri mediante cuisincronizzare tutti i segnali ricevuti dall’esterno o inviati all’esterno. In questo modole operazioni di lettura e scrittura possono essere sincronizzate con altre attivita’esterne alla memoria.

Memorie dinamiche

Le memorie RAM Dinamiche (DRAM) sono ampiamente usate nei calcolatori elet-tronici e sono sinonimo, tout-court, di memoria RAM. Il principio alla base dellarealizzare della funzione di memoria consiste nello sfruttare la carica elettrica imma-gazzinata in un condensatore formato mediante un transistor di tipo MOS. La caricaaccumulata si mantiene per alcuni millisecondi. E’ quindi necessario ripristinare (rin-frescare, refresh) periodicamente la carica per garantire la memorizzazione dei dati.

5.5. MEMORIE RAM 119

La frequenza di refresh dipende dalle dimensioni della memoria e dall’organizzazioneinterna.

La semplicita’ della realizzazione consente, al contrario delle SRAM, di avere unelevato grado di integrazione. Questo porta ad adottare una tecnica di multiplexingdelle linee di indirizzo, in modo da ridurre il numero totale di pin di un chip dimemoria.

L’indirizzo di una cella di memoria viene fornito in due fasi, e questo comporta uncerto rallentamento sul tempo d’accesso. Per leggere o scrivere un dato, e’ necessariofornire alla memoria prima l’indirizzo di Riga (Row Address Strobe, RAS) e poi quellodi colonna (Column Address Strobe).

Come per le memorie SRAM anche le memorie DRAM possono lavorare in modoasincrono o sincrono. Le DRAM sincrone sono ampiamente usate per via delle presta-zioni migliori. Le operazioni di lettura o scrittura sono sincronizzate su un fronte delclock. Nel caso delle DRAM DDR, entrambi i fronti del segnale di clock sono attivi,e questo porta a raddoppiare il ritmo di trasferimento dei dati.

All’interno dei calcolatori le DRAM si trovano in moduli preassemblati aventidiverse configurazioni fisiche caratterizzate da un diverso numero di pin. I modulisono noti con gli acronimi di SIMM (72 pin), DIMM (168 o 184), RIMM (184 pin). Imoduli SIMM sono ormai in disuso.

Capitolo 6

Microarchitettura

Siamo ora in grado di mettere insieme i moduli elementari studiati finora, multiplexer,codificatori, ALU, registri, etc., per costruire una CPU. Si tratta di un salto moltoimportante perche’ richiede di dar vita ad un sistema digitale complesso, al qualediamo il nome di microarchitettura.

Mentre la realizzazione dei moduli di base e’ una procedura standard e per moltiaspetti obbligata, influenzata in pratica solamente da fattori tecnologici, la realizza-zione di una microarchitettura offre invece molti gradi di liberta’ in piu’, poiche’ e’necessario stabilire la sua organizzazione, ossia come i vari elementi interagiscono fraloro, cercando di ottenere le massime prestazioni possibili.

Come per i capitoli precedenti iniziamo il nostro studio dando un modello astrattodella microarchitettura. Si tratta di un modello basato sulla decomposizione del siste-ma in due parti, individuate sulla base delle due funzioni fondamentali di ogni sistemadigitale complesso, ossia la funzione operativa e quella di controllo. Vedremo poi inseguito, gradualmente, come realizzare una semplice microarchitettura completa.

6.1 Modello funzionale

Da un punto di vista funzionale, ogni microarchitettura e’ composta da due parti ounita’, chiamate Unita’ Operativa (UO), o data path, ed Unita’ di Controllo (UC),vedi Figura 6.1.

Le due unita’ si comportano esternamente come due automi a stati finiti, sincro-nizzati dallo stesso clock, ϕ. I segnali in ingresso ed in uscita dalle unita’ sono alivello e la loro variazione avviene solo ad un nuovo ”colpo di clock”. Un colpo diclock rappresenta un impulso periodico che il sistema riceve dall’esterno (in pratica,l’impulso e’ un fronte del segnale di clock).

La distanza fra due impulsi, e quindi il periodo del clock, e’ tale da garantire cheun nuovo colpo di clock sia generato solo dopo che tutti i segnali abbiano esaurito iloro transitori. In altri termini, per quanto riguarda i segnali le unita’ agiscono comereti LLC.

121

122 CAPITOLO 6. MICROARCHITETTURA

UNITA’ OPERATIVA

UNITA’ CONTROLLO

X Y

Z

C

I

k

k

k-1

k+1

comandi condizioni

dati in dati out

φ

φk+1

φ

Figura 6.1: Decomposizione funzionale di un sistema digitale complesso

Per comodita’, l’intervallo di tempo fra i colpi di clock k e k + 1 verra’ chiamatoslot temporale.

Unita’ di controllo. L’unita’ di controllo dispone di un insieme di linee per l’in-gresso I di segnali di Istruzione, un insieme di linee per l’ingresso Z dei segnali dicondizione, ed un insieme di linee per l’uscita dei segnali C di controllo o comando.

L’unita’ di controllo interpreta le istruzioni generando segnali di comando direttiverso la parte operativa la quale esegue l’istruzione. Di regola, l’esecuzione di un’i-struzione avviene mediante passi elementari intermedi, ognuno eseguito durante unoslot temporale. Il risultato intermedio puo’ avere influenza sul modo con cui l’ese-cuzione debba procedere. A tale scopo la parte operativa invia alla parte controlloopportune informazioni, sotto forma di segnali di condizione.

Unita’ operativa. L’unita’ operativa dispone di un insieme di linee per l’ ingressoX dei dati, un insieme di linee per l’ingresso C dei segnali di controllo, generatidall’unita’ di controllo, un insieme di linee per l’uscita Y dei dati, ed un insiemedi linee per l’uscita Z dei segnali di condizione. L’unita’ operativa agisce da slaveeseguendo i comandi che l’unita di controllo genera. L’esecuzione avviene sfruttandole risorse di calcolo di cui l’unita’ e’ composta.

Vincoli strutturali Il comportamento esterno di ognuna delle due unita’ puo’ esse-re alla Moore oppure alla Mealy. Nel primo caso il valore dell’ uscita da una unita’ altempo k dipende al piu’ da un numero finito di ingressi passati, conteggiati a partiredallo slot k − 1; nel secondo caso l’uscita e’ anche influenzata dall’ingresso presentenello stesso slot temporale, k.

6.2. OPERAZIONI ELEMENTARI 123

Sono in teoria possibili quattro diverse combinazioni per il modello di Figura 6.1,Moore-Moore, Moore-Mealy, Mealy-Moore e Mealy-Mealy. L’ultima combinazione e’instabile, poiche’ porterebbe ad una indeterminazione dei segnali lungo l’anello diretroazione che appare nella Figura.

6.2 Operazioni elementari

Definiamo operazione elementare un insieme di attivita’ che l’unita’ operativa puo’terminare entro un ciclo di clock. L’esecuzione di un’operazione elementare e’ l’effettodei comandi inviati dall’unita’ di controllo. In questa sezione vedremo due esempi dioperazioni elementari.

6.2.1 Trasferimento dati fra due registri

Come primo esempio applichiamo la decomposizione UC-UO ad un semplice sistemacostituito da due registri, un registro sorgente, SRC, in un registro destinazione,DST . Il nostro sistema deve essere in grado di eseguire due semplici istruzioni

• l’istruzione COPY, mediante la quale il contenuto di SRC viene copiato in DST

• l’istruzione NOP (NO Operation)

Unita’ operativa

L’unita’ operativa e’ composta dalle seguenti risorse

• un registro sorgente

• un registro destinazione

• un bus che collega i registri

Entrambi i registri dispongono dei segnali per la scrittura e la lettura.

Unita’ di controllo

L’unita’ di controllo genera i seguenti

• RD1,WR1 (lettura/scrittura verso il registro sorgente)

• RD2,WR2 (lettura/scrittura verso il registro destinazione)

L’unita’ di controllo riceve l’istruzione da eseguire mediante un singolo segnale,copy. copy=1 rappresenta l’istruzione COPY, mentre copy=0 l’istruzione NOP.


φ

SRC DEST

WR1

RD1

WR2

RD2

copy=1RD

1 = 0

WR1 = 0RD2 = 0WR2= 0

RD1 = 1

WR1 = 0RD2 = 0WR2= 1

copy=1

copy=0

NOPSRC� DEST

(a)

(b)

(c)

copy=0copy=1

copy=1

copy=0

copy=0

U.C.

copyinit

U.O.

Figura 6.2: (a) sistema complessivo per il trasferimento di un dato dal registro SRCal registro DEST ; (b) automa di Moore per la specifica dell’unita’ di controllo intermini di operazioni effettuate; (c) automa di Moore per la specifica dell’unita’ dicontrollo in termini di segnali generati.

Realizzazione e vincoli temporali

La Figura 6.2 riporta come realizzare il sistema. La parte operativa si riduce allasemplice connessione dei registi mediante il bus.

Per quanto riguarda l’unita’ di controllo, la generazione dei segnali di controllo e’affidata ad un automa a due stati. In Figura 6.2.(b) uno stato riporta esattamentetutti i segnali di controllo da generare, mentre in Figura 6.2.(c) uno stato e’ etichettatocon

SRC → DEST

Questa notazione indica simbolicamente l’effetto dei segnali di comando e va letta nelseguente modo: il contenuto di SRC viene copiato in DEST . Torneremo tra brevesu questo simbolismo.

Poiche’ la unita’ di controllo ha soli due stati e’ sufficiente, per la sua realizzazione,usare un flip-flop (Figura 6.3.(a)).

La Figura 6.3.(b) illustra l’analisi sui vincoli temporali, nell’ipotesi che la gene-razione dei segnali di controllo sia sincronizzata sul fronte di discesa del clock (ossial’automa di controllo cambia stato) mentre un registro venga scritto sul fronte di sa-lita del clock. Sia t l’istante di tempo in cui inizia la copia. Trascurando i ritardi dipropagazione dei segnali lungo i collegamenti fisici, si ha che

• il segnale di lettura, RD1 arriva al registro SRC al tempo t1 = t + τc (τc =tempo di propagazione del flip flop)

6.2. OPERAZIONI ELEMENTARI 125

D

Reset

Q

INIT

COPYRD1

WR2

RD2

WR10

φ

(a)

φ

t1

τc τout ts

th

T

t2 t3

t4

(b)

Figura 6.3: (a) realizzazione dell’unita’ di controllo; (b): diagramma temporale deltrasferiemento

• il dato viene fornito in uscita in forma stabile a partire dal tempo t2 = t1 + τout(τout=tempo lettura del registro SRC)

• il clock puo’ passare da basso ad alto non prima del tempo t3 = t2 + ts (ts =tempo di set-up richiesto dal registro DST )

• il dato in ingresso a DST deve rimanere stabile almeno fino al tempo t4 = t3+th(th = tempo di hold)

Si ha pertanto

T ≥ τc + τout + ts + th

dove T e’ il periodo del clock.

Osserviamo che se th < τc + τout, come di norma accade, allora il dato in ingressoa DST non puo’ variare prima di th (infatti pur assumendo che il clock ritorni allivello basso immediatamente dopo la sua transizione positiva facendo cosi, nel casopeggiore, passare l’unita’ di controllo nello stato NOP con conseguente disabilitazionedell’uscita di SRC, il dato in ingresso a DST continuera’ a rimanere invariato per untempo τc + τout) Per cui

T ≥ τc + τout + ts

6.2.2 Impiego di una ALU

Ogni unita’ operativa possiede fra le sue risorse una ALU. La ALU, lo ricordiamo,non e’ altro che una rete combinatoria. Come tale, per il suo utilizzo e’ sufficienteche i dati siano posti al suo ingresso ed il risultato prelevato, dopo un certo tempo dipropagazione, tALU , dall’uscita. L’utilizzo della ALU e’ la parte fondamentale di ogniistruzioni aritmetico logica. Vediamo adesso due esempi che illustrano come poterimpiegare una ALU.


BA

R

Figura 6.4: Impiego di una ALU mediante tre registri.

ALU a tre registri

La prima soluzione si basa su tre registri, due per memorizzare i dati in ingresso ed unoper il risultato (Figura 6.4). L’automa di controllo e’ analogo a quello di Figura6.3.(a),con la differenza che nello stato che appare a destra della figura, i segnali di controlloda generare sono RDA = 1(leggi A)RDB = 1(letti B) RWR = 1 (Scrivi R). Inoltredeve essere generato il valore OPCode associato all’operazione della ALU selezionata.E’ importante sottolineare che se l’uscita dei registri A e B e collegata solamente allaALU, allora non e’ necessario prevedere un segnale di lettura.

ALU con accumulatore

In questa architettura il risultato della ALU viene memorizzato in uno dei registri dipartenza, chiamato per questo registro accumulatore, Figura 6.5. La possibilita’ dileggere e scrivere contemporaneamente il registro accumulatore deriva dal fatto che ilnuovo valore che si sta scrivendo modifica l’uscita della ALU solo dopo che il valoree’ stato gia’ scritto. Per effettuare l’operazione e’ sufficiente generare il segnale discrittura del registro accumulatore ed codice da inviare alla ALU.

6.3 Sequenza di operazioni elementari

Un’operazione elementare viene eseguita dalla parte operativa in un solo ciclo diclock. Di norma pero’ l’esecuzione di un’istruzione avviene eseguendo un insiemedi operazioni elementari. L’ordine di esecuzione delle operazioni di questo gruppopuo’ o essere strettamente sequenziale oppure essere influenzato, mediante le variabilidi condizione, dall’esito dell’operazione precedente. In questa sezione studieremo ilprimo caso. Al secondo caso e’ dedicata la sezione successiva.

6.3. SEQUENZA DI OPERAZIONI ELEMENTARI 127

BA

Figura 6.5: Soluzione con accumulatore per l’uso di una ALU.

TEMP1 TEMP2

OpCode

BA

WT1

WT2

ALU

REGISTRI

WM RM

3

32

Indirizzo

Figura 6.6: Parte operativa per l’esecuzione di una sequenza di operazioni elementari.

6.3.1 Impiego della ALU mediante un banco registri

Con il termine banco registri, o register file, si intende un insieme di registri indi-rizzabili: ogni registro e’ individuato da un indirizzo, mentre segnali di controllo iningresso al banco si riferiscono al registro selezionato dall’indirizzo corrente.

La Figura 6.6 mostra un’ipotetica unita’ operativa composta da un banco da 8registri da 32 bit e da una ALU. La ALU e’ collegata al banco mediante un unico bus.Per poter utilizzare la ALU sono presenti dure registri temporanei.

Supponiamo di voler eseguire la seguente istruzione

R1 = R2 +R1

il cui significato e’: aggiorna registro 1 con la somma del valore corrente con il valorecontenuto registro 2. Questa istruzione da luogo alla seguente sequenza di operazionielementari. La prima operazione serve per copiare il contenuto del del registro 1 inTEMP1. Per far questo, la parte di controllo deve asserire i segnali di controllo RMe WT1, nonche’ inviare al banco registro l’indirizzo 001. In modo sintetico

R1→ Temp1; RM,WT1, indirizzo = 001


1R1�TEMP1

2R2�TEMP2

3ALU.somma�R1

1

-

-

F0

-00110100

110101100

-01000010

F1BAWT2WT1RMWMIND2IND1IND0

1

2

3

Figura 6.7: Unita’ di controllo che governa la una sequenza di 3 operazioni elementari(sopra). Segnali di controllo generati in ogni stato (sotto).

La seconda operazione elementare e’

R2→ Temp2; RM,WT2, indirizzo = 010

con la quale il contenuto del registro 2 viene copiato in TEMP2. Infine, mediantel’operazione elementare

ALU.somma→ R1; WM,OpCode = Somma,BA, indirizzo = 001

si indica il fatto che la parte operativa deve ordinare alla ALU di eseguire al somma(il cui codice operativo e’ Somma) ed al banco registro di scrivere il registro 1. Pereseguire l’istruzione di somma fra due registri sono quindi necessari 3 cicli di clock.

L’unita’ di controllo che governa l’esecuzione seriale delle tre operazioni elementaricorrisponde al semplice automa di Figura 6.7.

6.4 Operazioni elementari condizionate

Nel caso generale una singola istruzione corrisponde ad un insieme di istruzioni ese-guite secondo un ordine che dipende dagli operandi dell’istruzione stessa o dall’esitodi istruzione precedente. Questo caso richiede la progettazione e la realizzazione diuna unita’ di controllo opportuna. In questa sezione studieremo due approcci allarealizzazione dell’unita’ di controllo. Vedremo poi come automatizzare l’esecuzionedella moltiplicazione fra due interi.

6.5 L’unita’ di controllo

In generale, la realizzazione dell’unita’ di controllo puo’ eseguire due approcci diffe-renti. Il primo approccio consiste nel descrivere l’unita’ di controllo come automa diMoore o Mealy e realizzarlo poi mediante tecniche classiche di sintesi. Questo approc-cio porta alla costruzione di unita’ di controllo cosiddette a logica cablata. Il nome

6.5. L’UNITA’ DI CONTROLLO 129

e’ dovuto al fatto che, qualora si rendesse necessario modificare l’unita’, e’ necessariosintetizzare ex-novo il nuovo automa modificato.

Il secondo approccio si fonda su una descrizione algoritmica dell’unita’ di con-trollo e porta alla nozione di microprogrammazione. L’unita’ di controllo realizzatamediante questa tecnica di dice microprogrammata. Come discusso nel Capitolo 1,le motivazione che hanno condotto all’introduzione della microprogrammazione so-no la maggiore semplicita’ progettuale di unita’ di controllo in grado di interpreta-re istruzione complesse, istruzione cioe’ la cui esecuzione richiede molte istruzionielementari.

6.5.1 Unita’ di controllo cablata

Questo approccio consiste nel descrivere l’unita’ di controllo mediante un automa, diMoore o di Mealy. Nel caso di automa di Moore, bisogna porre attenzione affinche’ ivalori che compaiono come condizione sugli archi siano disponibili nel momento in cuil’automa entra nello stato. Supponiamo che nell’entrare nello stato s l’automa generii comandi che danno vita ad una operazione elementare op. A meno che la parteoperativa non operi alla Mealy, nell’automa non puo’ allora comparire una condizioneil cui valore dipende dall’esito di op.

La realizzazione dell’automa avviene mediante tecniche di sintesi ”classiche”, dicui si e’ dato accenno nel Capitolo precedente.

6.5.2 Unita’ di controllo microprogrammata

Alla base di questa tecnica c’e’ la descrizione algoritmica del comportamento tipicodi un automa.

Linguaggio per automi di Moore Consideriamo un automa di Moore. Quandol’automa entra in un nuovo stato, esso genera un nuovo insieme di segnali di controlloche provocano l’esecuzione di una o piu’ operazioni elementari. Dopodiche’ l’automa,sulla base dei valori in ingresso, cambia stato.

Quanto detto, puo’ essere espresso mediante il seguente costrutto linguistico,chiamato microistruzione

L : T ; case(Z) of c1 : goto L1, c2 : goto L2, . . . cm : goto Lm;

dove L indica la label associata alla microistruzione (che corrisponde in sostanza alnumero associato allo stato dell’automa, una volta che gli stati sono numerati), T (Ta-sk) e’ una una lista compatibile di operazioni elementari, dette anche microoperazioni,che possono essere eseguita simultaneamente, Z e’ l’elenco dei segnali di condizione,mentre ci e’ un particolare valore dei segnali di condizione.

Questo costrutto corrisponde in sostanza ad un salto ad m vie. Quando l’automaentra nello stato, esegue T e poi si porta nello stato Li associato alla condizione ciche si e’ verificata.

Nel caso in cui ci siano solo due condizioni possibili (due archi uscenti dallo statodell’automa di cui uno con label c), la microistruzione ha formato


L : T ; if(c) then goto L1 else goto L2;

mentre in caso di assenza totale di alternative il formato e’ semplicemente

L : T ; goto L′

Un insieme di microistruzioni e’ detto microprogramma. Quindi un microprogram-ma costruito mediante i tre costrutti, e’ la descrizione algoritmica di un automa diMoore. La Figura 6.8 riporta un esempio di automa di Moore e relativa descrizionealgoritmica.

0

NOP

1

op1

4

op2

z1=0,z2=1

3

op2

2

op2

z1=1,z2=1

z2=0

z2=0

5

0: NOP; case (z1z2) of

01: goto 1;

11: goto 3:

-0: goto 4;

1: op1; goto 2;

2: op2: goto 5;

3: op3: if (z2=0) goto 2

else goto 4;

4: op4; goto 5;

5: HALT;

Figura 6.8: Un automa di Moore e relativa descrizione algoritmica

Sintesi dell’unita’ di controllo (Moore) Il passaggio dalla specifica dell’unita’di controllo in termine di microprogramma alla sua realizzazione circuitale e’ un pro-cedimento relativamente semplice. L’idea di base consiste nell’interpretare le labeldelle microistruzioni come indirizzi di memoria di una ROM. La struttura di unaparola della ROM contiene poi tutte le informazioni della microistruzione case, cherappresenta il caso piu’ generale di microistruzione. Tali informazioni sono gli indiriz-zi delle prossime microistruzioni possibili da eseguire ed i segnali di controllo relativialla microistruzione.

Prima di illustrare la struttura di tale circuito e’ bene sottolineare che di normail numero di alternative (diramazioni) dell’istruzioni case e’ ridotto; nonostante ilnumero totale di segnali di condizione sia elevato di norma ne viene considerato soloun piccolo sottoinsieme. In questo caso e’ sufficiente che una parola della ROM abbiam′ campi per gli indirizzi, dove m′ e’ il numero massimo di alternative possibili.La memoria conterra’ tuttavia un ulteriore campo, detto di Selezione, utilizzato perindicare quale fra tutte le variabili in ingresso debbano essere prese in considerazioneper valutare la condizione che determina l’indirizzo della prossima microistruzione. Lealtre variabili sono ”mascherate”. Per tale motivo tale circuito si chiama con ingressimascherati.

La Figura 6.9 mostra una possibile struttura di un circuito per eseguire un mi-croprogramma in cui i costrutti case abbiamo al massimo 4 diramazione (m′ = 2).

6.5. L’UNITA’ DI CONTROLLO 131

La struttura della parola di memoria prevede in questo caso gli indirizzi delle 4 alter-native, un campo selezione per selezionare quale delle m linee dei segnali condizioneconsiderare ed un campo T per i segnali di controllo.

0 1 2 3

k

SEGNALI DI

CONTROLLO

SEGNALI DI

CONDIZIONE

ROM

REGISTRO Clock

Decoder Indirizzo

2

m

SelL3

L2

L1

TL0

2 mux

Figura 6.9: Unita’ di controllo associata al linguaggio per la descrizione di automi diMoore nel caso in cui il numero di alternative massimo sia 4 (sono considerate al piu’2 delle m ≥ 2 variabili di condizione).

Linguaggio per automi di Mealy Negli automi di Mealy i valori dell’ingressocorrente influenzano anche l’uscita corrente. Il comportamento tipico di un automadi Mealy e’ quindi rappresentabile mediante il seguente costrutto

L : case(Z) of : c1 : T1 goto L1, c2 : T2 goto L2, . . . cm : Tm goto Lm;

Differentemente dall”automa di Moore, in questo costrutto appaiono prima le microo-perazioni (Ti) e poi l’istruzione di salto alla label della microistruzione (Li) associataalla condizione ci.

Nel caso di due sole condizioni si puo’ usare il costrutto seguente

if (Z) then T1,goto L1 else T2, goto L2

mentre in mancanza di condizioni la sintassi della microistruzione diventa

L : T ; goto L′

La Figura 6.10 mostra un esempio di impiego di questo linguaggio.

Sintesi dell’unita’ di controllo (Mealy) Come nel caso precedente, la strutturadel circuito si basa su una ROM, le cui parole hanno uno schema che ricalca lemicroistruzioni. L’indirizzo della ROM e’ suddiviso in due parti. Nella versione senzamascheramento delle condizioni, una parola di memoria contiene parte dell’indirizzodella prossima microistruzione e l’uscita da produrre. L’altra parte dell’indirizzodipende dall’ingresso attuale, Figura 6.11.


0

1

4

z1=0,z2=1/op1

3 2z1=1,z2=1/op2

z2=0/op3

z2=0/op4

5

0: case (z1z2) of

01: op1; goto 1;

11: op2; goto 3:

-0: op3; goto 4;

1: op3; goto 2;

2: op5: goto 5;

3: if (z2=0) op4;goto 2;

else goto 4;

4: op4; goto 5;

5: HALT;

/op3

/op5

/op4

Figura 6.10: Un automa di Mealy e relativa descrizione algoritmica

k

SEGNALI DI

CONTROLLO

ROM

REGISTRO Clock

Decoder Indirizzo

TLx

SEGNALI DI

CONDIZIONE

m

Figura 6.11: Unita’ di controllo associata al linguaggio per la descrizione di automidi Mealy, senza ingressi mascherati.

6.6 Esempio: calcolo del prodotto fra naturali

Illustriamo adesso mediante un esempio le tecniche esposte. Il nostro obiettivo e’ lacostruzione di una microarchitettura per il calcolo del prodotto P tra due interi senzasegno, A e B, di lunghezza n bit.

Parte operativa L’algoritmo elementare consente di calcolare P mediante una seriedi addizioni progressive

P =n−1∑i=0

Bi × 2iA

Osserviamo che Bi puo’ valere solamente 0 oppure 1, mentre il prodotto 2iA corri-sponde ad uno spostamento a sinistra di A. Cio’ porta alla microrchitettura di Figura6.12. L’unita’ operativa e’ cosi composta

• uno shift register, A, da 2n bit per il moltiplicando, con segnale di controllo SLper shift a sinistra (prodotto per 2).

• un shift register, B, da n bit per il moltiplicatore, con segnale di controllo pershift a destra SR.

6.6. ESEMPIO: CALCOLO DEL PRODOTTO FRA NATURALI 133

• un registro P accumulatore da 2n bit per il prodotto

• una ALU (sommatore) da 2n bit, con segnale di controllo per la scrittura (WR)

• Una porta NOR ad n ingressi per la generazione di un segnale di condizione

UNITA’DI

CONTROLLO

z b0

INIT

φ

SL

BA

P WR

SL SR

UNITA’ OPERATIVA

2n bit

2n bit

n bitφ

SR

WR

φ

φ

Figura 6.12: Microarchitettura per il calcolo del prodotto con particolare dettaglidella unita’ operativa. ϕ e’ il segnale di clock.

L’unita’ operativa produce due segnali di condizione, z e b0. Il primo indica se ilregistro B contiene il valore 0, nel qual caso z = 1. Esso e’ generato dalla porta NORcui sono applicate le cifre di B. L’uscita della porta e’ 1 se e solo se tutte le cifresono nulle. Tale condizione serve come condizione di terminazione dell’algoritmo. Ilsecondo segnale riguarda il valore della cifra di B che deve essere moltiplicata per2iA.

L’unita’ operativa si comporta come un automa di Moore. Se ad esempio duranteuno slot temporale l’unita’ riceve l’ordine di spostare a destra B e per tale spostamentoB diventa 0, allora il segnale z = 0 e’ disponibile all’unita’ di controllo nello slotsuccessivo.

Per quanto riguarda l’unita’ di controllo prenderemo in considerazione entrambigli automi (si ricordi che se l’unita’ operativa fosse di Mealy, allora l’unica opzioneper l’unita’ di controllo sarebbe stata Moore).

Automa di controllo di Moore L’algoritmo del prodotto puo’ essere descrittomediante l’automa di Moore di Figura 6.13. L’automa nasce nello stato DECIDI, e viritorna ogni volta che deve decidere quale altri segnali di controllo generare, a partireda quelli di condizione. Nello stato decidi non viene eseguita alcuna operazione. Glistati 1 e 2 hanno etichetta pari alle microperazioni da eseguire.

A titolo di esempio, la Figura 6.14 riporta l’esecuzione del prodotto fra A = 0110e B = 0101. Ogni riga della tabella contiene lo slot temporale (numero del periododi clock) seguito dai valori dei registri A,B, P e dei segnali di condizione, presi inconsiderazione dell’unita’ di controllo, all’inizio dello slot.


0

DECIDI

1

P+A� P

2

SL(A),SR(B)

3

HALT

b0=1

Z=0,b0=0Z=0

Figura 6.13: Automa di Moore relativo all’unita’ di controllo

All’inizio del primo ciclo di clock (T = 0), i registri A e B contengono i valori110 e 101. I segnali di condizione sono z = 0 e b0 = 1. L’automa non esegue alcunaoperazione (NOP), ma in base ai valori dei segnali, decide di passare nello stato 1.Lo stato dell’automa compare sopra il diagramma temporale della stessa Figura.

All’inizio dello slot T = 1, lo stato dell’unita’ operativa e’ ancora P = 0, A =110, B = 101, poiche’ nessun comando era stato impartito dall’unita’ nello slot pre-cedente (per comodita’ di scrittura omettiamo gli zeri non significativi). L’unita’ dicontrollo genera tuttavia i segnali per aggiornare l’accumulatore e si predispone atransire nello stato 2.

All’inizio dello slot T = 2, il valore di P e’ stato quindi aggiornato, P = 110.L’automa di controllo genera i segnali per effetture gli shift, che vengono eseguitidall’unita’ operativa. L’automa si predispone a passare nello stato 0.

Il prossimo ciclo di clock, T = 3, serve per decidere la diramazione da prendere infunzione dei segnali di stato (riportati vicino al segnale di clock). Poiche’ sia z che b0sono nulli, l’automa passera’ nello stato 2.

In T = 4, sono eseguite le due operazioni di shift. In particolare, a seguito diquesto shift, si avra’ b0 = 1. Questo valore non e’ pero’ osservabile dall’unita’ dicontrollo durante T = 4, ma bensi nel ciclo successivo.

In T = 5 infatti l’automa di predispone per transire nello stato 1, cui e’ associatal’operazione di aggiornamento di P . L’esecuzione continua finche’ z = 1.

Microprogramma alla Moore L’automa di Figura 6.13 corrisponde al seguentemicroprogramma.

00: NOP case (zb0) of: ; stato DECIDI

1-: goto 11 ; z=1, vai nello stato finale

00: goto 10 ; z=0,b0=0, vai nello stato 2

01: goto 1 ; z=0,b0=1, vai nello stato 1

01: P=P+A goto 10 ; aggiorna P, vai nello stato 2

10: SL(A),SR(B) goto 00 ; sposta i registri A e B

11: NOP;goto 11; ; rimani bloccato

Ogni microistruzione viene memorizzata in una parola della ROM. La label delprogramma corrisponde all’indirizzo della ROM. Una parola della ROM contiene i


SL(A);SR(B)000111100001000110007

NOP01000111100000001100008

HALT000111100000001100009

1

0

1

b0

0

0

0

z

00000110

00000110

00000110

00000110

00000110

00000000

00000000

P

P+A�P0001000110006

NOP0001000110005

SL(A);SR(B)0010000011004

NOP0010000011003

SL(A);SR(B)0101000001102

P+A�P0101000001101

NOP0101000001100

opBATempo

0

A=00000110B=0101P=00000000

A=00000110B=0101P=00000000

NOP

1

P+A�P

A=00000110B=0101P=00000110

2

SL(A);SR(B)

A=00001100B=0010P=00000110

0

NOP

2

SL(A);SR(B)

z=0;b0=1

z=0;b0=0

A=00001100B=0010P=00000110

A=00011000B=0001P=00000110

0

NOP

A=00011000B=0001P=00000110

z=0;b0=1

1

P+A�P

A=00011000B=0001P=00011110

2

A=00110000B=0000P= 00011110

SL(A);SR(B)

0z=1;b0=0

NOP

A=00110000B=0000P= 00011110

3

stato automadi Moore

Stato unità operativa

Figura 6.14: Esecuzione della moltiplicazione fra A = 0110 e B = 0101.

valori dei tre indirizzi per le tre possibili microistruzioni che appaiono dell’istruzionecase ed i tre segnali di controllo (Figura 6.15). Per quanto riguarda la realizzazionedell’unita’ di controllo si puo’ adottare la soluzione di Figura 6.16.

0

0

1

0

0

1

0

0

0

1

0

0

000000

010101

111001

111111

00

01

10

11

NOP; case (zb0) of...

P+A��P

SL(A);SR(B)

HALT

WR SL

CONTROLLO

SL

PROSSIMA ISTRUZIONE

INDIRIZZOINDIRIZZOINDIRIZZO

Figura 6.15: Struttura interna della ROM che contiene il microprogramma per ilprodotto.

Automa di Controllo di Mealy L’automa di Mealy che specifica l’unita’ dicontrollo e’ riportato in Figura 6.17.

Come si vede l’automa ha uno stato in meno; in particolare non e’ necessarioche l’unita’ abbia uno stato di decisione al quale non e’ associata alcuna operazioneutile (NOP); questo perche’ i segnali di controllo generati durante uno slot temporaleprendono in considerazione anche i segnali di condizione in ingresso nello stesso slot


z (msb)

b0

0 1 2 3

SEGNALI DI

CONTROLLO

SEGNALI DI

CONDIZIONE

Unita’ di Controllo

ROM

REGISTRO Clock

Decoder Indirizzo

Figura 6.16: Struttura per l’esecuzione del microprogramma.

00 0110Z=0,b0=1/P+A�Pz=1/NOP

-/SL(A);SL(B)

z=0,b0=0/SL(A);SL(B)-/HALT

Figura 6.17: Automa di Mealy relativo all’unita’ di controllo

temporale. Il digramma temporale che scaturisce dal calcolo del prodotto e’ quindipiu’ corto, come illustrato in Figura 6.18. Rispetto al precedente diagramma si notal’assenza dei ”vuoti” necessari all’automa di Moore per prendere la decisione.

E’ importante pero’ sottolineare che in questo caso il ciclo di clock deve esserepiu’ lungo rispetto alla soluzione precedente. Infatti, con automi di Moore i segnali dicontrollo dipendo solamente dallo stato e quindi sono disponibili solo dopo un ritardoτ dopo l’inizio del ciclo di clock, dove τ e’ il ritardo dovuto al calcolo dell’uscita. Nelcaso di automa di Mealy a questo ritardo va aggiunto il ritardo necessario affiche’siano calcolati i segnali di condizione, poiche da essi dipende anche l’uscita. Nelnostro esempio, il segnale z arriva all’automa dopo il tempo di propagazione dellaporta NOR.

Si usa pertanto dire che nell’implementazione dell’unita’ di controllo secondo Mea-ly le unita’ operativa e di controllo lavorano in serie, mentre nel caso Moore in parallelo(cio’ indica che le uscite dei segnali da un automa relative ad uno slot temporale sonocalcolate indipendentemente dai segnali dell’altro automa nello stesso slot).

Microprogramma alla Mealy La specifica dell’unita’ di controllo mediate micro-programma e’ la seguente.


SL(A);SR(B)000111100001000110004

HALT1000111100000001100005

1

0

1

b0

0

z

00000110

00000110

00000110

00000000

P

P+A�P0001000110003

SL(A);SR(B)0010000011002

SL(A);SR(B)0101000001101

P+A�P0101000001100

opBATempo

1

A=00000110B=0101P=00000000

0

P+A�P

A=00000110B=0101P=00000110

0

SL(A);SR(B)

A=00001100B=0010P=00000110

1 0

SL(A);SR(B)

A=00011000B=0001P=00000110

2

A=00011000B=0001P=00011110

A=00110000B=0000P= 00011110

SL(A);SR(B) NOP

stato automadi Mealy

Stato unità operativa

P+A�P

A=00110000B=0000P= 00011110

Figura 6.18: Esecuzione della moltiplicazione fra A = 0110 e B = 0101.

00: case (zb0) of: ; se

01: P=P+A;goto 1 ; z=0,b0=1, aggiorna P, vai in 1

00: SL(A) SR(B) goto 0 ; z=0,b0=0, shit reg., vai in 0

1-: goto 10 ; vai in 1

01: SL(A) SR(B) goto 0 ; shift vai in 0

10: goto 10 ; rimani bloccato

Nel caso di sintesi dell’automa secondo la struttura di Figura 6.11 il contenutodella memoria ROM e’ quello riportato in Figura 6.19.

L’indirizzo di memoria ha due componenti da due bit ciascuno. La parte bassae’ stabilita dai segnali condizione, quella alta dallo stato dell’automa. Escludendo ilcaso z = 1, b0 = 1, che e’ impossibile (se z=1 allora b0 deve essere 0), e’ possibilericonoscere in ROM 3 gruppi da quattro parole ciascuno.

Il primo gruppo e’ associato allo stato 00, che ammette 3 diramazioni, a secondadei valori di z e b0. Se z = 0 e b0 = 0, l’indirizzo completo da cui prelevare la paroladi memoria e’ 0000. Vengono generati i segnali di controllo che producono i due shift.Se invece z = 0 e b0 = 1, viene prelevata la parola di memoria all’indirizzo 0001. Inquesto caso si aggiorna il registro P e si deve andare nello stato 01. Infine, se z = 1allora bisogna andare nello stato 10.

Il secondo gruppo e’ composto dalle locazione con parte alta dell’indirizzo pari a01. In questo caso, l’automa eseguire sempre le operazioni di shift e poi ritornare in


00,0000,0100,1000,11

01,0001,0101,1001,11

10,0010,0110,1010,11

z b0

00 01 10- -

--00----

10101010

S’1,S’0 SL | SR | WR

1 1 0 0 0 10 0 0- - -

- - -1 1 0 - - -- - -

- - -- - -0 0 0 - - -

SL(A),SL(B); P+A�PNOPimpossibile

impossibileSL(A),SL(B)impossibileimpossibile

impossibileimpossibileNOPimpossibile

COMANDI

CONDIZIONI

stato presente

Figura 6.19: Contenuto della ROM relativo al microprogramma per l’implementa-zione alla Mealy. L’indirizzo di memoria ha due componenti. La prima componentedipende dall’indirizzo dell’istruzione corrente (stato attuale), mentre la seconda dallecondizioni esterne.

00, esiste una sola condizione possibile, z = 0 e b0 = 1. In modo analogo si ragionasul terzo gruppo.

6.7 Microarchitettura di una CPU ad accumulatore

Una volta approfonditi alcuni aspetti legati al funzionamento tipico di una microarchi-tettura, siamo pronti per esaminare una semplice microarchitettura completa. Comin-ciamo col fornire una descrizione esterna del comportamento della CPU, per poi vederecome questo comportamento venga in effetti messo in atto dalla microarchitettura.

6.7.1 La CPU come un interprete

Come spiegato nel Capitolo 1, esternamente, la CPU si comporta come interpretedi un linguaggio, detto linguaggio macchina. Le istruzioni del linguaggio macchinasono stringhe di bit e formano il cosiddetto set di istruzioni della CPU. Un pro-gramma in linguaggio macchina e’ una sequenza di istruzioni macchina. In accordoall’architettura di von Neumann, per svolgere la funzione di interprete, la CPU lavo-ra appoggiandosi su una memoria esterna che contiene sia le istruzioni da eseguire,disposte in sequenza, sia i dati (Figura 6.20).

In particolare, la CPU deve recuperare l’istruzione da eseguire dalla memoria edeseguirla. Questo comportamento e’ ciclico (Figura 6.21).

6.7.2 Il set istruzioni

La nostra microarchitettura e’ la realizzazione fisica di un interprete di un linguaggiomacchina composto da 8 istruzioni. Le istruzioni fanno riferimento ad un accumula-

6.7. MICROARCHITETTURA DI UNA CPU AD ACCUMULATORE 139

CPU MEMORIA

DATI

INDIRIZZI

CONTROLLO

Figura 6.20: Interazione CPU-Memoria.

Estrai dalla memoria

la prossima istruzione da eseguire;

Sia essa ISTR

Esegui l’istruzione ISTR

Figura 6.21: Descrizione del comportamento della CPU.

tore ed hanno tutte lunghezza fissa, pari a 2 byte. Esse sono

• Istruzioni per il controllo della CPU

– stop; ferma la CPU

• Istruzioni per il trasferimento dei dati da CPU (registro accumulatore) a me-moria

– load < indirizzo >

∗ copia i 2 byte con indirizzo < indirizzo > dalla memoria all’accumu-latore

– store < indirizzo >

∗ copia l’accumulatore in memoria nei 2 byte con indirizzo< indirizzo >

• Istruzioni aritmetiche

– add < indirizzo >


∗ Esegui l’addizione fra i due byte di indirizzo < indirizzo > e l’accu-mulatore e poni il risultato nell’accumulatore

– subtract < indirizzo >

∗ Esegui la sottrazione fra i due byte di indirizzo < indirizzo > el’accumulatore e poni il risultato nell’accumulatore

• Istruzioni controllo del programma

– jump < indirizzo >

∗ altera l’esecuzione sequenziale del programma, la prossima istruzioneda eseguire e’ quella in memoria all’indirizzo < indirizzo >

– jumpz < indirizzo >

∗ Se l’accumulatore e’ zero, allora la prossima istruzione da eseguire e’quella in memoria all’indirizzo < indirizzo >

– jumpn < indirizzo >

∗ Se l’accumulatore e’ negativo, allora la prossima istruzione da eseguiree’ quella in memoria all’indirizzo < indirizzo >

Codifica delle istruzioni

Ogni istruzione deve avere un identificativo univoco in modo che l’unita’ di controllopossa stabilire quali comandi generare. Poiche’ il nostro set e’ composto da 8 istruzio-ni sono necessari 3 bit, che ammetteremo essere i primi 3 bit dell’istruzione in formatomacchina. Questi bit memorizzano il cosiddetto codice operativo dell’istruzione, op-code, un valore progressivo da 0 a 7 che assegneremo al set istruzioni. I rimanenti 13bit dell’istruzione conterranno un indirizzo di memoria. Pertanto dalla loro numerosi-ta’ dipendera’ la dimensione dello spazio di memoria che puo’ riferire una istruzione.Dato che ogni istruzione e’ lunga 16 bit e’ possibile indirizzare al massimo 216−3=8KB.

0 15

opcode indirizzo

3

Figura 6.22: Formato delle istruzioni.

La microarchitettura per interpretare il set istruzioni e’ riportata in Figura 7.4.

6.7.3 Unita’ operativa

L’unita’ operativa e’ composta dalle seguenti risorse

• una ALU a 16 bit

• un bus interno da 16 bit


IR

Unità diControllo

PSW

PC

ACC

+2

MDR MAR

.

.

.

Segnali di controllo

ALU

PC-READ

PC-WRITE

INC

MDR-READ-MEM

MDR-WRITE-MEM

MDR-READ-BUS

MDR-WRITE-BUS

MAR-READ

MAR-WRITE

IR-READ

IR-WRITE

ACC-WRITE-ALU

ACC-WRITE-BUS

ACC-READ-BUS

OP-ALU

Alla Memoria

BUS-BATI BUS-INDIRIZZI

Figura 6.23: Microarchitettura della CPU.

• un addizionatore con un operando cablato a 2

• Registro PC (Program Counter) da 13 bit; contiene l’indirizzo della prossimaistruzione da eseguire.

• Registro IR (Instruction Register) da 16 bit; contiene l’istruzione che deve essereeseguita.

• Registro MAR (Memory Address Register) da 13 bit. Contiene l’indirizzo dellacella di memoria cui accedere (lettura o scrittura)

• Registro MDR (Memory Data Register) da 16 bit. Contiene il dato letto o dascrivere il memoria.

• Registro ACC (Accumulatore) da 16 bit. Contiene uno degli operandi dell’ope-razione che la ALU deve eseguire nonche’ il risultato dell’operazione.

• Registro PSW (Processor Status Word) da 2 bit. Contiene valori che condizio-nano l’unita’ di controllo. In particolare, il bit z che indica se l’ultimo valorescritto nell’accumulatore e’ zero ed il bit n che indica se tale valore e’ negativo.

6.7.4 Unita’ di controllo

L’unita’ di controllo deve generare, durante ogni ciclo di clock, i valori dei segnali dicontrollo riportati in Figura 7.4. I segnali controllano le seguenti risorse


• PC

– PC-READ, invia valore del PC sul bus interno

– PC-WRITE, scrive contenuto del bus interno in PC

– INC, Incrementa il PC di 2 unita’

• MDR

– MDR-READ-MEM, invia il valore nel registro sul bus dati

– MDR-WRITE-MEM, scrive nel registro il valore presente sul bus dati

– MDR-READ-BUS, invia il valore nel registro sul bus interno

– MDR-WRITE-BUS, scrive nel registro il valore presente sul bus interno

• MAR

– MAR-READ, invia il valore nel registro sul bus indirizzi

– MAR-WRITE, scrive nel registro il valore presente sul bus indirizzi

• ACC

– ACC-READ-BUS, invia il valore nel registro sul bus interno

– ACC-WRITE-BUS, scrive nel registro il valore presente sul bus interno

– ACC-WRITE-ALU, scrive nel registro il valore in uscita dalla ALU

• IR

– IR-READ, invia il campo indirizzo(bit 3-15) sul bus interno

– IR-WRITE, scrive nel registro il valore presente sul bus interno

Oltre a questi 14 segnali di controllo, l’unita’ genera i seguenti 3 segnali, per untotale quindi di 17 segnali di controllo

• ALU-OP, codice operazione verso la ALU1 (0=SUB, 1=ADD )

• MEM-READ, segnale per la lettura della memoria

• MEM-WRITE, segnale per la scrittura in memoria

6.7.5 Il ciclo istruzione

Abbiamo visto che la CPU preleva di continuo la prossima istruzione macchina daeseguire dalla memoria esterna per poi eseguirla (Figura 6.21). Questo ripetersi diattivita’ si chiama ciclo istruzione e si compone di due parti. La prima fase e’ dettafase di fetch, la seconda fase di esecuzione. Descriviamo adesso le micro-operazioniche devono avvenire nella microarchitettura durante la due fasi.

1Per rendere l’esempio semplice non abbiamo considerato operazioni logiche.


Fase di Fetch

L’obiettivo di questa fase prelevare dalla memoria la prossima istruzione da eseguire.Il registro PC contiene la posizione in memoria (indirizzo) della prossima istruzioneda eseguire, mentre il registro IR e’ dedicato alla memorizzazione dell’istruzione daeseguire. Pertanto, la fase di fetch si espleta copiando il contenuto della locazionedi memoria puntata da PC in IR. Inoltre, dopo avere prelevato l’istruzione dallamemoria, il PC deve essere incrementato di due unita’ in modo che riferisca la nuovaistruzione da eseguire dopo quella prelevata (Figura 7.5).

123

Memoria

PC

IR

123ADD 333125

Memoria

PC

IR

123ADD 333

ADD 333

125

Figura 6.24: Esempio di fase di fetch. La cella di memoria di indirizzo 123 contienel’istruzione ADD 333. Dopo la fase di fetch, questa istruzione si trova in IR ed il PCviene incrementato di due unita’.

Le micro-operazioni sono pertanto

f0: PC →MAR

f1: MEM [MAR]→MDR; PC + 2→ PC

f2: MDR→ IR

Le operazioni che appaiano in una riga sono eseguite in un ciclo di clock. Duranteil ciclo di clock 0, il contenuto di PC viene in MAR.

Durante il secondo ciclo di clock, si deve accedere il memoria per prelevare l’istru-zione. Questo e’ indicato dalla seconda operazione che esprime il fatto che il contenutodella cella di memoria, il cui indirizzo e’ contenuto in MAR, viene trasferito in MDR.

Contemporaneamente, il valore nel PC viene incrementato di due unita’ sfruttandoil sommatore dedicato cui e’ collegato (queste due attivita’ non sono in conflittopoiche’ interessano risorse diverse). Infine, ciclo di clock 2, il contenuto di MDR,ossia l’istruzione da eseguire, viene trasferito in IR. La Figura 6.25 i valori dei segnalidi controllo che indicano di eseguire le microperazioni.

La sequenza di operazioni elementari descritte assume che l’accesso in memoriaavvenga in un solo ciclo di clock. Se la memoria tuttavia ha un tempo di accessosuperiore a quello di un ciclo di clock, allora l’unita’ di controllo deve ”aspettare” ilprelievo del dato dalla memoria, generando un numero opportuno di stati di wait.Per semplificare il nostro studio questi stati di attesa non sono inseriti nella fase difetch, ne lo saranno quando si prelevano altri dati dalla memoria.


MEM

Write

IR

Write

MEM

Read

ACC

Write

ALU

IR

Read

ALU

OP

ACC

Write

Bus

ACC

Read

Bus

MAR

Write

MAR

Read

MDR

Write

BUS

MDR

Read

Bus

MDR

Write

Mem

MDR

Read

Mem

INCPC

Write

PC

Read

PC MDR MAR ACC IR MEM

00 00 0 000100000001

PC->MAR

10 00 0 000000010100

PC+2->PCMEM[MAR]->MDR ;

01 00 0 000000001000

MDR->IR

Figura 6.25: Esempi di segnali di controllo associati a microperazioni.

La fase di fetch termina con la decodifica dell’istruzione prelevata ossia nel deter-minare, sulla base del valore del campo del codice operativo, la particolare istruzioneprelevata.

Fase di esecuzione.

L’istruzione macchina viene eseguita in questa fase. Ogni istruzione corrisponde adiverse operazioni elementari. Vediamone una per categoria. L’istruzione load <indirizzo >, corrisponde alle seguenti micro-operazioni

• IR[3 : 15]→MAR; copia campo indirizzo in MAR

• MEM [MAR]→MDR; copia il dato dalla memoria in MDR

• MDR→ ACC;copia MDR in ACC

L’istruzione add < indirizzo > da vita alle seguenti micro-operazioni



• ACC +MDR→ ACC;copia in ACC, ACC+MDR

L’istruzione di salto incondizionato, jump < indirizzo > corrisponde a

• IR[3 : 15]→ PC;copia campo indirizzo in PC

mentre quelle di salto condizionato, per esempio jmpz < indirizzo > a

• if (Z = 1) IR[3 : 15]→ PC;se Acc=0 copia campo indirizzo in PC

L’intera unita’ di controllo puo’ essere specificata graficamente mediante un auto-ma, come riportato in Figura 7.6.

Ogni stato dell’automa riporta le microperazioni da eseguire. Da questa descri-zione e’ facile poi determinare quali segnali di controllo, fra quelli riportati in Figura7.4, l’unita’ deve generare. Si noti che l’automa ha una struttura che ricalca quelladi Figura 6.21.


PC->MAR

MEM[MAR] -> MDR

PC+2->PC

MDR->IR

NOP

DECODE

IR.op=stop

IR.ind -> MAR

Mem[mar] -> MDR

MDR -> ACC

IR.ind -> MAR

ACC -> MDR

MDR -> Mem[MAR]

IR.op=load IR.op=store

NOP

IR.op=jmpz

Z=0

IR.ind->PC

Fetch

Execute

NOP

n=0

IR.ind->PC

IR.op=jmpn

IR.ind->PC

IR.op=jmp

IR.ind -> MAR

ACC->MDR

MDR+ACC->ACC

IR.ind -> MAR

ACC -> MDR

MDR-ACC -> ACC

IR.op=add IR.op=sub

Figura 6.26: Unita’ di controllo come automa di Moore.

6.7.6 Unita’ di controllo microprogrammata

L’unita’ di controllo puo’ essere implementata mediante microprogrammazione. Se-guendo questa tecnica dobbiamo per prima cosa scrivere il microprogramma, medianteil linguaggio di microprogrammazione associato all’automa di Moore, e realizzare poiun circuito in grado di eseguire il microprogramma. Il microprogramma e’ noto anchecome firmware. L’effetto dell’esecuzione del microprogramma consiste nel generare,ad ogni ciclo di clock, opportuni segnali di controllo diretti verso l’unita’ operativa. Sifaccia attenzione a non confondere l’esecuzione del microprogramma con l’esecuzionedel programma che si trova nella memoria esterna alla CPU.

Microprogramma

Fetch0: PC -> MAR goto Fetch1

Fetch1: MEM[MAR] -> MDR,PC+2->PC goto Fetch2

Fetch2: MDR -> IR goto Decode

Decode: NOP; case (IR.opcode of)

{

000: goto Stop0 ; codice operativo Stop = 000

001: goto Load0 ; Load = 001

010: goto Store0 ; Store = 010

011: goto Add0 ; Add = 011

100: goto Sub0 ; Sub = 100

101: goto Jump0 ; Jump = 101

110: goto Jmpz0 ; Jumpz = 110

111: goto Jmpn0 ; Jmpn = 111


}

Stop0: NOP goto Stop0 ; rimane bloccato qui

Load0: IR.addr -> MAR goto Load1

Load1: MEM[MAR] -> MDR goto Load2

Load2: MDR -> ACC goto Fetch0 ;ritorna alla fase di fetch

Store0: IR.addr -> MAR; goto Store1

Store1: ACC -> MDR; goto Store2

Store2: MDR -> MEM[MAR]; goto Fetch0

Add0: IR.addr ->MAR; goto Add1

Add1: MEM[MAR]->MDR; goto Add2

Add2: MDR + ACC -> ACC; goto Fetch0

Sub0: IR.addr ->MAR; goto Sub1

Sub1: MEM[MAR]->MDR; goto Sub2

Sub2: MDR - ACC -> ACC; goto Fetch0

Jump0: IR.addr -> PC; goto Fetch0

Jmpz0: NOP; if (Z) goto Jmpz1 else goto Fetch0

Jmpz1: IR.addr -> PC; goto Fetch0

Jmpn0: NOP; if (N) goto Jmpn1 else goto Fetch0

Jmpn1: IR.addr -> PC; goto Fetch0

Realizzazione

Passiamo adesso alla realizzazione dell’unita’ di controllo. Ognuna di queste 21 mi-croistruzioni occupera’ una parola in una memoria ROM, detta memoria di controlloo Control Store.

Abbiamo gia’ visto una struttura generica (Figura 6.9) per eseguire microprogram-mi tipo Moore. Vedremo adesso una semplice variazione che consente di ridurre ladimensione della ROM. La cosa importante da notare e’ come viene determinata laprossima microistruzione da eseguire.

La gran parte delle microistruzioni non prevede diramazioni. Le istruzioni di saltocondizionato ne prevedono due, mentre la sola microistruzione di decodifica ne ha otto,una per ogni istruzione. L’idea allora e’ quella di organizzare la parola di memoria inROM secondo la seguente struttura

CONTROL WORD|SF0|SF1|DECODE

Partendo da destra, il primo campo contiene tutti i segnali di controllo da generare,il secondo e terzo (SF0 ed SF1) gli indirizzi delle due alternative per le istruzioni di


salto condizionato mentre il campo DECODE un bit che indica se si sta (Decode=1)la decodifica o meno. Per le istruzioni che non sono di salto condizionato SF0 contienel’indirizzo della prossima microistruzione da eseguire.

La selezione fra le tre alternative, avviene sulla base del valore di DECODE, deidue bit di condizione, z ed n, nonche’ della particolare istruzione da eseguire (Figura6.27). La ROM che appare nella Figura associa ad ogni codice operativo di un’istru-zione macchina, opcode (vedi Figura 7.3), l’indirizzo della prima microistruzione daeseguire. L’opcode e’ usato cioe’ come indirizzo della ROM. Sia SF3 il valore dettodalla ROM.

Sono possibili tre casi. Se siamo nella fase di decodifica, DECODE = 1, allorail circuito seleziona SF3; altrimenti l’indirizzo selezionato dipende dal tipo di istru-zione. Se l’istruzione non e’ di salto, allora la scelta deve ricadere su SF0; se invecel’istruzione e’ di salto condizionato, allora la selezione dipende dal valore del bit dicondizione.

OPCODE

ROM000

001

010

011

100

101

110

111

indirizzo stop

indirizzo load

indirizzo store

indirizzo add

indirizzo sub

indirizzo jump

indirizzo jumpz

indirizzo jumpn

DECODE

SF1 SF0

SEQUENZIALIZZATORE

SF3

N

ZBit di condizione

Indirizzo microistruzione

Figura 6.27: Circuito per la sequenzializzazione.

La Figura 6.28 mostra il dettaglio del sequenzializzatore. Il multiplexer ricevele tre alternative, SF0, SF1, SF2, e ne seleziona una sulla base dei valori di Sel0 eSel1 = DECODE.

Se DECODE = 0, ossia Sel1 = 0, allora puo’ essere scelto o SF0 oppure SF1,a seconda del valore di Sel0. Se l’istruzione da eseguire non e’ un salto condizionato(i cui codici operativi sono 110 e 111) allora Sel0 = 0 poiche’ l’uscita di entrambe leporte AND e’ 0. Se op = 110 allora Sel0 = z, mentre se op = 111 allora Sel0 = n.In questo modo il valore del bit di condizione, z oppure n a seconda dell’istruzione,determina se la prossima istruzione sara’ quella memorizzata all’indirizzo SF0 (nelcaso in cui z = 0 o n = 0), oppure SF1.

Per completare, la Figura 6.29 riporta il contenuto completo della ROM. Perfacilita’ di lettura, il campo control word contiene solo i valori pari ad 1, mentre icampi SF0 ed SF1 solo le reali alternative possibili.

6.7.7 Discussione

Osserviamo attentamente la struttura del microprogramma. Notiamo che ad ogniistruzione corrisponde una porzione del microprogramma composta da un numero


00000

00011

00010

00001

0

0

10000000000.........000

000011

000010

000001

00 01 10 11

COMANDI SF0 SF1

Sel1

Sel0

DEC

Sel1Sel0

ROMROM

VERSO U.O.

OP0OP1OP2

Z

NµPC

Figura 6.28: Dettaglio del circuito di sequenzializzazione

variabile di microistruzioni. Ad esempio, le istruzioni STOP e la JUMP corrispondonoad una sola microistruzione, le istruzioni JUMPZ e JUMPN a due, tutte le altre atre. Sappiamo che ogni microistruzione viene eseguita in un ciclo di clock. Il numerodi cicli di clock richiesti per eseguire una istruzione macchina, che chiameremo CyclePer Instruction (CPI ), e’ dunque variabile. Nel nostro esempio, il CPI di JMP e’ uno,mentre quello di ADD e’ tre.

Questa variabilita’ e’ una prerogativa delle architetture CISC, quelle cioe’ nellequali l’unita’ di controllo e’ realizzata proprio mediante la tecnica della micropro-grammazione. Nelle CISC il valore CPI e’ sempre maggiore di 1. Per contro le CPURISC sono caratterizzate dall’avere un CPI indipendente dalla particolare istruzioneeseguita e, idealmente, pari ad 1. Chiaramente, a parita’ di durata del periodo del se-gnale di clock, avere un CPI basso e’ importante perche’ si traduce immediatamentein una maggiore velocita’ di esecuzione di un programma.

La seconda osservazione da fare riguarda la generazione dei segnali di controllo.Abbiamo visto che l’esecuzione di ogni istruzione richiede al piu’ tre cicli di clock,che chiamiamo intervalli. Supponiamo allora di disporre di tre segnali, T1, T2, T3, taliche nell’intervallo i-simo solamente Ti = 1. Se osserviamo una colonna della Figura6.29, ad esempio quella relativa al segnale PC-WRITE, notiamo che tale segnale vale1 solo in alcuni intervalli. In particolare, nel primo nel caso di JUMP e nel secondonei casi JUMPZ e JUMPN. Questa osservazione ci conduce alla seconda strategia perimplementare l’unita’ di controllo, detta logica cablata.

6.7.8 Logica cablata

Nella logica microprogrammata l’unita’ di controllo e’ specificata mediante un mi-croprogramma. Questo vuol dire che, in generale, non e’ necessario definire alcunamacchina a stati finiti. Una semplice versione grafica dell’automa puo’ essere d’a-iuto, ma non e’ necessaria. Inoltre, la ROM che contiene il programma puo’ esseresostituita qualora si riscontrino degli errori nella realizzazione del microprogramma.


PCMDR MAR ACC IR MEM

PC

-RE

AD

PC

-WR

ITE

INC

MD

R-R

EA

D-M

EM

MD

R-W

RIT

E-M

EM

MD

R-R

EA

D-B

US

MD

R-W

RIT

E-B

US

MA

R-R

EA

D

MA

R-W

RIT

E

AC

C-R

EA

D-B

US

AC

C-W

RIT

E-B

US

AC

C-W

RIT

E-A

LU

IR-R

EA

D

IR-W

RIT

E

ME

M-R

EA

D

ME

M-W

RIT

E

OP

-ALU

SF

0-4

SF

0-3

SF

0-2

SF

0-1

SF

0-0

SF

1-4

SF

1-3

SF

1-2

SF

1-1

SF

1-0

DE

CO

DE

SF0SF1

01011011

000000111

01111011

00000111

00000011

00000011

01100100000

00000011

01010100000

001000111

01100011

1

000100

00110011

01110011

00000011

01001011

00101011

00000011

00011011

0

1

0

0

000011

00001100000

00001

00010

00011

00100

00101

00110

00111

01000

01001

01010

01011

01100

01101

01110

01111

10000

10001

10010

10011

10100

10101

PC->MAR; goto 1

MEM -> MDR;+2; goto 10

MDR -> IR; goto 11

NOP; goto F(IR.opcode)

STOP; goto 100

IR -> MAR; goto 110

MEM -> MDR; goto 111

MDR -> ACC; goto 0

IR -> MAR; goto 1001

ACC -> MDR; goto 1010

MDR -> MEM; goto 0


MEM -> MDR; goto 01101

MDR+ACC -> ACC; goto 0


MEM -> MDR; 10000

MDR-ACC -> ACC; goto 0

IR -> PC; goto 0

NOP; if(z) goto 1011 else goto 0

IR -> PC; goto 0

NOP; if(n) goto 10101 else goto 0

IR -> PC; goto 0

ALU

FETCH

DECODE

STOP

LOAD

STORE

ADD

SUB

JUMP

JMPZ

JMPN

CONTROL WORD

Figura 6.29: Dettaglio del contenuto della ROM.

Un’ unita’ di controllo a logica cablata (hardwired) non sfrutta alcuna nozionedi microistruzione. Si tratta semplicemente di realizzare, mediante una qualunquetecnica di sintesi, l’automa che descrive il comportamento dell’unita’ di controllo.Questa tecnica e’ stata storicamente la prima tecnica ad essere utilizzata. Le funzionidi stato futuro e di uscita venivano sintetizzate mediante porte logiche elementari.

L’automa che descrive l’UC ha una struttura particolare che si presta ad una rea-lizzazione alquanto efficiente, basata sulle osservazioni fatte nella precedente sezione.Il circuito e’ riportato in Figura 6.30

In questo circuito, un decodificatore riceve in ingresso il valore del campo opcodedell’istruzione e mette ad 1 la linea associata all’istruzione stessa. Per esempio, seopcode =000, l’uscita STOP del decodificatore verra’ 1, mentre tutte le altre saranno0. Un’altra caratteristica di questa realizzazione e’ la presenza di un generatore disegnali di temporizzazione sfasati, come disegnato in Figura 6.31.

Ogni segnale di controllo puo’ essere agevolmente essere generato combinando me-diante OR ed AND i segnali ricevuti dal decodificatore con quelli di sincronizzazione,F0F1F2T0T1T2. sono usati per generare i segnali della fase di fetch. Gli altri 3 quellidella fase di execute.

Ad esempio per il segnale PC-WRITE e’ facile vedere che


STOP

LOAD

STORE

ADD

SUB

JUMP

JUMPZ

JUMPN

N

Z

OPCODE


reset

F0

F1

F2

T0

T1

T2

CLOCK RETE COMBINATORIA

GENERATORE TEMPI

DECODIFICATORE

Figura 6.30: Struttura del circuito per la realizzazione dell’unita’ di controllo in logicacablata

PC-WRITE = T0(JUMP)+ T2(JUMPZ+JUMPN)

I segnali di sincronizzazione sono asseriti ciclicamente, a meno che’ un sia generatoun segnale di reset forzi a far ripartire prematuramente il ciclo. Il segnale di resetviene generato dalle istruzioni che sono eseguite in meno di tre intervalli elementari,eventualmente a causa di un segnale di condizione. Quindi, ad esempio

RESET = ....T0 JUMP + T1 (Z’JMPZ+N’JMPN) + T2(Z JMPZ+JMPN)....

dove l’apice indica l’operazione di negazione. Nel caso di istruzione JUMP i segnalidi sincronizzazione sono asseriti nel seguente ordine

F0F1F2T0F0...

mentre nel caso di JMPZ, se Z=0

F0F1F2T0T1F0...

6.8 Microarchitettura di un processore didattico, ilPD32

6.8. MICROARCHITETTURA DI UN PROCESSORE DIDATTICO, IL PD32 151

φ

F 0

F1

F2

T0

T1

T2

Fetch ExecuteFetch

Figura 6.31: Segnali di sincronizzazione prodotti dal circuito di temporizzazione. Incaso di reset, la generazione dei segnali riprende dal segnale T0, a partire dal prossimocolpo di clock.

PRIMA DI CHIUDERE:

• Memoria

• Ciclo Istruzione

• Shift Register

• Ciclo accesso memoria

• Collegamento fra R.C.

• Esempi dallo scorso anno

Capitolo 7

Esempi di microarchitetture

Abbiamo visto che da un punto di vista funzionale, la CPU e’ un interprete hardwaredi un linguaggio, chiamato linguaggio macchina. Questo significa che la CPU e’ ingrado i eseguire solamente programmi scritti in linguaggio macchina. Tali programmisono chiamati programmi eseguibili.

La generazione di programmi eseguibili avviene mediante traduzione di programmiscritti in altri linguaggi piu’ vicini al programmatore. Un esempio ben noto di questilinguaggi, cosiddetti di alto livello, e’ il linguaggio C. Di norma una sola istruzionedel linguaggio C corrisponde a molte istruzioni macchina.

Il linguaggio macchina di una CPU influenza la costruzione dei programmi ditraduzione (compilatori) dal linguaggio di alto livello a quello macchina in termini didifficolta’ e qualita’ della traduzione, dove per qualita’ si intende, in sostanza, il tempoche la CPU impieghera’ per eseguire il programma tradotto. Il linguaggio macchinaha influenza anche su come la microarchitettura della CPU deve essere realizzatanonche’ sulle prestazioni.

Per approfondire lo studio delle differenze fra le varie tipologie di CPU, vedremoin questo capitolo alcuni esempi di microarchitetture e come tipici frammenti di pro-grammi di alto livello sia eseguiti dalla CPU. Ci avvarremo a tale scopo del linguaggioassembly, che rappresenta in pratica una versione simbolica del linguaggio macchina.Questo studio avverra’ con il supporto del simulatore CPU Sim. Questo simulatore,come spiegato in dettaglio in appendice, consente di costruire diversi tipi di CPUognuna con il proprio linguaggio macchina. Ogni istruzione macchina viene definitamediante il linguaggio RTL. Il simulatore inoltre permette di scrivere programmi inlinguaggio assembly.

7.1 CPU con registro accumulatore

Il nostro primo esempio riguarda una CPU ad accumulatore. L’accumulatore e’ usatoimplicitamente nelle varie istruzioni. Nel caso di istruzioni aritmetiche, il registro ac-cumulatore contiene sia un operando, sia il risultato. Pertanto l’istruzione deve soloindicare dove reperire il secondo operando. Poiche’ il secondo operando viene speci-

153

154 CAPITOLO 7. ESEMPI DI MICROARCHITETTURE

ficato mediante l’indirizzo della cella di memoria in cui e’ memorizzato le istruzionidi questo tipo di CPU sono dette ad un indirizzo. Chiameremo l’ipotetico calcolatorecostruito usando questa CPU wombat1. Questo esempio e’ gia’ disponibile completonel simulatore.

7.1.1 Caratteristiche esterne

Set istruzioni Questa CPU e’ caratterizzata da 12 istruzioni, classificate nel se-guente modo. Le istruzioni hanno tutte lunghezza fissa, pari a 2 byte.

• Istruzioni per il controllo della CPU

– stop ; ferma la CPU

• Istruzioni per il trasferimento dei dati da CPU (registro accumulatore) a me-moria

– load < indirizzo >

∗ copia i 2 byte con indirizzo < indirizzo > dalla memoria all’accumu-latore

– store < indirizzo >

∗ copia l’accumulatore in memoria nei 2 byte con indirizzo< indirizzo >

• Istruzioni per ingresso, uscita di dati

– read

∗ Copia il valore dal bugger del dispositivo d’ingresso all’accumulatore

– write

∗ Copia l’accumulatore nel buffer del dispositivo d’uscita

• Istruzioni aritmetiche

– add < indirizzo >

∗ Esegui l’addizione fra i due byte di indirizzo < indirizzo > e l’accu-mulatore e poni il risultato nell’accumulatore

– subtract < indirizzo >

∗ Esegui la sottrazione fra i due byte di indirizzo < indirizzo > el’accumulatore e poni il risultato nell’accumulatore

– multiply < indirizzo >

∗ Esegui la moltiplicazione fra i due byte di indirizzo < indirizzo > el’accumulatore e poni il risultato nell’accumulatore

– divide < indirizzo >

∗ Esegui la divisione fra i due byte di indirizzo < indirizzo > e l’accu-mulatore e poni il risultato nell’accumulatore

7.1. CPU CON REGISTRO ACCUMULATORE 155

• Istruzioni controllo del programma

– jump < indirizzo >

∗ altera l’esecuzione sequenziale del programma, la prossima istruzioneda eseguire e’ quella in memoria all’indirizzo < indirizzo >

– jumpz < indirizzo >

∗ Se l’accumulatore e’ zero, allora la prossima istruzione da eseguire e’quella in memoria all’indirizzo < indirizzo >

– jumpn < indirizzo >

∗ Se l’accumulatore e’ negativo, allora la prossima istruzione da eseguiree’ quella in memoria all’indirizzo < indirizzo >

La Figura 7.1 riporta in modo compatto l’elenco delle istruzioni assembly, consintassi e significato.

(input)->accread

SIGNIFICATOSINTASSI ISTRUZIONE

Ferma la CPUstop

MEM[indirizzo]->accload <indirizzo>

Acc-> MEM[indirizzo]store <indirizzo>

acc->(output)write

MEM[indirizzo]+acc -> accadd <indirizzo>

acc-MEM[indirizzo] -> accsubtract <indirizzo>

acc*MEM[indirizzo] -> accmutiply <indirizzo>

acc*MEM[indirizzo] -> accdivide <indirizzo>

goto indirizzojump <indirizzo>

if (acc=0) goto indirizzojumpz <indirizzo>

if (acc<0) goto indirizzojumpn <indirizzo>

Figura 7.1: Istruzioni del linguaggio assembly di Wombat1.

Modello di memoria Le istruzioni di questa CPU si riferiscono ad una memorialineare con granularita’ di indirizzamento pari al byte. Questo vuol dire che l’unita’piu’ piccola che potrebbe essere essere letta o scritta in memoria e’ il byte.

Sistema di calcolo completo La Figura 7.2 riporta un ipotetico calcolatore basatosu la CPU Womabt1. Sono presenti due dispositivi, uno per l’ingresso dei dati el’altro per l’uscita. Ci limiteremo qui a fornire una descrizione elementare ed intuitivadell’interazione fra CPU e dispositivi.


L’interazione fra CPU ed i dispositivi e’ mediata da un’area di memoria (buffer).Il dispositivo di ingresso (p.e., tastiera) scrive nel buffer in modo asincrono, mentre laCPU legge il buffer tramite l’istruzione read. Analogamente, per scrivere un dato inuscita, la CPU copia il dato nel buffer di uscita ed il dispositivo di uscita visualizzail dato. Come spiegato in seguito, la memoria ha capacita’ di 4KB.

CPUMemoria4KB

input

output

indirizzo (12 bit)

dati (16 bit)

controllo(R,W)

controllo

(read)

dato

controllo

(write)

dato

Figura 7.2: Sistema di calcolo basato su Wombat1.

7.1.2 Caratteristiche interne, la microarchitettura

Codifica delle istruzioni Poiche’ il nostro set e’ composto da 12 istruzioni, perindividuarle univocamente sono necessari 4 bit, che ammetteremo essere i primi 4bit dell’istruzione in formato macchina. Questi bit memorizzano il cosiddetto codiceoperativo dell’istruzione, opcode, un valore progressivo da 0 a 11 che assegneremo,in modo arbitrario, alle 12 istruzioni. I rimanenti bit dell’istruzione conterranno unindirizzo di memoria. Pertanto dalla loro numerosita’ dipendera’ la dimensione dellospazio di memoria che puo’ riferito da una istruzione e quindi la memoria massimadel nostro ipotetico calcolatore. Supporremo che ogni istruzione sia lunga 16 bit, dacui deriva che e’ possibile indirizzare al massimo 216−4=4 KB.

0 15

opcode non usato

3 0 15

opcode indirizzo

3


Risorse elementari Vediamo adesso la microarchitettura della CPU (Figura 7.4).

Essa e’ caratterizzata da 6 registri, un registro cablato col valore 2, una ALU a 16bit1, ed un bus. I registri svolgono le seguenti funzioni

• Registro PC (Program Counter) da 12 bit; contiene l’indirizzo della prossimaistruzione da eseguire.

1Il simulatore CPU Sim assume l’esistenza di una ALU in grado di eseguire il prodotto e ladivisione fra numeri in complemento a 2. Per rendere uniforme il nostro studio, ammetteremo chele ALU utilizzate nei nostri esempi siano in grado di eseguire queste operazioni.


IR

Unità diControllo

PSW

PC

ACC

2 MDR MAR

.

.

.


Alla Memoria

ALU

PCR

PCW

INC MDRR-MEM

MDRW-MEM

MDRR-BUS

MDRW-BUS

MARR

MARW

IRWACCW-BUS

ACCR-BUS

ACCW-ALU

ACCR-ALU

PWSW

OP1ALU

OP2ALU

Figura 7.4: Microarchitettura della CPU Wombat1.

• Registro IR (Instruction Register) da 16 bit; contiene l’istruzione che deve essereeseguita.

• Registro MAR (Memory Address Register) da 12 bit. Contiene l’indirizzo dellacella di memoria cui accedere (lettura o scrittura)

• Registro MDR (Memory Data Register) da 16. Contiene il dato letto o dascrivere il memoria.

• Registro ACC (Accumulatore) da 16 bit. Contiene uno degli operandi dell’ope-razione che la ALU deve eseguire nonche’ il risultato dell’operazione.

• Registro PSW (Processor Status Word) da 3 bit. Contiene valori che condizio-nano l’unita’ di controllo. In particolare, un bit di halt (halt bit) che ferma laCPU, il bit z che indica se l’ultimo valore scritto nell’accumulatore e’ zero, edil bit n che indica se tale valore e’ negativo.

Il registro che contiene il valore 2 serve per incrementare il valore di PC.

Il ciclo istruzione Esternamente la CPU si comporta come un interprete, pre-levando di continuo la prossima istruzione macchina da eseguire dalla memoria edeseguendola. Questo ripetersi di attivita’ si chiama ciclo istruzione e si compone didue parti, o fasi. La prima fase e’ detta fase di fetch, la seconda fase di esecuzione.Descriviamo adesso le micro-operazioni che devono avvenire nella microarchitetturadurante la due fasi.

Fase di Fetch. Il registro PC contiene la posizione in memoria (indirizzo) della pros-sima istruzione da eseguire, mentre il registro IR e’ dedicato alla memorizzazionedell’istruzione da eseguire. Pertanto la fase di fetch si espleta copiando la locazionedi memoria puntata da PC in IR. Inoltre, dopo avere prelevato l’istruzione dallamemoria, il PC deve essere incrementato di due unita’ in modo che riferisca la nuovaistruzione da eseguire dopo quella prelevata. (Figura 7.5).


Memoria

PC

IR

Figura 7.5: Fase di fetch.

Le micro-operazioni sono pertanto

1. PC →MAR;PC → ACC

2. MEM [MAR]→MDR; PC + 2→ ACC

3. ACC → PC

4. MDR→ IR

Le operazioni che appaiano in una riga sono eseguite in un ciclo di clock. Duranteil ciclo di clock 1, il contenuto di PC viene copiato sia in MAR che in ACC. Questotrasferimento simultaneo e’ possibile perche’ il dato emesso da PC sul bus puo’ esserecontemporaneamente acquisito da entrambi i registri.

Durante il secondo ciclo di clock, si deve accedere il memoria per prelevare l’istru-zione. Questo e’ indicato dalla seconda operazione che esprime il fatto che il contenutodella cella di memoria, il cui indirizzo e’ contenuto in MAR, viene trasferito in MDR.

Contemporaneamente, il valore nell’accumulatore e’ incrementato di 2 unita’ (que-ste due attivita’ non sono in conflitto poiche’ interessano risorse diverse). Il risultatodi questa addizione viene poi scritto nuovamente in PC durante il terzo ciclo di clock.Infine, ciclo di clock 4, il contenuto di MDR, ossia l’istruzione da eseguire, vienetrasferito in IR.

La sequenza di operazioni elementari descritte assume che l’accesso in memoriaavvenga in un solo ciclo di clock. Se la memoria tuttavia ha un tempo di accessosuperiore a quello di un ciclo di clock, allora l’unita’ di controllo deve ”aspettare” ilprelievo del dato dalla memoria, generando un numero opportuno di stati di wait.Per semplificare il nostro studio questi stati di attesa non sono inseriti nella fase difetch, ne lo saranno quando si prelevano altri dati dalla memoria.

La fase di fetch termina con la decodifica dell’istruzione prelevata ossia nel deter-minare, sulla base del valore del campo del codice operativo, la particolare istruzioneprelevata.

Fase di esecuzione.L’istruzione macchina viene eseguita in questa fase. Ogni istruzione corrisponde a


diverse operazioni elementari. Vediamone una per categoria. L’istruzione load <indirizzo >, corrisponde alle seguenti micro-operazioni



• MDR→ ACC;copia MDR in ACC

L’istruzione add < indirizzo > da vita alle seguenti micro-operazioni



• ACC +MDR→ ACC;copia in ACC, ACC+MDR

L’istruzione di lettura dall’esterno corrisponde a (input e’ il buffer d’ingresso)

• (input)→ ACC

L’istruzione di salto incondizionato, jump < indirizzo > corrisponde a

• IR[4 : 15]→ PC;copia campo indirizzo in PC

mentre quelle di salto condizionato, per esempio jmpz < indirizzo > a

• if (ACC = 0) IR[4 : 15]→ PC;se Acc=0 copia campo indirizzo in PC

Unita’ di controllo L’unita’ di controllo puo’ essere specificata mediante un auto-ma, come riportato in Figura 7.6. Ogni stato dell’automa riporta le micro-operazionida eseguire. Da questa descrizione e’ facile poi determinare quali segnali di con-trollo, fra quelli riportati in Figura 7.4, l’unita’ deve generare. Ad esempio, lamicro-operazione ACC+MDR→ ACC corrisponde a mettere alto i seguenti segnali

ACCR−ALU , ACCW−ALU ,MDRR−BUS

nonche’ i segnali OP1R−ALU e OP2R−ALU che selezionano l’operazione di addizione.L’automa ha una struttura che ricalca il ciclo istruzione. E’ facilmente riconoscibile

la parte associata alla fase di fetch seguita da una seconda parte le cui diramazionidipendono dal codice operativo del registro istruzioni, IR.op nella figura.

7.1.3 Simulazione in CPU Sim

Passiamo adesso alla simulazione della nostra architettura in CPU Sim. E’ importanteanzitutto sottolineare che il simulatore fornisce una descrizione della microarchietet-tura in termini di di un linguaggio RTL. I dettagli di come queste micro-operazionisono realizzate non viene simulato. Il simulatore non consente di specificare l’esecuzio-ne parallela di piu’ micro-operazioni elementari; bensi, tutte le operazioni elementarisono eseguite in sequenza e devono terminare con la microistruzione End, che riportail controllo alla fase di fetch. Inoltre esso assume l’esistenza di una ALU in grado dieseguire tutte le operazioni aritmetiche di numeri rappresentati in complemento a 2.La Figura 7.7 riporta l’implementazione delle varie istruzioni nel simulatore. Si trattadel sistema Wombat1 fornito con il simulatore.


PC->MAR

PC->ACC

MEM[MAR]->MDR

PC+2->ACC

ACC->PC

MDR->IR

Halt-bit=1

DECODE

IR.op=stop

IR.ind->MAR

Mem[mar]->MDR

MDR->ACC

IR.ind->MAR

ACC->MDR

MDR->Mem[MAR]

IR.op=loadIR.op=store

. . . .

Test Acc

IR.op=jmpn

acc<0 acc≥0

IR.ind->PC

Fetch

Execute

Figura 7.6: Unita’ di controllo come automa di Moore.

7.1.4 Esempi di programmi assembly

primo esempio Consideriamo il seguente programma C

Programma in C. 1 int main() {

int x=-1, y=3, z;

z = x+y;

}

Come dovrebbe essere tradotto questo programma affinche’ possa essere eseguitoda una CPU con registro accumulatore? La traduzione deve prendere in considera-zione due aspetti. Il primo riguarda come ”tradurre” le variabili che appaiono nelprogramma in linguaggio macchina; la seconda riguarda poi come tradurre le istru-zioni C che appaiono nel programma, ossia l’istruzione di assegnamento e quello dicalcolo della somma.

A cosa corrispondono le variabili? Una variabile corrisponde ad uno spazio inmemoria centrale, la cui ampiezza deve essere sufficiente a memorizzare il valoredella variabile. Ammetteremo che i valori interi occupino 2 byte e siano codificati incomplemento a 2. Pertanto e’ necessario riservare in memoria centrale 3 spazi da 2byte ciascuno. Questa area di memoria si chiama record di attivazione (della funzionemain).

Il linguaggio assembly di CPU Sim consente di riservare un’area dati di una spe-cifica dimensione ed inizializzata con un valore. A tal fine si deve usare la psuedoi-struzione

[<label>:] .data <dimensione> <valore>

La label puo’ essere usata come operando in istruzioni assembly; esso viene intre-pretato come indirizzo del primo byte dell’area di memoria.

Per riservare lo spazio per le nostre tre variabili useremo pertanto le seguentipseudoistruzioni


•input-int->acc

•End

163000read

•ir(4-15)->mar

•acc->mdr

•mdr->Main[mar]

•End

4 12 2store

•ir(4-15)->mar

•Main[mar]->mdr

•mdr->acc

•End

4 12 1 load

16

16

LUNGHEZZA

CAMPI

•output-acc->int

•End

4000write

•set-halt-bit

•End

0000stop

MICROISTRUZIONIOPCODEINSTRUZIONE

•ir(4-15)->mar

•Main[mar]->mdr

•acc/mdr->acc

•End

4 168 divide

•ir(4-15)->mar

•Main[mar]->mdr

•acc*mdr->acc

•End

4 12 7 multiply

•ir(4-15)->mar

•Main[mar]->mdr

•acc-mdr->acc

•End

4 12 6subtract

4 16

LUNGHEZZA

CAMPI

•ir(4-15)->mar

•Main[mar]->mdr

•acc+mdr->acc

•End

5add


•if(acc>=0)skip-1

•ir(4-15)->pc

•End

4 12 B jumpn

•if(acc!=0)skip-1

•ir(4-15)->pc

•End

4 12 Ajumpz

4 16

LUNGHEZZA

CAMPI

•r(4-15)->pc

•End

9jump


Figura 7.7: Linguaggio macchina di Wombat1.

x: .data 2 -1 ; variabile x

y: .data 2 5 ; variabile y

z: .data 2 0 ; variabile z

Il programma assembly completa e’ pertanto

Programma assembly 1(file: somma.cpu)

load x ; acc = x

add y ; acc = x+y

store z; z = x+y

stop

x: .data 2 -1 ; x = -1

y: .data 2 3 ; y = 3


z: .data 2 0 ; z= 0

La Figura 7.8 mostra il simulatore in esecuzione.

Figura 7.8: Simulazione del programma in Wombat1.

Programma in C. 2Consideriamo adesso il seguente programma per il calcolo del valore massimo fra duevalore, che assumiamo essere positivi (cio’ semplifica il confronto)

int main() {

int x=2;

int y=3;

int max;

max=x;

if (y>max) max=y;

}

La traduzione in assembly del precedente programma e’

Programma assembly 2(file: massimo.cpu)

load x

store max ; max = x

load y;

subtract max ; acc = y - max

; (y - max<0)

jmpn skip; salta aggiornamento

; (y - max>0), aggiorna max

load y

7.2. WB2 UNA CPU REGISTRO-REGISTRO A DUE INDIRIZZI 163

store max

skip: stop

x: .data 2 2 ; x = 2

y: .data 2 3 ; y = 3

max: .data 2 0 ; max=0

Rilocazione

7.1.5 Osservazioni

Il nostro primo semplicissimo esempio di architettura ha messo in evidenza un impor-tante inconveniente. Poiche’ tutti gli operandi sono memorizzati in RAM, pratica-mente ogni operazione richiede l’accesso alla memoria (Figura 7.9). Questi frequentiaccessi limitano le prestazioni della CPU, poiche’ la memoria e’ piu’ lenta della CPU.Per superare questa limitazione abbiamo bisogno di piu’ registri generali da sfruttare

0

x

y

max

2

3

0

ACC

MDR

2

2

3

0

2

2

3

2

3

2

3

2

-1

2

3

2

3

2

3

2

load x store max load y

subtract max

jmpn skip

load y

3

2

3

3

store max

2

Accesso in memoria

Figura 7.9: Accessi in memoria relativi al programma che calcola il massimo.

per memorizzare i valori delle variabili.

7.2 WB2 una cpu registro-registro a due indirizzi

La nostra seconda architettura impiega 4 registri di appoggio, R0, R1, R2, R3, per usogenerale. La differenza fondamentale con la precedente cpu consiste nel fatto che glioperandi devono essere memorizzati nei registri generali ed ogni istruzione deve adessoprecisare gli indirizzi di questi due registri. Per quanto riguarda il risultato, esso vienememorizzato in un registro operando. La cpu sfrutta ancora l’indirizzamento direttoin memoria.


7.2.1 Caratteristiche esterne

Set istruzioni

• stop ; ferma la CPU

• load < Reg >< Indirizzo >; MEM[Indirizzo] → Reg

• store < Reg >< indirizzo >; Reg → MEM[Indirizzo]

• read < Reg >; (input)→ Reg

• write < Reg >; Reg → (output)

• add < Reg1 >< Reg2 >; Reg1 + Reg2 → Reg2

• sub < Reg >< Reg2 >; Reg1 - Reg2 → Reg2

• mul < Reg >< Reg2 >; Reg1 · Reg2 → Reg2

• div < Reg >< Reg2 >; Reg1 / Reg2 → Reg2

• jump < indirizzo >; goto < indirizzo >

• jumpz < indirizzo >; if (z=0) goto < indirizzo >

• jumpn < indirizzo >; if (n=0) goto < indirizzo >

Modello di memoria Anche in questo caso la memoria e’ un array di byte. Gliindirizzi nelle istruzioni sono assoluti (indirizzamento diretto); pertanto il massimospazio indirizzabile dipende dall’ampiezza dell’istruzione.

7.2.2 Caratteristiche interne

Codifica delle istruzioni La possibile codifica delle istruzioni avviene come indi-cato in Figura 7.10. Ogni istruzione e’ ampia 16 bit

Per la codifica delle istruzioni della nostra nuova microarchitettura e’ necessariomodificare il formato delle istruzioni macchina. Per codificare le istruzioni load estore dovremmo usare un campo da 4 bit per il codice operativo (ammettendo di nonsuperare 16 istruzioni) ed un campo da 2 bit per l’indice del registro. I rimanenti bitsono utilizzabili per l’indirizzo.

7.2.3 Microarchitettura

Per la realizzazione della microarchitettura che supporti questo tipo di istruzioni ab-biamo due differenti opzioni. La prima e’ riportata in Figura 7.11, ed e’ caratterizzatada un solo bus.

Supponiamo che istruzioni macchina siano lunghe 16 bit, il codice operativo occupii primi 4 bit, mentre l’indirizzo del registro i successivi 2 bit. In questo caso, la primaistruzione corrispondere, su questa architettura, alle seguenti operazioni elementari


JUMP <Indirizzo>

JUMPZ <Indirizzo>

JUMPN <Indirizzo>

STOP

0 15

opcode non usato

3

opcode

3

indirizzo

15130

opcodeLOAD <Registro><Indirizzo>

STORE <Registro><Indirizzo>Reg

3 150 5

opcode

ADD <Registro><Registro>

SUB <Registro><Registro>

DIV <Registro><Registro>

MUL <Registro><Registro>

Reg

3 150 5

Reg

7

indirizzo

opcodeREAD <Registro>

WRITE <Registro>Reg

3 150 5

non usato

non usato

non

usato


• IR[7 : 15]→MAR; muovi il valore del campo 7:15 di IR in MAR

• MEM [MAR]→MDR; preleva il dato dalla memoria

• MDR→ R1; copia il dato in R1

mentre la seconda istruzione alle operazioni elementari

• R0→ ACC

• R1 +ACC → ACC

• ACC → R1

E’ importante notare che l’accumulatore svolge ora un ruolo di registro d’appoggioed e’ invisibile a livello di istruzioni macchina.

La seconda microarchitettura consente di ridurre il numero di cicli di clock pereseguire un’istruzione come l’addizione. Essa e’ riportata in Figura 7.12. Ci sonoadesso due bus interni, che consentono di eliminare il passaggio intermedio attraversol’accumulatore.

In questo caso, l’istruzione di addizione puo’ essere eseguita con una microistru-zione in meno, e quindi piu’ velocemente.

• R0 +R1→ TEMP

• TEMP → R1

7.2.4 Costruzione in CPU Sim

Risorse hardware Le risorse della CPU sono

• I registri PC,IR,MDR,MAR,PSW


IR

Unità di

ControlloPSW

PC

ACC

MDR MAR

R[0]

R[1]

R[2]

R[3]

Figura 7.11: Microarchitettura della CPU Wombat2, prima versione

• Array di 4 registri, R

• ALU

Nel simulatore queste risorse corrispondo a moduli hardware. Fa eccezione la ALU chee’ implicitamente presente in ogni architettura. La Figura 7.13 mostra come appaionoi vari moduli nelle rispettive finestre di definizione.

Definizione dell’unita’ di controllo Il passo successivo consiste nella definizionedell’unita’ di controllo. Cio’ avviene mediante la definizione di operazioni elementari(microistruzioni) che essa coordina. Le operazioni sono di vario tipo (vedi appendice).Iniziamo col definire la fase di fetch (Figura 7.14)

Dopo aver definito la fase di fetch si passa a definire la fase di esecuzione. Ilche corrisponde a definire le istruzioni macchina. E’ necessario anzitutto definire ilformato delle istruzioni. Una istruzione puo’ avere nessun operando (come stop), unoperando (jmp address), due operandi, ma diverse dimensioni (p.e., load e add).

Una volta definito il formato, si passa alla ”implementazione” delle istruzionimacchina, il cui formato e’ riportato in Figura 7.15.

La definizione delle istruzioni macchina fatta nel simulatore e’ riportata in Figura7.16.

7.2.5 Esempi di programmi

Metodi di indirizzamentoStackSupporto per chiamate a procedureIstruzioni per il controllo


IR

Unità di

ControlloPSW

PC MDR MAR

R[0]

R[1]

R[2]

R[3]

TEMP

Figura 7.12: Microarchitettura della CPU Wombat2, due bus

Figura 7.13: Moduli hardware definiti in Wombat2


Figura 7.14: Definizione delle fase di fetch.

Figura 7.15: Definizione dei Formati delle istruzioni.

Figura 7.16: Definizione dei Formati delle istruzioni.


IR

Unità di

ControlloPSW

PC MDR MAR

R[0]

R[1]

R[2]

R[3]

Figura 7.17: Microarchitettura della CPU Wombat2, con tre bus

Capitolo 8

Architettura livello istruzioni(ISA)

L’architettura del set di istruzioni, Instruction Set Architecture o ISA, definisce lecaratteristiche dell’insieme di istruzioni che una CPU puo’ eseguire. Essa rappresental’interfaccia fra hardware e software poiche’ e’ sia la specifica per i progettisti di CPU,sia per gli sviluppatori di codice in assembly o di programmi di traduzione di linguaggidi alto livello.

Questo capitolo illustra brevemente le caratteristiche del set istruzioni, discutendotipi di istruzione. Verra’ poi approfondita la ISA PD-32, progettata appositamenteper scopi didattici. Infine verra’ dato un breve cenno alle ISA reali.

8.1 Il set istruzioni

Le istruzioni di una ISA possono essere classificare in base alla natura delle operazionieseguite, nel seguente modo 1.

• trasferimento dati, per copiare un dato da una sorgente (registro o memoria)ad una destinazione (registro o memoria).

• logico aritmetiche, per effettuare le operazioni di base sui dati del programma

• controllo del programma , per alterare il flusso altrimenti sequenziale di unprogramma

• ingresso, uscita , per trasferire dati dall’esterno del calcolatore all’interno eviceversa

• controllo del processore , per impostare valori di stato del processore

1Il set istruzioni di una ISA contiene molte istruzioni ridondanti ed in numero molto maggiorerispetto a quello teoricamente sufficiente a tradurre qualunque programma di alto livello. Questaridondanza e’ dovuta solamente a questioni di prestazioni e non di capacita’ o ”potenza” di calcolodi una CPU.

171

172 CAPITOLO 8. ARCHITETTURA LIVELLO ISTRUZIONI (ISA)

8.1.1 Trasferimento dati

Le istruzioni per il trasferimento dei dati servono per copiare un dato da una sorgente(registro, memoria) ad una destinazione (registro,memoria). In teoria sono possibiliquattro combinazioni (Figura 8.1)

memoria-memoriaregistro-memoria

memoria-registroregistro-registro

registro memoria

registro

memoria

sorgente

destinazione

Figura 8.1: Combinazioni possibili per il trasferimento dei dati

La variante memoria-memoria non e’ pero’ usata nella pratica. Il trasferimen-to dati puo’ essere implicito oppure esplicito. E’ implicito quando il trasferimentoe’ necessario per eseguire un’istruzione, tipicamente un’istruzione logico aritmetica(vedi dopo), esplicito quando invece il solo effetto di un’istruzione consiste appuntonel trasferimento. A livello simbolico le istruzioni per il trasferimento di dati sonotipicamente indicate con

• mov ; Muovi un dato

• load o ld ; Carica da memoria

• store o st ; Conserva in memoria

Nelle ISA cosiddette load-store non esistono istruzioni che trasferiscono implicita-mente dati dalla memoria. Il trasferimento da/verso memoria avviene solo mediantele istruzioni load e store (da cui deriva il nome dell’architettura). Questa sceltae’ tipica della macchine RISC ed ha il vantaggio di consentire varie ottimizzazionimicroarchitetturali.

8.1.2 Istruzioni logico aritmetiche

Queste istruzioni servono per eseguire operazioni di tipo logico o aritmetico. Il numerodi operandi espliciti di una istruzione aritmetica puo’ variare da tre a zero. Questovincolo impone uno ”stile” di programmazione, per cui puo’ essere usato come criteriodi classificazione delle ISA.

ISA a tre indirizzi

In questo tipo di architetture l’istruzione specifica gli indirizzi di tutti e tre gli ope-randi. Sono possibili due varianti. La prima e’ detta registro-registro. In essa tuttie tre gli operandi devono essere nei registri. Non sono possibili riferimenti ad ope-randi in memoria. Per trasferire gli operandi dalla memoria ai registri e viceversae’ necessario utilizzare le istruzioni load e store viste in precedenza. Le architettureregistro-registro sono quindi sinonimo di architetture load/store.

8.1. IL SET ISTRUZIONI 173

La seconda variante e’ detta registro-memoria ed ammette che alcuni dei tre ope-randi siano in memoria. Ad esempio, le architetture PowerPC e la Intel IA-64 hannoistruzioni a tre indirizzi. L’istruzione assembly dell’ISA IA-64

add r1=r2,r3

indica di sommare il contenuto dei registri generali r2 ed r3 e porre il risultato in r1,ossia ha significato

r2 + r3→ r1

Esiste anche una variante che consente di sommare un uno

add r1=r2,r3,1

con significato r2 + r3 + 1→ r1.

ISA a due indirizzi

In questo caso le istruzioni specificano le posizioni di due soli operandi. Un operandoe’ in memoria. Il risultato dell’operazione, sostituisce un operando. Ad esempio

add r1,r2

potrebbe indicarer1 + r2→ r1

ISA ad accumulatore Sono architetture in cui le istruzioni fanno riferimento ad unregistro implicito (accumulatore, Acc), che contiene sia un operando che il risultato.E ammesso il riferimento ad solo operando

add B

ha significato B +Acc→ Acc

ISA a stack Nelle ISA a stack le istruzioni non indicano alcun registro o indirizzodi memoria da cui prelevare operandi o registrare il risultato; tutti gli operandi sonoprelevati ed inseriti in una struttura dati gestita con politica LIFO, dette stack.

Le macchine a stack si fondano sull’utilizzo della notazione polacca inversa, secon-do la quale gli operatori di una espressione non hanno priorita’ e, al posto di essereinfissi, come nella notazione tradizionale, sono postfissi, ossia seguono gli operandi aiquali si applicano. La trasformazione dalla notazione tradizionale a quella polaccainversa puo’ essere facilmente posta in forma algoritmica, facilitando il processo diproduzione del codice macchina a partire da quello di alto livello. La traduzione diespressioni complesse non richiede il passaggio per registri intermedi.

Inoltre il codice in linguaggio macchina e’ potenzialmente piu’ breve rispetto aquello delle altre architetture. Per questa compattezza del codice, tale modello e’usato nella Java Virtual Machine, dove e’ spesso necessario trasferire codice attraversola rete.

Ad esempio l’istruzionec = a + b

viene tradotta in


push a ; STACK=[a]

push b ; STACK=[a|b]

add ; STACK=[a+b]

pop c ; STACK=[]

Esempio Per meglio mettere in luce come le differenti architetture influenzino lostile del codice in linguaggio macchina, consideriamo i due casi estremi, ossia l’ISA a 3indirizzi e quella a 0 indirizzi e vediamo, ad esempio, come viene tradotta l’istruzionedi alto livello

a = (b+ c)/(d+ e)

Nel caso di architetture a tre indirizzi la traduzione dell’espressione sarebbe

ld rb b ; carica b nel registro rb

ld rc c ;

ld rd d ;

ld re e ;

add t1 rb rc ; t1=b+c

add t2 rd re ; t2=d+e

div ra t1 t2; a=t1/t2

st ra a ; memorizza risultato in a

dove si e’ assunto di indicare con la stessa lettera della variabile che compare nel-l’espressione il suo indirizzo in memoria e con la lettera preceduta da r il registroutilizzato internamente. Per una macchina a stack la precedente espressione vienetradotta in

push b ; Stack=[b]

push c ; Stack=[c]

add ; Stack=[b+c]

push d ; Stack=[b+c,d]

push e ; Stack=[b+c,d,e]

add ; Stack=[b+c,d+e]

div ; Stack=[b+c/d+e]

pop a

8.1.3 Controllo del flusso di esecuzione

Le istruzioni che formano un programma sono disposte sequenzialmente in memo-ria, una dietro l’altra. Se non diversamente specificato, la CPU eseguirebbe questeistruzioni nello stesso ordine in cui sono disposte in memoria, ossia in sequenza. Leistruzioni di controllo che illustreremo in questa sezione sono in grado di modificarequesto ordine di esecuzione 2. E’ utile ricordare che qualunque algoritmo puo’ essereimplementato utilizzando, ricorsivamente, tre sole strutture di controllo, la sequenza(che e’ il modo di ”default” di controllo), la selezione (if...then...else) ed il ciclo,

2Tali istruzioni agiscono in sostanza sul Program Counter

8.1. IL SET ISTRUZIONI 175

(p.e., while...do). Pertanto affinche’ si possa implementare un algoritmo medianteil linguaggio macchina, una CPU deve implementare le istruzioni che corrispondonoalla selezione e ad ciclo Le istruzioni di controllo possono essere suddivise nei seguentitipi

• salti incondizionati

• salti condizionati

• chiamata a (ritorno da) subroutine

• interruzione software

Salto incondizionato Le istruzione di salto non condizionato alterno il flusso se-quenziale di un programma indicando la locazione di memoria da dove prelevare laprossima istruzione da eseguire. Esse corrispondono alle istruzioni di alto livello goto.Ad esempio,

jump 300

indica di saltare all’istruzione memorizzata nella locazione 300.

Salto condizionato Un’istruzione di salto condizionato consente di alterare il flussosequenziale di esecuzione solo se si verifica una condizione. La condizione puo’ esseretestata sulla base del valore di un flag nel registro di stato (PWS ), oppure puo’derivare direttamente da confronti su valori in registri. Ad esempio, consideriamo laselezione

if (a==b) c=d

Nel primo caso potrebbe corrispondere a

cmp a b ;confronta a con b (z = flag zero)

jnz L ;se a e’ diverso da b salta ad L

mov c d ;copia c in d

L:

mentre nel secondo

bne a b L ; (bne=branch not equal)

; se a e’ diverso da b salta ad L

mov c d ;copia c in d

L:

La prima tecnica, tipica delle architetture CISC, rende alcune traduzioni di confrontiartificialmente complesse. Ad esempio, se a e b sono due interi in complemento a 2,per stabilire se a < b bisogna eseguire a − b e controllare se il bit di stato N (cheindica se la sottrazione e’ negativa) e’ diverso da quello di overflow V . Cio’ deriva dalfatto che

a < b⇔ N ⊕ V = 1


Subroutine Come noto e’ prassi comune strutturare un programma in moduli piu’piccoli, detti sottoprogrammi (nel gergo ISA, subroutine). In ogni istante puo’ es-sere attivo un solo sottoprogramma. Ad un sottoprogramma e’ associato inoltre unambiente locale, cui esso accede in modo esclusivo, cioe’ non visibile ad altri sot-toprogrammi, nonche’ un ambiente globale derivato da sottoprogrammi attivati inprecedenza, la cui esecuzione non e’ ancora stata completata.

Il supporto ISA per le subroutine e’ rappresentato da istruzioni per la gestione diuno stack

push ; inserisce un dato nello stack

pop ; preleva un dato dallo stack

il trasferimento del controllo dovuto all’attivazione di una subroutine

call ; attiva una subroutine

ret ; ritorno da subroutine

e le istruzioni

enter

leave

per supportare programmi strutturati a blocchi.

Interruzioni Un’interruzione e’ una sospensione asincrona del programma in ese-cuzione che causa la chiamata di una routine di gestione dell’interruzione stessa3.Una interruzione viene segnalata dall’esterno al processore mediante un segnale elet-trico. Le interruzioni possono essere ad alta priorita (interruzione non mascherabile),oppure a bassa priorita’ (interruzione mascherabile). Concettualmente, mediante que-sto meccanismo si permette ad un dispositivo esterno (ad esempio un dispositivo ditemporizzazione) di chiamare una subroutine, detta interrupt handler.

Trap Sono utilizzate per segnalare condizioni anomale durante l’esecuzione di altreistruzioni, come il tentativo di eseguire un’istruzione con codice operativo non vali-do. Come per le interruzioni, un’eccezione provoca l’attivazione di una subroutine digestione, detta exception handler.

8.1.4 Istruzioni ingresso uscita

Queste istruzioni servono per inviare dati ad un dispositivo di uscita o riceverne dauno di ingresso. Le istruzioni per l’I/0 consentono di trasferire dati ad un registroesterno (buffer), associato al dispositivo. Gli indirizzi di questi registri possono essereo all’interno dello spazio di memoria (memory mapped I/O), nel qual caso di usa unanormale istruzioni di movimento dati, oppure appartenere ad uno spazio separato,(Isolated I/O), nel qual caso si usano istruzioni specifiche (tipicamente indicate conin o out). Poiche’ l’ingresso dei dati e’ asincrono, esso viene normalmente gestitomediante interruzioni.

3La logica di controllo esamina la segnalazione di interruzioni prima di ogni fase di fetch. Pertanto,la fase di esecuzione di una istruzione e’ atomica.

8.2. UNA ISA DIDATTICA, IL PD32 177

PD32

8 Registri

Bit di condizione

Unità per op. logico-aritmetiche

MEMORIA

Indirizzo

Dati

Istruzioni

Figura 8.2: Un sistema di calcolo basato sul pd32, visto del programmatore.

8.2 Una ISA didattica, il PD32

In questa sezione approfondiremo lo studio sulle ISA considerando il PD32 (ProcessoreDidattico a 32 bit), una ISA progettata per scopi didattici. Questa ISA e’ implemen-tata mediante un simulatore di pubblico dominio[PD32]. Per gli approfondimentisulla progettazione si rimanda al testo[CIOFFI94].

8.2.1 Caratteristiche

Le caratteristiche del PD32 sono (Figura 8.2)

Registri

• 8 registri generali, R0 . . . R7

• 1 Registro di stato, SR, con i seguenti flag

– Carry, C

– Negative, N

– Zero, Z

– Overflow, V

– Parity, P

– Interrupt Enabled, I

I registri sono ampi 32 bit ed accessibili in modalita’ 1,2,4 byte.

Dati I dati rappresentabili sono interi in rappresentazione complemento a 2.

Memoria Lo spazio di memoria e’ lineare e byte addressable. Non ci sono vincolisull’allineamento dei dati. La numerazione e’ di tipo little-endian.


I/O I dispositivi di ingresso/uscita sono accessibili mediante uno spazio di indirizziseparato. E’ possibile supportare fino ad 8 dispositivi.

Set Istruzioni Le istruzioni sono a 2 indirizzi e classificate come segue

• Movimento dati (MOVs, MOVFR, MOVTO, MVLs)

• Aritmetiche (ADDs, ADCs, CMPs, NEGs, SUBs, SBBs)

• Logiche (ANDs, ORs, XORs, NOTs)

• Shift (ADLs, ASRs, LSLs, LSRs, RCLs, RCRs, ROLs, RORs)

• Salto incodizionato (JMP)

• Salto condizionato (Jf ,JNf)

• chiamate a subroutine (JSR, RET)

• controllo della macchina (HALT, NOP, RESET)

• istruzioni sui bit di stato (CLRf ,SETf)

• ingresso uscita (IN,OUT)

dove s indica la taglia (size) dell’operando e puo’ essere s=B (byte), W (Word,2 byte), L (Long word, 4 byte) e f un flag del registro di stato. Sono definite 7modalita’ di indirizzamento: a registro, immediato, assoluto, indiretto con registro,con spiazzamento, relativo, con predecremento, con postdecremento.

8.2.2 Linguaggio Assembly

I programmi in linguaggio macchina sono prodotti per traduzione da un linguaggioassembly. Come noto, esiste una corrispondenza 1-a-1 uno fra istruzione assemblere istruzione macchina, ossia le istruzioni assembler non sono altro che una versionesimbolica di quelle macchina. Per tale motivo il linguaggio assembly facilita di moltola stesura del codice.

Il linguaggio assembly consente di usare nomi (simboli) per

• denotare indirizzi di memoria e dati

• riservare spazi di memoria

Un programma assembly PD32 e’ composto da un unico file di testo con la seguentestruttura

ORG <indirizzo di caricamento>

<DEFINIZIONI>

CODE

<ISTRUZIONI>

END

8.3. ESEMPI DI PROGRAMMI ASSEMBLY PD32 179

33

44

…

22

11

22

11

110x400

MEMORIA

0x401

0x402

0x403

0x404

0x405

0x406

Figura 8.3: Stato della memoria dopo aver caricato il programma che definisce levariabili.

ORG e’ una parola riservata che indica dove deve essere caricato il memoria il pro-gramma, <DEFINIZIONI> rappresenta le direttive per la definizione di dati o costantisimboliche, <ISTRUZIONI> rappresenta una lista di istruzione assembly, mentre CODEed END sono due parole riservate che denotano l’inizio e la fine del codice.

8.3 Esempi di programmi assembly PD32

In questa sezione vedremo alcuni esempi di programmi per il PD32. In particolareanalizzeremo come alcuni frammenti di codice in linguaggio C possano essere tradottiin assembly.

Direttive per la definizione di dati

Le direttive per la definizione dei dati sono DB (Define Byte), DW (Define Word),DL (Define Long word); esse riservano uno spazio di memoria, inizializzato con ildato che segue la direttiva, a partire dall’indirizzo di origine.

ORG 400h ;indirizzo iniziale (origine) del

;programma 400 h(h=esadecimale)

varByte DB 11h ;riserva spazio memoria di 1 byte

varWord DW 1122h ;2 byte

varLong DL 11223344h ;4 byte

CODE ;corpo del programma

END ;vuoto

Questo programma, una volta caricato tradotto e caricato in memoria, modifica lamemoria come in Figura 8.3

Le direttive per la definizione dei dati sono utili per allocare spazio per le variabilistatiche di un programma di alto livello. Assumendo che il tipo int richieda 2 byte elong int 4 byte, ad esempio le definizioni in C

int x=1,y=2;


long int z =3;

int a[3] = {0,1,2};

si traducono in

x DW 1

y DW 2

z DL 3

a DW 0,1,2

Direttive per la definizione di costanti

Questa direttiva permette di definire una costante simbolica. L’assemblatore sosti-tuisce la costante simbolica con il valore ad esso associato prima della traduzione delprogramma assembly in codice macchina. Ad esempio

valore EQU 100

associa al simbolo valore la stringa 100. Non viene allocata alcuna memoria.

8.3.1 Modi di indirizzamento

Per le variabili definite entro il main o in una funzione si possono usare o locazionidi memoria, oppure registri. Esse sono di norma gli operandi di una istruzione. IlPD32 offre sette differenti metodi di indirizzamento per indicare l’operando di unaistruzione.

Indirizzamenti immediato e diretto a registro

Consideriamo il semplice programma

int a;

int main ()

{

a = 123;

}

Esso puo’ essere tradotto nel seguente modo

ORG 400h

VALORE EQU 123 ; VALORE costante simbolica

CODE

MOVW #123,R0 ; copia 123 in R0

MOVW #VALORE, R0 ; equivalente istruzione precedente

END

Per la variabile a si usa il registro R0. Il valore 123 viene copiato quindi nel registroR0. Il primo operando e’ indirizzato in modo immediato, il secondo in modo direttoa registro. Si faccia attenzione al fatto che nel PD32 l’operando immediato non e’codificato nell’istruzione bensi si trova in memoria dopo l’istruzione stessa.


Indirizzamento assoluto

Non tutte le variabili possono essere memorizzate nei registri. Per mappare la varia-bile a dell’esempio precedente in memoria centrale, e’ necessario usare un indirizza-mento assoluto. Questo metodo consente di indicare l’indirizzo di memoria effettivo(Effective Address) della locazione che contiene la variabile.

ORG 400h

a DW 0 ; riserva 2 byte in memoria

CODE

MOVW #123,a ; copia 123 in a.

END

Per la variabile a viene allocato uno spazio di 2 byte, con indirizzo 400h. Il simbolo aviene sostituito dall’assemblatore con l’indirizzo effettivo della variabile, ossia 400h.Come per la modalita’ d’indirizzamento immediato, l’ assoluto non e’ codificato nel-l’istruzione ma viene conservato in memoria, dopo l’istruzione stessa. La figura 8.4riporta la memoria prima e dopo l’esecuzione del programma assembly.

00000000

10010000

00000001

01111101

00000000

...

...

00000000

..

...

...

00000000

00000000400

MEMORIA

401

402

403

404

405

406

a

407

movW #125,a

#125

indirizzo

Di a

408

409

40A

40B

40C

00000000

10010000

00000001

01111101

00000000

...

...

00000000

..

...

...

00000000

1111101400

MEMORIA

401

402

403

404

405

406

a

407

movW #125,a

#125

indirizzo

Di a

408

409

40A

40B

40C

Figura 8.4: Contenuto della memoria prima e dopo l’esecuzione del programma cheusa l’indirizzamento assoluto.

Indirizzamento indiretto a registro

Prima di illustrare questo metodo e’ importante chiarire l’uso del carattere #, checorrisponde all’operatore addressof del C. Consideriamo il seguente programma

int a=1122;

int* pi;

int main ()

{

pi = &a;


}

Il valore dell’indirizzo della variabile a deve essere copiato nella variabile puntatorepi. Una traduzione in assembly di questo programma e’ la seguente

ORG 400h

a DW 1122

pi DL 0 ; pi contiene un indirizzo

; deve essere 32 bit

CODE

MOVL #a, pi ; copia indirizzo di a in pi, ossia 400h

; MOVL a,pi avrebbe copiato 1122 in pi

END

Consideriamo adesso il codice

int a;

int* pi;

int main ()

{

pi = &a;

*pi = 123;

}

grazie al metodo indiretto a registro possiamo scrivere

ORG 400h

a DW 0

CODE

; pi corrisponde ad R0

MOVL #a, R0 ; copia indirizzo di a in R0

MOVW #123,(R0); copia 123 nella locazione il cui

; indirizzo si trova in R0

END

Questo metodo di indirizzamento permette di utilizzare un registro, nel nostrocaso R0, come puntatore.

indirizzamento con registro indice

Questo metodo e’ utile, per esempio, per accedere ad elementi di un vettore. Il valoreeffettivo dell’operando e’ la somma di una costante numerica e del contenuto di unregistro.

Ad esempio

int a[5]={0,1,2,3,4};

int main ()

{

a[4] = 123;

}


puo’ essere tradotto in

ORG 400H

a DW 0,1,2,3,4

CODE

MOVL #a, R0 ;

MOVW #123,4(R0) ; Copia 123 in MEM[4 X 2 + 400H]

END

8.3.2 Istruzioni aritmetiche

Vediamo adesso come sono tradotte le istruzioni aritmetiche. Il PD32 usa istruzionia due operandi, di cui solo uno puo’ essere al piu’ in memoria. Consideriamo ilprogramma

int a = 1;

int b = 2;

int c;

int main ()

{

c=a+b;

}

Come al solito dobbiamo per prima cosa allocare spazio per le tre variabili. Poiche’si tratta di variabili statiche esterne al main useremo la memoria. L’altro vincoloriguarda gli operandi delle istruzioni aritmetiche. Dato che uno solo di essi puo’essere in memoria, abbiamo bisogno di trasferire un operando in un registro, peresempio R0. Il codice e’ pertanto

ORG 400;

a DW 1

b DW 2

c DW 0

CODE

MOVW a,R0 ; copia a in R0

ADDW b, R0 ; R0+b in R0

MOVW R0,c ; copia R0 in c

END

8.3.3 Costrutti di controllo

I costrutti di controllo dei linguaggi ad alto livello richiedono istruzioni di salto con-dizionato ed non condizionato. Nel PD32 il salto condizionato e’ determinato dai bitnel registro di stato, SR.

I bit sono modificati ogni volta che si esegue una istruzione aritmetica. Per forzarela modificati, si deve impiegare l’istruzione di confronto (cmp), che esegue la differenzanon distruttiva fra gli operandi.


Per comodita’, useremo solo valori positivi in modo che il salto si possa eseguiretestando un solo bit di condizione.

if then else Questo costrutto viene tradotto come riportato in figura 8.5

CMPL R1, R2 ;R2-R1

JNC ELSE ;c=0 se

; R2>=R1

THEN:

; I1 ;ramo then

JMP CONT

ELSE: ;ramo else

; I2

CONT:

; I3 ;continua

if (R1>R2) I1;else I2;I3

Codice C

Codice Assembler

R1>R2

I1I2

si: R1>R2no: R1<=R2

I3

ELSE THEN

Figura 8.5: Traduzione della selezione if..then...else.

Consideriamo la traduzione del seguente programma C

unsigned int a=..;b=;max;

int main ()

{

if (a>b) max=a;

else max=b;

}

La traduzione in assembly del programma e’

ORG 400h

A DW ? ; sostituire ? con un valore

B DW ? ;

MAX DW 0 ;

CODE

MOVW B,R0 ; copia B in R0

CMPW A,R0 ; esegui B-A

; se A>B, allora il flag N=1

JNN ELSE ; salta al ramo else se N=0, ossia A<=B

THEN:

MOVW A,MAX ; copia A in MAX

JMP FINE ; salta il ramo else

ELSE:

MOVW B,MAX ; copia B in MAX


FINE:

HALT

END

ciclo for Vediamo adesso come tradurre un semplice ciclo a conteggio

int V[8];

int main ()

{

for (int i=0;i<8;i++) V[i]=i;

}

La prima cosa da fare e’ riformulare il ciclo for in modo dare rende esplicito il salto(il linguaggio C consente l’uso del goto e quindi anche delle label)

i=0;

FOR:

if (i=8) goto ENDFOR

V[i]=i++;

goto FOR

ENDFOR:

Per tradurre questo frammento di codice usiamo quattro registri: R0 per la variabilei, R1 per l’indirizzo iniziale del vettore V , R2 per il valore limite del conteggio ed R3per il passo (step) del ciclo. Il programma puo’ quindi essere tradotto come segue

ORG 400h

V DW 0,0,0,0,0,0,0,0

CODE

XORB R0,R0 ; R0=0

MOVL #V,R1 ; indirizzo di V in R1

MOVB #8,R2 ; limite per i in R2

MOVB #1,R3 ; incremento di in R3

FOR:

CMPB R2,R0 ; R0-R2

JZ ENDFOR ; se zero z=1, allora R2=R0, ossia i=8

; quindi esci dal ciclo

MOVW R0,(R1)+ ; V[i]=i++

; (R1)+ incrementa R1

; dopo che e’ stato usato

ADDL R3,R0 ; incrementa R0

JMP FOR ; ripeti ciclo

ENDFOR:

HALT

END


while do Il ciclo while...do puo’ essere trasformato in un ciclo for. Pertantola traduzione di questo costrutto non introduce novita’ rispetto a quanto visto inprecedenza.

8.3.4 La traduzione di un programma

Consideriamo adesso il seguente programma per il calcolo del massimo in un vettoredi 15 numeri interi positivi, che assumiamo occupino 1 byte.

...

unsigned short max = 0;

...

for (int i=0;i<15;i++)

if (V[i]>max) max = V[i];

...

Per comodita’, riportiamo il diagramma di flusso dell’algoritmo (figura 8.6)

Inizio

Fine

i=0

max=0

i<15

V[i]>max

max=V[i]

no

i=i+1

no

V

i

max

0

1

14

Figura 8.6: Diagramma di flusso del programma che calcola il massimo di un vettoredi 15 interi positivi.

Come puo’ essere tradotto questo codice? Ci sono varie alternative. Supponiamoche il vettore sia in memorizzato a partire dalla locazione di memoria 300h (non cisono sufficienti registri interni in cui memorizzare i dati). Per agevolare la traduzioneconsideriamo il diagramma di flusso del programma (vedi Figura 8.6.

La prima soluzione consiste nell’utilizzare un registro, ad esempio R1, per memo-rizzare l’indirizzo iniziale - R1 = 300h), R2 per l’indice i ed R3 per max. Il diagrammadi flusso diventa quello di figura 8.7, che ci guida nella scrittura del seguente codice.

ORG 400h

XORL R1,R1 ; azzera R1 (i)

XORL R2,R2 ; azzera R2 (max)


Memoria

R1 (i)

R2(max)

0

1

14

R30x300

Inizio

R1=0,R2=0R3=0x300

R1=15

(R3)>R2

R2=(R3)

si

R1=R1+1

no

R3=R3+1

Fine

Figura 8.7: Adattamento del diagramma di flusso.

MOVL #300h,R3 ; indirizzo di V in R3

LOOP:

CMPB #15,R1 ; 15-R1...

JZ FINE ; ... se z(R1=15), allora fine

1: CMPB (R3),R2 ; confronta V[i] con max

JNC skip ; se non carry, max>=V[i]

2: MOVB (R3),R2 ; V[i] in R2

SKIP:

3: ADDL #1,R3 ;incrementa indirizzo

ADDB #1,R1 ; incrementa i

JMP LOOP ; ripeti ciclo

FINE:

HALT

In questa soluzione le istruzioni con label 1 e 2 accedono in memoria. Nel caso in cuiil vettore sia ordinato in senso crescente, l’istruzione 2 viene sempre eseguita, per cuiil codice richiederebbe 30 accessi in memoria. Per quanto possibile, bisogna evitarequesti accessi poiche’ rallentano l’esecuzione del programma.

Una traduzione piu’ efficiente puo’ essere ottenuta sfruttando un registro d’appog-gio. Ossia sostituendo le istruzioni fra 1 e 2 con le seguenti

1: MOVB (R3),R4 ; copia V[i] in R4

CMPB R4,R2 ; confronta V[i] con max

JNC skip ; se non carry, max>=V[i]

2: MOVB R4,R2 ; V[i] in R2

La terza versione impiega un registro in meno. Questo si ottiene sfruttando l’indiriz-zamento con spiazzamento, ossia sostituendo l’istruzione con label 1 con la seguente

1: MOVB 300h(R1),R4 ; copia V[i] in R4

L’istruzione con label 3 viene rimossa.


Discussione Risulta chiaro da questo semplice esempio che la traduzione di unprogramma in codice assembly, e quindi in codice macchina, non e’ univoca. E’compito del compilatore trovare la traduzione ottima 4.

8.3.5 Subroutine

meccanismo di base

Il meccanismo di base relativo alle subroutine e’ fornito da due istruzioni, jsr (jumpto subroutine) e ret (return), come mostrato nel seguente codice

ORG 400h

CODE

JSR foo ; chiama subroutine foo

HALT

; foo denota 40C

RET ; ritorno al chiamante

END

L’istruzione jsr passa il controllo all’instruzione memorizzata all’indirizzo denotatofoo (ossia fornza il program counter, PC, ad assumere questo indirizzo), mentre retrestituisce il controllo al chiamante (cioe’ ripristana nel PC il valore dell’istruzioneche segue jsr; nel nostro caso halt ). Abbiamo visto che ogni istruzione occupa 4byte mentre gli operandi immediati (l’indirizzo rappresentato da foo) sono memo-rizzati dopo l’istruzione. Pertanto il contentuto della memoria, dopo aver caricato ilprecedente programma, e’ il seguente

400: JSR

404: 40C

408: HALT

40C: RET

Le istruzioni vengono eseguite secondo questa sequenza

JSR RET HALT

e cio’ richiede che PC vari in questo modo

400 40C 408

Per ottenere questo effetto le istruzioni sfruttano lo stack usando le operazioni diinserimento (push) ed estrazione (pop). L’instruzione

JSR 40C

induce le seguenti azioni

PUSH 408 ; inserisci nello stack l’indirizzo di ritorno

40C -> PC ; prossima istruzione memorizzata in 40C

4ad esempio molti compilatori C, prevedono l’opzione −O che richiede una traduzione ottimizzata.


mentre

RET

le azioni inverse

POP PC ; preleva l’indirizzo della prossima istruzione

; modifica il PC

Subroutine ricorsive

Lo stack permette ad una subroutine di chiamarne altre, o ad una subroutine dichiamare se stessa (ricorsione). Poiche’ in caso di piu’ chiamate di subroutine bisognaripristinare il PC seguendo l’ordine inverso delle chiamate, lo stack e’ la struttura datiideale per gestire le modifiche del PC. Per approfondire questo aspetto, consideriamoil seguente programma

int a = 3;

void foo(void) {

if (a!=0) { a--; foo() }

};

int main() { foo(); }

Esso viene tradotto in

ORG 400h

CODE

; main

MOVB #3,R1 ; 03 -> R1

JSR FOO ; PUSH RIT, FOO->PC

RIT: HALT

FOO:

CMPB #0,R1 ; R1 = 0?

JZ EXIT ; se z=1, allora esci

SUBB #1,R1 ; decrementa R1

JSR FOO ; PUSH EXIT, FOO->PC

EXIT: RET ; POP ->PC

END

dove per chiarezza sono state aggiunte le label RIT per indicare l’ indirizzo di ritornoal main. Una volta che il programma e’ stato caricato, la memoria diventa

400: MOVB #10,R1

404: 03 ; 0A = operando immediato

405: JSR FOO

409: 411 ; 411 = indirizzo di Foo (4 byte)

40D: HALT

411: CMP #0,R1


415: 00 ; operando immediato

416: JZ EXIT

41A: 42B ; 42B = indirizzo EXIT

41E: SUBB #1,R1

422: 01

423: JSR FOO

427: 411 ; 411 = indirizzo FOO

42B: EXIT

L’evoluzione dello stack e’ riportata in Figura 8.8

40D40D40D40D40D40D40D

42B

42B42B42B

42B42B42B42B42B

Figura 8.8: .

Record di attivazione

Per supportare le attivazione ricorsive (dirette o indirette) dei linguaggi di alto livelloe’ necessario non solo tenere traccia degli indirizzi di ritorno, ma consentire anche

• il passaggio di parametri tra chiamante e chiamato (sia in ingresso che in uscita)

• l’utilizzo esclusivo di un’area dati per le variabili locali alla funzione attivata

Una tecnica molto usata consiste nello sfruttare una struttura dati chiamata Re-cord di Attivazione. Ogni volta che una nuova funzione (subroutine) viene attivata unnuovo record di attivazione viene creato e memorizzato in cima allo stack. Al terminedella funzione il record viene eliminato.

I record di attivazione sono cioe’ gestiti con politica LIFO. Ad ogni record diattivazione e’ associato un indirizzo dello stack, detto Base o Frame Pointer (BP). Ilvalore del BP del record di attivazione che si trova in cima allo stack viene memorizzatoin un registro. Nel caso del PD32 useremo il registro R6. Si ricordi inoltre che nelPD32 la cima dello stack e’ riferita da R7 (R7 agisce cioe’ da Stack Pointer,SP). Loscopo del BP e’ accedere alle informazioni presenti nel record in modalita’ relativa.

Un record di attivazione contiene le seguenti informazioni

• Il valore dei parametri

• Indirizzo di ritorno

• Link dinamico


• Variabili locali

Il link dinamico di una subroutine e’ il valore del BP associato alla subroutinechiamante.

passaggio dei parametri Il passaggio dei parametri avviene secondo lo schemacome riportato in Figura Questo schema si riferisce al caso in cui la subroutine

push R0 ; primo parametropush R1 ; secondo parametro

jsr PROC; chiamo la subroutine

addl #8,R7; libera area dati: 4*numero_parametri…PROC:

PUSH R6; salva vecchio Base PointerMOVL R7,R6; setta BP corrente; primo parametro ad offset 8..

…POP R6; ripristino BP

RETR6 (old)

Indirizzo ritorno

R6,R7

Indirizzi crescenti…

R0

R1

R6+4

R6+8

R6+12

STACK

Figura 8.9: Esempio di passaggio di parametri mediante il record di attivazione

chiamante voglia passare due parametri, R0 ed R1 mediante lo stack alla subroutinePROC. Si noti che al rientro dalla subroutine la procedura chiamante ha il compitodi liberare l’area di memoria usata per il passaggio dei parametri. Questo avvienesemplicemente modificando il valore di R7. Si ricordi che nel PD32 lo stack cresceverso i valori bassi.

La subroutine chiamata crea il link dinamico salvando il vecchio BP (R6) e mo-difica il BP corrente in modo che sia uguale ad R7. Da questo momento in poi, iparametri saranno acceduti in modo relativo rispetto ad R6. Ad esempio io primoparametro si trova ad offset +8. Prima di eseguire l’istruzione di ritorno, la subroutinechiamata ripristina il vecchio BP.

Variabili locali Ammettiamo adesso che la subroutine chiamata debba agire sudelle variabili locali. Tali variabili, dette in gergo variabili automatiche, sono allocatenello stack, come mostra la Figura 8.10.

La Figura 8.10 si riferisce al caso in cui si debbano usare 3 variabili locali da 4byte ciascuna. Per l’allocazione dello spazio e’ sufficiente decrementare il valore diR7, mentre per il recupero dello spazio basta incrementare R7 della stessa quantita’.Queste operazioni sono a carico del chiamato ed avvengono dopo avere creato il linkdinamico verso il chiamante ed aggiornato il BP . In questo modo l’offset dei parametrinon varia. Si noti inoltre che le variabili locali si trovano ad un offset positivo rispettoai parametri.


…

PROC:

PUSH R6; salva vecchio Base Pointer

MOVL R7,R6; “setta” BP corrente

SUBL #12,R7; alloca 12 byte

; i parametri sono sempre al solito offset.

…

ADDL#12,R7; libera 12 byte

POP R6; ripristino BP

RET

VAR_LOCALE

VAR_LOCALER6

Indirizzi crescenti…

R6 (old)

R0

R1

R6+4

R6+8

R6+12

VAR_LOCALER7

Indirizzo ritorno

STACK

R6-4

R6-8

Figura 8.10: Esempio di allocazione di memoria per le variabili locali.

Salvataggio dello stato del processore Lo stato del processore in un dato istantee’ definito dall’insieme dei valori dei suoi registri. Se una subroutine A ne attivaun’altra, B, e’ fondamentale che quando B restituisce il controllo ad A, A ritrovi ilprocessore nello stesso stato. In questo modo A puo’ continuare il lavoro che stavaeseguendo. In altri termini vogliamo che l’esecuzione di B non abbia effetti collaterali(side-effect) su A.

Per garantire questa proprieta’ di isolamento fra chiamate e chiamato, la subrouti-ne chiamata salva lo stato prima che esso possa essere modificato, ossia che esegua laprima istruzione, e lo ripristina prima che il chiamante riprenda l’esecuzione successivaalla jsr.

Per salvare lo stato del processore, il PD32 mette a disposizione le istruzioniPUSHSR e POPSR mediante le quali il registro SR viene salvato nello stack e ripristinato(Figura 8.11). E’ compito della subroutine chiamata salvare e ripristinare eventualialtri registri utilizzati.

Esempio

Consideriamo la classica funzione per lo scambio di due valori

void swap(int *x,int*y) {

int tmp;

tmp=*y;

*y=*x;

*x=tmp;

}

int a=2; int b=3;

main () {

swap(&a,&b);


…

PROC:

PUSH R6; salva vecchio Base Pointer

MOVL R7,R6; “setta” BP corrente

SUBL #12,R7; alloca 12 byte

; i parametri sono sempre al solito offset.

PUSHSR; push status register

..

POPSR; pop status register

ADDL#12,R7; libera 12 byte

POP R6; ripristino BP

RET

SR

VAR_LOCALE

VAR_LOCALER6

Indirizzi cre

scenti…

R6 (old)

R0

R1

R6+4

R6+8

R6+12

VAR_LOCALE

R7

Indirizzo ritorno

Figura 8.11: Salvataggio e ripristino del registro di stato, SR.

}

}

Applicando quanto detto finora, una possibile traduzione di questa funzione, in cuiR6 svolge il ruolo di BP ed R7 quello di FP e’ la seguente

ORG 400h

a DL 0 ; area dati per a

b DL 3 ; area dati per b

CODE

MAIN:

MOVL #a,R0 ; sposto indirizzo di a in R0

PUSH R0 ; inserisco valore nello stack (parametro ingresso)

MOVL #b,R0 ; idem ...

PUSH R0 ; ... per b

JSR swap ; chiamo swap(&a,&b)

ADDL #8,R7 ; al ritorno recupero spazio dallo stack

HALT ; fine programma

SWAP:

MOVL R7,R6 ; salva BP

SUBL #4,R7 ; alloca spazio per tmp in BP-4

PUSH R0 ; salvo valori che usero’

PUSH R1 ; ...

PUSHSR R0 ; copio SR in R0


MOVL 4(R6),R0 ; R0=&b=y

MOVL 8(R6),R1 ; R1=&a=x

MOVL (R0),-4(R6); tmp=*y

MOVL (R1),(R0) ; *y=*x

MOVL -4(R6),(R1); *x=tmp

POPSR ; reinstallo stato precedente

POP R1 ; ripristino valore R1

POP R0 ; ripristino valore R0

ADDL #4,R7 ; recupera area tmp

RET ; ritorno controllo al chiamante

END

Discussione Praticamente tutti i linguaggi di programmazione procedurali usanole funzioni come strumento di modularizzazione. Per cui esistono istruzioni appositeper la gestione dello stack. Per esempio nella ISA 32, oltre a istruzioni simili a jsr eret, che gestiscono il salvataggio dello stato del processore, sono definite le istruzionienter e leave per il supporto alle regole di visibilita’ dei linguaggi di programmazioneprocedurali a blocchi. Per quanto riguarda il passaggio dei parametri, piuttosto chesfruttare lo stack, le architetture recenti cercano di sfruttare i registri interni medianteun meccanismo detto ”a finestra”. Tale meccanismo risulta piu’ efficiente poiche’ evitadi accedere il memoria.

8.3.6 Altri esempi di programmi per il PD32

Vediamo adesso altri esempi di programmi per il PD32

Jump Vector Table(*)

Il seguente costrutto case

int i,j,h,g,f,k;

main ()

{

case(k) {

case 0: f = i+j;break;

case 1: f = g+h;break;

case 2: f = g h;break;

case 3: f = i j;break;

}

}

puo’ essere tradotto usando una tabella di salti (Jump Vector Table). Si tratta diuna tabella in memoria i cui elementi contengono l’indirizzo cui bisogna saltare. Latraduzione in assembly e’ riportata in Figura 8.12

8.4. ESEMPI DI ISA REALI 195

ORG 400h

JVA EQU 400h

JVT DL 0,0,0,0 ;Jump Vector Table

CODE

movL #case0, JVA

movL #case1, JVA+4

movL #case2, JVA+8

movL #case3, JVA+12

movW #3, R4;esempio

aslW #2, R4

movL JVT(R4),R0

jmp (R0)

;….

Case0:

movW R2, R6

addW R3, R6

JMP Exit

Case1:

movW R1, R6

addW R5, R6

JMP Exit

Case2:

movW R1, R6

subW R5, R6

JMP Exit

Case3:

movW R2, R6

subW R3, R6

Exit:

HALT

END

R1 = gR2 = iR3 = j R4 = kR5 = hR6 = f

Case0

Case1

Case2

Case3

JVT[0]

JVT[1]

JVT[2]

JVT[3]

Figura 8.12: Traduzione di un costrutto case mediante tabella di salti.

Si noti che lo spiazzamento di un elemento nella tabella corrisponde al valore di k(R4 nella traduzione) moltiplicato per 4. Tale prodotto si ottiene spostando R4 di 2posizioni a sinistra (istruzione ASLW #2,R0).

Esercizio 8.1 (Risolto). Supponiamo che un carattere ASCII sia memorizzato in unavariabile di tipo char (1 byte). Scrivere un programma che modifichi il contenuto dichar in modo che il numero di bit pari ad 1 sia pari.

Soluzione. Un carattere ASCII richiede 7 bit. Si tratta di conoscere quanti di questi ibit sono pari ad 1. Se tale numero e’ dispari, allora e’ necessario porre l’ultimo bit ad1. Per quanto riguarda il primo punto, si sfrutta il bit P nel registro di stato. Questobit vale 1 se il risultato dell’ultima operazione aveva un numero pari di bit. Pertanto,se R0 contiene il carattere e’ sufficiente che siano eseguite le seguenti istruzioni

ADDB #0,R0 ; forza il bit P

JP FINE ; se P=1 non fare nulla

ORB #80h,R0 ; OR bit a bit (80h = 1000 0000)

; 1000 0000 OR 0bbb bbbb = 1bbb bbbb

JUMP FINE

FINE:

HALT

8.4 Esempi di ISA reali

Concludiamo questo capitolo accennando alle caratteristiche di alcune ISA di mag-giore diffusione. La Figura 8.13 riporta i nomi di queste ISA ed alcune realizzazioni


RISCUltraSparcSPARC

Usato nei computer MAC Famiglia PowerPCPowerPC

Modi 64-bit, 32-bitPower6Power

Molto innovativa rispetto

alle precenti

Itanium, Itanium2IA-64

Vari modi operativi per

compatibilita’

AMD Athlon 64, OpteronAMD64

Simile a AMD64Xeon, Celeron D, Pentium 4,

Pentium D,..Intel64

Estensioni SIMD Pentium IIIA-32 + estensioni

Vari modi operativi per

compatibilita’

Intel386,Intel486,PentiumIA-32

NoteEsempi di CPUISA

Figura 8.13: Alcuni nomi di ISA ed esempi di CPU che la implementano.

(microarchitetture).

Si puo’ osservare che mentre esistono relativamente poche ISA, molti sono invece iprocessori che realizzano una ISA. Le varie versioni introducono o dei miglioramenti aduna data microarchitettura, oppure sono basati su microarchitetture molto differenti.Un cambiamento sostanziale nella microarchitettura che implementa la stessa ISA (adesempio pipeline) introduce invece una nuova famiglia di processori. Ad esempio lafamiglia di processori Intel P6 e’ composta da vari processori (Pentium Pro, PentiumII, etc.) che implementano la stessa ISA IA-32.

Estensioni

In alcuni casi la specifica iniziale di una ISA viene estesa mediante l’aggiunta dialtre istruzioni orientate ottenere prestazioni migliori. Ad esempio, la Intel ha estesola IA-32 mediante istruzioni SIMD (Single Instruction Multiple Data). Si tratta insostanza di istruzioni che consentono di eseguire la stessa operazione (ad esempioaddizione) contemporaneamente su piu’ dati (ad esempio elementi di un vettore).Una recente estensione nelle CPU Intel e’ rappresentata da istruzioni al supportodella virtualizzazione del processore.

Modalita’ operative

Quando viene introdotta una nuova ISA e’ spesso importante garantire la compa-tibilita’ con ISA precedenti, poiche’ questo si traduce sia nella possibilita’ di potercontinuare ad eseguire i programmi gia’ esistenti, sia di introdurne gradualmente dinuovi che sfruttino le nuove caratteristiche della ISA.

A tale scopo, la soluzione adottata consiste nel definire delle modalita’ operative ingrado di emulare le ISA precedenti. Ad esempio, la ISA AMD64 specifica 6 modalita’operative, come riportato in Figura 8.14.


Figura 8.14: Modalita’ operative prevista dalla ISA AMD64

Privilegi

Ogni calcolatore e’ dotato di un sistema operativo. Si tratta in sostanza di un pro-gramma ”speciale” che facilita l’utilizzo del calcolatore da parte di altri program-mi (detti programmi utente o applicazioni). Il sistema operativo si prende in ca-rico la gestione di operazioni ”critiche”, ossia la cui correttezza determina il buonfunzionamento di tutto il calcolatore.

Per supportare l’esecuzione di operazioni critiche, come quelle del sistema ope-rativo, una ISA definisce di norma la nozione di privilegio, un attributo dello statocorrente del processore. Ad ogni livello di privilegio, corrisponde un insieme di istru-zioni ben preciso che esso puo’ eseguire. Il livello di privilegio massimo consente diusare tutte le possibili istruzioni ISA, mentre quelli piu’ bassi nascondono man manoalcune istruzioni critiche.

Il tentativo di eseguire un’istruzione senza aver il privilegio adeguato genera un’ec-cezione (trap). Le funzionalita’ offerte da queste istruzioni privilegiate non sono pre-cluse, ma possono essere sfruttare mediante un meccanismo di delega. Se il proces-sore si trova in uno stato di privilegio ridotto, e’ possibile da questo stato attivare


Sistema

Opertivo

Programma

Istruzioni

utene

ISA

Istruzioni

privilegiate

chiamate

al S.O.

Figura 8.15: L’utilizzo delle istruzioni privilegiate da parte di un’applicazione e’mediato dal sistema operativo.

codice contente istruzioni privilegiate accuratamente testato, tipicamente, chiamateal sistema operativo (Figura 8.15). Il livello di privilegio verra’ alzato ed alla finedell’esecuzione riportato a quello iniziale.

Registri

Il numero ed il tipo di registri e’ un aspetto caratteristico di una ISA. I registri sonodetti ad uso generale se non ci sono restrizioni sul tipo di informazione che possonomemorizzare, o ad uso speciale se dedicati ad una funzione (ad esempio il ProgramCounter). A titolo di esempio, la Figura 8.16 riporta i principali registri della IA-32.

Il primo gruppo di 8 sono registri ad uso generale, anche se ognuno e’ dedicatoad una particolare funzione. EAX e’ il registro aritmetico principale; EBX e’ usatoanche come puntatore Base per il calcolo di indirizzi; ECX come contatore per ope-razioni su stringhe e cicli; EDX e’ impiegato di per operazioni di ingresso/uscita oper le operazioni di moltiplicazione e divisione.

I registri ESI e EDI sono usati, tra l’altro, per le operazioni su stringhe (il primopunta alla stringa sorgente il secondo a quella destinazione di operazioni su stringhe).Gli ultimi due registri di questo primo, EBP ed ESP , servono come registro baseper il record di attivazione (Base Pointer, vedi Sezione 8.3.5) e Stack Pointer.

Il successivo gruppo di sei registri e’ costituito da registri segmento. Essi sonoampi 16 bit e conservano i selettori dei segmenti di memoria, come spigato piu’ avantiin Sezione 8.4.1. Infine c’e’ il registro EIP che altro non e’ che il program counter edinfine il registro di stato EFLAGS.

Nella figura 8.17 sono riportati i registri visibili nell’ISA Intel 64 in modalita’ 64-bit. Alcuni registri sono accessibili solo mediante particolari istruzioni. Ad esempio,le istruzioni relative ad operazioni su numeri in virgola mobile, eseguite da una unita’di calcolo dedicata FPU (Floating Point Unit) sono accessibili solo mediante istruzionispecifiche e sono ampi 80 bit (lo standard IEE 754, ha definito che la dimensione delformato doppia precisione estesa sia almeno di 79 bit). I registri MMX ed XMM sonoaccessibili solo da un insieme di istruzioni che hanno esteso la definizione originariadella IA-32.


Figura 8.16: I registri generali

8.4.1 Memoria logica

Le istruzioni macchina fanno in genere riferimento ad uno spazio di memoria logico,la cui struttura e numerazione differiscono da quelle fisiche. E’ compito di un mecca-nismo trasparente al codice mappare un indirizzo logico (quello usato nell’istruzione),addl, in un indirizzo fisico (quello in transito verso la memoria sul bus indirizzi), addf .Questa corrispondenza varia dalla semplice identita’ (per cui addl = addf , come nellevecchie CPU), o puo’ includere un ulteriore livello intermedio secondo il quale l’in-dirizzo logico viene prima trasformato in indirizzo virtuale, addv, e poi da questi inquello fisico, come nelle CPU attuali, Figura 8.18. Quest’ultima corrispondenza e’ ge-stita di norma dal sistema operativo, cui la CPU fornisce supporto mediante appositimeccanismi detti di paginazione (paging).

Le principali motivazioni del disaccoppiamento fra spazio di indirizzamento logicoe fisico sono i seguenti.

• Maggiori dimensioni, la dimensione dello spazio logico puo’ essere maggiore diquello fisico

• Protezione, e’ possibile implementare politiche di sicurezza per l’accesso ad areedi memoria logica


Figura 8.17: Registri visibili dell’ISA Intel64, in modalita’ 64-bit.

• Rilocabilita’, il codice puo’ essere caricato ed eseguito in qualunque area dimemoria senza che il codice debba essere modificato

Memoria lineare

In questo modello, le istruzioni hanno accesso ad un unico insieme continuo di celledi memoria di dimensione pari ad un byte ognuna caratterizzata da un indirizzo. Leoperazioni elementari sono quella di lettura di una cella di memoria e di scrittura diun dato in una cella di memoria.

Pur essendo le celle di memoria indirizzate byte per byte (byte-addressable), essepossono contenere dati composti da piu’ byte. L’ indirizzo di un dato multi-byte puo’essere o quello del byte meno significativo (little-endian, o a finale piccolo) oppurequello piu’ significativo (big-endian, o finale grande). Supponiamo che il valore intero5 sia codificato mediante 2 byte, memorizzati all’indirizzo 31. La figura 8.19 indica


Indirizzo

logico

Indirizzo

virtuale

Indirizzo

fisico

Figura 8.18: Indirizzi logico, virtuale fisico.

il contenuto della memoria. Nel caso di convenzione little endian questo indirizzoe’ quello del byte meno significativo e la memoria ha la configurazione riportata in(a); nel caso di convenzione big-endian il contenuto della memoria e’ quello riportatoin (b). La differenza nell’ordinamento di byte diviene visibile se due macchine conconvenzioni differenti si scambiano dati, oppure si osserva il contenuto della memoria,come ad esempio fatto mediante il codice dell’Esempio 2.32.

0000101

0000000

31

32

33

30

00000000

0000101

31

32

33

30

(a) (b)

Figura 8.19: I due modi per assegnare l’indirizzo ad un dato composto da due bye.

Esempio 8.1. Lo storico processore Z80, prodotto dalla Zilog a partire dal 1976 aveva16 piedini dedicati ad inviare indirizzi di memoria. Lo spazio di memoria era byteaddressable e lineare. Pertanto le istruzioni potevano indirizzare 216 byte, ossia lospazio di memoria era 64KB.

Figura 8.20:


Esempio 8.2 (Spazio d’indirizzamento AMD64). L’architettura AMD64 consente diindirizzare uno spazio di memoria lineare da 264 byte. Le implementazioni attualidi questa ISA tuttavia non sfruttano tutto lo spazio, poiche’ eccessivamente granderispetto alle reali esigenze. Esse invece richiedono che l’indirizzo sia contenuto nei bit0-47 bits. I bit 48-63 devono essere pari al bit 47 (come per l’estensione del segno).Lo spazio di memoria effettivo e’ quindi 248 byte.

Esempio 8.3. I programmi scritti in C vengono tradotti (dai compilatori) in pro-grammi eseguibili che organizzano lo spazio di memoria lineare in modo simile aquello riportato in Figura 8.21.

Codice

eseguibile

Varibili statiche

Stack

Heap

LIBERO

0

max

Figura 8.21: Suddivisione dello spazio di memoria lineare in aree di memoria che con-tengono dati differenti.L’area codice e l’area delle variabili statiche hanno dimensionefissa e nota al tempo di compilazione. Le altre aree sono dinamiche.

Lo spazio lineare e’ diviso in 4 aree di memoria. La prima area contiene il codiceeseguibile, la seconda e’ dedicata alle variabili globali. L’ampiezza di queste due areedi memoria non varia durante l’esecuzione del programma. La terza area e’ costituitadallo stack, che cresce verso gli indirizzi bassi. Lo stack e’ il supporto per l’esecuzionedi sottoprogrammi. L’ultima area di memoria, detta heap, serve per contenere variabilidinamiche (create con l’operatore new), e cresce in senso opposto allo stack.

Memoria bidimensionale

L’architettura di von Neumann prescrive che la memoria di un calcolatore contengasia i dati che il codice eseguibile. La natura di queste informazioni e’, ovviamente,profondamente diversa. Mentre i dati possono essere letti o scritti, il codice nonpuo’ mai essere modificato5. Per aumentare l’affidabilita’ dei programmi sarebbe

5In realta’ in passato cio’ non era escluso, ossia una istruzione poteva anche modificarne un’altra;questa tecnica del codice auto-modificante e’ in disuso.


dunque buona norma evitare che un’istruzione possa scrivere, per errore, una variabilenell’area di memoria che invece contiene il codice, ossia suddividere la memoria in dueparti logicamente distinte.

Un altro motivo per inserire meccanismi di protezione sull’uso della memoria derivadal fatto che nello stesso istante un calcolatore contiene di regola piu’ programmi attivi(multitasking), ognuno con un’area dati ad esso dedicato (per esempio organizzatacome in Figura 8.21) e con privilegi differenti (tipicamente il sistema operativo e variprogrammi utente).

Il modello di memoria bidimensionale permette di rispondere a queste esigenze.Esso introduce una seconda dimensione nello spazio di memoria, dando quindi l’il-lusione ad un programma di disporre di tanti spazi di memoria lineari indipendenti,chiamati segmenti. Un programma puo’ quindi impiegare segmenti differenti per con-tenere dati di tipo differente (codice, dati, etc) ed richiedere per ogni segmento uncerto grado di protezione.

Ad esempio, il segmento codice puo’ solo essere eseguito (quindi acceduto nella fasedi fetch), mentre un altro segmento potrebbe contenere le variabili del programma, equindi puo’ essere sia letto che scritto.

Esempio 8.4 (Protezione mediante segmentazione). La Figura 8.22 mostra il modellodi memoria segmentata nelle ISA IA-32. L’indirizzo di memoria e’ composto da dueparti. La prima parte si chiama selettore ed e’ lunga 16 bit la seconda 32 bit. La primaparte e’ memorizzata in un registro segmento. I primi 13 bit contengono l’indice inuna tabella, detta tabella dei descrittori contenente un certo numero di descrittori disegmento, un bit indica il tipo di tabella (Locale o Globale) e 2 il livello di privilegiodel richiedente (Requestor Privilege Level). L’architettura consente l’esistenza di piu’tabelle locali, ma di una sola globale - usata per segmenti del sistema operativo.

Indice

+base

limiteprivilegio

+

indirizzo

fine segmento

inizio segmento

Tabella dei descrittori

MemoriaT RPL

131 2

3216Selettore Offset

INDIRIZZO

Figura 8.22: Nell’ISA IA-32 l’indirizzo bidimensionale viene trasformato in uno linearemediante una tabella nella quale sono inserite informazioni di protezione.

Nel descrittore sono presenti, tra l’altro, l’indirizzo di base del segmento, il limitedel segmento, il tipo di segmento (ossia segmento a sola lettura, lettura/scrittura,


etc.) ed il livello di privilegio del segmento. Quest’ultimo dato serve per verificare seil livello di privilegio del richiedente (Requested Privilege Level, RPL) sia almeno parial livello di privilegio nel descrittore. In caso contrario viene generata un’eccezione.Un’eccezione viene anche generata se si cerca di accedere al segmento in modalita’non consentita (ad esempio in scrittura qualora il segmento sia a sola lettura). Laseconda parte dell’indirizzo contiene lo spiazzamento rispetto alla base.

Capitolo 9

Laboratori

9.1 Breve introduzione al simulatore DSCH

Questa sezione illustra alcuni esperimenti da svolgere mediante il simulatore di portelogiche DSCH. Il simulatore e’ di pubblico dominio, [DSCH].

DSCH mette a disposizione una libreria di componenti di base per disegnare esimulare una rete logica (come ad esempio porte NOT, AND, Pulsanti, etc., vediFigura 9.1) ed una libreria di componenti avanzati (ROM, Multiplexer 2:1, etc.).L’utente puo’ ampliare la libreria esistente definendo, anche in modo gerarchico, nuovicomponenti cui sono associati nuovi simboli.

DISPLAYCLOCK

LED

PULSANTE

1 logico0 logico

PORTELOGICHE

TASTIERA

FLIP-FLOP D

LATCH D A LIVELLO

RAM 8 x 8 BLOCCHI LOGICI

MOS

BUFFER tri-state

Figura 9.1: Gli elementi di base del simulatore DSCH.

Le simulazioni sono interattive; esse consentono di iniziare e terminare una simu-lazione nonche’ di agire sui dispositivi di ingresso (pulsante e tastiera). Il simulato-re consente di analizzare il diagramma temporale dei segnali generati durante unasimulazione. La Figura 9.2 mostra le icone disponibili nell’ambiente di simulazione.

205

206 CAPITOLO 9. LABORATORI

NUOVOSIMBOLO INIZIO

SIMULAZIONECRONOGRAMMA

LISTA SIMBOLI

ORIENTAMENTO

DUPLICA

MUOVI

LINEA

CONNESSIONECANCELLA

Figura 9.2: Icone del simulatore e descrizione delle principali funzioni.

La Figura 9.3 mostra l’ambiente di simulazione. Per usare il simulatore si deveanzitutto costruire un circuito utilizzando sia componenti delle librerie (drag anddrop) sia inserendo simboli. Dopodiche’ si avvia deve avviare la simulazione (iconastart). Alcuni componenti (generatore di onda quadra, pulsante, tastiera) consentonodi generare i segnali di ingresso indipendenti. I segnali di uscita sono quelli cui sonocollegati componenti di visualizzazione (led oppure display).

Figura 9.3: Ambiente di simulazione ed esempio di circuito logico.

Per simulare il circuito e’ necessario premere l’apposita icona. Durante la simu-lazione e’ possibile regolare la velocita’ di esecuzione e stabilire se mostrare lo statologico dei terminali dei componenti e delle linee che li connettono, Figura 9.4.

VELOCITA’ SIMULAZIONE

STATO DEI TERMINALISTATO

CONNESSIONI

Figura 9.4: Pannello di controllo della simulazione.

Ogni circuito viene salvato in un file di testo con estensione .SCH.

9.2. PORTE LOGICHE ELEMENTARI 207

9.2 Porte logiche elementari

Ritardo di propagazione La rapidita’ della reazione di una porta logica ad uncambiamento di segnale in ingresso e’ misurata dal ritardo di propagazione. Questovalore e’ dovuto a due componenti. La prima e’ costante ed e’ dovuta al temporichiesto affinche’ i componenti elettronici che costituiscono la porta possano reagiree costituisce il ritardo proprio della porta. La seconda componente varia a secondadel carico della porta, ossia il numero ed il tipo di elementi connessi all’uscita dellaporta. Nel simulatore questi due valori sono visibile all’interno di una finestra, cheappare cliccando due volte sulla porta (Figura 9.5). La prima componente apparesotto la voce delay, la seconda sotto la voce load. Il valore fanout, indica il numero dielementi connessi all’uscita della porta.

Il simulatore assegna ad ogni porta un ritardo proprio di 0.090 ns (standardspeed) o 0.080 (high speed). Per ogni componente collegato all’uscita il ritardo vieneincrementato di 0.070 ns.

RITARDODELLA PORTA

RITARDO COMPONENTIA VALLE

FANOUT

Figura 9.5: Ritardo di propagazione associato ad una porta.

9.2.1 Inverter

Come primo semplice esempio, consideriamo la simulazione di un invertitore. A questofine e’ necessario costruire il circuito di Figura 9.6.

Figura 9.6: Simulazione della porta NOT.

Dopo aver avviato al simulazione, SIMULATE → START-SIMULATION, e’ possibilepremere il pulsante ed osservare la reazione del circuito. Il pulsante assume il colore


rosso quando e’ nella posizione di on, ossia genera il valore logico 1. Quindi il led siillumina quando il pulsante e’ nella posizione off. Dopo aver simulato il circuito e’interessante osservare il diagramma temporale, Figura 9.7. E’ possibile aumentare larisoluzione del diagramma temporale agendo sul pulsante cha appare sopra alle freccedella finestra, fino ad osservare il ritardo di propagazione. Il valore della risoluzione e’espresso in ns per divisione (ns/div). Ad esempio, con una risoluzione di 0.1 ns/div,ogni divisione che appare nel diagramma rappresenta un intervallo di 0.1 ns.

input

output

Figura 9.7: Andamento temporale dei segnali in ingresso ed in uscita dall’invertitore.

9.2.2 Altre porte

La Figura 9.8 riporta il prossimo esperimento. Si tratta di simulare il funzionamentodelle principali porte logiche sfruttando due generatori di onda quadra, A e B, condiverse caratteristiche. Per l’onda quadra A i valori alto e basso hanno durata uguale,pari a 10 ns. Per l’onda quadra B, il segnale rimane alto per 10 ns e basso per 5ns.In questo modo le porte ricevono in ingresso tutte le 4 possibili combinazioni di valorilogici. I diagrammi temporali sono riportati in Figura 9.9.

Figura 9.8: Circuito per la simulazione delle porte.

9.3. RETI COMBINATORIE 209

Figura 9.9: Diagrammi temporali ottenuti dopo una simulazione.

9.3 Reti combinatorie

9.3.1 Full Adder

Studiamo il comportamento temporale di un sommatore completo. Costruiamo anzi-tutto il sommatore, come riportato in Figura 9.10. Il ritardo di propagazione di unaporta vale

0.090 + n 0.070

dove n e’ il numero di componenti collegati all’uscita della porta. Quindi tutte leporta hanno lo stesso ritardo, ad eccezione di XOR-1 che deve pilotare sia AND-2 cheXOR-2 (n = 2).

XOR-1

XOR-2

AND-1

AND-2

OR

Figura 9.10: Full Adder.

Per studiare il funzionamento porre in sequenza gli ingressi A,B e Cin ad 1, otte-nendo cosi un diagramma temporale simile a quello di Figura 9.11. Aumentando larisoluzione della scala temporale fino a portarla a 0.1 ns/div e’ possibile analizzarepiu’ da vicino le variazioni dei segnali.


Al tempo t1, e’ stato premuto il pulsante A. Dopo un certo ritardo di propagazionel’uscita S cambia stato. Questo avviene al tempo t2. I segnali A ed S sono separatidalle porte XOR-1 e XOR-2; per cui il ritardo t2− t1 e’ dovuto alla somma dei ritardidi XOR-1 e XOR-2 e vale 0.090+0.070 + 0.090 + 0.140=0.39 ns.

Al tempo t3, l’ingresso B cambia stato portandosi dal valore 0 ad 1. Il valore finaledelle uscite deve essere Cout = 1, S = 0. Possiamo osservare che la prima variazionee’ quella di Cout, che avviene al tempo t4, seguita dalla variazione di S, che avvieneal tempo t5. La differenza nei due tempi di propagazione e’ dovuta al maggior caricoe quindi ritardo della porta XOR-1 (vedi figura 9.11).

La variazione dell’ingresso al tempo t6 provoca la variazione di S al tempo t7. Ilritardo e’ determinato dalla sola porta XOR-2 ed e’ quindi minore rispetto a quelloosservato in t1.

(FIN QUI)

t1

t2

t3

t4 t5

t6

t7

Figura 9.11: Diagramma temporale relativo ad una simulazione del FA.

9.3.2 Ripple Carry Adder

Definizione di un nuovo simbolo Il simulatore DSCH consente di definire modulicomposti da elementi di base, o da altri moduli. Per creare un nuovo modulo, FILE →SCHEMA-TO-NEW-SYMBOL. Le linee di ingresso al modulo creato, sono definite sulla basedele linee di ingresso agli elementi costituenti il modulo alle quali sono effettivamentecollegati dispositivi di ingresso (ad esempio, un pulsante). Analogamente, le lineedi uscita del modulo sono definite sulla base delle linee degli elementi che risultanocollegate a dispositivi di uscita (ad esempio un led). E’ possibile variare l’ordine concui nel simbolo creato appaiono le linee, il lato, la dimensione del simbolo. Comeesempio, definiamo un nuovo simbolo, FA (Figura 9.12). Per usare il simbolo creatoINSERT → USER-SYMBOL. I simboli sono salvati in un file con estensione .SYM.

Un RCA a 4 bit Un RCA puo’ essere simulato collegando 4 sommatori completi.Possiamo usare il nostro simbolo appena creato, FA, oppure il simbolo Fulladderfornito con la distribuzione del simulatore (Figura 9.13).

Per simulare il circuito bisogna utilizzare due tastiere esadecimali (keyboard) comedispositivi di ingresso ed un display come dispositivo di visualizzazione. Un esempiodi diagramma temporale e’ riportato in Figura 9.14 nel caso in cui i valori da sommaresono F ed 1. E’ interessante notare le variazioni del segnale sum[0..7] che pilota il

9.3. RETI COMBINATORIE 211

LATO, L=ingresso, R=uscitaPOSIZIONE

AMPIEZZA

SIMBOLO

Figura 9.12: Finestra del nuovo simbolo creato a partire dal Full Adder.

Figura 9.13: Schema di un RCA da 4 bit. Il primo stadio usa un HA.

display. Le variazioni sono dovute alla propagazione del riporto che ha luogo dalprimo all’ultimo stadio, come discusso nella Sezione 4.3.3.

9.3.3 ALU

Consideriamo adesso la ALU ad un bit descritta nella Sezione . Per la sua simulazionedefiniamo anzitutto un nuovo componente, un multiplexer 4:1 (Figura 9.15), cui diamoil nome di Mux4-1 (si ricordi che il nome del simbolo e’ uguale al nome del file checontiene lo schema del componente).

Dopodiche’ e’ possibile costruire la ALU ad un bit di Figura 9.16.

Per simulare una ALU a 4 bit associamo al circuito precedente un ulteriore simbolo,ALU1. A partire da questo nuovo simbolo e’ poi possibile costruire una ALU a 4 bit,come riportato in Figura 9.17.


Figura 9.14: Diagramma temporale relativo ad una simulazione del RCA da 4 bit. Inquesta simulazione sono stati usati i simboli Halfadder e Fulladder

Figura 9.15: Schema del multiplexer 4:1 in Dsch (file: Mux4-1.sch).

9.4 Reti sequenziali

9.4.1 Latch con porte NOR

In questa prova simuleremo il latch SR studiato in Sezione 5.2.1. Si tratta di utilizzare2 porte NOR e collegarle in modo che l’uscita di una porta sia un dei 2 ingressi dell’al-tra. Come al solito, per osservare il diagramma temporale segnali di uscita dobbiamoutilizzare 2 led. Per comodita’ di interpretazione dei dati, conviene cambiare i nomidei due pulsanti in S ed R e quelli delle uscite in Q e Q′. Dopo aver collegato tutti glielementi il circuito diventa quello di Figura 9.18. La parte destra della stessa figurariporta un diagramma temporale.

9.4.2 Registro

In questo laboratorio verra’ assemblato un registro a 4 bit a caricamento parallelo (Se-zione 5.3). Definiamo per prima cosa una cella elementare del registro e colleghiamopoi 4 celle elementari.

9.4. RETI SEQUENZIALI 213

Figura 9.16: Schema della ALU ad 1 bit(file: ALU1.sch).

Figura 9.17: Schema della ALU ad 4 bit e relativa simulazione(file: ALU4INOUT.sch).

La Figura 9.19 mostra come realizzare un registro ad 1 bit. Il cuore del registroe un Flip/Flop Edge negative triggered di tipo D, disponibile fra gli elementi di basedel simulatore. L’ingresso RST del flip-flop serve per azzerare (Reset) il contenuto.

Le operazioni di scrittura e di lettura sono controllate da due segnali di controllo,i segnali Write e Read, come spiegato nella Sezione 5.3. Si noti infine la presenzadella linea Reset, mediante la quale e’ possibile azzerare il contenuto del registro. Lalinea agisce sull’ingresso RST del flip-flip.

A partire dal circuito di Figura 9.19 viene definito un nuovo simbolo, Reg1bit.sym.Il registro a 4 bit si costruisce usando il simbolo appena definito, come indicato inFigura 9.20. Tale circuito definisce un nuovo simbolo, Reg4.sym.

9.4.3 Contatore UP-DOWN

Usando il simulatore Dsch e’ possibile simulare la rete sequenziale descritta nell’esem-pio 5.5. Lo schema e’ riportato in Figura 9.21.


Figura 9.18: Simulazione di un latch SR e relativo diagramma temporale.

Figura 9.19: Schema di un registro da 1 bit.

Nello schema sono stati inseriti due led, SF0 ed SF1 per osservare i cambiamentidello stato futuro prima degli istanti di campionamento. Le uscite sono visualizzatesia mediante altri due led, out0 ed out1 sia, per una migliore interpretazione, medianteun display 7 segmenti. La figura 9.22 mostra un tipico diagramma temporale ottenutodalla simulazione del circuito.

E’ interessante notare la presenza di un segnale impulsivo spurio su SF1 (dettoglitch), che si manifesta quando lo stato dell’automa passa da 01 a 10. In questocaso due dei tre ingressi alla prima porta OR variano contemporaneamente, fornen-do tuttavia due configurazioni per le quali l’uscita della porta vale sempre 1. Talecambiamento di valori non e’ pero’ nella realta’ istantaneo. L’impulso si verifica sela transizione effettiva dei valori e’ 01-00-10. Fenomeni di questo tipo possono ve-rificarsi, in generale, a seguito del cambiamento del segnale in ingresso ad una retecombinatoria. Essi possono essere interpretati come transitori del livello logico delsegnale di uscita.

9.5 Microarchitettura

9.5.1 Trasferimento fra due registri

Questa simulazione prende in considerazione l’operazione di trasferimento dei dati(copia) da un registro ad un altro. Il circuito sfrutta 2 registri a 4 bit, creati in

9.5. MICROARCHITETTURA 215

Figura 9.20: Realizzazione di un registro da 4 bit a partire da registri elementari daun bit

precedenza, ed un flip-flop D per la sincronizzazione dei segnali (Figura 9.23).

Vediamo come avviene il trasferimento. Per prima cosa bisogna caricare un datonel registro sorgente (quello a sinistra nella figura). Questo dato viene prodotto dallatastiera (keyboard).

L’ operazione di caricamento richiede di generare a mano i segnali di controllo,LOAD e clockA. Il primo segnale abilita la scrittura del registro, mentre il secondoe’ il segnale di temporizzazione che stabilisce quando il registro deve essere effettiva-mente scritto. La scrittura avviene sul fronte di discesa di ClockA (si ricordi che iflip-flop D nel registro sono negative edge triggered, Sezione 9.4.2).

Il trasferimento fra i registri avviene premendo il tasto COPY e viene sincronizzatoda un generatore di clock. La pressione del tasto abilita il passaggio del clock. Sulfronte di discesa del clock, l’ingresso al flip-flop di sincronizzazione viene campionatoe trasferito in uscita, producendo cosi il segnale di controllo TRANSFER che abilitala lettura del registro sorgente e la scrittura del registro di destinazione.

La Figura 9.24 mostra un diagramma temporale. Questo diagramma si puo’ otte-nere procedendo secondo i seguenti passi. Si prema il tasto F della tastiera; succes-sivamente si premano i pulsanti LOAD (evento numero 1 nel grafico) per generareil segnale di abilitazione alla scrittura (ingresso W del registro sorgente - quello asinistra) e, per un breve periodo, il tasto ClockA (evento 2), in modo che il registropossa avvertire la transizione alto-basso che ne determina la scrittura.

A questo punto si prema il tasto COPY (evento 3). La pressione del tasto provo-chera’ la generazione del segnale di trasferimento (evento 4). Il trasferimento vero eproprio avviene in un ciclo di clock.


Figura 9.21: Realizzazione del contatore in Dsch (file: CounterLAB.sch).

reset cambio direzione

glitch

Figura 9.22: Diagramma temporale del contatore.

9.6 Introduzione al Simulatore CPU-SIM

Abbiamo visto finora alcuni esempi di funzionamento di semplici circuiti digitali chesono presenti all’interno di un calcolatore. Man mano che la complessita’ di un sistemadigitale aumenta diventa sempre piu’ difficile riuscire a mantenere una visione astrattadel sistema mantenendo la descrizione in termini di porte logiche. Pertanto, per poterdescrivere e simulare una microarchitettura, e’ necessario alzare il livello di astrazionedella descrizione, in modo da nascondere dettagli non indispensabili.

Una descrizione sufficientemente astratta, ma tuttavia ancora in grado di speci-ficare i dettagli di una microarchitettura si fonda sull’utilizzo del linguaggio RTL(Register Transfer Language). Si tratta di un linguaggio che consente di descriveretutte le attivita’ interne di una CPU mediante operazioni di trasferimento fra registri.

Il simulatore di pubblico dominio, CPU-SIM, consente di progettare l’architetturainterna di una CPU a livello di linguaggio RTL; esso consente di definire i registri, la

9.6. INTRODUZIONE AL SIMULATORE CPU-SIM 217

Figura 9.23: Circuito per il trasferimento fra due registri (fileExampleSimpleTranfer.sch)

memoria principale, le microistruzioni, nonche’ il set istruzioni (linguaggio macchinae assembly) di una ipotetica CPU. Ogni sistema di calcolo definito in CPU-Sim sichiama macchina (machine).

Moduli hardware Per definire una nuova macchina e’ anzitutto necessario definireil hardware che la compongono; tali moduli possono essere di 4 tipi: registri, array diregistri, bit di condizione, memoria.

A machine instruction is implemented by a sequence of microinstructions called itsexecute sequence. The user specifies the execute sequence of all machine instructionsand so the user has complete control over the semantics of every instruction. WhenCPU Sim executes a program, it repeatedly executes machine cycles that consist of afetch sequence (a sequence of microinstructions specified by the user) followed by theexecute sequence of the machine instruction that was fetched.


SCRIVE REGISTROSORGENTE SCRITTURA

REGISTRODESTINAZIONE

1

2

3

4INIZIO LETTURA

Figura 9.24: Diagramma temporale del trasferimento.

Indice - Università di Romaberaldi/LIBRO33.pdf · mediante ruote dentate, a Leibniz con il...

Documents

Transcript of Indice - Università di Romaberaldi/LIBRO33.pdf · mediante ruote dentate, a Leibniz con il...