Cursus Digitale Elektronica en Processoren [Work in Progress]

Cursus:

Digitale Elektronica & Processoren

H01L1A

versie 2.7

Willem M. A. Van Onsem, BSc.KOMMUSOFT

Katholieke Universiteit LeuvenAcademiejaar 2010-2011

Inhoudsopgave

I Digitaal Ontwerp en Fysische Limieten 1

1 De Basis van een Digitaal Ontwerp 31.1 Logische schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.1.1 Logische schakelingen in huis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.1.2 Waarheidstabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.1.3 Logische poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1.4 Logische schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.2 Booleaanse algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.2.1 Theorema’s en eigenschappen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.3 Synthese met logische poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.3.1 SOP & POS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.3.2 Canonieke versus standaard realisatie . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.3.3 Realisaties met NAND en NOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.4 Digitaal ontwerp in grote lijnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.4.1 Specificatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.4.2 Synthese . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.4.3 Bibliotheek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.4.4 Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.4.5 Documentatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.4.6 Ontwerpen met CAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.5 Taalgebaseerd hardware ontwerp: VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.5.1 Alternatieven en uitbreidingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.5.2 Voordelen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181.5.3 Nadelen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181.5.4 Beperkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191.5.5 Basisconcepten (entiteiten en architectuur) . . . . . . . . . . . . . . . . . . . . . . . . 191.5.6 Gelijkenissen en verschillen met klassieke programmeertalen . . . . . . . . . . . . . . . 22

2 Technologische Randvoorwaarden 232.1 Logische waarden voorstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.2 Implementatie van poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.2.1 Schakelaars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.2.2 Basispoorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.2.3 Complexe poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.3 Negatieve logica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322.4 Technologieen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.4.1 Specifieke chips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.4.2 Programmeerbare chips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

2.5 Praktische aspecten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.5.1 Spanningsniveaus en ruismarge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372.5.2 Dynamisch gedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

iii

iv INHOUDSOPGAVE

2.5.3 Vermogenverbruik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412.5.4 “0” en “1” doorgeven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422.5.5 Fan-in en fan-out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432.5.6 Tri-state buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

II Combinatorische en Sequentiele Schakelingen 45

3 Combinatorische Schakelingen (Schakelingen zonder geheugen) 473.1 Minimaliseren van logische functies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.1.1 Waarom minimaliseren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493.1.2 Hoe minimaliseren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.1.3 Karnaugh-kaarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.1.4 Quine-McCluskey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.1.5 Realisatie in meer dan 2 lagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573.1.6 Welke methode kiezen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.2 Rekenkundige basisschakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583.2.1 Getallen voorstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593.2.2 Radix-conversie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603.2.3 Optellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623.2.4 Negatieve getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 683.2.5 Optellen en aftrekken van negatieve getallen . . . . . . . . . . . . . . . . . . . . . . . . 693.2.6 Arithmetic-Logic Unit (ALU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723.2.7 Vermenigvuldigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 733.2.8 Andere courante bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 763.2.9 Vaste komma getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.2.10 Vlottende komma getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 773.2.11 Andere voorstellingen van gegevens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

3.3 Andere basisschakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813.3.1 Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.3.2 Decoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.3.3 Demultiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.3.4 Encoder en prioriteitsencoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.5 Vergelijker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863.3.6 Schuifoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

4 Sequentiele Schakelingen (Schakelingen met geheugen) 934.1 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4.1.1 Classificatie van sequentiele schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . 954.1.2 Terminologie van het kloksignaal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

4.2 Bouwblokken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 954.2.1 De flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 964.2.2 Registers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1034.2.3 Tellers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

4.3 Synchrone schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084.3.1 Leidende voorbeelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1084.3.2 Stap 1: opstellen van het toestandsdiagram . . . . . . . . . . . . . . . . . . . . . . . . 1084.3.3 Stap 2: Minimaliseren van de toestanden . . . . . . . . . . . . . . . . . . . . . . . . . 1104.3.4 Stap 3: Implementeren van de toestanden in het geheugen . . . . . . . . . . . . . . . . 1134.3.5 Stap 4: Implementeren van de combinatorische logica . . . . . . . . . . . . . . . . . . 1164.3.6 Tijdsgedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

4.4 Asynchrone schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1234.4.1 Leidend voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244.4.2 Stap 1: Opstellen van een toestandstabel . . . . . . . . . . . . . . . . . . . . . . . . . 124

INHOUDSOPGAVE v

4.4.3 Stap 2: Minimaliseren van de toestanden . . . . . . . . . . . . . . . . . . . . . . . . . 125

4.4.4 Stap 3: Codering van de toestanden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

4.4.5 Stap 4: Realisatie met digitale logica . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

4.4.6 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

III Processoren 145

5 Niet-Programmeerbare Processoren 147

5.1 De Niet-Programmeerbare Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

5.1.1 Algemene Structuur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

5.1.2 Het Datapad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

5.2 Formeel Beschrijven van een Algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

5.2.1 Leidend Voorbeeld: Deler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

5.2.2 Toestandsbeschrijving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

5.2.3 Toestand-Actie Tabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

5.2.4 ASM-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

5.3 Geheugencomponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

5.3.1 Register File Cell (RFC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

5.3.2 Registerbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

5.3.3 Random Access Memory (RAM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

5.3.4 Geheugens met Impliciete Adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

5.4 Synthese van een Niet-Programmeerbare Processor . . . . . . . . . . . . . . . . . . . . . . . . 167

5.4.1 Basisprincipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

5.4.2 Ontwerp Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

5.4.3 Minimaliseren Datapad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

5.4.4 Andere optimalisaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

5.4.5 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5 Tijdsgedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5.1 Kritisch pad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5.2 Verschoven kloksignalen (“clock skew”) . . . . . . . . . . . . . . . . . . . . . . . . . . 213

5.5.3 Synchroniseren van asynchrone ingangen . . . . . . . . . . . . . . . . . . . . . . . . . . 214

6 Programmeerbare Processoren 217

6.1 De Programmeerbare Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

6.2 Instructies en Velden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.1 Programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.2 Instructie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.3 Instructieformaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

6.2.4 Generische Instructiecyclus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

6.2.5 Uitvoeringssnelheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

6.2.6 Adresvelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

6.2.7 Adresseermodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

6.3 Processorontwerp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

6.3.1 RISC en CISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

6.3.2 Ontwerpcyclus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

6.3.3 Complex Instruction Set Computer (CISC) . . . . . . . . . . . . . . . . . . . . . . . . 229

6.3.4 Reduced Instruction Set Computer (RISC) . . . . . . . . . . . . . . . . . . . . . . . . 246

vi INHOUDSOPGAVE

IV Very High Speed Integrated Circuit Hardware Description Language 261

7 VHDL 2637.1 Elementen van de VHDL-taal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

7.1.1 Lexicale elementen (woordenschat) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2647.1.2 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2647.1.3 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2657.1.4 scheidingstekens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2657.1.5 Commentaar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.2 Typesysteem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2667.2.1 Voorgedefinieerde types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2667.2.2 Zelf types definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.3 Objecten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2707.3.1 Constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2717.3.2 Variabele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2717.3.3 Signaal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

7.4 Bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2757.4.1 Logische bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2757.4.2 Rekenkundige bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2767.4.3 Schuifoperaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2767.4.4 Vergelijkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2767.4.5 “Array aggregaat” bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

7.5 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2777.6 Combinatorische schakelingen in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

7.6.1 Hardwarebeschrijving met VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2787.7 Sequentiele schakelingen in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2787.8 Processoren in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

7.8.1 Leidend voorbeeld: sha1 checksum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2787.9 VHDL grammatica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2807.10 Programmeerjargon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

V Digitale Elektronica in de Praktijk 283

8 Circuits Schakelen 2858.1 Anatomie van een Geıntegreerd circuit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

8.1.1 DIP packing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2858.1.2 Populaire geıntegreerde circuits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

8.2 Analoge componenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2868.2.1 Weerstanden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2878.2.2 Condensatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2888.2.3 Spoelen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2898.2.4 Transistoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2898.2.5 Diodes en Operationele versterkers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

8.3 Bouw van een elektronische schakeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2898.3.1 Matrixbord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2908.3.2 Europrintplaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2918.3.3 Printed Circuit Board (PCB) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2918.3.4 Plaatsen van componenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2938.3.5 Tips bij het solderen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

8.4 Implementatie van een kloksignaal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2938.4.1 555-timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2938.4.2 Astabiele multivibrator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2958.4.3 Kristal-oscillator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

INHOUDSOPGAVE vii

8.5 Printed Circuit Board (PCB) Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2968.6 Oproep aan de lezers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

9 Experimenten 2999.1 Oneindig vermenigvuldigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

9.1.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3009.1.2 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3009.1.3 Realisatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

9.2 Fietslicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3049.2.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3049.2.2 Implementatie-specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3059.2.3 Realisatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

9.3 Tic tac toe-machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3079.3.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3079.3.2 Implementatie-specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

VI Appendices 311

A Conventies en Schemas 313A.1 Waarheidstabellen van basisschakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

A.1.1 Eenvoudige poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314A.1.2 Complexe poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314

A.2 Lijst van component interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314A.3 Conventies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315A.4 Poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

A.4.1 Basispoorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315A.4.2 Complexe Poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

A.5 Componenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315A.5.1 Rekenkundige schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315A.5.2 Geheugen schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315A.5.3 Andere schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

A.6 Kostprijs van de Componenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

B Softwarepakketten 319B.1 Geschreven software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

B.1.1 De software installeren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320B.1.2 Invoer en Uitvoer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320B.1.3 Uitvoer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322B.1.4 Ondersteunde functies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322B.1.5 Functiecompositie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

B.2 Andere software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

C Oplossingen van de Oefeningen 325C.1 Hoofdstuk 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325C.2 Hoofdstuk 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325C.3 Hoofdstuk 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

C.3.1 Karnaugh-kaarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325

Woordenlijst 337

viii INHOUDSOPGAVE

Notities vooraf

Deze cursus omvat de volledige inhoud van het onderwerp “Digitale Elektronica & Processoren” gegeventijdens het academiejaar 2010-2011 door prof. Van Eycken. De cursus is dan ook hoofdzakelijk gebaseerd opde presentaties voor dit opleidingsonderdeel. Andere bronnen worden vermeld in de referentielijst op pagina336. Aanbevolen literatuur is [?], [?], [?] en [?].

De cursus wordt uitgegeven onder de CopyLeft licentie, dit betekent dat iedereen de cursus vrij kan aan-passen en herverdelen.

De auteur garandeert de juistheid van deze cursus niet. Hoewel deze cursus met de nodige zorg is sa-mengesteld, is het niet ondenkbaar dat er fouten in staan. Errata/opmerkingen/suggesties kunnen altijddoorgestuurd worden naar [email protected], deze worden dan in de volgende versie verbeterd.

Over de auteur valt eigenlijk niet veel te zeggen, behalve dat hij geen exemplaren signeert.

Speciale dank gaat naar (in alfabetische volgorde) “Amy Winehouse”, “Harold Budd”, “Hooverphonic”,“Moby”, “Paul Simon”, “Piknik”, “Russkij Razmer” en “The Beatles” voor de muziek tijdens de nachtenwaarin deze cursus tot stand kwam.

Betreft het examen

Het examen bestond tijdens het academiejaar 2010-2011 traditioneel uit drie delen:

1. Theorie: bestaat uit twee vragen, dit zijn meestal termen. Deze termen kunnen achteraan in de indexop pagina 351 worden teruggevonden. De meeste ook in de woordenlijst op pagina 336.

2. Synthese van een datapad en controller: De student krijgt een VHDL-code, en wordt gevraagd naareen equivalent ASM-schema. Vervolgens dient hierbij het datapad en de controller gesynthetiseerd teworden. Soms volstaat het echter om bij de controller een toestandsdiagram weer te geven.

3. Synthese van een toestandsdiagram: Er wordt een toestandsdiagram gegeven (meestal in tabelvorm). Destudent dient dit diagram te vertalen in hardware. Meestal worden er extra beperkingen opgelegd, zoalshet gebruik van een bepaald type flip-flop, en/of poorten. Ook dient men vaak de Karnaugh-kaartenweer te geven.

Het examen is volledig gesloten boek. De eerste twee vragen worden mondeling besproken, wat op papier staatvormt echter de basis. De laatste vraag is volledig schriftelijk. Enkel het examenmoment geldt als evaluatie.De student mag een referentieblad meebrengen over VHDL. Dit is te koop bij de VTK CuDi.

Layout en Stijl

Alle pagina’s zijn afdrukbaar met een zwart-wit printer. Dit drukt eventuele kosten bij een afdruk van dezecursus. Bovendien verhoogt het de leesbaarheid bij kleurenblinden.

ix

x INHOUDSOPGAVE

Deze cursus is gecompileerd met LATEXen wordt geıllustreerd met talloze afbeeldingen. Deze afbeeldingenzijn allemaal tot stand gekomen met het grafisch pakket TikZ1 samen met zelfgeschreven bibliotheken. Alleafbeeldingen zijn bijgevolg vectorieel. En kunnen dus eindeloos uitvergroot worden met een geschikte .pdfviewer.

Terminologie wordt in het vetjes en zonder schreven2 gezet. Deze terminologie wordt ook herhaald op heteinde van de cursus in de index op pagina 351.

Kudos

Kudos gaan uit naar volgende personen/groepen (in alfabetische volgorde):

Conrad.be Leverancier van elektronische onderdelen om de circuits zelf te testen.

Prof. Christian Maes Voor onvergetelijke lessen Statistische Thermodynamica over het grootcanonischensemble Ξ (T, V, µ) = eβPV .

Ingmar Dasseville Voor enkele Haskell scripts in het kader van geautomatiseerde LATEX-code generatie.

Wina studentenkring Om overduidelijke redenen... In tegenstelling tot VTK...

Het revisoren-team bestaande uit: Ingmar Dasseville, Jonas Vanthornhout, Katie Pauwelyn en StevenRoose.

Personen die errata indienden Alex Witteveen, Christophe Van Ginneken, Davy Vanclee, Dennis De-gryse, Giel Dops, Ingmar Dasseville, Jonas Devlieghere, Jonas Vanthornhout, Katie Pauwelyn, LynnHouthuys, Neline van Ginkel, Philippe De Croock, Pieter Van Riet, Sander Van Loock.

Link naar deze cursus

De meest recente versie van deze cursus is op onderstaande link te vinden: Indien er fouten gerapporteerd

http://www.4shared.com/documents/??

Figuur 1: Link naar de meest recente versie van deze cursus.

worden, of toevoegingen gedaan worden zullen na verloop van tijd de aanpassingen daar te vinden zijn.

Deze cursus is opgedragen aan leden van mijn familie:

• Louis Van Onsem (1931-1993): voor drie jaar peterschap en m’n derde voornaam: Agnes.

• Gabriella Simons (1923-2012): voor haar humor, fijne herinneringen en 17 jaar plaatsvervangendpeterschap.

• Constant Soetewey (1907-1945): voor hoogstaande absurdistische literatuur, die dit jaar opnieuwuitgegeven werd[?] onder het pseudoniem Kurt Kohler.

1TikZ: TikZ ist kein Zeichenprogramm.2De zogenoemde “pootjes” die sommige letters krijgen. (Engels: serifs)

INHOUDSOPGAVE xi

bad poor average good excellent

QualityReference: 1

KommuSoft Quality Standards at

http://www.4shared.com/??

xii INHOUDSOPGAVE

Voorbeschouwing

xiii

xiv INHOUDSOPGAVE

Deel I

Digitaal Ontwerp en FysischeLimieten

1

Hoofdstuk 1

De Basis van een Digitaal Ontwerp

Eva werd niet als een soort accessoire van Adam geschapen,maar Adam was het eerste ontwerp voor Eva.“

”- Jeanne Moreau, Frans actrice (1928-)

Zoals de naam van deze cursus reeds doet vermoeden werken we metdigitale schakelingen, digitale schakelingen onderscheiden zich vande traditionele analoge schakelingen omdat ze slechts een beperktaantal waarden kunnen aannemen. In de praktijk werken we bijnauitsluitend met binaire signalen. Deze waarden hoeven niet nood-zakelijk een verschil in spanning aan te duiden. Sterker nog, het ge-bruik van elektronica is zelfs niet verplicht. Zo zouden we ook eenverschil in stroomsterkte, druk, reflectie,... als parameter kunnennemen. Het komt er enkel op aan om twee waarden te definierendie we symbolisch zullen voorstellen als 0 en 1 en een reeks operatieste kunnen realiseren voor deze natuurfenomenen. Indien we echtermeer dan twee verschillende waarden nodig hebben, kunnen we ditprobleem oplossen door een aantal binaire waarden te groeperen. Indit eerste hoofdstuk zullen we een beperkte set aan basisoperatiesop deze binaire signalen introduceren: de NOT, AND en OR. Weformaliseren deze operaties in de booleaanse algebra. Ook besprekenwe een methode om een booleaanse functie te synthetiseren. Tot slotbespreken we het verloop van een digitaal ontwerp en introducerenwe een taal om hardware mee te beschrijven: VHDL.

1.1 Logische schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.1.1 Logische schakelingen in huis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.1.2 Waarheidstabellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

1.1.3 Logische poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.1.4 Logische schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.2 Booleaanse algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.2.1 Theorema’s en eigenschappen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3

4 HOOFDSTUK 1. DE BASIS VAN EEN DIGITAAL ONTWERP

1.3 Synthese met logische poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.3.1 SOP & POS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.3.2 Canonieke versus standaard realisatie . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.3.3 Realisaties met NAND en NOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

1.4 Digitaal ontwerp in grote lijnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.4.1 Specificatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.4.2 Synthese . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.4.3 Bibliotheek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.4.4 Analyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.4.5 Documentatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.4.6 Ontwerpen met CAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.5 Taalgebaseerd hardware ontwerp: VHDL . . . . . . . . . . . . . . . . . . . . . . 17

1.5.1 Alternatieven en uitbreidingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.5.2 Voordelen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

1.5.3 Nadelen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

1.5.4 Beperkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

1.5.5 Basisconcepten (entiteiten en architectuur) . . . . . . . . . . . . . . . . . . . . . . 19

Entity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Component . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1.5.6 Gelijkenissen en verschillen met klassieke programmeertalen . . . . . . . . . . . . . 22

1.1 Logische schakelingen

Het definieren van binaire waarden op zich heeft niet veel nut: we willen met deze binaire waarden bepaaldeoperaties uitvoeren. Om berekeningen te kunnen uitvoeren maken we gebruik van logische schakelingen.Logische schakelingen zijn een reeks operaties op een of meer binaire parameters die resulteren in een uitgang.De waarde die op de uitgang staat is hierbij afhankelijk van de ingangen. De set van basisoperaties dientklein, simpel en tegelijk universieel te zijn: elke complexe schakeling moet uit een combinatie van dezebasisschakelingen kunnen worden opgebouwd.

Als basisschakelingen definieert men meestal de NOT, AND en OR operaties. Deze operaties zijneenvoudig en gemakkelijk te begrijpen en onthouden. Hoewel booleaanse algebra in heel wat andere cursussenreeds aan bod komt, zullen we er ook in deze cursus enkele secties aan besteden. We zullen de booleaansealgebra behandelen aan de hand van een model met lichtschakelaars.

1.1.1 Logische schakelingen in huis

We beschouwen een schakeling zoals op Figuur 1.1. Zoals we zien zal indien we de schakelaar x indrukken,

xx

Figuur 1.1: Basis van het lamp-model.

1.1. LOGISCHE SCHAKELINGEN 5

het lichtje branden. Indien we vervolgens de schakelaar loslaten zien we dat het lampje opnieuw dooft. Weformaliseren dit door te schrijven:

L = x (1.1)

Waarbij we L beschouwen als het al dan niet branden van het lampje, en x aanduidt of de schakelaar aldan niet ingedrukt is. Indien we nu als ingang beschouwen of de schakelaar al dan niet ingedrukt is, en alsuitgang of het lichtje al dan niet brandt, kunnen we hiermee functies gaan definieren.

Not Indien we de implementatie van de schakelaar aanpassen zijn we in staat om een NOT poort tebouwen. Zoals op Figuur 1.2(a). Deze schakelaar laat stroom door indien deze niet ingedrukt is. Bijgevolgkunnen we stellen dat het al dan niet branden van het lampje equivalent is met niet de schakelaar indrukken.We formaliseren dit als:

L = x′ = ¬x =!x = x = NOT x (1.2)

Zoals we zien zijn er in de loop der tijd nogal wat notaties ingevoerd; wat bovendien eigen is aan de volledigebooleaanse algebra. In deze cursus zullen we enkel het accent (x′) als negatie gebruiken. Literatuur buitendeze cursus kan echter andere standaarden gebruiken. Een NOT poort wordt vaak ook een inverter genoemd.

And Soms willen we dat het lampje pas gaat branden indien twee of meer schakelaars allemaal ingedruktzijn. In dat geval spreken we van een AND. Een AND kunnen we implementeren volgens het lamp-modelzoals in Figuur 1.2(b). We noteren:

L = x · y = x AND y (1.3)

Or Een andere basisbewerking is de OR. Hierbij willen we dat het lampje brandt bij minstens een inge-drukte schakelaar. Of we noteren:

L = x+ y = x OR y (1.4)

Een implementatie in het lamp-model is te vinden op Figuur 1.2(c).

x x

(a) Not

x y x y xy

x y

(b) And

y

x

y

x

y

x

y

x

(c) Or

Figuur 1.2: Implementatie van de basispoorten volgens het lamp-model.


Door deze drie basisbewerkingen met elkaar te combineren kunnen we eindeloos veel nieuwe bewerkingenbouwen. Zoals bijvoorbeeld de exclusieve OR, ook wel de XOR genoemd. De XOR is een bewerking waarbijhet lampje gaat branden indien juist een van de twee schakelaars ingedrukt is. Deze bewerking kunnen werealiseren door NOT, AND en OR bewerkingen te combineren als volgt:

L = x⊕ y = x XOR y = (x · y′) + (x′ · y) (1.5)

Deze schakelingen kunnen we dan vervolgens in ons lamp-model omzetten zoals op Figuur 1.3.

xy

xy

Figuur 1.3: XOR-poort in het lamp-model.

1.1.2 Waarheidstabellen

We kunnen alle schakelingen voorstellen met het lamp-model. Toch is het niet echt praktisch, we gaandus op zoek naar andere manieren om de logische formules te berekenen, en ook eenvoudig voor te stellen.Een makkelijke manier om logische schakelingen te berekenen is met behulp van waarheidstabellen. Eenwaarheidstabel is een tabel waarbij we alle variabelen voorstellen, en vervolgens met eventuele tussenstappende uiteindelijke bewerking berekenen. Hierbij maken we gebruik van waarheidstabellen die we reeds kennen:de waarheidstabellen van de basisfuncties.

Indien we n variabelen beschouwen betekent dit dat onze waarheidstabel 2n rijen telt. Immers kan elkevariabele ofwel 0 ofwel 1 zijn. Bovendien is het aantal functies met n variabelen beperkt tot 22n

. Ditzegt echter niet over het aantal mogelijke implementaties: deze is onbegrensd. In Tabel 1.1 geven we dewaarheidstabellen van de basisoperaties weer.

(a) Not

x x′

0 11 0

(b) And

x y x · y0 0 00 1 01 0 01 1 1

(c) Or

x y x+ y0 0 00 1 11 0 11 1 1

Tabel 1.1: Waarheidstabellen van de basisoperaties.

We kunnen vervolgens aan de hand van deze waarheidstabellen de werking van een XOR-bewerking bestu-deren. We dienen eenvoudigweg basisoperaties toe te passen op deelresultaten om zo uiteindelijk het finalegedrag van de bewerking te kennen zoals in Tabel 1.2. Indien twee implementaties voor iedere rij dezelfdeuitvoer genereren, zijn de implementaties equivalent, en beschrijven ze dezelfde functie. Equivalente imple-mentaties zijn nuttig om een schakeling efficienter te maken. We gaan immers altijd op zoek naar equivalenteimplementaties die minder kosten of sneller werken.

1.1. LOGISCHE SCHAKELINGEN 7

x y x′ y′ x′ · y x · y′ x′ · y + x · y′ x⊕ y0 0 1 1 0 0 0 00 1 1 0 1 0 1 11 0 0 1 0 1 1 11 1 0 0 0 0 0 0

Tabel 1.2: Waarheidstabel voor de implementatie van een XOR.

1.1.3 Logische poorten

Naast het uitrekenen van operaties heeft ons lamp-model nog een nadeel. Het is erg onpraktisch om grote encomplexe schakelingen voor te stellen. Een algemeen geaccepteerde notatie is deze met behulp van logischepoorten. Poorten zijn kleine componenten die enkele ingangen bevatten, en een uitgang. Op figuren 1.4(a)tot en met 1.4(c) geven we de poorten van de basisbewerkingen weer. We kunnen alle mogelijke schakelin-gen bouwen met deze poorten. Toch worden vaak ook alternatieve poorten gedefinieerd om veelgebruiktebewerkingen mee toe te passen.

Bovendien kunnen we de werking van de basis poorten ook veralgemenen naar meer ingangen. Zo definierenwe een n-and als een poort waar enkel een 1 op de uitgang verschijnt indien op alle n ingangen een 1 staat.Figuur 1.4(d) toont een 3-and. Een n-or is een poort waar enkel een 0 op de uitgang verschijnt indien opalle n ingangen een 0 staat. Zo staat op Figuur 1.4(e) een 5-or.

x L

(a) Not

xy L

(b) And

xy L

(c) Or (d) 3-and (e) 5-or

Figuur 1.4: Basispoorten en uitbreidingen.

Complexe poorten Complexe poorten die in de loop der tijd een eigen symbool kregen zijn onder meerde NOR, NAND en XOR, deze staan afgebeeld op Figuur 1.5, samen met een equivalent schema datuitsluitend uit NOT, AND en OR poorten. De waarheidstabellen van deze complexe poorten staan in

xy L

xy L

(a) NAND

xy L

xy L

(b) NOR

xy L

y

x

L

(c) XOR

Figuur 1.5: Complexe poorten.

subsectie Subsectie A.4.2.

Universiele poorten De reden dat NAND en NOR poorten populair zijn komt hoofdzakelijk omdat hetuniversiele poorten zijn. Dat betekent dat iedere basispoort kan geımplementeerd worden met behulp vanNAND of NOR poorten. In Tabel 1.3 staan deze implementaties. Bovendien is het realiseren van NAND enNOR poorten in de meeste technologieen goedkoper dan het bouwen van AND en OR poorten.


NOT AND OR

met NANDx L xy L

x

yL

met NORx L

x

yL

xy L

Tabel 1.3: Implementatie van de basispoorten met behulp van NAND en NOR poorten.

Geınverteerde ingangen Tot slot introduceren we nog een andere conventie die vaak gebruikt wordt:geınverteerde ingangen. NOT poorten worden heel vaak gebruikt, ook bij ingangen van andere poorten.Het symbool van de NOT poort neemt nogal wat plaats in op een schema. Daardoor is het de gewoonteom soms cirkels te tekenen aan de ingangen van een bepaalde poort: geınverteerde ingangen. Deze cirkelsstellen een NOT poort voor. Concrete voorbeelden staan op Figuur 1.6. In het algemeen kunnen we duszeggen dat een cirkel duidt op het inverteren. Inverteren in het schema betekent echter niet noodzakelijkdat we bij de fysische implementatie gebruik moeten maken van een inverter of NOT poort (meestal is hetzelfs omgekeerd): men kan vaak de implementatie van de poort - bijvoorbeeld AND of OR - zo aanpassendat er geen extra transistoren nodig zijn om ingangen te inverteren.

Figuur 1.6: Poorten met geınverteerde ingangen.

1.1.4 Logische schakelingen

De vorige subsectie toonde al dat we met deze poorten netwerken kunnen bouwen. Deze netwerken wordenlogische schakelingen genoemd. Deze schakelingen implementeren dan uiteindelijk de functionaliteitenwaarvoor we een digitaal circuit ontwerpen. We kunnen logische schakelingen beschrijven door middel vaneen schema zoals we dat tot nu toe altijd gedaan hebben. Een andere techniek is echter op basis van eentaal: VHDL1. Deze taal komt onder meer aan bod in sectie Sectie 1.5, en verder in de verdere hoofdstukkenvan deze cursus.

Optimaliseren Een belangrijk probleem met schakelingen is het vinden van een optimale implementatievoor een bepaalde functie. Sommige schakelingen beschrijven dezelfde functie. Sterker nog, voor elke functiezijn er oneindig veel schakelingen die deze functie kunnen implementeren. Bijgevolg zoeken we voor eenprobleem uit de set van equivalente schakelingen naar de schakeling die ons het meeste voordeel oplevert.Hiervoor zijn twee parameters vaak belangrijk: kostprijs en verwerkingskracht. Om deze parameters teoptimaliseren is het belangrijk eerst een (grove schatting) te kunnen maken van deze parameters voor eengeggeven logische schakeling. De kostprijs van een logische schakeling is eenvoudig te berekenen met volgendeformule:

Kostprijs = #poortingangen + #poortuitgangen−#inverters (1.6)

Merk op dat deze formule geen eenheid heeft. Het is dan ook niet de bedoeling de kostprijs in bijvoorbeeldeuro te berekenen: het is eerder bedoeld als een ruwe metriek om verschillende schakelingen met elkaar tekunnen vergelijken.

1VHDL: VHSIC Hardware Design Language; VHSIC: Very High Speed Integrated Circuit.

1.2. BOOLEAANSE ALGEBRA 9

De verwerkingskracht wordt dan weer bepaald door het concept van het langste pad. Ketens vanpoorten waarbij de uitgangen van sommige poorten weer ingangen van andere poorten aansturen zijn immersnefast. We streven dus naar schakelingen waarbij een signaal slechts door een beperkt aantal poorten heenmoet. De lengte van het langste pad is echter niet makkelijk te berekenen. Immers hangt de vertraging vaneen poort af van onder meer het type en het aantal ingangen. Het totaal aantal ingangen waar een signaaldoor moet daarentegen geeft in de meeste gevallen een goede ruwe schatting. We formaliseren tot:

Minimale vertraging ∝ #poortingangen langste keten (1.7)

Tijdsgedrag In de vorige paragraaf hadden we het reeds over performantie. Snelle systemen worden vaakbeperkt door het tijdsgedrag van logische schakelingen. Wanneer we in de wiskunde een functie beschrijvendie afhangt van een reeks variabelen, bestaat het concept tijd niet wanneer we plots een variable zoudenaanpassen. Maar zoals we reeds gesteld hebben, heeft een poort een zekere tijd nodig om de veranderingaan de ingang door te rekenen. Dit lijkt slechts een detail. Een nadelig effect hiervan is echter dat erovergangsverschijnselen kunnen ontstaan. Zo kan het gebeuren dat bij een verandering van een ingang,waarbij de uitgang niet hoort te veranderen, de uitgang toch tijdelijk een andere waarde aanneemt. Zo zienwe bijvoorbeeld op Figuur 1.7 dat een verandering aan een ingang gepropgaeerd wordt langs twee wegen.Het veranderde ingangssignaal propageert zich sneller door de ene dan door de andere weg. Bovendien hangtde vertraging niet enkel af van het type poort: tijdens de fabricage van poorten zullen er kleine verschillenoptreden, deze poorten zullen dan ook een licht verschillend tijdsgedrag ontwikkelen. Tussen twee (dezelfde)poorten zullen dus kleine tijdsverschillen optreden. In het geval een verschil in tijdsgedrag er toe leidt dater tijdelijk een foute waarde aan de uitgang (of ergens in het midden van het circuit optreedt), spreken wevan een glitch. Figuur 1.7 toont een scenario van veranderende signalen in een logische schakeling met eenglitch.

x

y

a

b

f

tf

01

b01

a01

y01

x01

“glitch”

Figuur 1.7: Voorbeeld van het tijdsgedrag van een logische schakeling met een “glitch”.

1.2 Booleaanse algebra

De tak van de wiskunde die zich bezighoudt met logische bewerkingen is de booleaanse algebra. Dezealgebra rekent uitsluitend met de twee logische waarden 0, 1 en drie logische operatoren die ons reedsbekend zijn: NOT (′), AND (·) en OR (+). Deze operaties hebben elk een specifieke prioriteit zodat menmet een minimum aan haakjes toch een complexe expressie kan beschrijven. Zo heeft de NOT prioriteit overde AND die prioriteit heeft over de OR.2

1.2.1 Theorema’s en eigenschappen

De booleaanse algebra maakt gebruik van theorema’s om de operatoren te evalueren. Zo worden de resultatenvan logische operatoren zonder variabelen gedefinieerd zoals we dat ook met een waarheidstabel kunnen doen.Deze definities staan in Tabel 1.4.

2Een ezelsbruggetje om dit te onthouden is het woord NANO: Not, ANd en Or.


0 · 0 = 0 1 + 1 = 11 · 1 = 1 0 + 0 = 00 · 1 = 1 · 0 = 0 1 + 0 = 0 + 1 = 10′ = 1 1′ = 0

Tabel 1.4: Booleaanse algebra zonder variabelen.

In de booleaanse algebra wordt ook met variabelen gerekend. Op die manier kan men vaak expressiesmanipuleren en optimaliseren. Indien we slechts een variabele beschouwen gelden regels weergegeven inTabel 1.5.

x · 0 = 0 x+ 1 = 1x · 1 = x x+ 0 = xx · x = x x+ x = xx · x′ = 0 x+ x′ = 1(x′)′ = x

Tabel 1.5: Booleaanse algebra met een variabele.

Tot slot werden ook regels gedefinieerd voor meerdere variabelen. Deze regels kunnen onder meer hetaantal variabelen reduceren evenals het aantal operatoren, of tot alternatieve implementaties leiden diemogelijk sneller werken. Een opsomming van deze wetten staan in Tabel 1.6.

Commutativiteitx · y = y · x x+ y = y + x

Associativiteitx · (y · z) = (x · y) · z x+ (y + z) = (x+ y) + z

Distributiviteitx · (y + z) = x · y + x · z x+ (y · z) = (x+ y) · (x+ z)

Absorptiex+ x · y = x x · (x+ y) = x

Wet van De Morgan(x · y)′ = x′ + y′ (x+ y)′ = x′ · y′

Tabel 1.6: Booleaanse algebra met meerdere variabelen.

Dualiteit Een opmerkelijke eigenschap bij booleaanse algebra is de dualiteit. Indien we bij een van dewetten uit Tabel 1.4, Tabel 1.5 of Tabel 1.6 de OR operaties door AND operaties vervangen en vice-versa,en de 1 door 0 vervangen en vice-versa, bekomen we eenvoudigweg een andere wet uit deze tabellen (meestaldezelfde rij, maar de andere kolom). Deze eigenschap noemen we de dualiteit van de booleaanse algebra.Bovendien geldt dus ook dat slechts de helft van de gestelde wetten vereist is. Het andere deel kan met dewetten van De Morgan afgeleid worden.

Verschil met de gewone algebra Omdat ook de booleaanse algebra een optelling en vermenigvuldiginglijkt te definieren en er bovendien ook analogieen te trekken zijn, lijkt het soms dat booleaanse algebra nietverschilt van de standaard algebra. Toch zijn er enkele opmerkelijke verschillen. Zo bestaat er geen verschilof deling in de booleaanse algebra. Verder voldoet in de booleaanse algebra volgend stelsel voor iedere y:

y + y′ = 1y · y = y

(1.8)

1.3. SYNTHESE MET LOGISCHE POORTEN 11

Terwijl in de standaard algebra er slechts een y is waarvoor dit geldt: y = 1. Tot slot is bij standaard algebrade optelling ook niet distributief tegenover de vermenigvuldiging, zo is 5 + 2 · 4 6= (5 + 2) · (5 + 4) terwijl inbooleaanse algebra x+ (y · z) = (x+ y) · (x+ z) dit wel geldt.

1.3 Synthese met logische poorten

Nu we weten hoe logische schakelingen werken, en hoe we deze door middel van de booleaanse algebra kunnenuitwerken, wordt het tijd om zelf schakelingen te beginnen bouwen. Dit doen we vertrekkend vanuit eenwaarheidstabel. Soms is het makkelijk om een implementatie af te leiden uit deze waarheidstabellen. Maarindien het aantal variabelen groot wordt of de functie complex is, wordt het vinden van een implementatiemoeilijk. In deze cursus stellen we dan ook enkele algemene technieken voor om uit een waarheidstabelmachinaal een logische functie te genereren. In Sectie 3.1 zullen we bovendien enkele methodes beschrijvenom deze logische implementaties te optimaliseren. Doorheen deze sectie zullen we een logische functiegenereren voor de waarheidstabel in Tabel 1.7. In de waarheidstabel zien we uitsluitend 0 en 1 staan. In

x y z f0 0 0 00 0 1 10 1 0 00 1 1 01 0 0 11 0 1 11 1 0 11 1 1 0

Tabel 1.7: Waarheidstabel voor het synthese-voorbeeld.

Subsubsectie 3.1.3 zullen we echter kennismaken met een derde ”waarde”3: de don’t care.

1.3.1 SOP & POS

Sum-of-Products (SOP) en Product-of-Sums (POS) zijn twee technieken die op een machinale manieruit een waarheidstabel een logische functie genereren. Ze maken respectievelijk gebruik van mintermen enmaxtermen.

Sum-of-Products De Sum-of-Products methode maakt gebruik van mintermen. Een minterm is eenlogische functie die slechts waar is voor een gegeven rij in een waarheidstabel. Dit bekomen we door hetbooleaans product te nemen van alle ingangen. Indien een ingang in die rij 0 is wordt de bijbehorendevariabele in het product geınverteerd. De minterm van rij i noteren we als mi. De Sum-of-Products methodeneemt de booleaanse som van 1-mintermen. Een 1-minterm is een minterm die waar is bij een rij waarbijf ook waar is. Tabel 1.8 toont voor iedere rij de minterm. Wanneer f waar is, wordt ook de 1-mintermingevuld. Vervolgens bepalen we de som van alle 1-mintermen.

Product-of-Sums Analoog maakt de Product-of-Sums gebruik van maxtermen. Zoals de naam reeds doetvermoeden is een maxterm een logische functie die altijd waar is behalve voor een rij in de waarheidstabel.Indien we de maxterm voor een bepaalde term willen genereren dienen we de booleaanse optelling van denegatie van de variabelen te nemen. We noteren een maxterm voor rij i met Mi, niet te verwarren metmi voor de mintermen. De Product-of-Sums methode neemt analoog het booleaanse product van de 0-maxtermen. Een 0-maxterm is analoog een maxterm wanneer f onwaar is. Tabel 1.9 toont voor iedere rijde maxterm. Wanneer f onwaar is, wordt ook de 0-maxterm ingevuld. Vervolgens bepalen we het productvan alle 0-maxtermen.

3De don’t care is geen echte waarde, ze duidt eerder op ongespecificeerd.


x y z minterm f 1-minterm0 0 0 m0 = x′ · y′ · z′ 00 0 1 m1 = x′ · y′ · z 1 m1 = x′ · y′ · z0 1 0 m2 = x′ · y · z′ 00 1 1 m3 = x′ · y · z 01 0 0 m4 = x · y′ · z′ 1 m4 = x · y′ · z′1 0 1 m5 = x · y′ · z 1 m5 = x · y′ · z1 1 0 m6 = x · y · z′ 1 m6 = x · y · z′1 1 1 m7 = x · y · z 0

xyz

f

m1

m4

m5

m6

SOP: f = m1 +m4 +m5 +m6 = x′ · y′ · z + x · y′ · z′ + x · y′ · z + x · y · z′

Tabel 1.8: Sum-of-Products methode toegepast op het voorbeeld.

x y z maxterm f 0-maxterm0 0 0 M0 = x+ y + z 0 M0 = x+ y + z0 0 1 M1 = x+ y + z′ 10 1 0 M2 = x+ y′ + z 0 M2 = x+ y′ + z0 1 1 M3 = x+ y′ + z′ 0 M3 = x+ y′ + z′

1 0 0 M4 = x′ + y + z 11 0 1 M5 = x′ + y + z′ 11 1 0 M6 = x′ + y′ + z 11 1 1 M7 = x′ + y′ + z′ 0 M7 = x′ + y′ + z′

xyz

f

M0

M2

M3

M7

POS: f = M0 ·M2 ·M3 ·M7 = (x+ y + z) · (x+ y′ + z) · (x+ y′ + z′) · (x′ + y′ + z′)

Tabel 1.9: Product-of-Sums methode toegepast op het voorbeeld.

1.3.2 Canonieke versus standaard realisatie

Wanneer we de Sum-of-Products of Product-of-Sums methodes toepassen, zullen alle min- of maxtermen perdefinitie alle variabelen bevatten. Deze implementatie wordt de canonieke vorm genoemd. Dit is bijgevolgeen relatief dure implementatie.

Nochtans bestaat er een eenvoudige methode om een groot deel van de poorten te elimineren of te reducerenin aantal ingangen. Deze methode zet de canonieke vorm om in de standaard vorm. De methode komt erop neer verschillende min- of maxtermen samen te nemen door er de wetten van De Morgan (zie Tabel 1.6)op toe te passen. Op die manier kunnen we dan deelexpressies van de vorm x + x′ uitkomen. Omdatdeze deelexpressies altijd waar zijn onafhankelijk van x kan bijgevolg x geelimineerd worden uit de nieuwemin- of maxterm4. Op Figuur 1.8 herleiden we de canonieke vormen van het voorbeeld naar hun standaardequivalent.

Door alle mogelijkheden uit te putten bij de standaard vorm bekomen we gegarandeerd de meest minimalevorm voor schakelingen met twee lagen. Het is echter wel mogelijk goedkopere schakelingen te ontwerpen dieuit meerdere lagen bestaat. In dat geval dient er echter een trade-off gemaakt te worden tussen kosten ener-zijds en performantie anderzijds. Zo toont Figuur 1.9 een alternatieve implementatie van een standaardvorm.Deze is 8% goedkoper5, maar zal slechts aan 66% van de snelheid werken. In dat geval zal de toepassing

4Strikt genomen is dit dan geen min- of maxterm meer.5De relatieve kost van een circuit kan berekend worden met Vergelijking (1.6).

1.3. SYNTHESE MET LOGISCHE POORTEN 13

Sum-of-Products

x′y′z + xy′z′ + xy′z + xyz′

xyz

f

= (x + x′) y′z + (y + y′)xz′ = y′z + xz′

xyz

f

Product-of-Sums

(x + y + z) (x + y′ + z) (x + y′ + z′) (x′ + y′ + z′)

xyz

f

= (y + y′) (x + z) (x + x′) (y′ + z′) = (x + z) (y′ + z′)

xyz

f

Figuur 1.8: Herleiden naar standaard vorm van voorbeeld.

vaak uitmaken wat het meest opportuun is.

f

x

y

z

f = xy + yz + xz

f

x

z

y

f = x(y + z) + yz

Figuur 1.9: Standaard vorm en alternatief.

1.3.3 Realisaties met NAND en NOR

Zoals reeds kort vermeld in Subsectie 1.1.3 zijn NAND en NOR poorten erg populair bij heel wat imple-mentaties. Dit komt omdat ze alle basispoorten kunnen emuleren zoals blijkt uit Tabel 1.3 op pagina 8.Bovendien is hun kostprijs lager dan een AND of OR poort6. NAND en NOR poorten blijken bovendienook makkelijk implementeerbaar als substituut voor AND en OR poorten in standaard vorm. Figuur 1.10toont hoe we ons voorbeeld in standaardvorm verder kunnen optimaliseren. Eerst inverteren we de min- enmax-termen door van een AND en OR respectievelijk een NAND en NOR te maken. We behouden echter defunctie door inverters aan de ingangen van het tweede niveau toe te voegen. Immers is tweemaal inverterenniets anders dan dezelfde waarde behouden. Door vervolgens de wetten van De Morgan toe te passen in detweede stap, resulteert dit in een circuit die alleen gebruik maakt van NAND en NOR poorten. Bovendiengeldt dat een circuit geımplementeerd met NAND en NOR poorten altijd zowel goedkoper en sneller is danzijn canonisch equivalent. Een laatste voordeel is dat we de schakelimg met een type poort implementeren.Dit kan nuttig zijn omdat we op een chip in massa poorten van eenzelfde type kunnen zetten, en dan laterde bedrading ontwerpen.

6Denk aan de formule van de kostprijs: het aantal inverters wordt afgetrokken van de kostprijs.


xyz

Sum-of-Products Product-of-Sums

De Morgan De Morgan

f

f

f

xyz

f

f

f

Figuur 1.10: Standaardvorm van het voorbeeld met NAND en NOR’s.

Specificatie §specificatie

Bibliotheek §bibliotheek

Synthese §synthese

Analyse §analyseDocumentatie §documentatie

Figuur 1.11: Typisch verloop van een digitaal ontwerp.

1.4 Digitaal ontwerp in grote lijnen

Nu we de concepten van een digitaal ontwerp in grote lijnen uitgetekend hebben, kunnen we het over deorganisatorische kant van de zaak hebben. Immers komt bij een digitaal ontwerp veel meer kijken dan alleenhet bouwen van de juiste schakeling. Een klant zal immers specificaties sturen waaraan de hardware moetvoldoen, bovendien wil de klant naast de hardware vaak ook nog documentatie over hoe men het toesteldient te gebruiken. Bovendien willen we vermijden dat we bij het ontwerpen telkens opnieuw het wiel moetenuitvinden. Er bestaan immers al bibliotheken die allerhande schakelingen voor bijvoorbeeld optellingen,testen op gelijke waarde,... bevatten. Deze zijn meestal met de nodige zorg samengesteld zodat het vindenvan een nog efficientere implementatie moeilijk wordt. We hebben er dus belang bij deze bibliotheken aan tespreken, en in het geval we een betere implementatie vinden, de bibliotheek aan te passen. Figuur 1.11 vathet hele verloop van het bouwen van een digitale schakeling goed samen. In de volgende subsecties zullenwe de verschillende stappen meer in detail bekijken.

1.4.1 Specificatie

Een Specificatie is een beschrijving van de functionaliteiten die van de hardware in kwestie gevraagd worden.In tegenstelling tot specificaties in bijvoorbeeld de informatica, is de interface ook een onderdeel van despecificaties. De interface beschrijft hoe de hardware interageert met zijn omgeving. Deze omgeving is nietnoodzakelijk de gebruiker die bijvoorbeeld toetsen indrukt en het scherm uitleest. Dit kan ook bijvoorbeeldeen PCI7 bus zijn waarmee met bijvoorbeeld een computer gecommuniceerd wordt.

7PCI: Peripheral Component Interconnect.

1.4. DIGITAAL ONTWERP IN GROTE LIJNEN 15

Dikwijls zijn initieel de specificaties onvolledig. De gaten in de specificaties worden dan ook opgevuldwanneer er zich problemen stellen bij bijvoorbeeld de synthese. Specificaties zijn bijgevolg een iteratiefproces. Dikwijls bevatten de specificaties ook reeds implementatiesbeslissingen die onnodige beperkingenopleggen aan het ontwerp. De beschrijving wordt ofwel in natuurlijke taal, wat soms dubbelzinnig is, of metbehulp van een blokschema beschreven.

1.4.2 Synthese

De Synthese is niets anders dan de vertaling van de specificaties van een hoog en abstract naar een lagerniveau. Hierbij dienen uiteraard concrete beslissingen genomen te worden over de implementatie. Zo kunnende specificaties bijvoorbeeld vermelden dat x en y bij elkaar opgeteld moeten worden. De synthese moet daneen concrete implementatie voorstellen. Bijvoorbeeld een 16-bit ripple-carry adder met twee registers.

Synthese gebeurt meestal op verschillende niveaus. Zo worden op het laagste niveau componenten ge-bouwd: dit zijn bijvoorbeeld de poorten maar ook flipflops of multiplexers8. Deze worden op een niveauhoger gebruikt om Register-Transfer-Level (RTL) Componenten te bouwen. Deze RTL componenten zijnbijvoorbeeld optellers, schuifregisters en tellers. Schakelingen met deze componenten zijn dan ApplicationSpecific IC (ASIC) componentenEen laag van componenten voor synthese. Hieronder vallen de algemenebouwblokken van een systeem zoals processoren en geheugens.. Deze componenten vormen dan uiteindelijkde bouwblokken voor het systeem. Bij de systeemsynthese worden dan processoren, geheugens en de ASICcomponenten gecombineerd. Figuur 1.12 toont de pyramide van synthese. Elk niveau combineert hierbij decomponenten geıntroduceerd op een niveau lager.

Ontwerp van componenten

Ontwerp op componentniveau(met basiscomponenten: poorten, flipflops)

Architectuursynthese (op RTL-niveau)(met RTL-componenten: optellers, tellers, schuifregisters)

Systeemsynthese(bouwblokken: processoren, geheugen, ASIC)

Figuur 1.12: De verschillende lagen bij de synthese.

1.4.3 Bibliotheek

We dienen niet het volledige stuk hardware vanaf transistor of poortniveau te ontwerpen. Heel wat werk isdan ook al in het verleden door andere ontwerpers gedaan. Het hergebruiken van deze ontwerpen heeft danook heel wat voordelen:

• De ontwerpen zijn meestal al door verschillende personen geoptimaliseerd. Het vinden van een nogoptimalere implementatie is daardoor quasi onbestaand.

8Zie respectievelijk Subsectie 4.2.1 en Subsectie 3.3.1.


• Men streeft naar telkens hogere integratieniveaus waarbij soms volledige systemen op chip te verkrijgenzijn. Bovendien worden deze systemen telkens geavanceerder. Dit komt door de Wet van Moore.Deze stelt dat elke 24 maanden het aantal transistoren op een chip verdubbelt.

• Vaak kan men componenten kopen die een bepaalde functie vervullen. Dit bespaart veel ontwerpwerk.Bovendien zijn deze componenten vaak veel goedkoper dan ze zelf te ontwerpen en te produceren.Bijvoorbeeld een 16 kB geheugen.

Er bestaan bibliotheken op elk syntheseniveau. Dus bijgevolg kan men tot op het niveau dat men zelf kiestputten uit de bibliotheken.

1.4.4 Analyse

Na elke synthesestap is het belangrijk om te testen of aan de vereiste specificaties voldaan is. Dit wordtgedaan in de Analyse. Niet alleen wordt hier getest of de implementatie de functionaliteit levert die gevraagdis, ook allerhande andere parameters worden in rekening gebracht:

• Kostprijs: vaak wordt hier als metriek het aantal pinnen en de oppervlakte van de printplaat (PCB9)gebruikt.

• Vermogengebruik : het vermogenverbruik wordt meestal berekend met de formule C · f · V 2 met alsparameters:

– C: De oppervlakte van de chip. De oppervlakte is in de tijd toegenomen. In 1983 was eengemiddelde chip immers 0.25 cm2, in 2000 was dat ongeveer 4 cm2.

– f : De klokfrequentie. De klokfrequentie is in de loop der tijd exponentieel gestegen. Met 1 MHzin 1983, en 1 GHz in 2000.

– V : De spanning die aan de chip geleverd wordt. De spanning is gedaald: van 5 V in 1983 tot1.5 V ongeveer 17 jaar later.

• Snelheid : de vertraging of doorvoer (“ throughput”), dit is het aantal resultaten per seconde.

• Testbaarheid : kunnen we alle fouten ontdekken met behulp van testvectoren?

1.4.5 Documentatie

Naast de hardware verlangt de klant meestal ook documentatie. Afhankelijk van het soort klant zal erandere documentatie vereist zijn. Indien we een volledig afgewerkt consumentenproduct maken, dienen weeen handleiding voor de consument en de hersteller samen te stellen. Hierin beschrijven we in natuurlijketaal hoe de component aangestuurd kan worden. Indien we echter een component leveren, bijvoorbeeld eengeheugenmodule zal men een handleiding maken met daarin de specifieke ontwerpdetails. Meestal zal ookintern binnen het bedrijf documentatie een vereiste zijn. Dit om de eventueel verdere ontwikkelingen teondersteunen.

1.4.6 Ontwerpen met CAD

Computer Aided Design (CAD) wordt vaak toegepast om een chip te ontwikkelen. Hierbij wordt metbehulp van een computer een een speciaal softwarepakket meestal het volledige ontwerp begeleid. Eenconcreet voorbeeld hiervan is bijvoorbeeld KiCad voor Linux. Zoals andere CAD tools bevat KiCad eenproject manager die de gebruiker door de verschillende stappen begeleidt, en een set tools die de gebruiker bijiedere stap de nodige ondersteuning bieden. Uiteraard ziet het ontwerp met een CAD-tool er gelijkaardig uitaan het ontwikkelingsproces op Figuur 1.11. De CAD-tools bieden echter meer mogelijkheden om ontwerpenal in een vroeg stadium te testen en te simuleren. Figuur 1.13 toont het ontwikkelingsproces met behulp vaneen CAD-tool.

9PCB: Printed Circuit Board.

1.5. TAALGEBASEERD HARDWARE ONTWERP: VHDL 17

Specificatie

Schema VHDL

Ingave ontwerp

Synthese

Functionele Simulatie

Ontwerp OK?

Ja

Nee

Fysisch ontwerp

Simulatie tijdsgedrag

Tijdsgedrag OK?

Ja

Nee

Chipconfiguratie

Figuur 1.13: Digitaal ontwerpen met CAD.

1.5 Taalgebaseerd hardware ontwerp: VHDL

Zoals reeds vermeld werd op Figuur 1.13, wordt VHDL veel gebruikt om schakelingen in te voeren in eencomputersysteem. VHDL is de afkorting van VHSIC Hardware Description Language. VHSIC staat voorVery High Speed Integrated Circuit.

VHDL is een programmeertaal waarmee men het gedrag van digitale circuits probeert te beschrijven. Detaal biedt mogelijkheden aan om op een eenduidige manier het gedrag van een circuit te specifieren op RTLniveau. Daarnaast is de taal erg nuttig om simulaties te draaien, synthese uit te voeren (VHDL software ismeestal in staat om zelf efficiente implementaties voor te stellen) en documentatie te genereren. VHDL isgestandaardiseerd bij de IEEE10. De eerste versie van VHDL is VHDL-87, gestandaardiseerd onder IEEE1076. In 1993 werd de tweede versie, VHDL-93 uitgebracht in IEEE 1164. Sinds 2002 bestaat er ook eenderde versie die nog niet gestandaardiseerd is. Deze standaarden omvatten echter uitsluitend de syntax: deimplementatie van de VHDL compiler is volledig vrij. Er is dan ook concurrentie tussen VHDL compilers infeatures om de meest efficiente implementatie te kunnen voorstellen.

1.5.1 Alternatieven en uitbreidingen

VHDL-AMS Een uitbreiding op VHDL is VHDL Analog and Mixed Signals (VHDL-AMS). Hierbijworden niet alleen digitale maar ook analoge signalen beschouwd. VHDL-AMS kan dus als een superset vande orginele VHDL beschouwd worden. Bovendien wordt met continue tijd gerekend in plaats van de doorVHDL gebruikte discrete tijdstippen. Dit werd geımplementeerd door een set algebraısche en differentielevergelijkingen. Hoewel deze uitbreiding in 1999 door de IEEE gestandaardiseerd werd, is VHDL-AMS sindszijn oorsprong in 1993 nooit echt doorgebroken.

10IEEE: Institute for Electrical and Electronics Engineers.


Verilog De de facto concurrent van VHDL is Verilog (IEEE 1364). Verilog is erg populair in de VerenigdeStaten maar is nooit echt doorgebroken in Europa. Beide talen stammen ook uit andere taalfamilies met an-dere paradigma’s: terwijl VHDL eerder lijkt op Ada, is Verilog meer verwant met C. Ondanks de concurrentielijkt geen van beide talen het pleit te kunnen beslechten. Of zoals D. Pellerin & D. Taylor het verwoordenin “VHDL Made Easy!”[?] stellen:

Both languages are easy to learn and hard to master. And once you have learned one of theselanguages, you will have no trouble transitioning to the other.

PLD talen Talen zoals Abel en Palasm zijn zogenaamde PLD talen11. Deze talen specifieren schakelingenop het niveau van de poorten en dit slechts voor een speciale technologie. Deze talen hebben bijgevolg ookeen ander objectief. Waar VHDL net bedoeld is om zich met de details bezig te houden, en de gebruikermet de grote lijnen, zijn PDL talen bedoelt om te implementeren op deze lagere niveaus.

1.5.2 Voordelen

VHDL wordt hoofdzakelijk in de industrie gebruikt omwille van zijn overdraagbaarheid. VHDL is immerseen standaard die door allerhande programma’s gehanteerd wordt. Elk van deze programma’s kunnen heeldiverse toepassingen hebben. Op die manier kan een stuk VHDL eerst gesimuleerd worden met het eneprogramma, daarna gesynthetiseerd met een ander, om bijvoorbeeld geanalyseerd te worden met een derdeprogramma. Deze programma’s kunnen bovendien afkomstig zijn van verschillende fabrikanten. Hierdoorkunnen fabrikanten zich ook toespitsen op een kant van het ontwerp zonder dat er compatibiliteitsproblemenontstaan.

VHDL is ook interessant om complexe schakelingen op een hogere abstractieniveau te beschrijven. Zo kanmen een schakeling die vaak terugkomt groeperen in een bepaalde module. Repetitieve structuren dienenslechts eenmaal beschreven te worden, maar kan men eindeloos blijven gebruiken.

VHDL maakt het ook mogelijk om de gebruiker te laten ontwerpen los van de eigenlijke implementatie.Zo dient de gebruiker alleen te specificeren dat twee getallen opgeteld moeten worden. Het is dan aan hetprogramma om de componenten te selecteren die dat op de beste manier doen (qua kosten, snelheid,...).

Tot slot zorgt VHDL er ook voor dat een ontwerp makkelijk te parametriseren valt. Indien de ontwerperniet zeker is van de woordlengte van zijn processor kan hij deze in een parameter onderbrengen. Als laterblijkt dat de woordlengte groter moet zijn, kan met een eenvoudige verandering van de parameterwaarde hetvolledige model aangepast worden, en dient men de componenten die de parameter gebruiken, niet opnieuwte ontwerpen.

1.5.3 Nadelen

Naast de reeks opgesomde voordelen heeft VHDL ook enkele belangrijke nadelen. Zo is het een eenvoudig teleren taal, maar de taal echt beheersen vraagt veel geduld. Dit komt door gedeeltelijk door de niet eenvoudigesyntax.

Een ander probleem is dat heel wat software afwijkt van de gestandaardiseerde versies. Er bestaan dan ookonnoemelijk veel VHDL “dialecten”: varianten op VHDL die ontwikkeld zijn door fabrikanten. De meestevan deze uitbreidingen werken slechts voor bepaalde softwarepakketten.

Een ander nadeel is dat de taal nogal langdradig is. Bij complexe circuits zullen de groeperingen zeker huneffect hebben, maar om kleine schakelingen te realiseren is nogal veel code nodig. Dit is wat vergelijkbaarmet Java.

11PLD: programmable Logic Device, zie Subsubsectie 2.4.2.


Een probleem met code in het algemeen is dat het erg onoverzichtelijk is. Een eenvoudig blokschema is nogaltijd overzichtelijker omdat mensen nu eenmaal grafisch sterker zijn. Pas bij grote complexe schakelingenverliest het visuele zijn kracht en zal een stuk code als doeltreffender worden aanzien.

Het feit dat VHDL redelijk uitgebreid is, brengt bovendien allerhande nadelen met zich mee. Alle extrafeatures voor bijvoorbeeld tijdsgedrag simulaties dienen immers in de taal beschreven te kunnen worden.Bijgevolg worden sommige taalconcepten hierdoor hopeloos moeilijker gemaakt dan strikt nodig.

1.5.4 Beperkingen

Naast de voor- en nadelen heeft VHDL ook enkele beperkingen. Zo is VHDL slechts tot op zeker niveauautomatisch synthetiseerbaar. Hierbij ondersteunt elke fabrikant van VHDL een verschillende subset.

Een tweede beperking is dat slechts de syntax en de semantiek van VHDL gestandaardiseerd is. Niet hoede code geschreven moet worden. Dit houdt in dat eenzelfde gedrag op tientallen verschillende manieren be-schreven kan worden. Dit zorgt er ook voor dat elk programma dat VHDL leest de code op een andere manierkan implementeren. Het gevolg is dat de codestijl, die in grote mate bepaalt hoe de code geımplementeerdzal worden, variabel is. In het ene programma kan een codefragment tot de meest optimale implementatieleiden, terwijl een ander programma met dezelfde code slechts een standaardimplementatie kiest. Men moetdus eerst heel wat ervaring opdoen met een programma alvorens men weet hoe men de code moet schrijvenzodat deze een efficiente implementatie kiest.

1.5.5 Basisconcepten (entiteiten en architectuur)

Na de voor- en nadelen besproken te hebben, is het tijd om een voorbeeld waarmee we de verschillendeconcepten zullen duidelijk maken. We ontwerpen een schakeling zoals op Figuur 1.14. We zullen eenschakeling genaamd “test” ontwerpen. Deze schakeling krijgt drie 8-bit ingangen (In1, In2 en In3). Alsuitgangen zijn er twee bits (Out1 en Out2). Out1 geeft 1 terug indien In1 en In2 aan elkaar gelijk zijn.Analoog geeft Out2 1 terug indien In2 en In3 gelijk zijn. Om deze vergelijker12 te bouwen werken webijgevolg met een hierarchisch schema. Waarbij we Comp op een andere plaats implementeren.

In1A

In2

B

AIn3

B

EQOut1

EQOut2

Comp

Comp

Test

Comp

EQ

B

A

A[0]B[0]

A[1]B[1]

A[2]B[2]

A[3]B[3]

A[4]B[4]

A[5]B[5]

A[6]B[6]

A[7]B[7]

Figuur 1.14: Voorbeeldcircuit voor VHDL code.

12We bespreken een algemenere vergelijker in Subsectie 3.3.5.


We zullen eerst Comp implementeren in VHDL. De code hiervoor staat in VHDL-code 1.1. Als we de codegoed bekijken onderscheiden we twee belangrijke delen entity en architecture.

Entity

Het entity gedeelte beschrijft de zogenaamde “ blackbox” ofwel de interface. Hierdoor is VHDL in staateen blokje te tonen met de juiste in en uitgangen.

Zoals we zien bevat de beschrijving het port commando. Het port commando specificeert dan de in- enuitgangen. Dit doet men door eerst de namen van de in- of uitgangen te vermelden. Daarna plaatst men hettoken in of out om te specificeren of het om een in- of uitgang gaat. Merk dus op dat elke geleider naar decomponent een expliciete richting heeft. Tot slot duidt men het type van de in- of uitgang aan. Logischerwijsbevat dit het token bit. Een bit betekent zoveel als een enkele lijn (ofwel verbinding). Meestal willen weverschillende lijnen samennemen, in dat geval duiden we dit aan met een bit vector, een bitvector is duseen lijst van geleiders naar het blok die ook onder een naam opereren. Het is handig verschillende geleiderssamen te nemen, dit maakt de code overzichtelijker. Indien bijvoorbeeld de lengte van A gewijzigd moetworden kost dit slechts een minimale ingreep.

Architecture

De concrete werking wordt beschreven in het architecture gedeelte. Dit beschrijft het gedrag van decomponent op RTL-niveau. VHDL is in staat met de gegeven beschrijving in de architecture omgevingeen implementatie op poortniveau te bouwen. Verder dient ook opgemerkt te worden dat een entity

verschillende architectures kan hebben.13. Deze architectures moeten met dezelfde interface als deovereenkomstige entity werken.

VHDL-code 1.1 8-bit comparator.

1 −− 8− b i t comparator2 −−3 entity Comp i s4 port ( A,B: in b i t v e c t o r (0 to 7) ;5 EQ: out b i t ) ;6 end entity Comp;78 architecture Behav1 of Comp i s9 begin

10 EQ <= ’1 ’ when (A=B) else ’ 0 ’ ;11 end architecture Behav1 ;

Component

Nu we een comparator component gebouwd hebben, zullen we deze component importeren in ons testcircuit.Hiervoor gebruiken we code beschreven in VHDL-code 1.2. Dit bestand deelt dezelfde structuur als de structuurin VHDL-code 1.1: een entity en architecture. Dit wijst er dus op dat we componenten hierarchisch kunnengebruiken. We bemerken echter een nieuw token: component. component is een virtuele verwijzing naar eenandere entiteit. Wat die entiteit is laten we in de code nog in het midden. Het enige wat we moeten doen is deinterface van deze component specificeren. Later zullen we dan in de configuratie (VHDL-code 1.3) een bindingvoorzien tussen ons virtuele component comparator en onze gedefinieerde entiteit comp. Verder merken weook op dat in het architecture gedeelte eenmaal we de component interface gedefinieerd hebben, we erinstanties van kunnen aanmaken. Zo maken we twee instanties aan: Comp1 en Comp2. Vervolgens dienen wenog de verbindingen tussen de entiteit test en deze instanties te leggen. Dit doen we met het token map.

13Vandaar dat we onze architectuur de naam Behav1 geven.


Hierbij mappen we de variabelen uit entity Test (In1, In2, In3, Out1 en Out2) op de in- en uitgangen vanhet component Comparator (X, Y en Z). Hierbij dient dus opgemerkt te worden dat we het gedrag van Test

specificeren aan de hand van reeds gedefinieerde entiteiten.

Tot slot dient ook opgemerkt te worden dat in tegenstelling tot klassieke programmeertalen alle componen-ten tegelijk werken. Het is dus niet zo dat bij het uitrekenen van Test eerst Comp1 en dan Comp2 uitgerekendzal worden.

VHDL-code 1.2 Voorbeeldcode.

1 −− Component Test met 2 comparatoren2 −−3 entity Test i s4 port ( In1 , In2 , In3 : in b i t v e c t o r (0 to 7) ;5 Out1 , Out2 : out b i t ) ;6 end entity Test ;78 architecture Struct1 of Test i s9 component Comparator i s

10 port ( X,Y: in b i t v e c t o r (0 to 7) ;11 Z : out b i t ) ;12 end component Comparator ;13 begin14 Comp1 : component Comparator port map ( In1 , In2 , Out1 ) ;15 Comp2 : component Comparator port map ( In2 , In3 , Out2 ) ;16 end architecture Struct1 ;

Configuration

We moeten nog de component Comparator met de entiteit Comp binden. Dit doen we in een configura-

tion omgeving. Deze configuratie wordt beschreven in VHDL-code 1.3. Zoals we zien kunnen we opnieuwverschillende configurations aanmaken en deze een aparte naam geven. Op die manier kunnen we dus defeitelijke implementatie snel wijzigen. Verder dienen we ook te vermelden welke entiteit we zullen configureren(Test) en om welke architectuur het gaat (Struct1). Vervolgens kunnen we per instantie aangeven welkeentiteit we gebruiken. Dit doen we door het token use entity. Ook specifieren we de architecture die wezullen gebruiken van deze entity. Vervolgens mappen we opnieuw met behulp van map de in- en uitgangenvan de entiteit op het virtuele component.

VHDL-code 1.3 Configuratie van de voorbeeldcode.

1 −− Conf i gura t i e : d e f i n i e e r koppe l ing component met een2 −− bepaa lde a r ch i t e c t uu r van een e n t i t e i t3 −−4 configuration Build1 of Test i s5 for Struct16 for Comp1 : Comparator use entity Comp( Behav1 )7 port map (A => X, B => Y, EQ => Z) ;8 end for ;9 for Comp2 : Comparator use entity Comp( Behav1 )

10 port map (A => X, B => Y, EQ => Z) ;11 end for ;12 end for ;13 end configuration Build1 ;


1.5.6 Gelijkenissen en verschillen met klassieke programmeertalen

VHDL lijkt in sommige opzichten een beetje op programmeren in klassieke programmeertalen zoals Java enC++. Immers kunnen we de ingangen als parameters bij een methode zien. De methode zelf fungeert ookals een interface die duidelijk maakt welke types er ingevoerd moeten worden, en welke uitvoer verwachtmag worden, zonder de feitelijke implementatie te tonen. We zouden bovendien elk component die we in eencircuit gebruiken kunnen zien als een functie-oproep naar de functie van het bijbehorende component. Dezevergelijking heeft echter enkele anomalieen.

• Gelijktijdigheid (“ Concurrency”): Alle hardwarecomponenten werken in parallel dit in tegenstellingtot klassieke talen waarin alles sequentieel wordt uitgevoerd.

• Tijdsconcept: Alle hardware werkt continu en houdt nooit op met werken. Bovendien zal bij eensimulatie de tijd uiteraard niet de reele tijd zijn.

• Datatypes: VHDL heeft nood aan typische hardware-types zoals bitvectoren, getallen met geparame-triseerde grootte,... Dit terwijl klassieke talen meestal proberen abstractie te maken van dit hardware-niveau.

Hoofdstuk 2

Technologische Randvoorwaarden

De enige limiet aan de realisatie van de toekomst is ons twijfelenvan vandaag.“

”- Franklin D. Roosevelt, Amerikaans staatsman en president (26e) (1882-1945)

Tot nu toe hebben we altijd abstractie gemaakt van de werkelijkheid.We hebben in Hoofdstuk 1 poorten geıntroduceerd, maar hebben al-tijd abstractie gemaakt van de concrete werking van deze poorten.Aan de hand van het lichtmodel konden we een en ander verklaren,maar deze schakelaars moesten manueel geschakeld worden. In dithoofdstuk zullen we een manier zien hoe we poorten kunnen im-plementeren, en een 0 en 1 kunnen voorstellen die gebruik maaktvan elektronica. Dit is uiteraard slechts een manier. Naast hetimplementeren van poorten stuiten we vaak op allerhande fysischeproblemen. Dit hoofdstuk geeft een overzicht van de verschillendeaspecten die we in de gaten moeten houden bij het ontwerpen vaneen elektronische schakeling. Verder biedt het een overzicht van ma-nieren om een digitale schakeling te realiseren. Tot slot bekijken wede ontwikkeling van digitale schakeling met een CAD tool.

2.1 Logische waarden voorstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.2 Implementatie van poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.2.1 Schakelaars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

Werking van NMOS en PMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.2.2 Basispoorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Implementatie in NMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Implementatie in CMOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

2.2.3 Complexe poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

AND-OR-Invert (AOI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

OR-AND-Invert (OAI) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Andere veelgebruikte poorten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.3 Negatieve logica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

23

24 HOOFDSTUK 2. TECHNOLOGISCHE RANDVOORWAARDEN

2.4 Technologieen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

2.4.1 Specifieke chips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Maatwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Standaard cellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Gate-array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.4.2 Programmeerbare chips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Programmable Logic Array (PLA) . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Programmable Logic Device (PLD) . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

Complex Programmable Logic Device (CPLD) . . . . . . . . . . . . . . . . . . . . 35

Field Programmable Gate Array (FPGA) . . . . . . . . . . . . . . . . . . . . . . . 36

2.5 Praktische aspecten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2.5.1 Spanningsniveaus en ruismarge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Ruismarge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Onlogische Spanningen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.5.2 Dynamisch gedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

2.5.3 Vermogenverbruik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

2.5.4 “0” en “1” doorgeven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

2.5.5 Fan-in en fan-out . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2.5.6 Tri-state buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

2.1 Logische waarden voorstellen

Alvorens we enige schakeling kunnen implementeren moeten we een conventie afspreken hoe we een 0 en 1voorstellen. Deze logische waarden moeten we voorstellen door twee fysische waarden. Deze fysische waardennoemen we “ High” en “ Low”. In de elektronica kiezen we meestal als fysische grootheid de spanning. Dereferentie-spanningen noteren we dan respectievelijk als VH en VL.

Omdat het moeilijk is om een constante spanning aan de uitgangen aan te leggen, kiezen we niet voor eenspanning, maar definieren we een bereik rond VH en VL. Immers is het systeem niet volledig deterministisch,en er kunnen bijgevolg kleine variaties in de spanningen optreden. Daarnaast hebben we ook nog allerhandeomgevingsparameters zoals de temperatuur, waardoor deze spanning sowieso enigszins zal afwijken. Tussenhet bereik van VH en VL definieren we ook nog een zone waar het niet duidelijk is of er een 1 of 0 op staat.Dit laat ons toe om fouten te detecteren. Indien de spanning immers dicht bij het midden ligt, is de kansop een foute interpretatie groot. Met een detectiesysteem zouden we dan bijvoorbeeld kunnen vragen om debit opnieuw uit te sturen. We definieren het bereik van VH als [VIH, VDD], dat van VL als [VSS, VIL]. Figuur 2.1toont schematisch het bereik van deze waarden. Overigens hebben VDD en VSS nog een andere betekenisbij een circuit: het zijn de spanningen die op de voeding van het elektronische apparaat geplaatst worden.Hierbij staat de S voor “ Source” en D voor “ Drain”.

VSS

VIL

VIH

VDD

Fysisch Positieve Logica Negatieve Logica

High

Ongedefinieerd

Low

1

-

0

0

-

1

Figuur 2.1: Schematisch bereik van “High” en “Low” spanning.

2.2. IMPLEMENTATIE VAN POORTEN 25

Negatieve logica Het is niet per definitie zo dat VH geassocieerd wordt met 1, en VL met 0. Dit hangtaf van het type logica dat gehanteerd wordt. We onderscheiden twee soorten logica: positieve logica ennegatieve logica. In geval van positieve logica is dit inderdaad het geval. Soms komt het echter voordeligeruit om deze orde om te draaien, in dat geval spreekt men van negatieve logica. Merk op dat bij negatievelogica de poorten fysisch anders geımplementeerd moeten worden. Immers kent de fysische poort alleenmaar spanningen, en geen 0 of 1. De belangrijkste reden om negatieve logica te gebruiken, is dan ook datde implementatie van een logische functie goedkoper kan zijn in bijvoorbeeld negatieve logica. Bovendienkan men in een circuit op verschillende plaatsen een andere logica gebruiken. Een concreet voorbeeld isde reset-module in veel elektronicasystemen die men vaak in negatieve logica realiseert. We behandelennegatieve logica nog verderop in Sectie 2.3.

2.2 Implementatie van poorten

2.2.1 Schakelaars

In Hoofdstuk 1 maakten we gebruik van het lichtmodel om poorten te implementeren. Daarbij werd gebruikgemaakt van schakelaars. Ook in de echte implementatie van poorten maakt men gebruik van schakelaars.Deze schakelaars kunnen door een derde ingang automatisch open en dicht geschakeld worden, deze ingangwordt ook het “ stuursignaal” genoemd.

Net als de schakelaars in het lichtmodel hebben deze schakelaars twee toestanden: open en gesloten.We kunnen dit interpreteren als een elektronische weerstand die respectievelijk een weerstand van ∞ Ω en0 Ω heeft. Figuur 2.2(a) toont hoe dergelijke schakelaars genoteerd worden. Afhankelijk van hun toestandworden ze bovendien anders genoteerd1.

Zoals eerder gezegd dienen deze automatische schakelaars een stuursignaal te hebben. Op Figuur 2.2(b) enswitchNotationControlledPmos staan de schakelaars met stuursignaal. We merken op dat er twee variantenvan schakelaars zijn. De ene variant, NMOS, is gesloten wanneer het stuursignaal een hoog fysische waardeheeft, en open bij een lage waarde. De tweede soort, PMOS, inverteert dit principe en is gesloten bij eenlaag fysische waarde, en open bij een hoge waarde.

Open Gesloten

(a) Schakelaars

L H

(b) NMOS Schakelaars met stuursignaal

L H

(c) PMOS Schakelaars met stuursignaal

Figuur 2.2: Notatie van een schakelaar (met stuursignaal).

Werking van NMOS en PMOS

In de vorige subsectie werden twee types automatische schakelaars geıntroduceerd: NMOS en PMOS. Ditzijn transistoren die in bijna elk elektronisch apparaat gebruikt worden. In deze subsectie zullen we determinologie van een transistor bespreken, en de werking van deze componenten verklaren. Zoals de meestetransistoren hebben een NMOS en PMOS drie aansluitingen: de Source, Gate en Drain, in het Nederlandsworden deze aansluitingen ook respectievelijk Collector, Basis en Emitter genoemd. Een transistor iseigenlijk niets anders dan een schakelaar tussen de source en drain. De weerstand tussen de source en dedrain wordt geregeld volgens de spanning die op de gate staat.

1In algemene schemas maken we abstractie van de toestand en is deze niet zichtbaar.


Figuur 2.3 toont de concrete werking van NMOS en PMOS transistoren. Voor beide typen transistorenbeschouwen we een substraat van siliciumdioxide (SiO2). We kunnen dit substraat zowel positief als negatiefdoperen2. Bij NMOS doperen we het substraat hoofdzakelijk positief (p). Bij de ingangen van de source ende drain doperen we negatief (n). Er kan nauwelijks stroom vloeien tussen het negatief en positief gedopeerdesubstraat. Bijgevolg fungeert de p-laag als een barriere tussen de source en de drain.

Indien we echter een positieve spanning aanbrengen op de gate, zullen de negatieve deeltjes in de p-laagzich aangetrokken voelen tot de gate. Er ontstaat een reorganisatie van de p-laag waardoor er een n-laagjegevormd wordt ter hoogte van de gate. Hierdoor ontstaat er een kanaal tussen de source en de drain, waardoorde schakelaar zich sluit. De spanning die tussen de gate en de source moet staan om dit te bereiken wordtde threshold spanning VT genoemd. Indien de spanning tussen de gate en de source VGS dus kleiner is danVT is de NMOS schakelaar open, anders is de schakelaar gesloten. Een PMOS transistor werkt op analogemanier, maar dan omgekeerd.

n+ n+isolatormetaal

Gate

Source Drain

p

(a) NMOS bij VGS < VT.

n+ n+isolatormetaal

Gate

Source Drain

p

(b) NMOS bij VGS ≥ VT.

p+ p+isolatormetaal

Gate

Drain Source

n

(c) PMOS bij VGD < VT.

p+ p+isolatormetaal

Gate

Drain Source

n

(d) PMOS bij VGD ≥ VT.

Figuur 2.3: Werking van NMOS en PMOS.

2.2.2 Basispoorten

Met de eerder beschreven NMOS en PMOS transistoren kunnen we de basispoorten implementeren. Eerstzullen we de basispoorten met behulp van NMOS implementeren. Het zal blijken dat deze implementatiesenkele nadelen hebben. Hierdoor zullen we opteren voor implementatie met CMOS. CMOS is in feite eencombinatie van NMOS en PMOS. We zullen alle schakelingen implementeren in positieve logica. In Sectie 2.3bespreken we kort poorten in negatieve logica.

Implementatie in NMOS

NOT Figuur 2.4 toont de implementatie van een NOT-poort in NMOS. Als ingang beschouwen we x, alsuitgang f de VDD en VSS zijn lijnen voor de voeding van de poort. Indien we een laag voltage aanbrengen opx is de NMOS transistor open. Hierdoor staat er een hoge spanning op f . Indien we een hoge spanning opx aanbrengen, zal de transistor zich sluiten. Hierdoor vloeit er stroom tussen VDD en VSS. Omdat de stroomdoor f nog andere componenten zal aansturen, zal de stroom bijgevolg verkiezen om door de transistor testromen, en krijgt f dus een laag potentiaal. Het principe van het verlagen van de spanning door stroomdoor te laten wordt Pull-Down Network (PDN) genoemd. In werkelijkheid zal een poort in NMOS niet devolledige hoogspanning of laagspanning op de uitgang aanleggen: wanneer de NMOS transistor gesloten is,zal er nog steeds een kleine weerstand over staan. Deze weerstand noteren we als Ron. Dit betekent dat fniet volledig gelijk zal zijn aan L. We berekenen de spanning op f dan ook met volgende formule:

Vout (x = 1) =Ron

R+Ron

VDD (2.1)

Een tweede groot nadeel is dat we bij x = H statisch vermogen verbruiken:

P (x = 1) =V 2

DD

R+Ron

(2.2)

2Het introduceren van alternatieve atomen.


Dit is op gebied van energie duur, vooral omdat er in een gemiddelde processor makkelijk miljoenentransistoren zitten. Bovendien zal dit hoge temperaturen genereren. Dit is dan ook de hoofdreden waaromer nauwelijks elektronica geımplementeerd wordt met NMOS.

VDD (H)

R

f = H

x = L

VSS (L)

(a) x=L, f=H

VDD (H)

R

f = L

x = H

VSS (L)

(b) x=H, f=L

Figuur 2.4: NOT poort geımplementeerd in NMOS.

“Open-drain poort” Indien we de weerstand als een extern component beschouwen, en meerdere NMOStransistoren in parallel aan de draad hangen, kunnen we het gedrag van een AND poort nabootsen. Figuur 2.5toont een dergelijke realisatie. Vanaf het moment dat een van de transistoren gesloten wordt, lekt de stroomdoor die transistor, en krijgt f dus een laag niveau. Alle ingangen moeten dus een lage spanning hebben, omeen hoge spanning aan de uitgang te verkrijgen. We kunnen dit principe dus zien als een AND waarbij aanalle ingangen een inverter staat. Dit systeem wordt “ Open-Drain Poort” genoemd. En heeft het voordeeldat we een AND kunnen bouwen aan de hand van draden. Deze implementatie is goedkoop indien we eenAND-poort willen maken met een zeer groot aantal ingangen. Standaard wordt dit soort implementatiedan ook gebruikt in de reset-functionaliteit van elektronica. Meestal wordt er immers een reset procedureaangeroepen indien een van de detectoren een fout registreert. In dat geval zal de detector een hoge spanningaan zijn ingang genereren. Dit resulteert een lage uitgang, bij een lage uitgang treed de reset-procedure danin werking.

VDD (H)

R

fx

y

Figuur 2.5: Open-Drain Poort in NMOS.

NAND en NOR De vorige paragraaf gaf reeds een opzet hoe we een NOR en NAND poort kunnenbouwen. We moeten er voor zorgen dat er stroom kan vloeien tussen VDD en VSS indien respectievelijkminstens een of alle transistoren gesloten worden. Figuur 2.6 toont de implementaties voor een NAND enNOR poort volgens dit concept. Een AND en OR poort kunnen we dan vervolgens synthetiseren door eeninverter achter de poort te plaatsen. Deze implementaties maken ook meteen duidelijk waarom een NANDgoedkoper is dan een AND3.

3Dit is geen rigoreus bewijs dat een NAND inderdaad goedkoper is dan een AND, vermits we enkel vanuit een conceptwerken, en er misschien andere manieren bestaan om een AND en NAND te realiseren.


VDD (H)

R

f

x

y

(a) NAND poort.

VDD (H)

R

f

x y

(b) NOR poort.

Figuur 2.6: NAND en NOR poort geımplementeerd met NMOS.

Implementatie in CMOS

Een belangrijk argument tegen het gebruik van NMOS is dat het veel vermogen nutteloos verbruikt: wanneereen transistor gesloten is lekt er onophoudelijk stroom van de bron naar de grond. CMOS biedt hiervoor eenoplossing. CMOS is een techniek waarbij we zowel een NMOS als een PMOS transistor gebruiken. Analoogaan het “Pull-Down Network” fenomeen van de NMOS, spreken we dan over het “ Pull-Up Network (PUN)”fenomeen bij PMOS.

NOT Indien we de uitgang f plaatsen tussen een NMOS en PMOS transistor, en beide transistorenaansturen met dezelfde ingang x zoals op Figuur 2.7, kunnen we een NOT poort implementeren. Op hetmoment dat we een hoge spanning aanleggen op de ingang sluit de NMOS transistor zich, en opent de PMOStransistor zich, hierdoor krijgt de uitgang dezelfde spanning als de ground. Indien we een lage spanning aande ingang aanleggen is de configuratie van de transistoren omgekeerd, en wordt komt aan de uitgang eenspanning VDD te liggen.

VDD (H)

f = Hx = L

VDD (H)

f = Lx = H

Figuur 2.7: NOT poort geımplementeerd met CMOS.

NAND en NOR Ook NAND en NOR poorten hebben hun equivalent in CMOS. Figuur 2.8 toont hiervooreen implementatie. Wat opvalt is dat we redelijk eenvoudig het CMOS equivalent kunnen halen uit eenNMOS implementatie. Immers is het onderste gedeelte van de NMOS-schakelaars volledig equivalent metde NMOS-implementatie. We plaatsen eenvoudigweg een PMOS circuit boven de uitgang. Dit circuit werktmet duale logica: indien de NMOS verbindingen parallel zijn, zullen we de PMOS transistoren in serieplaatsen, indien de NMOS transistoren in serie stonden, zetten we de PMOS transistoren in parallel. Verderkunnen we de weerstand ook weglaten. Deze weerstand stond er immers alleen om verschillende poorten aaneenzelfde voeding te kunnen hangen. Nu er echter geen stroom vloeit in om het even welke configuratie vande transistoren, is de weerstand dus nagenoeg nutteloos geworden, en brengt deze hoge kosten met zich mee.

Uitgangen verbinden Bij NMOS kunnen we uitgangen met elkaar verbinden, zonder dat dit problemenmet zich meebracht, sterker nog, we kunnen sommige poorten implementeren aan de hand van verbindingen.Een groot nadeel van CMOS is dat dit niet langer mogelijk is. Figuur 2.9 toont de reden hiervoor. Op hetmoment dat de ene ingang een hoog potentiaal heeft, en de andere een laag potentiaal ontstaat er immers


VDD (H)

x

y

f

(a) NAND

VDD (H)

y

x

f

(b) NOR

Figuur 2.8: NAND en NOR poorten geımplementeerd met CMOS.

een kortsluiting. De stroom is in staat om vanaf de VDD rechtstreeks de aarding te bereiken. Hoewel detransistoren een minimale weerstand hebben, volstaat deze meestal niet. Het gevolg zijn zeer hoge stromendie het elektronische circuit zouden kunnen beschadigen.

VDD (H) VDD (H)

Figuur 2.9: Kortsluiting bij wired poort implementaties met CMOS.

2.2.3 Complexe poorten

In Hoofdstuk 1 hadden we het reeds over de XOR-poort. Een poort die 1 teruggeeft als de twee ingangenniet gelijk zijn aan elkaar. Deze poort hadden we toen geımplementeerd met een ingewikkeld schema vanbasispoorten. Omdat we echter op transistor niveau werken, kunnen we verschillende complexe poortentoch relatief simpel implementeren. In de volgende subsecties zullen we eerst de AND-OR-Invert (AOI) enOR-AND-Invert (OAI) implementeren. Deze schakelingen worden relatief vaak gebruikt, om bijvoorbeeldXOR en XNOR poorten te implementeren.

AND-OR-Invert (AOI)

Een veelgebruikt component is een AND-OR-Inverter. Dit is een component die we op poort-niveau kunnenbeschrijven als een tweelagige structuur waarbij de ingangen eerst door een reeks AND-poorten gaan. De uit-gangen van de AND-poorten vormen op hun beurt de ingangen van een NOR-poort. Een concreet voorbeeldhiervan staat op Figuur 2.10(a). Indien we echter de schakeling zouden bouwen zoals we dit voorstellen oppoortniveau4, hebben we 18 transistoren nodig. Een efficientere manier is het implementeren van een nieuwcomponent de AOI zoals op Figuur 2.10(b). Hierbij hebben we slechts 10 transistoren nodig. Bovendienhebben we de implementatie gereduceerd tot een laag. Hierdoor wordt de vertraging van de component ookteruggedrongen.

4We substitueren dus iedere poort door zijn equivalent in CMOS.


a

b

xyz

f

(a) AOI op poort-niveau.

a b

VDD (H)

x y z

f

x

y

z

a

b

(b) AOI op CMOS-niveau.

a

b

xyz

f

(c) OAI op poort-niveau.

a b

x y z

f

x

y

z

a

b

VDD (H)

(d) OAI op CMOS-niveau.

Figuur 2.10: AND-OR-Inverter (AOI) en OR-AND-Inverter (OAI) in CMOS.

OR-AND-Invert (OAI)

De tegenhanger van de AND-OR-Inverter is de OR-AND-Inverter. Figuur 2.10(c) toont een voorbeeld vandit type component. Naar analogie met de AOI bestaat deze component op poortniveau opnieuw uit tweelagen, ditmaal gaan de ingangen door een reeks OR poorten waarbij hun uitgangen dan weer de invoer vaneen NAND poort vormen. Opnieuw kunnen we door een implementatie in CMOS het aantal transistorenvan 18 naar 10 reduceren.

Andere veelgebruikte poorten

Naast de NOT, NAND, NOR, AOI en OAI poorten, worden er nog enkele andere poorten frequent gebruikt.De implementatie van deze poorten wordt weergegeven in Figuur 2.11. In de volgende paragrafen wordt hunnut en werking kort toegelicht.

Buffer Een buffer of driver is een speciaal type poort met een ingang waarbij de uitgang dezelfde waardeheeft als de ingang. Men zou dus een buffer kunnen vervangen door een geleider. Een buffer wordt echterfrequent gebruikt indien een bepaalde draad verbonden moet worden met een groot aantal ingangen vanpoorten. Wanneer we dit aan de hand van een draad zouden doen, zou dit betekenen dat spanning op dezedraad verlaagd wordt door lekstromen. Men kan dit oplossen aan de hand van een vertakking van de draadnaar verschillende buffers die op hun beurt weer verschillende poorten aansturen. Een buffer dient dus -om bij complexe circuits - een signaal over een groot aantal componenten te kunnen verspreiden, waar eeneenvoudige vertakking zou falen. Figuur 2.11(a) toont de notatie en de implementatie van een buffer. Weimplementeren een buffer meestal aan de hand van twee opeenvolgende inverters.

AND-poort We hebben een AND-poort reeds voldoende geıntroduceerd om te weten wat deze componentdoet. Als we naar Figuur 2.11(b) kijken, zien we dat we deze poort implementeren door een NOT-poort aan


≡

x

VDD VDD

f

(a) Buffer

≡

x

y

VDD

x y

VDD

f

(b) AND-poort

≡

x y

VDD

x

y

VDD

f

(c) OR-poort

≡

x

VDD

y

VDD VDD

f

(d) XOR-poort

≡

x

VDD

y

VDD VDD

f

(e) XNOR-poort

Figuur 2.11: Implementatie van populaire alternatieve poorten in CMOS.

de uitgang van een NAND-poort te plaatsen. Dit verklaart ook meteen waarom we de voorkeur zullen gevenaan inverterende poorten: een NAND werkt sneller5 en is bovendien twee transistoren goedkoper.

OR-poort Analoog aan een AND-poort implementeren we een OR-poort ook met een inverter na eenNOR-poort. Figuur 2.11(c) toont hierbij de implementatie. De conclusies de we trokken voor AND-poortengelden uiteraard ook voor een OR-poort.

XOR-poort De XOR-poort werd reeds geımplementeerd aan de hand van NOT, OR en AND poorten,en dit aan de hand van een complex netwerk. We kunnen deze schakeling echter ook realiseren met eenAND-OR-Inverter6. Dit houdt in dat we een XOR poort ook relatief goedkoop kunnen implementeren.Figuur 2.11(d) toont dat we deze schakeling kunnen realiseren met een OR-AND-Inverter en twee invertoren.In totaal hebben we dus 12 transistoren nodig. Indien we deze schakeling zouden implementeren zoals opFiguur 1.5(c) op pagina 7 zouden we 22 transistoren nodig hebben.

5Omdat het signaal niet nog eens door de inverter moet propageren.6Een AOI deelt dezelfde conceptuele structure als deze die we voorstelden bij de poorten.


XNOR-poort Een laatste populaire poort is de XNOR-poort. Deze poort is niets anders dan de geınverteerdevan de XOR-poort. Door eenvoudigweg de AND-OR inverter te vervangen door een OR-AND-Inverter kun-nen we deze poort implementeren zoals op Figuur 2.11(e). De XNOR poort is dan ook de enige hierbovenbeschouwde poort die even goedkoop is als zijn inverse.

2.3 Negatieve logica

We hebben reeds kort negatieve logica behandeld in Sectie 2.1. Nu we de poorten op transistor-niveaugeımplementeerd hebben, zijn we beter in staat om te vatten wat negatieve logica precies doet. Indien wede NAND-poort beschouwen zoals op Figuur 2.8(a), kunnen we rekenen met high en low. Tabel 2.0(a)

(a) High en Low

x y fL L HL H HH L HH H L

(b) Positief

x y f0 0 10 1 11 0 11 1 0

(c) Negatief

x y f1 1 01 0 00 1 00 0 1

Tabel 2.1: Verschil tussen positieve en negatieve logica.

toont de functie met high en low signalen. Indien we deze signalen interpreteren met positieve logicazoals in Tabel 2.0(b) bekomen we inderdaad zoals verwacht de NAND-poort. Indien we echter negatievelogica toepassen zoals in Tabel 2.0(c) bekomen we een NOR-poort. Bijgevolg kunnen we dus stellen datpositieve en negatieve logica elkaars duale vorm zijn (zie Subsectie 1.2.1).

2.4 Technologieen

Niet elk toestel wordt volledig ontworpen en specifiek geproduceerd: net zoals bij software maken we vaakgebruik van modules waar we onze specifieke applicatie dan inpluggen. Deze sectie geeft een overzicht vande verschillende technologieen om een schakeling daadwerkelijk te realiseren.

Voor goedkope toestellen in beperkte oplages zal men vaak geen nieuwe specifieke chips ontwikkelen.Meestal maakt men gebruik van reeds bestaande componenten, die men vervolgens op een printplaat combi-neert. Nog een alternatief zijn programmeerbare chips. Hierbij wordt de logica in de chip geprogrammeerd,bijvoorbeeld in een geheugen. Het gedrag van de chip hangt dan ondermeer af van de waardes in dat geheu-gen. Dit laat toe programmeerbare chips in grote oplages te produceren die dan vervolgens voor allerhandeverschillende toepassingen gebruikt worden. Tot slot worden sommige chips ook volledig zelf geassembleerd.We overlopen eerst kort de drie vormen, waarna we ze in detail bespreken in de volgende subsecties.

• Specifieke Chips (ASIC) (Subsectie 2.4.1): Hierbij maken we de chips volledig zelf. Deze techniek isechter duur, omdat er bijvoorbeeld een masker moet aangemaakt worden. Bijgevolg is deze techniekenkel winstgevend bij grote volumes.

• Programmeerbare Chips (Subsectie 2.4.2): Dit zijn chips waarbij de logica geprogrammeerd kan wor-den. Meestal is dit echter volgens het “ Write Once Read Many (WORM)” principe. Deze chipskunnen een redelijke complexiteit aan en bevatten anno 2010 2 miljoen logische cellen. Meestal wordendeze chips dan ook gebruikt voor prototypes en voor apparaten met kleine tot middelgrote oplages7.

• Standaard Chips: Hierbij worden simpele chips gekocht zoals poorten (SSI) en chips die eenvoudigefuncties vervullen (MSI/LSI). Het enige wat men nog moet doen is deze componenten met elkaarverbinden. De zogenaamde “ Glue Logic”. Met deze techniek kunnen we echter enkel circuits bouwen

7minder dan 100 000 stukken per jaar.

2.4. TECHNOLOGIEEN 33

met een beperkte complexiteit. Een typevoorbeeld van zo’n chips is bijvoorbeeld de 744 chip. Dezebevat 6 NOT poorten.

2.4.1 Specifieke chips

Bij specifieke chips ontwerpen we zelf het volledige geıntegreerde circuit. Deze techniek is dan ook zeerarbeidsintensief. Er bestaan drie verschillende technieken om specifieke chips te maken: maatwerk, standaardcellen en gate-arrays. Deze technieken worden in de volgende subsubsecties besproken.

Maatwerk

Bij maatwerk zullen we elke transistor en verbinding zelf ontwerpen. Deze componenten stellen we danvoor als een set rechthoeken, die we op de chipoppervlakte plaatsen. Deze techniek zal in het algemeen tothet meest optimale ontwerp leiden qua snelheid, vermogenverbruik en afmetingen. Toch is deze techniekniet haalbaar voor complexe systemen. Men past maatwerk wel vaak toegepast bij het ontwerpen vancomponenten voor een bibliotheek. In dat geval zal men bijvoorbeeld een opteller zo efficient mogelijkimplementeren, zodat complexere systemen die een opteller nodig hebben, een zeer efficiente implementatiekunnen gebruiken. Een ander nadeel van deze techniek is, dat de bouw van transistoren verder evolueert.Deze transistoren worden telkens kleiner, en om de 18 maanden is een volledige herimplementatie nodig.Deze manier van werken wordt ook wel “ Custom Design” genoemd.

Standaard cellen

Een efficientere manier van werken is met de zogenoemde “ standaard cellen”. Deze techniek is min of meeranaloog met het maatwerk. Alleen gebruiken we hier componenten uit een bibliotheek als cellen, in plaatsvan transistoren. Elk van deze cellen heeft een vaste hoogte, en een variabele breedte. Bovendien wordt erin de hoogte ruimte voorzien voor bedrading. Elke logische cel heeft enkele ingangen aan de bovenkant, enenkele uitgangen aan de onderkant van de cel. Het komt er dus alleen nog op aan de cellen op een interessantemanier te plaatsen, de zogenoemde “ placement”. En het leggen van bedrading, wat “ routing” genoemdwordt. Deze taken dienen met de nodige zorg te gebeuren. Componenten die veel met elkaar interagerenworden beter dicht bij elkaar gezet, om de snelheid op te drijven, en bovendien is het aantal lagen voorbekabeling heel beperkt. Deze techniek laat echter wel toe om snel complexe bouwblokken te ontwerpen, enbovendien laat deze methode toe dat fabrikanten cellen kunnen optimaliseren. Figuur 2.12 toont hoe hetontwerp van deze standaard cellen er ongeveer uitziet.

Figuur 2.12: Ontwerp met standaard cellen.

Gate-array

Een techniek die nog minder ontwerp-kosten met zich meebrengt is de Gate Array. Hierbij beschouwen weeen tweedimensionaal rooster met identieke poorten8, de zogenoemde “ Sea of Gates”. In dit rooster heeftelke poort identieke afmetingen, en wordt er ruimte gelaten voor bedrading. Opnieuw bevinden zich alleingangen bovenaan en de uitgangen onderaan. Enkel de bedrading is vervolgens nog uniek aan het product.

8Meestal worden hiervoor NAND-poorten gebruikt. Bijvoorbeeld een 3-NAND-poort.


Dit heeft niet alleen het voordeel van goedkoop ontwerp, de rooster kunnen in massa geproduceerd worden,om daarna elk tot een specifieke circuit uit te groeien. Enkel de metallisatielaag9 is dus uniek.

2.4.2 Programmeerbare chips

Prototypes waar nog fouten uitgehaald moeten worden, of elektronica in bijvoorbeeld computers waar defirmware kan veranderen, worden meestal geımplementeerd met programmeerbare chips. Maar ook onderde programmeerbare chips bestaan nog verschillende technologieen. Vooral de programmeertechnieken zijnzeer divers. Hieronder worden de meest courante technieken opgesomd. Vervolgens worden deze techniekenverder toegelicht in de subsubsecties.

• Zekeringen: Hierbij bevat de chip een groot aantal zekeringen. We kunnen dan vervolgens een deelvan deze zekeringen doorbranden, om de logica te implementeren. Deze techniek is irreversibel: eendoorgebrande zekeringen kan niet hersteld worden. Weliswaar blijft bijprogrammeren10 wel mogelijk.

• Flash-programmeerbaar: Hierbij kunnen we verbindingen openen en sluiten met transistoren waarbijde gate opgeladen kan worden. Hierdoor wordt herprogrammeren mogelijk, dit is echter traag, enbovendien zal na enige tijd het flash geheugen niet meer herprogrammeerbaar zijn.

• Geheugen-programmeerbaar: Hierbij bevat de chip een geheugen component, meestal in SRAM. Detransistoren die de verbindingen bepalen worden dan gekoppeld aan dit geheugen. Het voordeel hierbijis dat we makkelijk en snel de chip kunnen programmeren, en dit kan zelfs dynamisch11. Het nadeel isdat dit geheugen telkens bij het aanleggen van voedingsspanning weer opnieuw ingeladen moet worden.Het typevoorbeeld van deze techniek is een Field Programmable Gate Array (FPGA).

Programmable Logic Array (PLA)

In Sectie 1.3 zagen we reeds dat we alle logische functies kunnen maken met een Sum-of-Products (SOP).Een Programmable Logic Array (PLA) is gebaseerd op dit idee. Deze chip bevat twee rasters van poorten:een AND-matrix en een OR-matrix. Als ingangen kunnen we vervolgens zowel een variable als zijn inverseaanleggen. Figuur 2.13

toont een schematische voorstelling van zo’n PLA. De punten tussen twee verbindingen stellen een zeke-ring door. Door zekeringen door te branden kunnen we dus het model aanpassen. Punten waar een kruisjebij staat zijn in dit voorbeeld doorgebrand. Bij een doorgebrande zekering in de AND-matrix, komt er een1 op de lijn, bij een doorgebrande zekering op de OR-matrix een 0. Er bestaan ook varianten op een PLA:

• een Programmable Array Logic (PAL) heeft een vaste OR-matrix; en

• een Programmable Read Only Memory (PROM) heeft een vaste AND-matrix. Hierbij fungeert dezematrix als een adresdecoder (zie Subsectie 3.3.2).

Programmable Logic Device (PLD)

Een PLA is niet in staat complexe functies te beschrijven zonder dat de AND- en OR-matrix zeer groot temaken. Omdat immers voor iedere verbinding ook nog lijnen moeten voorzien worden, zou de componental snel te groot worden. Een Programmable Logic Device (PLD) probeert hierop een antwoord te bieden.Hierbij wordt meer lagen logica gehanteerd. Figuur 2.14

toont het idee achter deze techniek. We beschouwen nog steeds een AND-matrix, alleen is een groot deelvan de invoer eigenlijk de uitvoer van geprogrammeerde functies op de chip, er ontstaat dus een feedback-mechanism. Zo zijn x1 en x2 de enig invoerlijnen, de andere lijnen zijn het resultaat van de geprogrammeerdelogica. Op de figuur bemerken we verder nog dat er componenten onder de uitgangen staan. Deze com-ponenten komen later in de cursus aan bod. Het vierkant stelt een 1-bit geheugen voor (zie Sectie 4.2),meestal een D-flipflop. De trapezium een multiplexer (zie Subsectie 3.3.1). Dit component laat ons dus

9De laag waar de verbindingen gelegd worden.10In een tweede iteratie andere zekeringen doorbranden.11De chip kan tijdens uitvoering zijn gedrag aanpassen.

2.4. TECHNOLOGIEEN 35

A0

O0

f0

A1

O1

f1

A2

O2

f2

A3

O3

f3

A4

O4

f4

A5

O5

f5

A6

O6

f6

A7

O7

f7

N0

x0

N1

x1

N2

x2

N3

x3

AND-matrix

OR-matrix

Figuur 2.13: Schematische voorstelling van een Programmable Logic Array (PLA).

toe complexere schakelingen te maken, en tegelijk het aantal zekeringen onder controle te houden. Het zalmeestal echter een grotere inspanning vragen om een logische functie te realiseren met een programmablelogic device.

Complex Programmable Logic Device (CPLD)

O I/O

PLD

OI/O

PLD

O I/O

PLD

OI/O

PLD

Schakelmatrix

Figuur 2.15: Schematische voorstelling van een Complex Programmable Logic Device (CPLD).

Een aantal PLD componenten samen op een chip samen met de zogenaamde Glue Logic om ze samen telaten werken, noemen we een Complex Programmable Logic Device (CPLD). Figuur 2.15 toont dat dezeglue eigenlijk neerkomt op een schakelmatrix om PLDs te laten samenwerken en in- en uitvoer modules omte intrageren met de buitenwereld. Naast de PLDs zelf dient dus ook de schakelmatrix geprogrammeerd te


N0

N1

N2

N3

N4

x1

x2

D D

f1 f2

f3

Figuur 2.14: Schematische voorstelling van een Programmable Logic Device (PLD).

worden. Een ander belangrijk verschil is dat CPLDs niet geprogrammeerd worden met behup van zekeringen.De chip wordt geprogrammeerd door ladingen op transistoren te plaatsen, bijgevolg kunnen de we deze chipenkele keren volledig herprogrammeren.

Field Programmable Gate Array (FPGA)

Een nog meer geavanceerde programmeerbare chip is de Field Programmable Gate Array (FPGA). Net zoalsbij een CPLD bevat deze chip enkele logische blokken met daartussen “glue”. Deze “glue” uit zich opnieuwin een schakelmatrix, maar ook in korte en lange verbindingen. Deze laatsten worden vaak ook lange lijnengenoemd. Daarnaast bevat de chip uiteraard ook opnieuw enen uitvoer modulen. Figuur 2.16(a)

schematiseert dit concept. In tegenstelling tot een CPLD heeft een FPGA andere logische bouwblokken,namelijk Logical Blocks (LB). Dit logische blok staat weergegeven op Figuur 2.16(b). Het bestaat typischuit 4 ingangen (x1, x2, x3 en x4) en twee uitgangen (y en yQ). Inwendig bestaat het uit een 16 bit Look-UpTable (LUT) en een Data Flip-Flop (D-FF). Deze Look-Up Table is in feite niets anders dan een kleingeheugen. Met de 4 ingangen zijn we in staat om 24 = 16 verschillende invoer-waarden te genereren. Voorelk van deze waarden programmeren we een bit als uitvoer. Deze wordt uitgevoerd langs de y. De DataFlip-Flop houdt deze bit een klokcyclus bij, en zal hem de volgende klokcyclus op yQ zetten. Het gevolg isdus dat yQ een klokflank na-ijlt op y. Tot slot beschouwen we op Figuur 2.16(c) de implementatie van eenschakelmatrix. Hierbij verbinden we 4 lijnen met elkaar. Dit levert dus 6 mogelijke verbindingen. Door hetprogrammeren van de chip, kunnen we de transistoren openen of sluiten, wat resulteert in het al dan nietverbinden van twee lijnen. De transistoren die men hierbij gebruikt zijn de zogenaamde “Pass-transistoren”.

Spartan-3 Een beroemde FPGA-chip is de Spartan-3 van Xilinx. Deze FPGA maakt gebruik van Con-figurable Logic Blocks (CLB) in plaats van LBs. Een CLB wordt onderverdeeld in vier “ slices”. Twee vandeze slices kunnen geconfigureerd worden als schuifregisters (zie Subsectie 3.3.6), geheugencellen, of logische

2.5. PRAKTISCHE ASPECTEN 37

I/O I/O I/O I/O I/O

SM

SM

SMc

SMc

SM

SM

SMc

SMc

SM

SM

SMc

SMc

LB

LB

SMc

SMc

LB

LB

SMc

SMc

(a) Volledige FPGA

y

yQD-FF

16 × 1 LUT:logischefunctie van 4variabelenx4

x3

x2

x1

(b) Logical Block (LB) (c) Schakelmatrix

Figuur 2.16: Schematische voorstelling van een Field Programmable Gate Array (FPGA).

blokken, de overige twee alleen als logische blokken. Deze complexere slices bevatten twee verschillende com-ponenten voor logica: twee functies met 4 variabelen, en een functie met 5 variabelen, meestal aangevuldmet flipflops. Verder bevatten deze vaak een multiplexer en een schuifregister. De specificaties van dezeslices zijn verder ook terug te vinden in [?, p. 22-23].

Op Figuur 2.16(a) zien we dat naast logische en in- en uitvoer blokken ook nog andere componentenop een FPGA zitten. Meestal gaat het dan om RAM-geheugen en een multiplexer. Bovendien bevat dechip ook enkele klokken die het systeem aansturen. Deze zijn als een zwart blokje weergegeven. Typischefrequenties bevinden zich rond de 50 MHz. Modernere FPGA’s uiten zich in grotere geheugens, soms zelfsmet een stack (LIFO, zie Subsectie 5.3.4), specifieke in- en uitvoer blokken zoals Ethernet, PCIe,... tot zelfsmicroprocessoren.

2.5 Praktische aspecten

In de vorige sectie werd beschreven hoe we chips kunnen bouwen. We hebben echter van enkele technischeaspecten abstractie gemaakt die een invloed hebben op de werking die niet altijd van het circuit kunnenafgelezen worden. Bijvoorbeeld de geometrie van de chip. De volgende subsecties beschrijven met welkepraktische aspecten rekening gehouden moeten worden bij het ontwerpen van een chipoppervlakte.

2.5.1 Spanningsniveaus en ruismarge

Ruismarge

In Sectie 2.1 hebben we reeds kort beschreven dat we een bereik specificeren voor een High en Low signaal.We definieerden ook een ongedefinieerde zone. Deze zone omvat signalen waar het onduidelijk is welk waarde


er precies aan de ingang staat. We willen natuurlijk vermijden dat een signaal ooit in deze ruismarge terechtkomt. Daarom introduceren we een ruismargeEen marge die we inbouwen tussen de minimaal acceptabelespanning aan de invoer, en de spanning vanaf wanneer we over de ongedefinieerde zone spreken. Dit doenwe om te voorkomen dat het signaal ooit in de ongedefinieerde zone zou kunnen terugkomen..

Een ruismarge is een spanningsmarge die we beschikbaar stellen door een kleiner gebied van uitgangsspan-ningen te gebruiken dan toegelaten. We zullen dus de poorten spanningen laten genereren die zich in hethoogste gedeelte van High bevinden, of in het laagste gedeelte van Low. De ruis zal het signaal uiteraardkunnen afzwakken, maar we bijven in de acceptabele zone van High en Low. Het resultaat is dus dat bij demarges van de ingangen ruimer is dan de marges van de uitgangen. Figuur 2.17 geeft dit concept schematischweer. Ook vermeldt de figuur de typische spanningsniveaus bij CMOS en TTL12 implementatie.

VSS

VOL

VIL

VIH

VOH

VDD

Ingang Uitgang

CMOS TTLCMOSTTL

ongedefinieerdongedefinieerd

High (H)

Low (L)

ruismarge (NML)

ruismarge (NML)High (H)

Low (L)

5.0 V

4.4 V

3.5 V

1.5 V

0.5 V

0.0 V

5.0 V

2.4 V

2.0 V

0.8 V

0.4 V

0.0 V

5.0 V

3.5 V

1.5 V

0.0 V

5.0 V

2.0 V

0.8 V

0.0 V

Figuur 2.17: Werking van ruismarge bij CMOS en TTL.

Onlogische Spanningen

Wanneer een transistor omschakelt, betekent dit niet dat van het ene moment op het andere er een anderespanning op de uitgang komt te staan, Deze overgang is een continue proces. Dit betekent dus dat op een zekermoment aan de uitgang de spanning in het ongedefinieerde gebied komt te liggen. Ideaal zou uiteraard zijndat bij een continue verandering aan de ingang er toch een discrete verandering aan de uitgang plaatsvindt.Dit is echter fysisch onmogelijk. De ontwerper dient dus rekening te houden met dit overgangsverschijnsel.

Dit fenomeen een groot probleem omdat op een dergelijk omschakelmoment beide transistoren13 halfopenzijn, en er dus stroom door de componenten vloeit. Verder weet men ook niet altijd welke spanning eraan de uitgang zal staan. De Transferfunctie is immers afhankelijk van zowel het productieproces alsomgevingsfactoren zoals warmte,... Figuur 2.18(a) toont verschillende realistische transferfuncties samenmet de ideale transferfunctie.

VSS VIL

VIL

VIH

VIH

VDD

VDD

VT

Ideaal

Realistisch

(a) Transferfuncties bij een inverter

VSS VIL

VIL

VIH

VIH

VDD

VDD

(b) Schmitt-Trigger transferfunctie

Figuur 2.18: Transferfuncties en Schmitt-Trigger ingangen.

12TTL: Transistor-Transistor Logic.13PMOS en NMOS.


Schmitt-trigger ingangen Dit effect is vooral nadelig voor bijvoorbeeld in- en uitvoer: communicatievan onze chip met de buitenwereld. Deze signalen veranderen doorgaans traag, en zijn bovendien niet striktstijgend of dalend. Dit heeft tot gevolg dat indien het ingangssignaal van een 0 naar een 1 moet gaan, hetgemeten digitale signaal meestal verschillende malen van waarde zal veranderen. We kunnen dit probleem(gedeeltelijk) oplossen door gebruik te maken van de zoegenoemde Schmitt-trigger ingangen, dit zijncomponenten met een hysteresis. Dit betekent dat de overgangsspanning bij een overgang van laag naarhoog, hoger is dan de overgangsspanning van hoog naar laag. Deze transferfunctie staat op Figuur 2.18(b),samen met het symbool voor een Schmitt-Trigger ingang: een NOT poort, met een miniatuur van de inversetransferfunctie.

2.5.2 Dynamisch gedrag

Schakeling

Laag⇒Hoog

Hoog⇒Laag

RIHC

ROH

VDD

V

t

RILCROL

V

t

Figuur 2.19: Dynamisch gedrag bij twee sequentiele NOT poorten.

Op simulaties zullen we meestal uitgaan van dynamisch gedrag. Dit betekent dus dat we veronderstellendat indien we bijvoorbeeld de spanning aan de ingang van een poort naar een andere spanning brengen, deuitgang na enige vertraging van de oude naar de nieuwe spanning omschakelt. Dit zullen we illustreren meteen voorbeeld zoals op Figuur 2.19 waar we twee NOT-poorten na elkaar plaatsen. We kunnen het gedragvan dit circuit nabootsen bij overgangen, door een lijn als een capaciteit te zien, verder zien we een geslotentransistor als een weerstand, open transistoren zijn open lijnen en worden dus niet beschouwd. We zulleneerst uit de beschreven modellen de spanning in functie van de tijd plaatsen.

Hoog naar laag Bij een overgang van hoog naar laag aan de ingang, zal de spanning op de kabel tussende twee poorten stijgen. Zoals we op de grafiek zien, zal dit exponentieel gebeuren. We zullen eerst dedoelspanning V∞ bepalen, en vervolgens de tijdsconstante τ . De doelspanning kunnen we eenvoudigafleiden uit de stroom, indien de condensator volledig opgeladen is, stroomt alle stroom uitsluitend door detwee weerstanden. Hierdoor kunnen we de stroomsterkte afleiden. De spanning over de condensator kunnenwe dan berekenen, omdat deze gelijk is aan de spanning op de tweede weerstand RIH :

I∞ =VDD

RIH +ROH⇒ V∞ = RIH · I∞ =

RIH · VDDRIH +ROH

(2.3)

We leiden vervolgens de tijdsconstante af door de het systeem als een RC-keten te modelleren. In datgeval moeten we de twee weerstanden als parallel beschouwen. De tijdsconstante is dan de vervangweerstandvoor deze twee weerstanden, vermenigvuldigd met de capaciteit van de condensator:

Rsubs. =RIH ·ROHRIH +ROH

⇒ τ = Rsubs. · C =RIH ·ROH · CRIH +ROH

(2.4)


Voor het opladen van een condensator geldt volgende exponentiele functie:

V (t) = V∞ ·(

1− e−t/τ)

(2.5)

Laag naar hoog We het dynamische gedrag voor laag naar hoog volledig analoog berekenen. Omdater geen bron meer op de schakeling staat, is de schakeling een zuivere RC-keten. De condensator zal dusontladen, met als eindspanning V∞ = 0 V. We berekenen de tijdsconstante dan ook opnieuw met behulpvan de vervangweerstand:

Rsubs. =RIL ·ROLRIL +ROL

⇒ τ = Rsubs. · C =RIL ·ROL · CRIL +ROL

(2.6)

Bij een RC-keten geldt voor het ontladen van een condensator vervolgens deze exponentiele functie:

V (t) = V0 · e−t/τ (2.7)

Tijdsconstante minimaliseren We zien dus dat we - bij overgangen van laag naar hoog en hoog naarlaag - te maken hebben met exponentieel tijdsgedrag. Deze constante wordt bepaald door de capaciteit, endoor de in- en uitgangsimpedanties. We proberen deze parameters zo aan te passen dat ze aan volgende vierdoelen voldoen:

τ % τ = Rsubs. · C lage tijdsconstantePstat.?? % Pstat. = V 2/ (RI +RO) = V 2/Rtot. minimaal statisch vermogenverbruikPdyn.?? % Pdyn. = V 2/RO minimaal dynamisch vermogenverbruik

V∞ ≈ VDD V∞ = RI · VDD/ (RI +RO) uitgangsspanning dicht bij de voedingsspanning(2.8)

Hiervoor streven we naar bepaalde waardes voor de verschillende parameters:

• Ingangsimpedantie RI : we streven naar een zo hoog mogelijke ingangsimpedantie, immers stelt Ver-gelijking (2.3) dat indien RI RO, V∞ ≈ VDD. Bovendien is het statisch vermogenverbruik lager (zieVergelijking (2.8)).

• Uitgangsimpedantie RO: We proberen de uitgangsimpedantie zo laag mogelijk te houden. Dit haaltde tijdsconstante naar beneden, waardoor de chip sneller schakelt (zie Vergelijking (2.4) en Vergelij-king (2.6)). Een nadelig bijeffect is een hoger dynamisch vermogenverbruik (zie Vergelijking (2.8)).

• Capaciteit C: De capaciteit probeert men zo laag mogelijk te houden. Immers verhoogt een hogecapaciteit rechtstreeks de vertraging (zie Vergelijking (2.8)). Hoge capaciteiten zijn kenmerkend voorlange verbindingen, vandaar dat men deze meestal op chips tot een minimum beperkt.

Al deze effecten zorgen ervoor dat een CMOS-implementatie betere karakteristieken heeft dan een NMOS-poort: NMOS heeft een groter statisch vermogenverbruik. Om dit tegen te gaan, kunnen we een sterkeweerstand R in de schakeling plaatsen. Dit leidt echter tot een grote uitgangsimpedantie vermits geldt datR ≈ RO, wordt de stijgtijd van de schakeling bijgevolg groter, en dus ook de algemene vertraging van dechip.

Stijg- en daaltijd We hebben het reeds uitvoerig gehad over het dynamisch karakter van een elektronischeschakeling. Naast het feit dat het enige tijd duurt alvorens een spanning die op een draad wordt aangelegddaadwerkelijk dit spanningsniveau bereikt, heeft ook een poort een dynamisch karakter. Een interessanteeigenschap is dat de stijgen daaltijd invloed hebben op de vertraging van de poort. We formaliseren dit indrie grootheden:

• Stijgtijd tr ofwel rise time: de tijd die de geleider nodig heeft om van een lage spanning naar eenhoge spanning te stijgen. Men neemt hiervoor de 10% en 90% grenzen tussen de basisspanning en detopspanning14.

14In sommige publicaties wordt 80% en 20% gebruikt.


90% VIH

50% VT

10% VIL

Stijgtijd tr Daaltijd tf

90% VOH

50% VT

10% VOL

tpHL tpLH

Figuur 2.20: Het dynamisch gedrag van een NOT-poort.

• Daaltijd tf ofwel fall time: de tijd die de geleider nodig heeft om van een hoge spanning naar eenlage spanning te dalen. Men neemt hiervoor de 90% en 10% grenzen tussen de basisspanning en detopspanning.

• Vertragingstijd tp ofwel propagation delay: De tijd die de poort nodig heeft tussen het moment datde ingangspanning die het midden bereikt tussen de basisspanning en de topspanning, en het momentdat de uitgang deze 50% grens bereikt. Vermits de stijgen daaltijd ook bepalen hoe snel een signaalnaar 50% stijgt of daalt, hebben deze parameters ook invloed op de vertragingstijd. We berekenen devertraging door het gemiddelde te nemen tussen de vertraging tijdens het dalen tpHL en het stijgentpLH :

Vertragingstijd tp =tpHL + tpLH

2(2.9)

Dit principe wordt geıllustreerd op Figuur 2.20. We zien hier twee situaties: in de eerste situatie is destijgtijd van de ingang gelijk aan de daaltijd van de uitgang. De poort heeft weliswaar een vertraging, maardeze is vrij beperkt. In het tweede geval is de stijgtijd van de uitgang dubbel zolang als de daaltijd van deingang. Hoewel de poort sneller reageert op het veranderende signaal, is de vertraging groter. Vermits destijg- en daaltijden beınvloed worden door de parasitaire capaciteit15, wordt dus ook de vertraging beınvloeddoor de aard van de draden. De vertraging bij korte draden is aanzienlijk kleiner dan deze van lange draden.

2.5.3 Vermogenverbruik

Een van de belangrijkste ontwerpbeperkingen bij grote schakelingen is het vermogenverbruik. Een hoogvermogenverbruik uit zich in twee verschillende nadelen:

• Levering: De verbruikte energie heeft een kostprijs: het bedrag op de elektriciteitsfactuur van eengebruiker. Bovendien uit het vermogenverbruik zich ook in een kortere levensduur van eventuelebatterijen.

• Gedissipeerd: het geleverde vermogen wordt omgezet in een andere vorm van energie: warmte. Dezewarmte moet afgevoerd worden, bijvoorbeeld via een koelingssysteem, wat ook weer vermogenverbruikmet zich meebrengt.

We beschouwen ook twee vormen van vermogenverbruik die we hierboven al enkele keren hebben aange-raakt:

15De capaciteit die wordt veroorzaakt door de draad zelf.


• Statisch vermogenverbruik: Dit is het vermogen die continu verbruikt wordt, ook indien de schakelingniets doet. We zagen reeds dat dit bij NMOS implementaties het geval is, omdat we bij het sluitenvan een NMOS-transistor, een lekstroom genereren van de source naar de drain. Bij NMOS-poortenmogen we dan ook uitgaan van een vermogenverbruik van 1 mW. Dit betekent dus voor een gemiddeldechip dat dit makkelijk oploopt in tot 1 kW wat totaal onaanvaardbaar is. Bij CMOS hebben weeenvoudigweg geen lekstroom en dus ook geen statisch vermogenverbruik.

• Dynamisch vermogenverbruik: Dit is het vermogen die verbruikt wordt op het moment dat een poortomschakelt. Hierdoor wordt de parasitaire capaciteit C op- of ontladen. In [?, 3.12] wordt hiervoorvolgende formule gegeven:

Pdyn. = C × f × V 2 (2.10)

Met chipoppervlakte C, een klokfrequentie f en voedingsspanning V . We kunnen deze formuleals volgt verklaren: vermits het chipoppervlakte hoofdzakelijk draden bevat is dit een goede schattingvoor de totale lengte van de draden en dus de parasitaire capaciteit. De klokfrequentie bepaalt hoeveelmaal we per seconde deze draden moeten open ontladen. Het vermogen ten slotte om een capaciteitC op te laden is evenredig met het kwadraat van de spanning. In de praktijk werken de meesteschakelingen met een klokfrequentie in de grootorde van 100 MHz. We schakelen schakelen natuurlijkniet alle draden telkens om, maar een realistische schatting ligt bij de 20% van de draden per klokflank.Indien we ook de oppervlakte van een poort in rekening brengen komen we uit op een ordegrootte van35 nW per inverter. We kunnen dus in de grootorde van 300 000 000 invertoren plaatsen voor eenvermogenverbruik van 1 W. In de praktijk is vermogenverbruik dan ook een van de belangrijkstebeperkingen om rekening mee te houden bij het ontwerpen van digitale schakelingen, vandaar dat erin deze cursus ook een grote nadruk ligt op het minimaliseren van digitale schakelingen.

2.5.4 “0” en “1” doorgeven

Een oplettend lezer zal zich misschien de vraag gesteld hebben waarom we een buffer zoals op Figuur 2.11(a)op pagina 31 niet implementeren door de NMOS en PMOS transistor om te wisselen. Dit zou ons immerstwee transistoren besparen, en bovendien zou de poort efficienter werken, zoals op Figuur 2.21(b). Dezemethode kunnen we echter niet consistent hanteren. Voor de verklaring moeten we terug naar een belangrijkdetail bij de werking van transistoren in Subsectie ??. Een NMOS transistor geleidt immers alleen maarindien de spanning tussen de basis en de collector VGS , groter is dan de transferspanning VT . Indien deNMOS transistor dus gesloten is, zal de uitgangsspanning VT lager zijn dan de ingangsspanning. Dit geeftmisschien bij een transistor geen noemenswaardige problemen, maar bij een opeenvolging van transistoren,zal de spanning uiteindelijk onder het grensniveau vallen. Samenvattend kunnen we zeggen dat NMOStransistoren hoge spanningen niet goed doorgeven, en dus een slechte pull-up zijn. Analoog voor PMOSgeldt dezelfde redenering, maar dan toegepast op lage spanningen. Een PMOS transistor is dus een slechtepull-down. Deze spanningsverschillen zijn ook gevisualiseerd op Figuur 2.21(b).

x

VDD VDD

f

(a) Buffer met inverterende poorten

x

VDD

VT f

(b) Fout buffer

Figuur 2.21: Buffer geımplementeerd met omgekeerde transistoren: NMOS is een slechte pull-up.


2.5.5 Fan-in en fan-out

Enkele belangrijke eigenschappen van een poort zijn de fan-in en fan-out. De fan-in is het aantal ingangendie de poort in kwestie heeft. Deze eigenschap is eigen aan het type poort: een 3-nand poort heeft bijvoorbeeldeen fan-in van 3. De fan-out is het aantal ingangen van andere poorten die de poort kan aansturen, hetaantal draden die uit de poort in kwestie komen zeg maar.

De fan-in en fan-out bepalen in grote mate de vertraging van een circuit. Indien we een groot aantalingangen hebben, en een van deze ingangen schakelt om, kan dit betekenen dat er ineens stroom doorde bijbehorende transistoren gaat stromen. De stroom diet dan ook door een sequentiele keten van detransistoren van de andere ingangen te stromen. Als het aantal ingangen groot is, is deze keten lang, enbijgevolg duur het langer alvorens deze verandering merkbaar wordt aan de uitgang van de poort. Bij eengroot aantal transistoren zullen we ook de spanning moeten opdrijven. Elke transistor heeft - indien gesloten- nog steeds een kleine weerstand. Indien de stroom door een serie transistoren moet vloeien, verliezen webij elke transistor een deel van de spanning. Bijgevolg wordt de spanning aan de uitgang gereduceerd. Eenhogere spanning aan de voeding leidt op zijn beurt weer tot hogere vermogens wat we juist willen vermijden.Het is bijgevolg wenselijk de fan-in zo laag mogelijk houden. Daarom komen in de realiteit poorten met eengroot16 aantal ingangen nooit voor. Indien men een poort met een groot aantal ingangen wil realiseren zalmen deze meestal met een opeenvolging van eenvoudigere poorten realiseren.

Een hoge fan-out is ook een voorbode van problemen em moeten we onder controle houden. Elke poortheeft immers maar een uitgang. Door deze uitgang moet alle stroom naar de ingangen van andere poortenstromen. Vermits de stroom over een draad beperkt is, kunnen we spreken over een maximale stroomsterkteIOmax. Deze stroomsterkte bepaalt dan weer hoe snel we de parasitaire capaciteit kunnen open ontladen:

IOmax = C · ∂V∂t

(2.11)

Vermits de snelheid waarmee deze capaciteit open ontlaadt op zijn beurt weer invloed heeft op devertraging, heeft de fan-out ook invloed op de maximale frequentie fmax van de elektronische schakeling:

fmax =1

∆V· ∂V∂t

=IOmaxC ·∆V

(2.12)

Bij het verhogen van de fan-out zal ook de parasitaire capaciteit zelf toenemen: een verbinding van deuitgang naar de ingangen, vormt een draad17. Vermits de grootte van deze draad zal afhangen van de fan-outzal de parasitaire capaciteit hiermee schalen. We kunnen de fan-out beperken door gebruik te maken vanbuffers: we verdelen de uitgang van de poort onder een paar buffers die op hun beurt de ingangen van deandere poorten bevoorraden. We laten get signaal aan de uitgang van de poort zich dus getrapt verdelenover alle ingangen van poorten die het hoort aan te sturen. Het nadeel van het gebruik van een buffer is datdit buffer ook moet omschakelen, wat extra vermogenverbruik en vertragingen teweeg brengt.

2.5.6 Tri-state buffer

Een uitbreiding van een buffer is een Tri-state buffer ofwel 3-state buffer. Figuur 2.22(a) toont het symbooldie men voor deze component gebruikt: een buffer met een derde ingang aan de zijkant van de driehoek.

Een tri-state buffer heeft drie mogelijke uitgangswaardes: 0, 1 en de zogenaamde zwevende modus Z.Deze laatste toestand wordt ook wel hoog impedant genoemd. Het betekent dat de lijn losgekoppeld isvan enige bron. Er staat dus zogezegd niets op de lijn. Hiertoe wordt een buffer uitgebreid met een tweedeingang: Enable E. Het resultaat is dat de component in drie toestanden kan worden gebracht: wanneerenable op 0 staat, staat de tri-state buffer in de Z stand. In het geval er een 1 op de enable-ingang wordtaangelegd, laat het de ingang x door. De ingang kan zelf in twee standen staan: 0 en 1. Op Figuur 2.22(b)

16Met groot bedoelen we meer dan 5 ingangen.17Weliswaar mogelijk met vertakking, maar dat is niet relevant.


wordt dit concept met behulp van een waarheidstabel weergegeven. Er bestaan verschillende manieren omdeze component te implementeren. Een goedkope manier wordt voorgesteld op Figuur 2.22(c) en maaktgebruik van een transmission gate, een component die functioneert als een schakelaar.

enable e

input x output f

(a) Symbool

e x f0 0 Z0 1 Z1 0 01 1 1

(b) Tabel

x

e

f

(c) Implementatie

x f

s

s

≡ x f

s

s

(d) Transmission Gate

x1

e1

x2

e2

f1

f2

f3

(e) Bus

Figuur 2.22: Tri-state buffer.

De transmission gate zelf bestaat zoals te zien op Figuur 2.22(d) uit twee transistoren. Indien s = 0en s = 1 zijn beide schakelaars open, en staat er dus geen signaal op uitgang f , in dat geval is de uitgangdus hoog impedant. In aalle overige gevallen is minstens een transistor gesloten, en wordt het signaal dieaangelegd wordt op x verder gepropageerd. De schakeling op Figuur 2.22(c) bevat extra componenten omopniew voldoende spanning op te bouwen18, dezelfde argumenten als met fan-in en fan-out gelden hierimmers.

Bus Tri-state buffers worden vaak gebruikt om bijvoorbeeld over een lijn gegevens van verschillende bron-nen over te brengen. We hebben reeds in Subsubsectie 2.2.2 op pagina 28 gezien dat het verbinden vanuitgangen van poorten tot een kortsluiting leidt, en we dit bijgevolg niet kunnen realiseren. We zoudenhierdoor echter genoodzaakt zijn om voor elke uitgang een aparte draad te voorzien. Verbindingen kunneneen groot gedeelte van het chipoppervlak beslaan, vandaar dat we het aantal draden ook tot een minimumproberen te beperken. We kunnen dit probleem oplossen met een zogenaamde bus. Bij een bus wordt eendraad gedeeld tussen verschillende bronnen xi. Elke bron stuurt ook een tri-state buffer aan waardoor dat- indien de bron op dat moment niets te zeggen heeft - de toestand hoog impedant is. Men dient er voor tezorgen dat er op elk moment hoogstens een tri-state buffer actief is. Omdat de andere tri-state buffers op datmoment hoog-impedant zijn, is er geen gevaar voor kortsluiting. Figuur 2.22(e) geeft een implementatie vandit principe. In Subsectie 3.3.1 zullen we een component tegenkomen die dit principe met een algemeneretechniek realiseert: de multiplexer.

18Bemerk de buffer tussen x en de tranmission gate.

Deel II

Combinatorische en SequentieleSchakelingen

45

Hoofdstuk 3

Combinatorische Schakelingen(Schakelingen zonder geheugen)

Zelfs al zou er niets nieuws geschapen worden, dan is er nog al-tijd een nieuwe combinatie.“

”- Henry Ford, Amerikaans automobielfabrikant (1863-1947)

Nu we de basis van het bouwen van digitale circuits onder de kniehebben, en de fysische beperkingen hiervan kennen, kunnen we nut-tige schakeling zoals optellers en vergelijkers ontwikkelen. Com-binatorische Schakelingen zijn schakelingen waarbij een bitvectoraan uitgangen uitsluitend bepaald wordt aan de hand van een bitvec-tor aan ingangen. We kunnen dus stellen dat het circuit een functie~f(~x) berekent. In Sectie 1.3 werd reeds een manier voorgesteld omvoor een gegeven functie tot een schakeling van canonieke vorm tekomen. In Sectie 3.1 zullen we kennismaken met technieken zienom deze implementaties verder te minimaliseren. In Sectie 3.2 enSectie 3.3 bespreken we de implementatie van enkele populaire com-binatorische schakelingen.

3.1 Minimaliseren van logische functies . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.1.1 Waarom minimaliseren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.1.2 Hoe minimaliseren? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.1.3 Karnaugh-kaarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Optimaliseren met behulp van Karnaugh-kaarten . . . . . . . . . . . . . . . . . . . 51

3.1.4 Quine-McCluskey . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

3.1.5 Realisatie in meer dan 2 lagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.1.6 Welke methode kiezen? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

3.2 Rekenkundige basisschakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

3.2.1 Getallen voorstellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

3.2.2 Radix-conversie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

r1 → r2 omzetting met r1 = rp2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

47

48HOOFDSTUK 3. COMBINATORISCHE SCHAKELINGEN (SCHAKELINGEN ZONDERGEHEUGEN)

r1 → r2 omzetting met rq1 = r2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

r1 → r2 omzetting met rq1 = rp2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Algemene omzetting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

3.2.3 Optellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Half adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Full adder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

Ripple-carry opteller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

Carry-lookahead opteller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

CLA-generator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3.2.4 Negatieve getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

‘Sign-Magnitude’-voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Excess formaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Complement-voorstellingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

Twee-complement voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

Betekenis van binaire getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

3.2.5 Optellen en aftrekken van negatieve getallen . . . . . . . . . . . . . . . . . . . . . . 69

Signed-magnitude voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

1-complement voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

2-complement voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

3.2.6 Arithmetic-Logic Unit (ALU) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

Instructieset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

Synthese van de ALE en CIG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

3.2.7 Vermenigvuldigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

2-complement vermenigvuldiger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

3.2.8 Andere courante bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Delen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

Modulo rekenen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

3.2.9 Vaste komma getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Aantal bits voor fouteloze voorstelling . . . . . . . . . . . . . . . . . . . . . . . . . 77

3.2.10 Vlottende komma getallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Underflow en overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

IEEE-formaat voor vlottende komma getallen . . . . . . . . . . . . . . . . . . . . . 78

Rekenen met vlottende komma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

3.2.11 Andere voorstellingen van gegevens . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

Binary Coded Decimal (BCD) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

American Standard Code for Information Interchange (ASCII) . . . . . . . . . . . 81

3.3 Andere basisschakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

3.3.1 Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Cascade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

3.3.2 Decoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

Cascade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

Alternatieve implementatie voor multiplexers . . . . . . . . . . . . . . . . . . . . . 83

3.3.3 Demultiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

3.3.4 Encoder en prioriteitsencoder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Prioriteitsencoders cascaderen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

3.3.5 Vergelijker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

Vergelijkers cascaderen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

Speciale gevallen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

3.3.6 Schuifoperator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

Implementatie van schuifoperaties . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

3.1. MINIMALISEREN VAN LOGISCHE FUNCTIES 49

3.1 Minimaliseren van logische functies

In deze sectie geven we eerst een motivatie waarom het minimaliseren van implementaties een belangrijketaak is. Daarna tonen we een methode om op efficiente wijze een minimale implementatie te realiseren. Wezullen ook een aantal uitbreidingen op deze methode beschouwen.

3.1.1 Waarom minimaliseren

In deze sectie zullen we als leidend voorbeeld schakelingen ontwerpen voor de worteltrekking en 7-segmentdisplay in een minimale implementatie. Streven naar een minimalisatie is een algemeen probleem en isvergelijkbaar met optimalisatie in de informatica. Minimalisatie levert niet enkel snellere doorvoer op.Hieronder sommen we de meest courante voordelen op, samen met hun metriek:

• Minimaliseren van de kostprijs. Afhankelijk van de realisatie hanteren we hiervoor twee metrieken:Voor CMOS verfijnen we hiervoor de oorspronkelijke formule van de kostprijs uit Vergelijking (1.6).En bekomen:

kostprijs =∑alle

poorten

kostprijs (poort) (3.1)

De kostprijs van een poort wordt dan bepaald met volgende formule:

kostprijs (poort) =

fan-in if poort ∈ INV,NAND,NOR,AOI,OAIfan-in + 1 if poort ∈ AND,OR (3.2)

We zien dus dat alle inverterende poorten relatief 1 goedkoper zijn dat de niet-inverterende poorten.Bij een FPGA bepalen we de kostprijs aan de hand van het aantal logische cellen:

kostprijs = #LB’s (3.3)

Uiteraard dient hierbij de kanttekening gemaakt te worden, dat niet voor elk gegeven aantal logischecellen, er een FPGA bestaat. Indien er voldoende logische cellen op de FPGA aanwezig zijn, is dekostprijs dan ook van minder belang. We zullen immers toch dezelfde FPGA gebruiken.

• Snelheid: We maximaliseren de snelheid door de maximale vertraging te minimaliseren. Deze vertragingis afhankelijk van de poorten in het kritische pad. Het kritische pad is een pad van de ingang naarde uitgang met de grootste vertraging. Deze vertraging is afhankelijk van twee parameters:

– Vertraging van de poorten: een poort heeft tijd nodig om bij verandering van de ingang ook deuitgang te veranderen. Deze vertraging is afhankelijk van de technologie en evenredig met defan-in. We zullen deze benaderen met de volgende formule:

vertraging (poort) =

0.6 + 0.4 · fan-in if poort ∈ INV,NAND,NOR,AOI,OAI1.6 + 0.4 · fan-in if poort ∈ AND,OR (3.4)

Deze formule toont dus dat opnieuw de fan-in een belangrijke factor is, en dat niet-inverterendepoorten opnieuw een nadeel hebben tegenover inverterende poorten.

– (capacitieve) belasting: dit hangt hoofdzakelijk af van de geometrische implementatie van deprintplaat. Deze vertraging is dan ook zeer moeilijk te berekenen en wordt niet beschouwd.

We berekenen dan de formule met volgende formule:

vertraging =∑

kritischpad

vertraging (poort) (3.5)


3.1.2 Hoe minimaliseren?

Om te minimaliseren hebben we een methode nodig. Deze methode manipuleert de logische uitdrukkingvan ~f (~x) tot een uitdrukking die equivalent maar voordeliger is, rekening houdend met de metrieken vanVergelijking (3.1) en Vergelijking (3.5).

Een probleem is echter dat er geen methodes bestaan die ons een reeks manipulaties voorstellen, waardoorwe altijd tot de meest optimale implementatie komen. We moeten dus bijgevolg methodes bedenken waarmeewe in staat zijn een redelijk optimale oplossingen te bekomen. Hiervoor zullen we methodes gebruikenzoals Karnaugh-kaarten. Computers bieden bovendien de mogelijkheid een groot aantal implementaties tesimuleren. Bij een groot probleem volstaat ook deze rekenkracht niet meer om tot de beste implementatiete komen1.

3.1.3 Karnaugh-kaarten

Karnaugh-kaarten of K-kaarten proberen het aantal nutteloze ingangen tot een minimum te beperken.Het is een visueel hulpmiddel dat gebruik maakt van een vermogen waar mensen goed in zijn: het herken-nen en begrijpen van patronen. De basis van een Karnaugh-kaart is dan ook de waarheidstabel. In eenwaarheidstabel kunnen we vaak door bepaalde rijen te beschouwen verbanden zien.

N-kubus Karnaugh-kaarten zijn niets anders dan de projectie van waarheidstabellen naar een tweedimen-sionele figuur. Wanneer we een waarheidstabel met N variabelen beschouwen, kunnen we dit in N dimensiesprojecteren op een zogenoemde N-kubus. Een N -kubus construeren we door booleaanse punten te beschou-wen in N dimensies: 0, 1n; en vervolgens bogen te trekken tussen elke twee punten waar er hoogstens eenvariabele verschilt. De buren van een knoop K is de verzameling knopen waarvoor er een boog bestaat vanof naar K. Figuur 3.1 toont N -kubussen voor 1 tot 4 dimensies.

0 1

(a) 1D

00 01

1110

(b) 2D

000 001

011010

100 101

111110

(c) 3D

0000 0001

00110010

0100 0101

01110110

1000 1001

10111010

1100 1101

11111110

(d) 4D

Figuur 3.1: N-kubus voor dimensies 1 tot 4.

Elke knoop van de N -kubus beschrijft bitvector van waarden aan de ingang. We kunnen dan vervolgensop deze knooppunten de waarde die we aan de uitgang verwachten plaatsen. Buren zijn cruciaal, indien deuitgang niet verandert tussen twee buren, kunnen we zeggen dat de veranderde ingangsbit irrelevant is voorde uitgang.

Karnaugh-Kaarten Zoals eerder gesteld zijn Karnaugh-kaarten zijn in feite niets anders dan 2D projectiesvan de hierboven beschreven N -kubus. De projectie van een N -kubus naar twee dimensies is eenvoudig voorN ≤ 2: het is gewoon de N -kubus zelf. Vanaf dimensies hoger dan 2 wordt het moeilijker.

Figuur 3.2 toont de overgang van een 3-kubus naar de respectievelijke Karnaugh-kaart. Bij een N -kubusheeft elke toestand N buren. Nochtans zien we op de figuur dat de linkse en rechtse toestanden slechts2 buren hebben in plaats van 3. We moeten dan ook op een Karnaugh-kaart modulo rekenen: de linksebuur van het meest linkse veld is het rechtse veld. Hetzelfde geldt in de andere richtingen. Elke cel in deKarnaugh-kaart beschrijft een bepaalde configuratie aan de ingangen. Aan de rand van de Karnaugh-kaart

1Wat is uberhaupt de beste oplossing, in veel gevallen zal de ene metriek verbeteren ten koste gaan van de tweede.


000 001

011010

100 101

111110

⇒000 001

010 011

100101

110111⇒

000 001

010 011

100101

110111

x

z

y

Figuur 3.2: Van N -kubus naar Karnaugh-kaart.

noteren we de naam van deze ingangen, en duiden we met een lijn bij welke cellen deze ingang 1 is. Voorcellen die niet omvat worden door deze lijn, zal de bijbehorende ingang op dat moment 0 zijn. Zo komtde cel linksboven op de figuur overeen met de configuratie 〈x, y, z〉 = 〈0, 0, 0〉: alle ingangen zijn 0. De celrechtsonder komt dan weer overeen met de configuratie 〈x, y, z〉 = 〈1, 1, 0〉: alleen ingang z legt in dat gevaleen 0 aan.

x

x

1

0

(a) 1D

x

y

x

y

2

0

3

1

(b) 2D

xyz

x

y

z

2

0

3

1

4

6

5

7

(c) 3D

wx

yz

w

x

y

z

0 12 3

4 56 7

8 910 11

12 1314 15

(d) 4D

wx

yz

wx

yz

w

x

y y

z z

v

0 12 3

4 56 7

8 910 11

12 1314 15

1617 1819

2021 2223

2425 2627

2829 3031

(e) 5D gespiegeld

w

x

y y

z z

v

0 12 3

4 56 7

8 910 11

12 1314 15

16 1718 19

20 2122 23

24 2526 27

28 2930 31

(f) 5D gekopieerd

Figuur 3.3: Karnaugh-kaarten voor verschillende dimensies met binaire waarden.

Figuur 3.3 toont Karnaugh-kaarten voor een verschillend aantal variabelen. In de cellen staat de decimalewaarde van de ingang die deze cel vertegenwoordigt. Daarvoor gebruiken we de variabelen in de volgendevolgorde: 〈v, w, x, y, z〉. We kunnen in principe blijven uitbreiden. Vanaf zes dimensies wordt het echtermoeilijk om nog patronen te herkennen. Karnaugh-kaarten hebben bijgevolg maar een beperkt vermogen.

Spiegelen of kopieren Vanaf vijf dimensies groepeert men meestal cellen in rasters van 4 × 4. Mengebruikt hierbij twee varianten: ofwel spiegelt men een van de twee tabellen zoals op Figuur 3.3(e), ofwelzijn de tabellen exacte kopies (op de waarde van een enkele variabelen na) zoals op Figuur 3.3(f). Hetspiegelen van variabelen is intuıtiever omdat dit consistent is met lagere dimensies.

Optimaliseren met behulp van Karnaugh-kaarten

Nu we weten wat een Karnaugh-kaart is, bespreken we een methode om een optimale implementatie uit dezeKarnaugh-kaarten af te leiden. We introduceren eerst terminologie, daarna bespreken we het stappenplanvan de methode in detail met een voorbeeld. Tot slot beschouwen we enkele uitbreidingen op dit stappenplan.


Terminologie Alvorens we aan het optimalisatiewerk kunnen beginnen, hebben we nood aan enige ter-minologie. Een implicant is een productterm zodat de functie die ontstaat uit deze productterm 1 is voorminstens een cel op de Karnaugh kaart, die zelf ook 1 is. De priemimplicant dient ook 0 te zijn voor decellen op de Karnaugh-kaart die zelf ook 0 zijn. Voor alle overige cellen op de Karnaugh-kaart maakt hetniet uit of de functie 0 of 1. Deze definitie heeft nauwe banden met de 1-minterm, het verschil is dat bij eenimplicant niet alle variabelen aanwezig moeten zijn. Zo zien we op Figuur 3.4(a) verschillende implicantenmet een verschillend aantal variabelen. Bij 1-minterm - zoals we bespraken in Subsectie 1.3.1 - zijn altijdalle variabelen aanwezig in het product. Een priemimplicant is een implicant die geen onderdeel is van eenandere implicant met strikt minder variabelen. De priemimplicanten van Figuur 3.4(a) worden weergegevenop Figuur 3.4(b). Zo zien we op de figuur dat de implicant x1 ·x2 ·x3 ·x′4 geen priemimplicant is: de implicantx1 · x3 · x′4 is immers altijd waar wanneer x1 · x2 · x3 · x′4 waar is, en bestaat uit minder variabelen. Eenverdere uitbreiding is de essentiele priemimplicant, dit is een priemimplicant die minstens een 1-mintermomvat die niet in een andere priemimplicant verweven zit. Visueel is dit een priemimplicant die minstenseen cel omvat met 1; en er bestaat geen enkele priemimplicant die deze cel omvat. Tenslotte definieren wenog de dekking of cover als een verzameling van implicanten zodat voor elke cel waar functie 1 is, deze celdoor minstens een implicant in de verzameling wordt omvat. Daarnaast mag geen enkele implicant een celomvatten waar de functie 0 is.

f

x1

x2

x3

x4

0 1 0 0

0 0 1 0

0 1 0 0

1 1 0 1

(a) Implicanten

f

x1

x2

x3

x4

0 1 0 0

0 0 1 0

0 1 0 0

1 1 0 1

(b) Priemimplicanten

f

x1

x2

x3

x4

0 1 0 0

0 0 1 0

0 1 0 0

1 1 0 1

(c) Essentiele priemimplicanten

Figuur 3.4: Terminologie van een Karnaugh-kaart.

Stappenplan We minimaliseren een functie met behulp van een Karnaugh-kaart in vier stappen, dezestappen zullen we in de volgende paragrafen bespreken:

1. Maak de Karnaugh-kaart.

2. Bepaal alle priemimplicanten.

3. Bepaal alle essentiele priemimplicanten.

4. Zoek de minimale dekking.

Daarna zullen we nog drie speciale gevallen bestuderen.

We bestuderen deze methode aan de hand van een voorbeeld. We zullen een schakeling synthetiseren diede functies f en g berekent. Functie f geeft 1 terug bij de getallen 0, 1, 3, 5, 7, 8, 10, 11, 14 en 15, en 0 inde andere gevallen, g is waar als de afgeronde vierkantswortel van het getal even is. De waarheidstabellenvan deze functies staan in Tabel 3.1.


(a) f

x1 x2 x3 x4 f

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

(b) g

x1 x2 x3 x4 g

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

Tabel 3.1: Waarheidstabellen voor de leidende voorbeelden.

Stap 1: maak de Karnaugh-kaart In de eerste stap bouwen we een Karnaugh-kaart op die de logischefunctie visueel weergeeft. We tekenen een Karnaugh-kaart met het juiste aantal ingangsvariabelen (zieFiguur 3.3) en vullen vervolgens de uitgangswaarden voor een bepaalde uitgang in op de respectievelijkeplaatsen. per uitgang dienen we een afzonderlijke kaart op te maken: in elke cel dienen we net een bit teplaatsen.

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

Figuur 3.5: Ingevulde Karnaugh-kaarten voor de uitgangen van het leidend voorbeeld.

Op Figuur 3.5 staan de Karnaugh-kaarten voor de functies f en g. De variabelen 〈x1, x2, x3, x4〉 vormende binaire voorstelling van het invoergetal2.

Stap 2: bepaal alle priemimplicanten De volgende stap is het bepalen van alle priemimplicanten vande Karnaugh-kaart. Visueel is een implicant niets anders dan een rechthoek zodat zowel de lengte en debreedte een lengte hebben van - mogelijk verschillende - machten van twee3. Deze rechthoeken vallen ookonder de modulo-regel op een Karnaugh-kaart: een rechthoek kan dus beginnen op de meest rechtse kolom, endoorlopen tot de meest linkse, zodat de kolommen in het midden worden overgeslagen. Een priemimplicantis een rechthoek zoals hierboven beschreven, maar waarbij een verdubbeling van de lengte of de breedte -in welke richting dan ook - niet langer mogelijk is. We kunnen priemimplicanten opsporen door eerst eencel met waarde 1 te beschouwen, en dan telkens ofwel de lengte ofwel de breedte te verdubbelen tot dit niet

2Volgens de little-endian conventie.3Niet te verwarren met veelvouden van twee.


langer mogelijk is. Dit is dus het geval wanneer er nullen bij een dergelijke verdubbeling in de rechthoekdreigen te komen liggen. doen. Indien er verschillende uitbreidingen mogelijk zijn, dienen al de uitbreidingengevolgd te worden. Figuur 3.6 toont de priemimplicanten voor de twee uitgangen van het leidend voorbeeld.

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

Figuur 3.6: Karnaugh-kaarten met priemimplicanten van het leidend voorbeeld.

Stap 3: Bepaal alle essentiele priemimplicanten Nadat we de priemimplicanten bepaald hebben,zullen we uit deze verzameling de essentiele priemimplicanten halen. Deze stap is eenvoudig: als een prie-mimplicant een of meer cellen omvat die door geen enkele andere priemimplicant omvat worden, is diteen essentiele priemimplicant. Deze implicanten zullen sowieso al tot de resulterende functie behoren. OpFiguur 3.7 staan de essentiele priemimplicanten voor f en g. We zien duidelijk dat in beide gevallen depriemimplicanten onvoldoende zijn om de volledige functie te beschrijven daar er nog enen niet niet gedektworden: dit komt omdat voor al deze cellen, er minstens twee priemimplicanten de cel bedekten.

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

Figuur 3.7: Karnaugh-kaarten met essentiele priemimplicanten van het leidend voorbeeld.

Stap 4: Zoek de minimale dekking De essentiele priemimplicanten zijn de goedkoopste manier omde cellen die ze dekken te implementeren, we zien echter dat dit in de meeste gevallen onvoldoende isom de volledige functie te beschrijven: er blijven cellen met waarde 1 ongedekt. We dienen nog extrapriemimplicanten toe te voegen om tot volledige dekking te komen. In het ideale geval doen we dit door allemogelijke toevoegingen van priemimplicanten na te gaan. Dit is echter een erg arbeidsintensief proces. Menlost dit probleem dan ook meestal op met een “ gulzige strategie” ofwel “ greedy algorithm”. We beschouweninitieel de verzameling van essentiele priemimplicanten, iedere iteratie voegen we de priemimplicant toe diehet meeste aantal cellen dekt die tot dan toe ongedekt bleven. We stoppen op het moment dat de set vanimplicanten de volledige functie dekt. We illustreren dit proces op Figuur 3.8 waarbij we elke iteratiestaptonen.

Synthese Elk van de priemimplicanten die we geselecteerd hebben stelt het product voor van enkelevariabelen. We implementeren de functie door de som te nemen van deze priemimplicanten. Voor hetvoorbeeld wordt dit dus:

f = x′2x′3x′4 + x′1x4 + x1x3

g = x′1x′3x′4 + x′1x

′2x3x4 + x2x3x

′4 + x2x

′3x4 + x1x2x3

(3.6)


f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

⇒

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

⇒

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

⇒

g

x1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

⇒

gx

1

x2

x3

x4

1 0 1 0

1 1 0 1

0 1 1 1

0 0 0 0

Figuur 3.8: Werking van het greedy algoritme bij het leidend voorbeeld.

Uitbreiding: Dambordpatroon Een patroon dat men vaak tegenkomt in Karnaugh-kaarten is het dam-bordpatroon. Dit dambordpatroon hoeft niet noodzakelijk uit vierkanten te bestaan, rechthoeken zijn ookmogelijk. Indien we dit patroon met de klassieke Karnaugh-methode implementeren bekomen we een grootaantal priemimplicanten wat leidt tot dure implementaties, we kunnen in dat geval gebruik maken van XOR-operaties die we achter elkaar schakelen. Een aaneenschakeling van XOR-operaties impliceert een groterevertraging maar heeft een grote invloed op de kostprijs. Figuur 3.9 toont enkele dambordpatronen en hunimplementatie met XOR-logica.

f1

x1

x2

x3

x4

0 1 0 1

1 0 1 0

0 1 0 1

1 0 1 0

f1 = (x1 ⊕ x2)⊕ (x3 ⊕ x4)

f2

x1

x2

x3

x4

0 1 0 1

0 1 0 1

1 0 1 0

1 0 1 0

f2 = (x3 ⊕ x4)⊕ x1

f3

x1

x2

x3

x4

0 0 1 1

0 0 1 1

1 1 0 0

1 1 0 0

f3 = x1 ⊕ x4

Figuur 3.9: Voorbeelden van dambordpatronen in Karnaugh-kaarten.

Uitbreiding: Don’t cares In sommige gevallen dienen we slechts een beperkte set van invoer-configuratieste beschouwen. Stel bijvoorbeeld dat we een seven segment digitale display4 implementeren die getallen van0 tot en met 9 voorstelt. In dat geval hebben we vier ingangen nodig. Maar we zullen bijvoorbeeld nooitde configuratie 10112 = 1110 aan de ingang tegenkomen. Er is echter wel een plaats gereserveerd op deKarnaugh-kaart voor deze configuratie. In dat geval maken we gebruik van de zogenaamde don’t care.Dit wordt genoteerd met een horizontale streep5, een “X” of “d” zijn alternatieve voorstellingswijzen, maarzullen we in deze cursus niet verder gebruiken. Een don’t care is geen speciale vorm van uitvoer: we kunnenenkel nullen of enen op de uitvoer plaatsen. Een don’t care wordt enkel gebruikt om aan te geven dat we vrijmogen kiezen of de uitvoer een 0 of 1 wordt, iets wat dus het geval is bij een configuratie aan de invoer dienooit zal voorkomen. We proberen dan natuurlijk een keuze te maken tussen 0 of 1 zodat de implementatievan de schakeling goedkoper wordt. We kunnen tot betere implementaties komen door een don’t care als een1 te zien indien dit de priemimplicanten kan vergroten. Op die manier bereiken deze priemgetallen immers

4Dit is een verzameling leds die zo georganiseerd is dat we met zeven leds, alle cijfers van 0 to 9 kunnen weergeven.5Engels: dash.


een groter gebied waardoor ze minder variabelen bevatten. Op Figuur 3.10 geven we de Karnaugh-kaartvan led A en B bij een seven-segment display, samen met de priemimplicanten die we bekomen na hettoewijzen van de don’t cares. In Appendix C staan de Karnaugh-kaarten van de andere leds. Deze kaartenzijn een goede oefening om het volledige proces te leren beheersen.

A

x1

x2

x3

x4

1 1 1 0

0 1 1 1

- - - -

1 - - 1

B

x1

x2

x3

x4

1 1 1 1

1 0 1 0

- - - -

1 - - 1

Figuur 3.10: Karnaugh-kaart met don’t cares van led A en B van een seven-segment display.

Uitbreiding: Meerdere uitgangen Tot dusver hebben we steeds aangenomen dat we de functie vooreen uitgang optimaliseren, uit het voorbeeld van de seven-segment display blijkt echter dat een componentverschillende uitgangen kan hebben. Een naıve manier kan erin bestaan al deze uitgangen los van elkaar tezien, en dus voor elke uitgang het proces van de Karnaugh-kaart doorlopen. Het is echter mogelijk dat een(priem)implicant in een dekking voor een van de uitgangen, ook nuttig kan zijn voor een andere uitgang.Men kan eerst een synthese apart maken, en dan kijken of er gemeenschappelijke implicanten in de bekomendekkingen zitten, maar dit is weinig waarschijnlijk. Het is immers mogelijk dat een minder goedkope dekkingvoor de uitgangen apart, wel tot de globaal goedkoopste oplossing leidt.

Hieronder een procedure bespreken die gebruik maakt van de priemimplicanten, er is echter geen garantiedat deze tot de globaal goedkoopste schakeling komt. Met trial-and-error kunnen we dus soms tot noggoedkopere implementaties komen. De volgende procedure bekomt echter meestal een goed resultaat:

1. Realiseer eerst bij elke uitgang de essentiele priemimplicanten;

2. selecteer vervolgens priemimplicanten die essentiele priemimplicanten zijn bij een andere uitgang. Bijdeze keuze is het ook belangrijk om de priemimplicant te selecteren die in het kleinste aantal functiesvoorkomt, dit doen we om de fan-out laag te houden waardoor we minder vertraging induceren. Merkop dat deze operatie ons niets kost: we hebben immers deze implicanten al gerealiseerd; en

3. de overige priemimplicaten realiseren we per uitvoer zoals op de klassieke manier. Indien een priem-implicant in verschillende uitgangen voorkomt, kunnen we deze eventueel bevoordelen.

Duale vorm Tot dusver hebben we telkens met behulp van Karnaugh-kaarten een AND-OR implementatiegerealiseerd: analoog aan de eerder gerealiseerd sum-of-products (SOP). De conclusie dat bijna alle logischemethodes en duale vorm hebben, geldt hier opniew: ook de Karnaugh-kaarten kunnen we gebruiken om eenminimale OR-AND implementatie te realiseren. In tegenstelling tot de AND-OR vorm draait alles hier rondnullen en niet rond enen. De priemimplicaten zijn hierbij gerelateerd aan 0-maxtermen: functies die overal1 teruggeven behalve voor een bepaalde rechthoek, opnieuw met machten van twee voor de lengte en debreedte. Verder werkt deze methode volledig analoog: we bepalen eerst de essentiele priemimplicanten envoegen vervolgens andere priemimplicanten toe. We synthetiseren vervolgens de schakeling door een ANDtussen alle gekozen priemimplicanten te plaatsen. Op Figuur 3.11 voeren we deze methode uit op de f -functievan het leidend voorbeeld.

3.1.4 Quine-McCluskey

Een alternatieve methode voor het synthetiseren van minimale logische functies is het Quine-McCluskeyalgoritme. Dit algoritme wordt gebruikt in CAD-pakketten voor booleaanse optimalisatie en werkt op basis


Ingevulde Karnaugh-kaart

⇒

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

Priemimplicanten

⇒

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

Essentiele Priemimplicanten

⇒

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

Resultaat

f = (x1 + x′3 + x4) (x′2 + x3 + x4) (x′1 + x3 + x′4)

f

x1

x2

x3

x4

1 0 1 1

0 0 1 1

0 1 1 0

1 1 1 0

Figuur 3.11: Duale methode met Karnaugh-kaarten.

van tabellen. Het algoritme zoekt ook naar priemimplicanten en essentiele priemimplicanten om een functiete optimaliseren en is dus het tabel-equivalent van de methode met de Karnaugh-kaarten. Het algoritmewerkt in exponentiele tijd: O (3n) met n het aantal variabelen. In de meeste gevallen is het aantal variabelente groot om een gegeven functie te optimaliseren, in dat geval wordt er gewerkt met de Espresso heuristiclogic minimizer.

3.1.5 Realisatie in meer dan 2 lagen

Een Karnaugh-kaart laat toe tot een sterke implementatie te komen wanneer we met twee lagen werken:bijvoorbeeld een AND- en OR-laag. Zoals we echter in de volgende secties zullen zien, zullen complexeschakelingen bij twee lagen toch vrij duur uitpakken. Daarom is het soms aangewezen om de logica in meerlagen te implementeren. Dit veroorzaakt tragere schakelingen maar aan een goedkopere kostprijs. Hierondergeven we enkele technieken:

• Specificatie: in heel wat gevallen gaat de specificatie van de component reeds gepaard met een expli-ciete implementatie. Bijvoorbeeld “1 indien x en ofwel y ofwel z en t” kunnen we dan rechtstreeksimplementeren als: f = x ∧ (y ⊕ (z ∧ t)).

• Factoranalyse: We kunnen een expressie ook algebraısch manipuleren met de wetten uit Sectie 1.2.Factoranalyse wordt ook gebruikt wanneer we een schakeling dienen te implementeren met beperktefan-in: stel dat we enkel NAND-poorten met twee ingangen ter beschikking hebben. Bij realisatiesmet beperkte fan-in moet men altijd proberen deze te implementeren in een boomstructuur. Indienwe dus f = x+ y+ z+ t moeten implementeren, converteren we dit naar f = (x+ y) + (z + t), en nietnaar f = x+(y + (z + t)). De boomstructuur laat toe schakelingen te realiseren die een vertraging vanO (log n) hebben tegenover de lineare implementatie met een vertraging van O (n), dit met dezelfdekostprijs.

• Functionele ontbinding: Soms zijn we ook in staat om een functie op te delen in verschillende deel-functies. In Subsubsectie 3.2.3 zullen we bijvoorbeeld een volledige opteller beschouwen. In plaatsvan een optelling van drie bits rechtstreeks te implementeren kunnen we twee optellingen van tweebits realiseren. In het algemeen betekent dit dat we de functie ~f (~x) soms kunnen herschrijven als~h (~g (~x) , ~x) waarbij ~g en ~h meestal eenvoudigere en dus goedkopere functies zijn.

Geen enkele van deze methodes levert altijd een beter resultaat op. Het probleem moet dan ook opgelostworden in “ trial-and-error” stijl.

3.1.6 Welke methode kiezen?

Samen met de methodes uit Subsectie 1.3.2 hebben we nu volgende methodes om een schakeling te synthe-tiseren:

• Canonieke Sum-of-Products


• Canonieke Product-of-Sums

• Minimale Sum-of-Products (Karnaugh-kaarten)

• Minimale Product-of-Sums (Karnaugh-kaarten)

• Meerlagenlogica

We kunnen ook vrij kiezen tussen AND-OR en NAND-NAND in het geval van Sum-of-Products, en voorOR-AND en NOR-NOR bij Product-of-Sums. Het is altijd voordeliger om respectievelijk voor NAND-NANDen NOR-NOR te kiezen: deze schakelingen zijn altijd goedkoper en sneller. Immers blijft bij een omzettenhet aantal poorten en de structuur dezelfde, en uit Vergelijking (3.2)) en Vergelijking (3.4) blijkt duidelijkdat dit een betere keuze is. Men kan ook beslissen om de bekomen minimale AND-OR implementatie om tezetten naar een AND-OR-Invert en een OR-AND implementatie naar zijn OR-AND-Invert equivalent.

Ook kunnen we in het algemeen bewijzen dat de implementatie met Karnaugh-kaarten altijd goedkoperen sneller is dan de implementatie van hun canonieke tegenhangers. Immers komt in het slechtste gevaleen implementatie met behulp van karnaugh-kaarten neer op dezelfde implementatie als de canonieke sum-of-products. In de meeste gevallen zal meerlagenlogica verder een grotere vertraging induceren dan deimplementatie met Karnaugh-kaarten, dit is echter niet algemeen en bovendien kan meerlagenlogica gepaardgaan met grote kostenbesparingen. Veel rekenkundige schakelingen die we in de volgende sectie zullentegenkomen maken dan ook gebruik van meerdere functionele lagen.

Het is niet altijd belangrijk om tot de meest optimale implementatie te komen. Indien we bijvoorbeeldde logica op een FPGA programmeren hebben we per functie een logic block ter beschikking. Het aantalpoorten in een logisch blok staat al op voorhand vast. Indien we dus onder dat aantal blijven levert het onsniks op om de functie verder te minimaliseren. We hebben immers toch reeds voor deze poorten betaald.Deze realisatie van de schakeling naar de beschikbare elementen (poorten, logic blocks,...) wordt dan ook de“ technology mapping” genoemd.

Om de verschillende implementaties te illustreren zullen we tot slot een schakeling implementeren in deverschillende vormen van logica. De Karnaugh-kaart en de implementaties voor de hierboven beschreven me-thodes staan op Figuur 3.12. Een samenvatting van deze implementaties in termen van kosten en vertragingstaan in Tabel 3.2.

Modus Implementatie Kosten Relatief Vertraging Relatief

Canonieke SOPAND-OR 47 100% 8.6 100%NAND-NAND 39 83% 6.6 77%

Canonieke POSOR-AND 59 126% 9.4 109%NOR-NOR 49 104% 7.4 86%

Minimale SOPAND-OR 16 34% 6.6 77%NAND-NAND 12 26% 4.6 53%

Minimale POSOR-AND 17 36% 6.2 72%NOR-NOR 13 28% 4.2 49%

Tabel 3.2: Samenvatting van de verschillende implementaties.

3.2 Rekenkundige basisschakelingen

In deze sectie definieren we enkele belangrijke schakelingen voor rekenkundige bewerkingen. We hebben hetdan over optellen, aftrekken vermenigvuldigen, delen, modulo rekenen en logische berekeningen. Alvorens weechter met getallen kunnen rekenen, moeten we een manier bedenken om getallen voor te stellen met behulp

3.2. REKENKUNDIGE BASISSCHAKELINGEN 59

A

x1

x2

x3

x4

0 0 0 0

1 1 1 1

0 1 1 0

0 1 0 0

(a) Karnaugh-kaart

x1

x2

x3

x4

A

(b) Canonieke SOP (AND-OR)

x1

x2

x3

x4

A

(c) Minimale SOP

x1

x2

x3

x4

A

(d) Canonieke POS (OR-AND)

x1

x2

x3

x4

A

(e) Minimale POS

Figuur 3.12: Verschillende implementaties van dezelfde logische functie.

van binaire signalen. Doorheen deze sectie zullen we de voorstelling van getallen regelmatig veranderen omextra functionaliteit toe te voegen.

3.2.1 Getallen voorstellen

Bij het voorstellen van getallen gebruiken de meeste mensen het Arabisch getalsysteem. Hierbij stellen weeen getal voor door een reeks cijfers. Een cijfer op een bepaalde plaats heeft een gewicht dat r keer groteris, dan het volgende cijfer, met de radix r van het getalstelsel. Om tot een eenduidige voorstelling van elkgetal te komen wordt de verzameling mogelijke cijfers beperkt tot r elementen: meestal zijn dat de cijfers 0tot 9, en daarna volgen de letters a, b, ... Een getal Dr wordt dus voorgesteld als:

Dr = dm−1dm−2 . . . d0, d−1 . . . d−n =

m−1∑i=−n

ri × di (3.7)

Hierbij zijn di de cijfers van het getal. Wereldwijd gebruikt men het decimale stelsel met radix r = 10.Andere populaire stelsel zijn het binair stelsel (r = 2), het octaal stelsel (r = 8) en het hexadecimaalstelsel (r = 16).

Het binaire getalstelsel heeft logischerwijs twee mogelijke cijfers, bij conventie meestal 0 en 1. We kunnendeze cijfers voorstellen door 0 of 1 op een lijn te zetten. Indien we meer cijfers nodig hebben, kunnen wemeerdere lijnen voorzien, die elk een cijfer van het getal voorstellen. In de informatica en elektronica zal mengetallen vaak niet binair uitschrijven: men gebruik van andere getalstelsel. Dit komt omdat binaire getallennogal langdradig zijn6. Immers is het omzetten van binaire getallen naar hexadecimale getallen niets anders

6Een binair getal bestaat gemiddeld uit 3.3 keer het aantal cijfers van zijn decimale tegenhanger.


dan het groeperen van vier cijfers. Indien men getallen noteert met een andere radix dan de decimale, wordtde radix in decimale notatie als subscript toegevoegd. Zo zijn 2A16 en 1010102 het equivalent van 42.

3.2.2 Radix-conversie

Omdat de meeste mensen met decimale cijfers werken, zullen we regelmatig decimale cijfers moeten kunnenomzetten naar hun binair (en soms ook ander) equivalent. We spreken hier van een bronradix en eendoelradix. We maken hier een onderscheid tussen vier gevallen:

1. De bronradix is een macht is van de doelradix;

2. de doelradix is een macht van de bronmatrix;

3. de bron en doelradix delen een macht met elkaar; en

4. een algemene methode voor omzettingen.

Een algemene methode is natuurlijk nuttig, maar het is belangrijk ook de andere methodes te beschouwen,omdat deze vaak veel sneller uit te rekenen vallen.

r1 → r2 omzetting met r1 = rp2

Een speciaal geval van omzetting treedt op indien de bronradix een macht is van de doelradix. In dat gevalkunnen we de omzetting doen aan de hand van alfabetomzetting. Immers betekent dit dat we elk broncijferkunnen omzetten naar p doelcijfers. De sequentie van doelcijfers dienen wiskundig equivalent te zijn aanhet broncijfer. Een concreet voorbeeld is het omzetten van een hexadecimaal getal in het binair stelsel(r1 = 16 = 24 = r4

2).

(a) Hex ↔ Binair

Hex Bin Hex Bin Hex Bin Hex Bin

0 0000 4 0100 8 1000 C 11001 0001 5 0101 9 1001 D 11012 0010 6 0110 A 1010 E 11103 0011 7 0111 B 1011 F 1111

(b) Octaal ↔ Binair

Oct Bin Oct Bin

0 000 4 1001 001 5 1012 010 6 1103 011 7 111

Tabel 3.3: Radix-conversie van hexadecimaal en octaal naar binair.

Tabel 3.3 toont de omzetting van hexadecimale en octale cijfers naar sequenties van binaire cijfers. Bijwijze van voorbeeld zetten we B4F16 om naar het binaire stelsel7:

B4F16 = 1011|0100|1111 = 1011010011112 (3.8)

Elk cijfer in B4F16 vervangen we dus door het binair equivalent, vervolgens nemen we al deze cijferssamen.

r1 → r2 omzetting met rq1 = r2

In de omgekeerde situatie willen we een getal met een bronradix r1 omzetten naar een getal met een radixdie een macht is van de bronradix. De oplossing bestaat erin dat we groepjes van q broncijfers naar eendoelcijfer omzetten. De vraag is hoe we de voorstelling met de bronradix onderverdelen in groepen? Dit doenwe vanaf de komma van het originele getal: voor het gehele gedeelte maken we groepjes van q cijfers naarlinks; na de komma maken we groepjes van cijfers naar rechts. Aan de uiteinden van de voorstelling kunnener soms onvoldoende cijfers aanwezig zijn deze groepjes te maken. In dat geval dienen nullen toegevoegd te

7De verticale strepen (|) dienen uitsluitend om educatieve doeleinden, en zijn niet verplicht.


worden. Eenmaal we deze groepjes hebben geconstrueerd, vertalen we elk van deze sequenties van cijfersnaar hun equivalent cijfer in het nieuwe getalstelsel (dit is dus de omgekeerde richting voor Tabel 3.3). Bijwijze van voorbeeld zetten we 1011011111.100012 om naar zijn octale equivalent:

1011011111.100012 = 1|011|011|111.100|012 = 001|011|011|111.100|0102 = 1337.428 (3.9)

Nullen die we bijvoegen om groepjes te kunnen maken hebben we onderlijnd.

r1 → r2 omzetting met rq1 = rp2

Een logisch gevolg van de voorgaande omzettingen, is dat we ook de mogelijkheid hebben om getallenmakkelijk tussen twee radixen om te zetten indien ze een macht met elkaar delen. In dat geval bestaat erimmers een getal r′ zodat r1 = sp en r2 = sq. We kunnen in dat geval de conversie laten verlopen langs eengetalstelsel met radix s. Een concreet voorbeeld is het binaire stelsel die als een tolk kan functioneren tussenhet hexadecimale en octale stelsel. Dit illustreren we door 1572558 om te zetten naar het hexadecimaalstelsel:

Oct→Bin 1572558 = 001|101|111|010|101|1012 = 11011110101011012

Bin→Hex 11011110101011012 = 1101|1110|1010|11012 = DEAD16(3.10)

We maken dus gebruik van de twee hierboven beschreven conversie-methodes om een derde conversie teintroduceren.

Algemene omzetting

De vorige methoden werken enkel onder een aanname: de ene radix moest een macht van een andere zijn, ofer moet een gemeenschappelijk macht zijn. In de praktijk is dit meestal niet zo, zo willen we vaak decimalegetallen omzetten naar hun binair equivalent, of omgekeerd. In deze subsubsectie behandelen we kort eenmethode om in het algemeen een radixomzetting uit te voeren. Deze omzettingen zijn relatief arbeidintensief,en vereisen bovendien een getalstel waarin we simpele rekenkundige operaties kunnen uitvoeren. Voor mensenis dit over het algemeen het decimaal stelsel, computers werken doorgaans met het binair stelsel8.

We dienen dus eerst het getal dat we willen omzetten, omzetten naar een stelsel waarin we makkelijkkunnen rekenen, bijvoorbeeld het decimale getalstelsel. Indien we bijvoorbeeld 8C98916 willen omzettennaar een getalstelsel een radix 36, zullen we dit getal eerst omzetten naar het decimale stelsel, dit doen wedoor de waarde van de cijfers te vermenigvuldigen met het gewicht van hun positie en deze vervolgens op tetellen:

8C98916 = 8 · 164 + 12 · 163 + 9 · 162 + 8 · 161 + 9 · 160 = 575881 (3.11)

Een mogelijk eenvoudigere methode, is het getal van links naar rechts te lezen en ondertussen een getalin ons geheugen aan te passen. Aanvankelijk is dat getal 0. Telkens wanneer we een nieuw cijfer tegenkomen,vermenigvuldigen we het getal in ons geheugen met de radix, en tellen er vervolgens de waarde van het cijferbij op. Dit doen we tot het laatste cijfer. Het getal die dan in ons geheugen zit, is het uiteindelijke getal.Dit komt dus neer op:

8C98916 = ((((0 · 16 + 8) · 16 + 12) · 16 + 9) · 16 + 8) · 16 + 9 = 575881 (3.12)

Eenmaal we het getal in een voorstelling hebben gezet waarmee we kunnen rekenen, bepalen we iteratiefelk cijfer van het getal in de nieuwe voorstelling en dit van rechts naar links. Dit cijfer rekenen we uit doorhet getal modulo de radix r te bepalen. Wanneer we dus 575881 modulo 36 uitrekenen, bekomen we 575881mod 36 = 25 = P36. Hiermee weten we al het laatste cijfers. We trekken vervolgens de bekomen waardeaf van het getal (575881 − 25 = 575856), en delen het door de radix r (575856/36 = 15996). Dit resultaatmanipuleren we iteratief verder, om de andere cijfers van rechts naar links te berekenen. Wanneer we 0

8Dit is niet altijd zo, in de Sovjet-Unie waren in de jaren ’50 ternaire computers populair: computers die met drie soortensignalen kunnen werken.


uitkomen, stopt het algoritme en hebben we de equivalente representatie gevonden. Tabel 3.4 illustreert ditprincipe.

Stap Getal Modulo Volgende getal Cijfer1 575881 575881 mod 36 = 25 (575881− 25) /36 = 15996 25 = P36

2 15996 15996 mod 36 = 12 (15996− 12) /36 = 44 12 = C36

3 444 444 mod 36 = 12 (444− 12) /36 = 12 12 = C36

4 12 12 mod 36 = 12 (12− 12) /36 = 0 12 = C36

5 0 − − −

Tabel 3.4: Voorbeeld van algemene radix-omzetting.

We kunnen dus concluderen dat: 8C98916 = CCCP36.

3.2.3 Optellen

Hoe tellen we nu twee getallen op? In het decimaal stelsel kunnen we twee (grote) getallen optellen doormiddel van cijferen. Hieronder geven we een illustrerend voorbeeld waarbij we 1425 + 1917 uitrekenen:

overdracht c 1 0 1x 1 4 2 5y + 1 9 1 7

som s 3 3 4 2

(3.13)

Om getallen in het decimaal stelsel te kunnen optellen gebruiken we een repetitieve structuur, waarbijwe 200 basisregels moeten onthouden. Een dergelijke basisregel f (ci, xi, yi) = 〈si, ci+1〉 is een functie diede eventuele overdracht of carry, en de cijfers van de twee getallen x en y in een bepaalde kolom omzetnaar de overdracht van de volgende kolom en de som van deze kolom. Een voorbeeld van zo’n basisregel isf (0, 4, 9) = 〈3, 1〉. Deze regel wordt in ons voorbeeld gebruikt in de derde kolom vanaf rechts9. De overdrachtis hierbij een restproduct van de optelling van twee cijfers (eventueel ook met de overdracht van de vorigeoptelling). Het is immers mogelijk dat het resultaat van de optelling groter of gelijk is aan de radix r. Indat geval is het cijfer die we onderaan schrijven, gelijk aan si = ci + xi + yi − r, de overdracht is dan gelijkaan ci+1 = 1. In het geval ci + xi + yi < r, is het resultaat si = ci + xi + yi en ci+1 = 0.

Binair optellen gebeurt volledig analoog, we hebben opnieuw met een repetitieve structuur te maken, alleendienen we nu slechts 8 verschillende regels te onthouden: immers zijn alle variabelen ci, xi en yi binair.

Nu we weten hoe we twee getallen kunnen optellen, zullen we digitale circuits voorzien om de binairesignalen van twee getallen daadwerkelijk om te zetten in binaire signalen die de som voorstellen. Hiervoorzullen we eerst twee nieuwe componenten voorstellen waarmee we een opteller kunnen realiseren. We zullenlater deze implementatie verder verfijnen om sneller te kunnen optellen.

Half adder

In deze paragraaf synthetiseren we een half adder (HA), die de laatste bit van de twee getallen optelt.Bij het laatste cijfer is de overdracht c0 sowieso 010, dus daarmee hoeven we geen rekening te houden. Wedienen een functie te ontwikkelen die de overdracht van de volgende kolom berekent, en de bit die het laatstecijfer van de som bepaalt. We stellen hiervoor een waarheidstabel en de bijbehorende Karnaugh-kaarten opin Figuur 3.13.

We zien dat we de som-bit si kunnen berekenen aan de hand van een XOR operatie tussen xi en yi, decarry ci+1 is enkel 1 wanneer beide cijfers xi en yi op 1 staan, dit gedrag kunnen we dus realiseren aan dehand van een AND-poort. Deze implementatie staat in Figuur 3.13(d)

9We nummeren de kolommen vanaf rechts, analoog aan de getalvoorstelling van Vergelijking (3.7).10Dit geldt enkel bij een optelling, later zullen we optellers ook gebruiken om het verschil tussen twee getallen uit te rekenen.


xi yi si ci+1

0 0 0 00 1 1 01 0 1 01 1 0 1

(a) Waarheidstabel

ci+1

xi

yi

0

0

1

0

si

xi

yi

1

0

0

1

(b) Karnaugh-kaarten

HAci+1

xiyi

si

(c) Interface

xi yi

ci+1

si

(d) Mogelijke implementatie

Figuur 3.13: Half adder (HA).

Full adder

Met een half adder kunnen we geen optellingen uitrekenen: immers houdt de half adder geen rekening metde carry die eventueel wordt gegenereerd uit de cijfers rechts van de plaats waar de half adder staat. Weontwikkelen dus een component die deze functionaliteit wel aanbiedt: de full adder (FA). Een full adderbevat een ingang extra tegenover een half adder: de overdracht van de vorige opteller ci. Een full adder teltop door XOR-operaties toe te passen op de drie ingangen: xi, yi en ci. Er is sprake van overdracht naar devolgende bit indien twee of meer ingangen op dat moment op 1 staan. Dit kunnen we implementeren mettweelagen-logica. De waarheidstabellen en Karnaugh-kaarten voor deze schakelingen staan samen met eenmogelijke implementatie op Figuur 3.14.

We kunnen ook een implementatie synthetiseren met behulp van functionele ontbinding. Bij een fulladder voeren we immers twee optellingen uit, de volgorde speelt hierbij geen rol. Indien minstens een vande twee optellingen van de half adders overdracht genereert, is er sprake van overdracht bij de full adder.Daarom plaatsen we een OR-poort tussen de twee carries. We kunnen een full adder dus ook implementerenzoals op Figuur 3.14(e). Tegenover de implementatie op Figuur 3.13(d), zien we dat we een poort uitsparen.Dit betalen we echter met grotere vertragingen, iets wat bij optellingen met grote getallen niet gewenst is.

Ripple-carry opteller

Met behulp van een half adder en n full adders kunnen we vervolgens een opteller realiseren die twee n+ 1bit getallen optelt. Dit doen we met behulp van een Ripple-carry opteller. Figuur 3.15 toont hoe dit inz’n werk gaat: we tellen de laatste twee bits op met een half adder11, de overige bits tellen we op met fulladders. De carry uitgang van elke adder gaat naar de de ingang van de volgende adder. De allerlaatste carryuitgang cn, kan men gebruiken als een overflow uitgang. Indien we immers twee n-bit getallen met elkaaroptellen, kan dit resulteren in getallen waarvoor die we enkel met n+1 bits kunnen voorstellen. In een andergeval wordt deze uitgang gebruikt om de waarde van de n+ 1-ste bit te bepalen. We kunnen ook - zoals opde figuur - de half adder vervangen door een full adder met als carry ingang c0 = 0.

Omdat we meestal getallen met een groot aantal bits optellen12 is het interessant om het tijdsgedrag vaneen ripple-carry adder te bekijken. Het kritisch pad gaat logischerwijs van een ingang van de half adder totde laatste full adder. Indien we de implementaties van de full adder met functionele ontbinding beschouwenblijkt het kritische pad x0 → cn te zijn. In dit geval moet het signaal doorheen een XOR, n AND en n ORpoorten. Elk van deze poorten heeft twee ingangen, de vertraging is dus bijgevolg:

vertraging = 2.4n+ 2.4n+ 3.2 = 4.8n+ 3.2 (3.14)

11Op de figuur gebruiken we hiervoor een full adder FA0, maar met carry ingang c0 = 0, wat op hetzelfde neerkomt. Laterzullen we zien dat door een full adder te gebruiken, we meer kunnen doen met een ripple-carry opteller.

12Op de meeste processoren spreken we over 32 of 64 bits.


xi yi ci si ci+1

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

(a) Waarheidstabel

si

xi

yi

ci

1

0

0

1

1

0

0

1

ci+1

xi

yi

ci

0

0

1

0

0

1

1

1


FA cici+1

xiyi

si

(c) Interface

xi yi

ci+1 ci

si


xi yi

ci+1 ci

si

HA HA

(e) Functionele ontbinding

Figuur 3.14: Full adder (FA).

FA0FA1FA2FAiFAn. . .. . . c0 = 0cn

y0x0

s0

y1x1

s1

y2x2

s2

yixi

si

yn−1xn−1

sn−1

Figuur 3.15: Schematische voorstelling van een n-bit Ripple-carry opteller.

Het is mogelijk dat we deze vertraging verder kunnen reduceren, een probleem is echter dat de ver-traging van een orde O (n) blijft. Voor berekeningen met grote getallen zijn ripple-carry adders dan ookonaanvaardbaar. Om dit euvel te verhelpen introduceren we de carry-lookahead opteller.

Carry-lookahead opteller

Een Carry-lookahead opteller (CLA) is een component ter vervanging van een full adder. Het is de bedoelingom met behulp van deze component rechtstreeks ci te berekenen als een functie ci (c0, x0, x1, . . . , xi−1, y0, y1, . . . , yi−1).De Carry-lookahead opteller heeft dezelfde ingangen als een full adder: 〈xi, yi, ci〉, maar meer en andere uit-gangen 〈ci+1, gi, pi, si〉. Deze uitgangssignalen hebben volgende functie:

• carry-generate gi: 1 indien er bij het optellen van xi en yi overdracht gegenereerd wordt; 0 in hetandere geval. Bijgevolg is gi = xi · yi.

• carry-propagate pi: 1 indien bij de optelling de overdracht van de vorige bit verder gepropageerd zalworden, en deze overdracht niet gegenereerd wordt; 0 in het andere geval. Bijgevolg pi = xi ·y′i+x′i ·yi =xi ⊕ yi.


• som si: het resultaat van de optelling si = ci⊕(xi ⊕ yi), wat equivalent is met si = cip′i+c

′ipi = ci⊕pi.

De opsomming van de uitgangen geeft dan ook al meteen een mogelijke implementatie; de waarheidsta-bellen, interface en een mogelijke implementatie staan op Figuur 3.16.

xi yi ci si gi pi0 0 0 0 0 00 0 1 1 0 00 1 0 1 0 10 1 1 0 0 11 0 0 1 0 11 0 1 0 0 11 1 0 0 1 01 1 1 1 1 0

(a) Waarheidstabel

si

xi

yi

ci

1

0

0

1

1

0

0

1

gi

xi

yi

ci

0

0

0

0

0

1

0

1

pi

xi

yi

ci

1

0

1

0

1

0

1

0


s c

x y

pg

xi yi

gi pi

si ci

(c) Interface

xi yi

si ci

gi pi


Figuur 3.16: Carry-Lookahead Opteller (CLA).

We kunnen de overdracht van de carry-lookahead opteller ci+1 vervolgens berekenen met de formuleci+1 = gi + cipi: er is overdracht wanneer deze ofwel gegenereerd wordt, ofwel wanneer er al overdracht is endeze gepropageerd wordt. De overdacht hangt dus niet langer rechtstreeks af van xi of yi. Deze eigenschapzal belangrijk blijken voor de synthese van het volgende component: de CLA-generator.

CLA-generator

Om een opteller te realiseren moeten we, net zoals bij de ripple-carry opteller, nog de glue logic voorzientussen de verschillende carry-lookahead optellers. Bij deze optellers is het verhaal echter gecompliceerder:we hebben een extra component nodig om de CLA elementen met elkaar te verbinden: de CLA-generator.Een n-bit CLA-generator is een component met ingangen 〈c0, g0, . . . gn−1, p0, . . . , pn−1〉. De component heefttot doel om de overdracht voor een reeks carry-lookahead optellers te berekenen met een zo klein mogelijkkritisch pad, logischerwijs heeft de component dan ook de uitgangen: 〈c1, . . . cn, g0,n−1, p0,n−1〉. De laatstetwee uitgangen zullen we later bespreken. Op figuur 3.17(a) zien we hoe we een CLA-generator aansluitenop de Carry-lookahead optellers.

Eerst zullen we een methode ontwikkelen om een overdracht ci te berekenen. Een overdracht kan maarop twee manieren tot stand komen: ofwel wordt deze gegenereerd, ofwel wordt deze gepropageerd. Ditformaliseren we als:


c0

s c

x y

pg

CLA0

x0 y0s0

p0g0

c1

c1

s c

x y

pg

CLA1

x1 y1s1

p1g1

c2

c2

s c

x y

pg

CLA2

x2 y2s2

p2g2

c3

c3

s c

x y

pg

CLAn−1

xn−1yn−1sn−1

pn-1gn-1

cn

cn

c0g0,n-1

p0,n-1

. . .

. . .

CLA-generatorg0,n−1

p0,n−1

(a) Structuur van de CLA-generator.

s c

x y

pg

CLA0

x0 y0s0

s c

x y

pg

CLA1

x1 y1s1

s c

x y

pg

CLA2

x2 y2s2

s c

x y

pg

CLA3

x3 y3s3

s c

x y

pg

CLA4

x4 y4s4

s c

x y

pg

CLA5

x5 y5s5

s c

x y

pg

CLA6

x6 y6s6

s c

x y

pg

CLA7

x7 y7s7

s c

x y

pg

CLA8

x8 y8s8

c0

p0g0

c1

p1g1

c2

p2g2

c3

g0,2p0,2

CLA-Generator1,0c0

p0g0

c1

p1g1

c2

p2g2

c3

g0,2p0,2

CLA-Generator1,1c0

p0g0

c1

p1g1

c2

p2g2

c3

g0,2p0,2

CLA-Generator1,2

c0

p0g0

c1

p1g1

c2

p2g2

c3

g0,2p0,2

CLA-Generator2,0

c0

(b) Cascade van CLA-generators met n = 9, k = 3.

Figuur 3.17: CLA-generator.

ci = g0,i−1 + p0,i−1 · c0 (3.15)

Een oplettende lezer zal gemerkt hebben dat we hierbij g en p twee indices geven. De indices wijzen danook op een bereik: alle getallen tussen 0 en (inclusief) i− 1. g0,i−1 betekent dus zoveel als: “er wordt ergenstussen 0 en i− 1 een overdracht gegenereerd, en deze wordt dan verder gepropageerd tot i. p0,i−1 betekentdat er een propagatie-pad is tussen index 0 en i. Een dergelijk propagatie-pad bestaat uitsluitend tot de i-debit indien voor alle posities tot i er geprogageerd wordt. Bijgevolg stellen we dat:

pi,j =

j∏k=i

pk (3.16)

Merk op dat we hier een booleaans product bedoelen, er staat dus tussen elk element van de deelexpressieeen AND. Er wordt soms ook overdacht gegenereerd. Dit is bijvoorbeeld het geval indien de vorige bit eenoverdacht genereerde, of een willekeurige bit ervoor, die deze dan tot de i-de bit weet te propageren. Ofmeer formeel:

gi,j = gj +

j−1∑k=i

gkpk+1,j = gj +

j−1∑k=i

(gk ·

j∏l=k+1

pl

)(3.17)

Merk op dat we hier met het sommatie-teken de booleaanse som bedoelen, wat dus neerkomt op OR-poorten. Wanneer we Vergelijking (3.16) en Vergelijking (3.17) in Vergelijking (3.15) schuiven, dan bekomenwe een formule waarmee we de overdacht ci kunnen berekenen, enkel op basis van de invoer van de CLA-generator:


ci = gi−1 +

i−2∑k=0

(gk ·

i−1∏l=k+1

pl

)+ c0 ·

i−1∏k=0

pk (3.18)

De berekening voor ci kost dus een i + 1-OR poort, en i + 1 AND poorten, elk van deze poorten heefteen ander aantal ingangen varierend van twee tot i+1. We kunnen nu opnieuw het kritische pad analyseren.Dit pad is x0 → cn. Hierbij gaat het signaal doorheen een XOR poort, een n + 1-input AND poort en eenn+ 1-OR poort. De totale vertraging is dus:

vertraging = 3.2 + 2 · (2 + 0.4 · n) = 0.8 · n+ 7.2 (3.19)

Toegegeven dat de orde van de vertraging nog steeds lineair is, maar de factor voor O (n) is met deCLA-generator sterk gereduceerd. De CLA-generator laat ons echter ook toe om toch logaritmisch gedragte bereiken, en dit met een cascade van CLA-generatoren. Indien we twee n-bit getallen willen optellen,en we groeperen elke k carry-lookahead optellers met een CLA-generator, en vervolgens groeperen we elkek CLA-generatoren tot een niveau hoger, dan hebben we dlogk ne niveaus nodig. We kunnen in dat gevalVergelijking (3.19) gebruiken om de vertraging te berekenen:

vertraging = 3.2 + (2 · dlogk ne − 1) · (4 + 0.8 · k) (3.20)

Hiermee kunnen we de vertraging reduceren tot een logaritmische orde. Figuur 3.17(b) toont hoe we eendergelijke cascade kunnen bouwen. Met deze cascade wordt ook meteen de reden van de twee extra ingangenduidelijk: het zijn de propagate en generate ingangen voor de CLA-generator een niveau hoger, die dus enkelkijkt of een blok van bits overdracht zullen genereren en propageren. De bijbehorende formule voor g0,k−1

en p0,k−1 kunnen we respectievelijk afleiden uit Vergelijking (3.17) en Vergelijking (3.16).

Bij wijze van afsluiter stellen we op Figuur 3.18 een mogelijke implementatie van een CLA-generator voor.Deze implementatie is ver van optimaal, en bovendien met een kleine n.

c1

p0g0

c2

p1g1

c3

p2g2

c0

g0,2

p0,2

Figuur 3.18: Een mogelijke implementatie voor een CLA-generator met n = 3.

We zien rechtsboven een reeks AND-poorten. De meest rechtse AND-poorten berekenen de telkens hetproduct van een reeks propagatoren pi en c0. Ze bereken dus of de carry c0 kan worden doorgegeven tot eenzekere bit. Links van elke generator-ingang gi staan ook een reeks AND-poorten. Deze poorten berekenenof we deze gegenereerde overdracht tot een zekere bit kunnen verder propageren. Helemaal links staat ookeen AND-poort die het product van alle propagatoren pi berekent, en aanlegt op de p0,2 uitgang. Onderaanbevinden zich een aantal OR-poorten die carry ci berekenen. De poorten nemen telkens de som van hunovereenkomstige generator gi−1 alsook de poorten die erin slagen overdracht ver genoeg te propageren. Totslot staat er nog links een OR-poort. Deze poort komt grotendeels overeen met de OR-poort die voor c3staat, er ontbreekt echter een ingang van een AND-poort met c0. Immers indien c0 = 1, wordt de overdrachtniet binnen dit bereik gegenereerd.


3.2.4 Negatieve getallen

Om getallen te kunnen aftrekken, zullen we eerst ons getalbegrip uitbreiden, zodat we ook negatieve getallenkunnen voorstellen. Negatieve getallen voorstellen kan op verschillende manieren. In onderstaande subsub-secties zullen we de meest populaire bespreken. We moeten hierbij in gedachten houden dat we eventueelde bovenstaande opteller zullen moeten uitbreiden om ook negatieve getallen te kunnen optellen. Het is dusaan te raden niet eender welke voorstelling te kiezen, maar een voorstelling waarvan we verwachten dat wehiermee efficient berekeningen kunnen uitvoeren.

‘Sign-Magnitude’-voorstelling

Het arabische getalstelsel lost het probleem van het voorstellen van negatieve getallen op aan de hand vaneen teken. Een getal bestaat dan uit twee delen: een teken (+ of −) en een grootte. Bij positieve getallenwordt dit teken zelfs meestal niet geplaatst. Deze voorstelling is gekend als de ‘ sign-magnitude’ voorstelling.Aangezien een getal ofwel positief of negatief is, kunnen we bij een binaire voorstelling een extra bit bij hetgetal plaatsen, bijvoorbeeld ervoor. Deze bit is 0 bij een positief getal, en 1 bij een negatief getal. In datgeval wordt dus 011002 = +1210 en 111002 = −1210. Een getal met n bits kan dus alle gehele waardenaannemen tussen −2n−1 + 1 en 2n−1 − 1. Er zijn echter enkele problemen met deze voorstelling. Zo zijner bijvoorbeeld twee voorstellingen van 0: −0 en +0. Dit leidt tot extra complexiteit bij bijvoorbeeld hetvergelijken van twee getallen. Optellen en aftrekken van twee getallen wordt bovendien gecompliceerder: erzijn verschillende testen nodig alvorens we de waardes van de getallen kunnen optellen of aftrekken, wattot grote vertragingen leidt. De sign-magnitude voorstelling is dan ook niet populair bij het voorstellen vangehele getallen. Wel is het een populaire manier om positieve en negatieve getallen met vlottende kommavoor te stellen zoals we zullen zien in Subsectie 3.2.10.

Excess formaat

Een tweede mogelijkheid om getallen voor te stellen is het zogenoemde excess formaat. Hierbij beschouwdmen een parameter, de excess-bias B. Men stelt ieder getal voor alsof het een positief getal is, maar mentrekt er virtueel de excess-bias vanaf. Indien de excess-bias dus bijvoorbeeld 12 is, dan slaat 00002 op −12;01002 op −8 en 11102 op +2. Een probleem met het excess formaat is dat men bij het implementeren vanoptellers en andere componenten de boekhouding op orde moet houden. Men kan dus geen twee getallen inexcess formaat zomaar optellen: men dient er de bias terug van af te trekken. Wanneer we dus bij excess-bias 12 de getallen 10002 = −4 en 11102 = 2 willen optellen, kunnen we deze optellen alsof het natuurlijkegetallen zijn, en bekomen we 101102 = 14, maar daarna dienen we nog 12 van af te trekken 11002 = −2. Hetexcess formaat wordt wel gebruikt bij de exponent bij getallen met vlottende komma (zie Subsectie 3.2.10).

Complement-voorstellingen

De meeste voorstellingen van negatieve getallen zijn gebaseerd op complement voorstellingen. Bij dezetwee voorstellingen zal men negatieve getallen voorstellen door het complement van de cijfers te nemen.Wanneer het eerste cijfer van het getal dus groter is dan de helft van de radix spreken we over een negatiefgetal. Er bestaan twee soorten complement voorstellingen voor een getal D met m cijfers en radix r:

• cijfer-complement of diminished-radix complement D′: hierbij wordt elk cijfer i vervangen door zijncomplement r − i− 1. Bijvoorbeeld:

– Het 9-complement van 133710 is 866210.

– Het 1-complement van 01001011 010100112 is 10110100 101011002.

Het 1-complement wordt soms gebruikt voor het voorstellen van negatieve getallen in het binairestelsel. Een belangrijk nadeel is echter dat er opnieuw twee voorstellingen van 0 bestaan. Om ditprobleem op te lossen, bestaat er een andere complement voorstelling.

• radix-complement D∗ = rm −D. Bijvoorbeeld:


– Het radix-complement van 133710 is 866310.

– Het radix-complement van 01001011 010100112 is 10110100 101011012.

Voor binaire getallen is dit het 2-complement. Dit is veruit de meest populaire voorstellingswijze.

Een eigenschap waar we later nog op zullen terugkomen is dat D∗ = D′ + 1. De voorstelling van hetradix-complement is dus altijd een groter dan de voorstelling van dat getal in cijfer-complement. Immers zalblijken dat - omdat het 1-complement snel uit te rekenen valt - het 2 complement ook snel uit te rekenenzijn. Immers is het 1-complement niets anders dan het toepassen van een NOT operatie op alle bits.

Twee-complement voorstelling

Omdat de 2-complement voorstelling vrij populair is, gaan we er nog wat dieper op in. Bij een getalstelsl metradix r en een getal met n cijfers, kunnen we rn getallen voorstellen. Een logisch gevolg is dat we getallengroter of gelijk aan rn niet voorstellen: 0 wordt immers ook voorgesteld. Daarom stellen we dat rn ≡ 0. Wekunnen rn immer voorstellen door een 1 gevolgd door n cijfers met 0. Omdat we maar n bits beschikbaarhebben, weerhouden we de laatste n bits: de 1 valt er dus zogezegd af. Omdat D∗ = rn −D geldt, kunnenwe stellen dat D∗ ≡ 0 − D = −D. Wanneer we dus de 2-complement voorstelling voor negatieve getallengebruiken, kunnen we onze opteller van de vorige subsectie gebruiken, zonder enige aanpassing.

Of een getal positief is of negatief, is natuurlijk een kwestie van interpretatie. De opteller weet niet of hetmet een geheel getal voorstelling of een 2-complement voorstelling te maken heeft, maar dat maakt nietsuit. We dienen zelf bij te houden welk soort getallen onze voorstelling kan bevatten. We kunnen we relatiefeenvoudig de negatie van een getal berekenen: we passen op elke bit een NOT operatie toe, en tellen daarvervolgens 1 bij op. Later zullen we zien dat we door een eenvoudige ingreep op onze eerder ontwikkeldeopteller, deze optelling kunnen realiseren met een minimum aan extra hardware.

Een ander voordeel van de 2-complement voorstelling, is dat er slechts een voorstelling van het getal 0 is.Indien we immers het negatief van 0 berekenen bekomen we:

D = 00002 ⇒ −D ≡ D∗ = 11112 + 00012 = 100002 = 00002 (3.21)

Dit resulteert in het feit een getal met n bits een bereik van −2n−1 tot 2n−1 − 1, wat exact een elementgroter is dan de 1-complement tegenhanger13.

Betekenis van binaire getallen

Om het verschil tussen de verschillende voorstellingen duidelijk te maken, zetten we de betekenis van deverschillende voorstellingen voor elke 4-bit getal naast elkaar in Tabel 3.5.

3.2.5 Optellen en aftrekken van negatieve getallen

Nu we de belangrijkste voorstellingen van negatieve getallen besproken hebben, werken we voor iedere voor-stellingen een schema uit hoe we getallen kunnen optellen en aftrekken. Deze schema’s worden weergegevenin Figuur 3.19. We bespreken in de volgende subsubsecties deze voorstellingen.

Signed-magnitude voorstelling

Bij een sign-magnitude voorstelling moeten we eerst een reeks testen uitgevoeren alvorens we getallen kunnenoptellen of aftrekken. In eerste instantie moeten we bij het aftrekken van twee getallen het teken van detweede operand veranderen: we maken het getal dus negatief. Daarna kunnen we een optelling uitvoerendie rekening houdt met het aangepaste teken. Bij deze optelling moeten we eerst testen of beide getallenhetzelfde teken hebben. Indien dit het geval is, tellen we de magnitudes van de twee getallen op, en dit wordt

13Dit is de plaats die vrijkomt omdat de 2-complement voorstelling slechts een voorstelling van 0 heeft.


Binair Unsigned Sign-Magnitude 1-Complement 2-Complement

0000 +0 +0 +0 +00001 +1 +1 +1 +10010 +2 +2 +2 +20011 +3 +3 +3 +30100 +4 +4 +4 +40101 +5 +5 +5 +50110 +6 +6 +6 +60111 +7 +7 +7 +71000 +8 −0 −7 −81001 +9 −1 −6 −71010 +10 −2 −5 −61011 +11 −3 −4 −51100 +12 −4 −3 −41101 +13 −5 −2 −31110 +14 −6 −1 −21111 +15 −7 −0 −1

Tabel 3.5: Betekenis van de binaire getallen.

de magnitude van het uiteindelijke getal. Het teken blijft dan gelijk aan dat van de twee oorspronkelijkegetallen. Indien het teken niet gelijk is, zal het getal met de grootste magnitude m het teken van het getalbepalen, en moeten de magnitudes van elkaar afgetrokken worden. We vergelijken dus de magnitudes. Inhet geval dat beide gelijk zijn, is het resultaat 0, en is de teken-bit is vrij te kiezen14. Zijn de magnitudesverschillende dan trekken we de kleinste magnitude af van de grootste, en bepaalt de grootste ook de teken-bit. Deze reeks testen - drie in totaal - zorgen voor complexe hardware die bovendien ook nog traag werkt, ditmaakt sign-magnitude tot een weinig populaire voorstelling. Figuur 3.19(a) geeft de werkwijze schematischweer.

1-complement voorstelling

Optellen en aftrekken met de 1-complement voorstelling is eenvoudiger. Bij een aftrekking berekenen weook eerst de negatie van de tweede operand. Dit komt neer op een bitgewijze15 NOT operatie. Vervolgenskunnen we de twee getallen optellen met onze eerder geımplementeerde opteller. Deze optelling volstaat nietaltijd: met het volgende voorbeelden kunnen we illustreren wat er kan fout lopen:

0101+ 10100 1111

+5+ −5−0

0110+ 11011 0011

+6+ −2

+3

1011+ 00110 1110

−4+ +3−1

(3.22)

Indien we twee getallen optellen met een tegengesteld teken, zodat de uitkomst positief is, zien we dathet resultaat altijd 1 lager uitvalt dan het correcte resultaat. Dit komt omdat de 1-complement voorstellingtwee representaties voor 0 heeft. Zoals we zien in het eerste voorbeeld, komen we −0 uit bij het optellen vantwee tegengestelde getallen. Omdat het ophogen van −0, +0 oplevert betekent dit dus dat het “twee stappenkost” om een waarde boven de 0 uit te komen. Wanneer we dus een resltaat 1 zouden moeten uitkomen, zalde opteller de voorstelling die bereken die 1 hoger is dan −0: +0. We kunnen dit probleem oplossen aan dehand van de carry cn. Indien deze carry gelijk is aan 1, moeten we nog 1 optellen bij het resultaat. Wanneerwe dit toepassen op de voorbeelden in Vergelijking (3.22) bekomen we wel correcte resultaten:

14Op de figuur hebben we voor 0 gekozen.15Met bitgewijs bedoelen we dat we de beschreven operatie op elke bit toepassen. In dit geval betekent dit dus dat we op

iedere bit afzonderlijk de NOT operatie toepassen.


Einde

mr = m2 −m1

sr = s2

mr = m1 −m2

sr = s1

mr = 0sr = 0

mr = m1 + m2

sr = s1

m1 > m2

m1 = m2

s1 = s2

s2 = s′2

Beginaftrekking

Beginoptelling

nee ja

nee ja

nee ja

(a) Sign-magnitude

Einde

Carry aanpassen

Br = B1 + B2

B2 = B′2

Beginaftrekking

Beginoptelling

(b) 1-complement

Einde

Br = B1 +B′2 +1 Br = B1 + B2

Beginaftrekking

Beginoptelling

(c) 2-complement

Figuur 3.19: Optelling en aftrekking van gehele getallen.

0101+ 10100 1111

+ 00001111

+5+ −5−0

+ +0−0

0110+ 11011 0011+ 0001

00100

+6+ −2

+3+ +1

+4

1011+ 00110 1110

+ 00001110

−4+ +3−1

+ +0−1

(3.23)

Deze aanpassing resulteert in een belangrijk nadeel: we de optelling-aftrekking dus in twee tijden moetenuitvoeren: eerst tellen we ze op en bepalen we de hoogste carry cn, vervolgens tellen we deze carry nog eensbij het resultaat op. Dit veroorzaakt dus een verdubbeling van de vertraging. Figuur 3.19(b) geeft het heleproces schematisch weer.

2-complement voorstelling

De 2-complement voorstelling is de beste voor de implementatie van een opteller-aftrekker. Immers kunnenwe een optelling eenvoudigweg uitvoeren zoals we die reeds hebben beschreven in Subsectie 3.2.3. Bij eenoptelling dienen we dus enkel de twee operatoren optellen: Br = B1 +B2. Bij een aftrekking moeten we eerstde negatie van de tweede operand berekenen. Wanneer we deze negatie: −B2 = B′2 + 1 in de berekening bijoptelling inschuiven, wordt de volledige berekening dus Br = B1 +B′2 + 1. Deze optelling lijkt tot hetzelfdeprobleem te leiden als bij de 1-complement voorstelling: we dienen tweemaal een optelling uit te voeren.In Subsectie 3.2.3 hebben we echter een opteller geıntroduceerd met een carry-ingang c0 die we altijd op0 hebben gezet. Door deze carry bit c0 op 1 zetten, tellen we automatisch 1 extra op bij het resultaat,en dit zonder extra hardware te gebruiken, of vertragingen te introduceren. Uit de formule blijkt ook datwe bitgewijze een NOT operatie moeten uitvoeren op B′2, maar enkel in het geval van een aftrekking. Ditkunnen we bewerkstelligen met een XOR poort: Een XOR poort is dan ook een geparametriseerde NOTpoort. Indien een van de ingangen van de XOR poorten op 1 staat, fungeert de XOR poort als een NOTpoort voor de andere uitgang. Indien de eerste ingang op 0 staat, laat de XOR poort de andere ingangeenvoudigweg door. We kunnen dus een opteller-aftrekker realiseren zoals op Figuur 3.20(b).

Deze component bevat een extra ingang s waarmee men kan aangeven of we een optelling of aftrekkingwillen uitvoeren. Indien s = 0 tellen we de twee getallen met elkaar op, anders trekken we de twee getallenvan elkaar af. Door een XOR poort op de laatste twee carry-uitgangen cn−1 en cn te plaatsen, kunnenwe een controle op overflow inbouwen. Deze component wordt meestal samengevat tot een interface zoalsop Figuur 3.20(a)16. Een schematische werkwijze van optellen en aftrekken met 2-complement voorstelling

16Bemerk op de figuur dat variabelen met hoofdletters een rij van in- of uitgangen voorstellen.


adder-subtractor

cout s

X Y

F

(a) Interface

FA0

f0

x0 y0

FA1

f1

x1 y1

FA2

f2

x2 y2

FAn−3

fn−3

xn−3 yn−3

FAn−2

fn−2

xn−2 yn−2

FAn−1

fn−1

xn−1 yn−1

. . .

. . .

cn

overflow

s

(b) Mogelijke implementatie

Figuur 3.20: Opteller-aftrekker voor 2-complement getallen.

staat op Figuur 3.19(c). De 2-complement voorstelling is dan ook populair omdat deze weinig bewerkingenen testen vergt om sommen en verschillen te berekenen. Bovendien is er weinig extra hardware - een XORpoort per bit en mogelijk een full adder in plaats van een half adder - nodig om een opteller om te bouwentot een opteller-aftrekker.

3.2.6 Arithmetic-Logic Unit (ALU)

FA0

ALE0

a0 b0

f0

FA1

ALE1

a1 b1

f1

FAn−2

ALEn−2

an−2bn−2

fn−2

FAn−1

ALEn−1

an−1bn−1

fn−1

i1i0m

CIG

overflow

cn . . .

. . .

Figuur 3.21: Schematisch implementatie van een arithmetic-logic unit (ALU).

Hoewel veel processoren in staat zijn om sommen en verschillen te berekenen zal men meestal geendirecte opteller of opteller-aftrekker vinden. Meestal gebruikt men hiervoor een Arithmetic-Logic Unit(ALU). Een ALU is een component die, gebaseerd op een opteller, allerlei instructies17 kan uitvoeren. Inons geval beschouwen we vier rekenkundige (optellen, aftrekken, increment en decrement) en vier logischebewerkingen (AND, OR, NOT en identiteit). We bouwen een ALU op ongeveer dezelfde manier zoals we eenopteller-aftrekker bouwden uit een opteller. In plaats van XOR poorten gebruiken we een nieuw component:een Arithmetic-Logic Extender (ALE). Een ander component – de Carry Input Generator (CIG) – berekentwelke ingang aan de carry c0 moet worden gegeven. In het algemeen heeft een ALU dus een structuur zoalsop Figuur 3.21 waarbij de ALE en CIG vrij geımplementeerd kunnen worden op basis van een instructieset.

17Welke instructies is niet echt gespecificeerd. Er bestaan dan ook boeken over het ontwerpen van een goede ALU.


Instructieset

Alvorens we in staat zijn een ALU te maken moeten we een instructieset definieren. Onze instructieset heeftdrie18 ingangssignalen die bepalen welke opdracht er moet worden uitgevoerd. We delen de acht opdrachtenin in twee groepen van vier: aritmetisch en logisch. Daarom noemen we de eerste bit van het instructiewoordm voor mode19. Verder wijzen we dan elke opdracht toe aan een bepaald instructiewoord zoals in Tabel 3.6.

m i1 i0 F X Y c0 Instructie

0 0 0 A′ A′ 0 0 NOT0 0 1 A AND B A AND B 0 0 AND0 1 0 A A 0 0 Identiteit0 1 1 A OR B A OR B 0 0 OR1 0 0 A− 1 A -1 0 Decrement1 0 1 A+B A B 0 Optelling1 1 0 A−B A B′ 1 Aftrekking1 1 1 A+ 1 A 0 1 Increment

Tabel 3.6: Instructieset van een typische arithmetic-logic unit (ALU).

Gebaseerd op deze instructieset moeten we een ALE en CIG implementeren. De ALE implementeerteen functie die 〈A,B〉-waardes afbeeldt op 〈X,Y 〉-waardes. Deze laatste waardes dienen als invoer voor deopteller. De CIG ten slotte geeft – gebaseerd op het instructiewoord – een waarde voor c0. Deze functiesstaan ook in het derde deel van instructietabel (Tabel 3.6).

Synthese van de ALE en CIG

Eenmaal we de instructieset hebben bepaald, dienen we enkel nog de ALE en CIG te implementeren. EenALE is een component met als ingangen het instructiewoord en van elke operand een bit. In ons geval wordtdit dus 〈m, i1, i0, aj , bj〉. Als uitgangen hebben we de ingangen van een van de full adders 〈xj , yj〉. We zijndus in staat om een waarheidstabel en Karnaugh-kaart op te stellen van de ALE. Zoals op Figuur 3.22(a). Opbasis van de Karnaugh-kaart kunnen we dan een logisch circuit bouwen zoals is te zien op Figuur 3.22(b). Opde figuur hebben we dat gedaan met AND-OR lagen, maar zoals reeds gezegd zijn equivalente NAND-NANDlagen goedkoper en sneller.

De CIG is enkel afhankelijk van het instructiewoord. Met de instructieset op Tabel 3.6 is dit 〈m, i1, i0〉.Een CIG heeft slechts een uitgang: de carry c0. Op basis van deze instructieset staat op Figuur 3.22(a) debijbehorende Karnaugh-kaart. Deze blijkt een eenvoudige AND-operatie te zijn zoals op Figuur 3.22(c). Dewaarde van i0 blijkt zelfs geen effect te hebben op de carry.

3.2.7 Vermenigvuldigen

In deze subsectie bouwen we een vermenigvuldiger gebaseerd op de manier hoe men met behulp van cijferentwee getallen vermenigvuldigt. We zullen hierbij enkel natuurlijke getallen beschouwen, later breiden wedit uit naar gehele getallen. Vergelijking (3.24) toont hoe we met behulp van cijferen twee getallen in hetdecimale getalstelsel vermenigvuldigen:

1 4 2 5× 3 6 5

7 1 2 58 5 5 0

+ 4 2 7 55 2 0 1 2 5

(3.24)

18Omdat we acht opdrachten gedefinieerd hebben, hebben we een log2 8 = 3 bit instructiewoord nodig.190=logisch, 1=aritmetisch.


xjm

i1

i0

aj aj

bj bj

1 0 0 1

0 0 1 0

0 1 1 1

0 1 1 0

0110

0110

0110

0110

yjm

i1

i0

aj aj

bj bj

0 0 0 0

0 0 0 0

0 0 0 0

0 0 0 0

1111

0011

0000

1100

c0

m

i1i0

0

0

0

0

0

1

0

1

(a) Karnaugh-kaarten

xj yj

mi1i0

bjaj

(b) Implementatie ALE

m i0 i1

c0

(c) Implementatie CIG

Figuur 3.22: Synthese van de ALE en CIG.

We kunnen dus twee getallen vermenigvuldigen door het eerste getal telkens te vermenigvuldigen met eenvan de cijfers van het onderste getal en deze – nadat we ze op de juiste manier hebben uitgelijnd – optellen.Deze methode werkt ook op binaire getallen zoals blijkt uit Vergelijking (3.25):

1 0 1 1× 1 0 1

1 0 1 10 0 0 0

+ 1 0 1 11 1 0 1 1 1

(3.25)

Een groot voordeel van vermenigvuldigingen met binaire getallen is dat een cijfer slechts 1 of 0 kan zijn.Indien het 0 is tellen we niets op bij het resultaat; anders dienen we het bovenste getal op te tellen, in ditvoldoende naar links opgeschoven. Deze realisatie noemt men een parallelle vermenigvuldiger. Figuur 3.23toont enkele voorbeelden van parallelle vermenigvuldigers. Zo zien we het speciale geval van een 1 × 1-bit, wat neerkomt op een AND-poort. De 3 × 2-bit vermenigvuldiger toont een speciale realisatie van hetcascaderende effect: vermits er maar twee bits zijn, hebben we slechts een opteller nodig. Met behulp vanAND-poorten kunnen we ofwel 0 op de opteller plaatsen, of het getal zelf. Tot slot implementeren we ookhet algemeen geval van een m× n-vermenigvuldiger.

Naast parallelle vermenigvuldigers bestaan er ook andere implementaties die sneller werken en goedkoperte realiseren zijn. De kostprijs om een getal met m bits te vermenigvuldigen met een getal van n bits isimmers O (n ·m). Met een sequentiele schakeling kunnen we de kosten sterk reduceren en vaak zelfs devermenigvuldiging versnellen. Tot slot is het vermenigvuldigen met een macht van twee een speciaal gevalwat we kunnen bewerkstelligen met een schuifoperator. Deze schuifoperator komt aan bod in Subsectie 3.3.6.


a0

× b0a0b0

a0b0

a0 × b0

(a) 1× 1-bit

a2 a1 a0

× b1 b0a2b0 a1b0 a0b0

+ a2b1 a1b1 a0b1c4 c3 c2 c1 c0

HA2 FA1 HA0

b0

b1

c0c1c2c3c4

a0a1a2

(b) 3× 2-bit

x0x1. . .xn−1 y0y1. . .yn−1

s0s1. . .sn−1

c n-optellerm−1

x0x1. . .xn−1 y0y1. . .yn−1

s0s1. . .sn−1

c n-optellerm−3. . .

x0x1. . .xn−1 y0y1. . .yn−1

s0s1. . .sn−1

c n-opteller2

x0x1. . .xn−1 y0y1. . .yn−1

s0s1. . .sn−1

c n-opteller1

sm−1smsm+n−2sm+n−1

s1s2

. . .b1

a0a1an−1

. . .b2

a0a1an−1

. . .bm−2

a0a1an−1

. . .b0

0

a1a2

(c) n×m-bit

Figuur 3.23: Parallelle vermenigvuldigers.

2-complement vermenigvuldiger

Het uitbreiden van deze vermenigvuldiger naar gehele getallen met 2-complement voorstelling is geen sine-cure. In de praktijk zal men dan ook eerst de getallen omzetten naar sign-magnitude voorstelling alvorenswe de twee getallen vermenigvuldigen. In dat geval kunnen we de magnitude van de twee getallen vermenig-vuldigen – zoals we hierboven hebben gedemonstreerd – en passen we een XOR operatie toe op de tekenbitvan de getallen. Het resultaat zetten we vervolgens weer om naar 2-complement voorstelling. Er bestaatuiteraard wel een vermenigvuldiger voor een 2-complement voorstelling. Deze zullen we enkel op hoog niveaubeschrijven door middel van een voorbeeld. We rekenen hierbij −2 × −3 uit op 4-bit voorstelling en hetresultaat stellen we voor op een 8-bit voorstellingen zoals in onderstaande vergelijking:

−2× −3

+6

1110× 1101

00000110(3.26)


De oplossing bestaat eruit om −2 ≡ 11102 te zien in zijn binaire vorm als −8 + 4 + 2 = −2, bemerk hetminteken bij de 8. Elk van de bits dient afzonderlijk vermenigvuldigd te worden, en vervolgens opgeteld teworden zoals in onderstaande vermenigvuldiging:

2 × −3+ 4 × −3+ −8 × −3−2 × −3

⇒⇒⇒⇒

1111 1010+ 1111 0100+ 0001 1000

0000 0110

(3.27)

3.2.8 Andere courante bewerkingen

Om het gedeelte van de gehele getallen af te sluiten beschouwen we nog enkele populaire bewerkingen opde gehele getallen. We geven voor deze bewerkingen geen concrete implementatie, al kan de beschrijving ophoog niveau misschien volstaan om zelf een component hiervoor te ontwikkelen.

Delen

Analoog aan vermenigvuldigen kunnen we ook een deling in een binaire voorstelling gebaseerd op cijferen.We geven een voorbeeld van een binaire deling maar vermelden geen details over het realiseren van eenschakeling:

1011 1010 1110− 111 0000 1101

100 1010− 11 1000

1 0010− 0 0000

1 0010− 1110

100

(3.28)

Door herhaaldelijk het resterende deeltal te vergelijken met een verschuifde deler en indien deze groteris, deze af te trekken, kunnen we de rest en de het quotient berekenen. Het aantal cycli is dus ook tevenshet aantal bits van het quotient. Deze manier van implementatie is dan ook de meest populaire, meestal zalmen echter geen parallelle deler gebruiken. Indien we delen door een macht van twee, kunnen we het getalberekenen met een schuifoperatie (zie Subsectie 3.3.6).

Modulo rekenen

Een andere populaire berekening is modulo (ook wel bekend als mod ). Modulo-rekening is sterk gerela-teerd aan, maar niet equivalent aan remainder-rekenen (ofwel rem). We definieren de remainder als:

a rem b ≡ a− ba/bc · b (3.29)

De modulo-operatie daarentegen houdt rekening met het teken van zowel a als b:

a mod b ≡a rem b if a · b > 0(a rem b) + b if a · b < 0

(3.30)

Het gevolg is dat het resultaat van een modulo altijd positief is: tussen 0 en abs b− 1. Net als bij andereoperaties, is een modulo operatie met een macht van twee een speciaal geval: in dat geval kunnen we eenAND operatie uitvoeren op het getal en de macht gedecrementeerd. Bijvoorbeeld:

1653 mod 16 = 1653 AND 15 = 5 (3.31)


3.2.9 Vaste komma getallen

We zullen het getal verder uitbreiden naar getallen met vaste komma en later met getallen vlottende komma.In Subsectie 3.2.11 zullen we ten slotte nog andere voorstellingen van gegevens bespreken.

Vaste komma voorstelling (ofwel fixed point) lost het probleem van het zetten van een komma op,door gewoon een bit af te spreken waarna men een komma plaatst, deze positie staat vast. Er is dan ookgeen voorstelling van de komma zelf nodig. Indien we dus bijvoorbeeld een 8-bit getal beschouwen, kunnenwe de eerste vier bit voorstellen als het geheel deel, de overige vier bit behoren dan tot het fractionelegedeelte. Dit formaliseren we met de notatie fix 〈i, f〉 waarbij i het aantal bits voorstellen die tot hetgehele deel behoren, en f het aantal bits die men aan het fractionele gedeelte toekent. Zo stelt 11100102

in fix 〈4, 3〉, 14.25 voor. De eerste vier bits stellen immers binair het getal 14 voor, de laatste drie stellen2 voor, deze delen we vervolgens door 2f wat hier 23 is, bijgevolg heeft het komma-gedeelte de waarde:2/2f = 2/23 = 2/8 = 1/4 = 0.25.

Aantal bits voor fouteloze voorstelling

In de vorige secties hebben we al aandacht besteed aan het aantal bits die we moeten reserveren om deresultaten van bewerkingen zonder verlies te kunnen blijven voorstellen. Bij een optelling van vaste vastekomma getallen moet het resultaat voorgesteld worden op een vaste komma voorstelling waarbij we hetgeheel en fractioneelgedeelte voorstellen met het maximum aantal bits van de operanden. Bovendien dienenwe een bit toe te voegen aan het geheel gedeelte, ofwel formeler:

fix 〈i1, f1〉+ fix 〈i2, f2〉 = fix 〈max (i1, i2) + 1,max (f1, f2)〉 (3.32)

Wat we verder kunnen veralgemenen tot:

n∑k=1

fix 〈ik, fk〉 = fix

⟨dlog2 ne+

nmaxk=1

ik,n

maxk=1

fk

⟩(3.33)

Bij vermenigvuldigingen moeten we het aantal bits optellen van zowel het gehele als fractionele gedeelte:

fix 〈i1, f1〉 · fix 〈i2, f2〉 = fix 〈i1 + i2, f1 + f2〉 (3.34)

Of algemener:

n∏k=1

fix 〈ik, fk〉 = fix

⟨n∑k=1

ik,

n∑k=1

fk

⟩(3.35)

3.2.10 Vlottende komma getallen

Het kan voorkomen dat we niet weten tot welke grootorde een getal in kwestie zal behoren: het kan bijvoor-beeld tussen 0.000 000 001 en 1 000 000 000 liggen. In dat geval zouden we vaste kommagetallen met eengroot aantal bits kunnen gebruiken. Maar in de meeste gevallen zullen slechts een beperkt aantal bits nuttigblijken. In dit soort gevallen kan men beter een getal met vlottende komma voorstelling gebruiken, ookwel zwevendekommagetal, drijvendekommagetal of floating-point number genoemd. Vlottende kommagetallen worden voorgesteld door een sequentie van bits die in drie groepen worden onderverdeeld:

• sign-bit s ofwel tekenbit s: een bit die het teken van het getal bepaalt. De vlottende kommavoorstellingwerkt dus met de sign-magnitude voorstelling.

• exponent E: een getal die bepaalt met hoeveel plaatsen het getal moet worden opgeschoven. Dit deelwordt voorgesteld in het excess-formaat.

• mantisse M : het getal onafhankelijk van het schuiven van plaatsen. De voorstelling van een mantisseM met m bits is een fix 〈1,m− 1〉 vast komma getal.


Het getal dat we hierbij willen voorstellen is gelijk aan:

N = (−1)s ·mantisse · rexponent (3.36)

met radix r. Net als bij een vaste komma getal noteren we een familie van vlottende komma getallen metfloat 〈m, e〉 met m het aantal bits van de mantisse en e het aantal bits van de exponent. We maken ook eenonderscheid tussen twee families van vlottende komma voorstellingen:

• Genormaliseerde vlottende komma voorstelling: hierbij leggen we een extra voorwaarde op betref-fende de mantisse: 1 ≤ mantisse < r. In het geval van binaire notatie (r = 2) impliceert dit dus dat deeerste bit altijd 1 is. Daarom wordt in dat geval de eerste bit van de mantisse weggelaten: deze staater impliciet. In dat geval wordt de mantisse dus voorgesteld als fix 〈0,m〉, maar dient men altijd devirtuele bit 1 tot het gehele gedeelte te rekenen. Deze aanpassing maakt de voorstelling efficienter: deextra bit bij de mantisse bij het fractionele gedeelte drijft de precisie van het formaat op.

• Niet-genormaliseerde vlottende komma voorstelling: hierbij is de bovengenoemde beperking dus nietvan toepassing. Niet-genormaliseerde vlottende komma getallen kunnen meer getallen voorstellen danhun tegenhanger, omdat het geheel gedeelte op 0 kan worden gezet. Men betaalt hiervoor echter omdatvoor veel getallen er verschillende voorstellingen bestaan. Het gevolg is dat het implementeren vanbijvoorbeeld een vergelijker complexer wordt.

Underflow en overflow

Naast het eerder geıntroduceerde overflow – het niet voor te stellen van grote getallen – introduceert devlottende kommavoorstelling nog een bijkomend fenomeen: “ underflow”. Underflow treedt op op hetmoment dat een getal niet meer voorgesteld kan worden omdat de absolute waarde te klein geworden is.Figuur 3.24 geeft dit fenomeen schematisch weer van een single (zie volgende paragraaf).

≈ −2128 −2−149 2−149 ≈ 2128

underflow

Genormaliseerde vlottende komma

≈ −2128 −2−126 2−126 ≈ 2128

underflow

Niet-genormaliseerde vlottende komma

Figuur 3.24: Underflow van een vlottende komma voorstelling.

Op de figuur worden de getallen die we kunnen voorstellen gemarkeerd met de grijze zone. Bij genor-maliseerde vlottende komma getallen, kunnen we enkel getallen tussen −2128 en 2128 voorstellen. Tussen−2−149 en 2−149 kunnen we slechts een getal voorstellen: 0. Merk op dat de gemarkeerde zone niet continuis: we kunnen bijvoorbeeld constanten zoals π en e niet exact voorstellen, de nauwkeurigheid hangt af vanhet aantal bits in de mantisse.

IEEE-formaat voor vlottende komma getallen

Nu we de vlottende komma voorstelling algemeen beschreven hebben, introduceren we enkele concrete ge-talvoorstellingen met vlottende komma zoals voorgesteld door IEEE20. IEEE beschrijft hun floating pointgetallen in IEEE 754-198521[?]. Men maakt er een onderscheid tussen vlottende komma getallen met enkeleprecisie (32-bit en beter bekend onder de term float of single) en dubbele precisie (64-bit en beterbekend als double). Tabel 3.6(a) toont de verdeling van de beschikbare bits onder de mantisse en exponent.

Elk van deze formaten werkt natuurlijk met radix r = 2. IEEE 754-1985 vermeldt ook hoe een vlottendekomma moet worden uitgelezen. Tabel 3.6(b) geeft hierbij weer hoe we het getal moeten interpreterenafhankelijk van de waarde van de exponent E en mantisse M . Bovendien wordt bij de IEEE 754 een extravariabele ingevoerd: de excess-bias B. Tot op heden is B altijd B = 2e−1 − 1, en is de range van deexponent dus van −2e−1 + 2 tot 2e−1 − 1. Eventueel zou men later kunnen afwijken en bijvoorbeeld meer

20IEEE: Institute for Electrical and Electronics Engineers.21De opvolger van deze standaard is IEEE 754-2008[?]. In deze standaard worden ook halve en viervoudige precisie gedefini-

eerd.


(a) Bit-indeling

Precisie grootte e m B

float 32-bit 8 23 127double 64-bit 11 52 1023

(b) Getalvoorstelling

E = 0 0 < E < 2e − 1 E = 2e − 1

M = 0 0 (−1)s × 1.M × 2E−B (−1)

s ×∞M 6= 0 (−1)

s × 0.M × 21−B (−1)s × 1.M × 2E−B NaN

Tabel 3.7: IEEE 754-1985 Floating Point.

positieve exponenten dan negatieve kunnen toelaten. Men gebruikt de excess voorstelling omdat dit toelaattwee getallen met vlottende komma te vergelijken zoals we een geheel getal vergelijken. We dienen dusgeen aparte vergelijker te bouwen voor een vlottend kommagetal. Het formaat definieert ook enkele specialevariabelen:

• Nul (0): dit getal kan eigenlijk niet weergegeven worden met ons eerdere definitie van een genorma-liseerde vlottende komma. Nul is echter een nuttig getal bij het programmeren: om bijvoorbeeld eenneutrale optelling uit te voeren. De getalexperts bij Intel bedachten daarom de regel dat indien E = 0,we het getal in niet genormaliseerde getalvoorstelling zien. Op die manier wordt 0 dus wel mogelijk.

• Negatief oneindig −∞/ Positief oneindig +∞: Indien een operatie tot een overflow leidt, zal hetresultaat worden voorgesteld als oneindig. Indien de bewerking een teken heeft,kan men dit tekenook worden overgeerfd in het oneindig resultaat. Oneindig gedraagt zich ongeveer hetzelfde als zijnwiskundig equivalent: bijvoorbeeld het optellen van eender welk getal - behalve oneindig en NaN - metpositief oneindig, levert positief oneindig op.

• Not a Number (NaN): In tegenstelling tot gehele getallen die bij bijvoorbeeld een deling door nul eenfout22 veroorzaken, zullen ongeldige bewerkingen bij de vlottende kommavoorstelling van IEEE 754resulteren in NaN. We denken dan aan delen door nul, en het verschil van oneindig en oneindig en devierkantswortel van een negatief getal trekken.

In Tabel 3.6(b) zien we ten slotte ook dat enkele bits onderlijnd worden. Dit zijn de zogenaamde verborgenbits. Deze bits zijn geen onderdeel van de mantisse, maar dienen we er wel denkbeeldig aan toe te voegenom het getal te kunnen interpreteren.

Rekenen met vlottende komma

Het hierboven geıntroduceerde formaat is relatief complex. Het bouwen van optellers en andere bewerkingenvoor deze vlottende-komma voorstellingen is geen sinecure en valt buiten het bereik van deze cursus. Webespreken enkel op hoog niveau hoe we met deze getallen kunnen rekenen. De details kan men vinden in [?,§4]. Het is belangrijk te weten dat IEEE 754 enkel het formaat van vlottende getallen beschrijft. Wiskundigeoperaties behoren niet tot de standaard: het resultaat van bijvoorbeeld het optellen van twee vlottendekomma getallen staat niet vast. Het is dus mogelijk dat op de ene processor een sinus uitrekenen een lichtafwijkend resultaat zal opleveren tegenover het resultaat bij een andere processor. Intel heeft bijvoorbeeldgepatenteerde technologie waarbij men de operatoren eerst omzet naar een equivalent met grotere mantisseom meer precisie te garanderen. In de praktijk komt het er dus op neer dat IEEE 754 niet specificeert wathet resultaat moet zijn na een wiskundige bewerking.

22En een interrupt bij de meeste processoren.


Optelling Het optellen van twee vlottende komma getallen verloopt in drie stappen:

1. Eerst denormaliseren we de twee getallen door de exponenten gelijk te maken. Deze stap is geen sinecureomdat we bij dit proces zoveel mogelijk informatie willen blijven behouden: indien we dus enkel bij eenvan de twee getallen de exponent aanpassen, lopen we kans dat zijn mantisse alle informatie verliest.

2. Vervolgens tellen we de twee mantisses met elkaar op.

3. Het resultaat dienen we vervolgens weer te normaliseren: het is immers mogelijk dat het resultaatgroter is dan voorstellbaar op de mantisse (of kleiner) in dat geval passen we de exponent aan enschuiven we met de bits op de mantisse.

Vermenigvuldiging Vermenigvuldigen is bij vlottende komma simpeler dan optellen:

1. We vermenigvuldigen de mantisse zoals we dit hebben gedaan bij vermenigvuldigen van natuurlijkegetallen. We passen een XOR-operatie toe op de tekenbit van de twee getallen, en we tellen deexponenten met elkaar op23.

2. We normaliseren het resultaat. Dit betekent dat ofwel de exponent hetzelfde blijft, ofwel met een moetworden opgehoogd.

3.2.11 Andere voorstellingen van gegevens

Naast de hierboven beschreven voorstellingen voor natuurlijke-, gehele- en kommagetallen bestaan er nogeen groot aantal andere voorstellingen. We stellen niet noodzakelijk getallen voor, maar tekst, beelden,geluid, enzovoort. We stellen er in deze subsectie twee voor: Binary Coded Decimal (BCD) is eenalternatief formaat om natuurlijke getallen voor te stellen. Dit kan eventueel uitgebreid worden tot gehele-en kommagetallen. De American Standard Code for Information Interchange (ASCII) is een formaat dathoofdzakelijk bedoeld is om tekst op te slaan.

Binary Coded Decimal (BCD)

In de vorige subsecties hebben we geen aandacht besteed aan het omzetten van een getal naar tekst. Dezeomzetting is vrij arbeidsintensief en kost dus ook veel hardware. Bovendien stuiten we op nog een probleem:heel wat decimale kommagetallen kunnen niet voorgesteld worden in het binair getalstelsel. Zo bestaat ergeen enkel binaire voorstelling voor 0.3. In dat geval moeten we het getal zo goed mogelijk benaderen24. Eenoplossing voor deze twee problemen is het Binary Coded Decimal (BCD) systeem. We kunnen immers elkdecimaal cijfer voorstellen met 4-bit. Bijgevolg kunnen we een decimaal getal voorstellen, door voor iedercijfer van de decimale voorstelling zijn binair equivalent om te zetten. Dit betekent dus dat we een decimaalgetal met n cijfers voorstellen met 4 · n bit. Elk van deze groepen bits kan dus alleen waardes van 0 tot9 aannemen. Bijvoorbeeld: 142510 = 0101 1001 00012 = 0001 0100 0010 0101BCD. Een nadeel van BCDvoorstelling is dat de meeste bewerkingen complexer worden. Tabel 3.8 toont de omzetting van een decimaalcijfer naar het BCD equivalent.

Bewerkingen met BCD Ter illustratie zullen we tonen hoe we een opteller kunnen realiseren voor hetBCD formaat. Hierbij streven we niet zozeer naar een minimale implementatie, maar tonen we dat eenoptelling complexer is tegenover zijn binair equivalent. Bij een optelling dienen we immers elke decimaalafzonderlijk op te tellen. Net zoals een half- en full adder bit per bit optelden, dienen we nu per decimaaleen 4-bit opteller te realiseren. Indien het resultaat van deze optelling bovendien groter is dan 9, dienenwe dit resultaat verder aan te passen: we trekken er 10 vanaf en we geven overdacht (carry) door. Bij deaftrekking hebben we dus nogmaals een 4-bit opteller nodig. We dienen ook een component te realiseren datcontroleert of het eerste resultaat groter is dan 9. Deze component heeft niet alleen een carry als uitgang,

23Optellen bij het excess-formaat verloopt anders, we dienen immers eenmaal de excess-bias van de som af te trekken.24Het is echter niet omdat het binair stelsel er niet in slaagt om alle decimale getallen voor te stellen dat het minder accuraat

is, integendeel: het binair stelsel is accurater.

3.3. ANDERE BASISSCHAKELINGEN 81

Dec. BCD Dec. BCD

0 0000 5 01011 0001 6 01102 0010 7 01113 0011 8 10004 0100 9 1000

Tabel 3.8: Decimale cijfers en hun BCD equivalent.

x0x1x2x3 y0y1y2y3

s0s1s2s34-bit opteller

x0x1x2x3 y0y1y2y3

s0s1s2s34-bit opteller

ci

0 0co

> 9

c

z0z1

z2z3

x0x1x2x3 y0y1y2y3

s0s1s2s3

(a) Schematische voorstelling

co

c

z3

z2

z1 z1

z0 z0

0 0 0 0

0 0 0 0

1 1 1 1

0 1 1 0

11-1

----

----

----

(b) Karnaugh-kaart

c

z0

z1

z2z3

co

(c) Implementatie ver-gelijker

Figuur 3.25: Mogelijke implementatie van een BCD opteller.

maar moet ook invoer genereren voor de tweede opteller. Indien het eerste resultaat immers groter is dan9, tellen we er nog eens 6 bij op. Dit betekent dat bij een tussenresultaat van 10, de tweede opteller tot 16komt wat dus gebaseerd op de laatste 4 bits in 0 resulteert. Figuur 3.25(a) toont schematisch hoe we tweedecimale cijfers kunnen optellen. Indien we deze structuur voor ieder cijfer herhalen, realiseren we een BCDopteller. De vergelijker synthetiseren we met behulp van Karnaugh-kaarten zoals op Figuur 3.25(b). Merkop dat het resultaat van de eerste opteller hoogstens 18 is, en we dus voor de andere waarden don’t careskunnen gebruiken. Een mogelijke synthese van deze vergelijker staat op Figuur 3.25(c). Tot slot merken weop dat we bij het bepalen van het negatieve getal van een BCD niet het 2-complement moeten berekenen,maar het 10-complement. Ook deze stap vereist extra hardware.

American Standard Code for Information Interchange (ASCII)

Een standaard om tekst voor te stellen is de American Standard Code for Information Interchange (ASCII).ASCII reserveert 7 bit per karakter in de tekst. Deze zeven bit zorgen dus voor 128 mogelijke karakters. Dekarakterset bestaat uit de Romaanse letters, Arabische cijfers, diverse leestekens en enkele functiesymbolen.De toewijzing van deze symbolen vertoont enige logica. Zo is het bijvoorbeeld eenvoudig om kleine lettersom te zetten naar de equivalente hoofdletter, of bijvoorbeeld binaire getallen in hun ASCII equivalent.Tabel 3.9 toont de ASCII-karakters met hun bijbehorende binaire code. ASCII bevat geen ondersteuningvoor karakters in het Cyrillische en Arabische geschrift. Unicode is een standaard die 8, 16 of 32 bit perkarakter reserveert om dit probleem op te lossen. Anno 2011 is 11% van de binaire waarden toegewezen.

3.3 Andere basisschakelingen

Naast de rekenkundige schakelingen in Sectie 3.2 zullen we in schema’s ook geregeld enkele andere bouw-stenen terugvinden. In deze sectie zullen we de meest voornaamste bespreken: In Subsectie 3.3.1 besprekenwe de multiplexer. Daarna bespreken we in Subsectie 3.3.2 en Subsectie 3.3.3 twee verwante bouwstenen:de decoder en demultiplexer. Het omgekeerde van de decoder, de encoder behandelen we in Subsectie 3.3.4.We eindigen met de vergelijker in Subsectie 3.3.5 en de reeds aangehaalde schuifoperatie in subsectie Sub-


000 001 010 011 100 101 110 1110000 NUL DLE SP 0 @ P ‘ p

0001 SOH DC1 ! 1 A Q a q

0010 STX DC2 " 2 B R b r

0011 ETX DC3 # 3 C S c s

0100 EOT DC4 $ 4 D T d t

0101 ENQ NAK % 5 E U e u

0110 ACK SYN & 6 F V f v

0111 BEL ETB ’ 7 G W g w

1000 BS CAN ( 8 H X h x

1001 HT EM ) 9 I Y i y

1010 LF SUB * : J Z j z

1011 VT ESC + ; K [ k

1100 FF FS , < L \ l |

1101 CR GS - = M ] m

1110 SO RS . > N ^ n ~

1111 SI US / ? O _ o DEL

Tabel 3.9: ASCII standaard.

sectie 3.3.6.

3.3.1 Multiplexer

Een multiplexer, selector of MUX is een component die bij n selectie-ingangen si en 2n data-ingangendi heeft en een uitgang f . Een multiplexer zet de waarde van de data-ingang dS met index S op de uitgang.Hierbij is S de binaire waarde die wordt voorgesteld door de selectie-ingangen si. In een blokschema wordtdeze component voorgesteld door een trapezium waarbij de data-ingangen aan de lange zijde staan, deuitgangen aan de korte zijde, en de selectie-ingangen aan een van de schuine zijden zoals op Figuur 3.26(a).Deze figuur toont een 4-naar-1 MUX. Eventueel worden aan de andere kant ook uitgangen toegevoegd, dezezijn identiek aan de selectie-ingangen aan de ene kant en dienen enkel om het blokschema overzichtelijker temaken. Figuur 3.26(b) en Figuur 3.26(c) tonen respectievelijk de eerder informeel besproken waarheidstabelen een mogelijke implementatie van deze component.

Multiplexers worden gebruikt wanneer we de keuze hebben tussen twee bronnen en we - afhankelijk vaneen bepaald criterium - een van de twee bronnen moeten doorgeven aan een ander component.

Cascade

Voor elke willekeurige n kunnen we dus een 2n-naar-1 multiplexer bouwen. Een fabrikant zal meestalechter voor een beperkt aantal waarden voor n een multiplexer bouwen, immers wenst men dit te doenin massaproductie. Daarom zal men veelal met een cascade werken. Figuur 3.26(d) toont een 16-naar-1MUX gebouwd met behulp van vijf 4-naar-1 multiplexers. We kunnen dit uiteraard veralgemenen: Indienwe een 2n×m-naar-1 multiplexer willen bouwen, kunnen we dit met n niveaus van 2m-naar-1 multiplexers.Het aantal multiplexers die we in dat geval nodig hebben is:

aantal multiplexers =2n·m − 1

2m − 1(3.37)

3.3.2 Decoder

Een andere schakeling die sterk gerelateerd is aan een multiplexer is een decoder. Een decoder beschiktover een enable-ingang e, en n adres-ingangen ai. De uitvoer bestaat uit 2n selectie-uitgangen si. Eendecoder zal, indien er een 1 aangelegd wordt op de enable-ingang e, een 1 op de selectie-uitgang sA zetten metindex A. Hierbij staat A voor de binaire waarde die voorgesteld wordt door de adres-ingangen ai, alle overige


s0

s1s0

s1

f

d0d1d2d3

(a) Interface

s0 s1 f0 0 d0

0 1 d1

1 0 d2

1 1 d3

(b) Waarheidstabel

f

d0d1d2d3

s1

s0

s1

s0

(c) Mogelijke Implementatie

s3s2

f

d0d1d2d3d4d5d6d7d8d9d10d11d12d13d14d15

s1s0

(d) Cascade

Figuur 3.26: Multiplexer.

selectie-uitgangen si zijn dan 0. Wanneer bovendien op de enable-ingang e een 0 wordt gezet, zullen alleselectie-uitgangen si op 0 staan. In een blokschema wordt een decoder voorgesteld zoals op Figuur 3.27(a)door een rechthoek. In dit geval een 2-naar-4 decoder. Bovenaan staan de adres-ingangen ai, aan de zijkantde enable-ingang e, en onderaan de uitgangen si.

Op Figuur 3.27(b) staat de waarheidstabel voor deze component. Figuur 3.27(c) toont een mogelijkeimplementatie. Decoders worden hoofdzakelijk gebruikt voor het decoderen van adressen. Dit is nuttig bijgeheugens zoals register-banken en RAM-geheugens.

Cascade

Net als bij multiplexer kunnen we, in plaats van een heel arsenaal aan decoders aan te bieden, door middelvan een cascade een nieuwe decoder bouwen, zoals op Figuur 3.27(d). Hier bouwen we een 4-naar-16 decodermet vijf 2-naar-4 decoders. In het algemeen kunnen we een n ·m-naar-2n·m decoder bouwen met n niveausvan m-naar-2m decoders. In totaal hebben we dus volgend aantal decoders nodig:

aantal decoders =2n·m − 1

2m − 1(3.38)

Alternatieve implementatie voor multiplexers

Decoders worden soms gebruikt bij de synthese van bijvoorbeeld multiplexers. Figuur 3.28(a) toont eenmanier om op basis van AND-poorten en een decoder een multiplexer te bouwen. Een alternatief waarbijwe de OR-poort weglaten en de AND-poorten vervangen door 3-state buffers zoals is te realiseren zoalsop Figuur 3.28(b). In dat geval hebben we een schakeling gerealiseerd die we een bus noemen. Bussenzijn multiplexers waarbij we toelaten dat de ingangen gedistribueerd zijn over de verschillende delen van deschakeling. Elk van deze ingangen dienen we eenvoudigweg een uitgang van de decoder toe toe te wijzen, ende uitgang met een 3-state buffer verbinden met de bus. Bussen hebben verschillende voordelen:

• We kunnen makkelijk het aantal ingangen uitbreiden. We dienen enkel over een decoder met voldoendegrote n te beschikken en een tri-state buffer per ingang;


Decodere

s0s1s2s3

a0a1

(a) Interface

e a0 a1 s0 s1 s2 s3

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

(b) Waarheidstabel

Decoders0s1s2s3

a0a1

e

(c) Mogelijke implementatie

Decoder

a2a3

e

Decoder

a0a1

Decoder

a0a1

Decoder

a0a1

Decoder

a0a1

s0s1s2s3s4s5s6s7s8s9s10s11s12s13s14s15

(d) Cascade

Figuur 3.27: Decoder.

• indien we de traditionele multiplexer gebruiken zal bij een groot aantal ingangen de fan-in van deOR-poort toenemen. Bovendien moeten alle ingangen van de multiplexer dicht bij elkaar staan; en

• tri-state buffers zijn meestal gratis op een FPGA. Elke logisch blok (LB) heeft immers minstens eenuitgang langs een tri-state buffer die verbonden is met een lange lijn.

Dec

od

er

1

f

d0d1d2d3

s1

s0

(a) Muliplexer

Dec

od

er

1 bus

f

d0d1d2d3

s1

s0

(b) Bus

Figuur 3.28: Multiplexer en bus gesynthetiseerd met decoders.

3.3.3 Demultiplexer

Het inverse van een 2n-naar-1 multiplexer is een 1-naar-2n demultiplexer (ook wel demux genoemd). Dezecomponent bestaat dan ook logischerwijs uit een data-ingang d en n selectie-ingangen ai. De componentbeschikt verder over 2n uitgangen si. Logischerwijs zetten we de waarde van de data-ingang d op de uitgangsA met de index A die binair wordt voorgesteld door de selectie-ingangen ai. Een aandachtige lezer zalmisschien al opgemerkt hebben dat dit probleem in wezen niet veel verschilt van de constructie van eendecoder. Sterker nog, we hoeven geen nieuw component te ontwerpen. Een demultiplexer is een decoder,maar met een andere interface. Figuur 3.29 toont de interface van een demultiplexer en de equivalentie meteen decoder. In tegenstelling tot de decoder zetten we de selectie-ingangen aan de zijkant en de data-ingang


aan de bovenkant. Meestal zullen we ook specifiek andere “taken” toekennen aan een demultiplexer tegenovereen decoder, maar achter de schermen werken we met dezelfde logica.

Demuxa0

a1

s0s1s2s3

d

≡ Decoder

a0a1

s0s1s2s3

d

Figuur 3.29: Demultiplexer

Demultiplexers worden maar zeer zelden gebruikt, kun doel is immers om data op een bepaalde lijn teplaatsen, terwijl men op de andere lijnen een 0 aanlegt. In de praktijk is het aanleggen van de data op allelijnen meestal geen probleem. In dat geval kunnen we dus de demultiplexer eenvoudigweg vervangen dooreen draad die de data-ingang met alle uitgangen verbindt.

3.3.4 Encoder en prioriteitsencoder

Ook de decoder heeft een inverse: een 2n-naar-n encoder. Een encoder bevat 2n data-ingangen di, een any-uitgang a en n selectie-uitgangen si. Het is de bedoeling dat de encoder, afhankelijk van de data-ingangwaarop een 1 staat, de index van deze data-ingangg weergeeft op de selectie-uitgangen fi. De any-uitgangis 1 op het moment dat er een data-ingang de waarde 1 heeft, en 0 indien er op geen enkele data-ingang een1 staat. We kunnen dit gedrag samenvatten in een waarheidstabel zoals in Tabel 3.9(a) voor een 4-naar-2encoder.

(a) Encoder

d3 d2 d1 d0 a f1 f0

0 0 0 0 0 - -0 0 0 1 1 0 00 0 1 0 1 0 10 1 0 0 1 1 01 0 0 0 1 1 1- - - - - - -

(b) Prioriteitsencoder

d3 d2 d1 d0 a f1 f0

0 0 0 0 0 - -0 0 0 1 1 0 00 0 1 - 1 0 10 1 - - 1 1 01 - - - 1 1 1

Tabel 3.10: Waarheidtabellen van een encoder en prioriteitsencoder.

Merk op dat de tabel niet alle strikt mogelijke ingangen toont. We nemen aan dat aan de ingangen enkelgeldige configuraties verschijnen. Indien dit niet zo is, staat het in principe vrij om te kiezen wat er op deuitgangen verschijnt. De ontbrekende rijen bevatten dus don’t cares op alle uitgangen. Op basis van dezetabel kunnen we eventueel Karnaugh-kaarten maken en een implementatie voorstellen: a = d3 + d2 + d1 + d0

f1 = d3 + d1

f0 = d3 + d2

(3.39)

We kunnen deze schakeling dus eenvoudig realiseren met een OR-poort per uitgang.

Prioriteitsencoder Een variant van de encoder is de prioriteitsencoder. Een prioriteitsencoder biedt eenantwoord op de ongeldige ingangen van de encoder. Hierbij telt niet de index van de data-ingang waaropeen 1 wordt aangelegd, maar de hoogste index van alle data-ingangen met 1. Tabel 3.9(b) formaliseert dit.Deze schakeling kunnen we dan als volgt implementeren:


a = d3 + d2 + d1 + d0

f1 = d3 + d′2d1

f0 = d3 + d2

(3.40)

Dit komt overeen met een extra AND- en NOT-poort. De interface voor beide schakelingen staat be-schreven op Figuur 3.30(a).

Encoder

d0d1d2d3

f0f1

aPrioriteits-encoder

d0d1d2d3

f0f1

a

(a) Interfaces

Prioriteits-encoder

Prioriteits-encoder

Prioriteits-encoder

Prioriteits-encoder

Prioriteits-encoder

d0d1d2d3d4d5d6d7d8d9d10d11d12d13d14d15

a

f3 f2 f1 f0

(b) Cascade

Figuur 3.30: Encoder en Prioriteitsencoder.

De interface is opnieuw een rechthoek. De data-ingangen staan bovenaan, de selectie-uitgangen onderaan,en de any-uitgang aan de linkerkant.

Prioriteitsencoders cascaderen

Ook bij prioriteitsencoders gaan we even in het op het cascaderend karakter. Ook encoders laten zicheenvoudig cascaderen, mits we ook extra multiplexers gebruiken. In Figuur 3.30(b) bouwen we een 16-naar-4prioriteitsencoder met vier 4-naar-2 prioriteitsencoders en twee 4-naar-1 multiplexers.

3.3.5 Vergelijker

Een vergelijker of comparator is een component die in staat is om uitspraken te doen over hoe twee getallenzich tot elkaar verhouden. Meestal is een vergelijker in staat om een uitspraak te doen over vier mogelijkeverhoudingen van de getallen X en Y :

X < YX > YX = YX 6= Y

(3.41)


Op basis van de eerste twee relaties, kunnen we uitspraken doen over de laatste twee25. We kunnen duseen component bouwen die enkel de eerste twee uitspraken naagaat. Een comparator bevat 4 ingangen (x0

ofwel gin, y0 ofwel lin, x1 en y1). De twee uitgangen (g en l) geven respectievelijk weer of het getal X > Yen X < Y . Figuur 3.31(a) toont de interface van een vergelijker.

Compx0/gin

y0/lin

x1 y1

g

l

(a) Interface

g

x1

y1

x0

y0

0 1 0 0

0 0 0 0

0 1 0 0

1 1 1 1

l

x1

y1

x0

y0

0 0 0 1

1 1 1 1

0 0 0 1

0 0 0 0


Comp

x1 y1

Comp

x2 y2

Comp

x3 y3

Comp

x4 y4

Comp

x5 y5

Comp

x6 y6

Comp

x7 y7 x0 y0

g

l

(c) Lineare cascade

Comp

x1 y1

Comp

x3 y3

Comp

x5 y5

Comp

x7 y7 x0 y0x2 y2x4 y4x6 y6

CompComp

Compg

l

(d) Hierarchische cascade

Figuur 3.31: Vergelijker

Op basis van de gedragsbeschrijving kunnen we een waarheidstabel en Karnaugh-kaarten opstellen zoalsop Figuur 3.31(b). Op basis van deze kaarten synthetiseren we volgende formules26:

g = x1y′1 + x0x1y

′0 + x0y

′0y′1

l = x′1y1 + x′0x′1y0 + x′0y0y1

(3.42)

Vergelijkers cascaderen

Deze vergelijker vergelijkt enkel getallen die uit twee bits bestaan. In de praktijk is dit niet nuttig. Netals bij een opteller zullen we echter een methode uitwerken om met deze bouwstenen grotere getallen tevergelijken. Net als bij een ripple-carry opteller, kunnen we door verschillende vergelijkers aan elkaar teschakelen, een vergelijker met een groter aantal bits bouwen. In dat geval bekomen we een structuur zoalsop Figuur 3.31(c). Zonder deze schakeling in detail te bestuderen komen we echter tot hetzelfde probleemals bij een ripple-carry opteller: de vertraging schaalt linear met het aantal bits, wat voor getallen met eengroot aantal bits onaanvaardbaar is. We kunnen de vergelijkers echter ook in een hierarchische structuurorganiseren, waardoor we de vertraging beperken tot een logaritmische orde zoals op Figuur 3.31(d). Merk

25Een getal X is niet gelijk aan een getal Y indien X < Y of X > Y .26Merk de dualiteit op: beide formules hebben dezelfde variabelen, alleen zijn alle atomen geınverteerd.


op dat we eenzelfde hoeveelheid hardware gebruiken. Deze schakeling laat echter toe om verschillende delenvan het getal tegelijk te vergelijken.

Speciale gevallen

Testen op gelijkheid We kunnen twee getallen altijd vergelijken met een vergelijker zoals eerder beschre-ven. Soms willen we echter een of twee getallen testen op specifieke eigenschappen, bijvoorbeeld of tweegetallen gelijk zijn. Dit kunnen we natuurlijk realiseren met een vergelijker, maar dit introduceert extrahardware en vertraging. In het geval van gelijkheid kunnen we dan ook gebruik maken van een rij vanXNOR-poorten waarbij elke poort een bit van het ene en een bit van het andere getal als invoer krijgt. Deuitgangen van al deze XNOR-poorten vormen vervolgens de invoer voor een AND-poort gaan. De uitvoervan deze AND poort toont ons dan of X gelijk is aan Y . Figuur 3.32(a) toont een realisatie van dit conceptvoor twee n-bit getallen.

. . .

X = Y

y0x0y1x1y2x2y3x3y4x4yn−1xn−1

(a) Gelijkheid

X = 0

X = 2n − 1

x0 even (X)

x0

x0

x1

x1

x2

x2

. . .

. . .

xn−1

xn−1

X ≥ 2k

X < 2n − 2k

x0 oneven (X)

xk

xk

xk+1

xk+1

xk+2

xk+2

. . .

. . .

xn−1

xn−1

(b) Testen met constanten

Figuur 3.32: Speciale gevallen van vergelijkers

Vergelijken met constanten We willen een getal niet altijd vergelijken met andere getal, maar soms meteen constante. In dat geval zouden we natuurlijk ook van de vergelijker kunnen gebruikmaken, en de Y zelfsamenstellen. Aangezien Y echter op voorhand gekend is spreekt het voor zichzelf dat we de implementatieechter grondig kunnen verbeteren. Bovendien kunnen we ook testen ontwerpen die we niet kunnen uitvoerenmet een vergelijker27. Dergelijke componenten kunnen bouwen getuigt ook van enig inzicht. Alle specialegevallen beschouwen is moeilijk. Op Figuur 3.32(b) geven we enkele voorbeelden. Deze opsommig is verrevan exhaustief en het verklaren van deze schakelingen wordt aan de lezer overgelaten.

3.3.6 Schuifoperator

Een laatste set van operaties die vaak gebruikt wordt zijn schuifoperaties. Vele processoren implementerenschuifoperaties. Een ARM processor laat bijvoorbeeld toe om tijdens elke operatie de operand over enkeleplaatsen te schuiven.

Er bestaan verschillende vormen van schuifoperaties, Daarom zullen we in deze paragraaf eerst de ver-schillende varianten bespreken. In het algemeen houdt een schuifoperatie in dat de waarde van de bit dieeerst op plaats i stond, nu op een plaats i+m staat. Of formeler: Y is het resultaat van een schuifoperatievan X over m plaatsen naar links indien

∀i ∈ N : i ∈ [0, n] ∧ i+m ∈ [0, n]⇒ yi+m = xi (3.43)

De definitie toont al dat i en i+m beide binnen het bereik moeten liggen. Wat we doen met de bits diebuiten de grenzen vallen, en met wat we de nieuwe plaatsen opvullen, wordt niet door Vergelijking (3.43)

27Bijvoorbeeld deelbaarheid door 2.


gespecificeerd. Een tweede opmerking is dat m ook negatief kan zijn, in dat geval voeren we een schuifoperatienaar rechts uit. Voor dit probleem bestaan er drie populaire oplossingen, de varianten van de schuifoperaties.

• Bij het schuiven negeren we de bits die buiten de grenzen vallen. Er bestaan twee vormen van schuivendie varieren in wat we op de vrijgekomen plaatsen zetten:

– Logisch schuiven: indien we logisch schuiven hebben we een extra parameter nodig, namelijkwelke waarde we op de nieuwe plaatsen zetten. Soms is dit zelfs een rij van bits. We maken dusde invoer groot genoeg om geen vrije plaatsen meer over te houden. Logisch schuiven wordt in deC/C++/Java taalfamilies vaak voorgesteld met de operatoren <<< en >>>.

– Aritmetisch schuiven: hierbij willen we eigenlijk een wiskundige functie realiseren namelijk ver-menigvuldigen of delen met een macht van 2. Hoe we dus aritmetisch schuiven hangt vooral afvan de getalvoorstelling. Indien we naar links schuiven betekent dit meestal dat we de nieuweplaatsen vullen met nullen. Indien we naar rechts schuiven zal bij een 2-complement voorstellingde hoogste bit (MSB) van het originele getal ingevoegd worden. Bij een “unsigned” voorstellingvullen we de vrije plaatsen ook met nullen op. Aritmetisch schuiven is vrij populair in program-meertalen. Programmeertalen die tot de C/C++/Java taalfamilie behoren, introduceren daarom2 functies: voor links (<<) en rechts (>>) aritmetisch schuiven deze worden gedefinieerd als:

X<<M ≡ X × 2M

X>>M ≡ X ÷ 2M(3.44)

Men kan meestal niet schuiven met een negatieve M . De richting van schuiven dient men dus opvoorhand te kennen.

• Bij het roteren vangen we de bits op die er langs een kant afvallen en plaatsen we deze op devrijgekomen plaatsen aan de andere kant.

Implementatie van schuifoperaties

In deze subsubsectie zullen we twee schakelingen realiseren. De eerste is een component die alle schuifopera-ties kan realiseren op 4-bit getallen, maar slechts over een plaats naar links of rechts. Het tweede componentis 8-bit barrel left rotator. Dit component roteert 8-bit getallen naar links over een variabel aantal plaatsen.Merk op dat het bij een rotatie het eigenlijk niet uitmaakt in welke richting we roteren: een n-bit getal mplaatsen naar links roteren is net hetzelfde als het getal n −m plaatsen naar rechts roteren. Deze tweedecomponent illustreert verder hoe we schuifoperaties efficient over meerdere posities kunnen uitvoeren.

Schuifoperaties over 1 bit Indien we een component maken die meerdere operaties kan uitvoeren moetenwe altijd eerst een instructieset definieren, net zoals we dat ook deden in in Subsubsectie 3.2.6. De instruc-tieset dient zowel een onderscheid te maken tussen schuiven of roteren, aritmetisch of logisch28 en links ofrechts. Verder willen we ook een bit voorzien die aangeeft of er uberhaupt een schuifoperatie moet wordenuitgevoerd: een soort enable-ingang. We zullen dus een 4-bit instructieset gebruiken. Tabel 3.11 toont debetekenis van elke bit. Op basis van deze instructieset kunnen we nu een component bouwen. Voor de

Signaal 0 1

s3 geen schuifoperatie schuifoperaties2 links rechtss1 schuiven roterens0 aritmetisch logisch

Tabel 3.11: Instructieset voor de schuifoperaties over 1 bit.

berekening van de uitgangsbits gebruiken we multiplexers. Immers kan elke uitgang yi maar drie mogelijke

28Enkel in geval van schuiven is dit relevant.


uitgangen hebben: xi−1, xi en xi+1. Bij de uitgangen aan de rand dienen we alleen een andere interpretatievoor sommige xj te vinden. Welke van deze drie ingangen we kiezen hangt verder alleen af van twee bits uithet instructiewoord: s3 en s2. In het geval dat s3 = 0 geldt yi = xi. Bijgevolg zetten we xi zowel op de d0

en d1 ingang van de multiplexer voor yi. Indien s3 = 1 en s2 = 0 schuiven we naar links. We zetten dus xi+1

en xi−1 respectievelijk op de d2 en d3 ingangen. Tot slot dienen we nog de randgevallen op te lossen. Dezerandgevallen beslaan enkel xi+1 voor y3 en xi−1 voor y0. Deze waarden zullen we respectievelijk noteren alsx4 en x−1 en vallen dus buiten de grenzen van de ingangen. In geval van rotatie geldt:

x−1 = x3

x4 = x0(rotatie) (3.45)

Dit dwingen we af met twee 2-naar-1 multiplexers. Deze multiplexers hebben als schakelelement instruc-tiebit s1. We dienen nu enkel nog het geval te behandelen waarin we schuiven. Indien we logisch schuiven,schuiven we de bits Lin en Rin in. Bij arithmetisch zullen we aan de rechterzijde een 0 inschuiven. Aan delinkerkant is dit ook het geval tenzij we schuiven met een 2-complement voorstelling. In dat laatste gevalbepaalt de hoogste bit immers ook het teken van het getal. In dat geval moeten we de waarde van de hoogstebit dus nogmaals inschuiven. We kunnen bovenstaande beschrijvingen formaliseren tot volgende formules:

x−1 = Rin

x4 = Lin

(schuiven, aritmetisch)

x−1 = 0x4 = 0

(schuiven, logisch, unsigned)

x−1 = 0x4 = x3

(schuiven, logisch, 2-complement)

(3.46)

Deze logica kunnen we vervolgens implementeren met OR-AND-poorten. Het resultaat van deze volledigeimplementatie staat op Figuur 3.33.

y0

x0

y1

x1

y2

x2

y3

x3

s1

s2

s3

Rin

s0

Lin 2-co

mp

Figuur 3.33: Implementatie van een schuifoperator over 1 bit.

8-bit barrel left rotator In de vorige paragraaf hebben we een schuifoperator gebouwd die over 1 bitkan schuiven. Door verschillende van deze schuifoperatoren na elkaar te plaatsen kunnen we schuiven overmeerdere plaatsen. Toch is dit niet erg praktisch: om m plaatsen te schuiven zouden we m van dezeschuifoperatoren na elkaar moeten plaatsen, wat grote vertragingen zou impliceren. In deze paragraaf zullenwe een rotator bouwen die de vertraging beperkt tot log2m, met m het maximaal aantal plaatsen dat kanopgeschoven worden. Het concept is toepasbaar op algemene schuifoperaties, dus ook bijvoorbeeld logischschuiven. Figuur 3.34 geeft het concept weer.


s0

s1

s2

x0

y0

x1

y1

x2

y2

x3

y3

x4

y4

x5

y5

x6

y6

x7

y7

Figuur 3.34: Implementatie van een 8-bit barrel left rotator.

Deze barrel left rotator is gebaseerd op het additief principe. Het additief principe stelt dat indien we eengetal willen schuiven of roteren over m bits, we dit ook kunnen verwezenlijken door eerst te schuiven/roterenover m1 bits en vervolgens over m2 bits met m = m1 + m2. Indien we onze rotator bouwen volgens eenstructuur waarbij elke niveau i een rotatie uitvoert over 2i plaatsen kunnen we elke rotatie-operatie uitvoeren.Gedurende dit hoofdstuk hebben we immers alle getallen binair kunnen voorstellen. Op Figuur 3.34 zien wedat het niveau s2, vier plaatsen naar links roteert. Het volgende niveau twee en het laatste een. Elk van dezeniveaus heeft dezelfde vertraging. Indien we dus een n-bit barrel left rotator willen bouwen die maximaalm plaatsen kan opschuiven moeten we dus dlog2me niveaus synthetiseren. Een niveau i roteert 2i plaatsenvoor ∀i = 0, 1, . . . , dlog2me− 1. Dit concept is eenvoudig te veralgemenen naar een volledige schuifoperator.Merk op dat het aantal niveaus dus theoretisch niet afhangt van het aantal bit in het getal. Op de meesteprocessoren neemt men echter m = n. Een andere mooie eigenschap is dat de volgorde van de niveaus nietrelevant is.

Hoofdstuk 4

Sequentiele Schakelingen(Schakelingen met geheugen)

We denken dat sommige mensen intelligent zijn, terwijl ze al-leen maar een goed geheugen hebben.“

”- Frederic Dard, Frans humoristisch schrijver (1921-2000)

In het vorige hoofdstuk hebben we combinatorische schakelingen ge-bouwd: schakelingen waarbij de waardes op de uitgangen enkel af-hangen van de waardes die op de ingangen staan. Bij de meesteschakelingen is er echter sprake van geheugen: een component dieeen toestand kan bijhouden. Afhankelijk van de invoer verandert detoestand en de uitvoer hangt af van de toestand van het componenten de waardes die op de ingangen staan. In dit hoofstuk introduce-ren we hier eerst de nodige terminologie voor waarna we een reekscomponenten ontwikkelen om gegevens op te slaan. Daarna bespre-ken we hoe we componenten met geheugen kunnen ontwerpen. Wemaken hierbij een onderscheid tussen synchrone sequentiele schake-lingen: schakelingen met een klok, en asynchrone sequentiele scha-kelingen: schakelingen waarbij een verandering aan de invoer deoorzaak is van de verandering van toestand.

4.1 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4.1.1 Classificatie van sequentiele schakelingen . . . . . . . . . . . . . . . . . . . . . . . . 95

4.1.2 Terminologie van het kloksignaal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

4.2 Bouwblokken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

4.2.1 De flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

De latch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

De flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

Types flipflops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

4.2.2 Registers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

4.2.3 Tellers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104

93

94 HOOFDSTUK 4. SEQUENTIELE SCHAKELINGEN (SCHAKELINGEN MET GEHEUGEN)

4.3 Synchrone schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

4.3.1 Leidende voorbeelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

4.3.2 Stap 1: opstellen van het toestandsdiagram . . . . . . . . . . . . . . . . . . . . . . 108

4.3.3 Stap 2: Minimaliseren van de toestanden . . . . . . . . . . . . . . . . . . . . . . . 110

Het minimalisatiealoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Omzetting naar een toestandsdiagram en -tabel . . . . . . . . . . . . . . . . . . . . 112

4.3.4 Stap 3: Implementeren van de toestanden in het geheugen . . . . . . . . . . . . . . 113

Stap 3A: Coderen van de toestanden . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Stap 3B: De keuze van het type flipflop . . . . . . . . . . . . . . . . . . . . . . . . 115

4.3.5 Stap 4: Implementeren van de combinatorische logica . . . . . . . . . . . . . . . . 116

Stap 4A: Logica die de volgende toestand berekent . . . . . . . . . . . . . . . . . . 117

Stap 4B: Logica die de uitgang toestand berekent . . . . . . . . . . . . . . . . . . . 120

4.3.6 Tijdsgedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Leidend voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

4.4 Asynchrone schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123

4.4.1 Leidend voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

4.4.2 Stap 1: Opstellen van een toestandstabel . . . . . . . . . . . . . . . . . . . . . . . 124

4.4.3 Stap 2: Minimaliseren van de toestanden . . . . . . . . . . . . . . . . . . . . . . . 125

Voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

4.4.4 Stap 3: Codering van de toestanden . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

Elimineren van critical races . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

Methode 1: Zoeken naar een goede codering . . . . . . . . . . . . . . . . . . . . . . 132

Methode 2: Gebruik maken van een tussentoestand . . . . . . . . . . . . . . . . . . 134

Methode 3: Invoeren van extra overgangstoestand . . . . . . . . . . . . . . . . . . 136

Initiele toestand (bis) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

4.4.5 Stap 4: Realisatie met digitale logica . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Hazards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Hazards en Karnaugh-kaarten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Realisatie leidend voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

Problemen ten gevolge van skew op ingangen . . . . . . . . . . . . . . . . . . . . . 141

4.4.6 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

4.1 Terminologie

Een sequentiele schakeling is een schakeling waarbij niet alleen de ingangen X van belang zijn, maar ookde toestand van deze schakeling. De toestand S wordt bepaald door de ingang, en door de vorige toestandSprev.. In de wiskunde wordt een dergelijke constructie beschreven als een eindige-toestanden machine offinite state machine (FSM). Om dit te verwezenlijken hebben we een geheugencomponent nodig, eencomponent die de toestand bijhoudt. Dit kunnen we bijvoorbeeld verwezenlijken met een condensator. InDRAM geheugens wordt dergelijke implementatie gebruikt. Het probleem met een condensator is dat delading na verloop van tijd verloren gaat, wat tot dynamische logica leidt. In DRAM wordt dit opgelost door decondensatoren in kwestie terug op te laden. Een alternatief zijn componenten met positieve terugkoppeling,doorgaans zijn deze bekend als flipflop of register. In Sectie 4.2 zullen we verschillende van deze bouwblokkenbespreken.

4.2. BOUWBLOKKEN 95

4.1.1 Classificatie van sequentiele schakelingen

classificationSequential Doorgaans kunnen we sequentiele schakelingen onderverdelen volgens twee classifi-catiesystemen: gebaseerd op de uitgangsfunctie F , en de synchroniciteit van de schakeling. Wat betreft deuitgangsfunctie beschouwen we twee types:

• Toestandsgebonden sequentiele schakelingen: In dit geval hangt de uitgangsfunctie enkel af van detoestand op dat moment. In dat geval is de uitgangsfunctie F (S). Dit concept is ook bekend alsde Moore machine ofwel Moore-FSM. Bij een Moore machine is de invloed van de ingang dus metvertraging te zien, vermits de schakeling eerst van toestand moet veranderen.

• Inputgebonden sequentiele schakelingen: Hierbij wordt de signatuur van de uitgangsfunctie uitge-breid. De uitgang is zowel afhankelijk van de toestand S als van de ingang X. Dit betekent dat indiende ingang verandert, maar de toestand niet de uitvoer F (S,X) ook verandert. Dit concept wordtook wel de Mealy machine ofwel Mealy-FSM genoemd. Elke Moore machine is dus ook een Mealymachine waar de invoer geen onderdeel uitmaakt van de logica die de uitgang berekent.

Verder maken we ook een onderscheid in schakelingen inzake synchroniciteit, ook hier beschouwen we tweesoorten:

• Asynchrone sequentiele schakelingen: Hierbij verandert uitgang F en toestand S wanneer de ingangX verandert. We zullen asynchrone schakelingen kort bespreken in sectie 4.4, bovendien zullen weveronderstellen dat slechts een bit tegelijk verandert aan de ingang.

• Synchrone sequentiele schakelingen: Hierbij veranderen de uitgang F en toestand S enkel op hetmoment de zogenoemde klokingang verandert. Veruit de meeste sequentiele schakelingen worden ge-bouwd op basis van een klok. In sectie 4.3 zullen we synchrone schakelingen en hun synthese uitgebreidbespreken.

4.1.2 Terminologie van het kloksignaal

Bij synchrone schakelingen maken we gebruik van een klokingang. Op deze klokingang staat periodiek een0 gevolgd door een 1. Om dit kloksignaal te beschrijven maken we gebruik van de volgende terminologie:

• Klokperiode: de tijd tussen twee opeenvolgende klokovergangen van 0 naar 1.

• Klokfrequentie: het aantal klokperiodes per seconden of formeler:

klokfrequentie =1

klokperiode(4.1)

• “Duty cycle”: fragment van de klokcyclus dat de klok op 1 staat.

duty cycle =tijd klok is 1

klokperiode(4.2)

De klok staat dus niet per definitie even lang op 0 als op 1.

• Stijgende flank (ook wel rising edge genoemd): de klokovergang waarbij de klok van 0 naar 1 gaat.

• Dalende flank (ook wel falling edge genoemd): de klokovergang waarbij de klok van 1 naar 0 gaat.

4.2 Bouwblokken

In deze sectie zullen we de bouwblokken van geheugen ontwikkelen. Hierbij zullen we in Subsectie 4.2.1 eersthet basisblok ontwikkelen om een bit te onthouden: de flipflop. Door flipflops te groeperen kunnen we eengroter geheugen ontwikkelen. Dergelijke geheugens worden registers genoemd. Registers kunnen meestalmaar een beperkt aantal flipflops tegelijk aanspreken. Registers bespreken we in subsectie 4.2.2. Een anderepopulaire toepassing van geheugens is een teller. We ontwikkelen een tellerschakeling in subsectie 4.2.3.


4.2.1 De flipflop

Bij de synthese van een flipflop zullen we een eerste positief feedback component introduceren: de set-reset latch. Vervolgens zullen we deze latch uitbreiden en verschillende varianten bespreken. Een probleemmet latches is het zogenaamde transparantie-probleem. Dit probleem zullen we oplossen door extra logicamet deze latch te verbinden wat resulteert in een flipflop. Er zijn verschillende varianten van flipflops omverschillende toepassingen te ondersteunen, we eindigen met een beknopt overzicht van de verschillendeflipflops.

De latch

Set S

Reset R

Qn

Q

S R Qnext

0 0 Q0 1 01 0 11 1 N/A

t

Qn 01

Q01

R 01

S 01

(a) Implementatie met NOR-poorten.

Set S∗

Reset R∗

Q

Qn

S∗ R∗ Qnext

1 1 Q1 0 00 1 10 0 N/A

t

Qn 01

Q01

R∗ 01

S∗ 01

(b) Implementatie met NAND-poorten.

Figuur 4.1: Set-reset latch.

Figuur 4.1 toont de NOR- en NAND-implementatie van de zogenaamde set-reset latch (ofwel SR-latch).Dit component werkt met positieve terugkoppeling waarbij de uitgangen dus ook een deel van de ingangenvormen. We onthouden de uitvoer door bepaalde waarden aan de ingang aan te leggen, die resulteren inhet opnieuw bekomen van dezelfde uitvoer. Bij de NOR-implementatie is dit (S,R) = (0, 0). De NAND-implementatie is in feite de volledig duale vorm en werkt volledig equivalent, alleen zijn S en R hier actieflage signalen (zie Sectie 2.3). We zouden ook negatieve logica aan Q en Qn moeten toekennen maar omdataltijd geldt Qn = Q′ kunnen we ook eenvoudigweg de twee uitgangen omdraaien en bekomen we positievelogica aan de uitgang. De stabiele invoer van de NAND-implementatie is dan ook (S∗, R∗) = (1, 1). Indienwe een van de ingangen laten afwijken van de stabiele toestand, komen we in een onstabiele toestand. Dezestabiele toestand kan maar op een manier terug stabiel worden. Op deze manier kunnen we een nieuwewaarde toekennen aan de latch. Deze waarde zal ook verder gelden nadat de ingangen weer stabiel zijn.Hierdoor kent men ook de termen set (1 in het geheugen) en reset (0 in het geheugen) toe aan de ingangen.Indien beide ingangen afwijken van de stabiele ingangen is het gedrag niet meer bepaald. In dat geval zalde uiteindelijke waarde afhangen van de implementatie van de latch en de vertraging van de poorten. Bijidentieke vertragingen leidt dit tot een oscillerend effect wat ook te zien is op de tijdsgrafieken op figuur 4.1.In een minder ideaal systeem zal de snelste poort1 de uiteindelijke vertraging bepalen. Dit gedrag noemtmen een “race” (zie 4.4.4).

Geklokte SR-latch Bij de SR-latch is er geen sprake van een klokingang. We kunnen immers ook geheu-gens zonder klok gebruiken in bijvoorbeeld asynchrone schakelingen. Door extra hardware voor de SR-latchte plaatsen, kunnen we een geklokte SR-latch bouwen. Figuur 4.2 toont hoe we dit kunnen realiseren.Zolang het kloksignaal op 0 staat zal het geheugen zijn waarde behouden, indien het kloksignaal op 1 staatgelden dezelfde regels als bij een SR-latch.

1Uiteraard zijn de twee poorten in theorie even traag, in de praktijk zullen er altijd kleine verschillen zijn.

4.2. BOUWBLOKKEN 97

Set S

Klok Clk

Reset R

Qn

Q

(a) Met AND- en NOR-poorten.

Set S

Klok Clk

Reset R

Q

Qn

(b) Met NAND-poorten.

Clk S R Qnext

0 − − Q1 0 0 Q1 0 1 01 1 0 11 1 1 N/A

(c) Overgangstabel.

Figuur 4.2: Geklokte SR-latch.

Geklokte D-latch Indien we elke klokflank een nieuwe waarde in de latch willen opslaan loont het meestalde moeite om de geklokte SR-latch om te vormen tot een geklokte D-latch. Een geklokte D-latch zoals opfiguur 4.3 bouwt meestal extra logica rond een geklokte SR-latch die met de data-ingang D de S en R ingangaanstuurt. D-latches zijn populair bij schakelingen waarbij bij iedere klokflank een nieuwe waarde wordtingelezen. Soms wordt dan echter ook een SR-latch gebruikt omdat dit de logica rond deze geheugenmodulessoms kan vereenvoudigen.

Data D

Klok Clk

Q

Qn

(a) Implementatie.

Clk D Qnext

0 − Q1 0 01 1 1

(b) Overgangsta-bel.

Figuur 4.3: Geklokte D-latch.

Set-up- en houdtijd Aan de hand van de implementatie van de geklokte D-latch op figuur 4.3 zullen wede vertragingen van verschillende signalen berekenen:

D → Q :

tHL = 1.4 + 1.4 = 2.8 if D = 0 ∧ Clk = 1tLH = 1 + 1.4 + 1.4 + 1.4 = 5.2 if D = 1 ∧ Clk = 1

D → Qn :

tHL = 1 + 1.4 + 1.4 = 3.8 if D = 0 ∧ Clk = 1tLH = 1.4 + 1.4 + 1.4 = 4.2 if D = 1 ∧ Clk = 1

Clk→ Q :

tHL = 1.4 + 1.4 + 1.4 = 4.2 if D = 0 ∧ Clk = 1tLH = 1.4 + 1.4 = 2.8 if D = 1 ∧ Clk = 1

Clk→ Qn :

tHL = 1.4 + 1.4 + 1.4 = 4.2 if D = 0 ∧ Clk = 1tLH = 1.4 + 1.4 = 2.8 if D = 1 ∧ Clk = 1

(4.3)

We kunnen dergelijke vertragingen grafisch weergeven zoals op de tijdsgrafieken op figuur 4.4. Deze grafi-sche voorstelling toont twee bekende problemen die veroorzaakt worden door het niet respecteren van tweeparameters:

• Set-up-tijd: De tijd alvorens de het actieve kloksignaal wordt verlaten waarin de waarde op de data-ingang niet meer mag wijzigen. Bij een geklokte D-latch zoals op figuur 4.3 is dit:

tset-up = tpHL (inverter) (vertraging van een hoog-naar-laag signaal door een inverter) (4.4)

Figuur 4.4(a) toont twee senarios. Bij het eerste wordt de set-up tijd gerespecteerd, bij het tweedefaalt de toekenning. Dit komt omdat bij dit scenario S∗ weer hoog wordt alvorens R∗ een hoog signaal


t

Qn01

Q01

R∗ 01

S∗ 01

Dn 01

Clk 01

D 01

t

Qn01

Q01

R∗ 01

S∗ 01

Dn 01

Clk 01

D 01

(a) Set-up-tijd??

t

Qn01

Q01

R∗ 01

S∗ 01

Dn 01

Clk 01

D 01

t

Qn01

Q01

R∗ 01

S∗ 01

Dn 01

Clk 01

D 01

(b) Houdtijd??

Figuur 4.4: Tijdsgrafieken van een D-latch.

aanlegt. Indien we de vertragingen van de poorten doorrekenen komen we uit dat de vertraging van aande inverter een cruciale rol speelt. Dit is ook enigszins logisch: indien we een 0 aan de data-ingang Daanleggen zal gedurende deze periode 1 op zowel de S als R van de geklokte SR-latch worden aangelegd,wat eigenlijk een ongeldige invoer is.

• Houdtijd: We moeten niet alleen het signaal op tijd aanleggen voor de klok een laag signaal aanlegt.Meestal moeten we het signaal daarna nog een tijdje laten staan om te vermijden dat de latch alsnogeen foute waarde aanneemt. Figuur 4.4(b) toont opnieuw twee scenarios.??

Metastabiliteit Een ander probleem dat komt kijken bij latches is de metastabiliteit. Dit probleemtreedt op bij de twee poorten2 van de SR-latch en dus bijgevolg alle afgeleide latches. Als we bij de NOR-implementatie (S,R) = (0, 0) aanleggen, of bij een NAND-implementatie (S∗, R∗) = (1, 1), kunnen we dezepoorten modelleren als NOT-poorten zoals op figuur 4.5(a). Indien we deze schakeling logisch analyseren zien

x

y

(a) Implementatie.

x

y

(b) Transfer-functies. (c) Bal-en-heuvel-analogie.

Figuur 4.5: Metastabiliteit.

we twee mogelijke stabiele oplossingen: waarbij ofwel x ofwel y 1 is, en de andere 0. Deze waarden zijn ookde enige die we beschouwen indien we de NOT-poort louter als logisch component zien. We implementeren

2NAND- of NOR-implementatie maakt niet uit.

4.2. BOUWBLOKKEN 99

deze poorten echter met behulp van transistoren, bijgevolg behoudt de poort een zeker analoog karakter.Op de grafiek op figuur 4.5(b) geven we de transfer-functie van de twee NOT-poorten weer. De stippelijngeeft de transfer-functie van de bovenste NOT-poort weer, de volle lijn de onderste. We zien zoals verwachtde twee stabiele toestanden. We bemerken echter ook een metastabiele toestand. Op het moment datop x of y een kleine hoeveelheid ruis wordt aangebracht zullen de poorten dit effect versterken en zal deschakeling in een stabiele toestand terechtkomen. Het probleem is echter dat we uiteraard niet weten hoelangdit zal duren. We gaan er echter vanuit dat de kans dat na een bepaald tijdstip er nog onvoldoende ruis isopgetreden Poisson-verdeeld is3. We formaliseren dus tot:

p (nog in metastabiele toestand na t) = e−t/τ (4.5)

De tijdsconstante τ is hierbij afhangen van twee factoren:

• De hoeveelheid ruis: hoe meer ruis hoe lager de tijdsconstante.

• De stijlheid van de curves rond de metastabiele toestand: hoe stijler hoe lager de tijdsconstante.

Een latch kan in een metastabiele toestand komen door een zogenaamde marginale triggering: een schendingvan de set-up- of houdtijd of van de minimale pulsbreedte4. In deze gevallen kan een overgang tussentwee stabiele toestanden worden onderbroken. Indien dit gebeurt op het moment dat men net voorbij demetastabiele toestand passeert treedt dit probleem op. Een latch komt dan ook bij elke overgang kortstondigin een metastabiele toestand. Ook een tijdje in een metastabiele toestand blijven is geen probleem. Zolangdeze toestand niet meer actief is wanneer we het signaal gaan gebruiken zullen er geen problemen optreden.Een populaire voorstelling van metastabiliteit is de zogenaamde bal-en-heuvel-analogie. In deze analogiebeschrijven we een heuvel zoals op figuur 4.5(c). Een bal kan op deze heuvel in drie toestanden een evenwichtbereiken: twee toestanden in een dal (passief evenwicht) en een metastabiele toestand op de heuvel (actiefevenwicht). Bij asynchrone circuits is metastabiliteit een veel voorkomend fenomeen. Zeker wanneer deklokfrequentie geen veelvoud is van de frequentie waarmee de ingang omwisselt. In dat geval bestaat deoplossing van het probleem eerder uit “hoe ga ik om met metastabiliteit?”, in plaats van “hoe los ik demetastabiliteit op?”.

De flipflop

Latches kunnen we gebruiken bij het opslaan van een bit. Indien we een geklokte latch aan een kloksignaalhangen zijn er twee toestanden afhankelijk van het niveau van het kloksignaal:

• Indien het kloksignaal hoog is Clk = 1 is de latch transparant. De latch neemt de waarde over die aande ingang staat.

• Indien het kloksignaal laag is Clk = 0 onthoudt de latch de laatste waarde die aan de ingang stondtoen de latch transparant was.

Latches geven echter problemen op het moment we verschillende latches na elkaar willen hangen. In dat gevalzullen immers alle latches transparant zijn op hetzelfde moment. Hierdoor zal de laatste latch de waardeaannemen die op de eerste latch wordt aangelegd5. Dit probleem wordt ook wel het transparantie-probleemgenoemd. Meestal willen we echter bij een sequentie van een aantal geheugencomponenten afdwingen dat deinformatie door een geheugencomponent per klokflank propageert. De flipflop is een geheugencomponent diein tegenstelling tot de latch flankgevoelig is. Dit betekent dat de flipflop enkel transparant is op het momentdat de klok van 0 naar 1 gaat, in tegenstelling tot een latch die transparant is gedurdende de volledige periodedat de klok hoog is. Om dit te realiseren zijn er doorgaans twee methodes:

• De master-slave flipflop.

• De edge-triggered flipflop.

We zullen deze twee verschillende technieken in de volgende paragrafen toelichten.

3De meeste kansverdelingen op het voorkomen van een gebeurtenis zijn Poisson-verdeeld.4De tijd dat een signaal wordt aangelegd.5Bij een groot aantal latches zal het signaal door vertragingen en set-up- en houdtijd uiteraard maar door een beperkt aantal

latches in een klokflank propageren.


Master-slave flipflop Een master-slave flipflop maakt gebruik van twee latches die beurtelings transparantzijn. De master (eerste latch) is transparant wanneer het kloksignaal laag is, de tweede latch is transparantbij een hoog kloksignaal. Gegroepeerd vormen we dus een geheugen die de laatste waarde opslaat die aande ingang stond op het moment dat het kloksignaal laag was, en deze verder propageert op het moment dathet kloksignaal hoog is. Figuur 4.6 toont dit concept samen met een tijdsgrafiek.??

Q

Q

D

Clk

Q

Q

D

Clk

Master Slave

Q

Q

D

Clk

Q

Q

D

Clk

Master Slave

Q

Q

D

Clk

Q

Q

D

Clk

Master SlaveQ1 Q2

Clk

D Q3

(a) Implementatie.

Q

Q

D

Clk

(b) Interface

Figuur 4.6: Master-slave flipflop.

Edge-triggered flipflop Een edge-triggered flipflop maakt gebruik van een structuur die we kunnen groe-peren als drie latches. Deze schakeling stelt ons in staat om het signaal op te slaan die aan de ingang staatop het moment dat de klok van 0 naar 1 gaat. Figuur 4.7 toont een basis en meer uitgebreide implementatiesamen met een tijdsgrafiek. In de meer uitgebreide versie zijn er naast de data- en klokingang ook nog twee

Qn

Q

A

S∗

R∗

B

Klok Clk

D

(a) Basisimplementatie.

Qn

Q

Klok Clk

D

Preset PR∗

Clear CLR∗

(b) Uitgebreide implementatie.

t

Qn01

Q01

S∗ 01

R∗ 01

A 01

B 01

D 01

Clk 01

(c) Tijdsgrafiek

Figuur 4.7: Edge-triggered flipflop.

andere ingangen beschreven:

4.2. BOUWBLOKKEN 101

• Preset PR∗: Indien dit signaal laag wordt, slaan we asynchroon een 1 op in de flipflop.

• Clear CLR∗: Indien dit signaal laag wordt, slaan we asynchroon een 0 op in de flipflop.

Deze twee signalen worden ook wel de asynchrone set en reset genoemd. Ze zijn asynchroon omdat zeonafhankelijk van de toestand van de klok een waarde in het geheugen kunnen inbrengen, deze eigenschapwordt bijvoorbeeld gebruikt om bij het opkomen van de stroom in de elektronica de flipflop in een gekendetoestand te brengen6.

Types flipflops

Er bestaan analoog aan de latches ook verschillende types flipflops. Hierbij is niet de klokaansturing variabel,maar de manier hoe data ingelezen wordt. Denk bijvoorbeeld aan het verschil tussen een SR-latch en D-latch.Elk type flipflop kunnen we karakteriseren aan de hand van twee tabellen:

• De karakteristieke tabel: deze tabel gebruikt men bij de implementatie van de flipflops. Het toontaan de linkerkant de ingangen, en aan de rechterkant geeft het weer hoe er op deze ingangen wordtingespeeld.

• De excitatietabel: deze tabel beschrijft de verschillende vormen van gedrag van de component aan delinkerkant, en aan de rechterkant hoe we dit gedrag kunnen verwezenlijken met de ingangen.

Deze twee tabellen zijn niet strikt het omgekeerde omdat de excitatietabel een kolom voorziet voor Q enQnext, terwijl de karakteristieke tabel uitsluitend een kolom aan de rechterkant voorziet. In de volgendeparagrafen zullen we de verschillende types flipflops bespreken met hun karakteristieke- en excitatietabel.

SR-flipflop De SR-flipflop ofwel set-reset flipflop werkt volledig analoog aan een SR-latch, alleen veran-dert de waarde uitsluitend op het moment dat de klok van een laag signaal naar een hoog signaal gaat. Dekarakteristieke tabel is dan ook volledig equivalent met deze van de SR-latch op figuur 4.1. Figuur 4.8 toontde interface en de karakteristieke- en excitatietabel van de SR-flipflop.

Q

QR

Clk

S

S R Qnext

0 0 Q0 1 01 0 11 1 N/A

Q Qnext S R0 0 0 −0 1 1 01 0 0 11 1 − 0

Symbool Karakteristieke tabel Excitatietabel

Figuur 4.8: Set-reset flipflop.

D-flipflop Ook de data-flipflop of D-flipflop is conceptueel equivalent aan zijn latch tegenhanger. Op hetmoment dat de klok van laag naar hoog gaat, zal het signaal dat aan de data-ingang D staat in het geheugenworden geladen. Hierdoor is het bouwen van schakelingen met D-flipflops meestal zeer eenvoudig. Merkdus op dat elk signaal slechts een klokperiode bewaard wordt. Figuur 4.9 toont het symbool samen met dekarakteristieke- en excitatietabel.

T-flipflop Een nieuwe variant is de zogenaamde toggle-flipflop ofwel T-flipflop. De toggle-flipflop heefteen ‘toggle’-ingang T . Indien deze ingang bij een stijgende klokflank hoog is, zal de flipflop het omgekeerdevan zijn huidige waarde opslaan, de zogenaamde ‘toggle’-operatie. Indien T = 0, blijft de opgeslagentoestand dezelfde. We kunnen een toggle-flipflop bouwen met behulp van een data-flipflop en een XOR-poort. Figuur 4.10 toont het symbool, een mogelijke implementatie en de karakteristieke- en excitatietabelvan de T-flipflop.

6Bij het opkomen van de stroom zal de flipflop of latch immers een waarde aannemen afhankelijk van de ruis en minimaleverschillen in poortvertragingen.


Q

Q

D

Clk

D Qnext

0 01 1

Q Qnext D0 0 00 1 11 0 01 1 1

Symbool Karakteristieke tabel Excitatietabel

Figuur 4.9: Data-flipflop.

Q

Q

T

Clk

Q

Q

D

Clk

Q

QnClk

TT Qnext

0 Q1 Q′

Q Qnext T0 0 00 1 11 0 11 1 0

Symbool Implementatie Karakteristieke tabel Excitatietabel

Figuur 4.10: Toggle-flipflop.

JK-flipflop De JK-flipflop of voluit Jack Kilby-flipflop7 is een combinatie van de set-reset flipflop en detoggle-flipflop. Bij een SR-flipflop komen we immers in een ongeldige toestand indien we aan de ingangen(S,R) = (1, 1). De JK-flipflop lost dit probleem op door in dat geval een toggle-operatie uit te voeren ophet geheugenelement, zoals te zien op de karakteristieke tabel op figuur 4.11. We kunnen een JK-flipfloprealiseren met behulp van een SR-flipflop waarbij:

S = J ·Q′R = K ·Q (4.6)

JK-flipflops worden vooral gebruikt om goedkopere schakelingen te synthetiseren. Deze eigenschap kunnenwe afleiden uit de vele don’t cares in de excitatietabel.

Q

QK

Clk

JQ

QR

Clk

S Q

Qn

Clk

J

K

J K Qnext

0 0 Q0 1 01 0 11 1 Q′

Q Qnext J K0 0 0 −0 1 1 −1 0 − 11 1 − 0

Symbool Implementatie Karakteristieke tabel Excitatietabel

Figuur 4.11: Jack-Kilby flipflop.

Overzicht We bundelen vervolgens al de latches en flipflops in figuur 4.12. Indien een cel leeg is bijdit overzicht is er geen realisatie mogelijk. Zo kunnen we onmogelijk een toggle-latch bouwen: deze zouimmers bij een actief kloksignaal continue inverteren, waardoor het uiteindelijke resultaat onvoorspelbaar is.We kunnen elke flipflop verrijken met de asynchrone preset en clear ingangen. Verder bestaan er ook nogvarianten van deze componenten waarbij we eerst een negatie toepassen op de ingang. In dat geval plaatsenwe een cirkel bij deze ingang. Indien we een negatie toepassen op de klokingang bij een flipflop zal de flipflopdus de waarde memoriseren bij een falling edge, in plaats van een rising edge.

7Genoemd naar Jack Kilby (1923-2005), Amerikaans natuurkundige en nobelprijswinnaar.


Set-Reset (SR) Data (D) Toggle (T) Jack Kilby (JK)

On

geklo

kt

Geklo

kt

Fla

nkgeklo

kt

Latch

Flip

flop

Q

QR

S

NOR

Q

QR

S

NAND

Q

QR

Clk

S Q

Q

D

Clk

Q

QR

Clk

S

Basis

Q

QR

Clk

S

PR

CLR

Uitgebreid

Q

Q

D

Clk

Basis

D Q

QClk

PR

CLR

Uitgebreid

Q

Q

T

Clk

Basis

Q

Q

T

Clk

PR

CLR

Uitgebreid

Q

QK

Clk

J

Basis

Q

QK

Clk

J

PR

CLR

Uitgebreid

Figuur 4.12: Overzicht van de interfaces van geheugencomponenten.

4.2.2 Registers

Register Een flipflop kan een bit opslaan voor een of meerdere klokflanken. Meestal willen we echtermeerdere bits opslaan om bijvoorbeeld een getal voor te stellen. Dit kunnen we doen door middel vanverschillende flipflops die elk een individuele bit opslaan. Een register is in dat opzicht eigenlijk ook eenn-flipflop. Omdat we vaak meerdere bits opslaan definieren we dus het registercomponent. Een registerneemt enige functionaliteit weg van de flipflops: zo kunnen we niet beslissen dat een individuele flipflop eenbit aan de ingang opslaat, en de andere flipflops niet. Desalniettemin maken ze schema’s eenvoudiger enworden registers op chipniveau verkocht. Verder biedt een dergelijk chip naast geheugenopslag ook extrafuncties aan: bijvoorbeeld schuifregisters en tellers. Een register heeft tradioneel ingangen voor de klok Clk,data D1, D2, . . . , Dn, load LD en asynchrone preset Pr∗ en clear Clr∗. Als uitgangen heeft het minstens dedata-uitgangen Q1, Q2, . . . , Qn. Enkel indien de load hoog is bij een rising edge zal de waarde die aan dedata-ingangen staat opgeslagen worden. Indien dit niet zo is, wordt de vorige waarde behouden. Figuur 4.13toont de interface van een register, samen met een mogelijke implementatie. We werken hier met D-flipflopsen multiplexers om te kiezen tussen het laden van een nieuwe waarde en een vorige waarde. Meestal wordtde clear en preset in negatieve logica geımplementeerd8.

Schuifregister We hebben reeds vermeld dat men de meeste registers uitrust met extra functionaliteit.Een concreet voorbeeld hiervan is het schuifregister. Indien we met normale registers werken kunnen weper klokflank tussen twee acties kiezen: een nieuwe waarde inladen (“load”), of de oude waarde behouden.Een schuifregister voegt daar een functionaliteit aan toe: de oude waarde een plaats naar rechts schuiven,en deze waarde bij de rising edge inladen. Hiervoor bevat een schuifregister een extra ingang Shft die indienactief, de waarde van het register opschuift. Sommige schuifregisters bevatten bovendien extra ingangen omte bepalen of er naar links of rechts geschoven moet worden. SerIn is een andere ingang, deze bepaalt welkebit er op de vrijgekomen plaats komt te staan. Figuur 4.14 toont de implementatie van een schuifregister diede data naar rechts opschuift. Schuifregisters worden vooral gebruikt om data serieel te maken: er wordt eengetal ingeladen in het register, en vervolgens kunnen we per klokflank de laatste bit doorsturen. Aangezienhet getal telkens verder opschuift sturen we zo na n-klokcycli een n-bit getal door. Dit kan handig zijn indiende kostprijs van meerdere draden te hoog is.

8Vandaar de asterisk (*) bij Clr∗ en Pr∗.


Pr

ClrClk

LD

Q0Q1Q2Q3

D0D1D2D3

Pr∗

Clr∗

LD

Clk

(a) Interface

D Q

QClk

PR

CLR

D3

Q3

D Q

QClk

PR

CLR

D2

Q2

D Q

QClk

PR

CLR

D1

Q1

D Q

QClk

PR

CLR

D0

Q0

LD

Clk

Pr∗

Clr∗

(b) Implementatie

Figuur 4.13: Interface en implementatie van een 4-bit register.

D Q

QClk

PR

CLR

D3

Q3

D Q

QClk

PR

CLR

D2

Q2

D Q

QClk

PR

CLR

D1

Q1

D Q

QClk

PR

CLR

D0

Q0

LD

ShftSerIn

Clk

Pr∗

Clr∗

(a) Implementatie

Figuur 4.14: Implementatie van een 4-bit schuifregister.

4.2.3 Tellers

Een andere functionaliteit die men vaak combineert met registers is tellen. Een teller maakt het mogelijkom de waarde tijdens een klokflank met een op te hogen: increment. De meeste tellers laten echter ooktoe om naar beneden te tellen: decrement. De meeste tellers laten ook toe om een waarde in te laden endeze dan vervolgens in de volgende klokcycli te verhogen of verlagen. Indien de teller op de maximale ofminimale voor te stellen waarde komt, treedt na de volgende cyclus een “wrap-around” op: het getal voorhet kleinste getal is het grootste en vice versa. Modulo-tellers wachten niet op de maximaal voor te stellenwaarde alvorens deze wrap-around toe te passen. Zo telt een BCD-teller enkel tussen 0 en 9. We zouden eenteller kunnen implementeren aan de hand van een register en een opteller9. Er bestaan echter goedkoperemanieren om tellers te implementeren.

Een teller die enkel naar boven telt wordt een up-counter genoemd. Analoog wordt een teller die enkel naarbeneden telt een down-counter genoemd. Een teller die in beide richtingen kan tellen is een bidirectionialcounter ofwel bidirectionele teller. Tellers introduceren ook een aantal nieuwe ingangen:

• Counter Enabled CEin: enkel indien dit signaal hoog is, wordt het tellen uitgevoerd. In het anderegeval blijft de waarde uit de vorige klokcyclus behouden.

• Down-Up D/U∗: deze ingang bepaalt de richting waarin er geteld wordt. Uit het symbool kunnen we

9Analoog aan het schuifregister die uit een schuifoperatie en register bestaat.


afleiden dat indien het signaal laag is we naar boven tellen, indien het signaal hoog is tellen we naarbeneden.

Een uitgang die we regelmatig in een teller zien terugkomen in Counter Enabled CEout. Deze uitgang ishoog op de klokflank waarbij de teller een wrap-around uitvoert. Indien we dan een cascade van tellersbouwen zal de teller die erna geschakeld is bij een wrap-around opgehoogd worden. Op die manier kunnenwe bijvoorbeeld met 3 4-bit tellers een 12-bit teller bouwen. Deze uitgang wordt soms ook de “Ripple CarryOutput (RCO)” genoemd.

CEin CEout

ClkClr∗

Q

Q

T

Clk

PR

CLR

Q0

Q

Q

T

Clk

PR

CLR

Q1

Q

Q

T

Clk

PR

CLR

Q2

Q

Q

T

Clk

PR

CLR

Q3

Figuur 4.15: Asynchrone 4-bit teller

Asynchrone teller Bij een asynchrone teller, asynchronous counter ofwel ripple counter wordt de ver-andering van de bittoestand van een van de bits gebruikt als klokingang voor de volgende bit. Dit leidttot minimaal hardwaregebruik, maar heeft hetzelfde probleem als een ripple adder: het signaal dient tepropageren door de bits10, wat leidt tot grote vertragingen als het om veel bits gaat. Vooral indien we logicakoppelen aan hoge bits kunnen deze vertragingen nefast zijn en leiden tot een lage performantie. We kunneneen down-counter realiseren door de Qn-uitgang aan de toggle-ingang van de volgende flipflop te koppelen(en niet de Q-uitgang). Eventueel kunnen we deze schakeling dus zelfs uitbreiden door een multiplexer teplaatsen tussen de flipflops die selecteert tussen Q en Qn en zo de gebruiker laat kiezen in welke richting deteller werkt. Het nadeel is dat ook deze multiplexer een vertraging induceert. Een eenvoudige implementatievan een asynchrone teller staat op figuur 4.15.

CEin CEout

ClkClr∗

Q

Q

T

Clk

PR

CLR

Q0

Q

Q

T

Clk

PR

CLR

Q1

Q

Q

T

Clk

PR

CLR

Q2

Q

Q

T

Clk

PR

CLR

Q3

Figuur 4.16: Synchrone 4-bit teller

Synchrone teller Een synchrone teller laat alle bits wel tegelijk van waarde veranderen. Dit doen wedoor de volgende toestand reeds vooraf uit te rekenen en bij het kloksignaal deze toestand op te slaan in deflipflops. Hoe we deze toestand berekenen staat ons in principe vrij net als de keuze van het type flipflop.Figuur 4.16 toont een implementatie met T-flipflops. Merk op dat ondanks het feit dat de nieuwe toestandberekend wordt voor de klokflank de teller daarom geen vertraging kan teweeg brengen: het berekenen vande volgende toestand van een teller met een grote woordlengte vraagt immers ook veel tijd (en kan dus hetkritieke pad worden). Het voordeel van een synchrone teller is dat we deze berekening parallel doen met

10Hiervan komt overigens de notie van asynchroniciteit: niet alle bits veranderen op hetzelfde moment van waarde.


andere berekeningen die van de teller afhangen. Doordat de volgende toestand ook meteen beschikbaar iszullen berekeningen die afhangen van de teller ook onmiddellijk kunnen worden uitgerekend.

CEin CEout

D/U∗

LD

ClkClr∗

D Q

QClk

PR

CLR

D0

Q0

Dir

QiDi

Ei Ei+1

D Q

QClk

PR

CLR

D1

Q1

Dir

QiDi

Ei Ei+1

D Q

QClk

PR

CLR

D2

Q2

Dir

QiDi

Ei Ei+1

D Q

QClk

PR

CLR

D3

Q3

Dir

QiDi

Ei Ei+1

(a) Algemene implementatie

LD

CEin

D/U∗

Clk

CLR

CEout

Q0Q1Q2Q3

D0D1D2D3

CEin CEout

Clr∗LD

D/U∗

Clk

(b) Interface

Dir

Qi

Ei

Di

Ei+1

(c) Hulpcomponent

Figuur 4.17: Parallel-laadbare bidirectionele 4-bit teller.

Parallel-laadbare bidirectionele teller Een speciaal geval van een synchrone teller is een parallel-laadbare bidirectionele teller. Een implementatie van zo’n teller staat op figuur 4.17(a). Deze teller is parallellaadbaar wanneer we de waarde van de teller kunnen zetten op een ingegeven waarde in een klokflank11. Bijhet laden wordt de LD ingang hoog gezet. In het andere geval dienen we elke bit te berekenen. Hiervoorwordt op figuur 4.17(a) een naamloze component ingevoerd. De nieuwe waarde van een bit wordt geınverteerdindien er geteld wordt op deze bit. In het andere geval blijft de bit onveranderd. Een bit wordt opgeteld indiende vorige bit geteld wordt en de bit een is bij een telling naar boven (analoog aan een overdracht (“carry”)dus), of nul en een telling naar beneden (een lening (“borrow”) dus). Bij het berekenen van de eerste bitQ0 gebruiken we logischerwijs de counter enabled CE ingang. Figuur 4.17(c) toont een implementatie vooreen dergelijk component. De teller die we hiermee ontwikkelen verenigt de meeste functionaliteiten die we intellers kunnen terugvinden. Figuur 4.17(b) toont een interface die vaak gebruik wordt voor tellers. Indieneen functionaliteit niet wordt aangeboden wordt de vermelding eenvoudigweg weggelaten.

Modulo-teller Tot nu toe hebben we enkel teller geconstrueerd die tellen van 0 tot het maximaal voor testellen getal. Bij een n-bit teller is dit dus 2n − 1. In de praktijk komt het geregeld voor dat we tellen toteen bepaalde waarde om daarna terug bij 0 te beginnen. Stel bijvoorbeeld dat we een teller maken die hetaantal minuten bijhoudt. Indien dit getal boven de 60 gaat komt het aantal minuten terug op 0, en dient hetaantal uren verhoogd te worden. Ook controllers die elektronica aansturen dienen soms een beperkt aantal

11Het schuifregister of figuur 4.14 kan bijvoorbeeld ook sequentieel geladen worden, waarbij we per klokflank een bit van hetgetal inschuiven.


toestanden met de regelmaat van de klok te herhalen, zelden zijn dit aantal toestanden een macht van twee.Voor dergelijke problemen kunnen we een Modulo-teller gebruiken. Een modulo-teller bestaat traditioneeluit een teller met daarrond extra logica die indien de maximale waarde wordt vastgesteld, in de volgendeklokflank een 0 in de teller laadt. We kunnen deze teller veralgemenen door ook het tellen naar beneden toe telaten, in dat geval dient de maximale waarde in de klokcyclus na 0 ingeladen te worden. Figuur 4.18(a) toonteen algemeen geval van een 4-bit teller. We tellen hierbij van 0 tot en met MAX. Uiteraard moet MAX in dit

LD

CEin

D/U∗

Clk

CLR

CEout

Clr∗

Clk

D/U∗

CEin

Q0Q1Q2Q3

CEout

0000MAX

=MAX

(a) Algemeen geval

LD

CEin

D/U∗

Clk

CLR

CEout

Clr∗

Clk

D/U∗

CEin

Q0Q1Q2Q3

CEout

01 00 00 01

(b) BCD-teller

Figuur 4.18: 4-bit modulo-tellers.

geval wel voor te stellen zijn met 4-bit. Voor een n-bit modulo-counter geldt dus steeds: MAX≤ 2n. Verderdienen we een component afhankelijk van MAX te synthetiseren. Deze component vergelijkt de waarde dieop de Qi-uitgangen staat met MAX, indien deze aan elkaar gelijk zijn en D/U

∗en CEin hoog zijn, dient een

1 aan de uitgang van deze component te verschijnen, in alle andere gevallen een 0. Voor eender welke MAXis dit te realiseren met een AND-poort12. Verder zien we op de figuur ook een variant van een multiplexer.Deze multiplexer stelt eigenlijk 4 multiplexers voor die elk een bit uit het linkse en een bit uit het rechtse vakals invoer hebben, en die selecteren met dezelfde ingang, namelijk: D/U

∗. Vanaf de volgende sectie zullen

we vaak met registers met een groot aantal bits werken. In dat geval besparen ontwerpers zich het tekenenvan de verschillende parallelle lijnen door een lijn te tekenen. Verder wordt er dus gebruik gemaakt van denotatie van de multiplexers om aan te duiden dat elke bit van deze lijnen door een dergelijk component gaat.

BCD-teller Een speciaal geval van een modulo teller is een BCD-teller. Deze teller telt van 0 tot en met9. BCD ofwel Binary Coded Decimal werd reeds eerder besproken in subsectie ??. BCD-tellers zijn populairbij het voorstellen van getallen die ook snel naar de gebruiker moeten worden gecommuniceerd. Dit komtomdat bij de omzetting van een getal naar het equivalent op bijvoorbeeld seven-segment displays, we cijferper cijfer kunnen werken. Indien we het getal binair opslaan wordt deze omzetting veel complexer. Opfiguur 4.18(b) implementeren we dan ook een BCD-teller. Vermits 9 binair voorgesteld wordt door 10012

kunnen we een AND-poort realiseren die in dat geval een 1 op de uitgang plaatst. Verder dienen we dus ookdeze waarde in de multiplexer in te brengen. Een oplettende lezer zal misschien merken dat sommige van demultiplexers in dat geval zinloos worden, omdat we bijvoorbeeld moeten kiezen tussen een 0 en een 0.

12Waarom?


4.3 Synchrone schakelingen

Nu we de bouwstenen hebben beschreven om een sequentiele schakeling te bouwen zullen we een stappenplanontwikkelen uit een set van specificaties een sequentiele schakeling te ontwikkelen. In deze sectie gaan weervan uit dat deze schakeling synchroon is. Dit betekent dat er sprake is van een klok die de schakelingaanstuurt. Het stappenplan kan opgedeeld worden in volgende stappen:

1. Het opstellen van een toestandsdiagram uit de specificaties.

2. Het minimaliseren van het aantal toestanden door F-gelijke toestanden te bepalen.

3. Het implementeren van de toestanden in een geheugen

(a) Het coderen van deze toestanden in geheugenelementen.

(b) Het kiezen van het type flipflop die de toestanden bijhoudt.

4. Het implementeren van de combinatorische logica

(a) Implementeren van logica die de volgende toestand berekent.

(b) Implementeren van logica die de uitgangen (uitvoer) berekent.

4.3.1 Leidende voorbeelden

We zullen dit stappenplan doorlopen met behulp van twee voorbeelden. Het eerste is een Moore-FSM.Uit subsectie ?? weten we nog dat de uitgang dus volledig bepaald wordt door de toestand. In het tweedevoorbeeld behandelen we een Mealy-FSM waarbij ook de invoer een rol speelt. Het stappenplan zelf verschiltmeestal op enkele punten tussen het proces voor een Moore-machine en een Mealy-machine. In dat gevalzullen op de afbeeldingen aan de linkerkant de Moore-machine staan, en aan de rechterkant de Mealy-machine.Indien dit niet relevant is voor het concept zullen we telkens gebruik maken van de Mealy-machine. Dezekeuze is uiteraard louter arbitrair.

We implementeren een Moore-machine die 1 op de uitvoer aanlegt als de laatste drie klokcycli afwisselendeen 0, 1 en 0 zijn. We implementeren een min of meer equivalente constructie voor een Mealy-machine,hier dienen echter op de twee laatste klokcycli een 0 en 1 op de ingang aangelegd te worden, en dient er ophet moment zelf een 0 op de ingang te staan. De Mealy-machine is dus de Moore-machine maar met eenklokcyclus verschoven.

4.3.2 Stap 1: opstellen van het toestandsdiagram

Het opstellen van het toestandsdiagram is meestal de moeilijkste stap. Dit komt omdat men niet formeelkan uitdrukken hoe men uit de specificaties een toestandsdiagram opstelt. Het opstellen van een dergelijkdiagram omvat echter meestal dezelfde vaardigheden als deze die bij bijvoorbeeld programmeren aan bodkomen. Door middel van oefening kan men dan ook bekwaamheid verwerven.

Het toestandsdiagram Alvorens we een toestandsdiagram kunnen opstellen zullen we eerst een toe-standsdiagram formeel definieren. Een toestandsdiagram bestaat uit een set van toestanden. Een toestandduiden we aan met een ellips. Meestal benoemen we toestanden met een hoofdletter. Dit is niet verplichtmaar maakt het makkelijk om naar een toestand te verwijzen. Verder zijn er ook transities: overgangen vande ene toestand naar de andere13 toestand onder een bepaalde ingangscombinatie. Een transitie duiden wedan ook aan met behulp van een gerichte pijl tussen de twee toestanden. Voor elke mogelijke ingangscom-binatie dienen we in elke toestand een transitie te voorzien. De ingangscombinatie waarbij de transitie vantoepassing is noteren we bij de gerichte pijl. Het kloksignaal is in een synchrone sequentiele schakeling geenonderdeel van de ingangscombinatie. Tot slot bevat een toestandsdiagram ook de initalisatie, een gerichte

13Een transitie kan ook naar dezelfde toestand gaan.

4.3. SYNCHRONE SCHAKELINGEN 109

H

0

I

0

E

0

M

0

K

0

L

0

J

1

N

0

O

0

D

0

F

0

G

0

B

0

C

0

A

0RST

0

1

0

1

0

1

010

1

0

1

0

1

0

1

0 1

0

1

0

1

0 1

0

1

01

0

1

(a) Moore-machine

D

B

E

A RST

G

C

F

1/0

0/0

0/1 1/00/0 1/0

0/0

1/0

0/0

1/0

0/0

1/0

0/0

1/0

(b) Mealy-machine

Figuur 4.19: Toestandsdiagrammen van de leidende voorbeelden.

pijl die naar een bepaalde toestand wijst maar niet uit een toestand komt. Het is de eerste toestand waarinde schakeling zich bevindt. Verder keert de schakeling ook naar deze toestand terug als de gebruiker eenreset-operatie op de schakeling uitvoert. De uitgangscombinatie wordt ook weergegeven op het toestands-diagram. Deze verschilt uiteraard tussen een Moore-machine en een Mealy-machine: bij een Moore-machineworden de uitgangen bij de toestanden genoteerd, dus in de ellips. Vermits de uitgangen bij een Mealy-machine afhangen van de ingangscombinatie wordt de uitgang bij de transitiepijlen gezet. We maken hierbijeen onderscheid tussen de ingangscombinatie en de uitgang door hier een slash (“/”) tussen te plaatsen. Opfiguur 4.19 geven we de toestandsdiagrammen van de Moore- en Mealy-machine weer.

Toestandstabel Een toestandsdiagram is een grafische voorstelling. Bij een groot aantal toestandenof bij bijvoorbeeld invoer van een toestandsdiagram in een computer, maken we meestal gebruik van eenalternatieve voorstelling: de toestandstabel. De rijen in de toestandstabel stellen de verschillende toestandenvoor, de kolommen stellen de invoercombinatie voor. In een cel i, j voor toestand Ai en invoer Ij plaatsenwe de volgende toestand. In het geval van een Moore-machine voorzien we een extra kolom die per rij deuitgangscombinatie van deze toestand weergeeft. Bij een Mealy-machine plaatsen we in elke cel naast devolgende toestand de uitgangscombinatie voor toestand Ai en invoer Ij . Ook hier plaatsen we een slash omde volgende toestand van de uitvoer te onderscheiden. De toestandstabellen van de leidende voorbeeldenstaan in tabel 4.1.

Opstellen van een toestandsdiagram en -tabel Zoals reeds gezegd is het opstellen van een toestands-diagram of -tabel een kunst. Een algemene techniek die gehanteerd kan worden is het aantal klokflanken tebepalen dat we geheugen moeten voorzien. In het geval van de voorbeelden is dit drie klokflanken voor deMoore-machine en twee klokflanken voor de Mealy-machine. Vervolgens kunnen we een toestandstabel of-diagram opstellen die de overgang naar verschillende toestanden van het geheugen voorstelt. Zo komt A inbeide voorbeelden overeen met de toestand waarin we starten, er is bijgevolg nog geen sprake over inhoud inhet geheugen. B en C betekent dat er na de eerste klokflank respectievelijk een 0 en een 1 in het geheugen


(a) Moore-machine

Toestand 0 1 Uitgang

A B C 0B D E 0C F G 0D H I 0E J K 0F L M 0G N O 0H H I 0I J K 0J L M 1K N O 0L H I 0M J K 0N L M 0O N O 0

(b) Mealy-machine

Toestand 0 1

A B/0 C/0B D/0 E/0C F/0 G/0D D/0 E/0E F/1 G/0F D/0 E/0G F/0 G/0

Tabel 4.1: Toestandstabellen van de leidende voorbeelden.

opgeslagen is. D, E, F en G spreken over de respectievelijke geheugentoestanden 00, 01, 10 en 11. Voorde Mealy-machine is dit reeds voldoende. Bij de Moore-machine introduceren we nog een extra niveau. Deovergangen op dit laatste niveau houden in dat we de oudste bit vergeten en de nieuwe bit memoriseren.Hierdoor gaan alle overgangen van een toestand op het laatste niveau enkel naar toestanden op hetzelfdeniveau. We kunnen machinaal eenvoudig een tabel opstellen voor een arbitraire diepte. Een groot nadeelis dat indien we n klokflanken willen memoriseren, we 2n+1 − 1 toestanden bekomen. Na het opstellen vandeze tabel dienen we enkel de specificaties nog te vertalen in de uitgangen van de toestanden in het gevalvan een Moore-machine, en de overgangen bij een Mealy-machine. Meestal kan men echter door logisch teredeneren voorkomen dat we dergelijke grote toestandstabellen moeten opstellen. In de volgende subsectiereduceren we het aantal toestanden tot de theoretische ondergrens. Of we de initiele tabel opstellen met dehier beschreven methode of door logisch te redeneren verandert niets aan het resultaat van de volgende stap.

4.3.3 Stap 2: Minimaliseren van de toestanden

Nu we een toestandsdiagram opgesteld hebben kunnen we dit diagram implementeren met behulp van logica.Het loont echter meestal de moeite om eerst het toestandsdiagram te minimaliseren. Minder toestandenimpliceren minder geheugencomponenten om de toestand bij te houden. Bovendien kunnen we meestal ookde achterliggende logica die de volgende toestand en de uitgangen berekent minimaliseren. Hiertoe geven weeen methode die gegarandeerd het kleinste toestandsdiagram vindt die de specificaties kan implementeren.Met minimaal bedoelen we hier het aantal toestanden. Dit betekent dus niet noodzakelijk dat de schakelingdie we hiermee verwezenlijken ook minimaal is.

Het minimalisatiealoritme

Het algemeen idee De methode die we implementeren gaat uit van een positief idee: alle toestanden zijnvertegenwoordigers van dezelfde toestand. Uiteraard is dit niet altijd het geval. Er zijn twee omstandighedenwaarin twee toestanden niet gelijk aan elkaar zijn:

1. De uitgang van de toestanden of overgangen uit een toestand zijn verschillend. In dat geval kunnenwe immers onmogelijk de uitgangsfunctie implementeren. Een uitgang kan immers niet tegelijk 0 of 1zijn.

2. De uitgang na een willekeurig aantal willekeurige invoer (configuraties bij een klokflank) is verschillend.In dat geval betekent dit dat we dus in de toekomst op het vorige probleem zullen botsen.


De eerste voorwaarde We kunnen deze twee condities eenvoudig in een algoritme implementeren. Hetalgoritme werkt op basis van een partitionering van de aanvankelijke toestandsruimte. Als twee toestandentot dezelfde partitite behoren. betekent dit dat ze eigenlijk hetzelfde zijn. Zoals eerder vermeld begint demethode met een positieve ingesteldheid: alle toestanden zijn gelijk. De initiele configuratie bevat dus eenpartitie waar alle toestanden in zitten. Vervolgens kunnen de eerste voorwaarde toepassen. Toestanden dieeen verschillende uitgang opleveren kunnen onmogelijk hetzelfde zijn. Voor een Moore-machine betekentdit dus de uitgang van de toestand. In het leidend voorbeeld is de uitgang 0 of 1. We partitioneren deconfiguratie dus in een partitie die 0 als uitgang geeft en een partitie met 1 als uitgang. De configuratie isdan:

partitieMoore,0 = A,B,C,D,E, F,G,H, I,K,L,M,N,O , J (Leidend voorbeeld) (4.7)

Merk echter op dat een schakeling ook meerdere lijnen als uitgang kan hebben. Indien de uitgang n bitstelt levert dit ons een configuratie op van hoogstens 2n partities. In het geval een Mealy-machine leidteen toestand niet rechtstreeks tot een uitgang. Twee toestanden zijn dan gelijk indien voor elke invoer-configuratie bij deze toestand, we dezelfde uitvoerconfiguratie bekomen. In het leidend voorbeeld beschouwenwe een 1-bit ingang en een 1-bit uitgang. Dit leidt dus tot hoogstens 4 partities. In ons geval zijn er maar 2partities:

partitieMealy,0 = A,B,C,D, F,G , E (Leidend voorbeeld) (4.8)

In het algemene geval met een m-bit ingang en een n-bit uitgang bekomen we hoogstens 2n+m partities.

De tweede voorwaarde De tweede voorwaarde kunnen we ook afdwingen door middel van iteratie.Hierbij itereren we over de lengte van de invoer. Het specifieke geval is uiteraard het geval waarbij de uitvoerna een klokcyclus reeds verschilt. Dit kunnen we herformuleren tot het volgende: Indien twee toestanden x0

en y0 onder een willekeurige invoer i0 naar twee toestanden x1 en y1 gaan, en deze twee toestanden behorenniet tot dezelfde partities, dan behoren x0 en y0 ook niet tot dezelfde partitie. Deze uitspraak is logisch, steldat x0 en y0 tot dezelfde partitie zouden behoren, dan kan het gebeuren dat we in de toestand geraken diedoor de partitie waar x0 en y0 toe behoort. Indien we daarna de invoer i0 dienen te verwerken komen wein toestand die zowel x1 en x2 dient te vertegenwoordigen. Vermits x1 en y1 echter tot een andere partitiebehoren is dit onmogelijk. We gebruiken deze regel om partities vervolgens verder op te delen. We gebruikende eerste configuratie van de minimale Moore-machine als voorbeeld. Hierbij gaan van de eerste partitiede toestanden A, B, C, D, F , G, H, K, L, N en O onder invoer van 0 en 1 naar de eerste partitie. Detoestanden E, I en M gaan onder invoer van 0 naar de tweede partitie (J) en onder invoer van 1 naar deeerste partitie. Bijgevolg splitsen we de eerste partitie op in A,B,C,D, F,G,H,K,L,N,O , E, I,M.Vermits de tweede partitie reeds uit een element bestaat, valt deze niet verder op te delen. De totale partitiena een iteratie is dan gelijk aan:

partitieMoore,1 = A,B,C,D, F,G,H,K,L,N,O , E, I,M , J (Leidend voorbeeld) (4.9)

Het enige wat we nu moeten doen is deze stap herhalen op de nieuwe partitie partitieMoore,1. Op die manierpassen we de regel toe bij een invoerlengte van 2. De enige vraag die open blijft is wanneer we mogenstoppen. Deze vraag is eenvoudig te beantwoorden: zolang er partities bijkomen kan een volgende stap departities verder verdelen. Indien de uitvoering van een stap geen wijzigingen aan de partities aanbrengt, zalde volgende stap dit uiteraard ook niet meer doen, en alle stappen hierna ook niet meer. In dat geval is hetveilig om te stoppen. Bij de minimalisatie van de Moore-machine zullen we dan volgende partities bekomen:

partitieMoore,0 = A,B,C,D,E, F,G,H, I,K,L,M,N,O , JpartitieMoore,1 = A,B,C,D, F,G,H,K,L,N,O , E, I,M , JpartitieMoore,2 = A,C,G,K,O , B,D,F,H,L,N , E, I,M , JpartitieMoore,3 = A,C,G,K,O , B,D,F,H,L,N , E, I,M , J

(Leidend voorbeeld) (4.10)

Het geval van de Mealy-machine is volledig analoog: we bekomen dan:partitieMealy,0 = A,B,C,D, F,G , EpartitieMealy,1 = A,C,G , B,D,F , EpartitieMealy,2 = A,C,G , B,D,F , E

(Leidend voorbeeld) (4.11)


Omzetting naar een toestandsdiagram en -tabel

Nadat we het aantal toestanden geminimaliseerd hebben, dienen we alleen nog een nieuwe Moore- of Mealy-machine te bouwen op basis van de partitie van de toestanden van de originele machine. Zoals we al enkelekeren vermeld hebben staat een partitie voor de toestand van de minimale machine. We dienen dus voorelke partitie een nieuwe toestand te voorzien. Dit doet men meestal door de nieuwe toestand dezelfde naamte geven als de toestand in de partitie die alfabetisch het eerst voorkomt. Maar we kunnen uiteraard ook eenarbitraire naam kiezen, of een naam die de letters van alle inwendige toestanden omvat. Verder dienen we inhet geval van een Moore machine aan elke toestand een uitvoerconfiguratie toe te kennen. Omdat we de eerstevoorwaarde hebben afgedwongen hebben alle toestanden in een partitie dezelfde uitvoerconfiguratie, bijgevolgnemen we de configuratie van een van de toestanden in de partitie over. Hetzelfde geldt voor de Mealy-machine. De uitgang verbonden aan de transitie uit een bepaalde nieuwe toestand is dezelfde als de uitgangvan dezelfde transitie uit een van de toestanden in de partitie. De transitiefunctie kunnen we opstellenop basis van de tweede voorwaarde: alle toestanden in partitie zullen voor eenzelfde ingangscombinatienaar eenzelfde partitie lopen. Op die manier kunnen we dus een transitie-functie opstellen over de nieuwetoestanden. De initiele toestand ten slotte is de toestand verbonden aan de partitie die de oorspronkelijkeinitiele toestand bevat. Op figuur 4.20 en tabel 4.2 staan de nieuwe machines na minimalisatie van deleidende voorbeelden. We kunnen eenvoudig vaststellen dat minimalisatie soms tot spectaculaire reductiesvan het aantal toestanden kan leiden.

A

0RST

B

0

E

0

J

1

0

1 0

1

0

10

1

(a) Moore-machine

ARST B

E

0/0

1/0 0/0

1/0 0/11/0

(b) Mealy-machine

Figuur 4.20: Geminimaliseerde toestandsdiagrammen van de leidende voorbeelden.

(a) Moore-machine

Toestand 0 1 Uitgang

A B A 0B B E 0E J A 0J B E 1

(b) Mealy-machine

Toestand 0 1

A B/0 A/0B B/0 E/0E B/1 A/0

Tabel 4.2: Geminimaliseerde toestandstabellen van de leidende voorbeelden.

Een formeel algoritme De cursus “Automaten en Berekenbaarheid” van prof. Demoen[?] bevat een for-meel algoritme voor de minimalisatie van een deterministische eindige toestandsautomaat (DFA). Met mini-male veranderingen kan dit algoritme omgevormd worden tot een algoritme die Moore- en Mealy-machinesminimaliseert. We beschouwen dit in Algoritme 1. Het algoritme bevat de algemene Minimize-procedure.Deze procedure maakt gebruik van twee functies: Minimize1 en Minimize2. De eerste functie wijkt aftussen een Moore- en Mealy-machine. Daarom wordt deze functie opgesplitst: voor de Moore-machine ge-bruiken we dus Minimize1Moore, de Mealy-machine maakt gebruik van Minimize1Mealy. We dienenook een formele beschrijving te geven van de variabelen in het algoritme. Het algoritme heeft als invoer 3verzamelingen:


Algorithm 1 Minimaliseren van een toestandsdiagram.

1: procedure Minimize(S, I,O, δ, f) . Minimaliseer de machine2: Q ←Minimize1(S, I,O, f) . Initiele partitionering gebaseerd op uitvoer.3: repeat4: P ← Q5: Q ←Minimize2(S, I, δ,P) . Bereken de nieuwe partitionering op basis van de oude.6: until P = Q . Indien geen verandering is het algoritme ten einde.7: return Q . De uiteindelijke partitie.8: end procedure9: function Minimize1Moore(S, I,O, f)

10: return s|s ∈ S : f (s) = o |o ∈ O . I wordt genegeerd.11: end function12: function Minimize1Mealy(S, I,O, f)13: return s|s ∈ S, ∀i ∈ I ∧ ∀f (s, i) = oi |o ∈ O,∀i ∈ I : ∃oi ∈ O14: end function15: function Minimize2(S, I, δ,P)16: return s|s ∈ P ∧ ∀i ∈ I : δ (s, i) = Pi |P ∈ P,∀i ∈ I : ∃Pi ∈ P17: end function

• S is de verzameling van alle toestanden.

• I is de verzameling van alle invoerconfiguraties.

• O is de verzameling van alle uitvoerconfiguraties.

Daarnaast heeft het algoritme ook nood aan twee functies:

• Een transitiefunctie δ : S × I → S die de volgende toestand beschouwt na een bepaalde invoer op deingangen te hebben waargenomen bij de klokflank.

• Een uitvoerfunctie f . Bij de Moore-machine is deze functie van de signatuur f : S → O, bij eenMealy-machine is dit f : S × I → O.

Het algoritme is geımplementeerd in het softwarepakket die wordt meegeleverd met deze cursus. De interfaceen de implementatie wordt besproken in Appendix B op pagina 319.

4.3.4 Stap 3: Implementeren van de toestanden in het geheugen

Stap 3A: Coderen van de toestanden

Tot nu toe hebben we toestanden altijd voorgesteld met letters. Uiteraard dienen we deze toestanden opde een of andere manier voor te stellen in de geheugencomponenten in onze schakeling. Vermits lettersniet opgeslagen kunnen worden in een flipflop of een register14 zullen we de toestanden moeten omzettennaar een binaire voorstelling. Dit wordt het coderen van de toestanden genoemd. Doorgaans lijkt ditgeen ingewikkeld probleem, we kunnen eenvoudigweg elke toestand een opeenvolgend nummer geven en dezetoestanden dan binair coderen. Merk echter op dat de toestand geen impliciete ordening hebben, alleenal door opeenvolgende nummers te gebruiken zijn er n! mogelijke coderingen mogelijk. Er bestaan echtertechnieken die ervoor zorgen dat we door een intelligente codering minder hardware zullen gebruiken. Ditleidt meestal tot goedkopere en snellere schakelingen. Algemeen zijn er drie technieken die we kunnengebruiken:

• “Straightforward codering”: soms is de codering triviaal.

• De “one-hot codering”: hierbij stellen we n toestanden voor door n bits, elke toestand krijgt z’n eigenbit. Indien de toestand actief is, is deze bit hoog, de andere bits zijn dan laag.

14Uiteraard kunnen we bijvoorbeeld wel het ASCII equivalent opslaan.


• De “minimal-bit-change”: we zoeken een codering die telkens een minimum aan bits verandert. Hierbijgebruiken we dlog2 ne bits om de n toestanden voor te stellen.

Uiteraard dienen we ons niet te beperken tot een van deze implementaties. Indien het aantal uitgangenbijvoorbeeld niet voldoet om een straightforward codering toe te passen kunnen we dit bijvoorbeeld aanvullenmet extra bits die een minimal-bit change gebruiken. We bespreken nu de verschillende coderingstechniekenin detail.

Straightforward codering Een codering kan triviaal zijn als de toestand een duidelijke betekenis heeft.Dit is doorgaans het geval bij bijvoorbeeld tellers. Ook indien we over een Moore-machine beschikkenwaarbij elke toestand een andere uitgang heeft en de uitgang minstens dlog2 ne bits bevat, kunnen weeen straightforward codering toepassen. In dat geval gebruiken we de uitgang van een toestand ook alszijn codering. Merk op dat in dat geval we geen logica nodig hebben die de toestand naar de uitgangcodeert. Deze codering is echter niet altijd ideaal. We reduceren dan de logica aan de uitgang, maar meestalresulteert dit in complexere logica om de transities te implementeren. Verder veranderen er meestal heel watbits per overgang. We herinneren ons dat een CMOS-implementatie enkel energie verbruikt wanneer dezeomschakelt. Indien we dus veel flipflops van waarde moeten laten veranderen betekent dit dus een grotervermogenverbruik. Een tweede aspect is dat niet elke bit tegelijk verandert. Vermits er meerdere bits zijnkan dit problemen opleveren: er bestaat een gevaar voor glitches, een tijdelijk foute waarde op een lijn tengevolge van asynchroon gedrag aan de ingang. Indien het resultaat van een teller dus nog in een andereschakeling gebruikt wordt leidt dit mogelijk tot problemen.

One-hotcodering We voorzien een flipflop voor elke toestand, hierdoor is het aantal flipflops O (n) integenstelling tot de O (log2 n). Bij elke toestand is er een flipflop hoog, alle andere flipflops zijn laag. Hetspreekt dus voor zich dat we deze configuratie enkel kunnen gebruiken bij een klein aantal toestanden. One-hotcoderingen hebben enkele voordelen: het ontwerp van een dergelijke schakeling is vrij eenvoudig en is dussnel te realiseren. Verder is het ideaal voor een implementatie bij een FPGA. Een one-hotcodering verbruiktdoorgaans weinig vermogen aangezien bij elke overgang tussen twee verschillende toestanden er twee flipflopsomschakelen. Tot slot zijn ook de combinatorische schakelingen voor de uitgangen en de transities doorgaansvrij goedkoop. Het grootste nadeel van een one-hot codering is dan ook de kostprijs voor de flipflops.

Minimal-bit-change Indien de kostprijs en vermogenverbruik een belangrijke factor zijn maken we meestalgebruik van de minimal-bit-change. Hierbij proberen we ervoor te zorgen dat de som van het aantal bits dieveranderen van alle overgangen minimaal is. Dit probleem is echter niet triviaal en is NP-compleet. Bij eenklein aantal toestanden kunnen we alle mogelijkheden uitproberen, bij een groter aantal maakt men gebruikvan programma’s zoals bijvoorbeeld MUSE, JEDI, MUSTANG,... Deze programma’s werken op basis vanheuristieken en geven meestal een benaderende oplossing. Soms worden er ook kansen bij de overgangenbetrokken om het de kosten en het vermogenverbruik verder te minimaliseren. Een typisch voorbeeld is deGray-code teller15. Gray ontwikkelde een teller die bij elke overgang slechts een bit veranderde. Figuur 4.21toont het toestandsdiagram van een 2-bit en 3-bit teller. Op de bogen plaatsen we hier het aantal bits dieveranderen. Het feit dat we niet voor een straightforward implementatie voor een teller kiezen kan vreemdlijken. Deze teller dient dan ook meestal niet om de binaire waarde onmiddellijk uit te lezen, maar kanbijvoorbeeld gebruikt worden als een controller die een lus vormt over een vast aantal toestanden. Over hetconcreet oplossen van dit probleem gaan we niet verder in.

Leidende voorbeelden Voor de Moore-machine kiezen we voor een minimal-bit-change benadering envoor de Mealy-machine een one-hot codering. Deze keuzes zijn louter didactief. De toegewezen bitvoorstel-lingen worden in een toestandstabel geschreven. Voor een one-hot codering is dit vrij triviaal. We wijzenelke toestand een bit toe. Welke bit heeft geen invloed op de schakeling. Tabel 4.3 stelt de Mealy-machineuit de leidende voorbeelden voor met de one-hot codering. Bij het zoeken naar een minimal-bit-change voorde Moore-machine maken we gebruik van een greedy algoritme. We stellen eerst een tabel op die het aantalbindingen tussen twee toestanden bevat. Vervolgens wijzen we coderingen aan toestanden toe volgens het

15Vernoemd naar Frank Gray (1887-1969), fysicus bij Bell Labs.


00RST 01

1110

000RST 011

110101

001

010

111

100

1

1

1

1

1 1

1

1

11

1

1

(a) Gray-code (minimal-bit-change)

00RST 01

1011

000RST 010

100110

001

011

101

111

1

2

1

2

1 2

1

3

12

1

3

(b) Straightforward

Figuur 4.21: Een 2-bit en 3-bit Gray-code teller en zijn straightforward equivalent.

Toestand 0 1001 010/0 001/0

010 010/0 100/0

100 010/1 001/0

Tabel 4.3: Codering van de Mealy-machine van het leidend voorbeeld.

aantal bindingen tussen de toestanden. De bindingstabel staat beschreven in tabel 4.3(a). We zien dat Een J een dubbele binding bevat. We kennen hier de waarde 01 toe aan E en 11 bij J . Verder is B gelinktaan E en daarom geven we dit de waarde 00. A krijgt ten slotte de waarde 10.

(a) Bindingstabel

A B E JA 1 1 1 0B - 1 1 1E - - 0 2J - - - 0

(b) Coderingstabel

Toestand 0 1 Uitgang10 00 10 0

00 00 01 0

01 11 10 0

11 00 01 1

Tabel 4.4: Codering van de Moore-machine van het leidend voorbeeld.

Stap 3B: De keuze van het type flipflop

Nadat we elke toestand kunnen voorstellen met een sequentie aan bits, dienen we flipflops te voorzien omdeze toestand bij te houden. Hierbij hebben we de keuze tussen de verschillende flipflops die we in 4.2.1besproken hebben. Elk van deze types zal een specifieke combinatorische logica vereisen met specifieke kostenen vertraging. Om de meest optimale schakeling te realiseren zullen we altijd alle types moeten uitproberen.Verder kunnen we ook voor verschillende bits een verschillend type flipflop voorzien. Hierop gaan we echterniet in. De ervaring leert ons wel dat voor verschillende toepassingen verschillende soorten flipflops een zekerevoorkeur genieten. De typische toepassingen zeg maar. Een cruciale factor is ook het aantal don’t cares. Inhet algemeen is het zo dat hoe meer don’t cares de combinatorische schakeling bevat, hoe eenvoudiger teimplementeren. Sommige flipflops introduceren makkelijker don’t cares dan andere flipflops.

De kosten van een flipflop Als we de kostprijs van de verschillende types flipflops met elkaar vergelijkenmerken we dat de JK-flipflop opmerkelijk duurder16 is. Dit betekent daarom niet dat de totale kostprijs

16Ter illustratie een JK-flipflop geıntegreerd circuit kost $0.116, een gelijkaardige D-flipflop kost ongeveer $0.049.


van de schakeling groter is. Immers dienen we ook een combinatorisch gedeelte te voorzien; de optelling vanbeide leidt tot de totale kostprijs.

Don’t cares Een JK-flipflop is dan duurder, maar door de typische realisatie leidt dit tot veel don’t cares.Dit leidt tot een eenvoudige schakeling. Het is logisch dat een JK-flipflop nogal wat don’t cares impliceert:er zijn immers enkele manieren om dezelfde waarde in een JK-flipflop te klokken. Ook een SR-flipflop laatruimte voor don’t cares in het combinatorische gedeelte. Een D-flipflop laat doorgaans weinig plaats voordon’t cares. Dit komt omdat in elke klokflank een nieuwe waarde uit de ingang wordt gelezen. We dienener dus telkens voor te zorgen dat op dit moment de juiste waarde aan de ingang staat. Een T-flipflop tenslotte heeft net hetzelfde probleem, meestal is het effect hier zelfs nog erger.

Eenvoud van het ontwerp Indien we de schakeling zelf moeten realiseren moeten we ook rekening houdenmet het tijdsaspect en dus de eenvoud van het ontwerp. Doorgaans leidt een D-flipflop tot de eenvoudigsteimplementatie. Dit komt omdat we meestal geneigd zijn absoluut te denken. Verder heeft een D-flipflop ookslechts een ingang, en is de component makkelijk te specifieren: ”wat we aan de ingang aanleggen staat devolgende klokflank in de flipflop”. Het opstellen van een excitatietabel is dan ook eenvoudig. Een T-flipflopis ook conceptueel eenvoudig: ındien de waarde moet omslaan, leg dan 1 aan op de ingang”. Moeilijker zijnde SR- en JK-flipflop. Dit komt in de eerste plaats omdat beide componenten twee ingangen hebben. Merkdus op dat we een excitatietabel met twee ingangen moeten opstellen.

Toepassingen Door jaren ervaring heeft men kennis opgebouwd welke toepassing welke flipflop vereist.In subsectie 4.2.3 hebben we reeds tellers gebruikt en hebben we vaak gebruik gemaakt van T- en D-flipflops. Tellers en frequentiedelers17 worden typisch geımplementeerd met T-flipflops. Meestal zal dit totijle excitatietabellen leiden. Een D-flipflop wordt typisch gebruikt om een waarde zeer tijdelijk te onthouden,meestal slechts enkele klokflanken. Voor complexe toepassingen waarbij de waarde van de flipflop frequenteen 0 of 1 wordt zijn SR- en JK-flipflops het meest geschikt.

Welke flipflop kiezen? De vorige paragrafen proberen hints te geven welke flipflops het meest geschiktzijn, deze hints zijn echter niet absoluut. Om tot de goedkoopste schakeling te komen, moeten we allemogelijkheden uitproberen. Meestal hebben we de tijd niet alle configuraties te proberen. In dat geval zijnD-flipflops meestal de beste keuze. Ook een FPGA volgt deze redenering en bevat enkel D-flipflops.

Samevatting We vatten de vorige paragrafen samen in tabel 4.5.

Flipflop JK SR D T

Kostprijs -- ++ ++ ++

Don’t cares ++ + - --

Ontwerp -- - ++ +

Toepassingen veel veranderingentijdelijke

geheugenstellers, fre-

quentiedelers

Tabel 4.5: Keuze van het type flipflop.

4.3.5 Stap 4: Implementeren van de combinatorische logica

Met alle vorige stappen hebben we beslist hoe we de specificaties van de sequentiele schakeling zullen imple-menteren. Het enige wat we nu nog moeten doen is de schakeling zelf implementeren. Deze implementatieis op te delen in het implementeren van de logica die de volgende toestand berekent, en de logica die deuitgang bepaalt. We bespreken elk van deze onderdelen apart.

17Een frequentiedeler is een moduloteller die de frequentie waarmee er geteld wordt deelt door het modulo-getal. Enkelwanneer zich een overflow voordoet geven we het signaal door. Hierdoor kunnen we delen van de schakeling aan een lagereklokfrequentie laten werken.


Stap 4A: Logica die de volgende toestand berekent

Excitatietabellen van flipflops Het deel van de logica die de volgende toestand van het circuit berekent isbij zowel een Moore- als een Mealy-machine identiek. Het is een combinatorische schakeling die als ingangende invoer van de component en de toestand heeft, als uitvoer heeft het de ingangen van de flipflops die detoestand bijhouden. Het aantal uitgangen en de uitgangen zelf hangen dus af van het type flipflop die wegekozen hebben. We dienen dus een tabel op te stellen die op basis van de invoer van de schakeling ende toestand aangeeft welke ingangen van welke flipflops hoog of laag moeten zijn. Deze functies noemenwe de excitatiefuncties; deze komen voort uit de excitatietabellen van de verschillende flipflops. Dezetabellen werden reeds geıntroduceerd in 4.2.1. In tabel 4.6 geven we eerst opnieuw een kort overzicht van deexcitatietabellen van de verschillende flipflops. Op basis van deze tabellen kunnen we nu de excitatiefuncties

(a) JK

Q Qnext. J K0 0 0 -0 1 1 -1 0 - 11 1 - 0

(b) SR

Q Qnext. S R0 0 0 -0 1 1 01 0 0 11 1 - 0

(c) D

Q Qnext. D0 0 00 1 11 0 01 1 1

(d) T

Q Qnext. T0 0 00 1 11 0 11 1 0

Tabel 4.6: Excitatietabellen van de verschillende flipflops

berekenen. Deze functies bevatten traditioneel veel don’t cares. Deze don’t cares hebben drie oorzaken:

• De don’t cares die we terug vinden bij de excitatietabellen. Dit zijn don’t cares in de uitgang van defunctie en komen enkel voor bij implementaties met JK- en SR-flipflops.

• Binaire coderingen van toestanden die niet bestaan. Een concreet geval is bijvoorbeeld 011 bij eenone-hot codering. Dergelijke invoer codeert nooit naar een uitvoer.

• Binaire coderingen van ingangscombinaties die niet mogelijk zijn. Stel bijvoorbeeld dat we een 2-bitingang beschouwen en enkel configuraties 00, 01 en 11 kunnen voorkomen.

Deze laatste twee zijn een vorm van invoer die niet kan voorkomen. In een tabel kunnen we de rijen weglaten,of we kunnen de rij opvullen met dont cares aan het uitganggedeelte.

De transitiefunctie We stellen de transitiefunctie op door voor elke bit die de toestand voorstelt de ingan-gen van deze flipflop als uitgangen van onze schakeling te zien. Hiervoor kunnen we eerst het coderingstabelwijzigen. We lineariseren het diagram en laten de uitvoer voorlopig vallen. We illustreren dit concept met deMoore-machine uit het leidende voorbeeld. In tabel 4.6(a) staat de toestandstabel van deze Moore-machinebeschreven. Elke bit van de toestand Fi is een ingang samen met de in dit geval 1-bit ingang Ii van de scha-keling. Als uitgang nemen we voorlopig de bits Di die de volgende toestand voorstellen. Deze linearisatiestaat in tabel 4.6(b). Merk op dat deze reeds de implementatie zijn als we werken met D-flipflops. In hetgeval we niet met D-flipflops werken dienen we nog een extra stap te beschouwen: in dat geval beschouwenwe voor elke flipflop het tuple (Fi, Di). Hierbij geldt Fi = Q en Di = Qnext.. We dienen dan nog enkel op tezoeken welke invoer het specifieke type flipflop nodig heeft in de excitatietabellen (zie tabel 4.6). In het gevalvan een SR- en JK-flipflop leidt dit dus tot een verdubbeling van het aantal uitgangen. Voorbeelden hiervanvoor respectievelijk de T-, JK- en SR-flipflop staan in tabellen 4.6(c), 4.6(d) en 4.6(e). In principe hebbenwe nu alle elementen om de combinatorische schakeling te realiseren. We minimaliseren eerst de functies metbehulp van Karnaugh-kaarten en implementeren dan vervolgens de logica. Merk op dat deze schakelingenmeervoudige uitgangen hebben (1 per D- en T-flipflop en 2 per JK- en SR-flipflop). We kunnen dus ook delogica verder optimaliseren door implicanten over de verschillende Karnaugh-kaarten samen te nemen. Opfiguur 4.22 geven we voor elk type flipflop de Karnaugh-kaarten en een implementatie. Naast de logica voorde volgende toestand, verbinden we ook de klokingangen van de flipflops met het globale kloksignaal, enimplementeren we de clear logica. De clear zorgt ervoor dat op het moment dat we de schakeling herzettenen dus het Clr∗ signaal van de schakeling 0 wordt, de schakeling in de eerste toestand terechtkomt. In ons


(a) Coderingstabel


00 00 01 0

01 11 10 0

11 00 01 1

(b) D-flipflop

F0 F1 I0 D0 D1

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

(c) T-flipflop

F0 F1 I0 T0 T1

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

(d) JK-flipflop

F0 F1 I0 J0 K0 J1 K1

0 0 0 0 - 0 -0 0 1 0 - 1 -0 1 0 1 - - 00 1 1 1 - - 11 0 0 - 1 0 -1 0 1 - 0 0 -1 1 0 - 1 - 01 1 1 - 1 - 1

(e) SR-flipflop

F0 F1 I0 S0 R0 S1 R1

0 0 0 0 - 0 -0 0 1 0 - 1 00 1 0 1 0 0 00 1 1 1 0 - 11 0 0 0 1 0 -1 0 1 - 0 0 -1 1 0 0 1 - 01 1 1 0 1 0 1

Tabel 4.7: Voorstelling van de transitiefunctie van de Moore-machine.

geval is dat 10. Daarom verbinden we de clear-ingang met de preset ingang van de eerste flipflop en declear-ingang van de tweede flipflop. Op de clear-ingang van de eerste flipflop en de preset-ingang van detweede wordt steeds een hoog signaal aangelegd. Merk verder ook op we in principe geen negatieve ingangenvoor toestandssignalen moeten gebruiken. In plaats van een negatie aan de ingang van de AND-poort teplaatsen, kunnen we eenvoudig gebruik maken van de Q-uitgang van de flipflop. Omdat we echter hiermeehet aantal lijnen voor de flipflops bijna verdubbelen, maken we er in de figuur abstractie van. Dit principekunnen we enkel toepassen voor signalen die uit de flipflops komen. De signalen die de ingangsconfiguratiebepalen hebben wel een expliciete NOT-poort nodig.

Het one-hot-codering geval Naast het geval van de Moore-machine zullen we ook de transitiefunctie vande Mealy-machine implementeren. Over deze realisatie is het ook eenvoudiger om enkele eigenschappen teformaliseren. Deze eigenschappen gaan over de kosten van de transitiefunctie voor dat we minimalisatie vande Karnaugh-kaarten toepassen. Verder hangen de eigenschappen af van het type flipflop die we gebruiken:

• Bij een D-flipflop is het aantal AND-poorten voor een flipflop equivalent met het aantal transities naarde toestand die de flipflop voorstelt. Bij een transitie18 naar toestand x dient immer de overeenkomstigeflipflop op 1 gezet te worden, in de andere gevallen is de waarde van de flipflop altijd 0. We kunnendit verder formaliseren tot: “Het aantal enen in de Di kolom is gelijk aan het aantal transities naartoestand i”.

• Bij een T-flipflop is het aantal T-poorten gelijk met het aantal transities die naar een de bijbehorendetoestand gaan, of vanuit de toestand vertrekken, die geen lussen zijn. Of eenvoudiger: “Het aantalenen in de Ti-kolom is gelijk aan het aantal transitites van of naar toestand i die geen lussen zijn”.

• Bij een SR-flipflop is het aantal AND-poorten die naar de S-ingang gaan gelijk aan het aantal transitiesnaar de toestand, die niet uit de toestand komen. Het aantal AND-poorten die voor de R-ingang staanzijn het aantal transities die uit de toestand vertrekken, en die geen lussen zijn. Deze logica kunnenwe ook omzetten naar het aantal enen in de kolommen Si en Ri.

18Inclusief lussen.


D0

F0

F1

I0

1

0

1

0

0

0

1

0

D1

F0

F1

I0

1

0

0

1

0

0

0

1

D Q

QClk

PR

CLR

F0

D Q

QClk

PR

CLR

F1

I0Clk

Clr∗

1

(a) D-flipflops

T0

F0

F1

I0

1

0

1

0

1

1

0

1

T1

F0

F1

I0

0

0

1

1

0

1

0

0

Q

Q

T

Clk

PR

CLR

F0

Q

Q

T

Clk

PR

CLR

F1

I0Clk

Clr∗

1

(b) T-flipflops

J0

F0

F1

I0

1

0

1

0

-

-

-

-

K0

F0

F1

I0

-

-

-

-

1

1

0

1

J1

F0

F1

I0

-

0

-

1

0

-

0

-

K1

F0

F1

I0

1

-

0

-

-

0

-

1

Q

Q

J

Clk

K

PR

CLR

Q

Q

J

Clk

K

PR

CLR

I0Clk

Clr∗

1

(c) JK-flipflops

S0

F0

F1

I0

1

0

1

0

0

0

-

0

R0

F0

F1

I0

0

-

0

-

1

1

0

1

S1

F0

F1

I0

0

0

-

1

0

-

0

0

R1

F0

F1

I0

1

-

0

0

-

0

-

1

Q

QR

Clk

S

PR

CLR

Q

QR

Clk

S

PR

CLR

I0Clk

Clr∗

1

(d) SR-flipflops

Figuur 4.22: Implementatie van de Moore-schakeling met verschillende soorten flipflops.

• Bij JK-flipflops gelden dezelfde regels als bij de SR-flipflops, we dienen hier S door J en R door K tevervangen.

We kunnen deze theorie testen met de praktijk in tabel 4.8. Hierbij hebben we de tabellen voor de ver-schillende types flipflops naast elkaar gezet, dit is louter om de voorstelling eenvoudig te houden. Merk opdat verschillende rijen uitsluitend don’t cares bevatten. Dit is het gevolg van het feit dat heel wat binairevoorstellingen van toestanden bij de invoer geen overeenkomstige toestand hebben. Meestal worden dezerijen in een tabel weggelaten, wat de tweede tabel een stuk korter en leesbaarder maakt. Uiteraard dienenwe dan wel op deze plaatsen in de Karnaugh-kaarten don’t cares te plaatsen. We zien dat D0 een 1 bevat,wat overeenkomt met een transitie naar toestand E op figuur 4.20(b), verder bevatten de kolommen voortoestand A en B respectievelijk 2 en 3 enen. Bij de JK-flipflop heeft toestand A 1 transitie naar A en 1transitie uit A. We zien dat dit ook overeenkomt met het aantal enen bij J2 en K2. We kunnen dus besluitendat dergelijke eigenschappen handig kunnen zijn bij het controleren van onze tabel. Een andere eigenschapis dat bij een T-flipflop er altijd twee bits veranderen. Bij elke rij zijn er dus ofwel 0 enen ofwel 2. Op figuur4.23 implementeren we de D- en JK-flipflop variant van de Mealy-machine. Het implementeren van de T- enSR-flipflop variant wordt als een oefening voor de lezer overgelaten. Merk op dat we hier de verbindingennaar de Clr∗ en Pr∗ ingangen anders geconfigureerd zijn dan bij de Moore-machine. Dit komt omdat debegintoestand van de Mealy-machine 001 is, terwijl dit 10 is bij de Moore-machine.


(a) D- en JK-flipflops

F0 F1 F2 I0 D0 D1 D2 J0 K0 J1 K1 J2 K2

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

(b) T- en SR-flipflops

F0 F1 F2 I0 T0 T1 T2 S0 R0 S1 R1 S2 R2

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

Tabel 4.8: Implementatie van de Mealy-schakeling met verschillende soorten flipflops.

Stap 4B: Logica die de uitgang toestand berekent

Naast de logica die de volgende toestand berekent, dienen we ook de de logica te synthetiseren die deuitgangen bepaalt. Dit is eigenlijk niets anders dan het synthetiseren van een combinatorische schakeling.Hiervoor dienen een tabel op te stellen die vanuit de coderingstabel een tabel opstelt die de functie bepaalt.Vermits de uitgang bij een Moore-machine anders bepaald wordt dan bij een Mealy-machine, zal ook detechniek om deze tabel op te stellen licht verschillen. Bij een Moore-machine wordt de uitgang enkel bepaalddoor de toestand. Hierdoor kunnen we de tabel opstellen door de transitiekolommen weg te laten. Bij eenMealy-machine dienen we een linearisering toe te passen. Hierbij beschouwen we niet meer de codering vande volgende toestand zoals in de vorige stap, maar uiteraard de uitgang. Vanuit die tabel stellen we danopnieuw een combinatorische schakeling op. Merk op dat deze schakeling niet afhangt van het type flipflop.Immers hebben alle types flipflop een Q-uitgang. De schakeling hangt wel af van de toestandscodering. Optabel 4.9 toont de tabellen die we opstellen voor de Moore- en Mealy-machine naast hun coderingstabellen.

(a) Moore coderingstabel


00 00 01 0

01 11 10 0

11 00 01 1

(b) Moore

F0 F1 O0

0 0 00 1 01 0 01 1 1

(c) Mealy coderingstabel

Toestand 0 1001 010/0 001/0

010 010/0 100/0

100 010/1 001/0

(d) Mealy

F0 F1 F2 I0 O0

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

Tabel 4.9: Uitgangslogica van de Moore- en Mealy-machine naast hun coderingstabellen.


D0

F0

F1

F2

I0

- 0 0 -

0 - - 1

- - - -

0 - - 0

D1

F0

F1

F2

I0

- 1 0 -

1 - - 0

- - - -

1 - - 0

D2

F0

F1

F2

I0

- 0 1 -

0 - - 0

- - - -

0 - - 1

D Q

QClk

PR

CLR

FF0

D Q

QClk

PR

CLR

FF1

D Q

QClk

PR

CLR

FF2

I0

Clk

Clr∗

1

1

1

(a) D-flipflop

J0

F0

F1

F2

I0

- 0 0 -

0 - - 1

- - - -

- - - -

K0

F0

F1

F2

I0

- - - -

- - - -

- - - -

1 - - 1

J1

F0

F1

F2

I0

- 1 0 -

- - - -

- - - -

1 - - 0

K1

F0

F1

F2

I0

- - - -

0 - - 1

- - - -

- - - -

J2

F0

F1

F2

I0

- - - -

0 - - 0

- - - -

0 - - 1

K2

F0

F1

F2

I0

- 1 0 -

- - - -

- - - -

- - - -

Q

Q

J

Clk

K

PR

CLR

Q

Q

J

Clk

K

PR

CLR

Q

Q

J

Clk

K

PR

CLR

I0

Clk

Clr∗

1

1

1

1

(b) JK-flipflop

Figuur 4.23: Implementatie van de Mealy-schakeling met verschillende soorten flipflops.

Daarna is het alleen nog een kwestie van de schakeling te implementeren, dit wordt meestal opnieuw gedaanmet behulp van Karnaugh-kaarten. We implementeren vervolgens op figuur 4.24 een volledige sequentieleschakeling gebaseerd op de Mealy-machine met een D-flipflop. Merk op dat we in deze figuur gebruikmaken van de Q-uitgangen. Hoewel we in de figuur de logica implementeren met AND-OR logica zal menin de praktijk altijd opteren voor NAND- en NOR-poorten bij de implementatie. Een andere interessantevaststelling dat het geheugen van de tweede flipflop niet gebruikt wordt. We kunnen bijgevolg deze flipflopen de logica er rond weglaten. Deze extra flipflop is het gevolg van een slecht gekozen toestandscodering.Dit drukt niet alleen de kosten, maar zorgt ook voor een kleinere vertraging waardoor we de klokfrequentiekunnen opdrijven. We gaan kort in op het tijdsgedrag in subsectie 4.3.6.

4.3.6 Tijdsgedrag

Tot slot bepalen we de maximale klokfrequentie die we bij een implementatie van een sequentiele schakelingkunnen hanteren. We herinneren ons uit het hoofdstuk over combinatorische schakelingen dat de vertragingin een systeem bepaald wordt door het kritische pad, de maximale tijd die een signaal nodig heeft om zichdoorheen de schakeling voort te planten. In een sequentiele schakeling betekent dit dat het signaal zichdoorheen de combinatorische schakeling dient te propageren die de volgende toestand bepaalt. Verder dientook de set-tup-tijd van de geheugenmodules en de tijd die het kloksignaal nodig heeft om zich tot aan deQ- of Q-uitgang te propageren in rekening te worden gebracht. Bij het bepalen van het kritische pad vande transitiefunctie moeten we alle paden vanuit alle ingangen (dus ook de flipflops die toestand bijhouden)beschouwen, naar alle flipflops. Of formeler:

vertraging pad = logica transitie + set-up flipflop + Clk naar Q of Q (4.12)

De vertragingen van de klok naar Q en Q kunnen we berekenen vanuit de implementatie van de flipflop.De fabrikant van een flipflop zal bovendien steeds deze vertragingen in het datasheet19 van de componentzetten. Indien de implementatie gegeven is, kunnen we de vertraging berekenen. Indien we een master-slaveD-flipflop gebruiken dienen we enkel rekening te houden met de propagatietijd van de klok naar Q of Q van

19Elk geıntegreerd circuit heeft een datasheet, een document opgesteld door de producent die de karakteristieken van decomponent formeel beschrijft.


O0

F0

F1

F2

I0

- 0 0 -

0 - - 0

- - - -

1 - - 0

D Q

QClk

PR

CLR

FF0

D Q

QClk

PR

CLR

FF1

D Q

QClk

PR

CLR

FF2

1

1

1

O0

I0

Clr∗

Clk

Figuur 4.24: Volledige implementatie van de Mealy-machine met D-flipflops.

een D-latch. We hebben deze vertragingen reeds uitgerekend in vergelijking (4.3) op pagina 97. Eenmaalwe de vertraging van het kritisch pad hebben berekend kunnen we de maximale klokfrequentie bepalen. Ditdoen we door het inverse te berekenen van deze vertraging:

fmax. =1

vertraging kritisch pad(4.13)

Merk wel op dat we bij het berekenen van de vertraging geen eenheid gegeven hebben. Deze vertragingen diewe tot hier toe hebben berekend dienen uitsluitend om verschillende implementaties met elkaar te vergelijken.In de praktijk zal de technologie waarmee we de schakeling realiseren een tijdseenheid impliceren waarmeewe die vertraging kunnen vermenigvuldigen.

Leidend voorbeeld

Moore-machine We berekenen de vertraging van de implementatie van de Moore-machine die beschrevenstaat op figuur 4.22(a). In totaal kunnen we 10 verschillende paden onderscheiden: in de schakeling staantwee flipflops. Het signaal van deze flipflops vormt een ingang bij alle 5 de AND-poorten. Merk op dat we deinverter aan de AND-poort niet moeten meetellen in onze berekening. We dienen in dat geval de Q-uitgangte beschouwen. In de onderstaande vergelijking berekenen we de vertraging van alle paden. Het subscriptvan de vertraging wijst op de bron- en doel-flipflop, en de AND-poort. Deze poorten nummeren we van 0

4.4. ASYNCHRONE SCHAKELINGEN 123

tot 4 van boven naar beneden:

tFF0→FF0,0 = Clk→ Q+ set-up D + 2-AND + 2-OR = 4.2 + 1 + 2.4 + 2.4 = 10.0tFF0→FF0,1 = Clk→ Q+ set-up D + 3-AND + 2-OR = 4.2 + 1 + 2.8 + 2.4 = 10.4tFF0→FF1,2 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8tFF0→FF1,3 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8tFF0→FF1,4 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8tFF1→FF0,0 = Clk→ Q+ set-up D + 2-AND + 2-OR = 4.2 + 1 + 2.4 + 2.4 = 10.0tFF1→FF0,1 = Clk→ Q+ set-up D + 3-AND + 2-OR = 4.2 + 1 + 2.8 + 2.4 = 10.4tFF1→FF1,2 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8tFF1→FF1,3 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8tFF1→FF1,4 = Clk→ Q+ set-up D + 3-AND + 3-OR = 4.2 + 1 + 2.8 + 2.8 = 10.8

(Voorbeeld)

(4.14)Het maximale pad heeft dus een vertraging van 10.8. Indien we een referentievertraging van 1 ns nemen,is de maximale frequentie fmax. = 1/10.8 ns ≈ 93 MHz. Indien we dezelfde schakeling met NAND-NANDlogica zouden hebben gebouwd, zou de vertraging van elk pad gereduceerd worden met 2. In dat geval zoude maximale klokfrequentie fmax. = 1/8.8 ns ≈ 114 MHz.

Mealy-machine Voor de Mealy-machine gebruiken we de implementatie op figuur 4.24. In deze schakelingdienen we twee paden te beschouwen: het eerste loopt van FF1 naar FF0, vertrekt vanuit Q en gaat dooreen 2-AND-poort. Het andere pad ligt tussen FF1 en FF2. Ook hierbij passeren we een 2-AND-poort, merkechter op dat het signaal vertrekt vanuit Q. De vertraging van dit pad is dus gelijk aan:

tFF1→FF0 = Clk→ Q+ set-up D + 2-AND = 4.2 + 1 + 2.4 = 7.6tFF1→FF2 = Clk→ Q+ set-up D + 2-AND = 4.2 + 1 + 2.4 = 7.6

(Voorbeeld) (4.15)

Beide paden hebben hier dus dezelfde vertraging. Als we een referentievertraging van 1 ns nemen, is demaximale frequentie fmax. = 1/7.6 ns ≈ 131 MHz.

4.4 Asynchrone schakelingen

Naast schakelingen waar het ritme bepaald wordt door een klok, bestaan er ook schakelingen die een vormvan geheugen bezitten, maar van toestand veranderen doordat het ingangssignaal verandert. We hebbenin dit hoofdstuk reeds dergelijke schakelingen geımplementeerd. In Subsectie 4.2.1 hebben we een latchgeconstrueerd. Een latch heeft in principe geen klokingang, maar houdt wel een toestand bij. Op het momentdat we een ingang aan een SR-latch aanpasen, zal de latch soms in een andere toestand terechtkomen. Verderbezit de component ook duidelijk een geheugen vermits als de ingang (S,R) = (0, 0), de vorige toestandbehouden blijft. De situatie van de latch illustreert hoe asynchrone schakelingen worden gerealiseerd: Wehebben een aantal ingangssignalen, die door logica worden verwerkt in een soort geheugen. Dit geheugenvertraagt een terugkoppeling, en houdt de toestand bij. Het terugkoppelen betekent dat de uitgangen vaneen logische schakeling als een deel van de invoer fungeren die door die logica verwerkt wordt. In dezecursus zullen we uitsluitend asynchrone sequentiele schakelingen beschouwen die voldoen aan een belangrijkevoorwaarde: de fundamentele modus, ofwel de “fundamental mode restriction”. Deze beperking bestaatuit twee delen:

• Er mag hooguit een ingangssignaal tegelijk veranderen. Een voorbeeld die dit concept duidelijk illu-streert is de SR-latch: indien we S en R ingang tegelijk van 1 naar 0 omschakelen, komt de componentin een oscillerend toestand komt.

• Een ingangsverandering mag slechts optreden als alle effecten van de vorige verandering uitgestorvenzijn. Ook dit principe kennen we al impliciet. Zo dienen we de set-up tijd van een flipflop te respecterenom te voorkomen dat de flipflop in een onvoorspelbare toestand komt.

We zijn in principe niet verplicht om ons aan deze voorwaarden te houden, het ontwerpen van schakelingendie deze restricties niet volgen is echter zeer moeilijk.


Ook bij het ontwerpen van een asynchrone schakeling zullen we een stappenplan volgen. In grote lijnenlijkt deze procedure op het ontwikkelen van synchrone schakelingen. De stappen zelf wijken echter sterk afvan hun synchrone variant. In de meeste stappen zullen we ook met de complexe problemen die eigen zijnaan een asynchrone schakeling moeten rekening houden. Het plan bestaat uit 4 stappen:

1. Opstellen van een toestandstabel.

2. Minimaliseren van het aantal toestanden.

3. Coderen van de toestanden.

4. Realisatie van de schakeling met digitale logica.

Terminologie Bij synchrone schakelingen werkten we met een klokflank. Vaak gebruikt men bij een klok-signaal de termen “stijgende klokflank” en “dalende klokflank”. Dit zijn immers de tijdstippen waaropgebeurtenissen plaatsvinden in de schakeling die relevant zijn. Een asynchrone schakeling heeft geen klok-signaal. Toch worden de termen “stijgende flank” en “dalende flank” ook in deze context gebruikt. Degebeurtenissen in een asynchrone schakeling zijn immers de omschakeling van een van de ingangssignalen.

4.4.1 Leidend voorbeeld

Een oplettende lezer heeft misschien al opgemerkt dat de geheugencomponenten die we gebruiken in syn-chrone schakelingen – latches en flipflops – op hun beurt weer asynchrone schakelingen zijn. Daarom zul-len we een nieuw type latch ontwerpen, die uiteraard louter fictief is. De latch wordt gebruikt als eeninterrupt-register. In de meeste computers voert een programma niet constant controles uit of een gebruikerbijvoorbeeld een toets aanslaat. De CPU bevat een component die bijhoudt of er een bepaalde gebeurtenisplaatsvindt. Hardwarematig controleert de CPU frequent of zo’n gebeurtenis is opgetreden. In dat gevalvoert de processor een procedure uit gedefinieerd door het besturingssysteem. Op dat moment dient decomponent uiteraard gereset te worden. Verder kan een besturingssysteem ook een masker plaatsen op eeninterrupt. In dat geval zal de CPU niet reageren op deze gebeurtenis. Deze component heeft twee ingangenI en E. I zal een stijgende flank vertonen wanneer de gebruiker een toets aanslaat, maar zal na enige tijdweer dalen. E bepaalt of de CPU luistert naar deze interrupt. Indien E = 0 heeft het besturingssysteem eenmasker gezet. Indien we een laag signaal op E aanleggen wordt een reset op de module uitgevoerd. Dit ishet geval wanneer de processor de procedure van het besturingssysteem zal uitvoeren. Op het moment datde procedure uitgevoerd is, zetten we E dan terug hoog om te luisteren naar een mogelijke gebeurtenis. Deuitgang Q vertelt ons of er een gebeurtenis is opgetreden op het moment dat er geen masker op de interrupt.

Formele beschrijving De vorige paragraaf is relatief informeel beschreven. We zetten deze beschrijvingom in een formeler equivalent. Dit doen we aan de hand van tabel 4.10. In de eerste kolom plaatsen we degebeurtenis. Dit is dus een ingang die van waarde verandert. De tweede kolom bevat de voorwaarden dierelevant zijn voor deze regel. Dit zijn testen in verband met ingangen en uitgangen. De derde kolom tenslotte bevat het effect. Een effect houdt in dat de uitgang verandert. Merk verder op dat het onmogelijk is

Gebeurtenis Voorwaarde(n) Effect(en)I : 0→ 1 E = 1 Q→ 1E : 1→ 0 Q→ 0

Tabel 4.10: Formele beschrijving van het leidend voorbeeld.

dat Q een 1 bevat en E een 0.

4.4.2 Stap 1: Opstellen van een toestandstabel

Net zoals bij de synchrone schakelingen stellen we eerst een toestandstabel op. Een eerste vraag die zichstelt is wat een toestand is. Een toestand is elke combinatie van in- en uitgangen waarin de schakeling


kan terechtkomen. De schakeling die we zullen implementeren telt 3 verschillende signalen. Dit betekentdus dat we hooguit 8 toestanden kunnen bekomen. Aangezien configuraties met (Q,E) = (1, 0) onmogelijkkunnen voorkomen houden we 6 toestanden over. We stellen een configuratietabel op die voor elke mogelijkeconfiguratie een toestand voorziet in tabel 4.10(a). Op basis van deze configuratietabel kunnen we nu een

(a) Configuratietabel

Toestand Q I Ea 0 0 0b 0 0 1c 0 1 0d 0 1 1

(onmogelijk) 1 0 0e 1 0 1

(onmogelijk) 1 1 0f 1 1 1

(b) Toestandstabel

ToestandI E

Q00 01 11 10

a a b − c 0b a b f − 0c a − d c 0d − b d c 0e a e f − 1f − e f c 1

Tabel 4.11: Configuratie- en toestandstabel van het leidend voorbeeld.

toestandstabel maken. Deze toestandtabel loopt erg gelijk met een toestandstabel van een Moore-machine.De tabel bestaat uit drie delen: toestand, invoer en uitvoer. Een verschil met de toestandtabel van deMoore-machine is dat we niet alle kolommen invullen bij elke toestand. Een toestand is immers gekoppeldaan een bepaalde invoerconfiguratie20, de fundamentele modus zorgt ervoor dat er slechts een bit tegelijkkan omslaan, bijgevolg kunnen we kolommen die op meerdere bits afwijken niet invullen. Concreet betekentdit dat we voor een invoer van n-bits, n+ 1 van de 2n kolommen kunnen invullen. In de overige kolommenschrijven we een liggende streepje (“-”). Veelal zal men ook de kolommen van de toestandtabel andersschikken. Men probeert configuraties die slechts een bit verschillen naast elkaar te plaatsen. Dit is echterniet vereist.

We stellen de toestandstabel op met behulp van de configuratietabel en de tabel met mogelijke gebeurte-nissen. Toestand a betekent in dit geval bijvoorbeeld dat we (I, E) = (0, 0) aan de ingangen aanleggen. Hetspreekt dus voor zich dat we bij de kolom met dezelfde configuratie ook een a schrijven. In dat geval is detoestand stabiel. Bij de tweede kolom geldt (I, E) = (0, 1), dit betekent dus dat we een stijgende flank van Ebeschouwen. Uit de gebeurtenissentabel leiden we af dat in dat geval Q op 0 komt te staan. Dit is reeds hetgeval. We migreren dus naar de toestand met (Q, I,E) = (0, 0, 1). Op de configuratietabel zien we dat dittoestand b is. Bij de laatste kolom beschouwen we een stijgende flank van I, opnieuw gebeurt er niets vermitser niet aan de voorwaarden wordt voldaan in de gebeurtenissentabel. Op deze manier kunnen we de volledigetoestandstabel opstellen zoals in tabel 4.10(b). We kunnen ook met behulp van een toestandsdiagram eengrafische voorstelling van deze tabel geven. Het toestandsdiagram staat op figuur 4.25.

Een toestandtabel bij asynchrone schakelingen wordt ook een “flow table” genoemd. Indien de tabel nogniet geminimaliseerd is, spreekt met van een “primitive flow table”.

4.4.3 Stap 2: Minimaliseren van de toestanden

Net als bij synchrone schakelingen loont het meestal de moeite om de toestandsruimte te minimaliseren.Dit leidt immers in de meeste gevallen tot een goedkopere schakeling. Vermits het probleem anders is,vertoont de minimalisatie van asynchrone schakelingen ook verschillen tegenover synchrone schakelingen.Een belangrijk verschil is dat we in de flow toestandstabel ook rekening moeten houden met don’t cares.Elke toestand heeft er immers 2n − n − 1 bij n-bit invoer. Daarnaast kunnen er uiteraard nog bijkomendedon’t cares optreden die probleemafhankelijk zijn. Meestal laten deze don’t cares toe om op een flexibelemanier de toestandsruimte te minimaliseren.

20Beschreven in de configuratietabel.


e

1

f

1

a

0

b

0

c

0

d

0

00

01

1000

01

11

00

10

1100

10

11

00

01

11

01

11

10

Figuur 4.25: Toestandsdiagram van het leidend voorbeeld.

Er bestaan verschillende methodes om de toestandsruimte te minimaliseren. We opteren voor een methodedie werkt met twee stappen. Allereerst is er de partitionering. Deze partitionering is volledig analoog aan desequentiele schakelingen (zie 4.3.3 op pagina 110). We dienen echter de voorwaarden van deze partitioneringminimaal aan te passen. De nieuwe voorwaarde wordt dan:

1. De toestanden hebben dezelfde uitgangscombinatie.

2. De don’t cares bevinden zich in dezelfde kolommen.

Vervolgens passen we opnieuw de iteratiestap toe zoals bij synchrone schakelingen. De voorwaarden veran-deren hierbij niet.

Nadat we de partitionering berekend hebben, kunnen we een eerste toestandsreductie toepassen. Bijde synchrone schakelingen betekent de toestandreductie dan ook meteen het einde van de minimalisatie.Bij synchrone schakelingen kunnen we verder reduceren. Hiertoe berekenen we compatibele toestanden21.Twee toestanden Si en Sj zijn equivalent indien:

1. Dezelfde uitvoerconfiguratie hebben

2. Voor elke ingangscombinatie geldt ofwel:

(a) Si en Sj zijn beide stabiel

(b) De volgende toestand van minstens een van de twee toestanden Si of Sj is niet gespecificeerd, erstaat dus een don’t care in de kolom van minstens een van de toestanden.

(c) Beide toestanden gaan naar dezelfde toestand Sk.

Merk op dat de toestanden Si, Sj en Sk niet de toestanden zijn uit de initiele toestandstabel, maar uit de doorpartitionering reeds gereduceerde toestandstabel. Een andere mogelijke valkuil is dat beide toestanden naardezelfde toestand moeten gaan, niet naar twee compatibele of equivalente toestanden. De reden hiervooris dat de compatibiliteitsrelatie niet transitief is: Als toestand A compatibel is met toestand B en B iscompatibel met toestand C, is A niet noodzakelijk compatibel met toestand C. De relatie is echter welsymmetrisch22 en uiteraard reflexief.

21Bemerkt het verschil met “equivalente toestanden” bij de partitionering.22Dit kunnen we eenvoudig aantonen door Si en Sj om te wisselen. In dat geval zien we dat de voorwaarden niet veranderen.


Het feit dat er de compatibiliteitsrelatie niet transitief is introduceert ook een nieuw probleem: we willenverschillende compatibele toestanden samennemen in een nieuwe toestand, een zogenaamde kliek Kn. Ver-mits hiervoor elke twee toestanden compatibel met elkaar moeten zijn, is dit proces niet deterministisch. Menkan dit probleem op verschillende methodes oplossen. In de praktijk lost men dit vaak op met behulp vanprogramma’s die zoeken naar een zo goed mogelijke groepering. Nadat we een groepering hebben bepaald,minimaliseren we opnieuw de toestandentabel. Dit betekent echter nog niet dat het minimalisatiealgoritmeten einde is: door het groeperen van toestanden in een nieuwe toestand, kunnen deze nieuwe toestandenweer compatibiliteit vertonen. We dienen dus opnieuw een compatibiliteitsrelatie op te bouwen en eventueelte minimaliseren. De minimalisatie stopt op het moment dat geen enkele nieuwe toestand meer compatibelis met een andere. Schematisch geven we het hele proces weer in een flowchart op figuur 4.26.

Partitionerenvan de

toestanden

Bepaalcompatibeletoestanden

Groepeercompatibeletoestanden

Samenvoegenvan de

toestandenin een groep

Toestands-tabel

veranderd?

Stop

Start

yesno

Figuur 4.26: Flowchart van het minimalisatieproces van asynchrone schakelingen.

Samenvoegen van toestanden in een nieuwe toestand Hoe bouwen we vanuit een groep toestandeneen nieuwe toestand op? Dit kunnen we in principe al afleiden uit de definitie van compatibele toestanden.Uit de toestanden s1, s2, . . . , sn construeren we een toestand t indien alle toestanden met elkaar compatibelzijn. We dienen bij t ook de overgangen te definieren: s gaat onder een invoer I over naar δ (s, I). Dezefunctie noemen we ook de transitie-functie. Verder voeren we ook een functie G (s) in, deze functie geeft denieuwe toestand weer van de groep waar s toe behoort. We kunnen dan volgende regels op t definieren23:

1. δ (t, I) = − indien ∀i : δ (si, I) = −. We plaatsen een don’t care bij een transitie van t met invoer Ials elke toestanden si onder deze invoer ook een don’t care bevat.

2. δ (t, I) = t indien ∀i : δ (si, I) = − ∨ δ (si, I) ∈ s1, s2, . . . , sn. Indien alle toestanden onder invoer Ibinnen de groep blijven of een don’t care bevatten, vormt t onder invoer I een stabiele toestand.

3. δ (t, I) = u indien ∀i : δ (si, I) = −∨G (δ (si, I)) = u. Indien alle toestanden onder invoer I naar dezelfdegroep transformeren, transformeert t onder deze invoer naar de toestand die deze groep voorstelt.

23We voeren de regels in de volgorde van verschijnen uit. Het kan zijn dat een situatie aan twee criteria voldoet, in dat gevalvoeren we de eerste regel uit.


Voorbeeld

Om alle speciale gevallen in te sluiten gebruiken we een andere toestandstabel beschreven in tabel 4.11(a).Allereerst passen we de initialisatiestap van het partitiealgoritme toe. We dienen hierbij buiten een verschil-

(a) Initiele tabel

ToestandI E

Q00 01 11 10

a a f − c 0b − b h − 1c − c g j 0d − f d − 1e g − d e 1f − f k − 0g l g j − 0h − l h e 1i i e − f 1j b − − j 0k − b k e 1l − l k − 1m m l − e 1

(b) Tabel na partitionering

ToestandI E

Q00 01 11 10

a a f − c 0b − b h − 1c − c g j 0d − f d − 1e g − d e 1f − f h − 0g b g j − 0h − b h e 1i i e − f 1j b − − j 0m m b − e 1

Tabel 4.12: Evolutie van de toestandstabel bij het minimaliseren voor en na partitioneren.

lende uitvoerconfiguratie ook rekening te houden met verschillende don’t care configuraties. Dit leidt tot devolgende partitie:

P0 = a , b, d, l , c , e , f , g , h, k , i,m , j (voorbeeld) (4.16)

Na het iteratieproces bij de partitionering die wel volledig behouden blijft bekomen we volgende partitie:

P1 = a , b, l , c , d , e , f , g , h, k , i , j , m (voorbeeld) (4.17)

Op basis van deze partitionering kunnen we een nieuwe toestandstabel opstellen: tabel 4.11(b). We gebruikenhier telkens de alfabetisch eerste letter van de toestanden die in een bepaalde partitie zitten. Dit is echtereen arbitraire keuze. Vervolgens minimaliseren we verder door een compatibiliteitsrelatie op te stellen. Zois a duidelijk niet compatibel met b net als a en d, ze hebben immers een verschillende uitvoer. Ook (a, c)en (a, e) zijn duidelijk geen elementen van de relatie: a en c gaan onder invoer (0, 1) naar een verschillendetoestand, hetzelfde geldt voor a en e onder invoer (1, 0). (a, f) behoort dan weer wel tot de relatie. Het zijnbeide toestanden met dezelfde uitvoer, en in alle mogelijke invoercombinaties heeft ofwel minstens een van detoestanden een don’t care, of wijzen ze naar dezelfde toestand. Alle andere toestanden zijn niet compatibelmet a omwille van hiervoor opgesomde redenen. We kunnen zo verder alle toestanden tegen elkaar uitspelen,en definieren zo de equivalentierelatie ≡0 als volgt24:

a ≡0 f b ≡0 hb ≡0 m c ≡0 jd ≡0 e f ≡0 jg ≡0 j h ≡0 m

(4.18)

We kunnen deze relatie ook grafisch voorstellen, dit doen we met behulp van een Merger diagram. Hierbijstellen we de toestanden voor als knopen, en indien twee toestanden compatibel zijn, tekenen we een onge-richte boog tussen de knopen die deze toestanden voorstellen. Een dergelijk Merger diagram staat op figuur4.27(a). We kunnen vervolgens een keuze maken welke compatibele toestanden we samennemen. Merk op

24Bij de definitie hebben we de symmetrische redundantie weggelaten. Het spreekt echter voor zich dat als x ≡0 y, dat ookgeldt y ≡0 x


a

f j

c

g b h

m

d ei

(a) Iteratie 1

a b c

d i g

(b) Iteratie 2

a b c

d i

(c) Iteratie 3

Figuur 4.27: Merger-diagrammen van het leidend voorbeeld.

dat we enkel toestanden kunnen samennemen als elke twee toestanden compatibel met elkaar zijn. Zo kun-nen we a, f samennemen, maar a, f, j is niet mogelijk omdat a en j niet compatibel met elkaar zijn. Opfiguur 4.27(a) duiden we met behulp van de stippelijnen aan welke toestanden we hebben samengenomen.Of formeler:

P2 = a, f , b, h,m , c, j , d, e , g , i (voorbeeld) (4.19)

We hadden echter in plaats van c, j ook voor g, j kunnen opteren. Of a, f en c, j kunnen inwisselenvoor f, j. Men kan argumenteren dat we met de laatste configuratie minder toestanden wegwerken. Merkechter op dat we eventueel na deze iteratie nog iteraties kunnen uitvoeren en toestanden wegwerken. Eenstrategie waarin we in elke iteratie het aantal toestanden maximaal reduceren zal niet altijd tot het besteresultaat leiden.

We genereren vervolgens voor elke voorgestelde groep een nieuwe toestand. Deze toestand stellen wemet de alfabetisch laagste letter voor van de toestanden die de groep omvat. De toestandstabel die hieruitvoortkomt staat in tabel 4.12(a). Hierbij voegen we dus de toestanden samen. We zullen in deze tekst de

(a) Iteratie 1

ToestandI E

Q00 01 11 10

a a a b c 0b b b b d 1c b c g c 0d g a d d 1g b g c − 0i i d − a 1

(b) Iteratie 2 en 3

ToestandI E

Q00 01 11 10

a a a b c 0b b b b d 1c b c c c 0d c a d d 1i i d − a 1

Tabel 4.13: Evolutie van de toestandstabel bij het minimaliseren voor en na twee iteraties.

groep b, h,m volledig uitwerken. Deze groep hebben we voorgesteld door b. Bij de invoer (0, 0) zien wedat zowel b als h een don’t care bevatten. Voor m is dit echter een stabiele toestand, bijgevolg is deze ingangook een stabiele toestand. Bij de configuratie (0, 1) wijzen alle toestanden naar b, vermits b in de groep zitdie later b zal worden, plaatsen we b in de tabel. Indien (1, 1) op de ingang wordt aangelegd gaan b en hnaar h, m bevat een don’t care. We kunnen dus zonder problemen ook h invullen bij die don’t care. h is eenonderdeel van de groep die later toestand b zal worden. Bijgevolg kunnen we ook voor deze kolom b invullen.In de laatste configuratie ten slotte – (1, 0) – gaan h en m naar e. We zien dat e een onderdeel is van de groepd, e. Deze groep zal dus later voorgesteld worden door de toestand d. Bijgevolg vullen we d in. Indienwe deze procedure ook toepassen op de andere groepen resulteert dit in tabel 4.12(a). Hiermee zijn we aanhet einde gekomen van de eerste iteratie. Vermist we echter een andere toestandstabel hebben tegenoverhet begin van de iteratie, dienen we een nieuwe iteratie aan te vatten. Hierbij berekenen we opnieuw eencompatibiliteitsrelatie: ≡1. We zullen de berekening van deze relatie achterwege laten, vermits we reeds de


vorige relatie uitgebreid hebben beschreven. We definieren ≡1 op symmetrie na als volgt:

c ≡1 g (4.20)

Het Merger-diagram van deze relatie staat op figuur 4.27(b). Hier is de keuze van de groep wel determinis-tisch. De nieuwe partitie is dus:

P3 = a , b , c, g , d , i (voorbeeld) (4.21)

Op basis van deze partitie ruilen we dus c, g in voor een nieuwe toestand c. De vernieuwde toestandstabelis dan tabel 4.12(b). Merk op dat we niet enkel de rij van toestand c moeten aanpassen. Ook toestandendie naar g kunnen springen, springen nu naar c, bijvoorbeeld toestand d. Opnieuw hebben we dus detoestandstabel aangepast. Dit impliceert dat we nogmaals een iteratie uitvoeren. De compatibiliteitsrelatie≡2 blijkt echter leeg te zijn, geen enkele toestand is dus compatibel met een andere. Dit leidt tot eenMerger-diagram zoals op figuur 4.27(c). We kunnen bijgevolg geen toestanden groeperen waardoor de tabelonveranderd blijft. We hebben dus het aantal toestanden geminimaliseerd tot 5 zoals in tabel 4.12(b).

Alternatieve groepering Bij de eerste iteratie bij het samenvoegen van de toestanden, konden we kiezentussen twee vormen van groeperingen. Ofwel groeperen we c en j ofwel g en j. Anderzijds hadden we ookf en j kunnen samenvoegen, maar deze configuratie is minder voordelig. We zullen bij wijze van extravoorbeeld ook het alternatieve scenario bespreken. Wanneer we dit alternatieve scenario uitwerken bekomenwe na een iteratie de waarden op Tabel 4.13(a). Op basis van deze tabel kunnen we verder bepalen welke

(a) Iteratie 1

ToestandI E

Q00 01 11 10

a a a b c 0b b b b d 1c − c g g 0d g a d d 1g b g g g 0i i d − a 1

(b) Iteratie 2 en 3

ToestandI E

Q00 01 11 10

a a a b c 0b b b b d 1c b c c c 0d c a d d 1i i d − a 1

Tabel 4.14: Evolutie van de toestandstabel bij een alternatieve minimalisering voor en na twee iteraties.

toestanden compatibel zijn. Door de definitie van compatibele toestanden toe te passen zien we dat enkel cen g compatibel met elkaar zijn. Vermits er geen alternatieven zijn, voegen we beide toestanden samen enbekomen we Tabel 4.13(b). We kunnen opmerken dat deze tabel volledig identiek is aan de Tabel 4.12(b).Bijgevolg kunnen we deze tabel ook niet verder minimaliseren. We kunnen ook besluiten dat zelfs wanneer weeen keuze kunnen maken tussen verschillende alternatieven, dit niet noodzakelijk betekent dat we een andereofwel minder minimale configuratie zullen uitkomen. Soms kan men via verschillende keuzes toch hetzelfdeof een even goedkope configuratie bekomen. Anderzijds is dit geen algemeen geldend principe: de keuzewelke toestanden zullen worden samengevoegd kan wel degelijk verschillende eindconfiguraties opleveren.

Leidend voorbeeld Bij wijzen van oefening kan de lezer de toestandstabel van het leidend voorbeeldminimaliseren. De oplossing staat in Subsectie ??.

4.4.4 Stap 3: Codering van de toestanden

Net als bij synchrone schakelingen moeten we elk van deze toestanden op een manier coderen in het geheugen.Het probleem is dat we bij het coderen van toestanden bij asynchrone schakelingen op nieuwe problemenstuiten.


Terminologie

Deze problemen brengen nieuwe terminologie met zich mee die we eerst zullen introduceren:

• Race: Een fenomeen dat optreedt wanneer door een ingangsbit te veranderen er minstens twee toe-standsvariabelen moeten veranderen.

• Critical race: Indien een race tot een tijdelijk verkeerde toestand leidt (de codering van een anderetoestand dus) spreken we van een critical race.

• Cycle: Een sequentieel circuit werkt met terugkoppeling. Door deze terugkoppeling kunnen er oscille-rende effecten optreden. Een race die in een oscillerend effect uitmondt heet een cycle.

Het optreden van deze een critical race of cycle hangt af van de vertragingskarakteristieken van de poorten.Het spreekt voor zich dat we trachten om deze fenomenen te voorkomen. Daarom zullen we ook techniekenontwikkelen die ons toelaten een goede toestandscodering te ontwikkelen waarbij we deze problemen reedskunnen voorkomen. Figuur 4.28 illustreert het principe van een critical race en cycle. Op Figuur 4.28(b) en

S 〈i, e〉 Qs1s0 00 01 11 10 q

00 00 01 00 00 001 00 01 10 −− 010 00 10 10 00 1

(a) Toestandstabel.

ie

qs1

s0

a

b

(b) Implementatie 1.

ie

qs1

s0

a′

b′

(c) Implementatie 2.

s1

s0

b

a

i

(d) Verwacht gedrag.

s0

s1

b′

a′

i

(e) Cycle.

s1

s0

b

a

i

(f) Critical race.

Figuur 4.28: Voorbeelden van een cycle en critical race.

Figuur 4.28(c) stellen we twee equivalente asynchrone schakelingen voor. Het enige wat we hebben aangepastis de twee NAND-poorten omzetten naar AND-poorten alsook een NAND-poort naar een OR-poort. In eencombinatorische schakeling is dit een perfect geldige transformatie die tot equivalente resultaten leidt. Inde implementatie bepalen de signalen s0 en s1 samen de toestand, q bepaald de uitvoer en i en e de invoer.Bij wijze van voorbeeld beschouwen we het systeem in een toestand 〈s0, s1〉 = 〈1, 0〉 met aan de ingang eensignaal 〈i, e〉 = 〈0, 1〉. We veranderen vervolgens het signaal van i waardoor we volgens de toestandstabelop Figuur 4.28(a) in toestand 〈s0, s1〉 = 〈1, 0〉 zullen terechtkomen. Wanneer we dit doen volgens de eersteschakeling bekomen we het tijdsgedrag zoals op Figuur 4.28(d). We zien dat beide toestandsignalen tegelijkveranderen. Zelfs wanneer er een klein tijdsverschil op de verandering zit zal dit echter niet tot groteproblemen leiden.

Wanneer we echter werken met de tweede oplossing is het tijdsverschil veel groter. Hierdoor ontstaat er eenterugkoppeling tussen het signaal b′ en s1. Beide reageren telkens op de verandering van de ander waardoorwe in een cycle terechtkomen. De toestandsverandering wordt dus 〈s0, s1〉 = 〈0, 1〉 → 〈0, 0〉 → 〈0, 1〉 → . . ..


Het aantal bits dat verandert tussen twee toestanden is een belangrijke eigenschap, deze wordt vaak ookde “Hamming distance” ofwel “Hammingafstand” genoemd, en is enkel gedefinieerd tussen twee bitreeksenvan dezelfde lengte.

Elimineren van critical races

Men kan critical races elimineren door ervoor te zorgen dat er nooit twee of meer toestandssignalen tegelijkmoeten veranderen. Overgangen zoals van 00 naar 11 zijn dus uit den boze. Er zijn grofweg drie methodeswaarmee we dit kunnen realiseren. We zullen deze methodes ordenen volgens het vermogen om problemenop te lossen. Zo is de laatste methode in staat om alle problemen op te lossen, maar zal deze meestal eenhoge kostprijs met zich meebrengen. We proberen dus de problemen op te lossen in de volgorde waarin demethodes worden voorgesteld. Verder zullen de methodes meestal in staat zijn een gedeelte van het probleemop te lossen, waarna de andere methodes de overige problemen kunnen oplossen. De methodes zijn:

1. Het kiezen van een toestandscodering die elke overgang realiseert door hooguit een bit te veranderen.

2. Werken met zogezegde “tussentoestanden”: via een reeds bestaande toestand toch de finale toestandbereiken, bij de verschillende overgangen verandert dan telkens slechts een bit.

3. Het introduceren van “overgangstoestanden”: nieuw toestanden toevoegen die geen functionaliteithebben buiten deze van het doorverwijzen naar een andere toestand.

We zullen elk van deze methodes in de volgende subsubsecties bespreken en toepassen op twee voorbeelden.De toestandstabellen van beide voorbeelden zijn gegeven in Tabel 4.14(a) en Tabel 4.14(b). In de tabellen

(a) Voorbeeld 1.

Toestand 00 01 11 10 Uitgang

a a1 b a2 c 00b b3 b4 c d 01c a c5 c6 d 10d b − a d7 11

(b) Voorbeeld 2.

Toestand 00 01 11 10 Uitgang

a a1 b a2 a3 0b a b4 − c 0c a c5 a c6 1

Tabel 4.15: Toestandstabellen van de leidende voorbeelden bij de asynchrone toestandscodering.

werden sommige overgangen geannoteerd met een subscript. Deze overgangen zijn stabiele configuraties: eenset van toestanden ingangbits die tot dezelfde toestand zullen leiden. In het eerste geval zijn er zeven vandeze stabiele configuraties, in het tweede voorbeeld zes. Deze configuraties zijn:

T1 =

〈a, 〈0, 0〉〉1〈a, 〈1, 1〉〉2〈b, 〈0, 0〉〉3〈b, 〈0, 1〉〉4〈c, 〈0, 1〉〉5〈c, 〈1, 1〉〉6〈d, 〈1, 0〉〉7

T2 =

〈a, 〈0, 0〉〉1〈a, 〈1, 1〉〉2〈a, 〈1, 0〉〉3〈b, 〈0, 1〉〉4〈c, 〈0, 1〉〉5〈c, 〈1, 0〉〉6

(4.22)

Deze stabiele configuraties spelen een belangrijke rol in de verschillende methodes en het transitiediagram.

Methode 1: Zoeken naar een goede codering

Hierbij kunnen we terugdenken aan de “minimal-bit-change” en de “Gray-code teller” uit 4.3.4. Deze me-thode lost in de meeste gevallen reeds heel wat problemen op. Een methode die het beste resultaat oplevert is


alle mogelijk toestandscoderingen afgaan en vervolgens het aantal overgangen met 1 veranderende bit tellen.Deze methode is niet efficient vermits we O (n!) verschillende configuraties moeten analyseren. We kunnenuiteraard met behulp van heuristische methodes reeds tot een acceptabele configuratie komen. Bovendienis de kans groot dat niet elke overgang tot 1 veranderende bit is te herleiden, in dat geval moeten we deandere methodes gebruiken. Een optimale configuratie in methode 1 leidt niet noodzakelijk tot het besteeindresultaat.

Voorbeeld Bij wijze van voorbeeld zullen we een goede codering zoeken voor beide voorbeelden. Heteerste geval (Tabel 4.14(a)) kunnen we oplossen met behulp van een heuristiek. Zo kennen we de toestandd de codering 10 toe. Omdat er slechts een overgang is tussen c en d, zullen we c de encodering 01 geven. akrijgt de encodering 00 omdat er zowel overgangen tussen a en c, als tussen a en d zijn. b krijgt ten slottede overblijvende codering 11. Het resultaat van deze codering staat in de coderingstabel in Tabel 4.15(a).We voeren ook wat nieuwe syntax in die het ons in de volgende stappen makkelijker zal maken: stabieleconfiguraties zullen we noteren tussen twee vertical bars (“|”) in de tabel. Cellen waarbij de toestand naareen andere toestand gaat waarbij de encodering minstens twee bits verandert worden onderlijnd. Dezeconfiguraties zullen we nog trachten aan te passen met de volgende methodes.

(a) Voorbeeld 1, alternatief 1.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 11 |00| 01 0011 |11| |11| 01 10 0101 00 |01| |01| 10 1010 11 − 00 |10| 11

(b) Voorbeeld 1, alternatief 2.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| 11 0001 |01| |01| 11 10 0111 00 |11| |11| 10 1010 01 − 00 |10| 11

(c) Voorbeeld 2.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| |00| 001 00 |01| −− 10 010 00 |10| 00 |10| 1

Tabel 4.16: Coderingstabellen van het voorbeeld na het toepassen van de eerste methode.

In het geval van een klein aantal toestanden kunnen we exhaustief zoeken. Dit wordt vergemakkelijktomdat we symmetrieen kunnen uitbuiten. De concrete codering maakt immers niet zoveel uit, zolang deHammingafstand maar dezelfde blijft. We introduceren hiervoor een transitiediagram. Een transitiediagramis een grafe waarbij de knopen toestanden voorstellen. We plaatsen bogen tussen twee toestanden wanneerer transities tussen twee toestanden kunnen plaatsvinden. Deze bogen bevatten de annotaties naar welkestabiele configuratie deze transitie uiteindelijk zal migreren. Deze annotaties worden opgedeeld in twee types.Wanneer we na de overgang meteen in een stabiele configuratie terecht komen zetten we de bijbehorendeannotatie op de boog zonder deze te onderlijnen. Wanneer we echter na deze toestand niet in een stabieleconfiguratie terechtkomen, noteren we de annotatie van de stabiele toestand waar we uiteindelijk in zullenterecht komen en wordt deze onderlijnd.

Het eerste leidende voorbeeld telt vier toestanden. We kunnen bijgevolg een grafe beschouwen met viertoestanden. Rotaties en spiegelingen bij deze grafes dienen we niet te beschouwen. De Hammingafstand blijftimmers onder deze transformaties gelijk. Bijgevolg zijn er slechts twee mogelijke configuraties voorgesteld opFiguur 4.29(a) en Figuur 4.29(b). Zoals we kunnen vaststellen komt Figuur 4.29(a). We kunnen door tweehorizontale of verticale buren om te wisselen de andere versie bekomen. Indien we dit doen – bijvoorbeeldmet B en C – bekomen we het alternatief op Figuur 4.29(b). We hebben dit alternatief ook in tabelvorm


A

00

B

11D

10

C

01

4;7

6;7

7

3;7

2;7

1;7

(a) Voorbeeld 1, alternatief1.

A

00

B

01

D

10C

11

4;7

6;7

7

3;7

2;7

1;7

(b) Voorbeeld 1, alternatief2.

A

00

B

01

C

10

1;4

6

1;3

(c) Voorbeeld 2.

Figuur 4.29: Transitiediagramma van het voorbeeld na het toepassen van de eerste methode.

geformaliseerd in Tabel 4.15(b). Een belangrijk aspect bij deze diagrammen is dat we het aantal overgangenwaarbij twee of meer toestand-bits willen minimaliseren. Dit komt dus neer op de diagonale transities. Wekunnen opmerken dat het eerste alternatief bijgevolg beter is dan het tweede.

Ook het tweede voorbeeld minimaliseren we met behulp van een transitiediagram zoals op Figuur 4.29(c).Men kan opnieuw stellen dat dit systeem equivalent is onder spiegeling. Onder rotatie is dit echter niet hetgeval. Hoe we immers de toestanden ook alloceren, er zal steeds een boog zijn met twee te veranderen bits.We kunnen echter kiezen welke twee toestanden er verbonden zijn met deze boog. In het geval van b en c iser slechts sprake van een transitie. Bijgevolg alloceren we de toestanden zoals weergegeven op Figuur 4.29(c)en op Tabel 4.15(c).

Methode 2: Gebruik maken van een tussentoestand

Vermits er geen kloksignaal is en we dus te maken hebben met een schakeling die blijft zoeken naar eenstabiele toestand, hoeven we niet noodzakelijk meteen de uiteindelijke toestand in een cel in te vullen. Wekunnen ook een tijdelijke transitie naar een andere toestand ondernemen - waarbij slechts een toestandsbitverandert - waarna we met een reeks tussentoestanden in de uiteindelijke toestand belanden. Dit principeis dus niet beperkt tot een tussentoestand. Een extra hulpmiddel dat we hierbij kunnen hanteren zijn dedon’t cares die nog in de tabel staan. Vermits deze configuraties toch niet kunnen voorkomen, kunnen weeen transitie invullen bij de bijbehorende don’t cares. In het andere geval moeten we op zoek gaan naar eentoestand die slechts een bit verschilt van de huidige toestand en die dezelfde stabiele eindtoestand voor deinvoer-bits stelt.

In het eerste voorbeeld is er sprake van twee transities die we moeten aanpassen: wanneer we ons bevindenin toestand 〈0, 0〉a met invoer 〈0, 1〉 en in toestand 〈0, 1〉c met invoer 〈1, 0〉. Om deze problemen op te lossendien we de relevante kolommen van de invoer te inspecteren. In het eerste geval zoeken we naar een toestandmet een Hammingafstand van 1 bit die ons onder invoer 〈0, 1〉 naar de toestand 〈1, 1〉b zal brengen. In heteerste geval lijkt zo’n toestand niet te bestaan. We kunnen echter toestand 〈1, 0〉d opmerken. Deze toestandverschilt slechts een bit en bevat in de relevante kolom een don’t care. Vermits de ingang toch niet kanvoorkomen in deze toestand kunnen we deze gebruiken om de overgang te bewerkstelligen. We vullen dus〈1, 1〉b in in de rij van toestand 〈1, 0〉d met invoer 〈0, 1〉. Verder passen we de rij van de originele toestandaan: de cel van toestand 〈0, 0〉a met invoer 〈0, 1〉 overschrijven we met de waarde 〈1, 0〉d. Concreet betekentdit dus wanneer we ons in toestand b bevinden en we leggen de relevante invoer aan, we eerst naar toestandd zullen springen. Toestand d is echter niet stabiel onder deze invoer waardoor we meteen naar toestand bmigreren: de oorspronkelijk bedoelde toestand.

We proberen ook de tweede problematische transitie van het eerste voorbeeld op te lossen: invoer 〈1, 0〉 intoestand 〈0, 1〉c. We gaan opnieuw op zoek naar een toestand die in dezelfde kolom ook tot toestand 〈1, 0〉dleidt. Er bestaat hiervoor een toestand: 〈1, 1〉b heeft een Hamming-afstand van 1 en we zien dat in de kolom


voor invoer 〈1, 0〉 deze ook een transitie naar 〈1, 0〉d leidt. Bijgevolg modificeren we de eerste cel zodat dezenaar 〈1, 1〉b leidt. Na deze stappen bekomen we de coderingstabel in Tabel 4.16(a) en het transitiediagramin Figuur 4.30(a). De schuingedrukte cellen zijn cellen die we hebben aangepast. Zoals we kunnen zien zijner geen transities meer die meer dan een bit aanpassen. De toestandscodering is dus volledig aangepast.

(a) Voorbeeld 1.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 10 |00| 01 0011 |11| |11| 01 10 0101 00 |01| |01| 11 1010 11 11 00 |10| 11

(b) Voorbeeld 1 met compressie.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 10 |00| 10 0011 |11| |11| 01 10 0101 00 |01| |01| 11 1010 11 11 00 |10| 11

(c) Voorbeeld 2.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| |00| 001 00 |01| −− 10 010 00 |10| 00 |10| 1

Tabel 4.17: Coderingstabellen van het voorbeeld na het toepassen van de tweede methode.

A

00

B

11D

10

C

011;7

6;7

3;4;72;4;7

(a) Voorbeeld 1.

A

00

B

01

C

10

1;4

6

1;3

(b) Voorbeeld 2.

Figuur 4.30: Transitiediagramma van het voorbeeld na het toepassen van de tweede methode.

We kunnen in deze methode ook een ander aspect bewerkstelligen: compressie. Compressie probeert desequentie van toestanden in te korten die de schakeling zal overlopen wanneer de ingang verandert. Stel datde schakeling zich in toestand 〈0, 0〉a bevinden en de ingang vanuit een stabiele configuratie naar de invoer-bits 〈1, 0〉 verandert. In dat geval doorloopt de schakeling de volgende toestanden: 〈0, 0〉a → 〈0, 1〉c →〈1, 1〉b → 〈1, 0〉d. We doorlopen dus vier toestanden alvorens we in de uiteindelijke stabiele configuratieterecht komen. Dit terwijl de Hammingafstand tussen a en d slechts een bit bedraagt. Dit betekent dus datwe rechtstreeks naar d kunnen migreren. Hiervoor dienen we dus enkel de transitie van toestand 〈0, 0〉a metinvoer 〈1, 0〉 aan te passen naar 〈1, 0〉d. We bekomen dus de coderingstabel in Tabel 4.16(b).

We zullen ook proberen deze methode toe te passen op voorbeeld 2. Meer bepaald wanneer we ons intoestand 〈0, 1〉b bevinden en we veranderen de ingang-bits naar 〈1, 1〉 beschouwen we momenteel een transitiewaarbij twee bits veranderen. De enige toestand met een Hammingafstand van 1 is echter 〈0, 0〉a. Vermitswe in deze toestand met ingang-bits 〈1, 1〉 in een stabiele configuratie zitten, kunnen we geen transitiebewerkstelligen naar 〈1, 0〉c. Het probleem kan dus niet opgelost worden met deze methode. We zullen dusmethode 3 hiervoor moeten aanwenden.


Methode 3: Invoeren van extra overgangstoestand

In de laatste methode introduceren we om de problematische transities op te lossen een nieuwe toestand.Deze toestand mag – net als in de vorige methode – slechts een Hammingafstand van 1 optekenen met detoestand waartussen de problematisch codering zich bevindt. Dit is niet altijd mogelijk. Daarom zal mensoms zelfs een pad van verschillende extra overgangstoestanden moeten ontwerpen die telkens een bit vanelkaar verschillen.

Omdat alle coderingen soms al in gebruik zijn of om aan de voorwaarde van de Hamming-afstand tevoldoen is het daarom niet altijd eenvoudig of zelfs mogelijk om een codering met hetzelfde aantal bits tevoorzien. In dat geval moeten we soms de toestandcodering uitbreiden naar meerdere bits. Wanneer weextra bits toevoegen betekent dit traditioneel dat we de volledige codering herbekijken wat veel werk metzich meebrengt. Door echter bits vooraan toe te voegen kunnen we de oude codering behouden (met leidende0-bits bijvoorbeeld) en maken we tegelijk ruimte om meer toestanden voor te stellen.

Eenmaal we een nieuwe codering hebben beschouwd is de realisatie eenvoudig: in de kolom van de relevanteinvoer-configuratie plaatsen we het pad door elke extra overgangstoestand te laten wijzen naar de volgendeovergangstoestand in het pad. Ook passen we de rij van de oorspronkelijke toestand aan zodat deze wijstnaar de eerste overgangstoestand in het pad. De overige kolommen vullen we op met don’t cares alsook deuitvoer in de overgangstoestanden.

We hoeven niet voor elke problematische transitie meteen extra overgangstoestanden te voorzien. Somskan men bijvoorbeeld eerst een overgang oplossen en vervolgens met methode 2 bijvoorbeeld proberen denieuwe toestand als tussentoestand te beschouwen bij het oplossen van een andere problematische transitie.

Met deze methode zullen we ten slotte de laatste problematische transitie oplossen van het tweede voor-beeld. De twee toestanden waartussen deze transitie zich afspeelt zijn 〈0, 1〉b en 〈1, 0〉c. Zonder de toestands-codering uit te breiden met extra bits zijn er twee coderingen die een Hammingafstand van 1 hebben metbeide toestanden: 〈0, 0〉 en 〈1, 1〉. We kunnen 〈0, 0〉 niet gebruiken omdat deze codering reeds gebruikt wordtdoor toestand a. De andere codering is echter nog vrij. We introduceren dus een toestand 〈1, 1〉d. Bij dezetoestand vullen we de transitie-kolommen en de uitvoer-kolom met don’t cares behalve de relevante ingang:〈1, 1〉. Deze kolom laten we verwijzen naar de doeltoestand 〈1, 0〉c. Tot slot passen we de rij van toestand〈0, 1〉b aan: we laten de relevante invoer-kolom verwijzen naar de ingevoerde overgangstoestand. Wanneerwe deze wijzigingen doorvoeren bekomen we de coderingstabel op Tabel 4.18 en het transitiediagram opFiguur 4.31. We zien in de coderingstabel dat er geen problematische transities meer zijn. Alle problemenzijn bijgevolg opgelost.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| |00| 001 00 |01| −− 11 010 00 |10| 00 |10| 111 -- -- -- 10 -

Tabel 4.18: Coderingstabel van het voorbeeld na het toepassen van de derde methode.

Initiele toestand Een laatste aspect die we moeten behandelen wanneer we methode 3 toepassen is deinitiele toestand: de schakeling van waaruit de schakeling vertrekt wanneer de spanning opkomt. Net alsbij flipflops en latches is dit niet te voorspellen. De originele toestand hangt dan ook af van verschillendefactoren: inductieve spanning ten gevolge van eerder gebruik, kleine verschillen in de vertragingen op poorten,de temperatuur van de poorten op dat moment, thermische ruis op de verbindingen. Het kan echter gebeurendat we dus in een codering terechtkomen van een overgangstoestand. Het probleem is dat in het voorbeeld


A

00

B

01

C

10D

11

1;4

6

6

1;3

Figuur 4.31: Transitiediagram van het voorbeeld na het toepassen van de derde methode.

de codering 〈1, 1〉 niet overeenkomt met een werkelijke toestand. Wanneer de schakeling dus met dergelijketoestand wordt geınitialiseerd moet de schakeling dus meteen een transfer maken naar een andere – welgeldige – toestand. Een probleem is echter dat in Tabel 4.18 er don’t cares in de kolommen staan. Het is dusmogelijk dat dit later wordt geımplementeerd zodat er stabiele configuraties ontstaan voor een codering dieniet overeenkomt met een toestand. Het is duidelijk dat dit niet de bedoeling is van een overgangstoestand.Om dit te vermijden kunnen we in de kolommen opgevuld met don’t cares concrete waarden invullen.

Welke waarden we precies invullen maakt niet zoveel uit. Zolang het stabiele configuraties met de relevanteinvoer-bit en voor een geldige toestand: dit betekent geen overgangstoestand. We zoeken dus in dezelfdekolom naar een stabiele configuratie en verwijzen in de tabel naar de overeenkomstige toestand.

In het leidend voorbeeld hebben we een overgangstoestand geıntroduceerd. Wanneer we 〈0, 0〉 aanleggenaan de invoer zien we een stabiele configuratie bij toestand 〈0, 0〉a. In de tweede kolom zijn er twee stabieleconfiguraties we kunnen dus kiezen om ofwel 〈0, 1〉b ofwel 〈1, 0〉c in te vullen. We kiezen hier voor het eerste.De volgende kolom is er slechts een stabiele configuratie: een configuratie met toestand 〈0, 0〉a. Men kanargumenteren dat we deze toestand niet kunnen gebruiken: er veranderen immers twee bits in vergelijkingmet de eerste bit. Anderzijds staat er nog een don’t care in de kolom. We kunnen deze don’t care ook latenverwijzen naar 〈0, 0〉a. Hierdoor is de volledig kolom nu gevuld met verwijzingen naar 〈0, 0〉a. Vermits devolledige kolom uniform met dezelfde waardes gevuld is, is de Hamming-afstand tussen de toestanden nietmeer van belang: Stel dat we ons in toestand 〈1, 1〉 bevinden en we een transitie naar 〈0, 0〉a maken, dankan het gebeuren dat door een verschil in vertraging we in de toestand 〈0, 1〉b ofwel 〈0, 0〉c terechtkomen.Beide toestanden vormen echter geen probleem omdat ze zelf ook instabiele configuraties zijn die uiteindelijktoch naar dezelfde toestand zullen transformeren. Er is dus sprake van een race, maar deze is niet critical.De laatste kolom ten slotte is reeds ingevuld en bijgevolg bekomen we de uiteindelijke coderingstabel inTabel 4.19.

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| |00| 001 00 |01| 00 11 010 00 |10| 00 |10| 111 00 01 00 10 -

Tabel 4.19: Coderingstabel van het voorbeeld met initiele toestand voor de overgangstoestand.

Initiele toestand (bis)

Naast eventuele overgangstoestanden kan het gebeuren dat niet alle coderingen zijn toegewezen aan werkelijkeof overgangstoestanden. Stel bijvoorbeeld dat we een coderingstabel beschouwen met 6 rijen. Hoewel erslechts zes toestanden zijn, zullen er in werkelijkheid meer toestandscoderingen mogelijk zijn. Zoals weal hebben aangehaald kan men niet voorspellen in welke toestandscodering de schakeling zich initieel zal


bevinden wanneer de stroom opkomt. Daarom dienen we de overige coderingen dus ook te beschouwen entransities te voorzien naar eerder geıntroduceerde stabiele configuraties. De werkwijze is dan ook volledigidentiek aan deze bij het aanpassen van de don’t cares van de overgangstoestanden. We gaan er dan ookniet verder op in.

4.4.5 Stap 4: Realisatie met digitale logica

Wie denkt dat met een geldige toestandscodering alle problemen van de baan zijn moeten we teleurstellen.We hebben dan wel kritische races geelimineerd, maar bij het realiseren van de schakeling dienen we hetvolgende problemen op te lossen: hazards. Een hazard vormt een ander probleem dan een race. Eenrace betekent dat door het tijdsverschil waartussen twee of meer signalen van waarde veranderen we ineen foute toestand kunnen terechtkomen. Combinatorische logica kan echter ook andere problemen metzich meebrengen: namelijk dat de signalen alvorens de definitieve waarde aan te namen eerst enkele malenveranderen.

Hazards

De vorige definitie is nogal abstract. We zullen deze dan ook verder toelichten aan de hand van een voorbeeld.Alvorens dit te doen introduceren we extra terminologie. Zo worden hazards opgedeeld in twee soorten: eenstatische hazard en een dynamische hazard.

In het geval van een statische hazard zou het signaal eigenlijk niet moeten veranderen. Stel bijvoorbeelddat we volgende expressie beschouwen:

f (x, y, z) = x · y + y′ · z (4.23)

Wanneer we 〈x, y, z〉 = 〈1, 1, 1〉 aanleggen is het duidelijk dat dit resulteert in een uitgang f (1, 1, 1) = 1.Stel nu dat we het signaal van y aanpassen naar laag, dan geldt nog steeds dat f (1, 0, 1) = 1. We kunnendus stellen dat het aanpassen van y in deze context geen verschil zal maken. Een gevaar voor een race iser dus bijgevolg zeker niet. Wanneer we deze formule implementeren met behulp van logica kunnen we eenschakeling ontwerpen zoals op Figuur 4.32(a). Wanneer we de verandering van y echter simuleren zien weop de bijbehorende tijdsgrafiek (Figuur 4.32(b)) dat het signaal even naar 0 gaat. We hebben dit fenomeenal eerder omschreven als glitch. Men deelt statische hazards verder onder in een statische 0-hazard en een

p

q

f

xy

z

(a) Voorbeeldimplementatie.

f

q

p

y′

y

(b) Tijdsgedrag van het voorbeeld.

Figuur 4.32: Statische hazards.

statische 1-hazard. De waarde verwijst naar de waarde die de uitgang oorspronkelijk had (en de waarde diedus ook moet worden aangehouden). Wanneer men schakelingen implementeert volgens het sum-of-productsprincipe kan men enkel statische 1-hazards bekomen. Wanneer men werkt volgens de product-of-sumsmethodologie treden enkel statische 0-hazards op. We zullen dit principe verderop uitleggen.


We beschrijven dynamische hazards aan de hand van een andere formule:

f (x, y, z, t) =

((x ∧ (x ∧ y)

′)′ ∧ (((x ∧ y)′ ∧ z

)′ ∧ t)′)′ (4.24)

Deze formule kunnen we implementeren met een schakeling zoals op Figuur 4.33(a). Wanneer we dezeformule uitrekenen met de invoer 〈x, y, z, t〉 = 〈0, 1, 1, 1〉 zal het uitgang-signaal laag zijn: f (0, 1, 1, 1) = 0.Wanneer we echter x aanpassen naar een hoog signaal bekomen we f (1, 1, 1, 1) = 1. Het signaal zal dussowieso omkeren. Wanneer we dit echter simuleren in de tijd bekomen we de grafiek op Figuur 4.33(b). Wezien dat uiteindelijk het signaal naar hoog gaat, maar dat er eerst storingen op de uitgang verschijnen. Eendynamische hazard is dan ook een storing waarbij de uitgang niet eenmaal verandert van signaal, maar eenoneven aantal keer (groter dan 1). Een voordeel van een sum-of-products of product-of-sums implementatiete gebruiken is echter dat dynamische hazards niet kunnen voorkomen.

d

b

caxyzt

f

(a) Voorbeeldimplementatie.

f

d

c

b

a

x

(b) Tijdsgedrag van het voorbeeld.

Figuur 4.33: Dynamische hazards.

Oorzaak Bij het definieren van de terminologie rond hazards hebben we niet stilgestaan hoe deze fenome-nen tot stand komen. Hazards worden veroorzaakt door een tijdsverschil waarin een verandering doorheende verschillende poorten wordt gepropageerd. Als voorbeeld nemen we opnieuw de schakeling bij statischehazards op Figuur 4.32(a). We zien dat het resultaat berekend wordt door een OR-poort die het resultaatvan twee AND-poorten binair optelt. Wanneer we y aanpassen zal de bovenste AND-poort deze veranderingmeteen waarnemen. De onderste AND-poort zal dit echter nog niet waarnemen: het signaal moet eerst nogdoor de NOT-poort propageren. Daardoor zal de bovenste AND-poort een 0 op de OR-poort kunnen aan-leggen alvorens de onderste AND-poort dit kan goedmaken door terug een 1 op een ingang van de OR-poortaan te leggen. Wanneer we dus y van 1 naar 0 zouden aanpassen treden er geen problemen op: de bovensteAND-poort zal een 1 aanleggen op een van de ingangen van de OR-poort alvorens de onderste dit doetwaardoor dit niet aan de uitgang merkbaar zal zijn. Samenvattend kunnen we dus stellen dat de oorzaakvan een hazard een verschil in vertraging is van eenzelfde ingang naar eenzelfde uitgang langs verschillendepaden.

Gestroomlijnd tijdsgedrag Omdat hazards veroorzaakt wordt door tijdsverschillen doorheen de scha-keling zouden we ervoor kunnen opteren om een schakeling te ontwerpen waar alle signalen gestroomlijnddoor de schakeling propageren. Dit is echter onmogelijk te realiseren. Allereerst zou men allerhande poortenmoeten tussenvoegen om bepaalde signalen voldoende te vertragen waardoor de schakeling duurder wordt.Daarnaast is het theoretische vertragingsmodel slechts een benadering. De werkelijke vertraging van eenpoort is ook afhankelijk van bijvoorbeeld de lengte van de verbindingen, de temperatuur van de poort,enzovoort. Sommige parameters zoals de temperatuur zijn bovendien op voorhand niet gekend.


Toestandssignalen In combinatorische en synchrone sequentiele schakelingen komen hazards natuurlijkook voor. Nochtans vormen hazards in deze schakelingen geen probleem. Dit komt omdat een combinato-rische schakeling maar na een bepaalde tijd het correcte resultaat op de uitgangen moet kunnen aanleggen.Bij een synchrone schakeling bepaalt het kloksignaal dan weer wanneer de signalen aan de uitgang zullenworden ingelezen. Zolang het signaal dus correct berekend is voor de rising-edge die het resultaat in deflipflops zal opslaan, is er geen enkel probleem. In het geval van asynchrone sequentiele schakelingen is ditniet geval. Dit komt door de toestandssignalen, de signalen die het terugkoppelingsmechanisme vormen. Designalen worden berekend door de logica van de schakeling, maar vormen ook een deel van de invoer van deschakeling. Wanneer de signalen dus tijdelijk een foutieve waarde aannemen kan dit tot problemen leiden:er kunnen oscillaties ontstaan of de schakeling kan in een foute toestand terechtkomen.

Het detecteren van hazards is een niet triviaal probleem en vereist doorgaans het simuleren van overgangen.Vooral in het geval van dynamische hazards is dit problematisch.

Hazards en Karnaugh-kaarten

Combinatorische schakelingen komen meestal tot stand met behulp van een Karnaugh-kaart volgens het sum-of-products concept. We hebben reeds aangehaald dat wanneer de logica het sum-of-products principe volgt,uitsluitend statische 1-hazards kunnen optreden. In deze subsubsectie gaan we hier dieper op in. Bovendienkunnen we op basis van Karnaugh-kaarten een methode voorstellen om combinatorische schakelingen teontwikkelen waar geen hazards kunnen optreden.

Op Figuur 4.34 tonen we de bijbehorende Karnaugh-kaart voor de schakeling op Figuur 4.32(a). Op defiguur tonen we ook voor elke AND-poort welke gevallen worden bedekt. In het voorbeeld veranderden we deinvoer van 〈x, y, z〉 = 〈1, 1, 1〉 naar 〈x, y, z〉 = 〈1, 0, 1〉. Zoals we op de figuur zien behoort dit tot een andergebied. Men zou kunnen stellen dat de AND-poorten controleren of de invoer zich in hun overeenkomstigerechthoek bevindt en zo ja, komt er een een op de uitgang. Een statische 1-hazard wordt veroorzaakt wanneerde rechthoek die we verlaten dit eerder “opmerkt” en dus de uitvoer op 0 brengt alvorens de rechthoek waarinwe toekomen dit merkt en de uitvoer terug hoog maakt. Door deze analogie kunnen we ook verklaren waaromwe bij een schakeling volgens het sum-of-product-principe nooit een statisch 0-hazard zullen realiseren: weverplaatsen ons van cel naar cel. Wanneer beide cellen 0 zijn, zal geen enkel rechthoek ooit actief worden.Bijgevolg zal op geen enkel moment er een 1 aan de ingang van de OR-poort verschijnen.

f

x

y

z

0

0

1

0

1

0

1

1

Figuur 4.34: Karnaugh-kaart bij het leidende voorbeeld.

Hazards voorkomen We kunnen een hazard voorkomen door ervoor te zorgen dat als we tussen tweecellen een transitie uitvoeren, er een rechthoek bestaat die beide cellen omvat. Een concrete oplossing wordthiervoor voorgesteld in Figuur 4.35(a). Wanneer we in dit voorbeeld een transitie uitvoeren, zullen de AND-poorten van de oorspronkelijke schakeling nog steeds een tijdsverschil optekenen. We introduceren echtereen AND-poort die onder de transitie telkens een 1 zal blijven aanleggen op de OR-poort. Bijgevolg zal deuitvoer altijd 1 blijven. Om dus hazards te vermijden introduceren we redundante termen: AND-poortendie niet strikt gezien nodig zijn om de correcte combinatorische logica voor te stellen, maar poorten die bijeen wijziging aan de invoer ervoor zorgen dat er nooit een statische 1-hazard kan optreden.


f

x

y

z

0

0

1

0

1

0

1

1

(a) Kaart.

x y z

f

(b) Implementatie.

Figuur 4.35: Het invoeren van redundante termen elimineert statische 1-hazards.

Is het altijd mogelijk om zo’n AND-poort te realiseren? Wat indien we bijvoorbeeld een dambord patroonbeschouwen zoals op Figuur 4.36? In dat geval zouden we geen redundante termen kunnen introduceren: we

f

x

y

z

1

1

1

1

0

1

1

0

Figuur 4.36: Dambord patroon.

kunnen dus bijvoorbeeld geen overgang van 〈x, y, z〉 = 〈1, 0, 1〉 naar 〈x, y, z〉 = 〈1, 1, 0〉 nemen en voorkomendat we in een 0 terecht komen. Merk echter op dat we hier twee ingangen hebben aangepast, iets wat volgensde specificaties niet mag. Indien we dus een dergelijke overgang nemen, zullen we altijd eerst een van deingangen eerst aanpassen en wachten tot de effecten zijn uitgewerkt. Dan pas passen we de andere ingangaan. Bijgevolg vormt dit geen probleem.

Product of sums In het geval van sum-of-product voegen we mintermen toe voor disjuncte 1-gebieden.Soms is het echter goedkoper om een product-of-sum te implementeren. In dat geval voorzien we maxtermenvoor disjuncte 0-gebieden. We gaan hier niet verder op in.

Realisatie leidend voorbeeld

We zullen voor het leidend voorbeeld doorheen deze sectie (coderingstabel in Tabel 4.18 op pagina 136)een schakeling realiseren. Hiervoor zullen we eerst de Karnaugh-kaarten opstellen zoals op Figuur 4.37(a).We doen dit voor zowel s0, s1 en Q. De volgende toestand hangt af van de originele toestand en van deingangen. De variabelen zijn dus s0, s1, I en E. Bij de uitgang Q is enkel de toestand van belang. Bijgevolgvermelden we enkel s0 en s1 op de Karnaugh-kaart. Vervolgens dienen we de logica zelf te implementeren.Hiervoor realiseren we de combinatorische schakelingen die we hebben gespecificeerd met behulp van deKarnaugh-kaarten. In dit geval doen we dit met een 3-OR poort voor s0 en een 2-OR poort voor s1. Inhet geval van Q hebben we bovendien geen poorten nodig: de uitgang komt immers overeen met een van detoestand-bits s0. Daarna verbinden we de uitgang van de combinatorische schakelingen met de ingangen diede respectievelijke toestand-bits voorstellen. We bekomen dus een implementatie zoals op Figuur 4.37(b).

Problemen ten gevolge van skew op ingangen

Met het voorkomen van hazards zijn de theoretische problemen opgelost bij het realiseren van een asynchroneschakeling: wanneer we een digitale schakeling simuleren zal de schakeling correct werken. Maar zoals reedsverschillende malen werd aangehaald is het theoretische model niet helemaal correct.


s0

s0

s1

I

E

0 0 0 0

0 0 − 0

− 1 − −0 1 0 1

s1

s0

s1

I

E

0 0 0 1

0 1 − 1

− 0 − −0 0 0 0

Q

s0

s1

1

0

−0

(a) Karnaugh-kaarten.

I E s0s1

Q

(b) Implementatie.

Figuur 4.37: Realisatie van het leidend voorbeeld.

skew is een fenomeen waarbij een extra vertraging wordt geıntroduceerd op een lokale plaats in de scha-keling. Of anders gesteld, een verandering op een lijn wordt niet overal op hetzelfde moment opgemerkt.Verder in deze cursus zullen we een speciale vorm van skew beschouwen: clock skew25. Een mogelijk gevolgis een essentiele hazard: de verandering van slechts een ingangssignaal brengt de schakeling in een foutetoestand.

Algemeen verloopt een essentiele hazard altijd als volgt:

1. Het ingangssignaal wordt aangepast (door een bit te veranderen, dus conform de regels).

2. Enkele poorten merken de verandering op en een bit van de toestand wordt aangepast.

3. Een poort merkt de verandering van de toestand op, maar heeft de aanpassing van de invoer nog nietopgemerkt.

4. Deze poort verandert op zijn beurt een toestand-bit.

5. Pas later wordt de verandering van de invoer opgemerkt.

Empirisch zijn essentiele hazards moeilijk op te sporen: het gebeurt niet zelden dat tijdelijk in de verkeerdetoestand terechtkomen geen probleem vormt, de foute toestand kan immers dienst doen als een via-toestandwaardoor de schakeling alsnog in de correcte toestand terecht komt. Er bestaat wel een algoritmische manierom essentiele hazards te ontdekken.

Voorbeeld Bij wijze van voorbeeld beschouwen we de schakeling op Figuur 4.37(b). We stellen op basisvan de Karnaugh-kaarten een coderingstabel op in Tabel 4.20. We zullen eerst het scenario in abstracto

Toestand I EQ

s0s1 00 01 11 10

00 |00| 01 |00| |00| 001 00 |01| |01| 11 010 00 |10| 00 |10| 111 00 11 01 10 1

Tabel 4.20: Coderingstabel van de schakeling uit Figuur 4.38.

beschouwen:

1. We bevinden ons in toestand 〈s0, s1〉 = 〈1, 0〉 met invoer 〈I, E〉 = 〈0, 1〉.

2. De invoer van I verandert naar 〈I, E〉 = 〈1, 1〉.25Zie Subsectie 5.5.2.


3. De toestand wordt omgeschakeld naar 〈s0, s1〉 = 〈0, 0〉maar de eerste AND poort heeft de omschakelingvan de ingang nog niet opgemerkt.

4. De AND-poort wordt hierdoor actief, bijgevolg schakelt de schakeling nu om naar toestand 〈s0, s1〉 =〈0, 1〉.

5. Deze toestand is stabiel met zowel de oude en de nieuwe invoer. Bijgevolg blijft de schakeling intoestand 〈s0, s1〉 = 〈0, 1〉 stabiel.

Dit scenario treedt op wanneer op de verbinding tussen I en de eerste AND-poort een significante vertragingplaatsgrijpt. Dit kan bijvoorbeeld het gevolg zijn van een lange lijn. Figuur 4.38(a) toont de schakeling metde skew en Figuur 4.38(b) het tijdsgedrag van de schakeling.

I E s0 s1

Q

a4

a3

a2

a1

a0

(a) Implementatie.

t

s0 01

s1 01

I 01

Ia0 01

a0 01

a1 01

a2 01

a3 01

(b) Tijdsgedrag.

Figuur 4.38: Essentiele hazard van het leidend voorbeeld.

Detectie Een eenvoudige manier om essentiele hazards op te sporen is de ingang niet een maar driekeer aanpassen. Toegepast op het voorbeeld betekent dit dat we opnieuw beginnen vanuit 〈s0, s1, I, E〉 =〈1, 0, 0, 1〉. Wanneer we I eenmaal aanpassen bekomen we volgens de coderingstabel: 〈s0, s1, I, E〉 =〈1, 0, 0, 1〉 → 〈1, 0, 1, 1〉 → 〈0, 0, 1, 1〉. We passen vervolgens nog tweemaal de invoer aan en bekomen:〈0, 0, 1, 1〉 → 〈0, 0, 0, 1〉 → 〈0, 1, 0, 1〉 → 〈0, 1, 1, 1〉 → 〈0, 1, 1, 1〉. Zoals we zien is de eindtoestand nietdezelfde. We hoeven het signaal nooit meer dan drie keer aan te passen.

Oplossing Een elegante oplossing voor het probleem bestaat er niet. Men moet proberen te voorkomendat toestandsvariabelen veranderen alvorens het ingangssignaal op alle poorten is aangekomen. Door decoderingstabel aan te passen kan men het probleem meestal reduceren, bijvoorbeeld door het aantal wijzi-gingen van toestandsvariabelen beperkt te houden. Maar bij sommige specificaties kan men dit effect nietwegnemen. In dat geval moet men op elektronisch niveau het plan aanpassen: men kan bijvoorbeeld vertra-gingen introduceren bij de andere poorten om het verschil weg te nemen. Meestal vereist dit zorgvuldige encomplexe bewerkingen, deze liggen buiten het bereik van deze cursus.

4.4.6 Besluit

Als algemene conclusie kunnen we stellen:

Vermijd asynchrone sequentiele schakelingen.

Asynchrone schakelingen zijn immers complexer te ontwerpen: twee ingangen mogen niet tegelijk aangepastworden dus dient men in sommige gevallen dit op te lossen aan de hand van extra (synchrone) logica voorde ingangen. Verder dient men verschillende problemen indachtig te zijn: de coderingstabel moet wordenaangepast aan races en hazards. Tot slot wordt de meeste elektronica gebouwd aan de hand van CADsoftware. In deze software zijn asynchrone sequentiele schakelingen meestal beperkt ondersteund.


Asynchrone schakelingen worden dan ook enkel gebruikt in twee gevallen: wanneer snelheid van cruciaalbelang is en een synchrone sequentiele schakeling op geen enkele manier de gewenste doorvoer kan bereiken.Verder is het niet altijd mogelijk om een sequentieel systeem te implementeren. We kunnen bijvoorbeelddenken aan een computernetwerk: elke machine heeft een eigen klok. Het synchroniseren van klokken is eenonmogelijk opdracht. In dat geval zal men met behulp van een kleine en eenvoudige asynchrone schakelingdata tussen de twee synchrone “eilanden” uit wisselen.

Deel III

Processoren

145

Hoofdstuk 5

Niet-Programmeerbare Processoren

We accepteren nu het feit dat leren een levenslang proces is omop de hoogte te blijven van veranderingen. En de meest urgentetaak is mensen te leren hoe te leren.

“

”- Peter F. Drucker, Amerikaans management consultant en auteur (1909-)

In de twee vorige hoofdstukken hebben we componenten gebouwd meteen beperkte functionaliteit. De combinatorische schakelingen latenons toe om schakelingen te ontwerpen die een rekenkundige operatieuitvoeren, maar we hebben geen geheugen beschikbaar om tussenre-sultaten in op te slaan. Het hoofdstuk over sequentiele schakelingenmaakt het mogelijk om schakelingen te ontwerpen met een geheu-gen. De meeste problemen hebben echter zeer grote toestandsruimtes(een 32-bit getal heeft meer dan vier miljard toestanden). Daaromvolstaan de methodes uit dit hoofdstuk niet om een component teontwikkelen die iets functioneel doet. Daarvoor zullen we methodesop een hoger niveau introduceren, dat van een niet-programmeerbareprocessor. Een niet programmeerbare processor voert een algoritmeuit dat op voorhand gekend is. Hierdoor kunnen we optimaal ge-bruik maken van de hardware en zoveel mogelijk instructies tegelijkuitvoeren. Het nadeel is dat eenmaal de processor geproduceerd is,we geen andere problemen met het component kunnen uitvoeren.

5.1 De Niet-Programmeerbare Processor . . . . . . . . . . . . . . . . . . . . . . . . 148

5.1.1 Algemene Structuur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

5.1.2 Het Datapad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

5.2 Formeel Beschrijven van een Algoritme . . . . . . . . . . . . . . . . . . . . . . . 150

5.2.1 Leidend Voorbeeld: Deler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

5.2.2 Toestandsbeschrijving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

5.2.3 Toestand-Actie Tabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

5.2.4 ASM-Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

ASM-Elementen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

147

148 HOOFDSTUK 5. NIET-PROGRAMMEERBARE PROCESSOREN

Het ASM-Blok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Traditionele Valkuilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Inputgebaseerde en Toestandsgebaseerde ASM-schema’s . . . . . . . . . . . . . . . 158

5.3 Geheugencomponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

5.3.1 Register File Cell (RFC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158

5.3.2 Registerbank . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

5.3.3 Random Access Memory (RAM) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

5.3.4 Geheugens met Impliciete Adressering . . . . . . . . . . . . . . . . . . . . . . . . . 162

Stack (LIFO: Last-In-First-Out) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

Queue (FIFO: First-In-First-Out) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

5.4 Synthese van een Niet-Programmeerbare Processor . . . . . . . . . . . . . . . 167

5.4.1 Basisprincipes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

Principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167

Leidend voorbeeld . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

Betere implementatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

5.4.2 Ontwerp Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Patronen in een algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Algemene vorm van een controller . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Natuurlijke volgorde van toestanden . . . . . . . . . . . . . . . . . . . . . . . . . . 173

Ondersteunen van subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174

Werken met “One-Hot” coderingen . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Programmeerbare controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

5.4.3 Minimaliseren Datapad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

Leidend voorbeeld: vierkantswortel benadering . . . . . . . . . . . . . . . . . . . . 177

Kostprijsberekening . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Variabelen samenvoegen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

Bewerkingen samenvoegen (“functional-unit sharing”) . . . . . . . . . . . . . . . . 188

Verbindingen samenvoegen (“bus sharing”) . . . . . . . . . . . . . . . . . . . . . . 200

Registers samenvoegen in registerbank (“register port sharing”) . . . . . . . . . . . 203

Vergelijking van de verschillende optimalisaties . . . . . . . . . . . . . . . . . . . . 205

5.4.4 Andere optimalisaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

Minimaal instructiewoord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

“Chaining”: meerdere bewerkingen per klokcyclus . . . . . . . . . . . . . . . . . . 207

“Multicycling” en “Pipelining”: meerdere klokcycli per bewerking . . . . . . . . . 207

5.4.5 Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5 Tijdsgedrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5.1 Kritisch pad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212

5.5.2 Verschoven kloksignalen (“clock skew”) . . . . . . . . . . . . . . . . . . . . . . . . 213

5.5.3 Synchroniseren van asynchrone ingangen . . . . . . . . . . . . . . . . . . . . . . . . 214

5.1 De Niet-Programmeerbare Processor

Alvorens we de bouw van zo’n processor verder uitwerken, dienen we eerst enkele concepten te formaliseren.Allereerst ontleden we in deze sectie uit welke delen zo’n processor is opgebouwd. Vervolgens zullen we insectie 5.2 een methode ontwikkelen om een algoritme formeel weer te geven. Deze beschrijving zal toelaten hetalgoritme later om te zetten naar een processor. In sectie 5.3 ten slotte zullen we extra geheugencomponentenintroduceren die we nodig zullen hebben bij de bouw van een processor.

5.1. DE NIET-PROGRAMMEERBARE PROCESSOR 149

5.1.1 Algemene Structuur

Een Niet-programmeerbare processor, ofwel Finite State Machine with Data path (FSMD) bestaat grof-weg uit twee delen:

• Een datapad: een component die bewerkingen (rekenkundig, aritmetisch,...) uitvoert en de resultatenopslaat in tijdelijk geheugen.

• Een controller: een component die het datapad aanstuurt. Het zegt welke actie op welk moment moetondernomen worden.

In dit hoofdstuk is de controller niet programmeerbaar. Dat wil zeggen dat de controller telkens hetzelfdeprogramma uitvoert. Dit betekent echter niet dat er een vaste cyclus in de controller zit. De controller kanafhankelijk van de waarden die in de geheugens van het datapad zitten, of van ingangen van de processorbeslissen om andere acties te ondernemen. Een controller is dus een sequentiele schakeling ofwel finite statemachine. De synthese van een finite state machine werd in het Hoofdstuk 4 reeds besproken. Uiteraardzullen we de karakteristieken die eigen zijn aan controllers in dit hoofdstuk bespreken.

Het spreekt voor zich dat de controller en het datapad continu data met elkaar uitwisselen. Enerzijds geeftde controller instructies aan het datapad. De groep signalen waarmee een controller een datapad aanstuurtnoemen we het “instructiewoord” ofwel “controle-signalen”. Anderzijds zullen de instructies vaak afhangenvan de toestand van variabelen opgeslagen in het datapad. De verzameling van signalen die het datapadover zijn variabelen doorstuurt naar de controller noemen we “statussignalen”.

Een processor voert operaties uit op data. Deze data moet op de een of andere manier ingelezen wordenin de processor. De verzameling ingangen waarmee we data vanuit de omgeving in het datapad injecterennoemen we de “data-ingangen”. Verder zullen we vaak ook informatie aan de controller moeten meedelen:we denken bijvoorbeeld aan een signaal dat actief wordt wanneer alle data ingelezen is, en het algoritme kanuitgevoerd worden. Deze signalen noemen we “controle-ingangen”. Daarnaast willen we ook de resultatenkunnen uitlezen. Hiervoor voorzien we een reeks signalen vanuit het datapad, deze signalen noemen we“data-uitgangen”. Tot slot zijn we soms ook geınteresseerd in de toestand van het algoritme. We zullenbijvoorbeeld enkel data uitlezen indien het algoritme afgelopen is. De controller kan informatie over hetalgoritme naar buiten brengen via “controle-uitgangen”. De verschillende informatiestromen tussen hetdatapad en de controller en de processor en zijn omgeving beschrijven we op figuur 5.1(a).

Pro

cessor

Om

gevin

g

Datapad

Controller

status-sign

alen

inst

ruct

iew

oor

d

controle-ingangen controle-uitgangen

data-ingangen data-uitgangen

(a) Processor

Datap

ad

Om

gevin

g

Tijdelijk geheugen

Operatorverbindingen

Functionele eenheden

Resultaatverbindingen

Resultaatverbindingen

instructiewoord

instructiewoord

externe-ingangen

externe-uitgangen

(b) Datapad

Figuur 5.1: Opbouw van een processor en datapad.


Door de controle-ingangen wordt de definitie van “niet-programmeerbaar” natuurlijk vaag. We zoudenimmers het toestandswoord van de controller in grote mate laten afhangen van de invoer die de controle-ingangen. Hierdoor kunnen we de processor toch programmeren. Het onderscheid is dan ook eerder eencommon-sense.

5.1.2 Het Datapad

Zoals we reeds hebben vermeld, kunnen we een controller modelleren als een eindige toestandsautomaatofwel finite state machine. Een datapad daarentegen bestaat uit verschillende componenten:

• Functionele Eenheden ofwel Functional Units (FU): dit zijn schakelingen die berekeningen en arit-metische operaties uitvoeren. Dit zijn dus de componenten die we in Hoofdstuk 3 hebben besproken:optellers, ALU, schuifoperator,... Uiteraard kunnen we ook zelf functionele eenheden bouwen op demanier die we gezien hebben.

• Tijdelijke geheugens: dit zijn componenten die de waarden waarop we bewerkingen uitvoeren voorenkele klokcycli kunnen vasthouden. Dit zijn bijvoorbeeld de registerbanken en RAM die we in sectie5.3 zullen invoeren. Het zijn groepen van flipflops die ons toelaten om op een hoger niveau te redeneren.

• Verbindingen: de tijdelijke geheugens en de functionele eenheden wisselen informatie uit. Daaromhebben we twee types verbindingen nodig:

– Operandverbindingen: dit zijn verbindingen die de waardes van de tijdelijke geheugens overbren-gen als operanden van de functionele eenheden. De waarde van een register kan op die manierbijvoorbeeld gebruikt worden bij een optelling.

– Resultaatverbindingen: het is de bedoeling dat de resultaten vervolgens in een tijdelijk geheugenopgeslagen worden. Resultaatverbindingen transporteren de resultaten van de functionele eenhe-den terug naar de tijdelijke geheugens. Sommige uitvoer kan ook weggeschreven worden naar dedata-uitgangen. Ook de invoer van de data-ingangen wordt door deze verbindingen verwerkt.

Het spreekt voor zich dat de verbindingen beslissen welke geheugens als operanden en resultaatgeheu-gens dienen. Daarom zullen we ze implementeren als bussen met multiplexers en 3-state buffers. Dezebussen zullen dan worden aangestuurd door de controller.

Dit concept beschrijven we op figuur 5.1(b).

In het datapad doen we dan ook niets anders dan waardes uit het tijdelijke geheugen inlezen, er eenoperatie van een functionele eenheid op uitvoeren en vervolgens in een tijdelijk geheugen plaatsen. Ditproces noemen we ook wel de “registertransfer” en formaliseren we als:

registera ← FUa

(registera1 , registera2 , . . . , registeran

)(5.1)

In het eerste hoofdstuk hebben we reeds vermeld dat we schakelingen bij het bouwen van een processorbeschrijven op registertransfer-niveau. Dit betekent dat we bijvoorbeeld abstractie zullen maken van flip-flops en zullen werken met registers. Ook zullen we details als het aantal bits die een opteller nodig heeftverwaarlozen. Deze nieuwe notatiestijl zullen we geleidelijk invoeren.

5.2 Formeel Beschrijven van een Algoritme

Alvorens we een processor kunnen bouwen die een algoritme uitvoert, moeten we eerst een formeel algoritmekunnen opstellen. Dit algoritme vertrekt altijd vanuit een probleemstelling. Hoe we een probleemstellingomzetten naar een algoritme behoort niet tot de inhoud van deze cursus1. We zullen altijd stellen dat hetalgoritme vooraf gekend moet zijn.

1Het omzetten van een probleem in een algoritme is geen exacte wetenschap. Het is een vaardigheid die wel geoefend kanworden. Hiervoor bestaan er andere cursussen.

5.2. FORMEEL BESCHRIJVEN VAN EEN ALGORITME 151

5.2.1 Leidend Voorbeeld: Deler

Als leidend voorbeeld doorheen dit hoofdstuk zullen we een processor bouwen die natuurlijke getallen kandelen. Uiteraard zouden we hiervoor een combinatorische schakeling kunnen bouwen. We zullen echter eenalgoritme beschouwen om de berekening te maken. De processor heeft 2 4-bit ingangen die het deeltal ende deler inlezen. Verder bevat het ook een controle-ingang. Zolang we een laag signaal op de controle-ingang aanleggen betekent dit dat er geen correcte invoer op de data-ingangen staat. Pas wanneer we eenhoog signaal aanleggen zal het algoritme dus een deling uitvoeren. Verder bevat de processor ook 2 4-bituitgangen om het quotient en de rest naar buiten te brengen, en een controle uitgang die hoog wordt op hetmoment dat het algoritme het quotient en de rest heeft berekend. Zolang de controle-uitgang dus laag is, ishet algoritme nog bezig met de berekening. Verder zal de processor ook wachten totdat de controle-ingangeerst laag is geweest alvorens opnieuw te beginnen. We maken de assumptie dat de deler nooit gelijk isaan 0. Het algoritme dat dan vervolgens het deeltal en de deler omzet in het quotient en rest staat opAlgoritme 2. We gaan niet in op de precieze werking van het algoritme. Indien we een index opvragen of

Algorithm 2 Delen van twee n-bit getallen.

1: function Division(N,D)2: Q← 03: R← 04: for I = n− 1 to 0 do5: R← R shl 1 . Logische shift R naar links over 1 positie6: R [0]← N [n− 1]7: N ← N shl 1 . Logische shift N naar links over 1 positie8: Q← Q shl 1 . Logische shift Q naar links over 1 positie9: if R ≥ D then

10: R← R−D11: Q [0]← 112: end if13: end for14: return (Q,R)15: end function

zetten bij een variabele zoals V [i] betekent dit dat we een operatie op de i-de bit uitvoeren. We tellen wevan rechts naar links, V [0] is dus de minst beduidende bit van V die rechts staat in de encodering. Verderzullen we ook de subscript-notatie gebruiken wanneer we bits samen nemen. Zo betekent v2v1w2w2v2w1

dat we een getal samenstellen uit de eerste twee bits van V , gevolgd door de eerste en de derde bit van W ,daarna volgen nog de derde bit van V en de tweede bit van W . Dit algoritme is echter niet geschikt vooreen processor. Een processor voert immers continu het programma uit. Bovendien wordt hier niet gewachttot er invoer op de data-ingangen staat. Een laatste opmerking is dat we geen berekeningen op invoerkunnen uitvoeren. Anders zouden we immers de uitgangen van functionele eenheden met de ingangen vande processor verbinden. Daarom dienen we variabelen te introduceren die we X, Y en Z noemen. Daaromzullen we het algoritme herschrijven2. We beschouwen hierbij de controle-ingang ci en de controle-uitgangco. De herschreven procedure staat in Algoritme 3.

5.2.2 Toestandsbeschrijving

Een eerste probleem dient zich aan hoe we de procedure omzetten in een reeks toestanden. De vraag isimmers wat we in een zo’n toestand zullen realiseren. Zo kunnen we Algoritme 3 uitvoeren en per instructieeen nieuwe toestand bouwen. Als we echter het programma onder de loep nemen, zien we dat dit algoritmezich uitstekend leent om verschillende instructies samen uit te voeren. Allereerst voeren we in de for-lushoofdzakelijke shift operaties uit. Deze shiftoperaties vinden plaats over een vast aantal posities. We dienen

2Strikt genomen is dit geen algoritme meer, vermits het nooit eindigt en er geen echt resultaat is. Een betere bewoording iswaarschijnlijk procedure.


Algorithm 3 Procedure voor het delen van twee 4-bit getallen.

1: procedure Division2: while true do3: repeat4: co← 05: X ← N6: Y ← 07: Z ← 08: until ci9: for I = 3 to 0 do

10: Z ← Z shl 1 . Logische shift Z naar links over 1 positie11: Z [0]← X [3]12: X ← X shl 1 . Logische shift X naar links over 1 positie13: Y ← Y shl 1 . Logische shift Y naar links over 1 positie14: if Z ≥ D then15: Z ← Z −D16: Y [0]← 117: end if18: end for19: repeat20: co← 121: Q← Y22: R← Z23: until ¬ci24: end while25: end procedure

dus helemaal geen schuifoperator te implementeren, en kunnen eenvoudigweg schuiven met verbindingen.Vervolgens doen we ook aan bitmanipulaties. Omdat deze bitmanipulaties opnieuw op vaste plaatsen plaats-vinden kunnen we dit realiseren met behulp van verbindingen. De enige twee aspecten die enige logicavereisen is de test of Z ≥ D is (lijn 14), en het eventueel aftrekken van D uit Z (lijn 15). Daarnaast moetenwe tijdens de uitvoer van de for lus ook controleren of I ≥ 0. In dat geval dienen we immers nogmaalsde for-lus uit te voeren. We kunnen dit echter controleren met een simpele OR-poort die alle bits van Isamenneemt. Indien minstens een van de bits een 1 is, zal de OR-lus een 1 teruggeven, en dienen we dusnog een cyclus uit te voeren. Dit leidt ertoe dat we ons algoritme in drie toestanden opdelen:

1. S0: inlezen van invoer, initialiseren van variabelen en wachten totdat ci hoog wordt (lijnen 3-8).

2. S1: uitvoeren van een cyclus van de for lus en I met 1 verlagen (lijnen 9-18).

3. S2: resultaten op de uitgang plaatsen en wachten tot ci laag wordt (lijnen 19-23).

5.2.3 Toestand-Actie Tabel

Nu we de toestanden hebben vastgesteld kunnen we het algoritme verder formaliseren. Dit zouden wekunnen doen met een grafische voorstelling zoals we gedaan hebben met een eindige toestandsautomaat.Het probleem is dat een rij in het toestandsdiagram niet enkel de voorwaarden en eventuele uitgangen bevat,daarnaast dient het ook nog de acties die door het datapad moeten worden uitgevoerd weer te geven. Dit zouleiden tot een complex en chaotisch diagram. Daarom verkiezen we een tabel: de “Toestand-Actie Tabel”.De tabel bestaat grofweg uit drie gedeeltes:

• de huidige toestand: de huidige toestand waarin de controller zich bevindt.

• Een toestandsgedeelte: die we kunnen vergelijken met de toestandstabel van een eindige toestandsau-tomaat. De tabel bevat volgende kolommen:


– condities (afhankelijk van controle- en status-signalen)

– de volgende toestand

– de uitvoer (van eventuele controle-uitgangen).

• een controle-actie gedeelte. Dit gedeelte bevat twee kolommen:

– conditie: een set voorwaarden wanneer een bepaalde set acties (gespecificeerd in de volgendekolom) moet worden uitgevoerd.

– actie: afhankelijk van de conditie welke opdrachten uitgevoerd worden op de variabelen in eenklokcyclus.

Tabel 5.1 toont de toestand-actie tabel van Algoritme 3. Een belangrijke opmerking is dat het onderverdelenvan toestanden in condities bij het toestandsgedeelte niet verder loopt bij het onderverdelen van diezelfdetoestand in het controle-actie gedeelte. Dit betekent dus dat de conditie bij de volgende toestand niet deconditie bij de controle- en datapad-acties impliceert en omgekeerd. Concreet betekent dit dus dat indienI > 0, dit niet betekent dat z2z1z0x3 < D of dat we de bijbehorende datapad-acties moeten uitvoeren.Het toestandsgedeelte en het controle-actie gedeelte zijn dus onafhankelijk en zijn enkel afhankelijk van dehuidige toestand.

Huidige Volgende toestand Uit- Controle- & datapad-actiesToestand Conditie Toestand gang Conditie Acties

S0

ci = 0 S0 co = 0X ← NY ← 0

ci = 1 S1 co = 0Z ← 0I ← 3

S1

I > 0 S1 co = 0 z2z1z0x3 < D

Z ← z2z1z0x3

X ← X shl 1Y ← Y shl 1I ← I − 1

I = 0 S2 co = 0 z2z1z0x3 ≥ D

Z ← z2z1z0x3 −DX ← X shl 1Y ← y2y1y01I ← I − 1

S2

ci = 0 S0

co = 1Q = YR = Z

ci = 1 S2

co = 1Q = YR = Z

Tabel 5.1: Toestand-actie tabel van het leidend voorbeeld.

Simulatie Om ons meer vertrouwd te maken met het concept van een toestand-actie tabel zullen we eendeling simuleren met behulp van de tabel. We zullen N = 12 delen door D = 7 op de processor en stap perstap kijken wat er verandert. Dit doen we met behulp van tabel 5.2. Omdat we met bitoperaties werkenzullen we alle variabelen in de tabel in binaire notatie zetten. We stellen dat vanaf dat we de simulatiebeginnen, reeds de data op de ingangen van de processor aangelegd staat. Bijgevolg is ci = 1, N = 1100 enD = 0101. We maken verder ook een assumptie dat X, Y en Z 4-bit geheugens zijn, dit is redelijk vermitswe uitsluitend bits in dit bereik gebruiken, en we geen schuifoperaties naar rechts uitvoeren waardoor hogerebits in het bereik zouden komen te liggen. I is een 2-bit geheugen vermits het uitsluitend waardes tussen 0 en3 moet aannemen. Initieel vertrekt de processor vanuit toestand S0 we zien op die toestand-actie tabel datin toestand S0 de ingangen in de geheugens worden ingelezen. Vermits er data op de ingangen staat, krijgtX de waarde van de teller N = 1100. De overige variabelen worden geınitialiseerd zoals beschreven staat in


Toestand Voldane Condities Acties Uitvoer

S0 ci = 1

X ← N = 1100

co = 0Y ← 0000Z ← 0000I ← 11

S1

I = 11 > 00Z ← z2z1z0x3 = 0001

co = 0X ← X shl 1 = 1000

z2z1z0x3 = 0001 < D = 0101Y ← Y shl 1 = 0000I ← I − 1 = 10

S1

I = 10 > 00Z ← z2z1z0x3 = 0011

co = 0X ← X shl 1 = 0000

z2z1z0x3 = 0011 < D = 0101Y ← Y shl 1 = 0000I ← I − 1 = 01

S1

I = 01 > 00Z ← z2z1z0x3 −D = 0001

co = 0X ← X shl 1 = 0000

z2z1z0x3 = 0110 ≥ D = 0101Y ← y2y1y01 = 0001I ← I − 1 = 00

S1

I = 00Z ← z2z1z0x3 = 0010

co = 0X ← X shl 1 = 0000

z2z1z0x3 = 0010 < D = 0101Y ← Y shl 1 = 0010I ← I − 1 = 11

S2 ci = 0co = 1

Q = Y = 0010R = Z = 0010

Tabel 5.2: Simulatie van het algoritme met behulp van de toestand-actie tabel (tabel 5.1).

de toestand-actie tabel. Omdat ci = 1 kunnen we afleiden dat de volgende toestand S1 is. Verder specificeertde tabel ook dat we een laag signaal op de controle-uitgang moeten aanleggen (momenteel staat er immersgeen uitkomst op de uitgangen). In de volgende stap bevinden we ons in toestand S1. We evalueren eerstde verschillende condities ??.

5.2.4 ASM-Schema

Zoals reeds gezegd is de visualisatie van een eindige toestandsautomaat niet toereikend om een algoritmeweer te geven. Een grafisch voorstelling die we wel kunnen gebruiken is een “Algorithmic-State-MachineChart” ofwel “ASM-schema”.

ASM-Elementen

Een ASM-schema lijkt op een flow-chart en bestaat drie verschillende soorten “ASM-elementen”:

• Toestandskader ofwel state box: dit is een set niet-conditionele toekenning. We stellen een toestands-kader voor door middel van een rechthoek waarin we de toekenningen schrijven. De toekenningen ineen toestandskader worden parallel uitgevoerd. Daarnaast bevat een toestandskader ook de status- endata-uitgangen van de processor. Men maakt een onderscheid doordat toekenningen met een pijl (←)weergegeven worden en uitgangen met een gelijkheidsteken (=). Figuur 5.2(a) toont een voorbeeld vaneen toestandskader.

• Beslissingskader ofwel decision box: dit is de voorstelling van een bepaalde conditie. Een conditiewordt voorgesteld met behulp van een ruit, waarin de conditie wordt geschreven. Vanuit een beslis-singskader vertrekken er twee pijlen: voor het geval waarin de voorwaarde waar of vals is. We noterende pijlen dan ook respectievelijk met “[True]” en “[False]”, soms wordt ook 1 en 0 gebruikt. Figuur5.2(b) toont een voorbeeld van een beslissingskader.


• Conditioneel kader ofwel conditional box: Dit is een toestandskader die enkel onder voorwaardengespecificeerd door een beslissingskader worden uitgevoerd. Ook deze toekenningen worden in paralleluitgevoerd. Verder bevat een conditioneel kader ook de conditionele uitvoer op de processoruitgangen.We noteren toekenningen en uitgangen op dezelfde manier als bij toestandskaders. Men stelt eenconditioneel kader voor als een rechthoek met afgeronde hoeken. Figuur 5.2(c) toont een voorbeeldvan een conditioneel kader.

variabele1 ← expressie1

· · ·variabelem ← expressiemuitgang1 = expressiem+1

· · ·uitgangn = expressiem+n

in

uit

(a) Toestandskader

test

in

uit 1 uit 2

[True] [False]

(b) Beslissingskader

variabele1 ← expressie1

· · ·variabelem ← expressiemuitgang1 = expressiem+1

· · ·uitgangn = expressiem+n

in

uit

(c) Conditioneel kader

Figuur 5.2: Voorstelling van de verschillende ASM-elementen

Het ASM-Blok

Deze ASM-elementen worden gegroepeerd in een “ASM-blok”. Alle ASM-elementen die in eenzelfde ASM-blok zitten, worden dan in een klokcyclus uitgevoerd. Hierdoor voorzien we per toestand in de Toestand-Actietabel een ASM-blok. Het blok zelf moet dan specificeren wat er in de toestand gebeurt. We zullen dezecomponent voorstellen met behulp van een vierkant met streepjeslijnen. Vermits alle acties in een klokflankuitgevoerd worden, bevat elk ASM-blok exact een toestandskader. Dit toestandskader bevat dan alle toe-kenningen en uitgangen die onafhankelijk van condities in die toestand worden uitgevoerd. Indien er geenonafhankelijke operaties zijn, is het vierkant leeg. Indien er naast onafhankelijke acties ook conditioneleacties gebeuren (zowel in het toestand- als het actie-gedeelte), zullen we vervolgens enkele beslissingskadersplaatsen. We voeren testen uit op variabelen in het datapad door middel van status-signalen en eventuelesignalen aan de controle-ingangen. Vermits we al deze testen reeds in de toestand-actie-tabel hebben gedefi-nieerd kunnen we eenvoudig de toestand-actie-tabel omvormen tot een ASM-schema. Zo staat op figuur 5.3het ASM-schema voor het leidend voorbeeld.

Traditionele Valkuilen

Traditioneel maakt men een aantal fouten tegen ASM-schemas. In deze subsubsectie zullen we een overzichtgeven van de meest gemaakte fouten.

Meerdere volgende toestanden Men kan in een ASM-schema een flow chart tekenen waarbij onderbepaalde condities, men twee verschillende pijlen kan volgen. Een voorbeeld van zo’n flow chart staat opfiguur 5.4(a). Indien bijvoorbeeld test t1 slaagt en t2 faalt, dienen we de stromen naar A1 en A3 te volgen.Dit is niet zo problematisch wanneer dit in hetzelfde ASM-blok gebeurt (we kunnen argumenteren dat wedan alle toewijzingen uit A1 en A3 uitvoeren). Indien we echter later naar verschillende toestanden gaankrijgen we problemen. We kunnen dit probleem makkelijk verhelpen door geen vertakkingen met pijlen toete staan. Enkel uit het beslissingskader vertrekken twee pijlen. Uit een toestands- en conditioneel kadervertrekt altijd slechts een pijl. Het samenbrengen van pijlen is wel toegelaten.

Geen volgende toestand Ook het omgekeerde kan voorkomen: een ASM-blok waarbij we geen volgendetoestand bekomen bij een bepaalde situatie. Figuur 5.4(b) toont een minimaal voorbeeld: indien aan t1


X ← NY ← 0Z ← 0I ← 3co = 0

ci = 0[False][True]

X ← X shl 1I ← I − 1co = 0

z2z1z0x3 < D

Z ← z2z1z0x3

Y ← Y shl 1Z ← z2z1z0x3 −DY ← y2y1y01

I > 0

[False][True]

[False][True]

co = 1

ci = 1

Q = YR = Z

[False][True]

S1

S2

S3

Figuur 5.3: ASM-schema van het leidend voorbeeld.

wordt voldaan zullen we nooit naar een volgende toestand overgaan. Dit komt omdat de pijl nooit eentoestandskader bereikt (en we dus in een volgende toestand komen. Ook dit probleem kunnen we eenvoudigvoorkomen: in elk ASM-blok gaan alle mogelijke lussen doorheen het toestandskader.

Verschillende toekenningen aan dezelfde variabele Tijdens een klokflank kan een variabele slechtseenmaal van waarde veranderen. We kunnen in een ASM-blok echter meerdere kaders plaatsen die elk eenwaarde aan dezelfde variabele toekennen. Figuur 5.4(c) toont zo’n situatie: indien t1 niet waar is, kennenwe zowel 0 als 1 toe aan X. Men kan argumenteren dat X dan de waarde 1 krijgt, omdat dit de laatstetoekenning is aan X in het diagram. De componenten die in een ASM-blok staan kunnen dus vrij veranderdworden in volgorde. Bovendien zullen we in sectie 5.4 een mechanisme ontwikkelen om deze ASM-schema’som te zetten in hardware. Incorrecte ASM-schema’s zullen leiden tot implementatiefouten. We kunnen ditvoorkomen door bij elk ASM-blok alle mogelijke paden te analyseren en te controleren dat geen variabeletwee toewijzingen krijgt.

Testen van nieuwe waarde Omdat alles in een ASM-blok tegelijk gebeurt, zijn de waardes van variabelenook nog niet aangepast wanneer we een toestandsblok verlaten. Zolang we ons echter nog in hetzelfde ASM-blok bevinden, zijn die aanpassingen nog niet doorgevoerd. Stel dat we bijvoorbeeld volgende C programmabeschouwen:

a--;

if(a > 3)

b = 2;

Dan kunnen we dit vertalen naar een toestand in het ASM-schema. Figuur 5.4(d) is echter niet de juistevertaling. Stel immers dat a = 4 dan zal in het C-programma de if-lus niet uitgevoerd worden, a heeftimmers voor het if-statement de waarde 3. In het ASM-schema krijgt a ook de waarde 3, maar alleen nadatwe het ASM-blok verlaten hebben. Bijgevolg zal bij de voorwaarde a nog steeds de waarde 4 hebben en zalde if-lus uitgevoerd worden. Een oplossing is om in dit geval gewoon te testen op a− 1 > 3 of dus a > 4.


A0

t1 t2

A1 A2 A3

[False][True] [False][True]

S1

S2 S3 S4

(a) Meerdere volgende toestanden

A0

t1

A1

[False][True]

S1

S2

(b) Geen volgende toestanden

X ← 0

t1

X ← 1

A0

[False][True]

S1

S2

(c) Meerdere toekenningen

a← a− 1

a > 3

b← 2

A0

[False][True]

S1

S2

(d) Testen op nieuwe waarden

y ← x+ 1

z ← y + 2

6= y ← x+ 1z ← y + 2

(e) Gebruik nieuwe waarde

A0

A1

(f) Conditioneel natoestandskader

uitgang← expressie

(g) Toewijzen uitgang

Figuur 5.4: Traditionele valkuilen bij het maken van ASM-schema’s.

Gebruiken van een nieuwe waarde Een verwante traditionele fout is het gebruiken van de nieuwewaarde in de volgende berekening. Een voorbeeld van dit concept staat op figuur 5.4(e). Hier zien we tweeASM-schema’s die niet equivalent zijn. Indien bijvoorbeeld x = 2 en y = 1 zal in de eerste flow z = 5. In hettweede geval is z = 3. Indien beide kaders in een verschillend ASM-blok of -element staan, is dit uiteraardtoegelaten. Indien de toekenningen in hetzelfde ASM-element of ASM-blok staan, worden de opdrachtenparallel uitgevoerd, en zullen we dus de oude waarde gebruiken. Men kan dit fenomeen testen door devolgorde van toekenningen in een ASM-element te wijzigen of de beslissingskaders en hun bijbehorendeconditionele kaders anders te schikken. Nadat deze volgorde dan wijzigt, zou het programma nog steeds opdezelfde manier moeten werken.

Aanduiden van controller-uitgangen We zijn reeds kort ingegaan op de notatie van uitgangen in detoestanden conditionele kaders. We noteren de waarde van een uitgang met behulp van een gelijkheidsteken(=). Indien we de uitgang niet vermelden, staat er een 0 op die uitgang (in het geval van meerdere bits, zijnalle bits dus 0). Soms komt het ook voor dat een uitgang in elke toestand een combinatorische schakeling vanenkele variabelen is. In dat geval moeten we deze uitgang niet in elk toestandskader vermelden, maar volstaathet om een nota te maken, zoals we ook op figuur 5.3. Deze nota is geen onderdeel van het ASM-schema,en wordt makkelijk vergeten.


Conditioneel kader na toestandskader Een laatste fout die regelmatig terugkomt is het plaatsen vaneen conditioneel kader na een toestandskader zoals op figuur 5.4(f). Vermits er geen beslissingskader aanvooraf gaat, is dit conditioneel kader helemaal niet gebonden aan een voorwaarde. Dit probleem lossen we opdoor het conditioneel kader om te vormen tot een toestandskader. Indien beide kaders bovendien in eenzelfdeASM-blok staan, kunnen we de inhoud van beide kaders samennemen in een toestandskader.

Inputgebaseerde en Toestandsgebaseerde ASM-schema’s

We hebben het reeds kort gehad over het toekennen van toestanden aan delen van een programma besproken.Een belangrijk aspect daarbij is dat we ASM-schema’s kunnen onderverdelen in twee categorieen:

• Inputgebaseerd ASM-schema: In dit schema kunnen we de waarde van testen (status-signale) encontrole-ingangen onmiddellijk gebruiken. Een inputgebaseerd ASM-schema van het leidend voorbeeldstond op figuur 5.3.

• Toestandsgebaseerd ASM-schema: Hierbij kunnen we de waardes van testen (status-signalen) encontrole-ingangen pas in de volgende klokflank gebruiken. Het betekent dus dat elke voorwaardelijkeuitvoering van een opdracht gepaard gaat met de overgang naar een nieuwe toestand. Bijgevolg bevatdit diagram ook geen conditionele kaders.

Inputgebaseerde ASM-schema’s kunnen meer opdrachten uitvoeren in een klokflank, omdat we niet moetenwachten op het kloksignaal om conditionele operaties uit te voeren. Anderzijds zal dit ASM-schema tot eenlangere klokcyclus leiden. Dit komt omdat de testen eerst moeten berekend worden alvorens we sommigeopdrachten kunnen uitvoeren. Een nadeel van toestandsgebaseerde ASM-schema’s is dat we meer toestandennodig hebben, wat zal leiden tot een groter geheugen en mogelijk ook logica.

De termen inputgebaseerd en toestandsgebaseerd komen van de controller. We hebben reeds bespro-ken dat een controller een eindige toestandsautomaat is. Ook bij deze eindige toestandsautomaten hebbenwe deze indeling gemaakt. Een toestandsgebaseerd ASM-schema zal aanleiding geven tot een toestands-gebaseerde controller en vice versa. Bij wijze van voorbeeld zullen we het leidend voorbeeld ook met eentoestandsgebaseerd ASM-schema visualiseren op figuur 5.5.

5.3 Geheugencomponenten

Alvorens we processoren kunnen implementeren zullen we eerst nieuwe componenten moeten introduceren.We zullen we deze componenten introduceren in een logische volgorde waarbij componenten gebruik makenvan eerder geıntroduceerde componenten.

5.3.1 Register File Cell (RFC)

Een register file cell is een uitbreiding op een geklokte D-flipflop. Het component bevat een klok-ingang Clk,data-ingangen Din1, . . . , Dinm, data-uitgangen Dout1, . . . , Doutn, leespoorten RE1,REn (ook wel “Read-Enabled” genoemd) en schrijfpoorten WE1, . . . ,WEdlog2m+1e (ook wel “Write-Enabled” genoemd). Dezeingangen laten ons toe om te kiezen uit welke data-ingang we data willen inlezen en deze bij de klokflankwillen opslaan. We zullen data geklokt wegschrijven, net zoals bij een D-flipflop. Indien alle schrijfpoortenWEi = 0 lezen we geen nieuwe waarde in, en blijft de oude waarde behouden. In de andere gevallen dienende schrijfpoorten een binair getal a te bepalen vanuit welke data-ingang dina we data inlezen. Indien ervoor het aantal data-ingangen m geen natuurlijk getal l bestaat zodat l = log2m+ 1, zal er bij alle overigewrite-enable configuraties, data ingelezen worden uit de laatste data-ingang. Daarnaast kunnen we op eenderwelke uitgang de inhoud van het geheugen plaatsen. Vandaar dat er per uitgang ook een read-enable ingangis voorzien. Indien we een laag signaal aanleggen op een read-enable ingang REi, zal de overeenkomstigeuitgang Douti hoog impedant zijn. De toestand van de uitgangen is niet geklokt: indien we tijdens tweeklokflanken in een read-enable ingang aanpassen zullen we mits enige vertraging het resultaat op de data-uitgang zien, we hoeven dus niet op een klokflank te wachten. Op figuur 5.6 tonen we een implementatievan een Register File Cell met m = n = 2.

5.3. GEHEUGENCOMPONENTEN 159

X ← NY ← 0Z ← 0I ← 3co = 0

ci = 0[False][True]

X ← X shl 1co = 0

z2z1z0x3 < D

Z ← z2z1z0x3

I ← I − 1Y ← Y shl 1

Z ← z2z1z0x3 −DI ← I − 1

Y ← y2y1y01

I > 0 I > 0

[False][True]

[False][True] [False][True]

co = 1

ci = 1

Q = YR = Z

[False][True]

S1S2

S3

S4S5

Figuur 5.5: Toestandsgebaseerd ASM-schema van het leidend voorbeeld.

5.3.2 Registerbank

Een belangrijke toepassing van een Register File Cell is een registerbank. Een registerbank bevat verschil-lende register file cellen, die geordend worden in matrixstructuur. We spreken dan ook over een m × nregisterbank met k schrijfpoorten en l leespoorten. Dit betekent dat de component m sequenties van nbits opslaat. We kunnen hierbij data op k verschillende sequenties tegelijk schrijven, en de inhoud van lverschillende sequenties uitlezen. Hiervoor dienen we volgende in- en uitgangen te voorzien:

• invoer-ingangen Iij : een set van k × n ingangen om k sequenties van n bits te kunnen inlezen in deregisterbank.

• write-enable-ingangen WEi: k verschillende signalen waarmee we aangeven of de invoer op Iij ingan-gen moet worden ingelezen.

• write-address-ingangen WAia: k groepen van dlog2me bits waarmee we aangeven op welk adres we

Q

Q

D

Clk

Din1Din2

Clk

Dout1

Dout2

RE1 RE2

WE2 WE1

00011011

Figuur 5.6: Implementatie van een Register File Cell (RFC) met 2 lees- en 2 schrijfpoorten


de n bits die op Iij staan zullen wegschrijven.

• uitvoer-uitgangen Oij : een reeks van l × n signalen die we gebruiken om data in de registerbank uitte lezen.

• read-enable-ingangen REi: l signalen die bepalen of we op de uitgangen Oij iets zullen uitlezen.Analoog aan de write-enable-ingangen.

• read-address-ingangen RAia: l groepen van dlog2me bits bepalen welke sequentie – binair voorgesteldop de adres-ingangen – wordt uitgelezen. Dit is analoog aan de write-address-ingangen.

Een registerbank omvat twee scenarios: het inlezen van data en het uitlezen van data. Indien we een hoogsignaal aanleggen op WEi, zullen we de data die op de ingangen Iij staan wegschrijven naar het adres datbinair geencodeerd is met de write-access ingangen WAia voor j = 0 . . . n− 1 en a = 0 . . . dlog2me − 1. Ditdoen we op de klokflank. Indien we een laag signaal aan de write-enable ingang plaatsen, wordt de inhouddie op de bijbehorende invoer-ingangen staat genegeerd. Bij het uitlezen van data is het signaal van deread-enable-ingang van belang. Indien we een hoog signaal aanleggen op REi zullen de uitvoer-uitgangenOij de waardes van de data opgeslagen in een adres, binair gevormd door de read-address-ingangen WAia,aannemen voor j = 0 . . . n − 1 en a = 0 . . . dlog2me − 1. Indien we een laag signaal aanleggen, zijn dezeuitvoer-uitgangen hoog impedant. Uitlezen van data gebeurt ongeklokt: indien we bijvoorbeeld de read-adress signalen aanpassen, zullen de uitvoer-uitgangen zich aanpassen ongeacht de toestand van de kok opdat moment. Tot slot beschouwen we vaak een speciaal geval van een registerbank: de dual port registerbankis een registerbank met een lees- en een schrijfpoort. Bijgevolg is in dat geval k = l = 1.

dec

od

erWA00

WA01

WE0

dec

od

erWA10

WA11

WE1

deco

der RA00

RA01

RE0

deco

der RA10

RA11

RE1

deco

der RA20

RA21

RE2

RFC RFC RFC

RFC RFC RFC

RFC RFC RFC

RFC RFC RFC

O00O10

O20

I00 I10

O01O11

O21

I01 I11

O02O12

O22

I02 I12

Figuur 5.7: Implementatie van een 4× 3 registerbank met 2 schrijf- en 3 leespoorten.??

Op figuur 5.7 beschouwen we een 4 × 3 registerbank met 2 schrijf- en 3 leespoorten. Bij de constructievan een registerbank met k schrijf- en l leespoorten, gebruiken we logischerwijs file register cellen met k


schrijf- en l leespoorten. We zullen hier het kloksignaal negeren vermits de klokingang van de registerbankhet kloksignaal enkel verder propageert naar de klokingangen van alle register file cellen. We construerenvervolgens k + l m-bit decoders te introduceren. Bij elk van de decoders verbinden we een read-enable REiof write-enable WEi met de enable-ingang van de decoder. De read-address RAij en write-address WAij

ingangen leggen vervolgens signalen aan op de adres-ingangen van de bijbehorende decoders.??

Verder zullen we ook een nieuwe notatie invoeren die we vanaf hier frequent zullen gebruiken: vaak zulleneen groot aantal signalen parallel verschillende bits van de ene component naar de andere overbrengen.Vermits door de orientatie van de de component meestal duidelijk is om welke signalen het gaat, zullen weniet elk signaal individueel tekenen. In dat geval stellen we de groep signalen voor met een brede lijn, enschrijven naast een dwarse streep het aantal signalen op die deze lijn voorstelt.

5.3.3 Random Access Memory (RAM)

Een variant van een registerbank is “Random Access Memory (RAM)”. De term “Random Access” slaatop het feit dat we het geheugen niet sequentieel moeten uitlezen. We kunnen dus een adres meegeven datbepaalt welke cellen we uitlezen. Verder wijkt een RAM ook af van “Read-Only Memory (ROM)” omdat wedata naar het geheugen kunnen schrijven. Bij ROM branden we de data via een ingewikkelde procedure op dechip, waarna we enkel data kunnen uitlezen. Beide eigenschappen zijn ook eigen aan een registerbank. Indienwe echter naar de implementatie van een registerbank kijken, is deze niet goedkoop. RAM geheugens biedeneen gelijkaardige functionaliteit met minder hardware. Hiervoor bestaan er twee soorten implementaties:

• Statisch RAM: hier realiseren we een bit geheugen met een flipflop (wat dus neerkomt op 4 tot 6transistoren per bit).

• Dynamisch RAM: een implementatie met behulp van een condensator. Indien er stroom op de conden-sator staat bevat de cel een 1, in het ander geval een 0. Dynamisch RAM heeft de eigenschap dat doorde data van een bit op te vragen, we de stroom uit de condensator halen, en deze dus opnieuw moetenopladen. Daarnaast kent een condensator ook lekstroom, waardoor we aan een zekere frequentie decellen die een 1 voorstellen terug moeten opladen.

Vermits we minder hardware per bit nodig hebben, zal RAM bepaalde functionaliteit van een registerbankniet aanbieden. Allereerst werkt RAM geheugen trager. Dit kan alleen al verklaard worden door eengrotere adres-decoder - RAM geheugens zijn immers groter - en het is dus niet geschikt voor het opslaanvan tussenresultaten in processoren. Daarnaast heeft RAM-geheugen een gecombineerde lees-schrijfpoortR/W ∗. Om aan te geven dat we iets willen schrijven of uitlezen bevat RAM-geheugen daarnaast ook eenChip Select-ingang CS. Deze ingang functioneert ook als een vorm van klok-ingang. RAM geheugen isbijgevolg niet geklokt3.

RAM-geheugens hebben complex tijdsgedrag. Daarom zullen we twee scenario’s bespreken: het uitlezenen wegschrijven van data bespreken samen met de verschillende vormen van vertraging. Verder zullen weook enkele typische grenzen van vertragingstijden voor vergelijkbare RAM-geheugen geven in tabel 5.3.

Uitlezen van data Hiervoor dienen we het adres op de adres-ingang aan te leggen en een hoog signaalop de Chip Select-ingang CS en de lees-schrijfpoort R/W

∗. Op het moment dat we dit doen, zal de data-

uitgang4 Dout hoog impedant zijn. Na enige tijd zal er op deze uitgang een ongeldig signaal komen te staandit wordt meestal veroorzaakt door de interne logica van de component. Vervolgens komt de werkelijke dataop de data-uitgangen te staan. Kenmerkend zijn hier de toegangstijd tAA en de CS toegangstijd tACS. Hetzijn de maximale tijdsverschillen tussen het aanleggen van het signaal en het verschijnen van de geldige dataop de data-uitgangen. Stel dat de lees-schrijfpoort en de chip-select ingang al hoog aangestuurd worden,en we zetten een adres op de adres-ingang zal het hoogstens de tijd gespecificeerd door de toegangstijd

3Of tenminste niet op de globale klok van de schakeling.4Meestal heeft RAM-geheugen geen enkele data-uitgang maar een reeks uitgangen waardoor we bijvoorbeeld 8 bit tegelijk

kunnen uitlezen.


duren alvorens er geldige data op data-uitgang komt te staan. Omgekeerd kan er ook een geldig adres opde adres-ingang staan en dienen we nog een hoog signaal op de CS- en R/W

∗aan te leggen. In dat geval

duurt het hoogstens de CS toegangstijd alvorens geldige data op de data-uitgang verschijnt. Eenmaal ergeldige data op de data-uitgang verschijnt kunnen we deze uitlezen en ergens in de schakeling gebruiken.Om nieuwe data uit te lezen of weg te schrijven zullen we ofwel het adres moeten veranderen, ofwel een laagsignaal op de CS- of R/W

∗-ingang aanleggen. Er treed enige vertraging op alvorens het signaal van de data-

uitgang dan terugvalt op de hoog impedante toestand. Deze vertraging noemen we de CE Off to OutputHigh Impedance State tHZ. Een laatste tijdseenheid is de leescyclustijd tRC. Deze vertraging bepaalt deminimale duur van het volledige leesproces. Het specificeert de minimale tijd die tussen twee leesopdrachtenligt. Vaak is deze bij DRAM langer dan de som van alle vertragingen die we hierboven beschouwd hebben.Dit komt omdat we na het uitlezen van de data, de condensatoren terug moeten opladen. Een schematischevoorstelling van deze tijden staat op figuur 5.8(a).

Adres Adres

CS · R/W∗

Dout geldig

tRC

tAA

tACS tHZ

(a) Uitlezen

Adres Adres

CS ·(R/W

∗)′Din - geldig -

tWC

tDW tDH

(b) Wegschrijven

Figuur 5.8: Tijdsgedrag van RAM-geheugens.

Wegschrijven van data Een gelijkaardig scenario treedt op bij het wegschrijven van data, alleen beschou-wen we hier de data-ingang5 Din. Opnieuw dienen we eerst het adres aan te leggen op de adres ingang. Verderzetten we een 0 op de lees-schrijfpoort om aan te geven dat we een schrijf-operatie uitvoeren, en zetten weeen 1 op de Chip Select-ingang om aan te geven dat we een operatie zullen uitvoeren. Vervolgens kunnen wedata op de data-ingang aanleggen. Wanneer we de correcte data wegschrijven is in principe irrelevant. Vanafhet moment dat we de operatie starten, zal het geheugencomponenten beginnen met data weg te schrijven.Als we data aan de data-ingang veranderen zal met enige vertraging de nieuwe data weggeschreven worden.We dienen alleen de tijdkarakteristieken van geheugencomponenten in het algemeen in de gaten te houden:de set-up-tijd tDW en de data houdtijd tDH. Kort voor het afronden van de operatie dient immers de dataniet meer te veranderen aan de ingang van de data-ingang. Dit is de set-up tijd. Anderzijds dient de databovendien nog een zekere periode na het afronden van de operatie te blijven staan: de houdtijd. Tot slotspreken we ook over een schrijf cyclustijd tWC. Dit is de minimale tijd dat het adres op de adres-ingangmoet blijven staan en de chip select-ingang en lees-schrijfpoort dezelfde configuratie blijven behouden. Eenschematische voorstelling van een schrijfoperatie staat op figuur 5.8(b). Typische vertragingen voor een4k× 1-RAM6 geheugen voor SRAM en DRAM staan in tabel 5.3.

5.3.4 Geheugens met Impliciete Adressering

RAM geheugens vereisen dat we een absoluut adres meegeven. In heel wat programmeertalen hebbenwe echter datastructuren beschikbaar die zonder expliciete adressen werken. We spreken dan over eenstapelgeheugen ofwel stack en een buffergeheugen ofwel queue. Omdat deze datastructuren bijzondernuttig zijn in sommige algoritmen, werden hiervoor ook hardware-equivalenten ontwikkeld. We zullen in devolgende subsubsecties eerst deze datastructuren bespreken en vervolgens een hardwarecomponent bouwen

5Vermits er bij het inlezen op data-uitgang een hoog-impedant signaal wordt aangelegd, combineren sommige RAM-geheugensde data-ingang en de data-uitgang. In dat geval kunnen de signalen dus in beide richtingen stromen. We gaan hier niet verderop in.

6Dit betekent dat het geheugencomponent 4096 adressen bevat en elk adres 1 bit bijhoudt.


∆t Vertraging2147H SRAM MM5280 DRAM

min max min maxtRC cyclustijd lezen 35 ns 400 nstAA toegangstijd 35 ns 200 nstACS CS toegangstijd 35 ns 180 nstHZ CS′ → Z 0 ns 30 ns 0 nstWC cyclustijd schrijven 35 ns 0 nstDW data set-up-tijd 20 ns 150 nstDH data houdtijd 0 ns 0 ns

Tabel 5.3: Typische vertragingstijden voor RAM-geheugens.

die deze structuren implementeert. Studenten met een uitgebreide kennis over deze datastructuren kunnende definitie overslaan.

Stack (LIFO: Last-In-First-Out)

Definitie Een stack ofwel stapelgeheugen is een datastructuur die een lineare lijst voorstelt. Alle methodesvan de stapel kunnen enkel bewerkingen uitvoeren op een uiteinde van deze lijst: de top. De lijst vanaangeboden functionaliteiten verschilt nogal. Toch dient een stapel minstens volgende functionaliteiten aante bieden:

• push: het toevoegen van een element aan de stapel. Dit element wordt dan de nieuwe top.

• pop: het weghalen van het element die zich bij de top bevindt. Het element net onder de top wordtdan de nieuwe top.

• reset: ook wel clear genoemd. Een operatie die de volledige stapel verwijdert. We kunnen dit opvattenals het herhalen van een pop-operatie totdat de stapel leeg is, in de meeste gevallen kunnen we dezeoperatie echter sneller uitvoeren.

• leeg/empty: controleren of een stapel leeg is en dus geen enkel element bevat. Indien dit het geval is,kan men geen pop-operaties meer uitvoeren.

• vol/full: controleren of het volledige geheugen van de stapel gebruikt wordt. Indien dit het gevalis, kan men geen push-operaties meer uitvoeren. Deze functionaliteit wordt meestal niet in software-implementaties van stapels aangeboden vermits men het geheugen dynamisch kan uitbreiden tot hetvolledige RAM geheugen in gebruik genomen is. Een fenomeen dat men doorgaans niet beschouwt insoftware.

In hardware is een element een hoeveelheid data met een vast aantal bits. Men spreekt over het “Last-In-First-Out (LIFO)”-principe omdat de elementen die het laatst aan een stapel toegevoegd worden (doormiddel van een push-operatie), de eerste elementen zijn die terug uit de stapel gehaald worden (door middelvan een pop-operatie).

6

(a) Push 6

6

2

(b) Push 2

6

2

(c) Pop

6

1

(d) Push 1

6

1

(e) Pop

6

(f) Pop

Figuur 5.9: Conceptueel voorbeeld van een stapelgeheugen.


Conceptueel voorbeeld We introduceren ook een conceptueel voorbeeld van een stapelgeheugen datstaat op figuur 5.10. Initieel is de stapel leeg en bevat deze dus geen elementen. Vervolgens voeren we eenpush-operatie uit met als argument 6. Het gevolg is een stapel met als enig element 6. Daarna voeren we eenpush operatie uit met 2. We voegen dus 2 toe aan de top van de stapel. Hierna voeren we een pop-operatieuit. Vermits het laatste toegevoegde element – dat nog niet van de stapel is gehaald – 2 is, zullen we 2terugkrijgen. Bij de push-operatie van 1 voegen we 1 toe aan de stapel. De stapel heeft dan als top 1 ensubtop 6. Tot slot voeren we twee pop-operaties uit. Omdat 1 het laatste toegevoegde element is, is dit hetresultaat van de eerste pop-operatie. Tot slot zullen we ook 6 van de stapel halen.

Implementatie met een schuifregister We kunnen een stapel implementeren met behulp van een schuif-register. Voorwaarde is wel dat het geheugen dan niet bijzonder groot kan worden. Bij een push operatiezullen we in dat geval de bits van het element inschuiven en dit aantal bits naar links opschuiven. Bij eenpop-operatie schuiven we dit aantal bits terug naar rechts, en stellen de meest rechtse bits dit element voor.Deze implementatie is vrij kostelijk: in 4.2.2 hebben we reeds registers geımplementeerd. Per bit geheugenhebben we een flipflop en enkele multiplexers nodig. Bij grote stapelgeheugens is deze kost onacceptabel.Daarom zullen we bij grote stapels meestal gebruik maken van RAM-geheugens.

3

lees

schrijf

0

0

1

2

3

(a) Push 6

0

lees

schrijf

1

0

1

2

3

6

(b) Push 2

1

lees

schrijf

2

0

1

2

3

6

2

(c) Pop

0

lees

schrijf

1

0

1

2

3

6

(d) Push 1

1

lees

schrijf

2

0

1

2

3

6

1

(e) Pop

0

lees

schrijf

1

0

1

2

3

6

(f) Pop

Figuur 5.10: Demonstratie van een stapelgeheugen met tellers.

Implementatie met RAM-geheugens Een goedkopere manier is gebruik maken van RAM-geheugens.Hierbij is de kost beperkt tot een 4 a 6 transistoren per bit. We realiseren dan een stapelgeheugen met behulpvan een RAM-geheugen – die tevens ook de grootte van het stapelgeheugen bepaalt – en twee tellers: hetleesadres en het schrijfadres. Indien het RAM-geheugen 2n adressen kent, beschouwen we een n-bit leestelleren n+ 1-bit schrijftellers7. De schrijfteller staat initieel op 0, de leesteller staat initeel op 2n − 1. Wanneerwe een push operatie uitvoeren schrijven we de data weg naar het adres voorgesteld door de schrijfteller,en verhogen we beide tellers. Bij een pop-operatie lezen we de data uit het RAM-geheugen op het adresvoorgesteld door de leesteller. Vervolgens verlagen we beide tellers. Merk op dat we bij een push- en pop-operatie dus niet alle data in het RAM-geheugen moeten opschuiven. We verhogen en verlagen enkel detellers. Indien we het volledige geheugen volgeschreven hebben, zal de schrijfteller op 2n komen te staan8.Dit betekent dus dat de n + 1-de bit van die teller een hoog signaal bevat. We kunnen dit hoog signaalnaar buiten brengen als een full-signaal. Op figuur 5.11 implementeren we dit stapelgeheugen. Indien hetreset-signaal actief wordt, wordt de schrijfteller gereset en komt deze op 0 te staan, de leesteller voert een load-operatie uit en laadt de waarde 2n− 1 in. Bij een push-operatie wordt het push/pop∗ signaal hoog, hierdoorwordt het increment-signaal bij beide tellers geactiveerd en worden deze opgehoogd in de volgende klokflank.De multiplexer zal intussen de huidige waarde van de schrijfteller doorsturen naar het RAM-geheugen, diede waarde die op de data-ingangen staat zal inlezen en wegschrijven. Bij een pop-operatie ontvangen beide

7Op die manier kunnen ze elk adres voorstellen. We voegen aan de schrijfteller een extra bit toe voor overflow.8Vermits de schrijfteller een n + 1-bit teller is.


LD

CEin

U/D∗

Clk

CLR

CEoutn+ 1-bitschrijfteller

LD

CEin

U/D∗

Clk

CLR

CEoutn-bitleesteller

2n − 1

n

D

A

CS

R/W∗

2n × w-bitRAM

n

n n

n

n

Reset∗

EnablePush/Pop∗

Full

nEmpty

Data In/Outn

Figuur 5.11: Implementatie van een stapelgeheugen met behulp van RAM-geheugen.

tellers een decrement-signaal, de multiplexer stuurt het leesadres door naar het RAM-geheugen die de waardedie op dit adres staat op de data-uitgang zal zetten. Ons component bevat daarnaast nog een enable-ingang:indien deze op 0 staat, worden de tellers en het RAM-geheugen niet aangepast en gebeurt er dus niets. Defull-uitgang brengt zoals eerder vermeld de hoogste bit van de schrijfteller naar buiten, en is hoog indien allegeheugenplaatsen opgebruikt zijn. Daarnaast bevat ons component ook een empty-uitgang. Deze voert eenNOR-operatie uit op alle bits van de schrijfteller. Indien alle bits 0 zijn (en de teller dus op 0 staat) is destapel leeg, en geeft empty dus een laag signaal. Tot slot kunnen we opmerken dat we voor de implementatiestrikt genomen geen twee tellers nodig hebben. Vermits de leesteller telkens gelijk is aan de gedecrementeerdewaarde schrijfteller (en modulo 2n), zouden we ook een combinatorische moduler kunnen voorzien die dewaarde van de leesteller uit de schrijfteller afleidt. In dit geval zal de vertraging van de pop- operaties welgroter worden.

Queue (FIFO: First-In-First-Out)

Definitie Een queue of buffergeheugen is een datastructuur die een lineare lijst voorstelt. Deze lijstheeft twee uiteindes. Aan het ene uiteinde voegen we elementen toe bij een schrijfoperatie, aan het andereuiteinde zullen we bij een leesoperatie elementen weghalen. Zoals de naam al doet vermoeden heeft eenqueue hoofdzakelijk de taak om data te bufferen in de tijd9. Dit kan bijvoorbeeld nuttig zijn indien weeen component soms aan hoge snelheid invoer data krijgt (zogenaamde bursts) en men deze data niet aandezelfde snelheid kan verwerken. Een queue dient minstens volgende functionaliteiten aan te bieden:

• Write (ofwel enqueue): het inlezen van data en dit aan een uiteinde van het buffergeheugen plaatsen.

• Read (ofwel dequeue): het uitlezen van data aan het andere uiteinde van het buffergeheugen.

• Reset: het buffergeheugen in de initiele toestand plaatsen (waarbij het dus geen elementen bevat). Ditkan opgevat worden als het herhalen van read operaties tot alle elementen uit de queue verdwenen zijn.

• Full: een indicator of alle beschikbare geheugenlocaties bezet zijn.

• Empty: een indicator dat het buffergeheugen leeg is.

9Men dient een buffergeheugen niet te verwarren met een buffer-component. Een buffercomponent staat in voor het gelijk-matig verdelen van de spanning over verschillende uitgangen (en buffert dus het elektrisch potentiaal).


In hardware is een element een hoeveelheid data met een vast aantal bits. Men spreekt over het “First-In-First-Out (LIFO)”-principe omdat de elementen die het eerst aan een queue toegevoegd worden (doormiddel van een write-operatie), de eerste elementen zijn die terug uit de queue gehaald worden (door middelvan een read-operatie).

6

(a) Write 6

6

2

(b) Write 2

6

2

(c) Read

2

1

(d) Write 1

2

1

(e) Read

1

(f) Read

Figuur 5.12: Conceptueel voorbeeld van een buffergeheugen.

Conceptueel voorbeeld Analoog aan het stapelgeheugen introduceren we een conceptueel voorbeeld vooreen buffergeheugen op figuur 5.13. We voeren dezelfde operaties uit als bij het stapelgeheugen (push is writeen pop is read). Toch zien we dat de elementen op een andere manier uit de datastructuur verdwijnen.Aanvankelijk is de queue leeg. Vervolgens plaatsen we met write operaties een 6 en een 2 in de queue. Bijde read operatie zullen we in tegenstelling tot bij een stapel, de 6 uit het geheugen halen.

0

0

lees

schrijf

0

1

(a) Push 6

0

1

lees

schrijf

0

1

6

(b) Push 2

0

2

lees

schrijf

0

1

6

2

(c) Pop

1

2

lees

schrijf

0

1 6

(d) Push 1

1

3

lees

schrijf

0

1 6

1

(e) Pop

2

3

lees

schrijf

0

1

6

(f) Pop

Figuur 5.13: Demonstratie van een buffergeheugen met tellers.

Implementatie met RAM-geheugens Analoog kunnen we ook een buffergeheugen implementeren metbehulp van een RAM-geheugen en een lees- en schrijfteller. De schrijfteller houdt de positie bij van hetuiteinde van de rij, waar we elementen zullen bijschrijven. De leesteller houdt de positie van het andereuiteinde bij, waar we elementen zullen uitlezen. We gebruiken het RAM-geheugen op een manier waarbijwe de elementen niet dienen te verplaatsen. Dit kunnen we doen door zowel de lees als de schrijftelleraanvankelijk op 0 te zetten. Indien we een schrijf-operatie dienen uit te voeren, schrijven we het elementenop het adres gespecificeerd door de schrijfteller, en incrementeren we deze teller. Bij een lees-operatie lezenwe de locatie van het geheugen uit en incrementeren we de leesteller. Indien een van de tellers aan heteinde van het geheugen komt, voeren we eenvoudigweg een wrap-around uit, en schrijven we dus opnieuwop het begin van het geheugen. Een probleem stelt zich op het moment dat de lees- en schrijftellers beidedezelfde waarde hebben. In dat geval zijn er immers twee situaties mogelijk: ofwel zijn op dat moment

5.4. SYNTHESE VAN EEN NIET-PROGRAMMEERBARE PROCESSOR 167

alle geheugencellen bezet, ofwel is op dat moment het buffergeheugen leeg (zoals bijvoorbeeld bij de initieletoestand van de tellers). We verhelpen dit probleem opnieuw door bij een 2n × w-bit RAM geheugen, detellers uit te breiden naar n + 1-bit tellers. De hoogste bit wordt niet gebruikt om het adres voor hetRAM-geheugen aan te wijzen, we beschouwen voor adressering dus enkel de laagste n bits. Indien deze nlaagste bits van de lees- en schrijfteller aan elkaar gelijk zijn, speelt zich opnieuw het scenario van vol ofleeg af. Indien daarenboven de hoogste bits aan elkaar gelijk zijn, is de queue leeg, indien ze niet gelijkzijn is het buffergeheugen vol. Het conceptueel principe van deze tellers staat op figuur 5.13. Op figuur5.14 implementeren we een schakeling die een buffergeheugen realiseert. Vermits de tellers in een richtingtellen, makken we gebruik van uptellers. Indien de enable-inang hoog is, zal afhankelijk van het signaal aande read/write∗-ingang een van de tellers een increment uitvoeren. Verder bepaalt deze ingang ook, welketeller de multiplexer naar het RAM-geheugen doorstuurt. De multiplexer stuurt wel enkel de laagste n bitsdoor. De enable ingang zal verder ook het RAM-geheugen activeren. Indien de reset-ingang geactiveerd is,zullen beide tellers terug de initiele waarde 0 krijgen. Tot slot implementeren we de indicators zoals eerderbesproken: een buffergeheugen is leeg indien alle n+1 bits van de twee tellers gelijk zijn. Een buffergeheugenis vol indien op de hoogste bits na de tellers gelijk zijn.

CEin

Clk

CLR

n+ 1-bitschrijfteller

0

1

CEin

Clk

CLR

n+ 1-bitleesteller n

D

A

CS

R/W∗

2n × w-bitRAM

n

Com

p

Full

Empty

n

n

n

n

n nReset∗

Enable

Read/Write∗

Data In/Outn

Figuur 5.14: Implementatie van een buffergeheugen met behulp van RAM-geheugen.

5.4 Synthese van een Niet-Programmeerbare Processor

Nu we een ASM-schema gedefinieerd hebben en nieuwe geheugencomponenten ter beschikkingen hebbenkunnen we eindelijk een processor implementeren. We vertrekken vanuit het ASM-schema, en zullen insubsectie 5.4.1 eerst een methode bespreken om op een mechanische manier een ASM-schema om te zettenin een processor. Deze methode leidt tot een straightforward resultaat, maar dit is verre van optimaal. Insubsecties 5.4.2, 5.4.3 en 5.4.4 zullen we dan ook optimalisaties bespreken om de processor goedkoper enefficienter te maken.

5.4.1 Basisprincipes

Principes

We kunnen door volgende principes toe te passen op het ASM-schema een processor bouwen:

1. Elke variabele is een register.


2. Voor elk register maakt de set-ingang deel uit van het instructiewoord.

3. Elke operatie komt overeen met een functionele eenheid (FU) die logischerwijs dezelfde opdracht uit-voert (indien er dus een optelling in het ASM-schema voorkomt, zullen we een opteller in het datapadplaatsen).

4. Indien een operatie de waarde van een variabele nodig heeft, maken we een verbinding van de uitgangvan het bijbehorende register naar de bijbehorende ingang van de functionele eenheid.

5. Indien het resultaat van een operatie wordt weggeschreven naar een variabele, bouwen we een verbin-ding van de uitgang van de bijbehorende functionele eenheid naar de data-ingang van het register.

6. Indien data-ingangen of constanten ingelezen kunnen worden bij een variabele, bouwen we een verbin-ding tussen de data-ingang/constante en het bijbehorende register, tenzij de constante 0 is.

7. Indien een variabele op 0 gezet kan worden, bevat het instructiewoord de reset-ingang van het bijbe-horende register.

8. Indien verschillende functionele eenheden waardes wegschrijven naar eenzelfde register, voorzien weeen multiplexer om de waarde te kiezen. De selectie-ingangen van deze multiplexers behoren tot hetinstructiewoord.

9. Elk ASM-blok komt overeen met een toestand van de controller.

10. Voor elke test waarbij een variabele betrokken is, dienen we een combinatorische module te bouwendie op basis van de waarde van de registers de test kan uitvoeren. De uitgang van deze test module iseen van het status-signalen, en bijgevolg een deel van de controller-ingangen.

11. De reset- en load-ingangen van de registers vormen samen met de selectie-ingangen de het instructie-woord: een deel van de uitgangen van de controller.

12. Data-uitgangen worden berekend aan de hand van een combinatorische schakeling met als invoer dewaarde van de relevante registers, en eventuele instructiewoord-bits.

Leidend voorbeeld

Datapad Op basis van het ASM-schema op figuur 5.3 op pagina 156 kunnen we een processor bouwen. Hetresultaat van van deze omzetting staat op figuur 5.15. In het ASM-schema is er sprake van vier variabelen:X, Y , Z en I. Daarom introduceren we vier registers. Uit het ASM-schema kunnen we afleiden danzowel Y als Z op 0 gezet kunnen worden. Daarom voorzien we op basis van de register reeds 6 instructie-bits: de set-ingangen van de X en I-registers en de set- en reset-ingangen van de Y en Z registers. Voorelk van de registers voorzien we vervolgens een lijn (deze tekenen we onder de registers). We kunnen nude functionele eenheden introduceren. Alle operaties uit het ASM-schema gebeuren in toestand S2. Intotaal zijn er 6 functionele eenheden: een shift voor zowel X als Y samen met de speciale recombinatiesen decrement. We maken geen verschil of de instructies al dan niet voorwaardelijk zijn. Elk van dezefunctionele eenheden plaatsen we onder de lijnen van de registers. Vervolgens tekenen we verbindingenvanuit de registers en eventuele data-ingangen naar de functionele eenheden. Zo tekenen we een signaalvanuit I naar de decrementor, X en Y naar een shift-operator, en andere registers naar hun specifiekerecombinaties. Verder tekenen we ook de testen: I > 0 en z2z1z0x3 < D. Ook deze testen verbindenwe met de respectievelijk registers en data-ingangen. Elk van deze testen vormen een deel van het status-signaal. We duiden deze bits aan met onderlijnde grote letters. Vervolgens dienen we de uitgang van defunctionele eenheden samen met data-ingangen te verbinden met de ingang van de registers. Zo zien we inhet ASM-schema dat de variable X vanuit twee bronnen waardes kan krijgen: vanuit de data-ingang N envanuit een schuifregister X shl 1. Bijgevolg voorzien we een multiplexer die zowel de data-ingang N als deuitgang van een schuifoperator combineert. De selectie- ingang van deze multiplexer maakt deel uit van hetinstructiewoord. Bits van het instructiewoord duiden we aan met onderlijnde kleine letters10. Y kan worden

10De voorstelling van bits van het toestanden instructiewoord zijn louter arbitrair, andere notaties zijn eveneens toegelaten.


gezet op drie soorten waardes: de waarde 0, het resultaat van een andere schuifoperator en de waarde na derecombinatiestap. Vermits we 0 kunnen activeren door een hoog signaal op de reset-ingang van het registeraan te leggen, zullen we 0 niet toevoegen aan de multiplexer, en combineert de multiplexer alleen de uitvoervan de schuifoperator met deze van recombinatie-functionele eenheid. Op een gelijkaardige manier realiserenwe de rest van de multiplexers. Tot slot dienen we nog combinatorische logica voor de data-uitgangen tebouwen. In dit geval is het simpel: de notitie bij het ASM-schema stelt dat de data-uitgangen Q en R louterde waardes van Y en Z naar buiten brengen. We specificeren dus deze uitgangen en verbinden de bussenvan de registers met deze data-uitgangen. We hebben nu het volledige datapad gerealiseerd zoals op figuur5.15.

RXa

b 01

RYc

d

e 01

RZf

g

h 01

RIi

j 01

shl 1 shl 1 y2y1y01 z2z1z0x3z2z1z0x3

−D −1z2z1z0x3

< D

A

I > 0

B

N 3D

Q R

Figuur 5.15: Implementatie van het datapad van het leidend voorbeeld via de basisprincipes.

Controller Naast het datapad moeten we ook de controller realiseren. De controller bouwen we op basisvan het ASM-schema. Elke toestand van het ASM-schema komt overeen met een toestand van de controller.De invoer van de controller bestaat enerzijds uit controle-ingangen en anderzijds status-signalen. Voor hetvoorbeeld van de deler betekent dit dus:

ci het signaal van de controle-ingang dat aangeeft dat de data-ingangen gereed zijn voor verwerking.

A het resultaat van de test z2z1z0x3 < D

B het resultaat van de test I > 0

Daarnaast dient de controller zowel een instructiewoord naar

co het signaal van de controle-uitgang dat aangeeft dat het algoritme was uitgevoerd en de resultaten opde data-uitgangen staat.

a indien hoog wordt de waarde van de variabele X gezet op de waarde van de multiplexer.

b indien hoog wordt de waarde N doorgegeven aan het register X, anders wordt X shl 1 doorgegeven.

c indien hoog wordt de waarde van de variabele Y gezet op de waarde van de multiplexer.

d indien hoog wordt de waarde van de variabele Y gezet op 0.


e indien hoog wordt de waarde Y shl 1 doorgegeven aan het register Y , anders wordt y2y1y01 doorge-geven.

f indien hoog wordt de waarde van de variabele Z gezet op de waarde van de multiplexer.

g indien hoog wordt de waarde van de variabele Z gezet op 0.

h indien hoog wordt de waarde z2z1z0x3 doorgegeven aan het register Z, anders wordt z2z1z0x3 −D.

i indien hoog wordt de waarde van de variabele I gezet op de waarde van de multiplexer.

j indien hoog wordt de waarde 3 doorgegeven aan het register I, anders wordt I − 1 doorgegeven.

Op basis van deze beschrijving kunnen we een toestandstabel bouwen die de volledige controller beschrijftzoals in tabel 5.4 of figuur 5.16. Deze tabel genereren we opnieuw op basis van het ASM-schema. Het

ToestandIngang Uitgang

Volgende toestandci A B co a b c d e f g h i j

S10 - - 0 1 1 0 1 - 0 1 - 1 1 S1

1 - - 0 1 1 0 1 - 0 1 - 1 1 S2

S2

- 0 0 0 1 0 1 0 0 1 0 0 1 0 S3

- 0 1 0 1 0 1 0 0 1 0 0 1 0 S2

- 1 0 0 1 0 1 0 1 1 0 1 1 0 S3

- 1 1 0 1 0 1 0 1 1 0 1 1 0 S2

S30 - - 1 0 - 0 0 - 0 0 - 0 - S1

1 - - 1 0 - 0 0 - 0 0 - 0 - S3

Tabel 5.4: Toestandstabel van de controller van het leidend voorbeeld via de basisprincipes.

S1 S2 S3

1--/01101-01-11

0--/01101-01-11

-00/01010010010

-10/01010110110-01/01010010010

-11/01010110110

0--/10-00-00-0-

1--/10-00-00-0-

Figuur 5.16: Toestandsdiagram van de controller van het leidend voorbeeld via de basisprincipes.

instructiewoord – een sequentie aan bits die bepaalt welke instructies op het datapad worden uitgevoerd – isafhankelijk van zowel de toestand als de controller-ingang en statussignalen. Bij wijze van voorbeeld zullen wede controller-tabel van het leidend voorbeeld opbouwen. Bij toestand S1 zijn alle opdrachten onafhankelijkvan testen. Bijgevolg zal het instructiewoord ook onafhankelijk zijn van de invoer. Dit instructiewoordkunnen we bouwen aan de hand van de instructies bij toestand 1. Zo is de controller-uitgang co = 0,logischerwijs is dit ook het geval de uitvoer. Daarnaast bevat de toestand de instructie X ← N . Bijgevolgzetten we het set-signaal van hetX-register hoog, samen met het selectie-signaal van de multiplexer, waardoordeze N doorgeeft. Dit resulteert in (a, b) = (1, 1). Daarnaast worden Y en Z op 0 gezet. Dit betekent datwe het set-signaal op laag zetten van beide registers en het reset-signaal op hoog. Vermits de waarde vande multiplexers niet wordt ingelezen, maakt het niet uit welke waarde de multiplexer doorgeeft. Daarom ishet volgende deel van het instructiewoord (c, d, e, f, g, h) = (0, 1,−, 0, 1,−). De instructie I ← N bepaalttot slot de rest van het instructiewoord. Het complete instructiewoord wordt dan:

S1 : (co, a, b, c, d, e, f, g, h, i, j) = (0, 1, 1, 0, 1,−, 0, 1,−, 1, 1) (5.2)


Ondanks het feit dat alle instructies onafhankelijk van testen worden uitgevoerd, is de volgende toestandwel afhankelijk van de ci-controller-ingang. Bijgevolg plaatsen we twee regels in de toestandstabel: indienci = 0 is de volgende toestand opnieuw S1, in het andere geval is de volgende toestand S2. In het gevalvan toestand S2 zijn sommige instructies wel afhankelijk van de resultaten van enkele testen. Er zijn echterwel enkele instructies die onafhankelijk van testen worden uitgevoerd. Op analoge wijze bekomen we voordeze instructiebits: (co, a, b, i, j) = (0, 1, 0, 1, 0). De andere instructies zijn afhankelijk van de test die wegespecificeerd hebben als de status-bit A ofwel z2z1z0x3 < D. In het geval deze test slaagt zijn de rest vande instructie-bits (c, d, e, f, g, h) = (1, 0, 0, 1, 0, 0). In het andere geval is (c, d, e, f, g, h) = (1, 0, 1, 1, 0, 1). Ditkunnen we formaliseren als:

S2 : (co, a, b, c, d, e, f, g, h, i, j) =

(0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0) if A(0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0) otherwise

(5.3)

Opnieuw wordt de volgende toestand gedifferentieerd op basis van een test: B. Indien B waar is, is I > 0bijgevolg is de volgende toestand S2, in het geval de test faalt, is de volgende toestand S3. Tot slot beschouwenwe de laatste toestand S3: hierbij worden er geen instructies uitgevoerd. Bijgevolg staan alle set- en reset-signalen van de registers op 0. Opnieuw is ook de selectie-ingang van de multiplexers irrelevant: de inhoudwordt immers niet opgeslagen in de registers. Tot slot is de controller-uitgang co = 1. Bijgevolg is devolledige uitvoer:

S3 : (co, a, b, c, d, e, f, g, h, i, j) = (1, 0,−, 0, 0,−, 0, 0,−, 0,−) (5.4)

Ook hier bepaalt de controller-ingang ci de volgende toestand. Bijgevolg differentieren we de volgende toe-stand opnieuw op basis van deze test. Op basis van deze paragraaf kunnen we dus de controller toestandstabelop tabel 5.4 opstellen. Voor de concrete implementatie van de controller met behulp van flipflops verwij-zen we naar het vorige hoofdstuk. Eenmaal de controller en het datapad gebouwd zijn, dienen we beidecomponenten alleen nog met elkaar te verbinden: de instructie-uitgangen van de controller worden gelinktmet de set- en reset-signalen van de registers en de selectie-ingangen van de multiplexers. De testen die ophet datapad worden uitgevoerd vormen dan weer de invoer van de controller. Merk verder ook op dat wehier een input-gebaseerd ASM-schema hebben verwezenlijkt. Een toestandsgebaseerd ASM-schema wordtop compleet analoge wijze gesynthetiseerd, alleen zal het instructiewoord niet afhangen van eventuele testen.Opdelingen zoals bij toestand S2 komen dus niet voor.

Betere implementatie

Zoals reeds eerder vermeld leidt de procedure die we in deze subsectie hebben ontwikkeld hebben niet toteen optimale oplossing. Er zijn verschillende problemen die afhankelijk van het algoritme tot een inefficienteimplementatie leiden:

• In deze implementatie zullen we voor elke operatie een aparte functionele eenheid voorzien. Merkechter op dat indien we in eender welke toestand slechts een optelling uitvoeren we dezelfde optellerzouden kunnen gebruiken.

• Nogal wat functionele eenheden hebben gelijkaardige kenmerken. Zo valt Y shl 1 te combineren mety2y1y01. Functionele eenheden te combineren leidt tot een complexere schakeling maar minder redun-dante delen.

• In sommige algoritmen wordt slechts een subset van de register tegelijk gebruikt. In dat geval kunnenwe een registerbank gebruiken en enkel de adressen uitlezen die bij een bepaalde toestand relevant zijn.

• We dienen niet steeds per register een bus te voorzien. Indien bij elke toestand een deel van de registerbelangrijk zijn, kunnen we op een beperkt aantal bussen de waardes van de relevante registers plaatsen.

• Soms kunnen we het ASM-schema verder optimaliseren. Dit sluit enigzinds aan bij de discussie overhet aantal toestanden die we gebruikten voor de vertaling van het algoritme naar een ASM-schema.

• Logischerwijs kunnen we de toestandstabel van de controller eerst minimaliseren alvorens deze teimplementeren.

In de volgende subsecties zullen we een groot deel van deze problemen bespreken en toepassen op het leidendvoorbeeld.


5.4.2 Ontwerp Controller

Patronen in een algoritme

Het ontwerp van een controller is in wezen equivalent met de implementatie van een Finite State Machine(FSM). De controller in het leidende voorbeeld is dan ook vrij eenvoudig te implementeren met behulp vande methodes uit Hoofdstuk 4. Bij complexe programma’s is een implementatie van een controller echter nietmeer zo triviaal: deze kennen een groot aantal toestanden en tests, en doorgaans een groot instructiewoord.Daarom werd al snel naar een methode gezocht om snel complexe controllers te bouwen. Dit doen we doorvolgende patronen in een ontwerp (ASM-schema) te zoeken:

• Natuurlijke volgorde van toestanden.

• Terugkerende sets van toestanden veroorzaakt door een subroutine.

• Eenvoud van het implementeren van logica met behulp van one-hot coderingen.

Elk van deze elementen wordt in de volgende subsubsecties verder uitgewerkt. Op basis van deze drie ele-menten zullen we een component bouwen die een algemene controller vertegenwoordigt: de microprogram-meerbare controller. Een component die we in een schakeling inpluggen en die we gegeven een ASM-schemavervolgens kunnen programmeren en daardoor omvormen tot een concrete controller.

Algemene vorm van een controller

SReg

NextStateLogic

OutputLogic

Controle-Signalen(CS)

Status-Signalen(SS)

Controle-Ingangen(CI)

Controle-Uitgangen(CO)

Figuur 5.17: Algemene vorm van een controller.

Allereerst grijpen we terug naar de definitie van een controller en combineren we deze met de defintievan een sequentiele schakeling. In subsectie 5.1.1 hebben we reeds de invoer en uitvoer van een controllerbesproken. We zien dezelfde structuur op figuur 5.17. Daarnaast weten we uit Hoofdstuk 4 hoe de algemenesequentiele structuur eruit ziet:

• State Register ofwel toestandsregister: een register die de huidige toestand bijhoudt.

• Next State Logic: combinatorische logica die de volgende toestand berekent.


• Output Logic ofwel uitvoer logica: een component die het instructiewoord ofwel de controle-signalenberekend, samen met de controle-uitgangen.

Beide combinatorische componenten zijn afhankelijk van zowel de controle-ingangen en de huidige toestandbijgehouden door het toestandregister. Daarnaast zullen de statussignalen (de resultaten van de testen inhet datapad) de volgende toestand mee helpen bepalen. In het geval van een inputgebaseerd ASM-schemais dit zelfs het geval voor de uitvoer logica. We kunnen dus stellen dat figuur 5.17 de algemene structuurvan de controller weergeeft. We zullen dit ontwerp in de volgende subsubsecties aanpassen tot een structuurdie gericht is op specifieke eigenschappen van een controller.

Natuurlijke volgorde van toestanden

SReg+1

NextStateLogic

OutputLogic


Status-Signalen(SS)



Figuur 5.18: Controller met natuurlijke volgorde van toestanden.

Men kan de toestand van een controller enigzinds vergelijken met een programmateller. In de meeste ge-vallen zal een programma dan ook bestaan uit een reeks toestanden waarbij de volgende toestand vaststaat.Omdat het zoeken van een minimale encodering voor grote toestandstabellen tijdrovend is, zullen we dezeoptie niet beschouwen. Een logisch gevolg hiervan is dat we de opeenvolgende toestanden opeenvolgende toe-standscoderingen geven, in plaats van deze volgende toestandscoderingen voor elke toestand uit te rekenen.We kunnen dit probleem eenvoudig oplossen door een incrementor en een multiplexer te voorzien. Een deelvan de volgende toestandlogica bestaat er dan uit om te bepalen of we de toestandcodering incrementeren,in het ander geval dient de volgende toestand logica zelf een adres te berekenen. In veel gevallen leidt dittot een vereenvoudiging van de uitvoer logica: er zijn immers heel wat toestanden die deze increment functiekunnen gebruiken, indien dit het geval is kunnen we bovendien don’t cares invoeren bij de logica die devolgende encodering berekent. De volgende toestandlogica dient dan ook enkel conditionele volgende toe-standen genereren. Figuur 5.18. Een oplettende lezer zal misschien reeds opgemerkt hebben dat een registergecombineerd met increment neerkomt op een teller. Vermits we met behulp van de multiplexer kunnenkiezen om het register met 1 op te hogen, ofwel een nieuwe waarde in te laden, hebben we hier een laadbareteller gerealiseerd. Op figuur 5.18 hebben we de componten die leiden tot deze laadbare teller gemarkeerdmet behulp van een lichtgrijze rechthoek.


SReg

+1

LIFO

NextStateLogic

OutputLogic


Status-Signalen(SS)



Push

/P

op∗

Figuur 5.19: Controller met natuurlijke volgorde van toestanden en subroutines.

Ondersteunen van subroutines

Bij het bouwen van een programma wordt vaak gebruik gemaakt van een subroutine: een klein programmadat we oproepen om een bepaalde opdracht uit te voeren en nadien terugkeert naar de toestand die volgt opde toestand waar we de subroutine hebben opgeroepen. Een probleem bestaat erin dat we niet eenvoudigwegde subroutine kunnen omzetten naar een reeks toestanden en vervolgens naar de eerste toestand van dezesubroutine kunnen springen. In dat geval weet de subroutine immers niet meer naar welke toestand men dientterug te springen (deze toestand wordt de terugkeertoestand genoemd) nadat de subroutine is uitgevoerd.Een oplossing zou erin kunnen bestaan om in dat geval per oproep van een subroutine de subroutine tekopieren in de structuur. Deze oplossing heeft echter enkele nadelen:

• Iedere keer wanneer we een subroutine oproepen dienen we een kopie te maken van alle toestanden.Indien de subroutine Ts verschillende toestanden heeft en we roepen de routine n keer op, resulteertdit in een controller waarvan n · Ts toestanden door de subroutine zijn gegenereerd. Dit leidt dus toteen groot aantal toestanden en complexe logica voor het berekenen van de volgende toestand en deuitvoer.

• In sommige programma’s roept een subroutine zichzelf op. Dit fenomeen wordt recursie genoemd. Wekunnen dit fenomeen niet rechtstreeks omzetten in de aangereikte oplossing, omdat we niet altijd voorafweten hoe diep deze recursie gaat. In dat geval zullen we de subroutine eerst moeten herschrijven ineen subroutine zonder recursie.

De oplossing bestaat dan ook uit een datastructuur genaamd de call stack die – zoals de naam reeds doetvermoeden – een vorm van stapelgeheugen is. De oplossing bestaat eruit bij elke oproep naar het stapel-geheugen de terugkeertoestand op de call stack te zetten. Op het moment dat de subroutine is afgelopen,wordt de terugkeertoestand terug uit het stapelgeheugen uitgelezen en in het toestandsregister geplaatst. Decallstack ondersteunt ook recursie omdat indien een subroutine zichzelf oproept, ook de terugkeertoestandvan deze subroutine op de stapel wordt gezet. Indien we deze wijziging combineren met wat we al hebbenbekomen we een structuur met een incrementor, een stapelgeheugen en een multiplexer zoals op figuur 5.19.De volgende toestand logica heeft dan vier verschillende types instructies:


• Natuurlijke volgende toestand: het toestandregister wordt met 1 opgehoogd. Dit gebeurt bij toestandenwaarbij de volgende toestand vast staat (onafhankelijk van testen).

• Specifieke volgende toestand: indien de volgende toestand wel afhankelijk is van testen, of we springennaar een bepaalde toestand in een programma kan de volgende toestand logica zelf een toestandberekenen.

• Uitvoeren van een subroutine: in dat geval wordt de natuurlijke volgende toestand van de huidige toe-stand op de call stack geplaatst, en lezen we de begintoestand van de subroutine in het toestandsregisterin.

• Terugkeren uit een subroutine: dit is de laatste instructie bij een subroutine. We voeren een pop-operatie uit op de call stack en de terugkeertoestand wordt in het toestandsregister ingelezen. Wemaken dus de veronderstelling dat we terugspringen naar de volgende natuurlijke toestand van deprocedure die we hebben opgeroepen11.

We realiseren deze schakeling door naast de incrementor, ook een een stapelgeheugen te plaatsen. De volgendetoestandslogica heeft controle over de multiplexer (die kan kiezen uit het stapelgeheugen, de incrementor ofeen toestandencodering die hij zelf heeft gegenereerd) samen met de push/pop∗-ingang van het stapelgeheu-gen. Verder kan de volgende toestand logica ook zelf een toestandcodering genereren door deze aan een vande data-ingangen van de multiplexer aan te leggen.

Werken met “One-Hot” coderingen

In het vorige hoofdstuk hebben we het reeds uitgebreid gehad over de one-hot codering. Een one-hotcoderingkan de volgende toestand logica drastisch vereenvoudigen. Een probleem is echter dat we bij een one-hotcodering het aantal flipflops opdrijven. Een tussenoplossing zou er echter uit kunnen bestaan om een decodertussen het toestandsregister en de volgende toestand logica te zetten. Merk op dat we verder ook de uitvoer-logica op een gelijkaardige manier kunnen vereenvoudigen. Figuur 5.20 toont een algemene controller waarbij

SReg

+1

LIFODecoder

NextStateLogic

OutputLogic


Status-Signalen(SS)



Push

/Pop∗

Figuur 5.20: Controller met one-hotcodering.

11We kunnen echter de component aanpassen dat we ook zelf een terugkeertoestand kunnen invoeren. Anderzijds kunnen we,indien dit nodig is, van de terugkeertoestand ook een lege toestand maken en de volgende toestandlogica dan naar het juisteadres laten springen.


we een decoder tussen het toestandsregister en de volgende toestanden uitvoer-logica’s plaatsen.

Programmeerbare controller

In plaats van specifieke logica te voorzien voor de volgende toestand logica en de uitvoer logica, kunnen wedeze componenten ook vervangen door een meer algemene structuur: een vorm van look-up tables. Indienwe deze look-up table vervolgens combineren met de decoder bekomen we een geheugen (deze componentenstaan gemarkeerd op figuur 5.20). Welk geheugen we gebruiken is in principe arbitrair. Indien we eenROM-geheugen gebruiken kunnen we de controller eenmaal programmeren naar een specifieke controller.Een andere mogelijkheid is om een RAM-geheugen te gebruiken waarbij we de specifieke controller telkensinladen bij het opstarten van het elektronisch circuit. Een voordeel van het gebruik van een RAM-geheugen isdat we bijgevolg het algoritme kunnen wijzigen, op voorwaarde dat alle benodigde hardware op het datapadaanwezig is. Daarentegen betalen we een prijs dat bij het opstarten van de component we eerst de controllermoeten inladen wat tijd vergt. Op figuur 5.21 tonen we een realisatie de microprogrammeerbare controller.

SReg

+1

LIFO ROM-geheugen


Status-Signalen(SS)



Figuur 5.21: Microprogrammeerbare controller.

Merk op dat we geen aparte geheugens voor de volgende toestand en de uitvoer voorzien. We kunnenbeide componenten immers combineren tot een geheugen component. Het ROM-geheugen dient dan ookverschillende rijen van bits op te slaan:

• Push/Pop bits: wordt gebruikt bij het oproepen of verlaten van een subroutine, ofwel blijft het stapel-geheugen ongewijzigd.

• Multiplexer bits: bepalen welke van de drie bronnen van toestandscoderingen we gebruiken: natuurlijkeopvolging, eigen adressering of stapelgeheugen.

• Toestandsencodering: in het geval men naar een speciale toestand wil gaan (geen natuurlijke opvolging).

• Controle-uitgang: bits die de toestand van een algoritme buiten de processor brengen.

• Controle-signalen ofwel het instructiewoord: bepaalt welke opdrachten het datapad zal uitvoeren.

5.4.3 Minimaliseren Datapad

Naast het introduceren van een algemene controller zullen we enkele verbeteringen bij een datapad bespreken.Hiervoor zullen we vier technieken bespreken:

• Het samenvoegen van variabelen.


• Het samenvoegen van bewerkingen.

• Het samenvoegen van verbindingen ofwel “bus sharing”.

• Het samenvoegen van registers in een registerbank.

Alvorens we al deze optimalisaties bespreken zullen we eerst een ander leidend voorbeeld introduceren. Wezullen telkens een van de leidende voorbeelden gebruiken op de plaatsen waar dit relevant is.

Leidend voorbeeld: vierkantswortel benadering

Een tweede leidende voorbeeld is het benaderen van een vierkantswortel. Veel programma’s berekenen vaakde vierkantswortel van de som van twee kwadraten (bijvoorbeeld bij het berekenen van een afstand tussentwee punten). Voor de meeste programma’s is het echter niet belangrijk dat deze vierkantswortel met eenhoge nauwkeurigheid berekend wordt. Daarom maakt men meestal gebruik van een volgende benadering:√

x2 + y2 ≈ max (max (|x| , |y|) , 0.875 ·max (|x| , |y|) + 0.5 ·min (|x| , |y|)) (5.5)

Figuur 5.22 toont een ASM-schema die deze vierkantswortel kan uitrekenen. Bemerk dat we ook een controle-ingang start voorzien, die op hoog dient gezet te worden alvorens het algoritme wordt uitgevoerd, en eencontrole-uitgang ready die aangeeft dat het resultaat berekend is. Daarnaast zijn er twee data-ingangen Aen B. Daarnaast voorzien we ook een data-uitgang R die het berekende resultaat naar buiten brengt. Indien

S0

S1

S2 S3

S4

S5

S6

S7

t1 ← At2 ← B

start[False][True]

t3 ← |t1|t4 ← |t2|

t5 ← max (t3, t4)t6 ← min (t3, t4)

t7 ← t5 shr 3t8 ← t6 shr 1

t9 ← t5 − t7

t10 ← t8 + t9

t11 ← max (t5, t10)

ready=1R = t11

Figuur 5.22: ASM-schema van het vierkantswortel-benaderingsalgoritme.

we dit ASM-schema op de eerder genoemde wijze zouden implementeren zouden we volgende componentennodig hebben:

• 11 registers (van een arbitrair aantal bits).

• 2 absolute waarde functionele eenheden.

• 2 maximum functionele eenheden.

• 1 minimum functionele eenheid.

• 1 opteller functionele eenheden.

• 1 aftrekker functionele eenheid.


• 1 shift 3 posities naar rechts functionele eenheid.

• 1 shift 1 positie naar rechts functionele eenheid.

Het is duidelijk dat dit ASM-schema een grote kost met zich teweeg brengt. We zullen in de volgendesubsubsecties dan ook de implementatie significant verbeteren.

R t1aR t2b

R t3cR t4d

R t5eR t6f

R t7gR t8h

R t9iRt10j

Rt11k

abs abs max min shr 3 shr 1 − + max

Figuur 5.23: Implementatie van het datapad van de benaderende vierkantswortel volgens de basisprincipes.

Kostprijsberekening

Alvorens we een goedkopere realisatie van de processor in kwestie kunnen bekomen, dienen we eerst te wetenhoeveel elk component precies kost. Hiervoor kunnen we de implementatie van bijvoorbeeld een multiplexerin een van de vorige hoofdstukken herbekijken, en de prijs uitrekenen. We zullen in deze subsubsectie echtereen bondig overzicht geven die de kostprijs van de belangrijkste componenten die we zullen tegenkomensamenvat. Per component zullen we de kostprijs zowel in transistoren als in het aantal logische cellen in eenFPGA weergeven. Verder zullen we ook telkens de componenten in functie van 1 bit uitdrukken, bijvoorbeeldeen 1 bit register. Het vermenigvuldigen met het aantal bits geeft een ruwe schatting maar ervaring uit vorigehoofdstukken zou moeten leren dat we soms ook heel wat transistoren kunnen uitsparen omdat we sommigedeelcircuits kunnen hergebruiken.

Variabelen samenvoegen

Een belangrijke verbetering is het reduceren van het aantal variabelen en dus het aantal registers. We merkenimmers op in figuur 5.22 dat de meeste variabelen slechts eenmaal op een waarde gezet worden, en daarna –meestal in de volgende toestand – uitgelezen worden. Vanaf dat moment worden deze variabelen niet meergebruikt, bijgevolg levert het niets op om hun waarde effectief bij te houden. We kunnen de registers die eerst


3-state buffer multiplexer register

# Transistoren 10 12 18 24 30 44# Logische cellen 0 1 2 2 3 1

Half Adder Full Adder Aftrekker Opteller/Aftrekker

# Transistoren 18 36 38 48# Logische cellen 2 2 2 2

Tabel 5.5: Samenvatting van de kostprijs van de belangrijkste componenten

de waarde van de ene variabele bijhielden echter hergebruiken om de waarde van een andere variabele bij tehouden. Hiervoor maken we gebruik van een levensduurtabel. Een levensduurtabel is een tabel waarin devariabelen horizontaal worden voorgesteld, en de toestanden verticaal. We markeren een gegeven cel indienwe in de gegeven of een latere toestand de waarde van de variabele uitlezen nadat de waarde is toegewezen.Zo zien we bijvoorbeeld op het ASM-schema (figuur 5.22), dat de variabele t5 toegewezen wordt in toestandS2 en we de waarde uitlezen in toestanden S3, S4 en S6. Dit betekent dus dat de levensduur van t5 zichuitstrekt van S3 tot en met S6. Men kan zich misschien afvragen waarom de toestand waarin we de waardetoewijzen niet ook deel uitmaakt van de levensduur. De reden is omdat op dat moment we nog geen registerhebben waarin we de variabele opslaan. Let wel: er dient een register te bestaan waarin we plannen dewaarde te zullen opslaan. In toestand S2 wordt echter enkel de waarde van t5 berekent en aangelegd opeen van de registers. Het register heeft echter de waarde nog niet opgeslagen. Dit doet het bij de klokflanktussen S2 en S3. We stellen de levensduur tabel op door voor elke variabele uit te rekenen wanneer welkevariabelen actief zijn. De levensduurtabel van het leidend voorbeeld staat in tabel 5.6. Onder de rij vanvariabelen vermelden we telkens het totaal aantal variabelen die in de gegeven toestand actief zijn.

S0 S1 S2 S3 S4 S5 S6 S7

t1 •t2 •t3 •t4 •t5 • • • •t6 •t7 •t8 • •t9 •t10 •t11 · •# 1 2 2 2 3 3 2 0

Tabel 5.6: Levensduurtabel van het vierkantswortel voorbeeld.

Formeel algoritme We hebben tabel 5.6 opgesteld door te redeneren over de levensduurte van een be-paalde variabele. We kunnen de levensduur echter ook berekenen met een formeel algoritme. Dit algo-ritme is geen leerstof die behoort tot het opleidingsonderdeel “Digitale Elektronica en Processoren”, maaris desalniettemin ook nuttig voor andere opleidingsonderdelen zoals bijvoorbeeld “compilerconstructies”, Incompilerconstructies wordt het genereren van een dergelijke tabel ook wel de “liveness analyse genoemd”. In[?] wordt zo’n algoritme aangereikt. In het algoritme zal men eerst code opdelen in toestanden. Dit hoevenwe hier niet meer te doen: dit zijn immers de toestanden van het ASM-schema. Verder dient elke toestandook drie verzamelingen bij te houden:

• succ [n]: dit is een verzameling toestanden die op toestand n kan volgen. Voor een ASM-blok zonderbeslissingskader bestaat de toestand uit juist een toestand. Voor ASM blokken met beslissingskaders


uit een of meerdere toestanden.

• use [n]: dit is een verzameling van variabelen die in toestand n gebruikt worden om berekeningen uitte voeren. Voor toestand S5 is dit dus: use [S5] = t8, t9

• def [n]: dit is de verzameling van alle variabelen die in een toestand n gedefinieerd worden. Indien weniet weten of een variabele in een bepaalde toestand zal gedefinieerd worden

We dienen vervolgens de volgende twee sets te berekenen per toestand:

• in [n]: een variabele zit in in [n] voor een toestand n wanneer er een uitvoer-pad bestaat waarbij devariabele levend is bij het binnenkomen van die toestand.

• out [n]: een variabele zit in out [n] voor een toestand n wanneer er een uitvoer-pad bestaat waarbij devariabele levend is bij het verlaten van die toestand.

Het algoritme die deze sets kan berekenen staat in Algoritme 4. Het algoritme werkt op basis van least-

Algorithm 4 Berekenen van liveness.

1: function Liveness(succ [n],use [n],def [n])2: for all n do3: in [n]← ∅4: out [n]← ∅5: end for6: repeat7: for all n do8: in’ [n]← in [n]9: out’ [n]← out [n]

10: in [n]← use [n] ∪ (out [n] \ def [n])11: out [n]← ∪s∈succ[n]in [s]12: end for13: until ∀n : in’ [n] = in [n] ∧ out’ [n] = out [n]14: return (in [n] , out [n])15: end function

fixed-point theorie. Hierbij berekenen we de sets door ze te initialiseren als lege sets. En vervolgens dezetelkens te updaten. Wanneer we een iteratie bereiken waarbij geen enkele set aangepast wordt, weten wedat dit in de volgende iteratie ook niet zal gebeuren. Bijgevolg kunnen we stoppen. In tabel 5.7 staan desucc [n], use [n] en def [n] tabellen samen met de nodige iteraties om de in [n] en out [n] set uit te rekenen.We kunnen opmerken dat de in [n] set dus overeenkomt met de levensduurtabel (zie tabel 5.6).

n succ [n] use [n] def [n] in0 [n] out0 [n] in1 [n] out1 [n] in2 [n] out2 [n]

S0 S0, S1 ∅ t1, t2 ∅ t1, t2 ∅ t1, t2 ∅ t1, t2S1 S2 t1, t2 t3, t4 t1, t2 t3, t4 t1, t2 t3, t4 t1, t2 t3, t4S2 S3 t3, t4 t5, t6 t3, t4 t5, t6 t3, t4 t5, t6 t3, t4 t5, t6S3 S4 t5, t6 t7, t8 t5, t6 t5, t7 t5, t6 t5, t7, t8 t5, t6 t5, t7, t8S4 S5 t5, t7 t9 t5, t7 t8, t9 t5, t7, t8 t5, t8, t9 t5, t7, t8 t5, t8, t9S5 S6 t8, t9 t10 t8, t9 t5, t10 t5, t8, t9 t5, t10 t5, t8, t9 t5, t10S6 S7 t5, t10 t11 t5, t10 t11 t5, t10 t11 t5, t10 t11S7 S0 t11 ∅ t11 ∅ t11 ∅ t11 ∅

Tabel 5.7: De evolutie van de in [n]- en out [n]-set op basis van het leidend voorbeeld (zie figuur 5.22)


Nut Men kan zich terecht afvragen wat het nut is van het opstellen van zo’n tabel. Wanneer welkevariabele actief is, is niet zo nuttig. Het interessante aspect zit hem eerder in de onderste rij: het aantalactieve variabelen per toestand. Dit getal specificeert immers hoeveel registers we in die toestand eigenlijknodig hebben om de variabelen te bewaren. De overige variabelen dienen we immers niet meer op te slaan,ze worden verder nergens meer gebruikt. Vermits we in elke toestand slechts een aantal registers nodighebben, is het totaal aantal benodigde registers niets anders dan het maximum van de onderste rij over alletoestanden. In het geval van het leidend voorbeeld is dit dus:

Nreg. = max (1, 2, 2, 2, 3, 3, 2, 0) = 3 (leidend voorbeeld) (5.6)

We kunnen dus onze schakeling implementeren met drie registers op voorwaarde dat een register de waardevan verschillende variabelen op verschillende tijdstippen bijhoudt. Een eenvoudige methode is aan elk vandeze drie registers een lijst met variabelen associeren die dit register zal bijhouden. De enige voorwaardeis dat de variabelen in geen enkele toestand allebei actief zijn. Deze methode zal sowieso tot het minimaalaantal registers leiden, maar introduceert een nieuw probleem: we zullen multiplexers voor de ingang vandeze registers moeten plaatsen en bovendien lopen we een gelegenheid mis om multiplexers te eliminerendie de waarde van een register doorgeven aan een functionele eenheid. Daarom zullen we extra tabellenopstellen.

Functionele-eenhedentabel Een tweede tabel die we zullen opstellen is de functionele-eenhedentabel.Deze tabel bevat horizontaal de toestanden en verticaal de types functionele eenheden. In elke cel schrijvenwe in, hoeveel functionele eenheden van het specifieke type we in de specifieke toestand nodig hebben. Zo zienwe bijvoorbeeld op figuur 5.22 dat we in toestand S2 zowel een component nodig hebben die het minimumberekent als een component die het maximum berekent. In toestand S1 hebben we twee functionele eenhedennodig die elk de absolute waarde berekenen. Indien we dit voor alle toestanden doen, bekomen we tabel5.8. De enige potentiele moeilijkheid aan het opstellen van deze tabel is de definitie van “type functionele

S0 S1 S2 S3 S4 S5 S6 S7 #abs 2 2max 1 1 1min 1 2shr 2 2− 1 1+ 1 1# 0 2 2 2 1 1 1 0 9

Tabel 5.8: Functionele-eenhedentabel van het leidend voorbeeld (zie figuur 5.22)

eenheid”. Men kan zich afvragen of bijvoorbeeld een shift over 3 bits bijvoorbeeld tot hetzelfde type behoortals een shift over 1 bit. In geval van twijfel kan het geen kwaad om een onderscheid te maken (en dus eenrij in de tabel te voorzien voor shr1 en shr3). Als algemene definitie kunnen we stellen dat twee functioneleeenheden tot hetzelfde type behoren wanneer we hardware kunnen voorzien die beide operaties op dezelfdecomponent uitvoert. Indien we dus beslissen om de shift te implementeren met behulp van de verbindingen,is een shift over drie bits een ander operatie dan een shift over 1 bit. Wanneer we echter met een schuifregisterwerken, kunnen beide operaties op hetzelfde schuifregister worden uitgevoerd.

Verbindingentabel, Invoer- en uitvoertabellen Een andere tabel is de zogenaamde verbindingenta-bel. Deze tabel bevat horizontaal de variabelen, en verticaal de functionele eenheden (niet verwarren met“type functionele eenheid”). In een cel plaatsen we een “I” wanneer de variabele als invoer dient voor defunctionele eenheid, en “O” wanneer het resultaat van deze functionele eenheid wordt weggeschreven in devariabele. We gaan er hier altijd van uit dat we in de verschillende toestanden verschillende functioneleeenheden gebruiken. Hierdoor ligt het aantal functionele eenheden in deze tabel meestal hoger dan het uit-eindelijke aantal functionele eenheden in de implementatie. In deze cursus zullen we de functionele eenhedendan ook nummeren. Zo maken we in toestand S1 gebruik van twee functionele eenheden die de absolute


waarde berekenen: abs1 en abs2. Hierbij zorgen t1 en t2 respectievelijk voor de invoer bij abs1 en abs2.De resultaten worden weggeschreven naar respectievelijk t3 en t4. Daarom noteren we in de tabel bij cellen(t1, abs1) en (t2, abs2) een “I” en in cellen (t3, abs1) en (t4, abs2) een “O”. Indien we dit voor alle toestandendoen, bekomen we tabel 5.9. Als laatste stellen we ook een set invoeren uitvoertabellen op. Deze tabellen

t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11

abs1 I Oabs2 I Omax1 I I Omin I I Oshr 3 I Oshr 1 I O− I I O+ I I O

max2 I I O

Tabel 5.9: Verbindingentabel van het leidend voorbeeld (zie figuur 5.22)

worden gedeeltelijk afgeleid uit de verbindingentabel (in dit voorbeeld tabel 5.9). In deze tabel hebbenwe enkel een onderscheid gemaakt tussen invoer en uitvoer. Sommige functionele elementen hebben echterverschillende ingangen. Door variabelen toe te wijzen aan een specifieke ingang maken we de tabel dusconcreter. In sommige gevallen staat deze ingang vast. In toestand S4 trekken we bijvoorbeeld t7 van t5 af.Het spreekt voor zich dat we dus t5 verbinden met de eerste ingang en t7 met de tweede ingang. Bij sommigefunctionele eenheden kunnen we echter kiezen. In dat geval is de operatie die door de functionele eenheidwordt uitgevoerd “commutatief”. Formeler kunnen we stellen dat een functie f commutatief is indien:

f (~x) = f (σ~x) voor elke permutatie σ (5.7)

Concrete voorbeelden van zulke operaties zijn optellen, minimum en maximum. Sommige functionele eenhe-den hebben meer dan twee ingangen. Ook hier kan er commutativiteit spelen. Soms is de operatie volledigcommutatief en is dus elke permutatie geldig. In andere gevallen is er sprake van gedeeltelijke commuta-tiviteit en wordt slechts een subset van permutaties ondersteund. Het toewijzen van ingangen kunnen wenatuurlijk willekeurig doen. Toch loont het de moeite om dit op een intelligentere manier te doen. In hetleidend voorbeeld (zie figuur 5.22) zien we bijvoorbeeld dat we zowel in toestand S2 en S6 een maximumberekenen. De kans is relatief groot, dat we in de toekomst deze twee bewerkingen op dezelfde functioneleeenheid zullen uitvoeren. In toestand S2 berekenen we max (t3, t4), in toestand S6 max (t5, t10). Indien weechter in toestand S6, max (t5, t3) hadden willen uitrekenen, was het zinvol geweest om deze operatie aan tepassen naar max (t3, t5). Indien we dan later de twee functionele eenheden zouden samenvoegen, dienen wegeen multiplexer voor de eerste ingang te plaatsen. In het algemeen geldt meestal volgende regel:

Wijs dezelfde variabele zoveel mogelijk aan dezelfde ingangen en uitgangen toe.

Bij wijze van voorbeeld zullen we deze regel toepassen op het leidend voorbeeld. Hierbij zijn variabelen t1,t2,t6 triviaal: ze worden uitsluitend in functionele eenheden met maar een ingang gebruikt. Daarom kennenwe dus deze ingangen toe aan:

(〈t1, abs1〉 , 〈t2, abs2〉 , 〈t6, shr 1〉) 7→ (I1, I1, I1) (leidend voorbeeld) (5.8)

Vervolgens kunnen we t5 en t7 toewijzen: beide variabelen zijn immers betrokken in een aftrekking. In dezebewerking is t5 verplicht gebonden aan ingang I1, t7 is gebonden aan ingang t7:

(〈t5,−〉 , 〈t7,−〉) 7→ (I1, I2) (leidend voorbeeld) (5.9)

We kijken eerst of we de toewijzingen van t5 en t7 kunnen uitbreiden. t5 is verder nog betrokken in shr 3 enmax2, dit zijn beide commutatieve functionele eenheden. We zullen dus ook voor deze operaties t5 toekennenaan ingang I1. t7 is in geen enkele andere operatie betrokken. We vatten samen:

(〈t5, shr 3〉 , 〈t5,max2〉) 7→ (I1, I1) (leidend voorbeeld) (5.10)


Nu we t7 aan deze functionele eenheden hebben toegewezen, kunnen we de andere variabelen die in dezeoperaties betrokken zijn toewijzen: max2 heeft een twee ingangen en aan de andere ingang dient t10 te staan:

(〈t10,max2〉) 7→ (I2) (leidend voorbeeld) (5.11)

Voor de overige variabelen hebben we niet meteen een aanwijzing. Daarom zullen we deze eenvoudigweg aaneen ingang toewijzen. Zo is t3 betrokken in max1 en min. Bij beide operaties kennen we t3 toe aan I1. Eenlogisch gevolg is dat t4 toegewezen wordt aan ingang I2. t8 wijzen we ook arbitrair toe aan I1 voor de +operatie, bijgevolg wijzen we t9 toe aan I2.

(〈t3,max1〉 , 〈t3,min〉 , 〈t4,max1〉 , 〈t4,min〉 , 〈t8,+〉 , 〈t9,+〉) 7→ (I1, I1, I2, I2, I1, I2) (leidend voorbeeld)(5.12)

Vermits elke eenheid maar een uitgang heeft kunnen we ook deze aspecten triviaal oplossen:

〈t3, abs1〉〈t4, abs2〉〈t5,max1〉〈t6,min〉〈t7, shr 3〉〈t8, shr 1〉〈t9,−〉〈t10,+〉〈t11,max2〉

7→

O1

O1

O1

O1

O1

O1

O1

O1

O1

(leidend voorbeeld) (5.13)

Indien we nu alle voorgaande informatie samenvatten in een tabel, bekomen we de invoeren uitvoertabellenzoals in tabel 5.10. We zetten hier de variabelen op de horizontale as, en de functionele eenheden op de

In I1 In I2 Out O1

t1 t2 t3 t5 t6 t8 t4 t7 t8 t9 t3 t4 t5 t6 t7 t8 t9 t10 t11abs1 • •abs2 • •max1 • • •min • • •shr 3 • •shr 1 • •− • • •+ • • •

max2 • • •

Tabel 5.10: Invoer- en uitvoertabellen van het leidend voorbeeld (zie figuur 5.22)

verticale as. Variabelen die aan geen enkele functionele eenheid bijdragen hebben we weggelaten uit dekolommen: bijvoorbeeld variabele t1 is nergens verbonden met een ingang I2, bijgevolg staat deze ook nietin dat deel van de tabel. Het weglaten van deze kolommen is vanzelfsprekend optioneel.

Onsamenvoegbaarheid en Prioriteit Nu we deze tabellen hebben opgesteld, kunnen we met het echtewerk beginnen: het samenvoegen van registers. Een eerste probleem die we moeten oplossen is bepalenwanneer twee variabelen eenzelfde register kunnen delen. Allereerst kunnen we opmerken dat een variabeleeigenlijk niet gebonden is aan een register: we zouden bijvoorbeeld dezelfde variabele in de ene toestandin register 1 kunnen bewaren en de andere toestand in register 2. Dit kan er toe leiden dat we inderdaadtot zeer compacte configuraties komen, maar in de meeste gevallen, maakt het het optimaliseren hopeloosingewikkeld. Daarom gebruiken we doorgaans de vuistregel:

We kennen een variabele toe aan strikt een register.

De vraag blijft in welke omstandigheden we twee variabelen niet in hetzelfde register kunnen opslaan. Eenalgemene regel is:


Twee variabelen kunnen niet in hetzelfde register worden opgeslagen indien de twee variabelenleven in een of meer toestanden.

We kunnen dit formaliseren met behulp van de sets die we berekend hebben in het deel over de lifenessanalyse:

∀ti, tj ∈ Variabelen, ti 6= tj : NietSamenvoegen (ti, tj)⇔ (∃s ∈ S : ti ∈ in [s] ∧ tj ∈ in [s]) (5.14)

Op basis van deze definitie kunnen we de volledige relatie berekenen van variabelen die we kunnen nietkunnen samenvoegen:

(t1, t2) (t3, t4) (t5, t6)(t5, t7) (t5, t8) (t5, t9)(t5, t10) (t7, t8) (t8, t9)

(5.15)

Toegegeven dat er negen paren van variabelen botsen, maar dit geeft ruimte voor een groot aantal manierenom variabelen samen te voegen. De schaduwzijde van het feit dat veel configuraties mogelijk zijn, is dat ereen serieuze kans bestaat dat we een foute configuratie uitkiezen. Om meer gericht op zoek te gaan naarwelke variabelen we kunnen samennemen, zullen we een heuristiek ontwikkelen: een functie die aangeeftin welke mate het de moeite loont om twee variabelen samen te nemen. Deze functie heeft de signatuurh : V × V → N, waarbij V de set van variabelen voorstelt, en N de set van natuurlijke getallen (met 0).Een interessante metriek kunnen we opstellen op basis van de invoeren uitvoertabellen (zie tabel 5.10). Deheuristiek definieren we dan als:

Het aantal in- en uitgangen die de twee variabelen gemeenschappelijk hebben met elkaar bijfunctionele eenheden die het potentieel hebben om samengenomen te worden.

De argumentatie is de volgende: indien we effectief functionele eenheden samennemen, zal dit er meestaltoe leiden dat verschillende registers naar eenzelfde ingang van deze samengestelde functionele eenheid wor-den geleid. Indien alle variabelen die deze ingang gemeenschappelijk hebben, echter in hetzelfde registeropgeslagen zitten, zijn deze multiplexers overbodig. Formeel kunnen we deze functie dus definieren als:

∀ti, tj , ti 6= tj : prioriteit (ti, tj) = #

∀ (ti, fa, c) , (tj , fb, c) ∈ Verbindingen, a < b,(fa, fb, c) ∃F ∈ SamenvoegbareFunctioneleEenheden,

fa, fb ∈ F

(5.16)

Ook deze definitie zullen we toepassen op leidend voorbeeld. We verwachten dat we max1 en max 2 kunnensamennemen alsook + en −. Daarom wordt de set SamenvoegbareFunctioneleEenheden gelijk aan:

SamenvoegbareFunctioneleEenheden = max1,max2 , +,− (leidend voorbeeld) (5.17)

De Verbindingen-set hebben we eigenlijk al opgesteld en kunnen we bekijken in de in- en uitvoertabellen(zie tabel 5.10). De set bestaat uit tuples met als volgorde: (variable, functionele eenheid, verbinding). DeVerbindingen bevat dus onder andere de volgende elementen:

Verbindingen = (t1, abs1, I1) , (t3, abs1, O1) , (t2, abs2, I1) , (t4, abs1, O1) , . . . (leidend voorbeeld)(5.18)

??prioriteit (t3, t5) = 1 prioriteit (t4, t10) = 1 prioriteit (t5, t8) = 1prioriteit (t5, t11) = 1 prioriteit (t7, t9) = 1 prioriteit (t9, t10) = 1

(5.19)

Opstellen van een compatibiliteitsgraaf Met de informatie uit de vorige paragraaf kunnen we eencompatibiliteitsgraaf opstellen. Een compatibiliteitsgraaf is een graaf waarbij de knopen (ofwel nodes)entiteiten voorstellen die al dan niet compatibel met elkaar zijn (in dit geval dus de variabelen). Verderbevat de graaf twee soorten bogen:

1. Incompatibiliteitsranden: dit zijn bogen tussen twee knopen die onverenigbaar met elkaar zijn. Inhet geval van de compatibiliteitsgraaf die we hier aan het opstellen zijn, zijn dit dus de paren uitvergelijking (5.15). We stellen de bogen voor met stippellijnen.


2. Prioriteitsranden: dit zijn bogen tussen twee knopen die net goed verenigbaar zijn, en die dus waar-schijnlijk een belangrijk voordeel opleveren wanneer ze samengevoegd worden. We hebben deze bogenberekend met de prioriteitsfunctie uit vergelijking (5.16). In dit geval komt dit dus neer op de bogen invergelijking (5.19). We stellen de bogen voor met volle lijnen. Bovendien hebben de bogen natuurlijkeen label: de waarde van de prioriteit.

Een uitgewerkte compatibiliteitsgraaf voor het leidend voorbeeld staat op figuur 5.24 (de gevulde gebiedenlaten we voorlopig nog buiten beschouwing). De bedoeling van een compatibiliteitsgraaf is om een grafischhulpmiddel te bieden om de variabelen optimaal samen te voegen. Op basis van de graaf moeten we opzoek gaan naar een max-cut graph partitioning: het opdelen van de graaf in een minimaal aantal groepenzodat het totale gewicht van alle groepen samen maximaal is. Hierbij is het totale gewicht van een groep desom van alle prioriteitsranden waarbij beide knopen in de groep zitten. De partitionering van de graaf dientverder volledig te zijn: elke knoop dient tot juist een groep te behoren. Het bekomen van een max-cut graphpartitioning is een niet-triviaal probleem en valt niet onder deze cursus. We zullen in de volgende paragraafeen methode ontwikkelen waarmee we grafisch tot een redelijke partitionering zullen komen.

t1

t2

t3

t4

t11

t10

t5

t9 t7 t8

t6

1

1

1 1 1

Figuur 5.24: De evolutie van de compatibiliteitsgraaf voor de variabelen.

Partitioneren van de compatibiliteitsgraaf Het bekomen van een optimale partitionering zullen we indrie stappen bewerkstelligen:

1. Zoek een kliek: een kliek is een groep knopen waarbij er tussen elke twee knopen een incompa-tibiliteitsrand zit. In het leidend voorbeeld kunnen we dus een kliek beschouwen met de knopent5 , t7 , t8. Deze variabelen vormen de oorsprong van de partities.

2. Voeg knopen toe op basis van de prioriteitsranden: we gaan de prioriteitsranden van groot naar kleinaf. Telkens wanneer er juist een van de knopen al toegevoegd is aan een partitie zullen we proberen deandere knoop ook aan de partitie toe te voegen. Dit kan enkel wanneer er geen incompatibiliteitsrandtussen de knoop van de partitie en de knoop die we willen toevoegen zit. Telkens wanneer we erinslagen om zo’n knoop toe te voegen, overlopen we alle bogen opnieuw. We stoppen wanneer we bijgeen enkele boog meer een knoop kunnen toevoegen. Indien twee bogen hetzelfde gewicht hebben, isde volgorde arbitrair. Toegepast op het voorbeeld kunnen we dus de volgorde volledig zelf kiezen. Wekiezen de volgorde op basis van de knoop met de laagste index. In het geval beide bogen dezelfdekleinste knoop gemeenschappelijk hebben, dient de andere knoop als “tiebreak”. We behandelen deknopen dus in volgende volgorde:

(t3, t5, 1) < (t4, t10, 1) < (t5, t11, 1) < (t7, t9, 1) < (t9, t10, 1) (leidend voorbeeld) (5.20)

Vervolgens beginnen we met toevoegen. De eerste boog die aan de voorwaarden voldoet is (t3, t5, 1),we voegen dus t3 toe aan de partitie van t5. Daarna volgt t11 die eveneens aan t5 wordt toegevoegd. Devolgende bogen zijn (t7, t9, 1), (t9, t10, 1) en (t4, t10, 1). We voegen dus t9, t10 en t4 toe aan de partitievan t7. Hiermee hebben we alle prioriteitsranden met succes kunnen oplossen. De partitie achter dezestap is dan ook: t3, t5, t11 , t4, t7, t9, t10 , t8.


3. Wijs de overige knopen toe: de laatste stap bestaat er uit om de knopen toe te wijzen die nog vrij zijn.Dit kunnen we arbitrair doen: we voegen een knoop toe aan een partitie naar keuze. Dit kan zolanger geen incompatibiliteitsrand tussen een knoop in de partitie en de knoop die we willen toevoegenzit. Indien dit wel zo is, zullen we een andere partitie moeten kiezen. In het geval voor iedere partitieer een incompatibiliteitsrand bestaat, richt de knoop zijn eigen partitie op. Vervolgens kunnen weweer naar stap 2 terugkeren om eventuele prioriteitranden op te lossen met de nieuwe partitie, omvervolgens weer stap 3 uit te voeren. Zo zullen we in het leidend voorbeeld t1 aan de partitie van t5toevoegen. t2 kunnen we niet aan diezelfde partitie toevoegen, want tussen t1 en t2 ligt immers eenincompatibiliteitsrand. Daarom voegen we t2 toe aan de partitie van t7. Tot slot dienen we nog t6toe te voegen. Hiervoor hebben we de keuze tussen de partities van t7 en t8. We kiezen hier voor departitie van t8, maar het alternatief is ook correct. Na deze stap hebben we alle knopen toegewezenen is de partitie de volgende:

t1, t3, t5, t11 , t2, t4, t7, t9, t10 , t6, t8 (leidend voorbeeld) (5.21)

R t1a

bc 00011011

R t2d

ef

g

000

001

010

011

100

101

110

111

R t6h

i 01

abs abs max min shr 3 shr 1 − + max

Figuur 5.25: Implementatie van het datapad van het leidend voorbeeld na het minimaliseren van de varia-belen.

Minimalisering Figuur 5.25 toont de implementatie van het datapad nadat we de variabelen hebbengereduceerd. De figuur toont drie registers. Elke registers krijgt de naam van een van de element van departitie12. Vermits het aantal registers op drie staat, zal ook het aantal verbindingen van de registers naarde functionele eenheden gereduceerd worden. Een register vertegenwoordigt een groep variabelen, bijgevolgtrekken we een lijn van een register naar alle functionele eenheden die invoer uitlezen uit minstens een van devertegenwoordigde variabelen. De verbinding gebeurt uiteraard met de relevante invoerlijnen. Bijvoorbeeldde min component berekent het minimum tussen t3 en t4 respectievelijk op ingang 1 en 2. Omdat t3vertegenwoordigd wordt door het register t1, verbinden we dit register met de eerste ingang. t4 wordt danweer vertegenwoordigd door register t2. Bijgevolg verbinden we dit register met de tweede ingang.

12In werkelijkheid vertegenwoordigt het register alle variabelen in de partitie. We hadden het register t1 dus ook bijvoorbeeldt3 kunnen noemen.


Het samenvoegen van registers levert ook nog een ander probleem op: wat doet men met de uitvoer vande functionele eenheden. In Figuur 5.23 komt de uitvoer van een functionele eenheid altijd in een registerterecht. Omdat we hier de registers samenvoegen in drie algemene registers lukt dit niet. We kunnen deuitvoer van de functionele eenheden verbinden met het register die de relevante variabele vertegenwoordigt.We kunnen echter geen uitgangen combineren. Dit kan tot kortsluiting leiden en bovendien is het onduidelijkwelke uitvoer er in dat geval in het register zou worden ingelezen. We kunnen dit probleem oplossen metbehulp van multiplexers. Bij iedere register waar meerdere uitgangen van functionele eenheden toekomenplaatsen we een multiplexer met voldoende data-ingangen. De uitgang van de multiplexer verbinden wevervolgens met het register. Ten slotte zijn de selectie-ingangen van de multiplexer de verantwoordelijkheidvan de controller. De controller dient bijgevolg te bepalen uit welke functionele eenheid de data moet wordeningelezen die in het register zal worden geplaatst.

Wanneer we een multiplexer introduceren, zal de controller extra logica moeten voorzien om de selectie-ingangen te besturen. Anderzijds verdwijnt de logica voor de set- en reset-ingangen van de registers diewegvallen. Ook moet de we logica voorzien voor de set- en reset-ingangen van de gegroepeerde registers. Indeze paragraaf beschrijven we kort hoe we de logica bepalen voor de selectie-ingangen van de multiplexers.Als voorbeeld nemen we register t1. Een eerste aspect is het voorzien van de set- en reset-ingangen, indieneen van de oorspronkelijke registers zo’n ingang voorzag. Dus voor het uiteindelijke register t1 moeten weenkel een set-ingang voorzien (verbonden met de controller). Dit komt omdat de originele registers voor t1,t3, t5 en t11 uitsluitend een set-ingang voorzien. Een tweede aspect is wanneer set- en reset-ingangen actiefmoeten worden. Omdat een samengevoegd register alle oorspronkelijke registers vertegenwoordigt, moetende set- en reset-ingangen actief zijn, wanneer dit bij minstens een van de originele registers het geval was.Concreet laadt het originele register t1 een waarde in, in toestand 0, t3 doet dit in toestand 1, t5 in toestand 2en t11 ten slotte in toestand 6. Bijgevolg moet de set-ingang van het samengevoegde register t1 dus actief zijnin toestanden 0, 1, 2 en 6. In alle andere toestand moet het signaal laag zijn. Hetzelfde geldt voor (hier nietaanwezige) reset-ingangen. Indien we de controller dus minimaal willen aanpassen kunnen we een OR-poortplaatsen die als invoer de uitvoer naar de register neemt en zelf het signaal op de set- en reset-ingangen vande samengevoegde registers bepaalt. In de praktijk zal het opnieuw synthetiseren van de logica goedkoperzijn. Een tweede type logica die we moeten synthetiseren is het signaal op de selectie-ingangen. We wetendat het originele register t1 in toestand 0 data moest inladen die op dat moment op data-ingang A van deprocessor staat. Deze data staat op 11 bij de multiplexer. Bijgevolg moet op dat moment ook deze waardeaan de selectie-ingangen van multiplexer staan. Analoog staat in toestand 1, 10 op de selectie-ingangen. Intoestand 2 is het signaal 01, en in toestand 6 is dit 00. In de andere toestanden moeten we natuurlijk ook eensignaal op de selectie-ingangen zetten. Omdat de waarde die de multiplexer doorgeeft toch niks uitmaakt,kunnen we hiervoor gebruik maken van don’t cares. Meestal maakt men multiplexers waarbij het aantaldata-ingangen machten van twee is. Wanneer we er echter minder data-ingangen gebruikt worden, kunnenwe op verschillende ingangen dezelfde data aanleggen. In zo’n situatie kunnen we dan kiezen tussen een vande data-ingangen die het signaal aanlegt. Dit leidt dus tot meer don’t cares en bijgevolg een mogelijk nogcompactere implementatie. Zo zien we dat bij de multiplexer van t2 we meermaals data-ingang B aanleggen.Dit zorgt ervoor dat behalve de hoogste bit, we vrije keuze hebben welke waarde wordt aangelegd. Tabel 5.11geeft de stuursignalen van alle componenten weer.

Toestand a b c d e f g h i0 1 1 1 1 - - 1 0 -1 1 0 1 1 1 1 0 0 -2 1 1 0 0 - - - 1 13 0 - - 1 0 1 0 1 04 0 - - 1 1 0 0 0 -5 0 - - 1 0 0 0 0 -6 1 0 0 0 - - - 0 -7 0 - - 0 - - - 0 -

Tabel 5.11: Stuursignalen voor de verschillende toestanden na samenvoegen van registers.


Het samenvoegen van registers gaat dus gepaard met de introductie van multiplexers en extra combina-torische logica in de controller. Dit is een van de redenen waarom het moeilijk is om te voorspellen of eenoptimalisatie effectief tot goedkopere implementaties zal leiden.

Bewerkingen samenvoegen (“functional-unit sharing”)

In het leidend voorbeeld zien we verschillende functionele eenheden. Sommige van deze functionele eenhedenvoeren echter dezelfde bewerking in een andere toestand uit. Het is mogelijk goedkoper deze bewerkingenmet dezelfde functionele eenheid uit te voeren. Anderzijds zijn sommige functionele eenheden zeer gelijk-aardig. In Subsectie ?? hebben we de implementatie van een schakeling besproken die getallen kan optellenen aftrekken. Functionele eenheden die gelijkaardige bewerkingen uitvoeren kunnen meestal worden sa-mengevoegd in schakelingen die beide bewerkingen kunnen uitvoeren, en waarbij de resulterende schakelinggoedkoper is dan de som van de twee aparte functionele eenheden. Het samenvoegen van functionele eenhe-den wordt functional-unit sharing genoemd omdat een functionele eenheid tussen verschillende toestandenwordt gedeeld.

Gelijkaardige bewerkingen samenvoegen Een probleem in dit proces is dat het samenvoegen vantwee functionele eenheden in een nieuwe functionele eenheid geen sinecure is, en meestal enige ervaringvereist. We zullen in doorheen deze subsectie verschillende functionele eenheden combineren om de lezer eennotie te geven over de principes hierachter. Meestal zoekt men naar logica die beide functionele eenhedengemeenschappelijk hebben. Daarna moeten extra ingangen bepalen welke bewerking wordt uitgevoerd doorde overige logica aan te sturen.

Compatibiliteitsgrafe Eenmaal we de kostprijs berekend hebben van het samenvoegen van verschillendefunctionele eenheden, dienen we een keuze te maken welke bewerkingen we effectief zullen samenvoegen.Hiervoor zullen we dezelfde werkwijze met de compatibiliteitsgrafe hanteren. In de compatibiliteitsgrafehebben de componenten de volgende betekenis:

1. Knopen: de knopen stellen bewerkingen voor, dus de originele functionele eenheden.

2. Incompatibiliteitsranden: twee bewerkingen zijn niet verenigbaar, wanneer ze een toestand gemeen-schappelijk hebben waarin ze beiden actief zijn.

3. Prioriteitsranden: twee of meer13 bewerkingen die men kan samenvoegen delen een prioriteitsrand. Hetgewicht is de winst in kostprijs (transistors of logische blokken) bij het samenvoegen.

Figuur 5.26 toont de initiele compatibiliteitsgraaf met de incompatibiliteitsranden.

abs1

abs2

min

max1 max2 +

- shr 3

shr 1

Figuur 5.26: Oorspronkelijke compatibiliteitsgrafe bij het samenvoegen van bewerkingen.

Multiplexers Wanneer twee functionele eenheden worden samengevoegd, delen ze een deel van de ingan-gen. Het is mogelijk dat de ingangen van beide functionele eenheden verbonden zijn met andere registers.In dat geval moeten extra multiplexers bepalen welk register de invoer levert voor de functionele eenheid.Multiplexers brengen echter een extra kost met zich mee. Zelfs wanneer de samengestelde functionele eenheid

13Soms kan men drie of meer bewerkingen samenvoegen in een nieuwe functionele eenheid.


goedkoper is, zal de resulterende schakeling daarom niet noodzakelijk goedkoper zijn. De extra kosten diemet het invoeren of aanpassen van multiplexers gepaard gaan, moeten dus ook in rekening worden gebracht.Figuur 5.27 illustreert dit concept. Aanvankelijk zijn er twee functionele eenheden FU1 en FU2, elk met eigenin- en uitgangen. Wanneer we de functionele eenheden in een nieuwe functionele eenheid FU1&2 onderbren-gen, introduceren we twee multiplexers. Ook de controller zal extra stuursignalen moeten implementeren:het bedienen van de multiplexers vereist extra logica. Soms zal de samengestelde functionele eenheid ookextra stuursignalen vereisen. Dit is het geval wanneer de twee functionele eenheden niet dezelfde bewerkinguitvoeren, en de controller dus moet bepalen welke opdracht zal worden uitgevoerd. Indien sommige registersdezelfde zijn (bijvoorbeeld A en C op de figuur), kunnen we multiplexers weglaten.

FU1

A B

F

FU2

C D

G

AC

a

BD

b

FU1&2c

F G

Figuur 5.27: Minimaliseren van bewerkingen introduceert multiplexers.

Minimum en Maximum bewerking In het leidend voorbeeld berekenen we het minimum en maximum.Deze schakelingen hebben we niet gedefinieerd in Hoofdstuk 3. De schakeling is echter vrij eenvoudig: weberekenen eerst het verschil tussen de twee getallen. Indien het verschil positief is, zullen we met behulpvan multiplexers het tweede getal teruggeven, in het andere geval geven we de waarde terug op de eersteinvoer. In het geval van het maximum draaien we de multiplexer om. Een schematische voorstelling staatop Figuur 5.28(a) geeft dit proces schematisch weer. Vermits we bij het verschil enkel geınteresseerd zijn

01

min(A,B)

BA

−teken

(a) Minimum

ci+1

aibici

(b) Carry-logica

01

min(A,B)/max(A,B)

BA

−teken

a

(c) Minimax

Figuur 5.28: Implementatie van een minimum-component.

in het teken, hoeven we de overige bits niet uit te rekenen. Bijgevolg moeten we ook enkel de carry-logicaimplementeren. Figuur 5.28(b) toont een mogelijke implementatie van deze carry-logica. De schakeling isbijgevolg een gereduceerde versie van Figuur 3.14(d). Wanneer we de kostprijs van de carry-logic uitrekenenkomen we uit op 20 transistors per bit14. Een multiplexer kost 12 transistors per bit. Bijgevolg kost eenminimum- of maximum-component 32 transistors per bit.

14Op een constante kostprijs na, die we hier niet beschouwen. Als het aantal bits vrij groot is, maakt de constante kostprijsmeestal niet veel uit.


De compatibiliteitsgrafe op Figuur 5.26 toont dat het samenvoegen van de min en max1 bewerking nietmogelijk is. Beide bewerkingen worden immers in dezelfde toestand gebruikt. We kunnen echter wel max1 enmax2 samenvoegen. Door het samenvoegen sparen we 32 transistors per bit uit. We dienen echter rekening tehouden met de mogelijke introductie van multiplexers. In dit geval hebben we geluk: max1 neemt als invoervariabelen t3 en t4 voorgesteld door registers t1 en t2. max2 neemt als invoer variabelen t5 en t10 die ookworden opgeslagen in registers t1 en t2. In dit geval dienen we dus geen extra multiplexers te introduceren,de totale winst is dan ook 32 transistors per bit zoals aangeduid op Figuur 5.37.

We kunnen er ook voor opteren om min en max2 samen te voegen. Figuur 5.28(c) toont een functioneleeenheid die zowel het minimum als maximum kan uitrekenen. De schakeling verschilt slechts op een puntvan Figuur 5.28(a): er staat een XNOR15-poort tussen het tekenen van het verschil een de multiplexer.Met behulp van het stuursignaal kan men dus beslissen om het signaal uit het verschil om te draaien of tebehouden. Door het signaal om te draaien, kan men dus de andere data-ingang bij de multiplexer selecteren.Omdat de XNOR-poort maar eenmalig in de schakeling moet worden verwerkt, stijgt de kostprijs per bitniet. Ook hier hebben we geluk met de registers: beide functionele eenheden halen hun invoer uit dezelfderegisters. De totale winst is dus opnieuw 32 transistors per bit.

Abs&max Een volgende combinatie die we uitproberen is het berekenen van een absolute waarde en hetmaximum. Omdat we in de vorige paragraaf besproken hebben dat het minimum en maximum zeer gelijk-aardig zijn, gelden alle uitspraken ook voor een component abs&min. Allereerst dienen we een component teintroduceren die de absolute waarde kan uitrekenen. Een mogelijke implementatie staat op Figuur 5.29(a).De meest significante bit bepaalt in complementvoorstelling het teken van het getal. Het teken stuurt vervol-

01

abs a

A

−

teken an−1

(a) Abs

01

abs ai

HA cici+1

an−1

ai

(b) Abs per bit

00011011

fi

FA cici+1

m0m1

si

di

biai

Max/Abs*

(c) Abs&max per bit

Figuur 5.29: Implementatie van abs en abs&max.

gens de selectie-ingang van een multiplexer aan. Indien het getal negatief is, wordt het tegengestelde van hetoorspronkelijke getal doorgelaten. In het andere geval wordt het getal zelf doorgelaten. We moeten per bithet tegengestelde uitrekenen en voor elke bit dienen we ook een multiplexer te voorzien. Deze implementatieper bit wordt voorgesteld op Figuur 5.29(b). Op basis van deze schakeling zetten we de kostprijs van eenabs bewerking op 32 transistors per bit. We kunnen beide componenten samenvoegen, door per bit eenschakeling te implementeren zoals op Figuur 5.29(c). De component berekent ofwel het maximum van detwee data-ingangen, of de absolute waarde van de tweede data-ingang. De schakeling werkt als volgt: defull adders berekenen samen met de NOT-poort het verschil tussen D (voorgesteld door de di-bits) en B(voorgesteld door de bi-bits), het resultaat is een getal S (voorgesteld door de si-bits). Indien we de absolutewaarde berekenen (dit betekent dat het signaal Max/Abs* laag staat), is D gelijk aan 0, bijgevolg is S = −B.

15Een XOR-poort is ook correct indien het stuursignaal wordt geınverteerd, alleen kost een XOR-poort meer.


In het geval we het maximum berekenen is S = A−B. Indien we de absolute waarde berekenen, zullen weop basis van het teken van B de multiplexer aansturen, en beslissen of we ofwel B doorlaten (in het gevalB positief is), ofwel S = −B. Dit hangt louter af van de hoogste bit van B zoals voorgesteld in Tabel 5.12.In het geval we het maximum berekenen zal het teken van S de multiplexer aansturen. Indien de teken-bitsn−1 laag is (S is positief), laten we A door. S is immers positief wanneer A ≥ B. In het andere gevallaten we B door. Op basis van de tekens van B, S en de operatie die we willen uitvoeren (absolute waardeof maximum), moeten we dus de stuursignalen m0 en m1 voor de multiplexer bepalen. Deze stuursignalenzijn voor de multiplexers van alle bits gelijk. Omdat we de logica dus maar eenmalig moeten implementerenzullen we de kostprijs hiervan verwaarlozen. De kost per bit omvat echter de multiplexer (18 transistorsper bit), de full adder (36 transistors per bit), de AND-poort (6 transistors per bit) en de NOT-poort (2transistors per bit). In totaal maakt dit dus 62 transistors per bit.

Max/Abs* bn−1 sn−1 fi m1 m0

0 0 − bi 1 −0 1 − si 0 11 − 0 ai 0 01 − 1 bi 1 −

Tabel 5.12: Multiplexer selectie-ingangen bij abs&max.

Nu we een samengesteld component hebben geımplementeerd, kunnen we de mogelijke winst berekenen.Er zijn verschillende manieren hoe we een dergelijk component kunnen gebruiken. Hieronder beschouwen wealle mogelijkheden: abs1,min , abs1,max1 , abs1,max2

abs2,min , abs2,max1 , abs2,max2abs1,max1,max2 , abs2,max1,max2

(5.22)

We zullen niet alle combinaties bespreken. De mogelijke winsten staan op Figuur 5.37. Enkel de scenario’sdie interessant zijn worden besproken. Als eerste voorbeeld nemen we abs1 en max1. De twee functioneleeenheden apart kosten 64 transistors per bit. Wanneer we de twee functionele eenheden samenvoegen, danverwachten we slechts 62 transistors per bit te betalen. Een probleem vormt echter de registers: abs1 haaltde gegevens uit register t1, terwijl max1 deze uit de registers t1 en t2 haalt. Vermits de samengesteldecomponent voor de absolute waarde de tweede ingang neemt, betekent dit dat we een multiplexer moetenplaatsen die kiest tussen register t1 en t2. Dit concept is geıllustreerd in Figuur 5.30. We kunnen echter

abs1

t1

t1

max1

t1 t2

t6

⇒

t1 t2

a

abs1&max1b

t1

t1 t6

≡abs1&max1

t2 t1

a

t1 t6

Figuur 5.30: Het combineren van abs1 en max1 introduceert een multiplexer.

een eigenschap van het maximum uitbuiten: deze operator is commutatief. Het maakt dus niet uit of dezecomponent het maximum van t1 en t2 berekent, of van t2 en t1. Door de bedrading van het maximum omte draaien, vervalt de noodzaak om een multiplexer in te voeren. De totale winst bij het combineren is dus2 transistors per bit. Ditzelfde principe kan men toepassen bij het samenvoegen van alle combinaties inVergelijking (5.22) met twee bewerkingen.


We kunnen ook drie functionele eenheden in een nieuwe functionele eenheid combineren. Vermits wetwee functionele eenheden hebben die de absolute waarde uitrekenen en twee die het maximum uitrekenenkunnen we verschillende combinaties uitproberen. Dit kan zolang niet beide absolute waardes door dezelfdecomponent worden uitgerekend. De twee bewerkingen zijn immers incompatibel. Als voorbeeld nemenwe abs1, max1 en max2. Vermits max1 en max2 commutatieve operaties zijn maakt de volgorde van dedata-ingangen niet uit. Omdat de bewerkingen die we combineren allemaal op dezelfde registers werken,zullen we dus geen extra multiplexers moeten introduceren. De oorspronkelijke kostprijs per bit was 32transistors voor abs1, 32 transistors voor max1 en 32 voor max2, wat dus samen 96 transistors per bitbetekent. De totale winst is dus 34 transistors per bit. Een probleem is hoe we de winsten met drie ofmeer functionele eenheden in een compatibiliteitsgrafe voorstellen. We kunnen immers geen boog tussendrie knopen trekken. Twee bogen die de drie knopen verbinden kan dan weer tot verwarring leiden: de tweebogen kunnen als twee afzonderlijke prioriteitsranden beschouwd worden. Daarom voert men meestal eengevulde knoop die de prioriteitsrand voorstelt. Vanuit de knoop vertrekken bogen naar de bewerkingen opdewelke de prioriteitsrand betrekking heeft. Op de knoop zelf noteren we de winst. Deze notatie staat ookop Figuur 5.37.

Add&Sub In Figuur 3.20(b) op pagina 72 bespraken we reeds hoe we een component kunnen realiserendie zowel een optelling als een aftrekking kan uitvoeren. Op basis van een stuur-signaal kan men beslissenwelke operatie uiteindelijk zal worden uitgevoerd. In deze paragraaf bespreken we de mogelijke winst diedit oplevert. Allereerst berekenen we de kostprijs per bit van een aparte opteller en aftrekker. Een optellerkost per bit een full adder, dit komt dus neer op een kostprijs van 36 transistors per bit. Een aftrekkervoorziet per bit een full adder en een NOT-poort. De kostprijs is bijgevolg 38 transistors per bit. De totalekostprijs van de twee afzonderlijke componenten is dus 74 transistors per bit. Bij een component die beidebewerkingen uitvoert vervangen we de NOT-poort door een XOR-poort zodat we kunnen kiezen of we debits inverteren. De kostprijs per bit wordt dus opgedreven naar 48 transistors per bit. Dit betekent duseen winst van 26 transistors per bit. Wanneer we echter naar de bedrading kijken, zien we dat de optellingdata uitleest uit registers t1 en t2. De aftrekking werkt met de registers t6 en t2. Bijgevolg moeten we eenmultiplexer introduceren die 12 transistors per bit kost. De totale winst wordt dus 14 transistors per bit.

FA

fi

biai

ci−1ci

(a) Opteller per bit

FA

fi

biai

ci−1ci

(b) Aftrekker per bit

FA

fi

bi

S/A*

ai

ci−1ci

(c) Opteller/aftrekker per bit

FA

01

fi

bi

S/A*

aidi

ci−1ci

(d) Opteller/aftrekker per bitmet multiplexer

Figuur 5.31: Implementatie van een opteller, aftrekker en opteller/aftrekker.

Add&Max We kunnen ook proberen om een optelling een het maximum in een bewerking samen te voegen.Rekenkundig zijn beide bewerkingen niet direct met elkaar verwant. We kunnen echter op Figuur 5.29(c)vaststellen dat we om het teken van het verschil te berekenen, full adders kunnen gebruiken. Vermits dezecomponenten de basis vormen van de optelling, is er een vermoeden dat in termen van poorten beide operatieseen deel van de logica delen. Figuur 5.32 toont de implementatie per bit voor een zo’n component. Indienwe een optelling willen uitrekenen, zal de XOR-poort voor elke bit eenvoudigweg de waarde van bi doorlaten.


00011011

fi

FA cici+1

m0m1

si

biai

Max/Add*

Figuur 5.32: De implementatie van add&max per bit.

Bijgevolg zullen de full adders de optelling van A (voorgesteld door de ai’s) en B (voorgesteld door de bi’s)uitrekenen. Het komt er op neer in dat stadion de waarde S (voorgesteld door de si’s) bij alle multiplexersdoor te laten. In het geval we het maximum berekenen is het signaal Max/Add* hoog. Bijgevolg doet deXOR-poort dienst als een NOT-poort voor bi. Het gevolg is dat S = A−B. Het teken van S wordt mee in delogica van de selectie-ingangen voor de multiplexer genomen en bepaalt dus of we ofwel A zullen doorlaten(indien S ≥ 0) ofwel B (indien S < 0). Het bepalen van de selectie-ingangen van de multiplexer vereistnatuurlijk ook logica. Tabel 5.13 beschrijft in welke omstandigheden welke selectie-ingangen vereist zijn.

Max/Add* sn−1 fi m1 m0

0 − si 0 −1 0 ai 1 01 1 bi 1 1

Tabel 5.13: Multiplexer selectie-ingangen bij add&max.

Een eenvoudige implementatie die geen extra kosten met zich meebrengt is m1 = Max/Add* en m1 = sn−1.

De kosten van een add&max-component bestaan uit drie delen: de multiplexer kost 18 transistoren perbit, de XOR-poort 12 transistoren per bit en de full adder 36 transistoren per bit. Samen maakt dit dus 66transistoren per bit. Nu we de kostprijs berekend hebben, kunnen we bepalen wat een dergelijk componentkan opleveren. We kunnen de component op drie verschillende manieren gebruiken:

+,max1 , +,max2 , +,max1,max2 (5.23)

Bij alle combinaties komen we hetzelfde probleem tegen: de opteller haalt data uit registers t6 en t2 terwijlde beide componenten die het maximum berekenen dit halen uit de registers t1 en t2. Doordat beidebewerkingen commutatief zijn kunnen we de ingangen schikken zoals we wensen. Het resultaat blijft echterdat we minimum 1 multiplexer moeten introduceren aan 12 transistors per bit. De kostprijs van een optelleris 36 transistors per bit en het maximum kost 32 transistors per bit. Indien we dus een opteller samenvoegenmet een maximum-component bekomen we dus een verlies van 10 transistors per bit. Dit duidt ook meteenaan dat het samenvoegen van bewerkingen niet altijd goedkoper is. Het rendeert echter wel wanneer we deopteller combineren met twee maximum componenten. In dat geval maken we 22 transistoren per bit winst.Deze winst staat ook op Figuur 5.37. Verliezen worden niet op een compatibiliteitsgrafe gezet. Men zalimmers dergelijke prioriteitsranden altijd vermijden omdat het de kostprijs alleen maar verder verhoogt.


Abs&Add&Max Tot dusver hebben we telkens twee types bewerken samengevoegd, eventueel is er welsprake van meerdere functionele eenheden. Het is echter ook mogelijk meer dan twee types bewerkingensamen te voegen in een nieuwe functionele eenheid. Componenten die drie of meer bewerkingen werden alkort besproken onder de naam “Arithmetic Logic Unit (ALU)” in Subsectie 3.2.6 op pagina 72. Het valtop dat combinaties met de absolute waarde, de opteller en het maximum op Figuren 5.29(c) en 5.32 eensoortgelijk patroon vertonen: een full adder met daaronder een multiplexer die ofwel het resultaat van de fulladder ofwel dit van de originele ingangen doorlaat. Meestal zijn de ingangen van de full adder ook voorzienvan poorten. Het samenvoegen van bewerkingen kan dus mogelijk de transistoren uitsparen die betrokkenzijn in de full adder en de multiplexer. Figuur 5.33 toont de implementatie per bit van een component diezowel een optelling, absolute waarde en maximum kan uitrekenen. Hiervoor werkt de component met twee

00011011

fi

FA cici+1

m0m1

si

biai

Add’Abs’

Figuur 5.33: De implementatie van abs&add&max per bit.

stuursignalen: Abs en Add. Indien Abs hoog staat en Add laag, wordt de absolute waarde uitgerekend. BijAbs laag en Add hoog berekent de component de optelling. Wanneer beide laag staan wordt het maximumuitgerekend. Dit systeem werkt als volgt: wanneer Abs hoog staat, zal het resultaat van de AND-poort 0zijn16. Verder zal in alle gevallen waarbij Add laag staat, wordt het signaal geınverteerd (dit zijn dus alletoestanden behalve de optelling). Hieruit kunnen we drie situaties afleiden: bij een optelling is S = A+B,bij het berekenen van een absolute waarde is S = −B en bij het berekenen van het maximum stellen weS = A−B. Het komt er dus op neer dat de selectie-ingangen van de multiplexer op basis van enerzijds hetsoort bewerking, en anderzijds het teken van S en B, de juiste data moeten doorlaten. De relevante selectie-ingangen voor de verschillende situaties staan op Tabel 5.14. De kostprijs per bit voor deze component

Abs Add bn−1 sn−1 fi m1 m0

0 0 − 0 ai 0 00 0 − 1 bi 0 10 1 − − si 1 −1 0 0 − bi 0 11 0 1 − si 1 −1 1 − − − − −

Tabel 5.14: Multiplexer selectie-ingangen bij abs&add&max.

bedraagt 72 transistors per bit: 18 voor de multiplexer, 36 voor de full adder, 12 voor de XOR-poort en 6voor de AND-poort. We kunnen verder opnieuw heel wat mogelijkheden beschouwen bij het combineren van

16Bemerk dat we de negatie nemen van Abs als tweede invoer op de AND-poort.


functionele eenheden: abs1,max1,+ , abs1,max2,+ , abs1,max1,max2,+abs2,max1,+ , abs2,max2,+ , abs2,max1,max2,+

(5.24)

Een eigenschap die we zeker kunnen uitbuiten is dat alle beschouwde bewerkingen commutatief zijn. abs1haalt bijvoorbeeld data uit register t1. Dit betekent dus dat we dit register op de tweede ingang moetenaanleggen. Door de operanden van de maximum-bewerkingen om te draaien vermijden we echter dat wehiervoor een multiplexer moeten invoeren. De optelling leest de gegevens echter uit registers t6 en t2. Wezullen dus sowieso een multiplexer moeten introduceren die kiest tussen het register t6 en een ander register(t1 of t2 afhankelijk van de gekozen combinatie). Een dergelijke multiplexer komt met een kost van 12transistors per bit. Indien we bijvoorbeeld abs2 combineren met de twee maximum-bewerkingen en deopteller, kunnen we de schakeling implementeren zoals op Figuur 5.34(a). In deze schakeling wordt de datavan B (voorgesteld door de bi’s) opgehaald uit register t2. Het getal A (voorgesteld door de ai’s) halen weuit register t1 en D (voorgesteld door de di’s) uit register t6. De 2-naar-1 multiplexer kiest bijgevolg uit eenvan de twee registers (register t6 wordt enkel gekozen bij een optelling). Een aspect die we echter kunnen

00011011

fi

FA cici+1

m0m1

si

bi

Add’Abs’

01

aidi

a

(a) Generische multiplexer.

00011011

fi

FA cici+1

m0m1

si

bi

Add’Abs

00011011

ai di0

(b) Samenstelling met poort.

Figuur 5.34: Methodes bij het introduceren van een multiplexer bij een samengestelde functionele eenheid.

uitbuiten is de AND-poort die vlak onder deze multiplexer staat. Het resultaat van de AND-poort bestaatimmers uit drie gevallen: ai, di of 0. We kunnen dus de AND-poort en de 2-naar-1 multiplexer samenvoegenin een 3-naar-1 multiplexer. Figuur 5.34(b) toont de implementatie door de AND-poort en de multiplexersamen te drukken. De kostprijs blijft in dit geval constant (al is dat niet altijd zo). Al kan er nog een redenzijn om dit te doen: de tijdsduur van het kritische pad. Wanneer het signaal door een 3-naar-1 multiplexergaat, is dit sneller dan door een 2-naar-1 multiplexer gevolgd door een AND-poort. Vermits het kritischepad de te realiseren kloksnelheid bepaalt, is dit een niet onbelangrijke factor.

Concreet realiseren we de volgende winsten: wanneer we een combinatie maken met een maximum-bewerking is de originele kostprijs 100 transistors per bit. De samengestelde component kost 72 transistorsper bit: 18 transistors voor de multiplexer, 36 voor de full adder, 12 voor de XOR-poort en 6 voor de AND-poort. Verder dienen we ook een multiplexer van 12 transistors per bit te implementeren. De winst is dus16 transistors per bit. Wanneer we een samenstelling maken met de twee maximum-bewerkingen, besparenwe alle transistoren betrokken in de tweede maximum bewerking: 32 transistors per bit. De totale winst isdus 48 transistors per bit.


Abs&Add&Max&Sub In de component die de absolute waarde, de optelling en het maximum samen-voegt in een functionele eenheid valt op dat in sommige omstandigheden de full adder het verschil van detwee operanden uitrekent. Dit effect is afkomstig van het maximum: we berekenen immers het verschilom te bepalen welk register we zullen doorlaten. Door minimale veranderingen kunnen we een componentimplementeren die in het geval we een verschil willen uitrekenen, de onderste multiplexer het resultaat vanhet verschil doorlaat. Hiervoor zullen we teruggrijpen naar Figuur 5.33. We beschouwen ook een extrastuursignaal: Sub. We dienen de schakeling per bit niet aan te passen, deze is dus volledig identiek aanFiguur 5.33. We dienen alleen de logica die de selectie-ingangen van de multiplexer berekent aan te passen.De nieuwe logica staat in Tabel 5.15.

Abs Add Sub bn−1 sn−1 fi m1 m0

0 0 0 − 0 ai 0 00 0 0 − 1 bi 0 10 0 1 − − si 1 −0 1 0 − − si 1 −0 1 1 − − − − −1 0 0 0 − bi 0 11 0 0 1 − si 1 −1 0 1 − − − − −1 1 − − − − − −

Tabel 5.15: Multiplexer selectie-ingangen bij abs&add&max&sub.

De kostprijs verschilt niet van deze van Abs&Add&Max: 72 transistors per bit.abs1,max1,+,− , abs1,max2,+,− , abs1,max1,max2,+,−abs2,max1,+,− , abs2,max2,+,− , abs2,max1,max2,+,−

(5.25)

Min&Sub We onderzoeken ook het samenvoegen van minimum- en verschil-bewerkingen. Uit de im-plementatie van minumum en maximum weten we al dat we daarvoor het teken van het verschil moetenberekenen. Daarom verwachten we dat het samenvoegen van de componenten winst kan opleveren. Fi-guur 5.35 toont de implementatie per bit van zo’n component. De full adder rekent altijd het verschil uit:

00011011

fi

FA cici+1

m0m1

si

biai

Figuur 5.35: De implementatie van min&sub per bit.

S = A − B. Ofwel wordt vervolgens op basis van het teken van S een getal doorgelaten (in het geval van


Sub/Min* sn−1 m1 m0

0 0 0 00 1 0 11 - 1 -

Tabel 5.16: Multiplexer selectie-ingangen bij min&sub.

een minimum-bewerking), ofwel wordt S zelf doorgelaten (wanneer we het verschil uitrekenen). Tabel 5.16toont hoe we de stuur-signalen van de multiplexer moeten implementeren.

De kostprijs per bit bestaat uit de multiplexer (18 transistors), de full adder (36 transistors) en de NOT-poort (2 transistors). Dit maakt dus samen 56 transistors per bit. In de schakeling komt maar een minimum-bewerking en een verschil bewerking voor. Dit is ook de enige combinatie die we kunnen uitproberen voordeze samengestelde functionele eenheid. Beide originele functionele eenheden halen bovendien gegevensuit dezelfde registers, bijgevolg worden geen extra multiplexers geıntroduceert. De kostprijs van de tweeafzonderlijke functionele eenheden is 70 transistors per bit. We maken dus 14 transistors winst per bit.

Abs&Min&Sub Bij het berekenen van de absolute waarde maken we een keuze tussen het ingevoerdegetal en de negatie van dat getal. Vermits we in de schakeling van Min&Sub de negatie van een ingevoerdgetal berekenen, hopen we deze hardware te kunnen hergebruiken. We proberen dus een Abs&Min&Subcomponent te implementeren. We moeten echter wel extra logica voorzien: het is immers de bedoeling datde full adders de negatie zullen leveren, maar dan moet de eerste operand wel op 0 worden gezet. Ditkan men doen door over een AND-poort te voorzien die wanneer het stuur-signaal op de AND-poort 0 is,zal de AND-poort ook 0 op de linkse ingang van de full adder aanleggen. We bekomen dus de schakelingop Figuur 5.36(a). Tabel 5.17 ten slotte, toont de logica bij de selectie-ingangen van de multiplexer. We

00011011

fi

FA cici+1

m0m1

si

biai

Abs’

(a) Algemene implementatie.

00011011

fi

FA cici+1

m0m1

si

01

biai

Abs’

(b) Met multiplexer.

Figuur 5.36: De implementatie van abs&min&sub per bit.

beschouwen een verschil-bewerking wanneer zowel Abs en Min allebei op 0 staan.

De kostprijs per bit van deze samengestelde component is 62 transistoren: 36 van de full adder, 6 van deAND-poort, 2 voor de NOT-poort en 18 voor de multiplexer. Er zijn twee verschillende combinaties van


Abs Min bn−1 sn−1 fi m1 m0

0 0 − − si 1 −0 1 − 0 bi 0 10 1 − 1 ai 0 01 0 0 − bi 0 11 0 1 − si 1 −1 1 − − − − −

Tabel 5.17: Multiplexer selectie-ingangen bij abs&min&sub.

functionele eenheden die we kunnen samenstellen met deze samengestelde functionele eenheid:

abs1,min,− , abs2,min,− (5.26)

Indien we abs1 betrekken in de combinatie, ontstaat er echter een probleem met de ingangen. De aftrekkerberekent immers het verschil tussen de waarde in registers t1 en t2. Omdat een verschil operator nietcommutatief is, mogen we dus de volgorde van de ingangen niet kiezen. abs1 berekent echter de absolutewaarde van t1. Hierdoor moet t1 op de tweede ingang worden aangelegd. Het gevolg is dus dat we eenmultiplexer moeten introduceren zoals op Figuur 5.36(b). Dit drijft de kostprijs op naar 74 transistors perbit. De originele kostprijs van de afzonderlijke functionele eenheden is 102 transistoren: 32 voor de absolutewaarde, 32 voor de minimum en 38 voor het verschil. De winst is dus 40 transistoren per bit voor eencombinatie met abs1 en 28 transistoren per bit voor een combinatie met abs2.

Combinaties met schuif-operaties over een vast aantal bits In de processor komen ook twee schuif-bewerkingen voor: shr 1 en shr 3. Kunnen we deze operaties niet combineren met andere functionele een-heden? Vermits een schuif-bewerking over een vast aantal bits17 wordt geımplementeerd met behulp vanbekabeling, worden er geen transistoren gebruikt. Het combineren met enig ander component zal bijge-volg nooit winst opleveren (het combineren zal immers altijd nieuwe logica introduceren, tenzij de originelebewerkingen niet optimaal werden geımplementeerd).

Uiteindelijk compatibiliteitsgrafe Nu we een groot aantal combinaties hebben uitgeprobeerd bekomenwe de compatibiliteitsgrafe of Figuur 5.37. Op de prioriteitsranden staat de winst in transistors per bit.

Optimaliseren van een meervoudige compatibiliteitsgraaf Bij de compatibiliteitsgraaf hebben wede max-cut methode gebruikt om tot een goed resultaat te komen. Dit algoritme is echter minder geschiktvoor compatibiliteitsgrafes met prioriteitsranden met drie of meer knopen. Het algoritme werkt minder goedvanaf het moment dat de winst op een prioriteitsrand voor drie of meer knopen verschilt van de som van dewinsten van prioriteitsranden tussen twee van de knopen. Daarom zullen we gebruik maken van een gretig18

algoritme. We zoeken de prioriteitrand met de meeste winst. Alle betrokken knopen worden vervolgens ineen aparte partitie ondergebracht. De knopen samen met prioriteitsranden die betrokken zijn in minstenseen van de knopen worden vervolgens uit de grafe verwijderd waarna we het proces herhalen.

Algoritme 5 formaliseert het principe. In het algoritme beschouwen we V , de verzameling van oorspron-kelijke bewerkingen. In het geval van het leidend voorbeeld is V dus:

V0 = abs1, abs2,min,max1,max2,−,+, shr1, shr3 (5.27)

E is de verzameling van prioriteitsranden. We stellen een element e ∈ E voor als een verzameling knopene ⊆ V . Bijgevolg is E ⊆ P (V ). l : E → N ten slotte is een functie die de prioriteitsranden afbeeldt op een

17Merk op dat dit niet geldt voor een schuif-operatie over een variabel aantal bits, hiervoor wordt een schuifoperator gebruikt(zie Subsectie 3.3.6 op pagina 88).

18Engels: greedy.


abs1

abs2

min

max1 max2 +

- shr 3

shr 1

2 14

14

32

92

28

34 22

54

Figuur 5.37: De uiteindelijke compatibiliteitsgrafe bij het samenvoegen van bewerkingen.

Algorithm 5 Het bepalen van sterke samengestelde functionele eenheden.

1: procedure CalculatePartition(V,E,l) . Berekenen van een sterke partitie2: P ← ∅ . Initiele partitionering gebaseerd op uitvoer.3: while V 6= ∅ ∧ E 6= ∅ do . Er zijn nog knopen en bogen over over4: e? ← argmaxe∈E l (e) . Bereken de prioriteitsrand met de grootste winst.5: V ← V \ e? . Verwijder de knopen die betrokken zijn met e?.6: E ← E \ e|e ∈ E ∧ e ∩ V 6= e . Verwijder de prioriteitsranden met knopen buiten V .7: P ← P ∪ e? . Voeg de knopen toe als partities.8: end while9: for v ∈ V do . Er zijn nog knopen over, maar geen bogen

10: P ← P ∪ v . Voeg de knoop toe als enkelvoudige partitie.11: end for12: return P . De uiteindelijke partitie.13: end procedure

geheel getal die de winst19 voorstelt. In het leidend voorbeeld zijn E en de functie l dus:

E0 : l =

abs1,min : 2, abs1,min,− : 28, abs2,max1,max2,−,+ : 92abs2,max1,max2 : 34, abs2,max1,max2,+ : 54, min,− : 14

max1,max2 : 32, max1,max2,+ : 22, −,+ : 14

(5.28)

Met X : f de set X ′ waarbij elk element x ∈ X verreikt is met de waarde f (x). Het element met dehoogste waarde in E0 is abs2,max1,max2,−,+ met 92 transistoren winst per bit. We nemen bijgevolgdeze prioriteitsrand en voegen deze toe aan de partitie-verzameling:

P1 = abs2,max1,max2,−,+ (5.29)

We verwijderen vervolgens de knopen uit V en de interfererende prioriteitsranden uit E:

V1 = abs1,min, shr1, shr3 (5.30)

E1 : l = abs1,min : 2 (5.31)

19De winst drukt men niet noodzakelijk uit in transistoren per bit: in het geval van een ontwerp op een FPGA zal menbijvoorbeeld het aantal logische blokken nemen.


Er blijft nog een prioriteitsrand over die we bijgevolg selecteren. We voegen deze toe aan de partitie enverwijderen de relevante knopen en bogen:

P2 = abs2,max1,max2,−,+ , abs1,min (5.32)

V2 = shr1, shr3 (5.33)

E2 : l = ∅ (5.34)

We merken dat de verzameling met prioriteitsranden E2 leeg is. We voegen de resterende knopen bijgevolgals enkelvoudige partities toe:

P3 = abs2,max1,max2,−,+ , abs1,min , shr1 , shr3 (5.35)

Nu we deze partitionering hebben gerealiseerd, kunnen we een nieuwe processor implementeren. Figuur 5.38toont de realisatie na het minimaliseren van de functionele eenheden.

R t1a

bc 00011011

R t2d

ef 00011011

R t6g

h 01

abs&min abs&max&+&- shr 3 shr 1

Figuur 5.38: Implementatie van het datapad na optimalisatie van de bewerkingen.

Verbindingen samenvoegen (“bus sharing”)

Niet alleen transistoren bepalen de kostprijs in een processor. Ook de bedrading vormt een niet te onder-schatten kost. Doorgaans bevatten registers echter een groot aantal bits: 16, 32 of 64 bits vormen geenuitzondering. Wanneer we dus een groot aantal verbindingen moeten leggen tussen de registers en de functi-onele eenheden loopt de kostprijs dus wel op. Daarom tracht men meestal dezelfde verbinding te gebruikenom data van de registers naar de functionele eenheden te brengen. Dit concept wordt dan ook bus sha-ring genoemd: het delen van verbindingen. Om het aantal verbindingen te verminderen, moeten we echtermultiplexers of tri-state buffers introduceren. Het verminderen van de verbindingen komt dus met een kost-prijs. Anderzijds bevatten sommige functionele eenheden zelf al multiplexers. Wanneer we twee of meerverbindingen kunnen samenvoegen die op de data-ingangen staan van een multiplexer van een functioneleeenheid, kan deze multiplexer worden gereduceerd of zelfs worden geelimineerd. Figuur 5.39 illustreert hetprincipe van bus sharing. In plaats van de originele twee verbindingen bekomen we na de transformatieeen verbinding die gedeeld wordt door de twee registers. Om te voorkomen dat beide registers tegelijk dataop de bus plaatsen voorzien we multiplexers. Indien een functionele eenheid aanvankelijk met behulp vaneen multiplexer kiest vanuit welk register data kan worden uitgelezen, kan deze bij het samenvoegen van deverschillende registers worden geelimineerd. In dit opzicht is het soms zelfs mogelijk om van deze operatieeen neutrale operatie te maken. Merk echter op dat een 2-naar-1 multiplexer 12 transistoren per bit kost,terwijl een tri-state buffer 10 transistoren per bit kost. In het voorbeeld maken we dus 8 transistoren perbit verlies. Dit impliceert echter niet dat we altijd verlies maken: stel dat verschillende functionele eenhedenmet behulp van een multiplexer het uit te lezen register bepaalden, kan het samenvoegen van verbindingenzelfs winst opleveren.


RR1

RR2

FU

a

⇒

RR1

a

RR2

b

FU

Figuur 5.39: Het samenvoegen van verbindingen kan multiplexers elimineren.

Compatibiliteitsgrafe Net als de twee vorige optimalisaties zullen we opnieuw gebruik maken van eencompatibiliteitsgrafe. In deze compatibiliteitsgrafe zijn de knopen logischerwijs de verbindingen. Een eersteprobleem is dat er twee soorten verbindingen zijn: operanden (van registers naar functionele eenheden) enresultaten (van functionele eenheden naar registers). Omdat de twee soorten verbindingen geen effect opelkaar hebben, worden ze apart geoptimaliseerd. We zullen dus twee compatibiliteitsgrafes aanmaken. Tweeverbindingen zijn incompatibel wanneer ze in dezelfde toestand actief20 gebruikt worden en gegevens van eenverschillende aansturing dragen. Met aansturing bedoelen we een register bij een operand en een functioneleeenheid bij een resultaat. Tot slot dienen we ook de prioriteitsranden te introduceren. Er is een voorkeurom twee verbindingen te gebruiken wanneer ze de aansturing delen (en dus tri-state buffers besparen) ofeenzelfde gebruiker21 hebben (en dus multiplexers besparen).

Om een compatibiliteitsgrafe op te stellen, zullen we twee nieuwe tabellen introduceren: een operand-tabel en een resultaten-tabel. Deze tabellen bevatten in de verticale dimensie de verbindingen van hetspecifieke type (operanden of resultaten) en in de horizontale dimensie de verschillende toestanden die hetalgoritme doorloopt. Een cel wordt gemarkeerd wanneer in de gegeven toestand de verbinding actief gebruiktwordt. We zullen dit doen op basis van het algoritme op Figuur 5.22 op pagina 177 en de verbindingen opFiguur 5.38.

In toestand S0 wordt de data ingelezen in de registers t1 en t2. Bijgevolg gebruiken we 2 verbindingen:r1 : In1 → t1 en r4 : In2 → t2. We markeren dan ook deze cellen in Tabel 5.17(b). In toestand S2 wordtde absolute waarde van beide registers berekend en wordt het resultaat opnieuw in de registers opgeslagen.Hiervoor wordt de data van registers t1 en t2 respectievelijk naar FU1 en FU2 geleid. Bijgevolg zijn deverbindingen o2 : t1 → FU1.1 en o6 : t2 → FU2.2 actief. Omdat het resultaat ook terug in de registersmoet worden geladen, zijn ook resultaten-verbindingen actief: r2 : FU1 → t1 en r5 : FU2 → t2. Analoogberekenen we de actieve verbindingen van de andere verbindingen en bekomen de waarden in Tabellen5.17(a) en 5.17(b).

Op basis van de opgestelde tabellen kunnen we de compatibiliteitsgrafes opstellen. Twee verbindingenzijn immers incompatibel wanneer er een kolom bestaat waar beide verbindingen tegelijk actief zijn en deaansturing verschilt. Zo kunnen we uit Tabel 5.17(a) dat o1 compatibel is met alle andere verbindingen: deverbinding is actief in toestand S7, een toestand waarin geen enkele andere verbinding actief is. o2 is echterwel incompatibel met andere verbindingen. o2 is immers actief in toestanden S1 en S2. In die toestandenzijn volgende verbindingen actief: o3, o4, o6. Van deze verbindingen wordt o4 ook aangestuurd door registert1. De verbindingen o3 en o6 worden echter aangestuurd door register t2. Bijgevolg is o2 incompatibel met

20Een verbinding wordt uiteraard altijd gebruikt en zal altijd een signaal overbrengen. Met actief bedoelen we dat hetresultaat ook effectief zal gebruikt worden. Bij bijvoorbeeld de resultaten betekent dit dat de data in de registers zal wordengeladen.

21Een gebruiker is een functionele eenheid in het geval van een operand en een register in het geval van een resultaat.


(a) Operand-tabel.

# Verbinding S0 S1 S2 S3 S4 S5 S6 S7

o1 t1 → Out •o2 t1 → FU1.1 • •o3 t2 → FU1.2 •o4 t1 → FU2.1 • • •o5 t6 → FU2.1 •o6 t2 → FU2.2 • • • • •o7 t1 → FU3 •o8 t6 → FU4 •

(b) Resultaten-tabel.

# Verbinding S0 S1 S2 S3 S4 S5 S6 S7

r1 In1→ t1 •r2 FU1→ t1 •r3 FU2→ t1 • •r4 In2→ t2 •r5 FU2→ t2 • • •r6 FU3→ t2 •r7 FU1→ t6 •r8 FU4→ t6 •

Tabel 5.18: Operand- en resultaten-tabel van het leidend voorbeeld.

o3 en o6. Analoog berekenen we alle incompatibiliteitsranden van de operanden en de resultaten:

Io = 〈o2, o3〉 , 〈o2, o6〉 , 〈o3, o4〉 , 〈o4, o6〉 , 〈o5, o6〉 , 〈o7, o8〉 (5.36)

Ir = 〈r1, r4〉 , 〈r2, r5〉 , 〈r3, r7〉 , 〈r6, r8〉 (5.37)

Vervolgens berekenen we de prioriteitsranden. o1 wordt aangestuurd door register t1. Andere operanden diedoor dit register worden aangestuurd zijn o2, o4 en o7. We hoeven bij eenzelfde aansturing niet te controlerenop het bestaan van een incompatibiliteitsrand. Eenzelfde aansturing is immers een voldoende voorwaardeom te stellen dat deze niet zal bestaan. o1 wordt verder gebruikt door Out. Vermits dit de enige verbindingis die hiervan gebruik maakt, levert het delen van de gebruiker geen extra prioriteitsranden op. We tekenenbijgevolg prioriteitsranden tussen o1 en o2, o4 en o7. Vervolgens beschouwen we verbinding o4 op basisvan de aansturing vinden we prioriteitsranden met o1, o2 en o7. Daarnaast is er een andere verbinding diedezelfde gebruiker deelt: o5. Omdat beide verbindingen niet tegelijk actief zijn, is er geen sprake van eenincompatibiliteitsrand. Daarom tekenen we ook een prioriteitsrand tussen o4 en o5. Indien we dit procesverder zetten bekomen we de volgende prioriteitsranden:

Po = 〈o1, o2〉 , 〈o1, o4〉 , 〈o1, o7〉 , 〈o2, o4〉 , 〈o2, o7〉 , 〈o3, o6〉 , 〈o4, o5〉 , 〈o4, o7〉 , 〈o5, o8〉 (5.38)

Pr = 〈r1, r2〉 , 〈r1, r3〉 , 〈r2, r3〉 , 〈r2, r7〉 , 〈r3, r5〉 , 〈r4, r5〉 , 〈r4, r6〉 , 〈r5, r6〉 , 〈r7, r8〉 (5.39)

De compatibiliteitsgrafen van de twee types verbindingen worden voorgesteld in Figuren 5.40(a) en 5.40(b).Nadat we de max-cut methode op de grafen toepassen bekomen we de volgende partities:

Po = o1, o2, o4, o5, o7 , o3, o6, o8 (5.40)

Pr = r1, r2, r7, r8 , r3, r4, r5, r6 (5.41)

Uiteindelijke implementatie


o1

o2

o3

o4

o5

o6

o7

o8

(a) Operanden (registers naar functionele een-heden).

r1

r2 r3

r4

r5

r6

r7 r8

(b) Resultaten (functionele eenheden naarregisters).

Figuur 5.40: De compatibiliteitsgrafes bij het samenvoegen van verbindingen.

Registers samenvoegen in registerbank (“register port sharing”)

Registers voorzien niet enkel logica om gegevens op te slaan. Er is ook logica vereist om nieuwe data opte slaan of om de data uit te lezen. We kunnen echter opmerken dat niet steeds alle registers hun data inelke toestand beschikbaar moeten stellen of nieuwe gegevens moeten opslaan. Door registers te groeperenin een registerbank kunnen we besparen op de implementatie van deze functies. Verder kunnen we hetaantal multiplexers en tri-state buffers mogelijk reduceren omdat het aantal ingangen en uitgangen van eenregisterbank beperkter zijn. Dit proces, ook wel register port sharing genoemd, zullen we in deze subsectiebespreken.

Alvorens we het aantal registers kunnen reduceren dienen we eerst te onderzoeken hoeveel lees- en schrijf-poorten22 we dienen te introduceren voor de registerbank(en). Hiervoor stellen we eerst een registertoe-gangstabel ofwel “Register Access Table” op. Op basis van deze tabel kunnen we dan opnieuw minimaliserenmet bijvoorbeeld de max-cut methode of in eenvoudige gevallen zelfs exhaustief zoeken.

Registertoegangstabel Een registertoegangstabel is een tabel met in de verticale dimensie de verschil-lende registers en de horizontale dimensie de verschillende toestanden. Een cel wordt gemarkeerd als leeg,lees (R), schrijf (W) of lees/schrijf (RW). De cel specificeert of we in de gegeven toestand uit het gegevenregister gegevens uitlezen en/of wegschrijven. We kunnen een registertoegangstabel opstellen met behulp vanhet ASM-schema op Figuur 5.22 of bijvoorbeeld de operanden resultaten-tabellen op Tabel 5.18. Wanneer

22Met poort wordt geen logische (AND, OR, NOT,...) poort bedoelt, maar een toegangspunt waar men data kan uitlezen ofwegschrijven.


R t1

01

R t2R t6

FU1 FU2 FU3 FU4

Figuur 5.41: De implementatie van het datapad na het minimaliseren van de verbindingen.

een operand-verbinding aangestuurd door een register ti actief is in toestand Sj , dan zetten we een R inde overeenkomstige cel van de registertoegangstabel. Wanneer er een resultaten-verbinding actief is in dezetoestand, plaatsen we een W in de cel.

Zo zien we in Tabel 5.17(a) dat in toestand S0 dat geen enkele verbinding actief is. Bijgevolg plaatsenwe in de kolom van toestand S0 geen R. In toestand S1 zijn de operand-verbindingen o2 en o6 actief. Deovereenkomstige register die aansturen zijn t1 en t2. We plaatsen dus in de rijen t1 en t2 in kolom S1 een R.Analoog berekenen we de leestoegang van de andere cellen:

R =

〈t1, S1〉 , 〈t1, S2〉 , 〈t1, S3〉 , 〈t1, S4〉〈t1, S6〉 , 〈t1, S7〉 , 〈t2, S1〉 , 〈t2, S2〉 , 〈t2, S4〉〈t2, S5〉 , 〈t2, S6〉 , 〈t6, S3〉 , 〈t6, S5〉

(5.42)

We berekenen op een gelijkaardige manier de schrijftoegang van de verschillende registers. Met behulp vanTabel 5.17(b) kunnen we vaststellen dat in toestand S0 de resultaten-verbindingen r1 en r4 actief zijn. Vermitsr1 en r4 data laten inlezen in register t1 en t2, schrijven we W in de cellen 〈t1, S0〉 en 〈t2, S0〉. In toestand S1

zien we opnieuw activiteit op de verbindingen naar t1 en t2 bijgevolg schrijven we opnieuw W in de volgendekolom. Wanneer we dit proces verder toepassen, bekomen we de volgende lijst van schrijftoegangen:

W =

〈t1, S0〉 , 〈t1, S1〉 , 〈t1, S2〉 , 〈t1, S6〉〈t2, S0〉 , 〈t2, S1〉 , 〈t2, S3〉

〈t2, S4〉 , 〈t2, S5〉 , 〈t6, S2〉 , 〈t6, S3〉

(5.43)

De uiteindelijke registertoegangstabel staat in Tabel 5.19.

Een registerbank bevat een set van registers. Een belangrijke vraag is hoeveel lees en schrijfpoorten wemoeten voorzien in een registerbank vermits dit in grote mate de kostprijs zal bepalen. De aantallen wordenbepaald door de registers die de registerbank vertegenwoordigt. In elke toestand wordt er immers dataingelezen en weggeschreven in deze registers. Het aantal leespoorten is dan ook gelijk aan het maximale aantal


Register S0 S1 S2 S3 S4 S5 S6 S7

t1 - W R W R W R - R - - - R W R -t2 - W R W R - - W R W R W R - - -t6 - - - - - W R W - - R - - - - -

Tabel 5.19: Registertoegangstabel van het leidend voorbeeld.

leesoperaties van de betrokken registers in een bepaalde toestand. Analoog stelt men het aan schrijfpoortengelijk aan het maximale aantal schrijfoperaties van deze registers in een toestand.

We zullen dit concept illustreren met twee voorbeelden. Stel dat we een registerbank opstellen die deregisters t1 en t6 groepeert. Vermits in toestand S2 naar beide registers wordt geschreven, moeten wetwee schrijfpoorten voorzien. Vermits de registerbank slechts twee registers vertegenwoordigt kan dit aantalonmogelijk groter worden. Verder kunnen we ook vaststellen dat in toestand S3 uit de twee registers datawordt uitgelezen. Bijgevolg is het aantal leespoorten ook gelijk aan twee.

Indien we een registerbank met de drie registers t1, t2 en t6 beschouwen is de situatie echter anders.Er bestaat immers geen enkele toestand waar uit alle registers tegelijk data wordt uitgelezen. Evenminbestaat er een toestand waarin data in alle betrokken registers wordt weggeschreven. In elke toestand zijn ermaximum twee leesbewerkingen en twee schrijfbewerkingen. We dienen dus 2 leespoorten en 2 schrijfpoortente voorzien, terwijl we drie registers beschouwen.

Alvorens de registers samen te voegen in een registerbank, zullen we eerst onderzoeken of het wel interessantis om alle registers in eenzelfde registerbank onder te brengen. Misschien is het interessanter om bijvoorbeeldtwee of drie registerbanken te voorzien. Het feit dat we slechts drie registers beschouwen, laat ons toe allemogelijkheden te onderzoeken. Er zijn in totaal 5 partities:

Pregisterbank =

t1 , t2 , t6t1 , t2, t6t1, t2 , t6t1, t6 , t2t1, t2, t6

(5.44)

Het aantal lees- en schrijfpoorten per partitionering in registerbanken staan in Tabel 5.20. We kunnenvaststellen dat het groeperen van alle registers in een registerbank de meeste voordelige implementatie is.

Registerbanken # Leespoorten # Schrijfpoorten # Poorten

t1 , t2 , t6 1 + 1 + 1 = 3 1 + 1 + 1 = 3 6t1 , t2, t6 1 + 2 = 3 1 + 2 = 3 6t1, t2 , t6 2 + 1 = 3 2 + 1 = 3 6t1, t6 , t2 2 + 1 = 3 2 + 1 = 3 6t1, t2, t6 2 = 2 2 = 2 4

Tabel 5.20: Registerbank-configuraties voor het leidend voorbeeld.

Vergelijking van de verschillende optimalisaties

Om de verschillende optimalisaties samen te vatten, presenteren we Tabel 5.21 die de implementaties na deverschillende optimalisaties samenvat. We drukken de kostprijs uit volgens twee systemen: het aantal tran-sistoren bij een ASIC implementatie en het aantal logische blokken wanneer we de processor implementerenop een FPGA. Verder bepalen we ook het aantal verbindingen. We delen het aantal transistoren verder


Minimalisatie Transistoren Logische cellen VerbindingenReg FU R→F F→R Tot. Reg FU Tot.

Origineel 484 234 0 0 718 11 14 25 20Registers 132 234 66 432 6 14 20 12Functionele Eenheden 132 140 320 5 9 14 7Verbindingen 132 140 378 3 9 12 4Registerbank 132 140 326 3 9 12 4

Tabel 5.21: Vergelijking van de kostprijs na de verschillende optimalisaties.

op in vier categorieen: registers, functionele eenheden, registers naar functionele eenheden en functioneleeenheden naar register. De laatst twee bepalen het aantal transistoren die betrokken zijn in de tri-statebuffers aan de uitgangen van de aansturing en de multiplexers aan de ingangen van de ontvangers. In hetgeval van een FPGA kunnen we enkel een onderscheid maken tussen registers en functionele eenheden. Dereden is dat een FPGA altijd multiplexers voorziet aan de in en uitgangen en we bijgevolg er de logica tussenregisters en functionele eenheden geen extra logische blokken vereist. Merk op dat de kostprijs telkens is uit-gedrukt per bit. Indien de registers bijvoorbeeld 32 bit getallen voorstellen moet men de kostprijs ongeveervermenigvuldigen met 32 om een benaderende kostprijs uit te rekenen.

5.4.4 Andere optimalisaties

Minimaal instructiewoord

De verzameling van stuursignalen noemt men doorgaans het instructiewoord. Het is immers een verzamelingvan bits die voor het datapad de operatie die moet worden uitgevoerd verder specificeert. Een typischdatapad bestaat uit een of meer registerbanken, een paar tellers, een paar afzonderlijke registers, een ofmeer aritmetische logische eenheden (ALU), een schuifoperator en een vergelijker. Al deze componentenintroduceren stuursignalen. Figuur 5.42 toont een voorbeeld van hoe zo’n instructiewoord er kan uitzien.Per bit bevat de figuur een korte beschrijving van de betekenis van de bit.

R

31

L

30

C

29

COE

28

S

27

WA2

26

WA1

25

WA0

24

WE

23

RA2

22

RA1

21

RA0

20

RE1

19RF

OE1

18

Teller Registerbank schrijf Registerbank lees 1

RA2

17

RA1

16

RA0

15

RE2

14RF

OE2

13

R

12

L

11

ROE

10

F2

9

F1

8

F0

7

AOE

6

SH2

5

SH1

4

SH0

3

D

2

SOE

1

OOE

0

Registerbank lees 2 Register ALU Barrel shifter

Figuur 5.42: Een voorbeeld van een instructiewoord.

In de meeste gevallen kan men echter het instructiewoord verkleinen met behulp van verschillende as-sumpties. Een eerste assumptie is bijvoorbeeld dat niet alle functionele eenheden (ALU, schuifregister,...)tegelijk actief zullen zijn. In plaats van voor elke functionele eenheid een reeks bits in het instructiewoord tevoorzien, kunnen we enkele bits reserveren die bepalen of een sequentie aan stuursignalen bedoeld zijn voorde ene functionele eenheid of de andere.

Een andere reductie omvat het gebruik van tri-state buffers. Tri-state buffers verhinderen dat uitvoervan registers of functionele eenheden tegelijk op dezelfde verbindingen worden gezet. Bijgevolg zijn destuursignalen van de tri-state buffers exclusief: slechts een van de stuursignalen van de tri-state buffers is


tegelijk actief. In plaats van voor iedere tri-state buffer een bit in het instructiewoord te voorzien, kunnenwe in bits een getal uitdrukken die bepaalt welke tri-state buffer nu de data op de verbinding moet zetten.Voor n tri-state buffers wordt het instructiewoord dus gereduceerd van n bits naar dlog2 ne bits.

Bij wijze van voorbeeld zullen we nog enkele voorbeelden geven gebaseerd op het instructiewoord vanFiguur 5.42.

1. De eerste operandbus bevat ofwel gegevens afkomstig van de de registerbank (leespoort 1) ofwel hetregister.We kunnen dus ofwel RFOE1 ofwel ROE elimineren. We besparen 1 bit.

2. De tweede operandbus bevat ofwel gegevens afkomstig van de de registerbank (leespoort 2) ofwel deteller.We kunnen dus ofwel RFOE2 ofwel COE elimineren. We besparen 1 bit.

3. In een registerbank is het signaal “read-enabled (RE)” altijd gelijk aan het stuursignaal op het tri-state buffer (RFOE). We kunnen dus voor beide leespoorten ofwel REi ofwel RFOEi elimineren. Webesparen 2 bits (we beschouwen immers twee leespoorten).

4. De resultaatbus bevat het resultaat van ofwel de ALU ofwel de schuifoperator. We kunnen dus opnieuwhet stuursignaal van een van de tri-state buffers wegwerken: ofwel AOE ofwel SOE. We besparen 1bit.

5. De ALU en barrelshifter worden nooit tegelijk gebruik (de resultaten kunnen immers niet tegelijk opde bus worden geplaatst). Op basis van de tri-state buffer die de output op de bus plaatst, weten wewelke component actief is. De overige bits die voor de instructie instaan (F0, F1, F0, SH2, SH1, SH0en D), kunnen worden gedeeld. We besparen bijgevolg 3 bits.

6. Bij de teller zijn de increment (C) en het inladen van de nieuwe waarde (L) exclusief. We besparen 1bit.

Op basis van deze maatregelen hebben 9 bits op het instructiewoord bespaard.

“Chaining”: meerdere bewerkingen per klokcyclus

Naast de eerder beschreven optimalisaties, kunnen we ook het ASM-schema zelf aanpassen. De argumentatieom dit te doen is een analyse van het tijdsgedrag. Elke klokcyclus wordt de data van de registers uitgelezenen voeren de functionele eenheden hierop bewerkingen uit. Niet alle functionele bewerkingen vereistenechter dezelfde hoeveelheid tijd om het resultaat te berekenen. We kunnen bijvoorbeeld denken aan deschuifoperaties met een vast aantal bits. Vermits hierbij geen logica moet worden geımplementeerd, wordtzo’n operatie in theorie onmiddellijk uitgevoerd. We kunnen echter analyseren wat er vervolgens met degegevens van de functionele eenheid zal worden gedaan. Indien het mogelijk is om de volgende operatie indezelfde klokcyclus uit te voeren kan dit tot besparingen leiden. Het groeperen van operaties die na elkaarmoeten worden uitgevoerd noemen we chaining. Figuur 5.43(b) illustreert dit principe.

Wanneer we het ASM-schema en het datapad aanpassen zoals op Figuur 5.43, voeren we een chainingtransformatie uit. In het ASM-schema worden twee operaties f1 en f2 uitgevoerd. We kunnen de tweeoperaties samenvoegen in een operatie f met f (x, y) = f2 (f1 (x) , y). Alvorens we een chaining-transformatiekunnen uitvoeren, moeten we echter een voorwaarde controleren: alle operanden moeten beschikbaar zijnalvorens we de gegroepeerde functie uitvoeren. Indien z bijvoorbeeld nog niet beschikbaar is in de eerstetoestand, kunnen we f nog niet berekenen.

“Multicycling” en “Pipelining”: meerdere klokcycli per bewerking

Multicycling Ook in omgekeerde richting kunnen we mogelijk winst boeken. Door een instructie “uit tesmeren” over verschillende toestanden kunnen we mogelijk de schakeling goedkoper maken, of de kloksnelheidverhogen. Dit concept noemen we multicycling. In het leidend voorbeeld dienen we bijvoorbeeld het verschilte berekenen tussen twee getallen. Het verschil wordt doorgaans gerealiseerd met een functionele eenheid die


y ← f1 (x)

t ← f2 (y, z)

⇒ t← f2 (f1 (x) , z)

(a) ASM-schema.

R x R y R z Rt

f1 f2

⇒

R x R z Rt

f2f1

f

(b) Datapad.

Figuur 5.43: De chaining-transformatie.

dit in twee “stappen” zal uitrekenen: eerst nemen we de negatie van het tweede getal, waarna we vervolgensmet behulp van een keten van full adders het eerste getal en de negatie van het tweede getal optellen. Omdatde twee stappen een sequentieel karakter vertonen23, zouden we ervoor kunnen opteren om twee toestandente voorzien. We voorzien dus geen aftrekker, maar voorzien twee functionele eenheden: een opteller en eencomponenten die de negatie van het getal kan berekenen.

t ← f (x, z) ⇒

y ← f1 (x)

t ← f2 (y, z)

(a) ASM-schema.

R x R z Rt

f

⇒

R x R y R z Rt

f1 f2

(b) Datapad.

Figuur 5.44: De multicycling-transformatie.

Figuur 5.44 beschrijft de transformatie die gepaard gaat met de introductie van multicycling. In hetASM-schema wordt een complexe functie f uitgerekend die we kunnen opsplitsen in twee functies f1 en f2

zodat f (x, y) = f1 (f2 (x) , y). In het ASM-schema wordt de functie uitgesmeerd over twee toestanden. Dithoeft niet te betekenen dat we de tweede toestand moeten introduceren: we kunnen bijvoorbeeld ook def2-bewerking naar de volgende (al bestaande) toestand schuiven. In het datapad wordt in het algemeen eenregister geıntroduceerd. Dit hoeft echter niet de betekenen dat we ook effectief een nieuw register zullennodig hebben. Door de minimalisatie van de variabelen, kunnen we eventueel het geıntroduceerde registerelimineren. Als voorwaarde om deze transformatie uit te voeren stellen we een voorwaarde: de bewerkingmoet zijn uitgevoerd alvorens andere bewerkingen het resultaat zullen gebruiken als operand.

De voordelen van multicycling zijn tweeledig. Allereerst kunnen we mogelijk hardware besparen in defunctionele eenheden. Een opteller is immers goedkoper dan een aftrekker. Wanneer elders in het algoritmebijvoorbeeld nog een negatie moet worden berekend, kunnen we mogelijk de geıntroduceerde functioneleeenheid delen waardoor dit geen extra kosten met zich meebrengt. Verder valt op te merken dat wanneerwe operaties kunnen herleiden naar kleinere basis-instructies, de kans groter is dat complexe operaties eendeel van die basis-instructies zullen delen. Een eerste winst is dus mogelijk de kostprijs van de functioneleeenheden.

23Men kan de twee stappen niet tegelijk uitvoeren of ze laten overlappen


Daarnaast kunnen we mogelijk de kloksnelheid opdrijven. Stel bijvoorbeeld dat de aftrekker de traagsteoperatie is in heel het proces, zal deze functionele eenheid de kloksnelheid bepalen. Het is echter mogelijkdat alle overige functionele eenheden significant sneller resultaten berekenen. Door een verschil-operatie opte splitsen in twee operaties die apart sneller presteren kunnen we mogelijk de kloksnelheid opdrijven. Indiende verschil-operatie vrij zeldzaam is, kan dit dus de doorvoer van het algoritme significant verhogen.

Multicycling komt in de meeste gevallen echter met een kostprijs. Allereerst valt in de praktijk de snelheids-winst meestal tegen. Stel bijvoorbeeld dat in het algoritme alleen verschil-bewerkingen worden uitgevoerd.De periode van het kloksignaal is in de realisatie van dit algoritme 1 v24. We kunnen deze periode vervolgensopdelen in 3 delen25: 0.35 v om de negatie te berekenen, 0.35 v voor de optelling en 0.3 v om de waardein het register in te klokken. Merk op dat de tijd in dit fictieve voorbeeld mooi verdeeld is over de tweedeeloperaties en dus ideaal is voor multicycling. Toch zullen we de kloksnelheid niet kunnen verdubbelen:de tussenresultaten (de negatie van het tweede getal) moeten immers ook in een register worden opgeslagen.De periode van een deelbewerking wordt bijgevolg 0.65 v. We besparen bijgevolg 35% op de klokfrequentie.

Een tweede kost heeft betrekking op de kostprijs. De kostprijs van de functionele eenheden kan in principeafnemen, maar introduceert extra logica ter hoogte van de controller. We introduceren immers een nieuwe“deel-toestand”: een toestand waarin we de negatie van de tweede operand hebben berekend. Verder dienenwe mogelijk nieuwe registers te introduceren om tussenresultaten in weg te schrijven26. Bovendien intro-duceren we mogelijk nieuwe verbindingen, multiplexers en tri-state buffers om de resultaten van de extrafunctionele eenheden in de correcte registers weg te schrijven.

Multicycling is echter wel een populaire techniek voor operaties die buitenproportioneel veel tijd vragen.Dit is meestal het geval bij bijvoorbeeld RAM-geheugen. Men merkt op dat sinds de jaren ’80 de processor-snelheid significant werd opgedreven terwijl de RAM-geheugens deze evolutie niet hebben gevolgd. Indienwe dus een toestand zouden voorzien om een cel uit het RAM-geheugen uit te lezen, zou de processorsnelheidhoogstens gelijk zijn aan deze van het RAM-geheugen. Een processor en geheugen werken dan ook eerderonafhankelijk van elkaar. Op geregelde tijdstippen geeft de processor een opdracht aan het RAM-geheugenom een cel uit te lezen en vervolgens enkele toestanden later te controleren of de gegevens reeds in de regis-ters of cache zitten. De 80x86 instructieset kent zelfs “prefetching”-instructies: instructies waarmee men deopdracht kan geven om data in de cache in te laden zodat op het moment dat de data effectief nodig is, dezemeteen kan worden uitgelezen.

Pipelining Het uitsmeren van instructies over verschillende toestanden maakt ook een ander effect moge-lijk: pipelining. Pipelining is een uitvoeringsstrategie naast sequentiele uitvoering en parallelle uitvoering.

t

(a) Sequentieel.

t

(b) Parallel.

. . .

. . .

. . .t

(c) Pipelining.

Figuur 5.45: De verschillende uitvoeringsstrategieen: sequentieel, parallel en pipelining..

24We introduceren hier een tijdseenheid v: de tijd die het proces nodig heeft om een verschil uit te rekenen en in te klokken.25De verhoudingen van de delen is louter fictief en dient enkel ter illustratie.26In het geval van een verschil-bewerking is dit niet het geval omdat we na de negatie van de tweede operand, de originele

operand niet meer nodig hebben. In het algemeen is dit echter niet het geval.


Figuur 5.45 toont de verschilende uitvoeringsstrategieen naast elkaar. Als voorbeeld gebruiken we hetwassen van kledij. In het geval van sequentiele uitvoer beschikken we over een wasmachine, een droogkasten een strijkijzer. Kledij wordt eerst in de wasmachine gestopt, vervolgens gedroogd en daarna gestreken.Wanneer we een grote hoeveelheid kledij moeten wassen, herhalen we dit mechanisme. Indien elke opdracht∆t in beslag neemt, betekent dit dus dat we O (3 · k ·∆t) tijd nodig hebben om alles te verwerken met k dehoeveelheid kledij. Dit proces staat beschreven in Figuur 5.45(a).

Men kan de doorvoer echter opdrijven door meer infrastructuur te voorzien. Indien we elke machine inhet n-voud aankopen en over n arbeiders beschikken, kunnen we de doorvoer opdrijven met ongeveer O (n).De gemiddelde tijd die het wassen van alle kledij in beslag neemt wordt dus gereduceerd tot O (3 · k ·∆t/n).Het probleem is echter dat de kosten ook stijgen met een factor O (n). Bovendien wordt de versnelling nietaltijd gerealiseerd. Meestal is er een vorm van boekhouding nodig die bepaalt wie welke taak precies zaluitvoeren27. Dit proces staat beschreven in Figuur 5.45(b).

Tot slot is er pipelining. In het geval van pipelining beschikken we opnieuw over een wasmachine, droogkasten strijkijzer. In plaats van echter alles na elkaar uit te voeren, werken de machines continu. Op het momentdat de wasmachine immers klaar is, verhuist de gewassen kledij naar de droogkast, maar stopt men nieuwekledij in de wasmachine. Het gevolg is dat wanneer er s stappen in het proces zijn, we de doorvoer kunnenopdrijven met O (s) ten opzichte van het sequentieel proces, zonder de kosten voor de infrastructuur op tedrijven. Dit proces staat beschreven in Figuur 5.45(c). Men kan pipelining ook vergelijken met het principevan de lopende band: we voorzien telkens een machine voor elke bewerking en het resultaat schuift vanmachine naar machine.

t ← f (x, z)

t ← f (x, z)

⇒

y ← f1 (x)z2 ← z1

y ← f1 (x)z2 ← z1

t← f2 (y, z2)

t ← f2 (y, z2)

(a) ASM-schema.

R x

R z

Rtf ⇒

R x R y

R z1R z2

Rt

f1

f2

(b) Datapad.

Figuur 5.46: De pipelining-transformatie.

Figuur 5.46 beschrijft het transformatieproces bij pipelining. Wanneer twee identieke operaties dicht opelkaar volgen, kunnen we beide bewerkingen uitsmeren in de tijd en tegelijk parallelle uitvoer introduceren.De transformatie van het datapad is erg gelijkaardig aan dat van multicycling. Merk echter op dat we ookeen nieuw register introduceren voor z. De reden is dat terwijl we de f2 voor de eerste keer uitvoeren, we ookde operanden van de tweede instructie moeten uitvoeren. We kunnen een pipelining-transformatie uitvoerenop voorwaarde dat alle resultaten zijn uitgerekend alvorens ze door andere bewerkingen worden uitgevoerden de instructies betrokken in het pipelining proces onafhankelijk van elkaar kunnen worden uitgevoerd.

27De maximaal te realiseren versnelling wordt geformaliseerd met de “Wet van Amadahl”.


We kunnen pipelining op vier niveaus toepassen:

1. Functionele eenheden: in dit niveau splitsen we de bewerkingen op in deelbewerkingen en bewaren wede tussenresultaten in registers.

2. Datapad: indien we werken met een trage registerbank (bijvoorbeeld RAM-geheugen) gebruiken wemeestal ook pipelining.

3. Controller.

4. Het ASM-schema: we kunnen het ASM-schema herschrijven, bijvoorbeeld door de verschil-instructieop te splitsen in een negatie-instructie en een optelling-instructie. Dit hoeft niet te betekenen datwe meer toestanden introduceren: sommige omstandigheden laten toe dat we een onderdeel van deinstructie gewoon doorschuiven naar de volgende toestand. Op basis van het aangepaste schema zullenwe mogelijk meer hardware introduceren, maar door het minimaliseren van het datapad kunnen we ditmogelijk terug ontdubbelen.

In moderne processoren implementeert men pipelining op nagenoeg alle niveaus in de zogenaamde generischeinstructiecyclus. De generische instructiecyclus is een beschrijving in welke onderdelen een gegeven instructiewordt uitgevoerd:

1. Lees een instructie.

2. Bereken de adressen (indien de instructie operanden uit bepaalde geheugenadressen haalt).

3. Lees de operand(en) uit.

4. Voer de bewerking uit.

5. Schrijf het resultaat weg.

Pipelining komt echter ook met enkele problemen. Om de snelheid effectief met O (s) op te drijven, dienende deelstappen precies evenveel tijd te vragen. In de praktijk is het niet eenvoudig een proces zo op te delen.Wanneer dit niet te realiseren valt geldt de “Wet van de zwakste schakel”: het traagste deelproces bepaalthoelang het duurt alvorens data zal worden uitgelezen. Verder is pipelining ook enkel interessant wanneerwe kort na elkaar een groot aantal maal de operatie moeten uitvoeren. Indien we slechts eenmaal de operatieuitvoeren blijft de rekentijd ongeveer dezelfde. We kunnen dus stellen dat de doorvoer (“throughput”)wordt verhoogd, maar de vertraging (“latency time”) ongeveer dezelfde blijft. Net als bij multicyclingdienen we ook opnieuw extra registers te voorzien om de tussenresultaten in op te slaan. Deze registerverhogen de kostprijs en zullen bovendien een deel van de tijdswinst tenietdoen omdat het wegschrijven vantussenresultaten in de registers ook tijd vergt.

Ins1

Ins1

Ins1

Ins2

Ins2

Ins2

Ins3

Ins3

Ins3

Ins4

Ins4

Ins4

. . .

. . .

. . .

t

Figuur 5.47: Terugkoppeling verhindert pipelining.


We kunnen ook niet zomaar elk proces uitvoeren volgens de pipelining uitvoeringsstrategie. Pipeliningvereist dat de opeenvolgende stappen eerder onafhankelijk van elkaar kunnen werken. Stel bijvoorbeeld datde tweede operatie echter een operand nodig heeft die in de vorige instructie wordt berekend, treedt ereen probleem op. Bij deze vorm van terugkoppeling verliezen we de performantie-winst. De pipeline wordtgestopt tot het resultaat van de eerste operatie beschikbaar is om vervolgens de tweede operatie uit te voeren.Figuur 5.47 illustreert dit principe. Stel dat instructie 2 bijvoorbeeld t4 ← t1 − t3 berekent en instructie3 vervolgens t5 ← t2 − t4. We kunnen opmerken dat instructie 3 als operand een resultaat gebruikt datwordt berekend door instructie 2. Bijgevolg worden er geen nieuwe instructies in de pipeline geınjecteerd,tot instructie 2 volledig is uitgevoerd.

5.4.5 Besluit

Als algemene conclusie kunnen we stellen dat het zeer moeilijk is om de optimale implementatie te vinden.Dit aspect wordt bovendien bemoeilijkt omdat de optimalisaties op verschillende niveaus elkaar beınvloeden:de minimalisatie van het aantal registers kan ertoe leiden dat we de functionele eenheden op een anderemanier zullen optimaliseren. Daarom zullen we ons meestal tevreden stellen met heuristieken: benaderendemethodes zoals bijvoorbeeld het max-cut algoritme. Sommige methodes zijn echter meer geschikt vooroptimalisatie bij het ene niveau tegenover het andere. Bovendien is de beste keuze afhankelijk van de gekozentechnologie: als we een schakeling implementeren op een FPGA zullen we logische blokken optimaliseren inplaats van transistoren.

Het algoritme herschrijven biedt ook veel mogelijkheden. Soms kunnen we hierdoor pipelining mogelijkmaken of een functionele eenheid alsnog hergebruiken. Wanneer we echter het algoritme aanpassen, moetenwe ook opnieuw het datapad minimaliseren.

Minimaliseren van het datapad is bijgevolg een complex proces waarbij het nagenoeg onmogelijk is omeen globaal optimale implementatie te bekomen.

5.5 Tijdsgedrag

Hoewel een niet-programmeerbare processor in wezen een sequentiele schakeling is, en we het tijdsgedragomtrent sequentiele schakelingen al hebben besproken, zullen we in deze sectie tijdsaspecten bespreken dieenkel relevant zijn voor niet-programmeerbare processoren.

5.5.1 Kritisch pad

Een belangrijk aspect is deze van het kritisch pad. We hebben al besproken dat het kritisch pad bepaalthoe snel een verandering aan de ingang effect heeft op de uitgang. In een processor is er niet altijd eenin- of uitgang. Wel moet op het moment van een klokflank de correcte data op de ingang van de registersstaan. Bovendien dienen we ook de controller in rekening te brengen die waar nodig de functionele eenhedenconfigureert, en ook bepaalt welke data er bijvoorbeeld uit de registers wordt uitgelezen.

Concreet komt het kritische pad nog altijd neer op het langste combinatorische pad. De verleiding isgroot om hierbij enkel het datapad in rekening te brengen: namelijk vanuit een register door een functioneleeenheid naar een register. Om te beantwoorden aan de formele definitie dient men dus de controller mee inrekening te brengen. Bovendien is het nagenoeg altijd zo dat het kritische pad zowel door de controller en hetdatapad loopt. Een typisch kritisch pad vertrekt dan ook vanuit bijvoorbeeld de ingang van een register diede toestand van de controller bijhoudt. Hierdoor wordt een nieuwe toestand in de registers van de controllergeklokt. Vervolgens loopt het kritische pad doorheen de uitvoer-logica van de controller naar bijvoorbeeldeen register van waaruit data dan door een functionele eenheid loopt om vervolgens ofwel terug te keren alsstatus-signaal naar de controller of als resultaat-signaal naar de flipflop.

5.5. TIJDSGEDRAG 213

Het concreet bepalen van het kritisch pad is geen sinecure. Meestal stelt men tabellen op per functioneleeenheid/register om te bepalen hoelang het signaal onderweg is, en wordt op basis van de tabellen dan hetkritische pad bepaald. Meestal kan men het kritisch pad ook niet meteen vertalen naar de klokfrequentie:men dient meestal enige buffer te nemen die te wijten is aan meta-stabiliteit, lange lijnen, enzovoort.

5.5.2 Verschoven kloksignalen (“clock skew”)

In het vorige hoofdstuk hebben we het reeds gehad over “skew”. Een speciaal geval van skew die in de contextvan processoren belangrijk wordt is clock skew, dit is de verschuiving van het kloksignaal. Processoren zijnimmers grote en complexe schakelingen. Een constante doorheen de schakeling is echter dat de controller, deregisters en eventuele RAM-geheugens allemaal afhankelijk zijn van een en hetzelfde kloksignaal. Het gevolgis dat een verandering die aanvangt bij de klok zelf niet altijd op alle plaatsen in de schakeling op hetzelfdemoment wordt waargenomen. Oorzaken van de vertraging zijn:

1. Vertraging op de verbinding

(a) Een verbinding die over de volledige schakeling loopt is relatief lang. Hoewel de snelheid van eenelektrisch signaal twee derde van de lichtsnelheid bedraagt, is de frequentie zeer hoog en kan eenrelatief kleine afstand toch een significant tijdsverschil betekenen in verhouding tot de periodevan de klok.

(b) Wanneer we werken met een FPGA doorloopt een kloksignaal meestal een of meerdere schakelma-trices. Deze matrices zijn opgebouwd uit poorten die een significante vertraging teweeg brengen.

2. Combinatorische logica op het klokpad

(a) Sommige schakelingen werken met een clock-enabled. Een clock-enabled werkt door het kloksigaaldoor een AND-poort te sturen. Deze AND-poort levert een extra vertraging op.

(b) Een Klokbuffer: een poort mag slechts een beperkte fan-out hebben. Het kloksignaal wordt echtergepropageerd naar een zeer groot aantal componenten. Men propageert het signaal dan ook dooreen hierarchische structuur van klokbuffers. Wanneer componenten echter niet aangesloten zijnop dezelfde diepte van deze hierarchie, ontstaat er een tijdsverschil.

3. Verschillende daal- en stijgtijden: door verschillende capacitieve belasting (tussen bijvoorbeeld tweeklokbuffers) zijn de vertragingen op lange lijnen – zelfs al zijn ze identiek in lengte – niet altijd gelijk.Wanneer een bepaalde lijn bijvoorbeeld een grote oppervlakte aan metaal vertegenwoordigt, stijgt decapaciteit van de virtuele condensator.

Clock enabled bij laadbare registers In registers werken we vaak met een clock enabled. Dit is eenbelangrijke oorzaak van clock skew en kan zelfs leiden tot het inklokken van foute waarden: wanneer dedata aan de ingang zelf afhankelijk is van de klok en sneller wordt aangepast dan de het signaal door deAND-poort propageert, wordt soms de nieuwe waarde opgeslagen. Er zijn dan ook grofweg twee technieken

Q

Q

D

ClkClk

D

CE

(a) Met multiplexer.

Q

Q

D

ClkClkCE

D

(b) Met clock enabled.

Figuur 5.48: Laadbaar registers

om een selectief op bepaalde klokflanken nieuwe waarden op te slaan:

1. Met behulp van een multiplexer (zoals bij Figuur 5.48(a));


2. Met behulp van een AND-poort (zoals bij Figuur 5.48(b)).

Zoals zo vaak is geen van de twee technieken altijd te verkiezen: beide implementaties hebben hun voor- ennadelen. Zo kost register met multiplexer 6 transistoren per bit meer dan een AND-poort. Ook het energie-verbruik ligt hoger: het kloksignaal komt immers in de flipflop terecht waar een groot aantal transistorenzullen schakelen. Dit verbruik is nutteloos wanneer we geen nieuwe gegevens willen inklokken en we dusopnieuw dezelfde waarde op de data-ingang aanbieden. Anderzijds is een multiplexer een vrij veilige optie.De nadelen van een AND-poort zijn dat dit typisch clock-skew introduceert omdat het kloksignaal duidelijkvertraging oploopt wanneer het door de AND-poort propageert. Wanneer het kloksignaal hoog is, mag de“clock enabled” bovendien niet zomaar worden veranderd: de flipflop zou dit immers interpreteren als eenveranderend kloksignaal. Het vereist dus wat ontwerpervaring om implementatie met een AND-poort veiligte stellen.

5.5.3 Synchroniseren van asynchrone ingangen

Ondanks voorzichtig ontwerp van een niet-programmeerbare processor, komt invoer doorgaans van buitende schakeling. Deze data wordt misschien ook door een synchrone schakeling – bijvoorbeeld een processor –aangeboden, maar het synchroniseren van verschillende klokken is onmogelijk. Zelfs in eenzelfde synchroneschakeling kunnen bovendien synchronisatieproblemen ontstaan, bijvoorbeeld wanneer bepaalde delen vande schakeling sneller resultaten berekenen. Dergelijke effecten maken het echter niet evident om logica teontwikkelen: meestal gaan we ervan uit dat tijdens berekeningen van de processor de ingang niet zomaareen andere waarde aanneemt. Stel dat de processor afwisselend de twee getallen aan de ingang optelt enaftrekt maken we meestal de assumptie dat halverwege de optelling de operanden niet veranderen. Omasynchrone veranderingen op te vangen gebruikt men doorgaans flipflops die de waarden aan de ingangenop vaste momenten inlezen. De data-uitgangen van deze flipflops zijn gedurende een klokflank stabiel.

Dit is echter de theorie en ook hier kunnen dingen foutlopen. Een signaal moet immers een tijdje op deingang van een flipflop worden aangelegd voor de klokflank om het correct in te klokken. Indien de gegevensop tijd worden aangelegd is er dus geen probleem. Wanneer de gegevens echter kort voor de klokflank wordenaangeleverd kunnen er verschillende problemen ontstaan:

• De gegevens komen te laat waardoor de oude gegevens na de klokflank op de uitgang van de flipflopsworden aangelegd. De gegevens komen dan meestal met vertraging van een klokflank wel beschikbaar.Dit wordt geıllustreerd in periode a op Figuur 5.49(b).

• Een deel van de gegevens wordt correct ingeklokt, een ander deel wordt foutief ingelokt, dit kan ertoeleiden dat de flipflops invoer aanleggen die zelfs niet mogelijk werd geacht. Dit wordt geıllustreerd inperiode b op Figuur 5.49(b).

• Een of meer flipflops komen in een metastabiele toestand terecht: er wordt noch 0 noch 1 op de ingangaangelegd. Het duurt een zekere tijd voor een flipflop uit dergelijke toestand gaat. Dit effect kan ookoptreden wanneer de nieuwe data al lang op de flipflop wordt aangelegd. Dit wordt geıllustreerd inperiode c op Figuur 5.49(b).

Aan de eerste twee problemen is weinig te verhelpen. In de praktijk zal men dit meestal oplossen met eensynchronisatiesignaal: men stuurt bijvoorbeeld het kloksignaal mee op een van de verbindingen tussen detwee circuits, of in het geval er maar af en toe data op de ingang komt te staan kondigt men dit aan doorde ingangen met de regelmaat van de klok te laten veranderen van signaal28.

Metastabiliteit is echter een probleem waar men wel iets aan kan doen. Uit Subsectie 4.2.1 weten weimmers dat de kans dat een schakeling zich na een zekere tijd nog steeds in een metastabiele toestandbevindt, exponentieel daalt met de tijd. Als we dus een redelijk termijn wachten, kunnen we vrij zekerstellen dat de de binnenkomende signalen niet metastabiel zijn. Deze tijd noemt men de metastability

28Dit is het geval bij Ethernet (IEEE 802.3).

5.5. TIJDSGEDRAG 215

Q

Q

D

Clk

F1

Q

Q

D

Clk

F2

Synchroonsequentieel

signaal

Externesignalen

a1 s1

a2 s2

(a) Schakeling.

t

s1 01

s0 01

a1 01

a0 01

Clk 01

a b c

(b) Problemen met synchronisatie.

Figuur 5.49: Synchronisatie.

resolution time tr. Logischerwijs wensen we dat tr ≥ tmeta met tmeta de tijd om uit een metastabieletoestand te geraken. tr hangt echter van drie andere parameters af:

tr = tclock − tcomb − tset-up (5.45)

Met tclock de periode van de klok, tcomb de tijd die het signaal nodig heeft om door de combinatorischeschakeling te propageren van het circuit en tset-up de set-up tijd om de resultaten op te slaan in de flipflopsvan het circuit29.

Q

Q

D

Clk

Q

Q

D

Clk

asynchroon comb.

clock

Figuur 5.50: De verschillende componenten van de “metastability resolution time”.

De klokperiode tclock staat in principe niet vast: we kunnen zelf de kloksnelheid bepalen, maar wensenmeestal een hoge kloksnelheid. Bovendien wordt de kloksnelheid ook beperkt in de mate dat invoer beschik-baar komt: wanneer we bijvoorbeeld geluid verwerken moet we 40 kHz aan metingen kunnen aanbieden. Inhet geval we echter een niet-programmeerbare processor beschouwen, staat de toepassing meestal vast en dusook de invoersnelheid van die toepassing. De kloksnelheid verder opdrijven heeft dan geen zin. We kunnendus de klokperiode altijd proberen te maximaliseren.

Men kan ook inzetten op technologie. Snelle flipflops hebben een kortere set-up tijd en bovendien verkleintook de halfwaardetijd: hierdoor zullen we dus ook sneller de metastabiele toestand verlaten. Bijgevolg wordttmeta kleiner. Een nadeel van deze flipflops is dat ze meer vermogen verbruiken.

Extra hardware kan ook een bijdrage leveren. Wanneer de processor de data moet verwerken met eenbepaalde doorvoersnelheid, maar de vertraging niet zo belangrijk is30 kan men in plaats van een flipflop, eenopeenvolging aan flipflops plaatsen. Men geeft hierdoor meer tijd aan het signaal om uit de metastabieletoestand te komen maar behoudt tegelijk een sterke (interne) klokfrequentie.

Indien de ingangssignalen zelf met hoge frequentie worden aangeleverd kunnen we n flipflops plaatsen diede synchronisatie uitvoeren. Een signaal propageert dus eerst door n flipflops en heeft dus meer tijd om uit

29Bijvoorbeeld om op basis van de invoer een nieuwe toestand aan te nemen.30De vertraging is bijvoorbeeld wel van belang bij real-time applicaties zoals live televisie-uitzendingen en Skype.


Q

Q

D

Clk

Q

Q

D

Clk

FFn

Q

Q

D

Clk

FF1. . .

comb.

clk

async.

(a) Zelfde kloksignaal.

Q

Q

D

Clk

Q

Q

D

Clk

FF2

Q

Q

D

Clk

FF1

comb.

clk/n clk

async.

(b) Trager kloksignaal.

Figuur 5.51: Metastabiliteit oplossen door een opeenvolging van flipflops.

de metastabiele toestand te geraken. In dat geval is de resolutie-tijd:

tr = n ·(tclock − tset-up

)− tcomb (Figuur 5.51(a)) (5.46)

Meestal volstaan 2 of 3 flipflops. Een abstracte implementatie staat beschreven in Figuur 5.51(a).

Soms verandert het signaal niet zo snel. Denk bijvoorbeeld aan een processor die een deling moet uit-rekenen. Meestal zal de interne klok significant sneller klokken omdat er veel operaties moeten wordenuitgevoerd om het quotient uit te rekenen, terwijl de invoer trager wordt aangepast, bijvoorbeeld maar om

de 10 klokflanken. In dat geval kunnen we werken met twee flipflops die aan een lagere (in dit geval1

10van

de originele klokfrequentie nieuwe waardes opslaan. De resolutie-tijd wordt dan:

tr = n · tclock + tclock − tcomb − 2 · tset-up (Figuur 5.51(b)) (5.47)

Een abstracte implementatie staat beschreven in Figuur 5.51(b).

Hoofdstuk 6

Programmeerbare Processoren

Mensen hebben met computers gemeen dat ze ook niets bereikenzonder goede programmeurs.“

”- Toon Verhoeven, Nederlands aforist (??-??)

In dit hoofdstuk bespreken we programmeerbare processoren. Dezeprocessoren verschillen van de niet-programmeren processoren om-dat een gebruiker een programma – een reeks van instructies – kanuitvoeren op de processor en bijgevolg in grote mate het algoritmedie de processor uitvoert zelf kan bepalen. Centrale processoreenhe-den (CPU’s) zijn hiervan slechts een subset van de programmeerbareprocessoren. We bespreken eerst de hoe een instructie eruitziet enhoe we een schakeling kunnen ontwerpen om deze instructies uittoe voeren. Cruciaal hierbij zijn de verschillende adresseermodi.Vervolgens beschouwen we de twee grote instructie-families: RISCen CISC. We zullen voor beide een instructieset ontwerpen en deverschillende aspecten die hierbij komen kijken bespreken.

6.1 De Programmeerbare Processor . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

6.2 Instructies en Velden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.1 Programma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.2 Instructie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219

6.2.3 Instructieformaat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

6.2.4 Generische Instructiecyclus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

6.2.5 Uitvoeringssnelheid . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

6.2.6 Adresvelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

Instructies met 3 adresvelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222



Instructies zonder adresvelden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

Instructies met registerbank-adressen: dubbele adressering . . . . . . . . . . . . . . 224

Besluit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

6.2.7 Adresseermodi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224

217

218 HOOFDSTUK 6. PROGRAMMEERBARE PROCESSOREN

Impliciete adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Onmiddellijke adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Directe adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Indirecte adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

Relatieve adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

Geındexeerde adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Geındexeerde adressering met autoincrement/autodecrement . . . . . . . . . . . . 227

6.3 Processorontwerp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

6.3.1 RISC en CISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

CISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

RISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228

Evolutie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

6.3.2 Ontwerpcyclus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

6.3.3 Complex Instruction Set Computer (CISC) . . . . . . . . . . . . . . . . . . . . . . 229

Ontwerp Instructieset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

Instructieset-stroomschema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Allocatie datapadcomponenten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238

ASM-schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Ontwerp Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

Ontwerp Datapad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242

De 8086 Microprocessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245

De 8051 Microcontroller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

6.3.4 Reduced Instruction Set Computer (RISC) . . . . . . . . . . . . . . . . . . . . . . 246

Ontwerp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246

De ARM7 Microprocessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

De ARM11 Microprocessor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

6.1 De Programmeerbare Processor

We zullen in deze sectie het verschil bespreken tussen een niet-programmeerbare processor (zie Hoofdstuk 5)en een programmeerbare processor. Algemeen is deze grens eerder vaag. Ook bij een niet programmeerbareprocessor zullen de controller en het datapad meestal beınvloed worden door signalen van buiten de schake-ling. Sommige technici kunnen door deze invoer te manipuleren de processor een algoritme laten uitvoerenwaarvoor de schakeling niet ontworpen was.

Een duidelijke grens kunnen we trekken bij de controller. Bij conventie stellen we dat een processor niet-programmeerbaar is wanneer de schakeling wordt aangestuurd met een vaste controller. In het geval wedus een ander algoritme willen uitvoeren zullen we een ander controller moeten implementeren om het uitte voeren. Bij een programmeerbare processor dient men de controller niet aan te passen. De controllerbeschikt immers over een geheugen waarin het programma geladen kan worden. Door het geheugen aan tepassen zal de controller het datapad anders aansturen waardoor een ander algoritme kan worden uitgevoerd.We kunnen dus stellen dat de eindige toestandsautomaat die in de controller werd geımplementeerd vaststaat, onafhankelijk van het ingeladen programma. Het geheugen waaruit zo’n controller leest noemen wehet programmageheugen. De gegevens die van de controller naar dit geheugen stuurt worden het adres,de programmateller of de program counter (PC) genoemd. De data van het programmageheugen naar decontroller noemen we de instructie.

6.2. INSTRUCTIES EN VELDEN 219

Merk op dat de definitie hierbij geen concrete uitspraak doet over hoe een programma of instructie er preciesdient uit te zien. De definitie impliceert bijvoorbeeld niet dat de processor elk te beschrijven algoritme moetkunnen uitvoeren. Hierbij kunnen we bijvoorbeeld denken aan een “Graphical Processing Unit (GPU)”. EenGPU is een programmeerbare processor die gespecialiseerd is in grafische taken. De instructieset is dan ookeerder beperkt tot grafische operaties. Hoewel men dergelijk processoren meestal niet kan programmerenom bijvoorbeeld Dijkstra’s algoritme uit te voeren, is de processor wel programmeerbaar.

Pro

cessor

Om

gev

ing

Datapad

Controller

Programma-geheugen

status-sig

nalen

inst

ruct

iew

oor

dcontrole-ingangen controle-uitgangen

data-ingangen data-uitgangen

adres

inst

ruct

ie

Figuur 6.1: De structuur van een programmeerbare processor.

Figuur 6.1 toont hoe een programmeerbare processor er in grote lijnen uitziet. Merk op dat het enigeverschil tussen deze figuur en Figuur 5.1(a) op pagina 149 de introductie van een programmageheugen is.

6.2 Instructies en Velden

Nu we de structuur van een programmeerbare processor hebben voorgesteld, zullen we in deze sectie deverschillende aspecten en terminologie van een programma bespreken.

6.2.1 Programma

Een algemeen aanvaarde definitie voor een programma is een sequentie van instructies. De instructies zijnop zo’n manier bepaald en geordend dat ze samen een complexe (en nuttige) taak uitvoeren. In dit opzichtbevat een sequentie van instructies dus dezelfde informatie als de eindige toestandsmachine van de controllerbij een niet-programmeerbare processor.

6.2.2 Instructie

Een instructie is een reeks van bits die de informatie van een toestand in het ASM-schema of een toestand inde eindige toestandsautomaat van de controller voorstellen. Door pipelining kan een instructie of multicyclingkan een instructie echter meerdere klokcycli duren. Dit kan men implementeren door bijvoorbeeld een anderevolgende instructie te kiezen. Om een toestand voor te stellen zijn drie types informatie vereist:

• De aansturing van het datapad: het bepalen van de stuursignalen naar de verschillende functioneleeenheden, registers, tri-state buffers en multiplexers betrokken in het datapad.


• Data-uitwisseling: sommige instructies bepalen welke informatie er ingeladen of weggeschreven wordtnaar (externe) geheugens.

• De volgende instructie: de meeste algoritmes bevatten lussen en voorwaardelijke gedeeltes. Dezecontrole wordt geımplementeerd doordat de instructies (impliciet) bepalen wat de volgende instructiezal zijn.

Een instructie moet niet elk type informatie expliciet specificeren. We kunnen bijvoorbeeld denken aanhet bepalen van de volgende toestand: meestal wordt een programma zo gestructureerd dat de volgendeinstructie bijna altijd op het volgende adres staat. In dat geval zullen enkel instructies die afwijken van dezeregel dit moeten specificeren.

Notatie van een instructie Om instructies uit te drukken bestaan er twee typische notaties: de mne-monische notatie en de actie-notatie. In de mnemonische notatie specificeert men eerst de operatie gevolgddoor het doel1 en de operanden. Verder worden zowel het doel en de operanden gespecificeerd aan de handvan adressen. Een typische instructie is bijgevolg add A B C. Dit voorbeeld is een instructie uit de 80x86

instructieset. Mnemonische notatie wordt dan ook vaak gebruikt in assembleertalen (80x86, ). Actie-notatiespecificeert daarentegen eerst het doel, meestal gevolgd door bijvoorbeeld een pijl met daarna de functie ende operand. Een concreet voorbeeld van een instructie volgens deze notatie is Mem[A] <- Mem[B]+Mem[C].Actie-notatie is populair bij hardwarespecificatietalen.

6.2.3 Instructieformaat

De mnemonische notatie en de actie-notatie zijn manieren om instructies voor te stellen zodat ze leesbaarzijn voor mensen. In digitale logica wordt een instructie enkel voorgesteld door een sequentie aan bits. Deontwerper van een processor dient dan ook een instructieformaat te specificeren: een beschrijving hoe eensequentie bits een instructie bepaalt. Men kan dit formaat natuurlijk vrij bepalen, maar meestal beoogt meneen structurele opbouw: de instructie wordt onderverdeeld in velden: groepen van bits waar een betekenisof een subtaak aan wordt toegekend. In de meeste instructieformaten komen volgende velden voor:

• Instructietype: een groep bits die de klasse van de instructie aangeeft (bijvoorbeeld een sprongbevel,een bewerking, een geprivilegieerde instructie,...)

• Opcode ofwel operation code: een groep bits die de bewerking voorstellen (bijvoorbeeld een optelling,vermenigvuldiging,...)

• Adres: een groep bits die de locatie van een operand of een resultaat specificeert. Een adres hoeftechter niet beperkt te zijn tot de locatie in een (extern) geheugen: ook registers en registerbankenkunnen soms worden geadresseerd.

• Adresseermode: een adresseermode bepaalt hoe het adres gespecificeerd in bits wordt omgezet ineen fysisch adres. Zo kan de adresseermode bijvoorbeeld bepalen dat het adres een register uit deregisterbank specificeert of dat de adressen indirect2 moeten worden berekend.

• Constante: bewerkingen zoals een optelling tellen soms een constante op bij een register. In dat gevalmoet de constante in de instructie worden ingebed.

Men dient op te merken dat een veld niet noodzakelijk een vaste lengte heeft of slechts eenmaal voorkomt. Stelbijvoorbeeld dat de adresseermode bepaalt dat de gegevens uit een registerbank moeten uitgelezen worden,verwachten we dat het adres korter zal zijn dan wanneer we het adres uit een RAM-geheugen halen. Verderzal men bij sommige operaties twee of meer operanden moeten selecteren. In dat geval is het dus mogelijk dathet adresveld meerdere keren voorkomt. Sommige processoren voorzien ook een instructieformaat waarbijmen twee of meer bewerkingen kan specificeren die dan parallel worden uitgevoerd. In dat geval komt deopcode dus twee of meer keer voor.

1De plaats waar het resultaat zal worden opgeslagen.2Bij indirecte adressering leest men de waarde van het geheugen uit op de gegeven locatie. Die waarde bepaalt dan de locatie

van de effectieve waarde.


6.2.4 Generische Instructiecyclus

Een processor voert een instructie doorgaans uit in vijf stappen. Deze stappen noemt men de generischeinstructiecyclus. De stappen zijn:

1. Lees de instructie in: het programmageheugen wordt uitgelezen en de instructie wordt in het instruc-tieregister (IR) opgeslagen. De programmateller wordt verhoogd.

2. Bereken de adressen: Op basis van de adresseermodi en de adressen in de instructie worden de echteadressen bepaald. Een adres uit een registerbank zal er dus anders uitzien dan een adres uit hetRAM-geheugen.

3. Lees de operanden: de adressen van de operanden worden uitgelezen en weggeschreven in tijdelijkeregisters.

4. Voer de bewerking uit: op basis van de data in de operand-registers en de opcode kan men de relevantebewerking op de relevante data uitvoeren. Het resultaat wordt in een tijdelijk register geplaatst.

5. Schrijf het resultaat weg: het resultaat wordt weggeschreven in een registerbank of RAM-geheugen(indien dit relevant is voor de bewerking).

Deze cyclus wordt eindeloos herhaald en leent zich meestal erg goed tot pipelining: enkel wanneer de volgendeinstructie een operand moet inlezen die bepaald wordt door een instructie die kort ervoor is uitgevoerd moetde pipeline worden onderbroken. Men kan een sprongbevel uitvoeren door in de instructie de programmatelleraan te passen.

6.2.5 Uitvoeringssnelheid

De uitvoeringssnelheid van een instructie hangt in grote mate af van twee factoren:

• De snelheid van het datapad

• Het aantal toegangen tot extern geheugen.

We kunnen de snelheid van het datapad doorgaans opdrijven door meer hardware te voorzien die bijvoorbeeldbewerkingen in parallel uitvoeren. Het aantal toegangen tot extern geheugen kunnen we dan weer verlagendoor kleine en simpele instructies te voorzien waardoor elke instructie maar een beperkt aantal operaties ophet geheugen uitvoert.

De grootte van een instructie is echter een trade-off. Wanneer we grote instructies voorzien met een grootaantal bits laten we de programmeur toe om een complexe taak in zo’n instructie te specificeren. Bijgevolgverwachten we dat een programma uit een klein aantal van dergelijke instructies zal bestaan. Omdat deinstructies echter complex zijn, verwachten we een traag datapad en veel geheugentoegangen. Wanneer deprocessor enkel simpele instructies aanbiedt kan het datapad deze snel uitvoeren, maar een programma zaleen groot aantal instructies bevatten. De complexiteit van een instructieset wordt dan ook soms uitgedruktin het aantal adresvelden.

6.2.6 Adresvelden

In deze subsectie zullen we enkele instructiesets bespreken volgens het aantal adresvelden. Bij de verschillendeinstructiesets zullen we aantal geheugentoegangen berekenen die nodig zijn om de functie (a+ b) × (a− b)uit te rekenen. Deze operatie wordt doorgaans niet als een instructie aangeboden (tenzij bij processoren dietaken uitvoeren waarbij deze bewerking zeer regelmatig zou voorkomen). We zullen dan ook uitgaan van eenalgemene instructieset die de optelling (Add-instructie), aftrekking (Sub-instructie) en vermenigvuldiging(Mul-instructie) voorziet.


Alvorens we de instructiesets met elkaar kunnen vergelijken, zullen we eerst enkele aannames moetenmaken over hoe gegevens en instructies kunnen worden ingelezen. We zullen uitgaan van een woordlengte3

w. We maken de assumptie dat een instructie zonder geheugenadressen in een woord4 kan worden opgeslagen.Het geheugen omvat 2w adressen, bijgevolg telt het geheugen w ·2w bits en is elk adres voor te stellen met eenwoord. Een instructie met k geheugenadressen kan dus worden opgeslagen in k+ 1 woorden. We vergelijkende instructiesets op basis van geheugentoegangen. Dit zijn dus het aantal toegangen om de instructie uit telezen samen met het uitlezen en wegschrijven van gegevens die in de instructie worden gespecificeerd.

Instructies met 3 adresvelden

Een instructieset met drie adresvelden bepaalt meestal een adres voor het resultaat en twee adressen voorde operanden. Bijvoorbeeld de Add a b c instructie berekent de optelling van de gegevens die op de geheu-genplaatsen b en c staan en plaatst het resultaat dus in adres a. Om (a+ b) × (a− b) dus uit te rekenenzullen we volgend programma uitvoeren:

Add c a b

Sub x a b

Mul c c x

Per instructie voorzien we dus 4+3 geheugentoegangen. 4 instructietoegangen per instructie, 2 leesoperatiesvoor de operanden en 1 schrijfoperatie. Omdat we 3 instructies uitvoeren vereist het programma dus 21geheugentoegangen. We kunnen echter opmerken dat in de laatste instructies we tweemaal hetzelfde adresvermelden. Dit soort instructies vormen dan ook de argumentatie om soms instructies met twee adresveldente gebruiken.


Instructiesets met twee adresvelden zijn vrij populair. 80x86 is een voorbeeld van zo’n instructieset. In zo’ninstructieset vertegenwoordigen het eerste en tweede adresveld de adressen van de operanden en het eersteveld ook het adres van het resultaat. Het eerste adres wordt bijgevolg overschreven.

Een probleem bij dit mechanisme is dat we soms na de bewerking de operanden willen kunnen hergebruikenom andere operaties uit te voeren. Zo willen we na het berekenen van a+b nog over a en b kunnen beschikkenom a−b uit te rekenen. We kunnen de waarde kopieren om dit probleem te vermijden. We kunnen de waardevan x kopieren naar adres y met behulp van twee instructies: Sub y y en Add y x. De meeste processorenvoorzien echter een kopieer instructie: de Mov-instructie. Het voordeel van deze instructie is dat naast hetophalen van de instructie slechts twee geheugentoegangen vereist zijn.

We kunnen het algoritme dan ook als volgt implementeren:

Mov c a

Add c b

Mov x a

Sub x b

Mul c x

De Mov-instructie vereist in totaal 5 geheugentoegangen, de overige instructies vereisen 6 geheugentoegangen.In totaal vereist het uitvoeren van het algoritme dus 28 geheugentoegangen. We dienen echter wel op temerken dat de instructies sneller zullen worden uitgevoerd.

3De woordlengte is het aantal bits die in een geheugen onder een adres worden opgeslagen.4Een woord is een sequentie van w bits met w de woordlengte.



We kunnen de instructieset verder reduceren tot een adresveld per instructie. Dit doen we met behulpvan een accumulator (ACC). Een accumulator is een speciaal register die dienst doet als zowel de eersteoperand en het register waar het resultaat in wordt geplaatst. Men kan deze instructieset dus vergelijkenmet de eerste instructieset, maar waarbij de eerste operator altijd een vast adres voorstelt. Het voordeelvan een accumulator is de implementatie door middel van een register: de accumulator inlezen of resultatenwegschrijven vereist bijgevolg geen geheugentoegang.

Ook wanneer we een accumulator gebruiken zullen we soms tussenresultaten tijdelijk in een andere va-riabele willen opslaan om de waarde later in te lezen. We kunnen hier geen gebruik maken van de Mov-instructie omdat het resultaat altijd vast staat: de accumulator. Daarom worden twee nieuwe instructiesgeıntroduceerd: de Load-instructie leest het adres uit en plaatst de waarde in de accumulator, de Store-instructie schrijft de waarde van de accumulator weg in het opgegeven adres. De Store-instructie is bijgevolgeen instructie waar de accumulator geen dienst doet als de ontvanger van het resultaat.

We kunnen het algoritme realiseren met volgende code:

Load a

Add b

Store x

Load a

Sub b

Mul x

Store c

Elke instructie vereist telkens 3 geheugentoegangen: 2 om de instructie uit te lezen en 1 geheugentoegangom het adres uit te lezen of de resultaten weg te schrijven. Omdat het algoritme in 7 instructies kan wordengeımplementeerd, zijn er in totaal 21 geheugentoegangen vereist.

Instructies zonder adresvelden

Sommige instructiesets bevatten geen adressen als operanden. In een dergelijk systeem moeten we echterwel een systeem implementeren die zelf de adressen voorstelt.

Een populaire methode werkt met een stapelgeheugen. In zo’n systeem beschouwen we een stapel diegroeit bij een een Load-instructie. Wanneer een instructie een berekening uitvoert worden de operanden uitde bovenste elementen van de stapel gehaald. Deze elementen worden van de stapel gehaald en het resultaatwordt vervolgens op de stapel gezet. Ook in een dergelijk systeem is er soms nood aan het opslaan vantussenresultaten om deze later te hergebruiken. Ook hiervoor gebruiken we de store operatie. De operatieneemt als argument een adres van de stapel: het aantal elementen onder de top. Ook dit kan men alseen adres zien. Men maakt echter meestal de assumptie dat deze waarde niet buitengewoon groot is ende waarde dus in de instructie kan worden meegenomen. Bijgevolg bevat de instructie dus geen adres.Omdat het bovenste gedeelte van de stapel meestal met een registerbank wordt geımplementeerd, vereisende bewerkingen bijgevolg geen geheugentoegangen.

We kunnen het algoritme implementeren met volgende instructies:

Load a

Load b

Add

Load a

Load b

Sub

Mul


Store c

Om de impact te berekenen moeten we opnieuw een onderscheid maken tussen twee soorten instructies:Load- en Store instructies vereisen twee geheugentoegangen (1 geheugentoegang om de instructie op te halenen 1 instructie om het resultaat op te halen of weg te schrijven) de overige instructies vereisen slechts eengeheugentoegang. In totaal vereist dit programma dus 13 toegangen tot het geheugen.

Instructies met registerbank-adressen: dubbele adressering

Tot slot dienen we nog te vermelden dat een adresveld niet noodzakelijk altijd een geheugenadres moetomvatten. Men kan bijvoorbeeld een bit in dit veld voorzien die bepaalt of het adres een geheugenadresspecificeert of het adres van een registerbank. Daarnaast kan de interpretatie van een dergelijk adres ookafhangen van de instructie. Moderne processoren interpreteren bijvoorbeeld vaak de adressen bij bewerkingenals registerbank-adressen en de tweede operand bij een Load- of Store-instructie als een geheugenadres.Vermits een algoritme vooral met tussenresultaten zal rekenen verwachten we een tijdswinst omdat we niettelkens de operanden uit het geheugen moeten uitlezen.

Een dergelijke instructieset kan ook instructies met variabele lengte beschouwen. Sommige instructiesomvatten immers geen geheugenadressen, andere wel. In dat geval kan de eerste instructie bijvoorbeeldaanleiding geven om het volgende woord in een instructieregister in te lezen, of de instructie meteen uit tevoeren.

Registeradressen worden meestal voorgesteld met een prefix R. In het geval van een dergelijke instructiesetziet het programma er als volgt uit:

Load R1 a

Load R2 b

Add R3 R1 R2

Sub R4 R1 R2

Mul R5 R3 R4

Store c R5

Bewerking instructies worden voorgesteld in een woord en vereisten geen extra geheugentoegang. Bijgevolgvereisen ze een geheugentoegang. Load- en Store-bewerkingen vereisen 3 geheugentoegangen: 2 bij hetinlezen van de instructie en 1 bij het inlezen of wegschrijven van de data. In totaal vereist het programmadan ook 12 keer toegang tot het geheugen.

Besluit

Er zijn verschillende instructiesets mogelijk met een verschillend aantal adresvelden. Instructies met eengroot aantal adresvelden laten compacte programma’s toe maar vereisen soms onnodig toegang tot hetgeheugen. Deze extra belasting komt in twee vormen: het inlezen van de adresvelden van de instructie enhet uitlezen of wegschrijven van data in de vermelde geheugenadressen.

Een instructieset met minder adresvelden zal minder vaak onnodig toegang tot het geheugen aanvra-gen. Anderzijds wordt het programma langer waardoor de processor meer instructies uit het geheugen metuitlezen.

6.2.7 Adresseermodi

In de loop der jaren zijn er verschillende manieren ontwikkeld om een geheugenadres te bepalen op basis vaneen adresveld. Deze methodes noemen we adresseermodi. Adresseermodi hebben als primair doel het aantalbits te reduceren die het adresveld in beslag neemt. Anderzijds laten verschillende adresseermodi soms toeom meer te realiseren per instructie en dus tot compactere programma’s te schrijven.


Ook in hogere programmeertalen maakt men impliciet gebruik van adresseermodi. We kunnen bijvoorbeelddenken aan arrays. Wanneer men in Java het tiende element van een array a wil uitlezen schrijft men a[10].Impliciet stelt men echter het adres dat tien plaatsen verder dan het begin van het record voor a ligt.Adresseermodi kunnen programma’s dus ook leesbaarder maken.

Impliciete adressering

Impliciete adressering is een adresseermode waarbij een adresveld niet vermeld wordt in de instructie maardoor de processor zelf kan worden berekend.

Dit is bijvoorbeeld het geval bij processoren met een stapelgeheugen. In een dergelijke instructieset wordende adressen afgeleid uit de toestand van de stapel: de bovenste elementen bevatten de data van de operanden.De processor rekent deze aspecten dus zelf uit.

Ook bij processoren die werken met een accumulator is dit het geval: men vermeldt immers de bestemmingvan de data niet. Dergelijke processoren bieden meestal een instructie aan om de gegevens uit de accumulatorte verwijderen: de CLRA-instructie.

Onmiddellijke adressering

Behalve in het adresveld de plaats in het geheugen te specificeren waar de data moet worden opgehaald,kunnen we ook de data zelf opslaan in een adresveld. Deze vorm van adressering noemen we onmiddellijkeadressering. Dit is bijvoorbeeld het geval wanneer we werken met constanten.

Directe adressering

Meestal lezen we operanden uit met behulp van een adres. Dit adres verwijst ofwel naar een geheugenadresofwel naar een index van een registerbank. In beide gevallen spreken we over directe adressering. Hetis meestal voordelig om een registerbank te gebruiken. Dit omwille van twee redenen: een registerbankbevat minder adressen en de toegang is sneller. Omdat een registerbank typisch 8 tot 256 registers bevat, isbijgevolg de lengte van een registeradres tussen de 3 en 8 bits, terwijl een geheugenadres typisch tussen de32 en 64 bits lang is. We besparen dus ook tijd bij het inladen van de instructie.

Indirecte adressering

Soms kennen we de plaats waar de data in het geheugen staat niet expliciet. Stel bijvoorbeeld dat we werkenmet een heap5, hangt de plaats waar de data staat meestal af van de manier hoe het programma eerder werddoorlopen. Het adres wordt dan ook ergens anders bewaard in het geheugen of een registerbank.

Indirecte adressering is een belangrijke vorm in programma’s. Naast werken met een onbekend adres laathet ook toe het adres mee te geven wanneer we bijvoorbeeld een subroutine uitvoeren die een “pointer”vereist.

Indirecte adressering maakt het mogelijk om in een instructie de operand in te lezen waarvan het adresergens in het geheugen staat. In dat geval dienen we dus het adres te specificeren waar het adres staat.

Tweemaal het geheugen uitlezen in een instructie is echter een dure operatie. Daarom zal men de adressendoorgaans in een registerbank opslaan. In dat geval spreken we dan ook van register-indirecte adressering.

5Een heap is een geheugenruimte waar men dynamisch records kan toevoegen en terug verwijderen.


opcode adres

Operand

Adres

Geheugen

(a) Indirecte adressering

opcode adres

Operand

Geheugen

Adres

Registerbank

(b) Register-indirecte adressering

Figuur 6.2: Indirecte adressering

Relatieve adressering

Hedendaagse besturingssystemen ondersteunen doorgaans multiprogramming: het tegelijk uitvoeren vanverschillende programma’s. Bijgevolg worden verschillende programma’s tegelijk in het register geladen.De compiler van een programma weet doorgaans op voorhand niet waar het programma in het geheugenzal worden ingeladen. Wanneer een programma echter een sprongbevel uitvoert, moet het adres van hetsprongbevel wijzen naar het correcte adres.

Het aangehaalde voorbeeld is een van de redenen om relatieve adressering toe te passen. Bij relatieveadressering houdt de processor een basisadres bij in een impliciet register. Dit basisadres wordt bij hetgegeven adres opgeteld om het werkelijke adres te bepalen. Het adresveld wordt in dat geval de offsetgenoemd.

opcode offset

Operand

Geheugen

Basis

Register

+

(a) Relatieve adressering

opcode adres offset

Operand

Geheugen

Basis

Registerbank

+

(b) Register-relatieve adressering

Figuur 6.3: Relatieve adressering

Naast het verzekeren van correcte spronginstructies kan relatieve adressering ook tot kortere instructie-woorden leiden. We kunnen bijvoorbeeld een registerbank voorzien die verschillende basisadressen voorziet.De basisadressen kunnen bijvoorbeeld wijzen naar datastructuren die vaak gebruikt worden. Naast eenveld die het register in de registerbank specificeert, dient men een veld te voorzien die de offset vanaf hetbasisadres voorstelt. Een dergelijke vorm van adressering noemen we register-relatieve adressering.


Geındexeerde adressering

We kunnen ook de twee velden omdraaien door het basisadres in de instructie onder te brengen en deoffset in een impliciet register of een registerbank op te slaan. Deze vormen van adressering noemen wegeındexeerde adressering. Geındexeerde adressering is vooral interessant voor gegevensstructuren met eigenindexsystemen. We denken hierbij bijvoorbeeld aan arrays, matrices, stapels, wachtrijen,... In het registerstaat immers de index van de datastructuur zelf. Bij een array is dit bijvoorbeeld i indien we het i-de elementwillen uitlezen.

opcode basis

Operand

Geheugen

Offset

Register

+

(a) Geındexeerde adressering

opcode adres basis

Operand

Geheugen

Offset

Registerbank

+

(b) Register-geındexeerde adressering

Figuur 6.4: Geındexeerde adressering

De structuur van geındexeerde adressen op Figuur 6.4 lijkt sterk op de structuur van relatieve adressenop Figuur 6.3. Het verschil is echter dat een basisadres een volwaardig adres is en dus makkelijk 32 bits telt.De offset daarentegen telt doorgaans slechts 3 tot 8 bits. Bij geındexeerde adressering zijn de instructies dusgroter.

Ook bij deze vorm van adressering kunnen we gebruik maken van een register bank. In dat geval wordthet adres van de registerbank bepaald door een veld in de instructie. Uit dit adres wordt dan de offset opge-slagen in registerbank berekend. Deze vorm van adressering noemen we naar analogie register-geındexeerdeadressering.

Geındexeerde adressering met autoincrement/autodecrement

Meestal leest men een bepaald element uit een array, matrix,... uit binnen een lus in het programma.De meeste programma’s zullen dan ook de volledige array of een significant deel overlopen. Dit gebeurtdoorgaans in een logische volgorde van links naar rechts of omgekeerd. Men kan het mechanisme achtergeındexeerde adressering uitbreiden met autoincrement en/of autodecrement. Wanneer we deze adresse-ringmode toepassen wordt het impliciete register die de offset bijhoudt na het uitvoeren van de opdrachtautomatisch opgehoogd of verlaagd. Hierdoor kan men bij een volgende instructie meteen het volgende ofvorige element in de array uitlezen zonder eerst zelf manueel het register op te hogen. Dit kan voordelig zijnomdat het uitrekenen van de nieuwe waarde voor het offset-register parallel kan gebeuren met het uitvoerenvan de instructie zelf.

Figuur 6.5 illustreert het principe. Op basis van de een de instructie kiest men welke waarde door demultiplexer stroomt, deze waarde wordt bij de originele offset opgeteld en vervolgens in het register ingeladen.Door dezelfde instructie vervolgens daarna uit te voeren, zullen we een ander geheugenadres uitlezen bij hetbepalen van de operand.


opcode basis

Operand

Geheugen

Offset

++−11

Figuur 6.5: Geındexeerde adressering met autoincrement/autodecrement.

Soms bestaat een array niet uit bytes maar uit bijvoorbeeld long integers (8 bytes). Bij sommige proces-soren kan men dan ook de staplengte bepalen door deze in een veld in de instructie te specificeren, of wegte schrijven in een speciaal hiervoor bestemd register.

6.3 Processorontwerp

Nu we de belangrijkste aspecten van een instructieset hebben besproken, zullen we het ontwerp van deprocessor zelf in detail bespreken. We zullen eerst de algemene ontwerpcyclus waarna we het ontwerpbespreken voor de twee grote families van instructiesets: CISC en RISC.

6.3.1 RISC en CISC

In de vorige sectie werden instructiesets vergeleken volgens het aantal adresvelden per instructie. Het aantaladresvelden vormt dan ook de belangrijkste basis om instructiesets in te delen in een van de twee families:de Complex Instruction Set Computer (CISC) of Reduced Instruction Set Computer (RISC).

CISC

In het geval van CISC beschouwt men een grote instructieset met complexe en trage instructies. De instruc-tieset omvat meestal een groot aantal verschillende operaties waarbij men ook een groot aantal adresseermodivoorziet. Dit leidt meestal tot een complex datapad met veel functionele eenheden registers en complexeverbindingen die de datastroom controleren. Het gevolg is dat dergelijke processoren aan een lage klokfre-quentie werken. De programma’s zijn echter vrij kort en men hoopt meestal snelheidswinst te boeken doorde operaties die worden uitgevoerd bij een operatie in parallel op het datapad uit te voeren. Typische CISCinstructiesets zijn System/360, PDP-11, VAX, Motorola 68k en 80x86.

RISC

Een RISC processor omvat een kleine instructieset die uit een klein aantal eenvoudige instructies bestaat. Eeninstructie omvat hoogstens een adresveld en meestal zijn slechts enkele adresmodi beschikbaar. Een eenvou-dige instructieset leidt echter tot een eenvoudig datapad waardoor men een hoge kloksnelheid kan aanbieden.De programma’s zijn vrij lang maar men hoopt meestal om hierdoor neven-operaties die soms ongewild wor-den uitgevoerd op een CISC processor te vermijden. Typische RISC instructiesets zijn DEC Alpha, ARM,SPARC, en MIPS.

6.3. PROCESSORONTWERP 229

Evolutie

Men merkt dat er een evolutie is van CISC processoren naar RISC processoren. Deze evolutie werd vooralgepromoot door onderzoek bij IBM dat aantoonde dat meestal een beperkte subset van de aangeboden in-structies effectief door programma’s werd gebruikt. Dit effect werd ook versterkt door de komst van compilersdie er meestal niet in slagen alle aspecten van een CISC instructieset automatisch uit te buiten. Andereaspecten die voor het gebruik van RISC processoren pleiten zijn de grootte van de chip, de energieconsumptieen de kostprijs.

6.3.2 Ontwerpcyclus

Ontwerpinstructieset

Instructieset-stroomschema

Allocatievan datapad-componenten

Bepaal hetASM-schema

Ontwerp vande controller

en het datapad

Figuur 6.6: De processorontwerp-cyclus.

Figuur 6.6 beschrijft de vijf fases bij het ontwerpen van een processor:

1. Ontwerp van de instructiecyclus: in deze fase stelt men een set van mogelijke instructies op, meestalgaan de instructies gepaard met een informele beschrijving van het effect van de instructie.

2. Instructieset-stroomschema: in deze fases worden per instructie alle betrokken operaties beschreven.De meeste instructies zullen immers verschillende effecten teweegbrengen. Bij de 80x86-instructiesetzal bijvoorbeeld naast de bewerking ook de programmateller worden opgehoogd en zullen bepaalderegisters op basis van het resultaat worden aangepast.

3. Allocatie van het datapad: op basis van de vereiste bewerkingen kunnen we bepalen welke componentenwe in het datapad zullen moeten voorzien. Dit omvat een beschrijving van de vereiste registers enfunctionele eenheden. Indien dit tot een duur datapad leidt kan men beslissen om de instructiesetopnieuw te herbekijken en begint men dus terug met fase 1.

4. Op basis van de beschikbare datapad componenten kan men een ASM-schema opstellen. Doorgaanswordt een instructie niet in een klokcyclus uitgevoerd. De verschillenden vereiste operaties wordendus uitgevoerd in verschillende toestanden in het ASM-schema. Dit schema beschrijft dan ook deverschillende registertransfers per klokcyclus.

5. Ontwerp van de controller en het datapad: op basis van het ASM-schema kunnen we vervolgens eendatapad en controller synthetiseren. De methodologie van deze synthese staat beschreven in Hoofd-stuk 5.

6.3.3 Complex Instruction Set Computer (CISC)

In deze subsectie zullen we het proces doorlopen bij het ontwerpen van een CISC processor.


Ontwerp Instructieset

In de eerste stap zullen we een CISC instructieset bepalen. We bepalen eerst de specificaties van het geheugenwaarmee de processor werkt. Bij wijze van voorbeeld zullen we een 216 × 16-bit geheugen beschouwen. Dewoordlengte is dus 16 bit en elk adres kan voorgesteld worden met behulp van 16 bits. We beschouwen ookeen registerbank met 8 registers. Elk registeradres kan dus voorgesteld worden met 3 bits.

Uit de specificaties van het geheugen kunnen we afleiden dat een adresveld bij voorkeur ook 16 bit groot is.De rest van de instructie zullen we ook voorstellen met behulp van 16 bit. We beschouwen vier verschillendetypes van instructies:

1. Registerinstructies: instructies die bewerkingen uitvoeren met 1 of 2 operanden en 1 doelregister.

2. Verplaatsinstructies: instructies die de gegevens van een register of geheugenadres kopieren naar eenregister of geheugenadres.

3. Spronginstructies: instructies die de programmateller aanpassen. Deze instructies bepalen bijgevolghet verloop van het programma.

4. Overige instructies: dit zijn instructies zoals No Operation (NOP)6.

We voorzien in een instructie dan ook twee bits om het type voor te stellen. De instructies vereisen hoogstensdrie registers. In elke registers zullen we daarom drie velden van telkens 3 bits voorzien om het doelregister– Bestemming – en de twee operandregisters Operand 1 en Operand 2 voor te stellen. Vermits een instructie16 bits telt en we in totaal reeds 11 bits hebben toegewezen, blijven er 5 bits over voor de opcode. Wehebben bijgevolg een instructieformaat gedefinieerd zoals weergegeven op Figuur 6.7.

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

Type Operatie/mode Bestemming Operand 1 Operand 2

16-bit adres/constante

Figuur 6.7: De bitstructuur van de CISC instructieset.

Het type en de opcode bepalen samen welke instructie zal worden uitgevoerd. We dienen echter nogbewerkingen toe te kennen aan de verschillende waardes. Hiervoor voorzien we Tabellen 6.1 6.2, 6.3 en 6.4die de instructies per type beschrijven.

Registerinstructies De registerinstructies worden allemaal uitgevoerd op registeradressen en worden op-gedeeld in drie categorieen: aritmetische, logische en schuifoperaties. De categorieen worden bepaald doorde eerste twee bits: wanneer o4 laag is beschouwen we een schuifoperatie, in het andere geval beschouwenwe ofwel een aritmetische of logische operatie. Bij een schuifoperatie bepaalt o3 of we naar links of naarrechts schuiven. De overige drie bits bepalen vervolgens het aantal bits waarover we schuiven. In het anderegeval bepaalt o3 of we aritmetische (laag) of logische operatie (hoog beschouwen). We delen de aritmetischeoperaties verder op in optelling/aftrekking-bewerkingen en vermenigvuldiging/deling operaties. o2 deelt deoperaties verder in zodat bij bewerkingen met twee operanden o1 laag is en we in het andere geval bewer-kingen met een operand beschouwen. We beschouwen volgende operaties: optelling, aftrekking, increment,decrement, vermenigvuldiging, deling, vierkantswortel en negatie. In het geval van logische bewerkingenbepalen de overige drie bits welke operatie we uitvoeren: AND, NAND, OR, NOR, XOR, XNOR, mask eninvert. De verschillende instructies worden voorgesteld in Tabel 6.1 samen met een formele beschrijving vande bewerking.

6De “No Operation” is een instructie die geen effect heeft. Deze instructie wordt gebruikt bij pipelining om ruimte op tevullen in de pipeline zodat instructies kunnen wachten tot andere instructies zijn uitgevoerd.


Operatie/mode Bewerking Formeel Assembleertaalo4 o3 o2 o1 o0

0 0 n2 n1 n0 Schuif rechts RF[d]←RF[s1]>>N ASR Rd Rs1 #N

0 1 n2 n1 n0 Schuif links RF[d]←RF[s1]<<N ASL Rd Rs1 #N

1 0 0 0 0 Optelling RF[d]←RF[s1]+RF[s2] ADD Rd Rs1 Rs2

1 0 0 0 1 Aftrekking RF[d]←RF[s1]-RF[s2] SUB Rd Rs1 Rs2

1 0 0 1 0 Increment RF[d]←RF[s1]+1 INC Rd Rs1

1 0 0 1 1 Decrement RF[d]←RF[s1]-1 DEC Rd Rs1

1 0 1 0 0 Vermenigvuldiging RF[d]←RF[s1]*RF[s2] MUL Rd Rs1 Rs2

1 0 1 0 1 Deling RF[d]←RF[s1]/RF[s2] DIV Rd Rs1 Rs2

1 0 1 1 0 Vierkantswortel RF[d]←SQRT(RF[s1]) ROOT Rd Rs1

1 0 1 1 1 Negatie RF[d]←-RF[s1] NEG Rd Rs1

1 1 0 0 0 AND RF[d]←RF[s1] AND RF[s2] AND Rd Rs1 Rs2

1 1 0 0 1 NAND RF[d]←RF[s1] NAND RF[s2] NAND Rd Rs1 Rs2

1 1 0 1 0 OR RF[d]←RF[s1] OR RF[s2] OR Rd Rs1 Rs2

1 1 0 1 1 NOR RF[d]←RF[s1] NOR RF[s2] NOR Rd Rs1 Rs2

1 1 1 0 0 XOR RF[d]←RF[s1] XOR RF[s2] XOR Rd Rs1 Rs2

1 1 1 0 1 XNOR RF[d]←RF[s1] XNOR RF[s2] XNOR Rd Rs1 Rs2

1 1 1 1 0 MASK RF[d]←RF[s1] AND 1 MASK Rd Rs1

1 1 1 1 1 INV RF[d]←INV(RF[s1]) INV Rd Rs1

Tabel 6.1: De registerinstructies van de CISC-processor (type 00).

Operatie/mode Bewerking Formeel Assembleertaalo0 m3 m2 m1 m0

0 0 0 0 0 Onmiddellijk RF[d]←Constante LOAD Rd #waarde

0 0 0 0 1 Direct RF[d]←Mem[adres] LOAD Rd adres

0 0 0 1 0 Indirect RF[d]←Mem[Mem[adres]] LOAD Rd (adres)

0 0 1 0 0 Register-geındexeerd RF[d]←Mem[adres+RF[s1]] LOAD Rd adres+(Rs1)

0 1 0 1 0 Register-indirect RF[d]←Mem[RF[s1]] LOAD Rd (Rs1)

0 1 0 1 1 Register-relatief RF[d]←Mem[RF[s1]+s2] LOAD Rd (Rs1)+Rs2

− − 1 0 1 Kopieer register RF[d]←RF[s1] COPY Rd Rs1

1 0 0 0 1 Direct Mem[adres]←RF[s1] STOR adres Rs1

1 0 0 1 0 Indirect Mem[Mem[adres]]←RF[s1] STOR (adres) Rs1

1 0 1 0 0 Register-geındexeerd Mem[adres+RF[d]]←RF[s1] STOR adres+(Rd) Rs1

1 1 0 1 0 Register-indirect Mem[RF[d]]←RF[s1] STOR (Rd) Rs1

1 1 0 1 1 Register-relatief Mem[RF[d]+s2]←RF[s1] STOR (Rd)+Rs2 Rs1

Tabel 6.2: De verplaatsinstructies van de CISC-processor (type 01).

Verplaatsinstructies Verplaatsinstructies zijn instructies die gegevens tussen het geheugen en de register-bank kopieren. Er zijn in dit geval slechts twee basisinstructies mogelijk: kopieren naar het geheugen (store)of kopieren naar de registerbank (load). We bepalen dit met behulp van de eerste bit o0. Met de overigevier bits kunnen we vervolgens de adresseermode bepalen. De eerste bit van de adresmodus bepaalt of de in-structie een adresveld voorziet. Dit is nuttig omdat de hardware snel moet kunnen beslissen of dit adresveldook moet worden uitgelezen. Indien m3 dus laag is maken we gebruik van een adresveld, in het andere gevalkan men het adres afleiden uit de gegevens in de registervelden. De overige bits bepalen vervolgens de soortadressering: onmiddellijk (000), direct (001), indirect (010), relatief (011), geındexeerd (100) en registerkopie(101). Afhankelijk van het feit of we een adresveld beschouwen is de adressering dan bijvoorbeeld relatiefof register-relatief. Verder zijn sommige combinaties niet mogelijk: we kunnen bijvoorbeeld onmogelijk dewaarde van een register naar een constante kopieren wanneer we onmiddellijke adressering zouden gebruiken.Wanneer we de verschillende mogelijkheden uitproberen bekomen we de instructieset in Tabel 6.2.

Spronginstructies Doorgaans beschouwt men vier verschillende soorten sprongbevelen:



0 0 − − − Onconditionele sprong PC←adres JMP adres

0 1 − − − Conditionele sprong PC←adres CJMP adres

of PC←PC+1

1 0 − − − Subroutine sprong Mem[RF[s1]]←PC+1; JSR adres (Rs1)

RF[s1]←RF[s1]+1;

PC←adres

1 1 − − − Terugkeer subroutine RF[s1]←RF[s1]-1; RTS (Rs1)

PC←Mem[RF[s1]]

Tabel 6.3: De spronginstructies van de CISC-processor (type 10).

• Ongeconditioneerde sprong (JMP): in dit geval wordt de programmateller gezet op het opgegevenadres.

• Geconditioneerde sprong (CJMP): dit is een spronginstructie die enkel wordt uitgevoerd als aan eenbepaalde voorwaarde wordt voldaan. Hiervoor houdt de processor een statusregister bij. Een bitin het statusregister noemt men meestal een statusvlag7. Sommige instructies die we verder zullenbeschouwen kunnen op basis van een bepaalde voorwaarde een 0 of een 1 naar dat register schrijven.Enkel wanneer het statusregister op 1 staat wordt de programmateller op het opgegeven adres gezet.In het andere geval wordt de programmateller opgehoogd.

• Subroutine sprong (JSR): Wanneer het programma een subroutine wil uitvoeren, wordt het terug-keeradres eerst op een stapel gezet. Dit terugkeeradres is de opgehoogde programmateller. Nadat destapel is verhoogd wordt de programmateller vervolgens aangepast zodat de processor aan het beginvan de subroutine staat.

• Subroutine terugkeer (RTS): Eenmaal we de subroutine hebben uitgevoerd is het de bedoeling dathet processor terugkeert naar het stuk code net achter de plaats waar de subroutine werd opgeroepen.Omdat verschillende stukken code een subroutine kunnen oproepen werd daarom dit adres op de stapelgeplaatst. Door het adres uit te lezen van de stapel en de stapel met een element te reduceren bereiktde processor de correcte toestand.

Vermits we slechts vier instructies beschouwen kunnen we de instructies voorstellen met behulp van twee bits.De overige bits zijn dan ook niet relevant. Tabel 6.3 beschrijft het formaat van verschillende spronginstructiessamen met een formele beschrijving.

Overige instructies De voorwaardelijke sprong leest het statusregister uit. Tot nu toe hebben we echternog geen instructies geıntroduceerd die de waarde van het statusregister aanpast. Hiervoor voorzien we zesvergelijking-operaties: groter dan (GT), groter dan of gelijk aan (GE), kleiner dan (LT), kleiner dan ofgelijk aan (LE), gelijk aan (EQ) en niet gelijk aan (NE). Indien aan de voorwaarde wordt voldaan wordt hetstatusregister op 1 gezet, in het andere geval op 0. Soms wenst men ook complexere condities te berekenen.Daarom voorzien we ook twee overige instructies die het statusregister aanpassen: zet status (SetS) enreset status (ClrS). Tot slot introduceren we ook twee andere operaties: de no operation (NOP) en resetregister (ClrR). No-operation kan worden gebruikt als we werken met pipelining om de pipeline op te vullenmet instructies waardoor de instructies na de no operation-instructie wachten tot de instructie ervoor isafgelopen. Het op 0 zetten van een register is soms nuttig alvorens we bijvoorbeeld de som van een arraywillen berekenen en vormt een alternatief voor de het inladen van een constante vermits de laatste instructietwee woorden vereist. Het instructieformaat van de overige instructies staat in Tabel 6.4.

7Met het concept vlag introduceert men meestal een terminologie: de vlag is gehesen wanneer de bit op 1 staat.



0 0 − − − No-operation NOP

0 1 0 − − Reset register RF[d]←0 CLR Rd

0 1 1 − − Reset status Status←0 ClrS

1 0 0 0 0 Groter dan Status←RF[s1] > RF[s2] GT Rs1 Rs2

1 0 0 0 1 Groter dan of gelijk Status←RF[s1] >= RF[s2] GE Rs1 Rs2

1 0 0 1 0 Kleiner dan Status←RF[s1] < RF[s2] LT Rs1 Rs2

1 0 0 1 1 Kleiner dan of gelijk Status←RF[s1] <= RF[s2] LE Rs1 Rs2

1 0 1 0 0 Gelijk Status←RF[s1] == RF[s2] EQ Rs1 Rs2

1 0 1 0 1 Niet gelijk Status←RF[s1] != RF[s2] NE Rs1 Rs2

1 1 − − − Zet status Status←1 SetS

Tabel 6.4: De overige instructies van de CISC-processor (type 11).

Machinetaal Het binaire patroon van de instructies wordt ook wel de machinetaal genoemd. Het isimmers een formele beschrijving hoe communicatie met de processor verloopt. Een programmeur kan eenprogramma schrijven in machinetaal door elementen van deze taal in het geheugen in te laden. Zo zalbijvoorbeeld de de instructie 00100001111100002 een optelling realiseren die de som van registers R6 en R0berekend en opslaat in register R7. We kunnen dit signaal als volgt decoderen:

00︸︷︷︸registerbewerking

aritmetisch︷︸︸︷10 000︸︷︷︸

optelling

D=R7︷︸︸︷111 110︸︷︷︸

s1=R6

s2=R0︷︸︸︷000 (6.1)

Deze interpretatie van de machinecode wordt op hardware niveau uitgevoerd met behulp van logische poortenin de controller. Om schrijffouten te vermijden zullen programmeurs doorgaans de broncode in hexadecimalecijfers schrijven. Dit maakt de instructies compacter en vermijdt schrijffouten door bijvoorbeeld een 1 of 0te vergeten. De instructie kunnen we dus ook voorstellen als 21F016.

Assembleertaal Hoewel de hexadecimale voorstelling de meeste schrijffouten voorkomt, vormt dit geengemakkelijke basis om programma’s te schrijven. De hexadecimale code is immers niet makkelijk leesbaaromdat de bits niet altijd in groepen van vier zijn gestructureerd en we bijgevolg niet snel kunnen bepalenof een bepaald binair getal overeenkomt met een optelling. Daarom maakt men meestal gebruik van eenassembleertaal. Een assembleertaal is een mnemonische voorstelling van de instructie en vormt een een-op-een relatie met de binaire instructies. Tabellen 6.1 6.2, 6.3 en 6.4 bevatten daarom ook een kolom die hetequivalent in een zelf ontwikkelde assembleertaal voorstelt.

Assembleerprogramma Een programma geschreven in de assembleertaal naar een equivalent programmain machinetaal gebeurt door een assembleerprogramma. Dergelijke programma’s werken met een eenvoudigeopzoektabel die per mnemonische instructie het binaire equivalent bevat. De meeste assembleerprogramma’sbieden bovendien extra gebruiksgemak aan: symbolische adressen en labels.

Wanneer we gegevens uit het geheugen lezen of wegschrijven dienen we een adres op te geven. De program-meur moet daarom bijhouden op welke plaats welke data precies staat. De meeste assembleerprogramma’snemen deze taak echter gedeeltelijk over met symbolische adressen. Een programmeur gebruikt hierbij eensymbolische naam en het programma kent zelf een adres toe. Dit leidt niet alleen tot gebruiksgemak maarvoorkomt ook dat programmeurs per ongeluk een fout adres opgeven.

Ook wanneer we sprongbevelen uitvoeren dienen we een adres op te geven. Het probleem met explicieteadressen is dat wanneer we een instructie invoegen alle adressen erna opschuiven. Om dit probleem te verhel-pen werken assembleerprogramma’s met een label. Een label is een symbolische markering bij een bepaalde


instructie. Wanneer men vervolgens een sprong-instructie invoegt zet de programmeur de symbolische mar-kering op de plaats waar het adres moet staan. Het assembleerprogramma houdt vervolgens zelf bij metwelk adres dit label overeenkomt en vervangt de symbolische markering bij sprongbevel door een explicietadres.

Voorbeeld Bij wijze van voorbeeld zullen we een programma beschrijven in zowel een hoog-niveau pro-grammeertaal, de assembleertaal en de machinetaal. Het programma berekent tegelijk het minimum, maxi-mum en de som van 1024 getallen in een array A. Wanneer we dit in bijvoorbeeld Pascal implementerenschrijven we volgende code: In het codefragment in 6.1 maken we de assumptie dat een ander deel van

Listing 6.1 Hoog niveau beschrijving van het min-max-sum algoritme.

1 program minmaxsum ;2 var3 min : integer ;4 max : integer ;5 sum : integer ;6 A : array [ 0 . . 1 0 2 3 ] of integer ;7 begin8 min = maxint ;9 max = 0 ;

10 sum = 0 ;11 for i := 0 to 1023 do12 begin13 sum = sum + A[ i ] ;14 i f A[ i ] > max then15 max = A[ i ] ;16 i f A[ i ] < min then17 min = A[ i ] ;18 end ;19 end .

het programma waardes in A zal laden. We houden verder drie integers bij: min, max en sum. Vervolgensoverlopen we in een for-lus alle items. Ieder item wordt bij sum opgeteld en ondergaat vervolgens twee testen:indien het getal groter is dan max passen we max aan. Analoog berekenen we min. Bijgevolg bevatten op heteinde van de lus min en max respectievelijk het minimum en maximum.

Het omzetten van dit codefragment naar assembleertaal valt buiten het bereik van deze cursus maarwordt besproken in cursussen over compilerconstructie. We presenteren echter een equivalent programma inassembleertaal in 6.2. Het codefragment bestaat grofweg uit twee delen: data en programma. ORG DATA enORG PROGRAM zijn dan ook directieven voor het assembleerprogramma. Het zijn geen instructies die omgezetworden in machinecode maar aanwijzingen om de assembleercode correct om te zetten in machinecode.Onder ORG DATA plaatst men een lijst met variabelen samen met hun datatype. Het is de bedoeling dat hetassembleerprogramma ruimte voorziet voor de variabelen en de symbolische adressen in de code vervangtdoor hun fysieke waarde. Het type van de variabele bepaalt hoeveel adressen er gereserveerd moeten wordenin het geheugen. In de micro-assembleertaal beschouwen we twee types: Word en Array. Een Word omvat eenwoord en is dus een hoeveelheid data die kan worden binnengehaald met een adres. Het assembleerprogrammazal bijgevolg adres 016 toekennen aan min, 116 aan max en 216 aan sum. In het geval van de processor die wehier ontwikkelen is dat 16 bit. Een Array duidt op een aantal woorden met het aantal gespecificeerd tussenvierkante haken. Dit betekent dus dat de variabele A zal worden opgeslagen in adressen 316 tot 40216.

Na ORG PROGRAM begint het eigenlijke program. De instructies staan dus vanaf adres 40316 vermits devorige adressen worden ingenomen door de variabelen. Indien we een nieuwe variabele toevoegen, zal hetassembleerprogramma alle adressen automatisch aanpassen. Het programma begint met het zetten van dedrie registers waarin we min (R0), max (R1) en sum (R2). Zo laden we de maxint constante in in R0 en 0in de overige registers. Daarna begint de initialisatie van de for-lus. We gebruiken hiervoor register R3 als


Listing 6.2 Het min-max-sum algoritme in assembleertaal.

1 ORGDATA2 min Word3 max Word4 sum Word5 A Array [ 1 0 2 4 ]6 ORGPROGRAM7 LOAD R0 #0xFFFF −−R0 bewaart he t minimum8 CLR R1 −−R1 bewaart he t maximum9 CLR R2 −−R2 bewaart de som

10 CLR R3 −−R3 bewaart de lus− t e l l e r ( i )11 LOAD R4 #0x03FF −−MaxCount (1023)12 LOAD R5 #A −−beg inadres A13 body : LOAD R6 (R5) −−beg in fo r lus , R6 bewaart A[ i ]14 ADD R2 R2 R6 −−sum=sum+A[ i ]15 LE R6 R1 −−ind ien A[ i ] <= max16 CJMP next −−spr ing naar next17 COPY R1 R6 −−anders : max = A[ i ]18 next : GE R6 R0 −−ind ien A[ i ] >= min19 CJMP l a s t −−spr ing naar l a s t20 COPY R0 R6 −−anders : min = A[ i ]21 l a s t : INC R3 R3 −−hoog l u s t e l l e r op22 INC R5 R5 −−hoog adres van de array op23 LE R3 R4 −−ind ien i <= 102324 CJMP body −−spr ing terug naar het beg in van de l u s25 STOR min R0 −−p l a a t s R0 in min26 STOR max R1 −−p l a a t s R1 in max27 STOR sum R2 −−p l a a t s R2 in sum

lus-variabele (i). R4 gebruiken we als register die de constante bijhoudt om de for-lus te beeindigen. Totslot gebruiken we register R5 die het adres bijhoudt van het element die we op dat moment moeten uitlezen.Vanaf het body-label beginnen de instructies in de for-lus. Zo laden we eerst de data op de specifieke plaatsin de array in register R6. De data wordt bij het som-register opgeteld waarna we een eerste test uitvoeren.Indien de waarde kleiner of gelijk is dan het op dat moment geldende maximum, slaan we het aanpassenvan de max variabele over. In het andere geval kopieren we het getal naar het max-register. In de tweedetest vergelijken we de waarde met het minimum. Indien de waarde groter is dan het minimum slaan we hetaanpassen van het min-register over. Na de twee testen bereiken we het last-label: de laatste instructiesbinnen de for-lus. In dit gedeelte hogen we de lus-teller op samen met adres binnen de array. Vervolgensvergelijken we de for-teller en de eindconditie. Wanneer de teller kleiner is of gelijk aan het einde van dearray voeren we de lus opnieuw uit: we springen dus terug naar het body-label. In het andere geval is defor-lus afgelopen. Tot slot dienen we nog de waardes binnen het register te kopieren naar de variabelen.Dit doen we met behulp van drie store-instructies. Merk op dat het voorgestelde algoritme niet volledigequivalent is: we slaan immers eerst de waarde van A[i] in een register op in plaats van deze telkens uitte lezen. Het voordeel van deze werkwijze is echter dat we load-instructies en toegang tot het geheugenuitsparen en bijgevolg de snelheid van het programma opdrijven.

We kunnen de code in assembleertaal handmatig omzetten in binaire machinetaal. Het resultaat na dezeomzetting staat in 6.3. In de listing beschouwen we twee formaten: -- ----- --- --- --- beschrijftinstructies en ---- ---- ---- ---- beschrijft adresvelden. In werkelijkheid is er natuurlijk geen verschilbij de instructies. Verder beschouwen we in het bestand don’t care bits. Men kan deze bits uiteraard nietvoorstellen in een geheugen. In dat geval dienen we gewoon een waarde – 0 of 1 – in te vullen. Doorgaanskiest een assembleerprogramma 0. We zien dat een assembleerprogramma zowel de labels als de variabelenvervangt door hun fysische equivalent. Verder worden de verschillende instructies omgezet en de opgegevenregisters ingevuld. Samen met deze cursus komt het programma assembler-cisc.hs die in staat is omprogramma’s geschreven in de gegeven assembleertaal om te zetten in de gegeven machinetaal. Men schrijfthet programma in de assembleertaal en slaat het op in een bestand. Vervolgens roept men het programma


Listing 6.3 Het min-max-sum algoritme in machinetaal.

1 01 00000 000 −−− −−− #LOAD R02 1111 1111 1111 1111 #0xFFFF3 11 010−− 001 −−− −−− #CLR R14 11 010−− 010 −−− −−− #CLR R25 11 010−− 011 −−− −−− #CLR R36 01 00000 100 −−− −−− #LOAD R47 0000 0011 1111 1111 #0x03FF8 01 00000 101 −−− −−− #LOAD R59 0000 0000 0000 0011 ##A=3

10 01 01010 110 101 −−− #LOAD R6 (R5)11 00 10000 010 010 110 #ADD R2 R2 R612 11 10011 −−− 110 001 #LE R6 R113 10 01−−− −−− −−− −−− #CJMP14 0000 0100 0001 0010 #next=0x41215 01 −−101 001 110 −−− #COPY R1 R616 11 10001 110 000 −−− #GE R6 R017 10 01−−− −−− −−− −−− #CJMP18 0000 0100 0001 0110 #l a s t = 0x41619 01 −−101 000 110 −−− #COPY R0 R620 00 10010 011 011 −−− #INC R3 R321 00 10010 101 101 −−− #INC R5 R522 11 10011 −−− 011 100 #LE R3 R423 10 01−−− −−− −−− −−− #CJMP24 0000 0100 0000 1100 #body=0x40C25 01 10000 −−− 000 −−− #STOR R026 0000 0000 0000 0000 #min = 0x027 01 10000 −−− 001 −−− #STOR R128 0000 0000 0000 0001 #min = 0x129 01 10000 −−− 010 −−− #STOR R230 0000 0000 0000 0010 #min = 0x2

aan met assembleer-cisc bestand program. De uitvoer is een binair bestand genaamd program die deequivalente machinecode voorstelt. In Hoofdstuk 9 ten slotte vindt men terug hoe men de CISC-processorzelf kan realiseren. Op die manier kan men dus zelfgeschreven programma’s uitvoeren.

We zullen tot slot op basis van het programma cijfermateriaal berekenen over het aantal uitgevoerdeinstructies. Dit is nuttig wanneer we bijvoorbeeld een sneller datapad willen ontwikkelen en statistischegegevens nodig hebben in verband met het voorkomen van instructies. Bij het verzamelen van statistischegegevens kunnen we een onderscheid maken tussen enerzijds het programma en de uitvoer. Bij de uitvoervan een programma kunnen sommige instructies immers meermaals worden uitgevoerd. Tabel 6.4(a) toontdan ook het gebruik van instructies in een programma. Wat opvalt is het hoge aantal verplaatsinstructies.Wanneer we de frequentie van de instructies willen berekenen zullen de meeste instructies 1024 keer in delus worden uitgevoerd: we denken bijvoorbeeld aan de increment instructies. Een probleem vormen echterde register-kopieer instructies (COPY). De uitvoer van deze instructies hangt immers af van de gegevens inde array. We kunnen echter stellen dat wanneer we reeds k elementen hebben onderzocht, de kans om nogeen minimum of maximum te bekomen gelijk is aan:

Pnieuw min/max (k) =1

1 + k(6.2)

In dat geval verwachten we dat we 15.018 keer deze instructie zullen moeten uitvoeren. Tabel 6.4(b) beschrijftde frequentietabel bij de uitvoer. Wat opvalt is dat het aandeel aan verplaatsinstructies significant lager is.Dit is typisch: buiten de lussen voert men vooral instructies uit die gegevens inladen en wegschrijven. Binnende lussen voert men meestal rekenwerk uit.


(a) Programma.

Register Verplaats Sprong OverigeOp # % Op # % Op # % Op # %

INC 2 10 LOAD1 3 14 CJMP 3 14 CLR 3 14ADD 1 5 STOR1 3 14 LE 2 10

COPY 14 10 GE 1 5LOAD5 1 5

Tot. 3 14 Tot. 9 43 Tot. 3 14 Tot. 6 29

(b) Uitvoer.

Register Verplaats Sprong OverigeOp # % Op # % Op # % Op # %

INC 2048 20 LOAD5 1024 10 CJMP 3072 30 LE 2048 20ADD 1024 10 COPY 15 0 GE 1024 10

STOR1 3 0 CLR 3 0LOAD1 3 0

Tot. 3072 30 Tot. 1045 10 Tot. 3072 30 Tot. 3075 30

Tabel 6.5: Frequentietabel bij het uitvoeren van het voorbeeldprogramma.

Instructieset-stroomschema

Na het opstellen van een instructieset volgt de volgende stap: het opstellen van een instructieset-stroomschemaofwel Instruction Set Flowchart. Een dergelijk stroomschema is een visuele voorstelling van alle instruc-ties samen met de bijbehorende registertransfers. Meestal wordt dit schema dan ook gebruikt om laterde instructiedecoder te ontwikkelen: een onderdeel van de controller die de instructie omzet in de juistestuursignalen voor het datapad.

Bij het definieren van de instructieset hebben we verondersteld dat we beschikken over:

• een geheugen (Mem)

• een registerbank (RF)

• een programmateller (PC)

• een instructieregister (IR)

• een statusvlag (Status)

Het stroomschema kent twee concepten: instructieblokken en beslissingsblokken. Een instructieblok wordtvoorgesteld door een rechthoek terwijl een beslissingsblok wordt voorgesteld door een driehoek. Op hetbovenste hoekpunt wordt de variabele gezet die betrokken is in de beslissing of een booleaanse expressie.Op de basis van de driehoek worden vervolgens de verschillende resultaten van de variabele of booleaanseexpressie geplaatst en vertrekt vanuit elk resultaat een pijl. Men leest een stroomschema dan ook door derelevante pijl te volgen.

De beschrijving van een stroomschema lijkt op dat van een ASM-schema maar verschilt op enkele punten.Zo omvat een stroomschema geen concrete toestanden: we doen geen uitspraak over wat precies in welkeklokcyclus moet worden afgehandeld, soms zullen bewerkingen in het stroomschema dus verder onderverdeeldworden. Verder kent een stroomschema wel een sequentiele volgorde toe aan instructies. Instructies dievermeld staan in eenzelfde blok worden conceptueel na elkaar uitgevoerd8. In een ASM-schema worden

8Dit hoeft echter niet te betekenen dat de opdrachten ook effectief na elkaar moeten worden uitgevoerd. Indien beideinstructies niet interfereren bijvoorbeeld kan men de instructies omdraaien of tegelijk uitvoeren.


alle instructies in een blok tegelijk uitgevoerd. Stel bijvoorbeeld dat men in een blok volgende instructiestegenkomt:

a← a+ 1b← Mem[a]

(6.3)

In het geval deze instructies in een ASM-schema staat zal b de waarde van het geheugen inlezen dat op hetadres van de oude waarde van a staat. In het geval van een stroomschema wordt de waarde op het adresernaast uitgelezen.

Een stroomschema voor een instructieset omvat alle mogelijke instructies die kunnen worden uitgevoerd.Centraal staat doorgaans een instructieblok die beschrijft hoe de instructie wordt opgehaald en de program-mateller wordt opgehoogd. Vanuit dit blok worden de stroom vervolgens opgedeeld op basis van mogelijkeinstructies. Elke vertakking voert vervolgens de instructie uit en keert terug naar het centrale blok zodat devolgende instructie kan worden opgehaald.

Figuur 6.8 toont het stroomschema van alle 44 instructies in een afbeelding. De verschillende types instruc-ties zijn in verschillende richtingen opgebouwd. Centraal zien we een instructieblok met twee instructies:IR← Mem[PC] laadt de instructie op het adres van de programmateller in het instructieregister en PC← PC

hoogt de instructieteller op. Na het inladen van de instructie vertakt de stroom zich aan de hand van dedata in het instructieregister. Allereerst maken we op basis van IR15

9 en IR14 een onderscheid tussen deverschillende types. Eenmaal voldoende vertakt beschrijft een instructieblok de concrete uitvoer van debewerking. Het stroomdiagram toont ook details die niet in de tabellen met de instructies vermeld staan.We denken hierbij bijvoorbeeld aan het inlezen van het adresveld. In het geval de instructie gepaard gaatmet een adresveld wordt wordt dit ook uitgelezen met Mem[PC]10 waarna de programmateller nogmaalswordt opgehoogd. Na het uitvoeren van de instructies komen de verschillende stromen terug samen bij hetinstructieblok die de volgende instructie inleest.

Allocatie datapadcomponenten

Nadat per instructie een formele beschrijving werd opgesteld met betrekking tot de verschillende operaties,bestudeert men in een volgende fases het datapad. Op basis van de uitgevoerde bewerkingen, kunnen weimmers de vereiste hardware vastleggen. Zo vereist het stroomdiagram vijf soorten geheugen:

• Een extern geheugen Mem: 216 × 16 ofwel 128 kiB met 1 lees/schrijfpoort.

• Een registerbank RF: 23 × 16 met 2 leespoorten en 1 schrijfpoort.

• Een statusvlag Status

• Een instructieregister IR

• Een programmateller PC

De laatste twee registers behoren echter tot de controller en zullen we in deze stap niet beschouwen. Wekunnen verder voor elke operatie een functionele eenheid voorzien. Anderzijds zal elke klokcyclus er hoogstenseen instructie actief zijn. Alle bewerkingen die moeten worden uitgevoerd kunnen we uitvoeren met driealgemene functionele eenheden:

• Aritmetische Logische Eenheid (ALU)

• Vergelijker

• 16-bit bidirectionele schuifoperator.

9Met deze notatie bedoelen we de 15-de bit van het instructieregister.10Merk op dat alvorens we deze instructie bereiken, de programmateller al is opgehoogd. Bijgevolg staat de programmateller

op dat moment op het adresveld.


We maken de assumptie dat de ALU alle basisbewerkingen (ADD, SUB, MUL, DIV, ROOT, NEG, AND,NAND, OR, NOR, XOR, XNOR, MASK en INV) kan uitvoeren, dat de vergelijker iedere conditie (GT,GE, LT, LE, EQ en NE) met betrekking tot twee registers kan uitrekenen en dat het schuifregister de tweeschuifinstructies (ASR, ASL) kan uitvoeren. Instructies die niet onder het type registerinstructies vallenvoeren doorgaans geen bewerkingen uit behalve de optelling. In dat geval is de ALU echter vrij waardoordit geen probleem vormt.

In deze fase is het echter de bedoeling te onderzoeken of we de snelheid niet kunnen opdrijven doorextra hardware te voorzien. Wanneer men echter aanpassingen aanbrengen aan het datapad zal men ook deinstructieset moeten herzien.

Wanneer we de snelheid willen opdrijven zullen we dit altijd doen ter hoogte van het kritisch pad. Hetheeft immers weinig zin andere instructies sneller uit te voeren wanneer de kloksnelheid onder druk staatvan een andere instructie. We hebben reeds vermeld dat geheugen doorgaans een bottleneck vormt dus ishet meestal interessant vooral naar instructies te kijken met een groot aantal geheugentoegangen.

Op basis van het stroomdiagram kunnen we opmerken dat impliciete adressering het meeste geheugenop-roepen kent. De instructie vereist immers volgende bewerking:

RF[d]← Mem[Mem[Mem[PC]]] (6.4)

Dit komt bijgevolg neer op 4 geheugentoegangen (inclusief het inlezen van de instructie). Stel dat het RAM-geheugen een toegangstijd heeft van 50 ns, dan vereist de instructie dus minstens 200 ns. Indien we dus devolledige instructie in een klokcyclus uitvoeren, dan is de maximale klokfrequentie bijgevolg:

fmax =1

4 · 50 ns= 5 MHz (6.5)

We kunnen de impliciete adressering onmogelijk versnellen met de gegeven toegangstijd. Anderzijds impli-ceert het uitvoeren van de instructie in een klokcyclus dat alle instructies in 200 ns worden uitgevoerd, ookregisteroperaties die geen geheugenoperaties vereisen. Dit betekent dat het uitvoeren van het voorbeeldpro-gramma 2 052 800 ns vereist.

We kunnen een multicycling transformatie uitvoeren waarin instructies worden uitgesmeerd zodat perklokcyclus er een geheugentoegang wordt uitgevoerd. In dat geval is een klokcyclus ongeveer 50 ns lang.Wanneer we dus een LOAD instructie uitvoeren met behulp van impliciete adressering zal dit nog steeds200 ns vereisen. Anderzijds zullen bijvoorbeeld registeroperaties in 1 klokcyclus worden uitgevoerd. UitTabel 6.4(b) kunnen we echter afleiden dan het grootste deel van de instructies enkel toegang tot het geheugenvereisen om de instructie in te laden. De uitvoertijd van het programma zal dus ongeveer verviervoudigen.

Met de multicycling transformatie dienen we echter een nieuw register te introduceren: het adresregister(AR). Dit register houdt het adres bij tijdens de uitvoeren van verplaatsinstructies. We hebben slechtsnood aan een register omdat bij bijvoorbeeld impliciete adressering we dit register enkele malen kunnenoverschrijven tot de instructie is uitgevoerd.

ASM-schema

Na het alloceren van componenten bij het datapad zullen we een ASM-schema opstellen. We stellen dit procesop op basis van enerzijds het stroomdiagram op Figuur 6.8 en anderzijds de allocatie van de componentenop het datapad. Met deze stap dienen we echter te beslissen welke bewerkingen we in welke toestanduitvoeren. Concreet betekent dit dat we de instructieblokken van het stroomdiagram opsplitsen in zo weinigmogelijk ASM-blokken. In principe kan men alle instructies altijd tegelijk uitvoeren. Anderzijds hebben wede componenten op het datapad reeds vastgelegd. Concreet betekent dit dat we in dit geval over slechtseen ALU beschikken, dat we slechts een adres van het geheugen tegelijk kunnen uitlezen, we een woord pertoestand naar de registerbank kunnen wegschrijven, enzovoort. Bij wijze van voorbeeld zullen we enkelegevallen bespreken.


Aritmetisch schuiven naar rechts (ASR) Om de voorbeelden te bespreken zullen we telkens eerstde relevante delen van het stroomschema voorstellen. In het geval van aritmetisch schuiven naar rechts(ASR) is dit Figuur 6.9(a). De cyclus omvat slechts twee instructieblokken: het ophalen van een instructieen het uitvoeren. Dit is het geval bij alle registerinstructies. Hardwarematig is er geen probleem om detwee bewerkingen in een klokcyclus uit te lezen: we kunnen de instructie uit het geheugen inlezen en dezetegelijk uitvoeren en in het instructieregister plaatsen. Er zijn echter drie redenen om dit niet te doen: indat geval heeft het plaatsen van de instructie in het register geen nut: de volgende instructie zal de waardeimmers overschrijven zonder dat deze ooit werd uitgelezen. Verder beschouwen we ook een Moore-machineals controller. Dat betekent dat de stuursignalen afhankelijk zijn van de data die in een vorige klokcycluswerd uitgevoerd. Tot slot is het ophalen van de instructie een bewerking die met alle overige instructieswordt gedeeld. De logica wordt meestal eenvoudiger als men bij het ophalen van de instructie niet voorsommige instructies meteen de relevante bewerkingen uitvoert.

We stellen dus twee verschillende toestanden: een toestand waarin we de instructie ophalen en een toestandwaarin we de schuifoperatie naar rechts uitvoeren. In het ASM-schema moeten we dus een leeg toestands-kader introduceren na het toestandskader die de instructie ophaalt. Onder dit toestandskader plaatsen wevervolgens beslissingskaders die naar een conditioneel kader leiden waar de instructie wordt uitgevoerd. EenASM-schema dat enkel relevant is voor de ASR-instructie is getekend in Figuur 6.9(b). Merk op dat in eenASM-schema zaken die in hetzelfde toestandskader gebeuren tegelijk worden uitgevoerd, dit in tegenstellingtot een stroomschema.

Laden van een constante (LOAD) We beschouwen vervolgens de LOAD-instructie met onmiddellijkeadressering die een constante uit het programma in een register inladen. Een compact deel van het stroom-schema staat op Figuur 6.10(a). In het geval van deze instructie zijn we verplicht om twee toestanden tevoorzien. Dit komt omdat het geheugen slechts een leespoort heeft en we bijgevolg geen twee woorden te-gelijk uit het geheugen kunnen laden. Verder wordt ook de programmateller tweemaal opgehoogd terwijlde controller slechts een increment-operator omvat. We introduceren dus opnieuw twee toestanden: eentoestand waarbij we de instructie inlezen en een toestand waarin we het adresveld inlezen en wegschrijvennaar de registerbank. Dit leidt tot het ASM-schema in Figuur 6.10(b).

Laad direct uit het geheugen (LOAD) Naast het inladen van een constante bevat de instructiesetook een instructie om gegevens in te laden waarbij het adres gespecificeerd is. Opnieuw kunnen we omwillevan het feit dat het geheugen slechts een leespoort telt deze operatie enkel met minstens drie toestandenuitvoeren. Bij een multicycling-transformatie dienen we echter de tussenresultaten op te slaan. Hiervoorwerd echter het adresregister geıntroduceerd. Dit adresregister zal na toestand twee het adres bevatten datmoet worden uitgelezen. In de derde toestand wordt de waarde meteen terug uitgelezen om het correcteadres uit het geheugen uit te lezen.

Laad indirect uit het geheugen (LOAD) De laatste LOAD-instructie die we beschouwen is de impli-ciete adressering. Deze instructie vereist in totaal viermaal toegang tot het geheugen. Bijgevolg vereist dezeoperatie minimum vier toestanden. Ook hier beschouwen we dus een multicycling-transformatie waarbijwe een instructieblok van het stroomschema op in drie toestandsblokken in het ASM-schema. We zullenbijgevolg de tussenresultaten opnieuw moeten wegschrijven. In een algemeen geval betekent dit dat we tweeregisters moeten voorzien11. In dit geval hebben we slechts een extra register nodig. We dienen immers enkelde resultaten van de vorige toestand te onthouden. Dit betekent dat we in de vierde toestand de resultatenvan de tweede toestand niet meer nodig hebben.

Sprong naar een subroutine (JSR) Ook in het geval van een sprong naar een subroutine moetenwe het uitvoeren van de eigenlijke instructie opsplitsen in twee delen. De volledige set instructies staat opFiguur 6.13(a). Dit komt opnieuw door de toegang tot het geheugen: we moeten zowel het adresveld uitlezen

11In een algemeen geval kan het immers voorkomen dat het finale resultaat afhangt van alle tussenresultaten berekend in devorige toestanden.


en de programmateller na uitlezen in het geheugen plaatsen. Het geheugen omvat echter een lees/schrijfpoort.We kunnen dus niet tegelijk lezen en schrijven. Om de toestand te overbruggen zullen we bovendien opnieuwgebruik moeten maken van de adresregister. In de eerste toestand lezen we dus eenvoudigweg het adresvelduit en hogen we de programmateller op. In de tweede toestand schrijven we de programmateller weg naarhet geheugen, hogen we de stapel op en stellen we tot slot de programmateller gelijk aan het adresregister.Men kan opmerken dat er nog een tweede reden is om de instructies in twee blokken op te splitsen: we dienentweemaal een increment uit te voeren. In het geval van de programmateller valt deze verantwoordelijkheidechter onder de controller. De controller beschikt over een eigen increment-operator waardoor men in principetegelijk een optelling met de ALU en een increment van de programmateller kan realiseren. Het ASM-schemadie de twee blokken voorstelt staat in Figuur 6.13(b).

Terugkeer uit een subroutine (RTS) Tot slot beschouwen we ook nog de terugkeer instructie waarvanhet stroomschema is afgebeeld op Figuur 6.14(a). Deze instructie voeren we uit in een toestand. Men kanopmerken dat we eerst de waarde van een register in de registerbank moeten aftellen om vervolgens derelevante geheugenplaats in te lezen. We kunnen echter zonder gebruik te maken van extra hardware eenchaining-transformatie uitvoeren en dus niet alleen het resultaat na de decrement-operatie opslaan in deregisterbank maar deze ook gebruiken om het adres te bepalen in het geheugen. We kunnen bijgevolg alleinstructies in een klokcyclus uitvoeren. Dit leidt dan ook tot het ASM-schema op Figuur 6.14(b).

Ontwerp Controller

Na het ontwerpen van een (gedeeltelijk) ASM-schema, kunnen we een specifieke controller ontwikkelen vooronze processor. In de eerste plaats beschouwen we altijd de controller uit Figuur 5.19 op pagina 174. In dezecontroller beschouwen we echter enkele algemene componenten zoals een toestandsregister, next-state logicaen output logica. In deze subsubsectie ondernemen we een poging deze componenten in te vullen.

De eerste component die we zullen bespreken is het toestandsregister. Dit register omvat normaal detoestand waarin de controller zich bevindt. In het geval van een processor is de toestand echter de plaatsin het programma waarin we ons bevinden. Deze plaats wordt gemarkeerd door de programmateller: dezeteller bevat immers het geheugenadres van waaruit we de instructie zullen uitlezen. Het stroomschema enhet ASM-schem specificeren verder ook dat we op basis van de waarde van de programmateller de relevanteinstructie uit het geheugen inlezen en deze vervolgens in het instructieregister plaatsen. We voegen bijgevolghet geheugen en register tussen de programmateller enerzijds en de next-state- en output-logica anderzijds.De implementatie van de controller na deze stap is geıllustreerd in Figuur 6.15.

Door het toestandsregister te vervangen met de programmateller introduceren we echter een belangrijkprobleem: de waarde van het toestandsregister in een controller beschrijft immers volledig de toestand. Ditzou dus betekenen dat we op basis van de programmateller of de overeenkomstige instructie alle bewerkingenkunnen afleiden. Dit is echter niet het geval: bij sommige bewerkingen werd een multicycling transformatieuitgevoerd. Bij bijvoorbeeld een indirecte laad-instructie doorlopen we vier verschillende toestanden. Alleenin de eerste twee toestanden wordt de programmateller opgehoogd. Dit betekent dus dat we geen onder-scheid kunnen maken tussen bijvoorbeeld toestand S3 en S4 in Figuur 6.12(b) op pagina 251. We kunnendit probleem echter oplossen met behulp van de componenten die de volgende toestand en de uitvoer-logicaberekenen. Klassiek zijn dit twee combinatorische schakelingen. We kunnen echter ook een eindige toe-standsautomaat implementeren om deze componenten voor te stellen. Deze automaat omvat dan een interntoestandsregister die de verschillende deeltoestanden van een instructie bijhoudt. In sommige processorenis er zelfs sprake van een volledige eindige toestandsautomaat-controller met een micro-programmateller enmicro-programmageheugen.

De controller laat toe om naast de programmateller op te hogen ook op twee andere manieren een nieuwewaarde in te laden: de logica die de volgende toestand uitrekent kan zelf een waarde voorstellen of de waardekan worden afgeleid uit een LIFO-stack (ook wel de execution stack of uitvoerstapel genoemd) in het gevalvan subroutines. Op basis van het stroomschema kunnen we echter opmerken dat in het geval van een


spronginstructie het adres expliciet in het programma wordt vermeld. We hebben bijgevolg geen extra logicanodig om het adres verder te decoderen. Daarom vervangen we de verbinding vanuit de next-state logicanaar de multiplexer door een verbinding vanuit het geheugen naar de multiplexer.

Wanneer we een subroutine uitvoeren doet een deel van het geheugen zelf dienst als stapel. Dit zienwe bijvoorbeeld in het stroomschema waar de instructies Mem[RF[s1]] ← PC en RF[s1] ← RF[s1] + 1respectievelijk eerst de waarde van de programmateller op de juiste plaats in de stapel plaatst en vervolgenseen register in de registerbank die dienst doet als stapelteller ophoogt. In het geval we terugkeren uit eensubroutine geldt een omgekeerde procedure. De controller die we op dit moment beschouwen voorziet hiervoorop dit moment zelf een LIFO-stapel. We kunnen vervolgens deze stapel elimineren en de verbindingen afleidennaar het geheugen. Dit betekent dat de uitgang van de increment die oorspronkelijk het adres van de LIFObepaalde nu in bepaalde omstandigheden het geheugenadres bepaalt. Verder werd al een verbinding vanuithet geheugen naar de multiplexer voorzien. We elimineren dus een verbinding en reduceren ook de multiplexertot een 2-naar-1 MUX. De controller na het doorvoeren van deze twee wijzigingen staat op Figuur 6.17.

Tot slot dienen we op te merken dat het geheugen van de ontwikkelde processor geen onderdeel is van decontroller zelf: ook het datapad heeft toegang tot hetzelfde geheugen om bijvoorbeeld programmaconstantenuit te lezen. Een architectuur waar men een centraal geheugen beschouwt die zowel gegevens als programma’sbeschouwt noemen we Von Neumann-architectuur, in het geval beide geheugens gescheiden zijn spreken weover Harvard-architectuur. We verplaatsen dus het geheugen uit de controller. Dit doen we door twee bussente beschouwen: een adresbus is een reeks verbindingen waarmee men de adresingangen van het geheugen kanaansturen en met behulp van de databus leest men gegevens in of schrijft men deze weg in het geheugen. Dedatabus is bijgevolg een bus die in twee richtingen werkt. We dienen bijgevolg tri-state buffers te voorzienvoor zowel lees- als schrijfoperaties. Ook op de adresbus brengen we tri-state buffers aan: het datapad moetimmers ook adressen kunnen aanleggen. De uiteindelijke controller beschrijven we in Figuur 6.18.

Ontwerp Datapad

De laatste stap is het ontwerpen van een datapad. We hebben reeds enkele stappen geleden de vereistecomponenten voor het datapad vastgelegd. We dienen echter nog verbindingen te introduceren om deverschillende instructies te kunnen uitvoeren. Deze verbindingen omvatten ook tri-state buffers aan deingangen van een bus en multiplexers aan de uitgangen. De vereiste verbindingen kunnen we uiteraardafleiden uit het ASM-schema.

Het is mogelijk dat er conflicten ontstaan tussen enerzijds het ASM-schema en anderzijds de componentenen verbindingen op het datapad. Dit kunnen we oplossen door terug te keren op een van de volgende stappen:

• De allocatie van de componenten: in dat geval voorzien we extra componenten zoals een extra ALUof registerbank. We dienen vervolgens wel opnieuw een ASM-schema op te stellen en mogelijk ook eennieuwe controller ontwerpen.

• Het ASM-schema: we kunnen extra toestanden introduceren zodat we de componenten op het datapadmeermaals kunnen gebruiken. Hiervoor dienen we het ASM-schema en mogelijkerwijs de controller aante passen. Dit leidt uiteraard tot meer klokcycli voor (sommige) instructies.

Bij het omzetten van het ASM-schema naar de verbindingen van het datapad is het belangrijk een onder-scheid te maken tussen bewerkingen die onder de verantwoordelijkheid van de controller vallen en deze van hetdatapad. Zo beschrijft toestand S0 het ophalen van een instructie en deze vervolgens in het instructieregis-ter plaatsen. Zowel de programmateller en het instructieregister vallen echter onder de verantwoordelijkheidvan de controller. Bijgevolg dienen we voor deze bewerkingen geen verbindingen te introduceren. Ook hetinterpreteren van de instructie is de verantwoordelijkheid van het datapad.


Bij het ontwerp beginnen we met een datapad waar we enkel de componenten tekenen. Verder wordenook externe componenten (behalve de controller) die interageren met het datapad getekend. In dit concretegeval is dit het centrale geheugen samen met de adres- en databus. We beschrijven ook de tri-state buffersvan de databus van en naar het geheugen. Deze aspecten werden ook al beschreven bij het ontwerp van decontroller. Dit resulteert in de afbeelding op Figuur 6.19.

We realiseren een controller door de verschillende instructies toe te voegen en waar nodig extra bussen inhet datapad aan te brengen. Het is daarom nuttig om onmiddellijk bij het introduceren van een bus mettri-state buffers bij de aansturing en eventueel ontvangers aan de kant van de gebruikers te plaatsen. Indienlater blijkt dat de bus enkel door een register wordt aangestuurd of de multiplexer slechts data ontvangtvan een bus, kan men deze componenten gewoon verwijderen. We zullen in de rest van deze subsubsectieenkele instructies vertalen naar het datapad. Natuurlijk dienen we in realiteit alle instructies te beschouwen.Het resulterende datapad staat in Figuur 6.21 op pagina 256 en de uiteindelijke controller in Figuur 6.20 oppagina 255. We zullen vanaf hier de synthese van deze figuren beschouwen.

Schuifoperatie (SHR) We beschouwen opnieuw de schuifoperatie naar rechts. Zoals reeds aangehaald ishet inlezen en interpreteren van de instructie de verantwoordelijkheid van de controller. Bijgevolg rest alleennog verbindingen te voorzien voor de laatste bewerking in de instructie: RF[d]← RF[s1]>>N. Het bepalenvan de juiste adressen in de registerbank (d en s1) valt hierbij ook onder de verantwoordelijkheid van decontroller. Dit doen we door verbindingen te plaatsen tussen de output logica eindige toestandsautomaaten de adres-ingangen van de registerbank en de schuiflengte-ingangen van het schuifregister. We dienen dusenkel bussen te realiseren die gegevens vanuit de registerbank naar het schuifregister transporteert en terug.De eerste bus wordt via een tri-state buffer aangestuurd vanuit de eerste lees-poort van de registerbank12.Verder loopt vanuit het schuifregister een bus terug naar de registerbank.

Optelling (ADD) In het geval van een optelling dienen we opnieuw slechts de verbindingen verantwoor-delijk voor de optelling zelf te realiseren. Dit betekent dat we de twee leespoorten moeten aanleggen op detwee ingangen van de ALU. We hebben echter al een operandbus voorzien: deze bus wordt aangestuurd doorhet register bepaald door het s1 veld van de instructie. We verwachten dat de implementatie van de con-troller vereenvoudigt wanneer we dit principe consistent toepassen. Bijgevolg zullen we ook bij de optellingdeze bus aansturen met de inhoud van RF[s1]. We dienen echter nog een andere operand-bus te voorzien:een bus om RF[s2] te verplaatsen. Deze bus wordt dus aangestuurd door de tweede leespoort van de re-gisterbank. We dienen tot slot ook de twee ingangen van de ALU aan de operandbussen te koppelen. Hetdatapad voorziet ook reeds een resultaatbus. Deze resultaatbus wordt aangestuurd door de schuifoperatoren gebruikt door de registerbank. Omdat we het schuifregister niet tegelijk met de ALU gebruiken, kunnenwe bijgevolg de resultaatbus hergebruiken. We voorzien dus een tri-state buffer tussen de uitgang van deALU en de resultaatbus. De overige registerinstructies worden allemaal ofwel door het schuifregister ofweldoor de ALU uitgevoerd. Zonder verder in detail te gaan kunnen we dus stellen dat de twee operandbussenen de resultaatbussen dus volstaan om al deze instructies te ondersteunen.

Onmiddellijk laden (LOAD) Naast register-instructies beschouwen we ook instructies die data in en uithet geheugen halen. Dit geheugen bevindt zich buiten het datapad, maar het datapad kan wel communicerenmet dit geheugen via de adres- en databus. Wanneer we een constante inladen betekent dit dat we volgendebewerking uitvoeren: RF[d] ← Mem[PC]. We beschikken evenmin over de inhoud van de programmateller,maar de controller kan wel de inhoud op de adres-bus plaatsen. In dat geval staat de inhoud die moetworden ingeladen dus op de data-bus. Wanneer we dus een tri-state buffer plaatsen tussen de data-bus ende resultaat-bus, kunnen we de data in de registerbank inladen.

Direct laden (LOAD) Het ASM-schema op Figuur 6.11(b) op pagina 250 beschrijft hoe gegevens directuit het geheugen worden ingeladen. Het proces komt neer op twee bewerkingen waar het datapad een rol in

12We kunnen ook opteren voor de tweede leespoort. Vermits momenteel nog geen enkele leespoort in gebruik is, is de keuzearbitrair.


speelt: AR ← Mem[PC] en RF[d] ← Mem[AR]. De eerste bewerking heeft veel gemeen met het onmiddellijkinladen van een constante: we laden immers opnieuw Mem[PC] in, alleen is de gebruiker nu het adresregisterAR. We kunnen opnieuw gebruik maken van de resultaatbus vermits deze bus opnieuw door geen enkel andercomponent gebruikt wordt in dezelfde toestand. We dienen hierbij wel het adresregister aan te sluiten opde resultaatbus. Hiervoor hoeven we op dit moment uitsluitend een eenvoudige verbinding te gebruiken:het adresregister dient immers niet te kiezen tussen data van verschillende bussen waardoor een multiplexeroverbodig is. Vervolgens beschouwen we de tweede bewerking. In deze bewerking dient de inhoud van hetadres-register op de adres-bus te verschijnen. Hiervoor voorzien we dus een verbinding tussen de lees-poortvan het adresregister enerzijds en de adresbus anderzijds. In dit geval dienen we wel gebruik te maken vaneen tri-state buffer: er zijn immers nog registers en componenten die hun inhoud op de adres-bus kunnenplaatsen.

Geındexeerd laden (LOAD) Als laatste laad commando beschouwen we geındexeerd laden. Bij geındexeerdladen voorzien we opnieuw twee relevante bewerkingen: de eerste bewerking stelt: AR ← Mem[PC]+RF[s1],en in een volgende toestand RF[d] ← Mem[AR]. De tweede bewerking is identiek aan een bewerking bij hetdirect laden van een waarde. Bijgevolg dienen we geen extra verbindingen te voorzien. De eerste operatieomvat echter een nieuw aspect: we laden niet enkel de waarde van de programmateller in, maar tellen erook nog de registerwaarde RF[s1] bij. Bijgevolg dienen we de waarde die op de databus verschijnt eerst aante leggen op een ALU die vervolgens de som berekent. Het resultaat van de ALU wordt dan aangelegd opde resultaat-bus en wordt op die manier in de registerbank ingeklokt. Om de data aan te leggen kunnen wegebruik maken van een operand-bus: slechts een van de twee wordt immers gebruikt om de data van hetregister RF[s1] te verplaatsen. Omdat in alle voorgaande bewerkingen de eerste operandbus deze waardetransporteerde, zullen we de waarde van de data-bus dan ook aanleggen op de tweede operand-bus. Deoptelling is immers commutatief dus maakt de concrete toewijzing niks uit. Concreet introduceren we duseen nieuw tri-statebuffer tussen de databus en de tweede operand-bus. Vermits alle overige laad-instructiesenkel gebruik maken van bewerkingen die reeds werden beschouwd, zullen deze geen nieuwe verbindingenintroduceren.

Kopieren van een register (COPY) Verplaatsinstructies verplaatsen niet enkel gegevens tussen regis-ters en het geheugen, maar ook tussen de registers onderling. Dit is de zogenaamde COPY-instruction. Wekunnen in de eerste plaats denken om in het geval van een copy-instruction een operandbus te verbinden metde resultaat-bus met behulp van een tri-state buffer. Anderzijds kan deze instructie worden ondersteund zon-der extra verbindingen te voorzien. Wanneer we immers schuiven over 0 bits naar links of rechts, zal dezelfdewaarde op de resultaat-bus worden aangelegd die op de eerste operand bus stond. De meeste ALU’s latenbovendien toe dat met behulp van een bepaalde functiecode de waarde aan een van de ingangen eenvoudig-weg wordt aangelegd op de resultatenbus. We kunnen kiezen welke methode moet worden geımplementeerdin de logica van de controller, maar de operatie introduceert geen nieuwe verbindingen op het datapad.

Direct stockeren (STOR) De verplaats-instructies die data uit het geheugen inladen hebben op hetinladen van een constante na een tegenhanger die data wegschrijft naar het geheugen. Vermits het berekenenvan het adres gelijkaardig is, zullen we hiervoor geen nieuwe instructies moeten voorzien. De bewerking diehet uiteindelijke resultaat wegschrijft – Mem[AR] ← RF[s1] dienen we echter wel te beschouwen. In dezebewerking leggen we de inhoud van het adresregister aan op de adresbus. De verbindingen hiervoor zijn reedsvoorzien omdat we dit ook moeten doen om bijvoorbeeld gegevens direct in te laden. Anderzijds dienen wede inhoud van het gespecificeerde register aan te leggen op de registerbank. Tot nu werd altijd de eersteleespoort gebruikt om RF[s1] uit te lezen. Om de implementatie van de controller eenvoudig te houdenzullen we deze conventie verder toepassen. We dienen echter de leespoort te verbinden met de data-bus.We voorzien dus een tri-state buffer tussen de eerste leespoort en de databus. Met deze STOR-instructiebeschouwen we alle overige verplaats-instructies ook als geımplementeerd.

Sprong naar subroutine (JSR) We zullen ook enkele sprong-instructies beschouwen. De eerste instruc-tie is de sprong naar een subroutine. We beschouwen deze instructie omdat we hierdoor ook tegelijk de bewer-kingen van de onvoorwaardelijke (JMP) en voorwaardelijke (CJMP) sprong beschouwen. Het ASM-schema


van deze instructie staat op Figuur 6.13(b) op pagina 252. We zien op het ASM-schema twee toestanden dievan belang zijn. In de eerste toestand wordt het geheugen op het adres van de programmateller ingelezenin het adresregister. Deze bewerking hebben we echter ook beschouwd bij het inladen van geheugendatamet directe adressering. In de volgende toestand beschouwen we drie bewerkingen: Mem[RF[s1]] ← PC,RF[s1] ← RF[s1]+1 en PC ← AR. De increment van het register RF[s1] is eenvoudig te implementeren.Dit is immers een register-instructie en bijgevolg dienen we geen extra verbindingen te voorzien. We dienenverder ook de waarde van de programmateller weg te schrijven in het geheugen op het adres aangegeven dooreen register. Hiervoor dienen we verbindingen te voorzien die de programmateller verbindt met de databusen de eerste leespoort met de adresbus. Merk op dat we bijgevolg zowel de controller als het datapad moetenaanpassen. Tot slot dienen we de waarde van het adresregister naar de programmateller kopieren. Eenprobleem is echter dat alle beschikbare bussen reeds bezet zijn. We kunnen weliswaar de tweede operand-bus gebruiken, maar deze heeft op dit moment geen verbinding met de programmateller. We kunnen ditoplossen door een verbinding te voorzien vanuit het adresregister naar de programmateller, al da niet via detweede operandbus, ofwel door het ASM-schema aan te passen. We kunnen bijvoorbeeld een nieuwe toestandvoorzien waarin – bijvoorbeeld via de vrijgekomen databus – de waarde van het adresregister aanlegt op demultiplexer van de programmateller. In dit geval kiezen we voor het tweede. Dit leidt tot de finale controllerin Figuur 6.20.

Terugkeer uit subroutine (RTS) De laatste spronginstructie die we beschouwen is de terugkeer uit eensubroutine ofwel de RTS-instructie. Het relevante ASM-schema bij deze instructie staat in Figuur 6.14(b).Hiervoor dienen twee bewerkingen tegelijk worden uitgevoerd: RF[s1]← RF[s1]-1 en PC← Mem[RF[s1]-1].Een terugkeer-instructie heeft veel gemeen met een sprong naar een subroutine. Toch is er een fundamenteelverschil: het geheugenadres wordt bepaald door een verschil berekend in dezelfde klokcyclus. Dit verschilwordt berekend door de ALU. Het resultaat van de ALU dient niet enkel teruggeschreven worden naar deregisterbank, maar moet ook op de adresbus worden aangelegd (om de waarde op te vragen die in de program-mateller moet worden weggeschreven). Daarom voorzien we een tri-state buffer tussen de resultaat-bus ende adresbus. Het wegschrijven van de waarde van de programmateller is vervolgens de verantwoordelijkheidvan de controller. De vereiste verbindingen in de controller werden reeds gerealiseerd.

Groter dan (GT) en andere vergelijkingen Tot slot beschouwen we een van de overige instructies:de groter dan operatie (hoewel iedere operatie kan worden beschouwd). De vergelijker in het datapad is eenalgemene vergelijker die op basis van stuursignalen een van de voorwaarden bepaalt. De vergelijker vergelijktde waarde in de registers RF[s1] en RF[s2]. Vermits hiervoor reeds operandbussen werden voorzien dienenwe enkel verbindingen tussen de bussen en de ingangen van de vergelijker te voorzien. Verder dienen wevervolgens het resultaat in het statusregister weg te schrijven. We kunnen hiervoor een bit van de resultaatbusgebruiken. In dat geval dienen we echter een tri-state buffer te voorzien. Vermits het statusregister slechtseen bit bijhoudt, is de vereiste verbinding slechts een bit breed. Daarom voorzien we een aparte verbindingvanuit de vergelijker naar het statusregister. De toestand van het statusregister vormt ook een signaalvoor de controller (bijvoorbeeld bij een voorwaardelijk sprong). We kunnen andere condities testen door destuursignalen van de vergelijker aan te passen. We beschouwen geen verdere overige instructies omdat dezegeen nieuwe verbindingen introduceren. Deze instructies zetten of resetten immers registers, iets wat wekunnen realiseren met behulp van een multiplexer aan de ingang van het statusregister en met behulp vande reset-ingang bij verschillende registers. We bekomen dan ook het uiteindelijke datapad op Figuur 6.21.

De 8086 Microprocessor

Tot slot kijken we naar enkele populaire CISC-processoren: de 8086 microporocessor en de 8051 microcon-troller. De structuur van deze processoren staat respectievelijk in Figuur 6.22 en Figuur 6.23.

Vooral de 8086 is een populaire processor in computers en vormt de basis voor alle Intel CPU’s13. Opde figuur staat een component waarvan de vorm nog niet werd geıntroduceerd: een trapezium met in het

13Hoewel de verdere processoren bijvoorbeeld de bitlengte van de registers verder hebben opgedreven is de algemene structuurnog steeds dezelfde.


midden een inkeping wordt meestal gebruikt om een ALU aan te duiden.

In het blokdiagram van Intel 8086 zien we twee ALU’s staan. De bovenste ALU rekent enkel het adres uitbij impliciete adressering en staat dan ook bekend als de adress adder. De onderste ALU voert verschillendebewerkingen uit zoals optellen, aftrekken, vermenigvuldigen,... Verer zien we onderaan links ook een regis-terbank. Deze registerbank houdt de acht registers van elk 16 bit. Vier van de registers: AX, BX, CX enDX kunnen verder worden opgedeeld als registers van 8-bit. De overige vier registers zijn registers met eenspeciaal doel: bijvoorbeeld SP houdt de stack pointer bij. Deze registers kan men dan ook niet aanwendenom eender welke instructie op toe te passen en de waarde wordt meestal impliciet aangepast.

Onder de ALU zien we nog een register die de Operand Flags bijhoudt. Het is een 16 bit registers waarvan9 bits dienstdoen om een voorwaarde met betrekking tot het resultaat berekend in de ALU bij te houden.Bijvoorbeeld als het resultaat van de ALU gelijk is aan 0 wordt de Zero Flag op 1 gezet. Het voordeel vandit register is dat men niet altijd eerst een expliciete vergelijk-instructie moet uitvoeren.

Boven de central bus zijn we een andere registerbank. Deze registerbank houdt registers bij met betrekkingtot de adressering zoals Instruction Pointer (IP) Code Segment (CS), Data Segment (DS), Extra Segment(ES) en Stack Segment (ES). Behalve de instructionpointer (het equivalent van de programmateller) valt debetekenis van de overige registers buiten het bereik van deze cursus. Men kan echter stellen dat ze nuttigzijn om het adres in een instructie uit te rekenen.

Tot slot vinden we bovenaan centraal ook nog een registerbank. Deze registerbank noemen we de Instruc-tion Queue. Het is een geheugen dat enkele instructies bevat die waarschijnlijk binnenkort zullen wordenuitgevoerd. Door deze in een register te bewaren hoopt men geen wachttijden te introduceren om instructiesuit het geheugen op te halen. Onder deze wachtrij bevindt zich ten slotte de controle-eenheid ofwel decontroller die op basis van de instructie de gegevens op de juiste manier door de bussen laat stromen.

De 8051 Microcontroller

De 8051-microcontroller is in tegenstelling tot de Intel 8086 een Harvard-machine met een onderscheid tussendatageheugen en instructiegeheugen. In tegenstelling tot de 8086 waar enkel een rekeneenheid met registerswordt voorzien, voorziet de 8051 een rekeneenheid, geheugen, ROM-geheugen, Input-Output (I/O), interruptlogica en een timer.

De processor werkt hoofdzakelijk met een woordlengte van 8-bit. Zo voorziet men een 8-bit ALU en 8-bitregisters. De adresbus is echter 16-bit waardoor een groter geheugen kan worden uitgelezen. Wat opvaltis dat de processor zowel een klein RAM-geheugen voorziet van 128 bytes waar de programmagegevens inworden ondergebracht terwijl de chip ook over een grote hoeveelheid EPROM of ROM geheugen beschiktwaar het programma in wordt ingelezen. EPROM kan slechts eenmalig worden beschreven. Het is danook de bedoeling om deze chip in een specifieke applicatie te gebruiken door er een programma in onder tebrengen zonder hier later wijzigingen in aan te brengen. Verder kan men ook opmerken dat de chip voorverschillende speciale registers extra functionaliteit voorziet. Zo zien we een increment-operator die enkeldienst doet om de programmateller op te hogen.

6.3.4 Reduced Instruction Set Computer (RISC)

Ontwerp

Het ontwerp van een RISC processor verloopt ongeveer gelijkaardig aan dat van een CISC processor. Eenprogramma zal echter uit meer instructies bestaan dan bij een CISC processor, daarom is de klokfrequentieeen zeer belangrijke factor. Pipelining vormt dan ook een zeer belangrijk aspect in de implementatie van een


RISC processor. Zo worden de instructies zelf in nagenoeg alle processoren uitgevoerd volgens het pipeliningprincipe14.

Pipelining zal er meestal toe leiden dat men extra beperkingen op de instructieset plaatst. We denken bij-voorbeeld aan het feite dat de meeste instructies even lang zijn. Op de ARM7 processor worden bijvoorbeeldalle instructies voorgesteld met 32 bit (inclusief verplaats instructies). Door geen optioneel adresvelden tevoorzien kan een instructie in een toestand worden opgehaald. Dit is belangrijk wanneer we bijvoorbeeldeen instructie willen inlezen in een toestand. Met optionele velden toe te laten moeten we op basis van deinstructie beslissen of we de programmateller verder ophogen. Dit verhindert echter dat we in de volgendetoestand dus een nieuwe instructie kunnen ophalen. Ook de controller en het datapad zelf werken volgens hetpipelining-principe. Dit is belangrijk omdat de pipeline in het geval van sprongbevelen bijvoorbeeld moetworden onderbroken. Andere instructiesets voorzien geen hardware om de pipeline te onderbreken maar eenNo-Operation instruction die tussen twee instructies kunnen worden geplaatst waardoor de tweede instructiewacht tot de eerste instructie volledig is uitgevoerd.

De ARM7 Microprocessor

Bij wijze van voorbeeld zullen we twee microprocessoren bespreken: de ARM7 en ARM11 microprocessor.Voor beide processoren zullen we de structuur bespreken samen met de instructieset en de vormen vanpipelining die werden geımplementeerd.

Figuur 6.24 beschrijft de structuur van een ARM7 processor. Op de figuur staan opnieuw enkele vormendie nog niet werden geıntroduceerd. Zo wordt een barrel shifter typisch voorgesteld aan de hand van eenparallellogram en een vermenigvuldiger aan de hand van een zeshoek waarbij de linkse en rechtse knoopinwendige hoeken zijn.

Net als in het geval van de Intel 8086 omvat de processor zelf geen RAM geheugen behalve enkele regis-ters. Instructies en data worden dan ook uit een geheugen gelezen naast de ARM processor die verbondenis via een adresbus A[31:0] en een databus D[31:0]. De ARM7 processor omvat grofweg drie delen: eengeheugeninterface: dit omvat het adresregister, de adres incrementer, en het write data register ; een reken-kundige eenheid met een registerbank, vermenigvuldiger, ALU en barrel shifter en de controle eenheid diede instruction pipeline en de instruction decoder omvat.

De ARM11 Microprocessor

14Zie voorbeelden van de ARM7 en ARM11 microprocessor verder in deze subsectie.


IR←

Mem[PC]

PC←

PC+1

00

01

10

11

IR

15 IR

14

01 IR

13

01 IR

12

01 IR

12

000

001

010

011

100

101

110

111

IR

11 IR

10 IR

9000

001

010

011

100

101

110

111

IR

11 IR

10 IR

9000

001

010

011

100

101

110

111

IR

11 IR

10 IR

9000

001

010

011

100

101

110

111

IR

11 IR

10 IR

9

RF[d]← Mem[PC]

PC← PC+1

RF[d]← Mem[Mem[PC]]PC← PC+1

RF[d]← Mem[Mem[Mem[PC]]]

PC← PC+1

RF[d]← Mem[Mem[PC]+RF[s1]]

PC← PC+1

RF[d]← Mem[RF[s1]]

RF[d]← Mem[RF[s1]+s2]

RF[d]← RF[s1]

Mem[Mem[PC]]← RF[s1]

PC← PC+1

Mem[Mem[Mem[PC]]]← RF[s1]

PC← PC+1

Mem[Mem[PC]+RF[s1]]← RF[s1]

PC← PC+1

Mem[RF[s1]]← RF[s1]

Mem[RF[s1]+s2]← RF[s1]

RF[d]← RF[s1]

Figuur 6.8: Het instructieset-stroomschema van de CISC processor.


IR← Mem[PC]PC← PC + 1

00011011

IR15IR14

00011011

IR13IR12

RF[d]← RF[s1]>>N

(a) Stroomschema.

S0

S1

PC← PC + 1IR← Mem [PC]

IR15

IR14

IR13

IR12

RF [d]← RF [s1] n

(b) Tussentoestand.

Figuur 6.9: Stroomschema naar ASM-schema voor de ASR-instructie.


00011011

IR15IR14

01

IR13

01

IR12

000001010011100101110111

IR11IR10IR9

RF[d]← Mem[PC]

PC← PC + 1

(a) Stroomschema.

S0

S1


IR15

IR14

IR13

IR12IR11

IR10

IR9

PC [d]← Mem [PC]PC← PC + 1

(b) ASM-schema.

Figuur 6.10: Stroomschema naar ASM-schema voor de LOAD constante-instructie.



00011011

IR15IR14

01

IR13

01

IR12

000001010011100101110111

IR11IR10IR9

RF[d]← Mem[Mem[PC]]

PC← PC + 1

(a) Stroomschema.

S0

S1

S2


IR15

IR14

IR13

IR12IR11

IR10

IR9

AR← Mem [PC]PC← PC + 1

RF [d]← Mem [AR]

(b) Tussentoestand.

Figuur 6.11: Stroomschema naar ASM-schema voor de LOAD direct-instructie.



00011011

IR15IR14

01

IR13

01

IR12

000001010011100101110111

IR11IR10IR9

RF[d]← Mem[Mem[Mem[PC]]]

PC← PC + 1

(a) Stroomschema.

S0

S1

S3 S4


IR15

IR14

IR13

IR12IR11

IR10

IR9


AR← Mem [AR] RF [d]← Mem [AR]

(b) Tussentoestand.

Figuur 6.12: Stroomschema naar ASM-schema voor de LOAD indirect-instructie.



00011011

IR15IR14

00011011

IR13IR12

Mem[RF[s1]]← PC + 1RF[s1]← RF[s1] + 1PC← Mem[PC]

(a) Stroomschema.

S0

S1

S5


IR15

IR14

IR13

IR12


Mem [RF [s1]]← PCRF [s1]← RF [s1] + 1PC← AR

(b) Tussentoestand.

Figuur 6.13: Stroomschema naar ASM-schema voor de JSR-instructie.


00011011

IR15IR14

00011011

IR13IR12

RF[s1]← RF[s1]− 1PC← Mem[RF[s1]]

(a) Stroomschema.

S0

S1


IR15

IR14

IR13

IR12

RF [s1]← RF [s1]− 1PC← Mem [RF [s1]− 1]

(b) Tussentoestand.

Figuur 6.14: Stroomschema naar ASM-schema voor de RTS-instructie.


PC Mem IR

+1

LIFO

NextStateLogic

OutputLogic

CSSS

CI CO

Figuur 6.15: Het ontwerp van een CISC-controller met programmateller, geheugen en instructieregister.

PC Mem IR

+1

LIFO

NextState

&OutputLogicFSM

CSSS

CI CO

Figuur 6.16: Het ontwerp van een CISC-controller met interne eindige toestandsautomaat.


PC Mem IR+1

NextState

&OutputLogicFSM

CSSS

CI CO

Figuur 6.17: Controller met samengevoegd geheugen en stapelgeheugen.

PC IR+1

NextState

&OutputLogicFSM

AdresbusDatabus

Mem

Data&Prog.

CSSS

CI CO

Figuur 6.18: Controller met extern geheugen (Von Neumann-architectuur).


RF8× 16

AR Status

Shift ALU Comp

AdresbusDatabus

Mem

Data&Prog.

Figuur 6.19: De basis datapad-ontwerp van de CISC-processor.

PC IR+1

NextState

&OutputLogicFSM

AdresbusDatabus

Mem

Data&Prog.

CSSS

CI CO

Figuur 6.20: De uiteindelijke controller van de CISC-processor.


RF8× 16

AR Status

Shift ALU Comp

AdresbusDatabus

Mem

Data&Prog.

Figuur 6.21: Het datapad-ontwerp na het aanbrengen van verbindingen van de CISC-processor.


MemoryInterface

ControlUnit

OperandsFlags

I1

I2

I3

I4

I5

I6

DH DL

CH CL

BH BL

AH AL

DI

SI

BP

SP

IP

ES

SS

DS

CS

Vcc

Vss

Figuur 6.22: De structuur van de 8086 microprocessor.


Port 0Drivers

Port 2Drivers

RAMAddressRegister

RAMPort 0Latch

Port 2Latch

EPROM/ROM

ACCStackPointer

ProgramAddressRegister

B Regis-ter

TMP2 TMP1 Buffer

PC Incre-ment

PSWProgramCounter

DPTR

Port 1Latch

Port 3Latch

Port 1Drivers

Port 3Drivers

Interrupt,Serial Port,and TimerBlocks

Inst

ruct

ion

Reg

iste

rTime andControl

Oscillator

P0.0-P0.7 P2.0-P2.7

P1.0-P1.7 P3.0-P3.7XTAL1

XTAL2

PSEN*

ALE/PROG*

EA*/PP

RST

Vcc

Vss

Figuur 6.23: De structuur van de 8051 microcontroller.


Adress RegisterScan

Control

AddressIncrementer

Register bank(31× 32-bit registers)

(6 status registers)

Multiplier

Barrelshifter

Write Data RegisterInstruction Pipeline &Read Data Register &

Thumb Instruction Decoder

InstructionDecoder

& ControlLogic

DBGRQI

BREAKPTDBGACKECLK

EXEC*ISYNCBL[3:0]

APEMCLK

WAIT*RW*MAS[1:0]

IRQ*FIQ*

RESET*ABORT

TRANS*MREQ*

OPC*SEQ

LOCK

CPI*CPACPBM*[4:0]

TBETBITHIGHZ

A[31:0]

ALE ABE

D[31:0]ENOUT*

DBE

ENIN*

Vcc

Vss

Figuur 6.24: De structuur van de ARM7 microprocessor.

Figuur 6.25: De pipelining-structuur van de ARM11 microprocessor.

Deel IV

Very High Speed Integrated CircuitHardware Description Language

261

Hoofdstuk 7

VHDL

In redelijke taal weerklinkt wat in werkelijkheid gebeurt.“”- Gerard Bolland, Nederlands taalkundige en filosoof (1854-1922)

VHDL is een taal waarmee hardware kan worden beschreven. Hetwordt gebruikt om elektronische schakelingen te genereren, simule-ren, analyseren, enzovoort.

7.1 Elementen van de VHDL-taal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

7.1.1 Lexicale elementen (woordenschat) . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

7.1.2 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

7.1.3 Identifiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

7.1.4 scheidingstekens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

7.1.5 Commentaar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.2 Typesysteem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.2.1 Voorgedefinieerde types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

7.2.2 Zelf types definieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266

Definieren met opsomming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

Definieren met subtypering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

Definieren van fysische types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

Definieren van matrices en vectoren (“array aggregate”) . . . . . . . . . . . . . . . 269

7.3 Objecten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270

7.3.1 Constante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

7.3.2 Variabele . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

7.3.3 Signaal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272

Logische signalen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273

7.4 Bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

7.4.1 Logische bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

7.4.2 Rekenkundige bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

7.4.3 Schuifoperaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

7.4.4 Vergelijkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

7.4.5 “Array aggregaat” bewerkingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

7.5 Bibliotheken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277

7.6 Combinatorische schakelingen in VHDL . . . . . . . . . . . . . . . . . . . . . . . 277

263

264 HOOFDSTUK 7. VHDL

7.6.1 Hardwarebeschrijving met VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Structurele beschrijving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Gedragsbeschrijving . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Repetitieve structuren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

7.7 Sequentiele schakelingen in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . 278

7.8 Processoren in VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

7.8.1 Leidend voorbeeld: sha1 checksum . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

VHDL-proces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

7.9 VHDL grammatica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280

7.10 Programmeerjargon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

7.1 Elementen van de VHDL-taal

In deze sectie bespreken we de verschillende elementen van de VHDL-taal. Een opsomming van de mogelijkesleutelwoorden en andere karaktersequenties met hun betekenis wordt doorgaans de “syntax” van de taalgenoemd. In deze sectie lichten we de verschillende sleutelwoorden toe. In de rest van dit hoofdstuk zullenwe dan de betekenis (ofwel “semantiek”) bespreken.

7.1.1 Lexicale elementen (woordenschat)

Elk code-bestand1 bestaat uit een sequentie van lexicale elementen die men tokens noemt. We zullen eerstde verschillende lexicale elementen die in VHDL-code kunnen voorkomen beschrijven. Deze kunnen we dan alsterminologie gebruiken. De tokens kunnen verder worden onderverdeeld in: literals (deze vertegenwoordigenbepaalde waardes zoals getallen, tekst,...), identifiers (dit zijn namen van variabelen, functies, componen-ten,... gebruikt om naar te refereren en definieren), scheidingstekens2 (haakjes en andere symbolen diewaardes en identifiers combineren) en commentaar. We beschrijven de verschillende soorten tokens verderin de volgende subsecties.

7.1.2 Literals

We onderscheiden vier soorten literals: getallen, karakters, karakterreeksen en bitreeksen. We overlopen deverschillende types. In VHDL is er ook nog sprake van enumeration literals en van de NULL literal, dezeliterals worden niet beschouwd.

Getal Een getal (ook wel “abstract literal” genoemd) is een numerieke waarde. Net als bij program-meertalen onderscheid men verschillende soorten numerieke waarden:

• universal integer: dit zijn numerieke literals die geen decimale komma (.) bevatten, bijvoorbeeld1425. Deze getallen zijn vergelijkbaar met het int-type in Java3.

• universal real: dit zijn numerieke getallen die wel een decimale komma bevatten. Bijvoorbeeld1425.1917. Merk op dat indien er enkel nullen achter de komma staan dat het getal dezelfde waardeheeft als een universal integer: 1425.0, maar daarom niet dezelfde representatie. In Java zoudenwe dit type voorstellen met bijvoorbeeld een float of double.

• physical types: dit zijn fysische waarden. Fysische waarden bestaan uit een getal gevolgd door eenfysische eenheid. Er wordt een spatie tussen het getal en de eenheid gezet. Bijvoorbeeld: 1818 ns. Dittype heeft geen echt equivalent in de meeste programmeertalen. Immers redeneren programmeertalenmeestal niet over grootheden.

1Onafhankelijk van de taal.2Engels: delimiters.3De vergelijking gaat echter niet geheel op: een int is immers beperkt tot 32 bit en heeft een specifieke representatie.

7.1. ELEMENTEN VAN DE VHDL-TAAL 265

Getallen worden standaard in decimale notatie uitgedrukt. Men kan ze ook in exponentiele vorm schrijvendoor het toevoegen van een ’E’ of ‘e’ op het einde van het getal gevolgd door de exponent, bijvoorbeeld:14e2. Om een andere basis te gebruiken, wordt volgend formaat gebruikt: base#literal#exp, met de basistussen 2 en 16. Zo kunnen we 1425 schrijven als 16#591#, of 4864 als 16#13#E2. Tot slot mag men ook vrijunderscores ( ) toevoegen in een getal om de code leesbaar te houden. Bijvoorbeeld: 19_171_425.

Karakter Een karakter (ofwel “character literal”) slaat een karakter (ofwel character) op: de eenheidvan tekst. Deze literals worden tussen enkele aanhalingstekens (’) geplaatst, bijvoorbeeld ’K’. In Java zouhet equivalent van dit type een char zijn.

Karakterreeks Een karakterreeks (ofwel “string literal”) slaat een sequentie karakters op, dus eentekstfragment. In Java noemt men een dergelijk type een String. Deze reeks wordt tussen dubbele aanha-lingstekens (") geplaatst, bijvoorbeeld "Hello World!". Een probleem doet zich voor wanneer we de dubbeleaanhalingstekens (") zelf in het tekstfragment willen gebruiken. In dat geval dienen we de aanhalingstekensdubbel te plaatsen, bijvoorbeeld:

"""The answer?"" said Deep Thought. ""The answer to what?"""[?, §25]

Bitreeksen Een bitreeks (ofwel “bit string literal”) is een sequentie aan bits (dit is een eenheid vaninformatie die ofwel 0 ofwel 1 is). Een bitreeks wordt geschreven als een sequentie van enen en nullen tussendubbele aanhalingstekens ("). Zoals we al vroeger in deze cursus hebben opgemerkt is zo’n sequentie nietefficient, leesbaar en praktisch. Daarom laat men ook octale en hexadecimale notatie toe. Hiertoe wordt ereen B (binair), O (octaal) of X (hexadecimaal) voor de dubbele aanhalingstekens geplaatst om de bitreeks ineen bepaald formaat te lezen. Bij hexadecimale getallen gebruikt men a, b, c, d, e en f om respectievelijk 10tot 15 voor te stellen. Net als bij getallen kan de gebruiker underscores ( ) toevoegen om tot meer leesbarecode te komen.

7.1.3 Identifiers

Een identifier is een referentie naar een variabele, functie, component,... Dit is vergelijkbaar met de naamvan een variabele, methode, klasse,... in Java. Identifiers beginnen met een letter en mogen letters en cijfersbevatten. Ook de underscore ( ) teken is toegelaten, indien dit niet het eerste of laatste karakter van deidentifier vormt. Identifiers zijn niet hoofdletter gevoelig. In VHDL’93 wordt het begrip van een identifierverder uitgebreid. Deze uitbreiding wordt hier niet beschouwd. Voor meer details [?, p. 4].

Gereserveerde woorden Niet alle namen die aan de hierboven beschreven regels mag men zelf gebrui-ken. Sommige identifiers zijn immers sleutelwoorden die een reeds ingebouwde functie vevullen in VHDL:ze verwijzen naar functies die in de VHDL compiler zijn ingebakken. De woorden in Tabel 7.1 mogen nietgebruikt worden als identifiers.

We onderscheiden verschillende soorten sleutelwoorden: enerzijds zijn er compiler-directieven zoals bij-voorbeeld case en downto, daarnaast zijn er basis-operaties zoals nand en sla, tot slot zijn er ook type-directieven zoals array en signal. Sommige gereserveerde worden werden pas geıntroduceerd in VHDL’93,we gaan hier niet verder op in.

7.1.4 scheidingstekens

Een scheidingsteken (ofwel “delimiter”) tenslotte wordt gebruikt om operaties op gegevens uit te voe-ren, bijvoorbeeld een optelling maar ook een index. De scheidingstekens van VHDL worden weergegeven inTabel 7.2.

We onderscheiden opnieuw verschillende soorten scheidingstekens: tekens die operaties voorstellen (zoals+ en *), tekens die voorwaarden voorstellen (zoals <>), tekens die tekst afbakenen (zoals ( en [) en tekensdie aangeven dat twee fragmenten los van elkaar staan (zoals ,).


abs access after alias all and architecture

array assert attribute begin block body buffer

bus case component configuration constant disconnect downto

else elsif end entity exit file for

function generate generic group guarded if impure

in inertial inout is label library linkage

literal loop map mod nand new next

nor not null of on open or

others out package port postponed procedure process

pure range record register reject rem report

return rol ror select severity shared signal

sla sll sra srl subtype then to

transport type unaffected units until use variable

wait when while with xnor xor

Tabel 7.1: Gereserveerde woorden in VHDL.

& ’ ( ) *

+ , - . /

: ; < = >

| [ ] => **

:= /= >= <= <>

Tabel 7.2: Scheidingstekens in VHDL.

7.1.5 Commentaar

Commentaar zijn delen van de code die genegeerd worden door de VHDL-compiler, maar die nuttig zijn voorprogrammeurs: ze bevatten gegevens over het project en richtlijnen die een belangrijke rol kunnen hebbentijdens het project. Commentaar plaatst men na twee horizontale strepen -- en reikt tot het einde van delijn. Dit is vergelijkbaar met de dubbele slash (//) in Java.

7.2 Typesysteem

VHDL is getypeerd: een variabele slaat data op volgens een bepaald type, dit type geeft een interpretatie aanzowel de data en de operatoren die erop gedefinieerd zijn. De types kunnen bovendien door de programmeuruitgebreid worden. Men vertrekt echter steeds van basistypes.

7.2.1 Voorgedefinieerde types

Ook in de VHDL-secties werden sommige van deze types reeds gebruikt. Tabel 7.2(a) geeft een overzicht vande meest populaire basistypes.

Naast deze reeks van basistypes bevat VHDL ook standaard enkele afgeleide types. Het zijn types die eengereduceerd bereik uit de basistypes vertegenwoordigen. Deze subtypes staan in Tabel 7.2(b) samen methun gereduceerd bereik.

7.2.2 Zelf types definieren

Hoe definieren we nu zelf types? Afhankelijk van het soort type dat we willen bouwen zijn er verschillendemogelijkheden:

• opsomming;

7.2. TYPESYSTEEM 267

(a) Overzicht van belangrijke types in VHDL.

Type Bereik Operatoren (prioriteit)

INTEGER

ABS, **−2 147 483 647 *, /, MOD, REM

tot + (unair), - (unair)2 147 483 647 + (binair), - (binair)

=, /=, <, <=, >, >=

REAL

ABS, **−1.0E38 *, /

tot + (unair), - (unair)1.0E38 + (binair), - (binair)

=, /=, <, <=, >, >=

TIME

−2 147 483 647 ABS

tot *, /2 147 483 647 + (unair), - (unair)fs, ps, ns, us + (binair), - (binair)ms, sec, min, hr =, /=, <, <=, >, >=

BIT ‘0‘ of ‘1‘NOT

=, /=, <, <=, >, >=AND, NAND, OR, NOR, XOR, XNOR

BIT VECTOR onbegrensde rij BIT

NOT

&

SLL, SRL, SLA, SRA, ROL, ROR=, /=, <, <=, >, >=AND, NAND, OR, NOR, XOR, XNOR

CHARACTER 256 karakters (ASCII)

STRING onbegrensde rij van CHARACTERs

(b) Overzicht van belangrijke afgeleide types in VHDL.

Type Bereik Operatoren (prioriteit)

NATURAL 0 tot INTEGER’HIGH equivalent aan INTEGER

POSITIVE 1 tot INTEGER’HIGH equivalent aan INTEGER

DELAY LENGTH 0 fs tot TIME’HIGH equivalent aan TIME

Tabel 7.3: Overzicht van belangrijke types en afgeleide types in VHDL.

• subtypering (beperk het bereik);

• fysische types; en

• Afgeleide types met matrices en vectoren.

De lijst is niet exhaustief: VHDL bevat ook constructies om bijvoorbeeld records aan te maken, dezeconstructies vallen buiten het bereik van deze cursus.

We bespreken de verschillende methodes nu in meer detail.

Definieren met opsomming

We kunnen een type specificeren door alle mogelijke toestanden op te sommen. Deze methode wordt toege-past voor bijvoorbeeld de types bit en byte. De namen of karakters die de toestand bepalen worden tussenhaakjes opgesomd na het sleutelwoord is. Dit doen we na het sleutelwoord type en de identifier voor hettype. VHDL-code 7.1 toont mogelijke definities van bit en byte. We definieren ook het type StateMachine,dit type bevat drie elementen: start, processing en wait die de “toestanden” weergeven van een schakelingdie we bijvoorbeeld zouden kunnen willen bouwen.


VHDL-code 7.1 Definieren van types door opsomming.

1 type b i t i s ( ’ 0 ’ , ’ 1 ’ ) ;2 type boolean i s ( f a l s e , t rue ) ;3 type StateMachine i s ( s t a r t i n g , proce s s ing , wa i t ing ) ;

In Java is de enum de dichtste imitator van het definieren van types aan de hand van opsomming. Immersis het aantal waarden die een enum kan aannemen beperkt. VHDL is echter wel niet (sterk) objectgericht, dusdeze analogie gaat slechts gedeeltelijk op.

Definieren met subtypering

Soms wensen we een type te specificeren die een deelverzameling omvat van een reeds eerder gespecificeerdtype. Zo zal een integer alle waarden omvatten die met 32 bit voor te stellen zijn, het is echter mogelijkdat we bijvoorbeeld een type byte willen specificeren die uitsluitend numerieke waarden bevat die we op 8bit kunnen voorstellen. In dat geval gebruiken we het sleutelwoord subtype gevolgd door een identifier diede naam van het type aanduidt, daarna volgt opnieuw het sleutelwoord is en het “supertype”. VHDL kenttwee soorten beperkingen die hierop kunnen volgen: de “range beperking” en de “index beperking”.

Een “range beperking” omvat twee literals die het begin en het einde markeren van een bereik van waarden.Vermits alle basistypes in VHDL een inherente orde-relatie hebben4 is dit voldoende om altijd alle waardentussen de twee gegeven waarden mee in het bereik te nemen. Syntactisch definieert men een range beperkingmet het sleutelwoord range gevolgd door de laagste waarde gevolgd door het sleutelwoord to gevolgd doorde hoogste waarde.

Voor vectoren kan men gebruik maken van de “index constraint”. Deze beperking zet voorwaarden ophet bereik van de index van de vector. Syntactisch schrijven we tussen haakjes respectievelijk de laagsteof hoogste waarde gevolgd door respectievelijk het sleutelwoord to of downto en daarna respectievelijk dehoogste of laagste waarde. In VHDL hoeft men geen getal als index te gebruiken: ook karakters kunnenbijvoorbeeld voor dit doel worden aangewend. Bovendien is het mogelijk dat een lijst multidimensionaal isen er dus verschillende indices moeten beperkt. In dat geval worden de indices gescheiden door komma’s.Omdat deze cursus slechts een inleiding tot VHDL wil geven zullen we deze uitzonderlijke situaties niet verderbeschouwen. We verwijzen dan ook naar [?].

VHDL-code 7.2 lijkt enkele definities van types op aan de hand van subtypering. Zo definieren we de byte

aan de hand van een integer en het type lowercase is een deelverzameling van de character. Tot slotdefinieren we ook een type InputVector die een sequentie bits voorstelt waarvan de index loopt van 7 tot 3.

VHDL-code 7.2 Definieren van types door subtypering.

1 subtype byte i s i n t e g e r range 0 to 255 ;2 subtype l owercase i s cha rac t e r range ’ a ’ to ’ z ’ ;3 subtype InputVector i s b i t v e c t o r (7 downto 3) ;

Er bestaan in Java geen duidelijk equivalent van definities aan de hand van subtypering. Natuurlijkkan men wel subklassen definieren met behulp van het sleutelwoord extends, maar in Java heeft men demogelijkheid extra velden toe te voegen. De beste analogie is misschien een speciale constructor die bijaanmaak van een object na zal gaan of de gewenste waarde wel degelijk mogelijk is.

4Voor karakters maakt men gebruik van de ASCII-code.

7.2. TYPESYSTEEM 269

Definieren van fysische types

Soms dienen we ook te werken met fysische types: types met een zekere eenheid. Zo is de periode van hetkloksignaal een tijdsverschil die we dienen uit te drukken in een zekere tijdseenheid.

VHDL ziet fysische eenheden eerder als getallen, maar met bijgevoegde constanten die de “eenheden” vor-men. Zo kan men bijvoorbeeld gewicht definieren als een getal tussen 0 en 1′000′000 met drie eenheden: degram, de kilogram en de ton.

VHDL-code 7.3 toont aan de hand van voorbeelden hoe we een fysische eenheid definieren. We vermeldenopnieuw het sleutelwoord type gevolgd door de identifier van het type. Daarna bakenen we het type af aande hand van een “range beperking”, in een units blok definieren we vervolgens de eenheden als “virtueleconstanten”. Het eenheden-blok bestaat altijd uit minstens een eenheid-identifier: de “primaire eenheid”. Deprimaire eenheid heeft altijd een waarde gelijk aan 1 en specificeert bijgevolg ook meteen de nauwkeurigheid.Zo kunnen we in het voorbeeld geen gewichten voorstellen met een nauwkeurigheid van een microgram:immers drukken we elk gewicht uit in gram. Daarna volgen optioneel andere eenheden, deze eenheden gaanaltijd gepaard met een toekenning van een reeds gekende eenheid. Zo is bijvoorbeeld een kilogram hetequivalent van 1′000 gram. VHDL zal al deze eenheden doorrekenen als constanten. Een ton krijgt dus dewaarde 1′000′000. Een code-blok wordt beeindigd met het end sleutelwoord waarna het soort blok wordtherhaald.

VHDL-code 7.3 Definieren van fysische types.

1 type Weight i s range 0 to 1 000 00002 units3 gr ;4 kg = 1000 gr ;5 ton = 1000 kg ;6 end units ;78 type Distance i s range 0 to 10 000 000 0009 units

10 pm;11 nm = 1000 pm;12 um = 1000 nm;13 mm = 1000 um;14 end units ;

Er is opnieuw geen echt equivalent in Java. Men kan natuurlijk ook constanten definieren en deze bijvoor-beeld gr en kg noemen. Fysische types zijn echter meer getallen waar men een soort afspraak maakt hoedeze getallen een fysische grootheid zullen voorstellen.

Definieren van matrices en vectoren (“array aggregate”)

Tot slot kunnen we ook types ook verder gebruiken bij de constructie van vectoren matrix-types. Dithebben we bovendien al eerder gedaan: de bit vector is een array aggregate van het basistype bit.

VHDL kent twee soorten vector-types: begrensde (“constrained”) en ongebonden (“unconstrained”). In hetgeval van een begrensde vector wordt het aantal elementen gespecificeerd samen met het type5, terwijl inhet geval van een ongebonden vector er geen beperking op de index wordt gezet.

5Dus niet bij de declaratie van een object van dat type.


In het geval van begrensde vectoren specificeren we het type met het sleutelwoord type gevolgd door deidentifier van het type. Daarna schrijven we is array daarna volgt de “index beperking” (zie eerder) enhet sleutelwoord of tot slot dienen we ook het basistype te specificeren. Zoals reeds eerder gezegd hoefteen “index beperking” niet altijd te slaan op een bereik van een numerieke index. In VHDL-code 7.4 gevenwe twee voorbeelden. In het eerste geval gebruiken we een numerieke index. In het tweede geval makenwe gebruik van het eerder geıntroduceerde type StateMachine (zie VHDL-code 7.1), vermits een opsommingbeperkt is in lengte de vector dit bijgevolg ook. Wanneer we meerdimensionale vectoren willen specificerenscheiden we de verschillende indices aan de hand van een komma (,).

In het geval van een onbegrensde vector schrijven we als “index beperking” de identifier van een (eerdergedefinieerd) type gevolgd door het range sleutelwoord en daarna het <> scheidingsteken. Een voor de handliggend type om te gebruiken als index is het natural type: de natuurlijke getallen zoals dit ook als indexin Java wordt gebruikt. Onbegrensde vectoren worden meestal als associatieve lijsten opgeslagen: enkelwanneer een index wordt toegekend wordt deze opgeslagen6. Men kan natuurlijk ook combinaties makenvan begrensde en onbegrensde indices: bijvoorbeeld een matrix waar de eerste index begrensd is maar detweede niet. Op VHDL-code 7.4 tonen we een voor de hand liggende declaratie van een onbegrensde vectorvan real objecten.

VHDL-code 7.4 Definieren van matrix types.

1 −− Begrensd2 type word i s array (15 downto 0) of b i t ;3 type AConstrainedArray i s array ( StateMachine , 1 to 3) of b i t ;45 −− Onbegrensd6 type AnUnconstrainedArray i s array ( natura l range <>) of r e a l ;

Er bestaat geen equivalentie in Java. Men kan argumenteren dat het declareren van een array een vastelengte heeft en dus zou kunnen overeenkomen met een begrensde array. Deze begrenzing manifesteert zichechter op instantie-niveau en niet op type-niveau. Wanneer we deze analogie wel zouden gebruiken kan eenonbegrensde vector worden gezien als een HashMap.

7.3 Objecten

Types beschrijven enkel het soort waarden die een object (ofwel instantie) kunnen voorstellen. Types zijndaarom nuttig omdat de VHDL-compiler consistentie kan controleren. Een programma werkt echter in deeerste plaats met objecten.

Een object is een benoemd item (aan de hand van een identifier) met een specifieke waarde. We onder-scheiden 3 soorten objecten:

1. constante: een object met een vaste waarde. Deze waarde wordt eenmaal ergens in het programmabepaald en kan in de rest van de code gebruikt worden;

2. variabele: een object met een waarde die kan veranderen doorheen het programma. Een variabeleverandert meteen van waarde en heeft dus geen echte band met de “werkelijkheid”; en

3. signaal: een object die de toestand van een draad, in- of uitgang of een andere fysische toestandvoorstelt. De waarde verandert enkel nadat er een zekere tijd is verstreken.

We bespreken de verschillende soorten objecten hieronder in meer detail samen met de bijbehorendesyntax en semantiek.

6Indien de index immers niet begrensd is zou men anders oneindig veel geheugen nodig hebben om zo’n lijst op te slaan.

7.3. OBJECTEN 271

7.3.1 Constante

Constanten worden gebruikt om aan een ontwerp parameters toe te kennen. Stel dat we bijvoorbeeld eenprocessor wensen te ontwerpen, maar nog niet bepaald hebben hoe groot het operand gedeelte van deoperand in een instructie moet worden, kunnen we hiervoor een constante toekennen. Wanneer we dan latervan operandgrootte willen veranderen, dienen we enkel de constante aan te passen. Constanten zijn dusbenoemde waarden die door de VHDL-compiler op alle plaatsen waar de constante wordt aangeroepen zullenworden vervangen door de werkelijke waarde.

We specificeren een constante aan de hand van het constant sleutelwoord, vervolgens specificeren we denaam en het type. We plaatsen het : tussen de naam en het type. Na het := scheidingsteken plaatsen weeen waarde of een expressie. Het algemene formaat is dus:

constant identifier : type := expressie; (7.1)

In plaats van een waarde kunnen we ook een expressie specificeren. In zo’n expressie mogen we waardenen constanten schrijven en operaties hiertussen. Het gebruik van variabelen is natuurlijk niet toegelatenvermits de waarde van deze variabelen niet op voorhand gekend is en kan veranderen.

VHDL-code 7.5 Definieren van constanten.

1 constant pi : r e a l := 3 .14159265 ;2 constant byte l eng th : natura l := 8 ;3 constant word length : natura l := 4∗ byte l eng th ;

VHDL-code 7.5 toont enkele voorbeelden van constante-declaraties. Zo definieren we pi en byte length

aan de hand van waarden, word length wordt gedefinieerd aan de hand van een expressie waarin zowel eenwaarde en een constante betrokken zijn.

7.3.2 Variabele

Een variabele is een VHDL-object die wel van waarde kan veranderen. Ze worden tijdens de uitvoer gebruiktdoor de VHDL-compiler, bijvoorbeeld om te bepalen hoeveel klokflanken een component moet wachten alvorensweer van waarde te veranderen, of wanneer de compiler bijvoorbeeld een tweede maal door de een lus gaatander gedrag te bewerkstelligen.

Omdat een variabele van waarde kan veranderen zijn er twee soorten toekenningen: de “declaratie” ende “assignatie”. Bij de declaratie stelt men de variabele voor samen met een type en optioneel een initielewaarde, bij de assignatie geeft met de variabele een nieuwe waarde.

Bij de declaratie gebruikt men het sleutelwoord variable gevolgd door de naam van de variabele, het :

scheidingsteken en het type van de variabele. Optioneel voegt men hierna nog het := scheidingsteken toemet een expressie de de eerste waarde voor de variabele oplevert. Een algemeen formaat7 is dus:

variable identifier : type [:= expressie]; (7.2)

Bij de assignatie kent men een nieuwe waarde toe. Dit doet men door de identifier van de variabele tevernoemen gevolgd door het := scheidingsteken en een expressie voor de nieuwe waarde, of formeler:

identifier := expressie; (7.3)

7Delen van de formaat-declaratie die tussen vierkante haken staan zijn optioneel.


Voorbeelden van werken met variabelen staan in VHDL-code 7.6. In de code wordt de declaratie van index

getoond zonder directe assignatie. Later kennen we achtereenvolgens 0 en 1 toe aan index. We declarerenook twaalf en geven deze variabele de waarde 12. We declareren ook viertwee die de waarde 42 krijgt8.tenslotte hogen we index voor de laatste keer op.

VHDL-code 7.6 Werken met variabelen.

1 variable index : i n t e g e r ; −−d e c l a r a t i e2 index := 0 ; −−a s s i g n a t i e3 index := index + 1 ; −−a s s i g n a t i e4 variable twaa l f : na tura l := 12 ; −−d e c l a r a t i e met a s s i g n a t i e5 variable v i e r twee : natura l := 4∗ twaal f−6∗ index ; −−d e c l a r a t i e met a s s i g n a t i e6 index := index + 1 ; −−a s s i g n a t i e

7.3.3 Signaal

Een signaal ten slotte is het VHDL-equivalent van een fysische verbinding of een groep van verbindingen in dehardware. Een toekenning bij een signaal is niet direct: de expressie wordt niet louter geevalueerd. Wanneerde betrokken signalen waarop de toekenning steunt later veranderen, zal het signaal zelf ook veranderen.

Een signaal wordt gedeclareerd door het sleutelwoord signal gevolgd door de identifier van het signaal enna een dubbele punt (:) het type van het signaal. Optioneel volgt ook een assignatie gedeelte, of formeler:

signal identifier : type [<= expressie]; (7.4)

Bij een “assignatie” plaatsen we eerst de identifier van het object gevolgd door de <= operator en deexpressie, of formeler:

identifier <= expressie; (7.5)

Zoals reeds eerder vermeld werkt de toekenning bij een signaal anders dan bij de toekenning van eenvariabele en constante. VHDL laat bovendien slechts een toekenning toe per signaal (die mogelijk uitgesteldkan worden en beslist op de waarde van variabelen). In het andere geval betekent dit immers dat eendraad wordt aangestuurd door twee verschillende expressies en dus kortsluiting kan veroorzaken. Hoe we ditprobleem kunnen oplossen bespreken we in deze sectie.

VHDL-code 7.7 Werken met signalen.

1 signal a : b i t <= ’ 1 ’ ; −−Dec la ra t i e met a s s i g n a t i e2 signal b : b i t ; −−Dec la ra t i e3 signal y : b i t ; −−Dec la ra t i e4 y <= a and b ; −−Ass i gna t i e met e xp r e s s i e5 b <= ’0 ’ , ’ 1 ’ after 100 ns ; −−Ass i gna t i e met t i j d b e p e r k i n g

In VHDL-code 7.7 beschouwen we drie signalen van het type bit: a, b en y. De signalen hebben dus ofwelde waarde ’0’ of ’1’. a kennen we de constante ’1’ toe. Het signaal blijft dus constant. Bij b kennen wede waarde ’0’ toe, maar na 100 nanoseconden wordt het signaal ’1’. Wanneer we y gelijk stellen aan eenAND-operatie tussen a en b. Het signaal van y zal dus gelijk zijn aan ’0’, maar na 100 nanoseconden (eneen zekere vertraging) wordt de waarde gelijk aan ’1’.

8Op dat moment heeft index nog de waarde 1.

7.3. OBJECTEN 273

Logische signalen

We hebben reeds het type bit gedefinieerd. Dit type neemt twee waarden aan: ’0’ en ’1’, dit lijkt eenideaal type bij het werken met signalen. In de praktijk zijn deze waarden echter ontoereikend om hardwarete beschrijven. In de cursus hebben we bijvoorbeeld al vaak de toestand “hoog impedant” aangehaald:een toestand waarbij de draad aan geen enkel deel van het circuit aangelegd wordt. Deze toestand wordtbijvoorbeeld gebruikt bij de realisatie van een bus. Om meer toestanden te kunnen voorstellen, werd IEEE1164 opgesteld. Dit zijn de verschillende toestanden waarin een draad zich kan bevinden, een verrijktbit-type dus.

IEEE 1164 introduceert onder meer twee nieuwe types: std logic en std ulogic. Beide types bevattenvolgende elementen:

1. ’U’: een niet-geıntialiseerd signaal (bijvoorbeeld bij het opstarten van hardware);

2. ’X’: een sterk aangestuurd maar onbekend signaal;

3. ’0’: een sterk aangestuurde logische 0;

4. ’1’: een sterk aangestuurde logische 1;

5. ’Z’: hoog-impedant (niet aangestuurd);

6. ’W’: een zwak aangestuurde maar ongekend signaal;

7. ’L’: een zwak aangestuurde logische 0;

8. ’H’: een zwak aangestuurde logische 1; en

9. ’-’: don’t care (’0’ of ’1’).

VHDL-code 7.8 De definitie van std logic en std ulogic (IEEE 1164).

1 type s t d u l o g i c i s (2 ’U’ , −−n i e t g e i n i t i a l i s e e r d ( ops tar t en )3 ’X’ , −−s t e r k aangestuurd , maar ongekend4 ’ 0 ’ , −−s t e r k aangestuurde l o g i s c h e 05 ’ 1 ’ , −−s t e r k aangestuurde l o g i s c h e 16 ’Z ’ , −−hoog impedant ( n i e t aangestuurd )7 ’W’ , −−zwak aangestuurd , maar ongekend8 ’L ’ , −−zwak aangestuurde l o g i s c h e 09 ’H’ , −−zwak aangestuurde l o g i s c h e 1

10 ’− ’ −−don ’ t care ( ’0 ’ o f ’1 ’ )11 ) ;1213 type s t d u l o g i c v e c t o r i s array ( natura l range <>) of s t d u l o g i c ;1415 function r e s o l v e d ( s : s t d u l o g i c v e c t o r ) return s t d u l o g i c ;1617 type s t d l o g i c i s r e s o l v e d s t d u l o g i c ;1819 type s t d l o g i c v e c t o r i s array ( natura l range <>) of s t d l o g i c ;

VHDL-code 7.8 toont hoe we de types zouden kunnen definieren. Bij deze code zien we dat std logic wordtgedefinieerd met behulp van std ulogic, maar dat er ook nog een extra identifier bij deze declaratie staat:resolved. Deze identifier wijst naar een functie waarvan de signatuur eerder in de code werd gedefinieerd.Deze functie wordt gebruikt om meervoudige toekenning mogelijk te maken: stel dat we een bus zoudenschrijven in VHDL, dan zullen we de poorten van verschillende componenten toewijzen aan eenzelfde signaal.


Zoals echter al opgemerkt laat VHDL dit niet toe, tenzij we een resolutie-functie resolved9 definieren die regelsspecificeert hoe een verzameling aan signalen – de std ulogic vector – worden omgezet in een type. VHDLzal dus bij meervoudige toekenning een soort virtueel “bus”-component bijvoegen met invoer alle mogelijkesignalen die op de bus worden aangebracht en als uitvoer het signaal die op de “werkelijke” bus staat.

De resolved functie doet dus dienst als een operator die gegeven verschillende signalen, een consensus-signaal moet berekenen. IEEE berekent zo’n signaal aan de hand van een tweedimensionale tabel res table

die twee signalen omzet in een signaal. Deze tabel staat beschreven in Tabel 7.4.

⊕ ’U’ ’X’ ’0’ ’1’ ’Z’ ’W’ ’L’ ’H’ ’-’

’U’ ’U’ ’U’ ’U’ ’U’ ’U’ ’U’ ’U’ ’U’ ’U’

’X’ ’U’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’

’0’ ’U’ ’X’ ’0’ ’X’ ’0’ ’0’ ’0’ ’0’ ’X’

’1’ ’U’ ’X’ ’X’ ’1’ ’1’ ’1’ ’1’ ’1’ ’X’

’Z’ ’U’ ’X’ ’0’ ’1’ ’Z’ ’W’ ’L’ ’H’ ’X’

’W’ ’U’ ’X’ ’0’ ’1’ ’W’ ’W’ ’W’ ’W’ ’X’

’L’ ’U’ ’X’ ’0’ ’1’ ’L’ ’W’ ’L’ ’W’ ’X’

’H’ ’U’ ’X’ ’0’ ’1’ ’H’ ’W’ ’W’ ’H’ ’X’

’-’ ’U’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’ ’X’

Tabel 7.4: Resolutie-tabel voor std logic.

De tabel is reflexief: wanneer de twee signalen gelijk zijn, is de het resultaat ook gelijk aan de invoer. Detabel is ook commutatief: onafhankelijk van welke dimensie we voor welk signaal kiezen levert dit eenzelfdewaarde op. Dit is vanzelfsprekend: anders zouden we immers een signaal in de bus bevoordelen tegenovereen ander signaal. Verder is de tabel ook associatief: wanneer we resolutie ⊕ toepassen op drie verschillendesignalen a, b en c, maakt het niet uit welke twee signalen we eerst uitrekenen: a ⊕ (b⊕ c) = (a⊕ b) ⊕ c,ongeacht de waardes van de signalen. Er is tot slot ook sprake van enige prioriteit: wanneer een signaalde waarde ’U’ heeft aangenomen, is het resultaat sowieso ’U’. Op basis van de tabel kunnen we volgende“prioriteitsregels” opstellen:

’U’ ’X’, ’-’ ’0’, ’1’ ’W’ ’L’, ’H’ ’Z’ (7.6)

Dit betekent dat wanneer we resolutie ⊕ toepassen op twee signalen van een verschillende prioriteitsklasse,het resultaat steeds de waarde van de hoogste prioriteitsklasse wordt gebruikt. Een uitzondering vormt dedon’t care (’-’) die zich als sterk signaal (’X’) gedraagt. Wanneer twee waarden uit dezelfde prioriteitsklassekomen en gelijk zijn is het resultaat evident gelijk aan de invoer-signalen. Wanneer de twee invoer-signalenniet gelijk zijn, is het resultaat het signaal van een prioriteitsklasse hoger, Vergelijking (7.6) zorgt ervoor dattelkens wanneer dit mogelijk is, de prioriteitsklasse erboven slechts een element bevat, de don’t care (’-’)doet zich immers voor als een sterk signaal (’X’).

VHDL-code 7.9 toont hoe we deze resolutie-functie kunnen schrijven in VHDL. Dit code-fragment is bovendieninteressant omdat het inzicht heeft in het ontwikkelen van functies en de verschillende attributen die bij eenvector horen. In de eerste lijnen van de code definieren we de res table: een tabel die de hierbovenbeschreven functie opslaat. De functie resolved wordt dan gebruikt om voor een vector van signalen metwillekeurige grootte een nieuw signaal uit te rekenen. Na de signatuur van de functie volgt een lijst van lokalevariabelen, deze komen voor het function-blok. We declareren de resultaat-variabele result en geven dezede standaard waarde ’Z’. We controleren vervolgens of de vector een lengte heeft die gelijk is aan 1. Ditdoen we door het length attribuut op te vragen van de vector10. Indien de vector een lengte heeft van 1is de resolutie triviaal: we geven dit element terug. Wanneer er sprake is van meer (of minder) elementen.

9We kunnen ook een andere identifier gebruiken.10We krijgen toegang tot een attribuut met de ’-operator, dit is vergelijkbaar met het punt (.) in Java.

7.4. BEWERKINGEN 275

VHDL-code 7.9 Implementatie van de std logic resolutie-functie in VHDL.

1 constant r e s t a b l e : array ( s t d u l o g i c , s t d u l o g i c ) of s t d u l o g i c :=2 −− ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’Z ’ , ’W’ , ’L ’ , ’H’ , ’− ’ ( tweede invoer )3 ( ( ’U’ , ’U’ , ’U’ , ’U’ , ’U’ , ’U’ , ’U’ , ’U’ , ’U’ ) , −− ’U’4 ( ’U’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ ) , −− ’X’ ,5 ( ’U’ , ’X’ , ’ 0 ’ , ’X’ , ’ 0 ’ , ’ 0 ’ , ’ 0 ’ , ’ 0 ’ , ’X’ ) , −− ’0 ’ ,6 ( ’U’ , ’X’ , ’X’ , ’ 1 ’ , ’ 1 ’ , ’ 1 ’ , ’ 1 ’ , ’ 1 ’ , ’X’ ) , −− ’1 ’ ,7 ( ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’ Z ’ , ’W’ , ’ L ’ , ’H’ , ’X’ ) , −− ’Z ’ ,8 ( ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’W’ , ’W’ , ’W’ , ’W’ , ’X’ ) , −− ’W’ ,9 ( ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’ L ’ , ’W’ , ’ L ’ , ’W’ , ’X’ ) , −− ’L ’ ,

10 ( ’U’ , ’X’ , ’ 0 ’ , ’ 1 ’ , ’H’ , ’W’ , ’W’ , ’H’ , ’X’ ) , −− ’H’ ,11 ( ’U’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ , ’X’ ) −− ’− ’12 ) ;1314 function r e s o l v e d ( s : s t d u l o g i c v e c t o r ) return s t d u l o g i c i s15 variable r e s u l t : s t d u l o g i c := ’Z ’ ;16 begin17 i f s ’ l ength = 1 then18 return s ( s ’ low ) ;19 else20 for i in s ’ range loop21 r e s u l t := r e s t a b l e ( r e s u l t , s ( i ) ) ;22 end loop ;23 return r e s u l t ;24 end i f ;25 end function r e s o l v e d ;

We doen dit door het low attribuut op te vragen: de laagste (en enige) index. In het andere geval vouwenwe de vector aan de hand van de accumulator result en de tabel res table. Dit doen we door het range

op te vragen: dit is een verzameling van indices die gedefinieerd zijn voor de vector. Indien er dus sprake isvan een lege vector is het resultaat ’Z’.

Zoals men al uit de code kan afleiden bevat het pakket tot slot ook nog vector-types zoals std logic vector

en std ulogic vector.

7.4 Bewerkingen

We kunnen zoals in VHDL-code 7.9 telkens een tabel aanleggen voor de uitvoer van een functie, maar dit isniet echt praktisch. Bovendien is het mogelijk dat we het bereik van een variabele op voorhand niet kennen.VHDL kent dan ook een groot aantal bewerkingen van verschillende aard. Voor de meeste van deze bewer-kingen hebben we in deze cursus al hardware gesynthetiseerd: bijvoorbeeld een opteller, vermenigvuldiger,schuifoperator. In deze sectie geven we een overzicht van de belangrijkste bewerkingen.

7.4.1 Logische bewerkingen

De logische bewerkingen komen grotendeels overeen met de beschouwden poorten in Hoofdstuk 1. Dit zijndus de not, and, nand, or, nor, xor en xnor11. Behalve de not-operator zijn alle operatoren gedefinieerd mettwee operanden. Logische bewerkingen zijn gedefinieerd op logische types zoals bit, boolean, std logic

en op afgeleide “array aggregaten” zoals de bit vector en std logic vector. Een voorwaarde bij dezevectoren is dat ze van dezelfde lengte zijn: wat zou men immers invullen op plaatsen die maar door eenelementen bepaald zijn?

11xnor is niet beschikbaar is VHDL’87.


7.4.2 Rekenkundige bewerkingen

7.4.3 Schuifoperaties

7.4.4 Vergelijkingen

7.4.5 “Array aggregaat” bewerkingen

Tot slot zijn er nog enkele operaties gedefinieerd op generische12 vectoren. Dit zijn de “concatenate” en de“slice”.

Bij een “concatenate”13 voegen we twee vectoren samen in een nieuwe vector. Fysisch komt dit dus neerop het bundelen van signalen. Een concatenate wordt aangeduid met de & operator: de identifiers van tweevectoren met hetzelfde type worden links en rechts van de operator geschreven, het resultaat is een vectorvan hetzelfde type met de lengte de som van de lengtes van de twee gegeven vectoren. Een typisch voorbeeldis een bus die data vanuit verschillende componenten groepeert en doorstuurt. Stel bijvoorbeeld dat tweecomponenten elk vier bit op de bus willen zetten, kunnen we dit beschrijven zoals in VHDL-code 7.10.

VHDL-code 7.10 Vector aaneenschakeling.

1 signal bus : b i t v e c t o r (7 downto 0) ;2 signal parta , parb : b i t v e c t o r (3 downto 0) ;3 bus <= parta & partb ;4 −− e qu i v a l en t with :5 −− bus (7) <= parta (3)6 −− . . .7 −− bus (4) <= parta (0)8 −− bus (3) <= partb (3)9 −− . . .

10 −− bus (0) <= partb (0)

Zoals ook in het codefragment staat is een aaneenschakeling equivalent met het overlopen van de indicesen de eerste indices toekennen vanuit de eerste operand. Wanneer de eerste operand uitgeput is, wordt detweede operand gebruikt. Het voordeel van de concatenate operator is echter dat men niet op voorhandhoeft te weten over welk bereik de operanden werken.

Bij een “slice”14 halen we een deel van de elementen uit een vector en wordt deze gezien als een op zichzelfstaande vector.

VHDL-code 7.11 Vector matrixdeling.

1 signal bus : b i t v e c t o r (7 downto 0) ;2 signal l a r g e r : b i t v e c t o r (0 to 3) ;3 bus (5 downto 4) <= l a r g e r (1 to 2) ;4 −− e qu i v a l en t with :5 −− bus (5) <= la r g e r (1)6 −− bus (4) <= la r g e r (2)

12Onder generisch verstaan we dat het “element-type” er niet toe doet13Nederlands: aaneenschakeling of concatinatie.14Nederlands: matrixdeel

7.5. BIBLIOTHEKEN 277

7.5 Bibliotheken

Net zoals Java kent VHDL een mechanisme om eerder gedefinieerde deelprogramma’s te groeperen in eenpakket dat dan in een volgend ontwerp kan worden gebruikt. Dit is belangrijk: net zoals men in Java grotedelen van een programma kan hergebruiken voor andere programma’s kan men meestal componenten uit eenvorig project hergebruiken om nieuwe hardware te beschrijven.

VHDL maakt gebruik van twee concepten: “packages” en “libraries”.

Een pakket (“package”) groepeert functies, programma’s, types, constanten, signalen, structuren, enzo-voort die zullen worden gedeeld onder verschillende eenheden. VHDL kent verschillende standaard pakkettenzoals IEEE 1164. Een pakket bestaat doorgaans uit twee delen: de “pakket declaratie” (ook wel “packagedeclaration”) genoemd waarin men samen met de naam van het pakket de verschillende componenten die inhet pakket zitten oplijst, en de “package body” waarin men de opgelijste delen specificeert en implementeert.

Een bibliotheek (“library”) daarentegen is een plaats waar men code en analyses opslaat. Dit is dus eenmap of een databank.

VHDL-code 7.12 Voorbeeld van een “package declaration”.

1 package var i ous i s2 constant hold : time ;3 procedure push ( signal button : inout s t d l o g i c ; hold : time ) ;4 end package var i ous ;

VHDL-code 7.13 Voorbeeld van een “package body”.

1 package body var i ous i s2 constant hold : time := 100 ns ;3 procedure push ( signal button : inout s t d l o g i c ; hold : time ) i s4 begin5 button <= ‘0 ’ , ‘ 1 ’ after hold ;6 end procedure push ;7 end package body var i ous ;

VHDL-code 7.12 en VHDL-code 7.13 tonen respectievelijk een voorbeeld van een “package declaration” en“package body”. Beide voorbeelden hebben betrekking op een pakket various die we willen definieren. Inde “package declaration” schrijven we dat het pakket twee items bevat: een constante hold van het typetime en een procedure push (wat een procedure precies doet is hier niet relevant). In het “package body”dienen we deze abstracte items te binden met betekenis. Zo is de waarde van hold 100 ns en komt push erblijkbaar op neer dat de knop tijdelijk het signaal ‘0’ zal aanleggen.

Om pakketten te definieren en . De bibliotheken work en std zijn altijd beschikbaar.

VHDL laat ook “overloading” toe. Bij overloading kan men eenzelfde functie meerdere malen definierenwanneer het aantal of het type parameters verschilt. Zo kan men een optelling beschrijven op een bit vector

en een integer, en is de uiteindelijke uitwerking transparant naar de gebruiker toe.

7.6 Combinatorische schakelingen in VHDL

In deze sectie zullen we verschillende combinatorische schakelingen die we doorheen de cursus hebben ont-wikkeld beschrijven in VHDL. In deze sectie zullen we eerst een formeel overzicht geven van de VHDL-syntax.


Vervolgens zullen we in subsectie Subsectie 7.6.1 een methode ontwikkelen om combinatorische elementente beschrijven met deze syntax. In elk hoofdstuk zullen we de methodologie uitbreiden zodat we de nieuwecomponenten ook kunnen beschrijven.

7.6.1 Hardwarebeschrijving met VHDL

Structurele beschrijving

VHDL-code 7.14 2-naar-1-multiplexer.

1 −− 2−naar−1 Mu l t i p l e x e r2 −−3 architecture Struct of MUX2 i s4 signal U,V,W : b i t ;5 component AND2 i s6 port (X,Y: in b i t ;7 Z : out b i t ) ;8 end component AND2;9 component OR2 i s

10 port (X,Y: in b i t ;11 Z : out b i t ) ;12 end component OR2;13 component INV i s14 port (X: in b i t ;15 Z : out b i t ) ;16 end component INV ;17 begin18 Gate1 : component INV port map (X=>S , Z=>U) ;19 Gate2 : component AND2 port map (X=>A,Y=>S , Z=>W) ;20 Gate3 : component AND2 port map (U,B,V) ;21 Gate4 : component OR2 port map (X=>W,Y=>V, Z=>Y) ;22 end Struct ;

Gedragsbeschrijving

Repetitieve structuren

7.7 Sequentiele schakelingen in VHDL

7.8 Processoren in VHDL

7.8.1 Leidend voorbeeld: sha1 checksum

Als leidend voorbeeld zullen we een specifieke processor bouwen die de sha1 hash van een boodschap kanberekenen. Een hash is een “samenvatting” van een sequentie data. In het geval van sha1 is deze samenvatting160 bit lang (voor eender welke sequentie aan bits).

Een dergelijke samenvatting kan bijvoorbeeld als handtekening gebruikt worden om te verifieren dat eenhet bestand wel degelijk gemaakt is door de afzender en niet aangepast is door een “man-in-the-middle”. Zokan men een samenvatting van het document genereren en deze bijvoorbeeld via een ander kanaal doorsturen.Wanneer de ontvanger dan ook het originele bestand ontvangt kan deze, door zelf ook de samenvatting uitte rekenen dat men over hetzelfde bestand spreekt. Het is natuurlijk niet uitgesloten dat twee bestanden totdezelfde samenvatting worden herleid, maar het algoritme is zo opgesteld dat “reverse engineering”15 zeermoeilijk is.

15Het analyseren van het resultaat om dit vervolgens uit te buiten.

7.8. PROCESSOREN IN VHDL 279

VHDL-code 7.15 n-bit Opteller.

1 −− Opt e l l e r2 −−3 l ibrary i e e e ;4 use i e e e . s t d l o g i c s i g n e d . a l l ;56 entity adder i s7 generic (n : p o s i t i v e := 4) ;8 port ( Cin : in s t d l o g i c ;9 X,Y : in s t d l o g i c v e c t o r (n−1 downto 0) ;

10 S : in s t d l o g i c v e c t o r (n−1 downto 0) ;11 Cout , Overflow : out s t d l o g i c ) ;12 end adder ;1314 architecture behav of adder i s15 signal Sum : s t d l o g i c v e c t o r (n downto 0) ;16 begin17 Sum <= (X(n−1) & X) + Y + Cin ;18 S <= Sum(n−1 downto 0) ;19 Cout <= Sum(n) ;20 Overflow <= Sum(n) xor X(n−1) xor Y(n−1) xor Sum(n−1) ;21 end behav ;

Algoritme

Het algoritme in pseudo-code staat beschreven in Algoritme 6. Technisch gezien moet het bericht dus uitblokken van 512 bits bestaan en de lengte in bits moet congruent zijn met 448 mod 512. Dit is natuurlijkniet altijd het geval. In dat geval worden 0’en bijgevoegd op het einde van het bestand tot aan de voorwaardeis voldaan. De overige 64 bits in het laatste blok moeten dan worden opgevuld met de lengte van het bestandin bits modulo 264. We gaan er vanuit dat deze stappen al uitgevoerd zijn door de logica die invoer op onzeprocessor aanlegt, we krijgen dus 512-bit blokken aangeleverd met correcte inhoud. Een laatste opmerkingover de invoer is dat indien het bestand bovendien tekst bevat is nog een extra stap nodig, we gaan er hiervanuit dat het bestand binair is, ook deze stappen worden dus niet beschouwd.

Het algoritme leest eerst enkele constanten in h0, h1, . . . , h4. Vervolgens leest het algoritme de verschillendeblokken x in. In een eerste stap wordt het blok opgedeeld in items van 32-bit. Dit impliceert dus 16 items.Men vult de array ~w echter op tot 80 items door een functie toe te passen op de vorige data-elementen. Daarnaworden op basis van de items, a, b, c, d en e aangepast: grotendeels door de variabelen te permuteren enenkele variabelen op te tellen met constanten en het item. Op basis van a, b, c, d en e worden h0, h1, . . . , h4

aangepast. Wanneer alle blokken zijn behandeld, vormt de aaneenschakeling van h0, h1, h2, h3 en h4 hetresultaat.

VHDL-proces

Het algoritme die we voorstellen in Algoritme 6 is niet equivalent met een VHDL-beschrijving van een proces: erontbreekt welke instructie we wanneer zullen uitvoeren, een duurder datapad kan immers meerdere instructiestegelijk uitvoeren. Het is bijvoorbeeld evident dat we a ← h0 en b ← h1 in parallel kunnen uitvoeren. Wekunnen er ook voor opteren om de instructies van de if-lussen in een tijdstap uit te voeren: de controllerbeslist welke instructies moeten worden uitgevoerd en overloopt dus alles if’s tegelijk. We hebben op basisvan het algoritme een procesbeschrijving opgesteld die een redelijke hoeveelheid instructies samenneemtzonder dat dit tot een duur datapad leidt. Het proces is niet gegarandeerd het meest efficiente, maar ditvoorbeeld heeft dit ook niet tot doel.

Zo kunnen we bijvoorbeeld de twee for-lussen in elkaar schuiven. Dit leidt niet enkel tot snellere imple-mentatie, maar bovendien moet de volledige ~w-vector niet worden uitgerekend: we dienen wel 16 × 32-bit


Algorithm 6 Genereren van een sha1 checksum.

1: function Sha1(~x) . ~x is een vector van 512-bit blokken.2: h0 ← 6745230116; h1 ← EFCDAB8916; h2 ← 98BADCFE16; h3 ← 1032547616; h4 ← C3D2E1F016

3: for x ∈ ~x do4: a← h0; b← h1; c← h2; d← h3; e← h4

5: for i = 0 to 15 do . Elke wi telt 32-bit.6: wi ← x shr 32 · i7: end for8: for i = 16 to 79 do . Blok wordt uitgebreid naar 80× 32-bit.9: wi ← (wi−3 xor wi−8 xor wi−14 xor wi−16) rol 1

10: end for11: for i = 0 to 79 do12: if 0 ≤ i ≤ 19 then13: f ← (b and c) or ((not b) and d); k ← 5A82799916

14: else if 20 ≤ i ≤ 39 then15: f ← b xor c xor d; k ← 6ED9EBA116

16: else if 40 ≤ i ≤ 59 then17: f ← (b and c) or (b and d) or (c and d); k ← 8F1BBCDC16

18: else . 60 ≤ i ≤ 7919: f ← b xor c xor d; k ← CA62C1D616

20: end if21: t← (a rol 5) + f + e+ k + wi; e← d; d← c; c← b rol 30; b← a; a← t22: end for23: h0 ← h0 + a; h1 ← h1 + b; h2 ← h2 + c; h3 ← h3 + d; h4 ← h4 + e24: end for25: return (h0 shl 128) or (h1 shl 96) or (h2 shl 64) or (h3 shl 32) or h4

26: end function

bij te houden om de vorige waarden van ~w op te slaan. Merk op dat dit dus een 512-bit geheugen vormt:precies evenveel als de invoergrootte. Dit is niet toevallig: het laat toe om een schuifregister te gebruiken enzo het sha1 algoritme efficient in hardware te implementeren.

Signalen versus variabelen

7.9 VHDL grammatica

Een programmeertaal beschrijft men meestal aan de hand van een (geannoteerde) context-vrije grammatica.Zo’n grammatica bestaat uit “productieregels”. Een productieregel bestaat aan de linkerkant uit een een“non-terminal” en aan de rechterkant uit een sequentie van “terminals” en non-terminals. Een non-terminalis een symbool waarop verdere productieregels kunnen worden toegepast. Een terminal is een elementen uitde taal zelf, bijvoorbeeld een sleutelwoord of karakter. Een programma is geldig wanneer men vanuit destart non-terminal een sequentie van terminals kan genereren die equivalent is met dat programma.

Om een grammatica compacter voor te stellen maakt men doorgaans gebruik van extra componenten. Zozijn elementen aan de rechterkant van een productie-regel tussen vierkante haken optioneel. Ze zijn nietverplicht bij een productieregel. Wel is het zo dat alles wat tussen vierkante haakjes staat samengenomenmoet worden: wanneer twee elementen binnen dezelfde vierkante haken staan, worden beide elementengenegeerd, of allebei toegevoegd. Een tweede vorm van syntactische suiker zijn accolades. Deze wordengebruikt bij herhaling van een groep elementen: de elementen binnen acculades worden nul, een of meerderekeren herhaald. Doorgaans zal het laatste element binnen de accolades een terminal zijn: het scheidingstekentussen twee groepen elementen.

7.10. PROGRAMMEERJARGON 281

VHDL-code 7.16 Beschrijving van de procedure om de sha1 uit te rekenen.

1 l ibrary i e e e ;2 use i e e e . s t d l o g i c 1 1 6 4 . a l l ;34 entity shaca l c i s5 port (6 c l k : in s t d l o g i c ;7 data : in s t d l o g i c v e c t o r (511 downto 0) ;8 enable : in s t d l o g i c ;9 s i g n a t u r e : out s t d l o g i c v e c t o r (159 downto 0) ;

10 done : out s t d l o g i c ;11 ) ;12 end entity shaca l c ;1314 architecture prototype of shaca l c15 begin16 process ( c lk , data , enable )17 variable wvec : s t d l o g i c v e c t o r (511 downto 0) ;18 variable h0 , h1 , h2 , h3 , h4 , h5 , a , b , c , d , e , f , t : s t d l o g i c v e c t o r (31 downto 0) ;19 variable i :20 begin21 while enable = ’0 ’ loop22 wait until c l k = ’ 1 ’ ;23 end loop ;24 s i g n a t u r e <= h0 & h1 & h2 & h3 & h4 & h5 ;25 end process26 end architecture prototype ;

In een grammatica komen traditioneel veel identifiers voor: namen van allerhande items die op de een ofandere manier gerelateerd zijn met het type. Een probleem is echter dat een productie-regel verschillendeidentifiers kunnen bevatten en daarom de betekenis niet altijd duidelijk is. Daarom zullen we non-terminalsdie eigenlijk identifiers zijn extra annoteren: de non-terminal eindigt op “-ident” en bevat ervoor informatieover het soort identifier. In werkelijkheid staat er dus een identifier.

Grammatica 1 beschrijft de belangrijkste delen van de VHDL taal. Deze grammatica wordt louter terillustratie gegeven: het is niet de bedoeling deze grammatica te kennen, het kan echter helpen bij hetbegrijpen van de VHDL syntax.

7.10 Programmeerjargon

Tijdens het beschrijven van de VHDL taal zijn we verschillende termen tegengekomen die vaak aan bod komenbij programmeertalen in het algemeen. Voor lezers die minder vertrouwd zijn met programmeren volgt hiereen beschrijving van deze concepten. De lijst is niet exhaustief, voor een uitgebreidere Engelstalige lijst, zie[?].

Overloading Overloading betekent dat men verschillende betekenissen kan koppelen aan een en dezelfdeidentifier. Door extra informatie kan de compiler echter zelf bepalen welke betekenis aan een oproepmoet worden gekoppeld. Zo is het bijvoorbeeld in Java toegestaan om verschillende methodes tedefinieren met eenzelfde naam, wanneer het aantal parameters of de types van deze parameters anderszijn. Op basis van het aantal parameters en het type van deze parameters weet de Java compiler welkemethode moet worden opgeroepen.


Grammatica 1 De belangrijkste delen van de VHDL-grammatica.

〈type-decl〉→type 〈ident〉 is 〈type-ind〉 ;〈subtype-decl〉→subtype 〈ident〉 is 〈subtype-ind〉 ;

〈arraytype-decl〉→type 〈ident〉 is array ( 〈type-name〉 range <> , 〈type-name〉 range <>) of 〈elem-subtype-ind〉 ;〈arraytype-decl〉→type 〈ident〉 is array 〈index-constraint〉 of 〈elem-subtype-ind〉 ;

〈const-decl〉→constant 〈ident〉 , 〈ident〉〈subtype-ind〉 [:= 〈expression〉] ;〈var-decl〉→[shared] variable 〈ident〉 , 〈ident〉〈subtype-ind〉 [:= 〈expression〉] ;〈signl-decl〉→signal 〈ident〉 , 〈ident〉〈subtype-ind〉 [register|bus] [:= 〈expression〉] ;

〈package-decl〉→package 〈ident〉 is 〈type-decl〉|〈subtype-decl〉|〈arraytype-decl〉|〈const-decl〉|〈var-decl〉|〈signl-decl〉|〈component-declaration〉|〈use-clause〉 end [package] [〈package-name-ident〉] ;〈lib-clause〉→library 〈logical-name-ident〉 , 〈logical-name-ident〉 ;〈use-clause〉→use 〈selected-name〉

〈package-body〉→package body 〈package-name-ident〉 is end [package body] [〈package-name-ident〉] ;

〈subtype-ind〉→[〈resolution-function-name〉] 〈type-name〉 [〈range-constraint〉|〈index-constraint〉]〈type-ind〉→[〈resolution-function-name〉] 〈type-name〉 [〈range-constraint〉|〈index-constraint〉]〈elem-subtype-ind〉→[〈resolution-function-name〉] 〈type-name〉 [〈range-constraint〉|〈index-constraint〉]

〈selected-name〉→〈prefix〉 . 〈suffix〉

Deel V

Digitale Elektronica in de Praktijk

283

Hoofdstuk 8

Circuits Schakelen

Tot slot bieden we een laatste gedeelte over het bouwen van digitaleschakelingen in de praktijk. Dit gedeelte is optioneel. Het is geenleerstof, staat niet in de presentaties en vorm zeker geen onder-deel tijdens het examen. Het is dan ook eerder tot stand gekomenvoor “enthousiastelingen” die de opgedane kennis in de praktijk wil-len omzetten. In dit hoofdstuk beschrijven we welke geıntegreerdecircuits men zich dient aan te schaffen om de schakelingen te imple-menteren. In de rest van het deel worden enkele projecten besprokendie men kan realiseren.

8.1 Anatomie van een Geıntegreerd circuit

We beginnen het hoofdstuk met de terminologie die men hanteert bij geıntegreerde circuits.

8.1.1 DIP packing

Vermits het de bedoeling is dat men de circuits zelf implementeert, zullen we ook enkel werken metgeıntegreerde circuits die men zelf kan ineenzetten. Meestal kiest men daarvoor voor “DIP packing”. DIPpacking beschouwt rechthoekige chips met verbindingen in de lengte. Figuur 8.1(a) geeft dit concept gra-fisch weer. Een verbinding noemt men een “pin” of “pootje”. Omdat chips correct georienteerd moeten

18

27

36

45

(a) Structuur (b) Vooraanzicht (c) Zijaanzicht

Figuur 8.1: DIP packing

worden maakt men gebruik van twee systemen. De “notch” is een cirkelvormige inkeping aan een kant vande chip. Daarnaast zet men op de meeste chips ook een “index marker”. Een index marker is een cirkelin de buurt van pin 1. Wanneer we de notch aan de linkerkant plaatsen (zoals op de figuur), worden depootjes onderaan van links naar rechts genummerd. De nummering van de bovenste pootjes verloopt vanrechts naar links. Elke digitale chip beschikt telkens over minstens twee pootjes: de power pin (ofwel Vcc)

285

286 HOOFDSTUK 8. CIRCUITS SCHAKELEN

en de ground pin (ofwel GND). Bij de meeste chips stelt pin 1 de ground pin door. Meestal stelt de laatstepin (pin 8 op Figuur 8.1(a)) de power pin voor. Soms gebruikt men ook de eerste pin van de bovenste rij(pin 5 op Figuur 8.1(a)). De powerpin moet worden verbonden met de positieve pool van de voeding, deground pin met de negatieve pool. In een schematische voorstelling van een geıntegreerd circuit geeft menvaak de nummers van de verschillende pinnen weer. Een diagram die de functie van de verschillende pinnenbeschrijft noemt men een “pinout”. Figuur 8.1(b) en Figuur 8.1(c) tonen het voor- en zijaanzicht van eenDIP geıntegreerd circuit. Doorgaans zijn de pootjes dikker rond het midden van de chip dan het einde. Destructuur van DIP vereist bijna dat het aantal pootjes altijd even is. Indien dit niet het geval is zal menmeestal een veelvoud van de componenten in een chip implementeren. Zo bestaan er bijvoorbeeld chips die4 NAND-poorten aanbieden.

8.1.2 Populaire geıntegreerde circuits

Nu we de structuur van een geıntegreerd circuit hebben voorgesteld, zullen we een bondige samenvatting ge-ven over de belangrijkste geıntegreerde circuits. Belangrijke geıntegreerde circuits werden gestandaardiseerdmet een nummer. Op gebied van digitale elektronica spreekt men over twee “geıntegreerde circuit-families”:de 74000 serie en de 4000 serie. De 74000 serie omvat digitale componenten geımplementeerd met transistor-transistor logic. De 4000 serie implementeert dezelfde schakelingen in CMOS-logica. Indien we dus Zo steltgeıntegreerd circuit 4068 een 8-NAND poort voor in CMOS logica. 47068 biedt dezelfde poort aan, maarvolgens een andere technologie. Voor een volledige lijst van de geıntegreerde circuits in de 74000 en 4000families: zie [?, ?].

# Naam # Naam

555 555-timer556 2× 555-timer

4017 Decade counter4269 8-bit counter4701 4× 2-NAND4703 4× 2-NOR4705 6× NOT4706 6× Buffer4707 4× 2-NOR4708 4× 2-AND4710 4× 3-NAND4702 3× 2-NOR

Tabel 8.1: Lijst met populaire geıntegreerde circuits.

In Tabel 8.1 staat een lijst met populaire geıntegreerde circuits. Naast de digitale circuits omvat de tabelook enkele analoge schakelingen. De werking van deze circuits wordt verder in dit hoofdstuk verduidelijkt.

8.2 Analoge componenten

Naast geıntegreerde circuits zal men in de praktijk in een digitale schakeling ook analoge componentenaantreffen: weerstanden, condensatoren, transistoren en in mindere mate spoelen. Deze componenten zijnmeestal nodig om effectief iets aan te sturen (bijvoorbeeld een led) of bij de captatie van invoer (bijvoorbeeldradiogolven). In deze sectie geven we een kort overzicht.

8.2. ANALOGE COMPONENTEN 287

8.2.1 Weerstanden

Een weerstand is een component die de stroomsterkte in een circuit verlagen en bovendien lokaal de span-ningsniveaus verminderen. Een circuit gedraagt zich dan ook volgens de “Wet van Ohm”. Deze wet steltdat tussen elke twee punten in een elektronische schakeling, het verschil in potentiaal ∆V lineair schaalt metzowel de stroomsterkte I als de weerstand R:

∆V = I ·R (8.1)

De meeste weerstanden in een schakeling hebben een vaste weerstand R, er bestaan echter ook weerstandenzoals lichtgevoelige weerstanden, waar de weerstand afhangt van de lichtintensiteit, temperatuur, ... In dezecursus zullen we enkel weerstanden met een vaste weerstand beschouwen.

Kleurcode

De weerstand wordt traditioneel niet numeriek op de component genoteerd, maar aan de hand van vier totzes banden die elk een specifieke kleur hebben. Deze sequentie beschrijft de weerstand, de toleratie1 en opti-oneel de temperatuurscoefficient2. Afhankelijk van het aantal banden, heeft elke band ook een verschillendebetekenis: getal, multiplicatie, toleratie en temperatuurscoefficient. Tabel 8.2 toont hoe de verschillendekleuren overeenstemmen met hun betekenis.

Kleur Cijfer c Multiplicatie m Toleratie t Temperatuurscoefficient T

Zwart 0 100 n.v.t. n.v.t.Bruin 1 101 01.00% 100 ppmRood 2 102 02.00% 50 ppm

Oranje 3 103 n.v.t. 15 ppmGeel 4 104 n.v.t. 25 ppm

Groen 5 105 00.50% n.v.t.Blauw 6 106 00.25% n.v.t.Paars 7 107 00.10% n.v.t.Grijs 8 n.v.t. n.v.t. n.v.t.Wit 9 n.v.t. n.v.t. n.v.t.

Zilver n.v.t. 10−2 10.00% n.v.t.Goud n.v.t. 10−1 05.00% n.v.t.

Tabel 8.2: De verschillende kleurcodes bij een weerstand.

De eerste band is altijd aangebracht op een plaats waar de straal van de weerstand groter is. In het gevalde weerstand uit zes banden bestaat, is de zesde band aangebracht aan de andere kant van de weerstandwaar de straal ook groter is. Om toch het onderscheid te kunnen maken tussen de eerste en de laatste bandzijn de tweede en de derde band altijd aan dezelfde kant van de weerstand. Vermits er hoogstens zes bandenaangebracht zijn op een weerstand kan men dus door te rekenen vanuit het midden van de weerstand, altijdde eerste band lokaliseren door de kant te nemen die de meeste banden bevat. De posities samen met debetekenis van de banden staat schematisch voorgesteld op Figuur 8.2.

In het algemeen beschrijven de eerste twee (in het geval van vier banden) of drie banden de cijfers die sameneen getal vormen. Dit getal moet dan vermenigvuldigt worden met de multiplicator. De toleratie drukt aande hand van een percentage uit wat het betrouwbaarheidsinterval is. Indien de weerstand bijvoorbeeld 10 kΩis met een toleratie van 5%, dan is het betrouwbaarheidsinterval: [9.5 kΩ; 10.5 kΩ].

1Dit is een betrouwbaarheidsinterval waarin de werkelijke weerstandswaarde zit.2De werkelijke waarde van de weerstand is altijd enigszins afhankelijk van de temperatuur van de weerstand op dat moment.


Figuur 8.2: De uitlijning en betekenis van de verschillende kleurbanden.

In het geval de weerstand vier banden bevat zijn de eerste twee banden cijfers c1 en c2, de derde demultiplicatie m en de laatste de toleratie t, in dat geval is de weerstandswaarde dus:

R = (10 · c1 + c2) ·m Ω (4 banden) (8.2)

In het geval van vijf en zes banden zijn de eerste drie banden cijfers c1, c2 en c3, de vierde de multiplicatie m,de vijfde de tolerantie t en optioneel de zesde de temperatuurcoefficient. In dat geval is de weerstandswaardedus:

R = (100 · c1 + 10 · c2 + c3) ·m Ω (5 en 6 banden) (8.3)

8.2.2 Condensatoren

Condensatoren en spoelen zijn componenten die streven naar een behoudt van respectievelijk spanning enstroomsterkte. In het geval van wisselstroom of een periodiek veranderende spanning, kan men ze bovendienzien als weerstanden waarbij de weerstand afhangt van de fase op dat moment.

Een condensator heeft tot doel spanning te stabiliseren, dit doet een condensator door elektronischespanning om te zetten in een elektrisch veld, wanneer de spanning vervolgens oploopt of afneemt, zal hetelektrische veld een tegenbeweging uitvoeren. Het garanderen van de spanning is van cruciaal belang ineen groot digitaal circuit. Zo hebben computers meestal enkele condensatoren die dicht bij de voeding hetspanningsverschil moeten waarborgen. Immers is het mogelijk dat door het aan- en uitschakelen van andereapparaten, de spanning licht fluctueert. In analoge circuits is dit meestal niet problematisch. In een digitaalcircuit kan dit echter het verschil maken tussen een 0 of een 1. Omdat in sequentiele circuits een foutgeınterpreteerd signaal tot een opeenvolging van foute invoer en foute toestanden kan leiden is een fouteinterpretatie dus zeer gevaarlijk.

Een condensator wordt ook vaak gebruikt in een RC-keten: een keten waarbij een weerstand een conden-sator in serie worden geplaatst. Wanneer er dan spanning wordt aangelegd op het circuit, zal de spanning opde condensator traag evolueren. Dit kan men dus gebruiken om signalen met enige vertraging te laten pro-pageren. Dit is belangrijk in analoge circuits alsook in digitale, bijvoorbeeld om een kloksignaal te generen(zie Sectie 8.4).

Een condensator wordt als volgt gerealiseerd. Men voorziet doorgaans twee of meer platen die dicht bijelkaar liggen, maar niet verbonden zijn zoals weergegeven op Figuur 8.3.

~E

Figuur 8.3: De realisatie van een condensator.

8.3. BOUW VAN EEN ELEKTRONISCHE SCHAKELING 289

Wanneer er spanning wordt aangelegd op de condensator, worden de platen elektrisch geladen. Als gevolgontstaat er een elektrisch veld dat gelijk is aan:

E =V

d(8.4)

De meeste condensatoren worden niet gerealiseerd aan de hand van twee parallelle platen, maar aan de handvan bijvoorbeeld een opgerold structuur waarbij de twee platen gescheiden worden door een dielektrischestof.

8.2.3 Spoelen

Een spoel tracht de stroomsterkte te behouden, dit doet men door stroomsterkte om te zetten in magnetischveld.

Een spoel wordt doorgaans weinig gebruikt bij een digitaal circuit. Men kan een spoel in een RL-ketengebruiken om een vertraging te realiseren op de stroomsterkte, bovendien kan men een LC-keten realiserenom een oscillerende keten te bouwen.

In de analoge elektronica wordt een spoel typische gebruikt bij het filteren van bepaalde frequenties uit eensignaal, bijvoorbeeld uit een gecapteerd radiosignaal zodat enkel de signalen van een bepaald radiostationde luidspreker aanleggen.

Men realiseert een spoel door door de stroomsterkte die doorheen een geleider vloeit om te zetten in eenmagnetisch veld. Men bereikt een maximaal effect wanneer men deze geleider op een spiraal-vormige manierbuigt zoals weergegeven op Figuur 8.4.

Figuur 8.4: De realisatie van een spoel.

8.2.4 Transistoren

We hebben transistoren al in Hoofdstuk 2 besproken, maar dan vooral in een digitale context. Transistorenworden echter ook in een analoge context gebruikt: bijvoorbeeld als versterker waarbij de weerstand tussende collector en de emittor wordt bepaald door de spanning die op de basis wordt aangelegd. Soms ookals basis om een feedback-circuit te bouwen: als men bijvoorbeeld een RC-keten laat open ontladen opbasis van een transistor, en deze transistor vervolgens ook aangestuurd wordt door deze RC-keten, kan menwisselstroom realiseren of bijvoorbeeld een kloksignaal.

8.2.5 Diodes en Operationele versterkers

Diodes en operationele versterkers zijn componenten die toelaten om bij een bepaalde drempelwaarden,stroom door te laten. In het ideale geval betekent dit dat een diode wanneer de spanning correct gepolariseerdis, een weerstand van 0 Ω voorstelt. In het andere geval is de weerstand ∞ Ω.

8.3 Bouw van een elektronische schakeling

Om de verschillende componenten die we hier besproken hebben samen te schakelen, dienen we geleiders tevoorzien. We kunnen dit natuurlijk realiseren door geleiders zoals koperdraad te voorzien en dit te solderenaan de connectoren van de verschillende componenten. Dit zou echter tot een chaotische realisatie leiden die


weinig compact is. Men maakt dan ook meestal gebruik van bijvoorbeeld een matrixbord, europrintplaat ofprintplaat die de geleiders structureren: meestal wordt een zijde van een plaat voorzien voor de componentenen de andere zijde voor de geleiders. In het geval van een printplaat wordt soms de zijde van de componentenook gebruikt om geleiders op te zetten. Indien geleiders enkel aan een kan van de plaat automatisch wordenaangebracht, zal men soms ook manueel nog extra geleiders moeten aanbrengen, meestal met behulp vankoperdraad. Wanneer men aan de twee kanten van de plaat geleiders toelaat, kan men in feite elke schakelingrealiseren zonder extra geleiders te moeten aanbrengen.

8.3.1 Matrixbord

Een matrixbord ook wel breadboard genoemd is een paneel waar de geleiders reeds op voorhand op eengestructureerde wijze zijn aangebracht. De componentenkant van een matrixbord bestaat uit vooraf gefabri-ceerde gaten, waar componenten eenvoudigweg ingeplugd kunnen worden. Figuur 8.5 beschrijft een typischmatrixbord.

A B C D E F G H I J1 1

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9

10 10

11 11

12 12

13 13

14 14

15 15

16 16

17 17

18 18

19 19

20 20

21 21

22 22

23 23

24 24

25 25

26 26

27 27

28 28

29 29

30 30

31 31

32 32

33 33

34 34

35 35

36 36

37 37

38 38

39 39

40 40

41 41

42 42

43 43

44 44

45 45

46 46

47 47

48 48

49 49

50 50

51 51

52 52

53 53

54 54

55 55

56 56

57 57

Figuur 8.5: Een voorbeeld van een matrixbord.

Op de figuur zien we centraal twee matrices van 57× 5 pinnen. Deze pinnen zijn horizontaal verbonden.Aan beide kanten zijn ook lange lijnen. Dit zijn 25 × 2 matrices die verticaal verbonden zijn. Bij grotebreadboards zijn er (zoals ook de figuur) meerdere onderbroken lange lijnen. Ook bestaan er breadboards metmeer centrale matrices. Bovenaan ten slotte voorziet men verbindingen voor bijvoorbeeld stroombronnen.De meeste lange lijnen worden verbonden met de polen van de spanningsbron. Tussen twee centrale matrices

8.3. BOUW VAN EEN ELEKTRONISCHE SCHAKELING 291

loopt een opening van 0.2 inch. Dit laat toe om typische chips in DIP verpakking op het breadboard teplaatsen. Immers kan men dit niet op een centrale matrix plaatsen: anders zouden de pootjes met elkaarverbonden worden.

Een matrixbord is erg geschikt om snel een prototype mee uit te testen. Na gebruik kan men immers decomponenten terug uitpluggen. Een matrixbord is echter niet geschikt om compacte en blijvende realisatiesmee te bouwen. Immers men de componenten zo orienteren dat de juiste connectoren met elkaar verbondenworden. Dit leidt er toe dat bijvoorbeeld DIP-componenten altijd onder elkaar moeten worden geplaatsten bovendien in het midden van een kolom. Doorgaans kan men door eerst de componenten te plaatsen endan de geleiders te minimaliseren tot een compacter ontwerp komen dan omgekeerd. Een matrixbord biedtechter comfort aan bij het schakelen van elementen en is daarom nuttig voor een eerste realisatie.

8.3.2 Europrintplaat

Een europrintplaat is een stap tussen een matrixbord en speciaal ontwikkelde printplaat. In een europrint-plaat beschouwen we een rechthoekige bord van kunststof. Op deze plaat brengt men in een rasterstructuurrechthoekige plaatjes van koper aan die men eilanden noemt. Zo’n plaatje bevat drie gaten waarop men deverbindingen van de componenten kan solderen. Hierdoor zijn de connectoren die worden gesoldeerd aaneenzelfde eiland automatisch verbonden. Deze structuur is geıllustreerd op Figuur 8.6.

Figuur 8.6: Structuur van een europrintplaat.

Doordat de eilanden relatief klein zijn, levert dit vrij compacte schakelingen op. Immers verliest men bijeen matrixbord meteen een volledige rij wanneer men op een bepaalde plaats een component inplugt. Bij eeneuroprintplaat zijn dit slechts drie verbindingen. De componenten dienen op het bord gesoldeerd te worden,wat dus tot een permanente realisatie leidt. Het realiseren van een schakeling is echter arbeidsintensief enbovendien is het moeilijk om een component terug te verwijderen. In Subsectie ?? bespreken we hoe mencomponenten op een (euro)printplaat solderen.

8.3.3 Printed Circuit Board (PCB)

Wanneer men een schakeling heeft ontwikkeld die men wil realiseren in een klein formaat gebruikt menmeestal een “Printed Circuit Board (PCB)” of “printplaat”. Een printplaat is een op maat gemaakte plaatwaarbij de verbindingen gerealiseerd worden door een koperen laag aan de ene kant van deze plaat. Decomponenten worden op deze plaat bevestigt door openingen in de plaat. De componenten worden aan deandere kant bevestigd waarbij de verbindingen door middel van kleine openingen en de connectoren wordenop de koperen kant gesoldeerd. Moderne printplaten laten ook toe om verbindingen aan de twee kanten vande plaat te plaatsen.


2SA2SC

100 kΩ

1kΩ

Figuur 8.7: Een voorbeeld van een printed circuit board (pcb).

Figuur 8.7 toont een voorbeeld van een printplaat die een knipperlicht implementeert aan de hand vantwee transistoren. In het grijs staan de verbindingen die aan de achterkant van de plaat zijn aangebracht. Dezwarte lijnen tonen de contouren van de componenten die aan de voorkant van de plaat worden aangebracht.De grijze cirkels wijzen op verbindingen en gaten in de printplaat.

Men kan printplaten op twee manieren bekomen: ze bestellen bij een bedrijf die hierin gespecialiseerd isof ze zelf maken. Bij beide dient men eerst de printplaat te ontwerpen. Op maat gemaakte printplaten zijnrelatief goedkoop: ongeveer e 10.00 voor een prototype en e 00.25 per stuk bij massaproductie. We zullennu het productieproces bespreken.

Ontwerp

Het ontwerp van een printplaat is een proces waarin men bepaald hoe de koper-laag er zal uitzien samen metde locaties van de openingen. Er bestaan computerprogramma’s die voor een geven elektronische schakelingeen compacte printplaat ontwerpen en verder bestaan er ook computerprogramma’s zoals PCB Designer diemensen helpen bij het ontwerpen van zo’n printplaat. Het ontwerpen van een compacte printplaat is geensinecure. Het is echter meestal wel mogelijk om snel een eenvoudig ontwerp te bouwen. We gaan hier nietverder op in. Meer informatie over het plaatsen van componenten en verbindingen is te vinden in [?].

Productieproces

Eenmaal de printplaat ontworpen is, kan men beslissen deze ook zelf te produceren. In deze subsubsectiezullen we het productieproces om zelf printplaten te maken bondig beschrijven. Meer informatie over ditproces is te vinden in [?].

Het proces bestaat grofweg uit vier fases: “blootstelling”, “etsen”, “tin betegeling” en “boren”[?, p. 69]. Inde volgende paragrafen zullen we de fases bespreken. De productie van printplaten is op zich niet gevaarlijk,maar er komen corrosieve chemicalien bij kijken. Het is dus aangewezen handschoenen en een veiligheidsbrilte dragen.

Blootstelling Als primaire grondstof hebben we een koperplaat nodig. Deze

Etsen

Tin betegeling

Boren

8.4. IMPLEMENTATIE VAN EEN KLOKSIGNAAL 293

8.3.4 Plaatsen van componenten

8.3.5 Tips bij het solderen

8.4 Implementatie van een kloksignaal

In de cursus hebben we telkens abstractie gemaakt van de implementatie van een kloksignaal: een signaal diemet een bepaalde frequentie afwisselend 0 en 1 aanlegt. Hoe kunnen we een dergelijk signaal implementeren?Een eerste antwoord zou kunnen zijn dat men een sequentiele schakeling bouwt die dit signaal zal aanleggen.Het probleem is dat een dergelijke schakeling zelf een kloksignaal nodig heeft. We zullen dus een andercomponent nodig hebben. Twee populaire keuzes zijn het gebruik van een 555-timer en een kristal-oscillator.We zullen beide technieken kort bespreken.

8.4.1 555-timer

De 555-timer3 is een geıntegreerd circuit die gebruikt wordt om allerhande periodieke functies te implemen-teren. Het component kost los rond de $2.50. Een 555-timer kan kloksignalen produceren tot ongeveer300 kHz.

Pinout en interface

Een 555-timer is een component met 8 verbindingen. Figuur 8.8(a) geeft de pinout van de chip met DIPpacking weer. In een blokdiagram tekent men een 555-timer meestal met vaste posities voor de verschillende

555

GN

DV

cc

Trigger

Disch

arge

Ou

tpu

tT

hresh

old

Reset

Con

trolV

oltage

(a) 555-timer pinout

1 5

8 4

3

7

6

2

555

(b) 555-interface

556

Disch

arge1

Vcc

Th

reshold

1D

ischarge

2

Con

trol1

Th

reshold

2

Reset

1C

ontrol

2

Ou

tpu

t1

Reset

2

Trigger

1O

utp

ut

2

GN

DT

rigger2

(c) 556-timer pinout

Figuur 8.8: De pinout van de 555-timer en 556-timer.

in- en uitgangen. Figuur 8.8(b) toont deze posities samen met de nummers van de pinout.

Werking

De werking van de 555-timer is niet eenvoudig te verklaren. Dit komt omdat men een dergelijk timerimplementeert met complexe analoge elektronica zoals operationele versterkers. Zonder in detail te tredenzullen we verklaren hoe we een 555-timer als kloksignaal kunnen gebruiken. De ground pin en de power pinleggen een spanning aan op de component zodat het kan functioneren. Daarnaast bevat de 555-timer eeninterne flipflop. De toestand van deze flipflop (0 of 1) wordt aangelegd op de output pin. Twee ingangen

3Soms uitgesproken als “triple five” of “triple five timer”.


dienen vervolgens om het signaal om te wisselen: de trigger en de threshold. De trigger is een ingang die deflipflop op 1 zet op het moment dat de spanning hoger wordt dan 1/3 van de spanning die op de Vcc staat.De threshold werkt omgekeerd: de ingang is gevoelig voor spanning boven 2/3 van de spanning op de Vcc.Indien op dat moment de trigger een spanning heeft groter dan 1/3, wordt de flipflop terug op 0 gezet. Deoverige pinnen zijn van minder belang. De controle pin kan de waarde van de threshold aanpassen. Wanneerwe dus een vaste kloksignaal willen genereren is het belangrijk dat de control pin ten alle tijde op een vastespanning staat. Daarom wordt de controle pin meestal via een condensator verbonden met de negatieve poolvan de stroombron. Vermits een condensator behoudt van spanning nastreeft, is dit dus de beste garantieop een constante spanning op de controle-ingang. De discharge ingang is een verbinding die stroom naar deground laat vloeien op het moment dat de output hoog is. Wanneer de output laag is, is de discharge hoogimpedant. De reset pin ten slotte zal de output terug op 0 zetten wanneer men een lage spanning4 aanlegt.Meestal is de reset-ingang aangesloten op de positieve pool van de stroombron om dit te vermijden.

1 5

8 4

3

7

6

2

555

100nC1

R1

t

U (output)

0 V

1 V

t

U (C1)

0 V

1/3 V

2/3 V

V

Figuur 8.9: Schakeling voor de implementatie van een kloksignaal met een 555-timer

Op basis van de beschrijving kunnen we een eenvoudige schakeling met een RC-keten ontwerpen die eenkloksignaal zal genereren. Deze schakeling staat beschreven in Figuur 8.9. Op het moment dat men eenspanning op de schakeling aanlegt, is de condensator C1 niet opgeladen en het output-signaal van de 555-timer is hoog. Bijgevolg wordt de condensator opgeladen door de RC-keten. Op het moment dat de spanningvan de condensator (de spanning tussen pin 1 en pin 6) 2/3 van de totale spanning bereikt, wordt de outputop laag gezet. Vanaf dat moment begint de condensator te ontladen. De spanning over de condensatorneemt bijgevolg af en op het moment dat spanning onder 1/3 van de totale spanning gaat, detecteert detrigger dit. Op dat moment wordt de output terug hoog en begint de cyclus opnieuw. Omdat het opladen enontladen van tussen 1/3 en 2/3 van de spanning in de RC-keten even lang duurt, is de duty cycle bijgevolg50%. Figuur 8.9 toont ook de spanning van de output en de condensator op verschillende momenten in detijd. De stippellijnen op de grafiek van de condensator tonen het verdere verloop van de functie indien deoutput-niet zou worden omgedraaid.

De frequentie van het kloksignaal hangt duidelijk af van de parameters van de RC-keten. Een condensatorwordt open ontladen volgens volgende functies:

Uop (t) = Uf − (Uf − U0) · e−t/R1·C1 (8.5)

Uont (t) = U0 · e−t/R1·C1 (8.6)

Met U0 de beginspanning en Uf de spanning die op de keten wordt aangelegd. In een halve klokcyclus wordtde spanning dus opgeladen van 1/3 V naar 2/3 V of ontladen van 2/3 V naar 1/3 V . De tijd die hierbijverstrijkt is dus gelijk aan:

∆t = −R1 · C1 · ln (1/2) = ln (2) ·R1 · C1 ≈ 0.693147181R1 · C1 (8.7)

4Beneden een spanning van 0.8 V tegenover de ground.

8.4. IMPLEMENTATIE VAN EEN KLOKSIGNAAL 295

De frequentie van het kloksignaal is bijgevolg gelijk aan:

f =1

2∆t=

1

2 · ln (2) ·R1 · C1=

1

ln (4) ·R1 · C1≈ 0.72134752

R1 · C1(8.8)

Meer informatie over de implementatie, de werking en concrete oscillator-schakelingen is te vinden in [?].

556-timer

Tot slot introduceren we ook nog een andere populaire geıntegreerde schakeling: de 556-timer. Dezegeıntegreerde schakeling is eigenlijk niets anders dan twee 555-timers in een chip. Het voordeel van der-gelijke chips is dat bepaalde in- en uitgangen gedeeld kunnen worden. In het geval van de 556-timer is dathet geval voor de power pin en ground pin.

8.4.2 Astabiele multivibrator

Een andere manier om een kloksignaal te implementeren is door een oscillator te implementeren. De meesteoscillatoren werken op basis van het volgende principe: een we beschouwen een transistor die een zekereweerstand tussen de collector en emitor aanbrengt. De weerstand wordt bepaald door de spanning tussen debasis en de emitor. Door een schakeling te implementeren die de weerstand negatief terugkoppelt naar debasis en hierover een zekere tijd laat verstrijken kunnen we een oscillator bouwen. Een dergelijke feedbackschakeling moet dus in het geval van een PNP-transistor bij een lage weerstand de spanning op de basisverlagen en bij een hoge weerstand de spanning aan de basis opdrijven.

C1 C2

R1 R2 R3 R4

+V

0 V

Figuur 8.10: Astabiele multivibrator.

Een typische manier om dit te realiseren is een symmetrische schakeling met twee PNP-transistoren entwee RC-ketens zoals geıllustreerd op Figuur 8.10. Deze schakeling werkt als volgt. We beschouwen eentoestand waarbij de eerste transistor gesloten is5 en de andere transistor gesloten.

8.4.3 Kristal-oscillator

Een nadeel van de 555-timer is dat de periodieke functie meestal niet nauwkeurig wordt aangelegd. Compo-nenten op basis van transistoren en weerstanden zijn bijvoorbeeld onderhevig aan de temperatuur. Indienmen dus een kloksignaal met een zekere frequentie aanlegt kan men fluctuaties op die frequentie verwachten.Zolang de frequentie laag is, levert dit weinig problemen op: de componenten rekenen immers zo snel datde data lang op de ingangen van de registers staat alvorens ze worden ingeladen. Wanneer men echter eenprocessor implementeert, wil men een hoge kloksnelheid die zo weinig mogelijk tijd de data onbenut laat.Ook bij hoge frequenties blijft er echter sprake van ruis. In dat geval kan de ruis het verschil maken tussende correcte data die aan de ingang van een register staat, of oude of tijdelijke data.

5Een transistor is gesloten wanneer er stroom vloeit van de collector naar de emitor. In het ander geval is de transistor open.


In dergelijke gevallen zal men opteren voor een kristal-oscillator. Een kristal-oscillator werk op basisvan piezo-elektromagnetisme. De fysica achter dit proces valt buiten het bereik van deze cursus. Men kanechter stellen dat het een component is die op basis van een kwartskristal met een zeer vaste frequentie vanweerstand varieert. De afwijkingen worden dan ook uitgedrukt in “parts per billion (ppb)”.

8.5 Printed Circuit Board (PCB) Layout

In vakbladen zal men meestal naast de schakeling ook een “printed circuit board (pcb) layout” weergeven.Dit is een schematische weergave hoe men de schakeling compact kan realiseren op een printplaat. Eendergelijke afbeelding dient niet om de schakeling te analyseren, maar enkel om de schakeling zelf op eenefficiente manier te realiseren. Een probleem met dergelijke plannen is dat men andere symbolen gebruiktom de componenten voor te stellen: meestal wordt de basisvorm van het relevante component weergegeven,bovendien dient men ook twee lagen weer te geven: de boven- en onderkant van de printplaat.

De meeste afbeeldingen lossen het probleem van de twee lagen op met behulp van kleur: in deze cursuszullen we de voorzijde afbeelden in het zwart en de achterzijde in het grijs. Het probleem met het toewijzenvan componenten wordt meestal aangepakt door de componenten te labelen. Meestal wordt hierbij het typecomponent (weerstand, condensator, ...) weergegeven, maar de meest relevante eenheid van de component.Zo zal bij een condensator de capaciteit in micro-Farad worden weergegeven.

Bij wijze van introductie toont Figuur 8.11 een overzicht van de symbolische weergaven van enkele populairecomponenten.

1 nF

capacitor

(a) Condensator.

1N60P

diode

(b) Diode.

4017

(c) DIP-chip.

wire

(d) Draad.

X01

(e) Kristal-oscillator.

L01

(f) LED.

U01(g) Schakelaar.

X01

transistor

(h) Transistor.

USB01

(i) USB-verbinding.

200k

resistor

(j) Weerstand.

Figuur 8.11: PCB-weergave van populaire componenten.

8.6. OPROEP AAN DE LEZERS 297

Een PCB-layout kan ook digitaal worden ingevoerd. Bijvoorbeeld met gEDA of Gerber. Bovendien kandeze software op basis van de gegevens een lijst met specificaties maken waar gaten in de printplaat moetenworden geboord, waar de geleiders moeten worden aangebracht en welke componenten worden gebruikt enwaar deze moeten worden aangebracht. Dit proces kan bovendien worden geautomatiseerd door relevanteapparatuur aan te sturen. Dit ligt buiten het bereik van deze cursus.

8.6 Oproep aan de lezers

De auteur roept enthousiaste lezers op om projecten te delen zodat deze in deze cursus kunnen wordengepubliceerd als een hoofdstuk in dit deel. Men kan echter niet elk project als nuttig beschouwen. Ingediendeprojecten moeten aan enkele voorwaarden voldoen:

1. De componenten in het project dienen in de cursus vermeld te worden. Het is niet de bedoeling om“exotische componenten” te introduceren, in het bijzonder denken we dan aan componenten uit deanaloge elektronica (operationele versterker, spoel, ...). Sommige projecten kunnen een klein aantalvan dit soort componenten bevatten. In dat geval dient men een korte beschrijving van de werking bijte voegen.

2. Het project moet realiseerbaar zijn. Zowel op een op maat gemaakte printplaat als bijvoorbeeld eeneuroprintplaat. Verder is het evenmin de bedoeling dat het project veel werk vereist en het resultaatweinig inzichten zal verwerken (hierbij denken we bijvoorbeeld aan een 1024-bit opteller).

3. De effecten die in het project beschreven worden moeten te verklaren zijn, en dit op basis van de cursus.

Indien het project aan deze voorwaarden voldoet maakt het kans om opgenomen te worden. Een lezer kaneen project indienen op volgend adres: http://goo.gl/rzIlr3. Een “aanvraag” bestaat uit een of meerdereschema’s samen met een verslag. Dit verslag bevat een lijst van benodigde componenten, aanwijzingen bijde bouw van de schakeling en een tekst die de werking verklaart. Het verslag mag figuren bevatten die dewerking verder uitleggen. Omdat een dergelijke aanvraag veel werk vraagt, kan men ook een “voor-aanvraag”indienen (op hetzelfde webadres). In een voor-aanvraag specificeert men kort het project in een tekst vanmaximaal een pagina. Op basis van de reactie van de auteur kan men dan beslissen om al dan niet eenaanvraag in te dienen.

Hoofdstuk 9

Experimenten

Het leven is niets dan een experiment. Hoe meer je experimen-teert, hoe beter.“

”- Ralph Waldo Emerson, Amerikaans dichter en filosoof (1803-1882)

In dit hoofdstuk beschrijven we enkele experimenten die we kunnenuitvoeren om praktische en nuttige digitale schakelingen te realise-ren voor dagelijks gebruik.

9.1 Oneindig vermenigvuldigen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

9.1.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

9.1.2 Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

Implementatie-specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

9.1.3 Realisatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

Toestanden en soorten schakeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301

Toestandscodering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Type flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Implementatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303

9.2 Fietslicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

9.2.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304

9.2.2 Implementatie-specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305

9.2.3 Realisatie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Toestandstabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Toestandscodering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

Type flipflop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

Implementatie in poortlogica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

9.3 Tic tac toe-machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

9.3.1 Benodigdheden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

9.3.2 Implementatie-specificaties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

299

300 HOOFDSTUK 9. EXPERIMENTEN

9.1 Oneindig vermenigvuldigen

Een van de voordeling van delen en vermenigvuldigen met constanten, is dat de overdracht of het lenen ookbeperkt is. Wanneer we een binair getal bijvoorbeeld vermenigvuldigen met 3, kan de carry nooit groterworden dan 4. Wanneer we dit veralgemenen naar een vermenigvuldiging in het binair stelsel met n, kan deoverdracht nooit groter worden dan 2 ·n−1. We kunnen dit uitbuiten om een sequentiele vermenigvuldiger temaken die over bit-stromen met oneindige lengte werkt. We realiseren dus een schakeling waar als invoer eenstroom aan bits en het bijbehorende kloksignaal binnenkomt, en als uitvoer een andere stroom bits gekloktvolgens hetzelfde kloksignaal maar waarbij de bits het k-voud voorstellen van de inkomende bitstroom.We werken volgen big-endian encodering: de eerste bit die in de schakeling binnenkomt is altijd de minstsignificante.

9.1.1 Benodigdheden

Dit hangt grotendeels af van de constante k waarmee we willen vermenigvuldigen. Voor een constante k = 5zijn de benodigdheden de volgende:

1. 2 leds;

2. 3 npn-transistoren;

3. 1 pnp-transistoren;

4. 2 drukschakelaars.

Samen kosten deze componenten (zonder gereedschap, printplaten en soldeersel) ongeveer e ??.??1.

9.1.2 Model

In de inleiding hebben we de werking van de component niet gespecificeerd. Dit zullen we in deze sectie doen.Wanneer een getal bit-na-bit wordt ingelezen in het circuit, dient het circuit dit getal de vermenigvuldigen.We kunnen echter de eigenschap uitbuiten dat de overdracht die bij de vermenigvuldiging optreedt, altijdeindig zal zijn. Bij voorbeeld zullen we een vermenigvuldiging met k = 5 modelleren.

q0start q4

q2 q6

q8

0/0 1/1

1/1

0/1

1/0

0/0

1/1

0/1

1/0

0/0

Figuur 9.1: Een toestandsdiagram voor k = 5.

De machine begint in een toestand waar er geen overdracht is, formeler c = 0. Dit is de toestand q0 opFiguur 9.1. Wanneer er nu een 0 binnenkomt, is het resultaat logischerwijs 0 en blijft de overdracht ookop 0 staan. We trekken dus een lus vanuit q0 met boog 0/0. Wanneer er echter een 1 op de invoer wordtaangelegd, dan weten we dat de uitvoer-bit ook 1 moet worden, en dat we vanaf dat moment met overdrachtc = 4 moeten rekening houden. Nu hebben we alle invoer voor q0 gemodelleerd, maar q4 dienen we verder

1Gebaseerd op prijzen bij Conrad.

9.1. ONEINDIG VERMENIGVULDIGEN 301

in te vullen. In het algemeen geldt de regel voor een vermenigvuldiging van k dat we een boog van qi naarqj trekken met label bi/bo zodat:

bi ∈ 0, 1 (9.1)

r =i

2+ k · bi (9.2)

bo = r mod 2 (9.3)

j = r − bo (9.4)

Voor q4 betekent dit dus dat we een boog 0/0 naar q2 trekken en een boog 1/1 naar q6. We dienen vervolgensook bogen uit deze toestanden te trekken en dit tot er geen nieuwe toestanden meer opduiken. We bekomenvervolgens een diagram zoals op Figuur 9.1. We kunnen dit voor iedere k doen.

Implementatie-specificaties

Reset Getallen hebben altijd een eindig aantal cijfers en bijgevolg ook een eindig aantal bits. We willen deschakeling dan ook niet noodzakelijk gebruiken om een product uit te rekenen over een oneindige sequentiebits. Maar wel op een snelle manier getallen van willekeurige lengte vermenigvuldigen. We dienen echteraan het circuit duidelijk te maken dat we een nieuw getal willen vermenigvuldigen. We kunnen dit op tweemanieren doen:

1. We lezen de resterende bits uit door telkens 0 op de ingang aan te leggen tot het circuit zich terugin toestand q0 bevindt, dit duurt hoogstens log2 (n) + 1 stappen. Dit is ook in principe de correctemethode omdat het resultaat van een vermenigvuldiging nu eenmaal een getal met meer bits kanopleveren. Een nadeel is echter wanneer we dit circuit in een processor zouden gebruiken, waarbij deregisters een beperkt aantal bits hebben, we meestal geınteresseerd zijn in de n minst significante bits2,en we dus klokflanken “verspillen”.

2. We voorzien een reset-ingang die de schakeling terug in de grondtoestand brengt. De meest significantebits gaan verloren.

In dit voorbeeld kiezen we voor de eerste variant. Dit houdt immers ook het circuit eenvoudig en goedkoop.

In- en Uitvoer Normaal kunnen we een dergelijk circuit gebruiken in bijvoorbeeld een processor, ofkunnen we het in een ethernet-kaart implementeren wanneer data moet worden aangepast. Wanneer weechter de schakeling op zichzelf willen implementeren, dienen we deze te kunnen testen. Bijgevolg zullen weook invoer-uitvoer voorzien. Communicatie tussen mens en modules wordt meestal gerealiseerd met behulpvan leds en schakelaars. Om duidelijk te maken welk signaal we zelf zullen aanleggen zullen we ook leds aande ingang gebruiken. Een probleem die zich soms stelt is dat er een groot aantal bits aan de invoer kunnenworden aangelegd, en het dus niet eenvoudig is om met drukschakelaars een bepaalde configuratie aan teleggen. In dat geval kunnen we gebruik maken van een tuimelschakelaar. Een tuimelschakelaar kan wordenaangekocht, maar ook geımplementeerd met behulp van een drukschakelaar, twee weerstanden, een pnp- ennpn-transistor. Een dergelijke implementatie staat beschreven in Figuur 9.2.

9.1.3 Realisatie

Toestanden en soorten schakeling

In de vorige subsectie hebben we besproken hoe we een diagram kunnen opstellen voor de overdracht. Ditdiagram is precies het diagram voor de Mealy-machine om onze schakeling te realiseren. We kunnen hetdiagram dus rechtstreeks gebruiken om een toestandstabel op te stellen zoals in Tabel 9.1.

2Analoog met de overloop bij bijvoorbeeld een optelling.


100k

output

20k

VDD

VSS

Figuur 9.2: Implementatie van een tuimelschakelaar.

Toestand I0 1

q0 q0/0 q4/1q2 q0/1 q6/0q4 q2/0 q6/1q6 q2/1 q8/0q8 q4/0 q8/1

Tabel 9.1: Toestandstabel van de oneindige vermenigvuldiger.

Toestandscodering

We dienen nu enkel nog een codering te bedenken om de verschillende toestanden op te slaan. Een logischemanier kan zijn om qi op te slaan als het binaire equivalent van i/2. Dit biedt bovendien in dit geval vrijmooie overgangen: bij twee overgangen verandert er geen bit, bij vijf overgangen slechts een bit, een overgangbrengt twee veranderingen teweeg en een overgang drie. We kunnen echter q8 ook encoderen als 111. Ditzorgt ervoor dat er geen overgangen met drie bits meer zijn. Dit is natuurlijk heuristisch: er is geen echtegarantie dat dit effectief tot een goedkopere implementatie zal leiden, al wordt het wel verondersteld. Decoderingstabel wordt dan zoals voorgesteld als in Tabel 9.2

Toestand I0 1

000 000/0 010/1001 000/1 011/0010 001/0 011/1011 001/1 111/0111 010/0 111/1

Tabel 9.2: Coderingstabel van de oneindige vermenigvuldiger.

Type flipflop

Het is niet echt duidelijk welk type flipflop hier nodig is. We zullen de schakeling met een D-flipflop implemen-teren. Wanneer we D-flipflops gebruiken bekomen dienen we combinatorische schakelingen te implementerenzoals op Tabel ?? een grafische voorstelling met behulp van Karnaugh-kaarten staat op Figuur 9.3.

9.1. ONEINDIG VERMENIGVULDIGEN 303

q2 q1 q0 I d2 d1 d0 O

0 0 0 0 0 0 0 00 0 0 1 0 1 0 10 0 1 0 0 0 0 10 0 1 1 0 1 1 00 1 0 0 0 0 1 00 1 0 1 0 1 1 10 1 1 0 0 0 1 10 1 1 1 1 1 1 01 1 1 0 0 1 0 01 1 1 1 1 1 1 1− − − − − − − −

Tabel 9.3: De oneindige vermenigvuldiger.

d2

q2

q1

q0

I

0 0 0 0

0 0 1 0

- 0 1 -

- - - -

d1

q2

q1

q0

I

0 0 1 1

0 0 1 1

- 1 1 -

- - - -

d0

q2

q1

q0

I

0 0 1 0

1 1 1 1

- 0 1 -

- - - -

O

q2

q1

q0

I

0 1 0 1

0 1 0 1

- 0 1 -

- - - -

Figuur 9.3: Karnaugh-kaarten voor de oneindige vermenigvuldiger.

Implementatie

Tot slot dienen we enkel nog de schakeling te implementeren. Het logische circuit staat om dit te realiserenstaat op Figuur 9.4. In de praktijk worden poorten meestal niet per eenheid verkocht: het is goedkoper omvier poorten op een chip te zetten dan vier afzonderlijke chips te produceren. Bijgevolg dienen we nog eenkeuze te maken hoe we deze schakeling realiseren.

Wanneer we naar de schakeling op Figuur 9.4 kijken, kunnen we de verschillende types poorten tellen:

1. 3× NOT poort;

2. 2× 2-NOR poorten;

3. 1× 3-NOR poort;

4. 4× 2-NAND poorten;

5. 2× 3-NAND poorten; en

6. 3× D-flipflops.

Op chipniveau zullen we daarom werken met volgende poorten:

1. 1× 7400 (4× 2-NAND poorten), DIP14, ongeveer e 00.14 per stuk;

2. 1× 7404 (6× NOT-poorten), DIP14, ongeveer e 00.17 per stuk;

3. 1× 7410 (3× 3-NAND poorten), DIP14, ongeveer e 00.32 per stuk;

4. 1× 7427 (3× 3-NOR poorten), DIP14, ongeveer e 00.32 per stuk; en

5. 2× 7474 (2× D-flipflops), DIP14, ongeveer e 00.14 per stuk;

Hieruit kunnen we dan een printplaat samenstellen zoals op Figuur 9.5.


I q0 q1 q2

Q

Q

D

Clk

Q

Q

D

Clk

Q

Q

D

Clk

O

Figuur 9.4: Mogelijke implementatie voor de oneindige vermenigvuldiger.

USB

2N3904

2N3906

100k

20k

U0

2N3904

2N3906

100k

20k

U1

7474 7474 7407

7410 7410 7410

Figuur 9.5: Printplaat-ontwerp voor de oneindige vermenigvuldiger.

9.2 Fietslicht

Men kan vandaag fietslichten kopen met verschillende knippermodes. Bij wijze van experiment zullen we eenknipperlicht implementeren gebaseerd op een ledlamp van Hema.

Het fietslicht bestaat uit drie leds en kent 4 standen: uit, links-rechts, knipperen en aan. Figuur 9.6beschrijft de verschillende modi. Men verandert de modus door een drukschakelaar in te duwen. In het gevaldat men in knipper-modus staat, is de frequentie waarmee men van toestand van led verandert, slechts dehelft.

9.2.1 Benodigdheden

Volgende componenten heeft men nodig om deze schakeling te implementeren:

• 3 leds

9.2. FIETSLICHT 305

uit links-rechts knipperen aan

Figuur 9.6: De verschillende standen van een Hema-fietslicht

• 3 NPN transistoren. Bij voorkeur BC547C

• 3 weerstanden van 1 kΩ.

• 1 drukschakelaar.

• 1 europrintplaat.

Alle componenten zijn verkrijgbaar bij Conrad. De richtprijs is ongeveer e ??.??.

9.2.2 Implementatie-specificaties

In deze subsectie bespreken we hoe we de schakeling zullen implementeren. Dit betekent dat we onder meerde in- en uitvoer vastleggen.

In- en Uitvoer Naast de drie leds van het fietslicht is er geen uitvoer: we gaan er immers vanuit dat eengebruiker door op de drukschakelaar te duwen de werking van het licht zelf kan leren. Als invoer voorzienwe een enkele drukschakelaar. We realiseren de in- en uitvoer aan de hand van de schakeling op Figuur 9.7.

1k

white

l0

1k

white

l1

1k

white

l2

k0

VDD

VSS

Figuur 9.7: De IO-module van het fietslicht


Toestanden en soort schakeling We dienen ook te beslissen wat soort schakeling we zullen implemen-teren. Vermits het aantal toestanden en de mogelijkheden nogal beperkt is, is het implementeren van eenprocessor niet nodig: we kunnen deze schakeling met een eenvoudige sequentiele schakeling realiseren.

Verder dienen we te beslissen of we een synchrone of asynchrone schakeling zullen bouwen. Er speeltnatuurlijk een tijdsaspect: we willen niet dat we meteen in de volgende toestand geraken wanneer een ledaan of uitgaat. Anders is het verschil tussen knipperen en aan moeilijk te zien. We kunnen echter ook hetkloksignaal als een ingangsignaal beschouwen. Dit laatste pleit voor een asynchrone schakeling: er is sprakevan twee soorten ingangen: de schakelaar van het fietslicht die aangeeft dat we een volgende toestand willenkiezen, en het kloksignaal die wanneer het opkomt betekent dat we de bij links-rechts en knipperen leds aanof uit moeten zetten. Een asynchrone schakeling is echter moeilijker te implementeren. Wanneer we vooreen synchrone schakeling opteren zal de gebruiker wanneer hij de schakelaar induwt moeten wachten tot hetvolgende kloksignaal voor de volgende stand van het fietslicht wordt geactiveerd. Het tijdverlies valt echtergoed mee en is meestal niet levensbedreigend. In dit boek kiezen we daarom voor een synchrone schakeling.

Verder rest ons nog het aangeven van de verschillende toestand en wat we doen wanneer een gebruiker deschakelaar indrukt. In principe zijn hier drie mogelijkheden. Iedere keer wanneer de gebruiker de schakelaarindrukt, dan komen we in de begintoestand van de stand. We kunnen ervoor opteren terecht te komen in eentoestand die bijvoorbeeld globaal bepaald is: wanneer er k ticks geweest zijn komen we in de k mod n-detoestand terecht, met n het aantal toestanden van die stand. Een laatste optie is dat het niet uitmaakt,zolang we maar in een toestand terechtkomen die geldig is voor die stand. We opteren in deze cursus voorde eerste optie, dit is ook zo bij het echte fietslicht van Hema.

9.2.3 Realisatie

Toestandstabel

Op basis van de specificaties zullen we een toestandstabel opstellen. De uitgangssignalen van de sequentieleschakeling zijn drie bits: voor elke led betekent 1 dat de overeenkomstige led zal branden, in het gevalvan 0 brandt de led natuurlijk niet. Verder voorzien we een ingangssignaal: dit signaal is 1 wanneer degebruiker de schakelaar indrukt. In het geval de schakelaar niet ingedrukt is, is het signaal 0. Dit levert onsde toestandstabel op zoals Tabel 9.4. In de tabel hebben we de toestanden geannoteerd met de stand in

Toestand k0 l0 l1 l2 Toestand k0 l0 l1 l20 1 0 1

a0 a0 b1 0 0 0 j1 k1 n2 0 0 0b1 c1 n2 0 0 0 k1 l1 n2 0 1 0c1 d1 n2 0 0 1 l1 m1 n2 0 0 0d1 e1 n2 0 0 0 m1 b1 n2 0 0 1e1 f1 n2 0 1 0 n2 o2 r3 0 0 0f1 g1 n2 0 0 0 o2 p2 r3 0 0 0g1 h1 n2 1 0 0 p2 q2 r3 1 1 1h1 i1 n2 0 0 0 q2 n2 r3 1 1 1i1 j1 n2 1 0 0 r3 r3 a0 1 1 1

Tabel 9.4: Toestandstabel van het fietslicht.

subscript (0 uit, 1 links-rechts, 2 knipperen, 3 aan). In stand 2 moest de frequentie gehalveerd worden. Dithebben we opgelost door vier toestanden te voorzien: twee wanneer alle leds uit zijn, en twee wanneer alleleds branden. Op die manier kost het twee klokflanken vooraleer de leds veranderen.

Toestandscodering

In totaal hebben we 18 toestanden nodig om de schakeling te realiseren. Een toestand zal dus wordengeencodeerd op minstens 5 bits. We kunnen er ook voor opteren om de toestand van de leds rechtstreeks in

9.3. TIC TAC TOE-MACHINE 307

het geheugen te encoderen. In dat geval hebben we drie bits nodig om de toestand van de leds weer te gevenen vier overige bits3. Dit zou neerkomen op zeven bits wat vrij duur is. We zullen de toestand voorstellenaan de hand van 5 bits.

Nadat we het aantal bits bepaald heb dienen we nog voor elke toestand een codering te voorzien. Hierproberen we de transitie- en uitvoerlogica mee te vereenvoudigen. We zien dat de links-rechts staat de meestetoestanden gebruikt. We zullen dit dan ook encoderen op zo’n manier dat de eerste bit 1 aanwijst en deoverige bits werken volgens het principe van een 4-bit gray-teller. De overige standen zullen allemaal meteen 0 beginnen. Ook hier proberen we enige logica in de codering te stoppen. Zo spreekt het voor zich datwe de uit-toestand code 00000a toewijzen: we kunnen logica voorzien die wanneer bepaalde bits passief zijn,alle leds meteen niet branden. De eerste en tweede toestand van de knipper-stand geven we dan weer decoderingen 01000n en 01001n. Alle leds moeten branden in de laatste twee toestanden van de knipper-standen de enige toestand van de aan-stand. We coderen deze toestanden respectievelijk met 01101p, 01100q en01110r. De volledige coderingstabel staat beschreven in Tabel 9.5.

Toestand k0 l0 l1 l2 Toestand k0 l0 l1 l20 1 0 1

00000a 00000a 10000b 0 0 0 11100j 11101k 01000n 0 0 010000b 10001c 01000n 0 0 0 11101k 11111l 01000n 0 1 010001c 10011d 01000n 0 0 1 11111l 11110m 01000n 0 0 010011d 10010e 01000n 0 0 0 11110m 10000b 01000n 0 0 110010e 10110f 01000n 0 1 0 01000n 01001o 01110r 0 0 010110f 10111g 01000n 0 0 0 01001o 01101p 01110r 0 0 010111g 10101h 01000n 1 0 0 01101p 01100q 01110r 1 1 110101h 10100i 01000n 0 0 0 01100q 01000n 01110r 1 1 110100i 11100j 01000n 1 0 0 01110r 01110r 00000a 1 1 1

Tabel 9.5: Coderingstabel van het fietslicht.

Type flipflop

Na het opstellen van de coderingstabel dienen we het type flipflop uit te kiezen.

Implementatie in poortlogica

9.3 Tic tac toe-machine

Tic tac toe is een spel waarbij twee spelers beurtelings een zet spelen. Tijdens een zet schrijft een spelereen cirkel of een kruis op het scorebord, een 3 × 3 raster. De eerste speler zet altijd een cirkel, de tweedeeen kruis. Elke speler probeert een situatie te bekomen waarbij drie van de eigen symbolen op een rij staan.Het spel is simpel en kan daarom goedkoop op zelf in electronica geımplementeerd worden. We zullen bijdit experiment twee schakelingen ontwerpen en realiseren: een schakeling zodat twee personen tegen elkaarspelen, en een schakeling waarbij het ook mogelijk is om te spelen tegen een artificiele intelligentie4.

9.3.1 Benodigdheden

Volgende componenten heeft men nodig om deze schakeling te implementeren.

1. 22 leds waaronder 11 rode en 11 groene.

2. 11 NPN transistoren. Bij voorkeur BC547C.

3Het komt immers 9 keer voor dat alle leds uit zijn. Om een onderscheid te maken tussen de verschillende toestanden hebbenwe dus minstens 4 extra bits nodig

4Deze AI-bot zal perfect spelen: als eerste speler zal hij altijd winnen


3. 11 weerstanden van 1 kΩ.

4. 6 drukschakelaars.

5. 1 normale schakelaar.

6. 1 europrintplaat.

Alle componenten zijn verkrijgbaar bij Conrad. De richtprijs is ongeveer e ??.??

9.3.2 Implementatie-specificaties

Alvorens we dit spel kunnen implementeren, zullen we eerst moeten specificeren hoe we bijvoorbeeld met degebruiker(s) gaan communiceren, hoe we de toestand van het bord gaan voorstellen, hoe het spel verloopt,enzovoort.

Uitvoer De uitvoer is een 3×3 bord waar op elke tegel in principe een cirkel of kruis kan worden geplaatst.Dit geeft dus ongeveer5 39 toestanden. De uitvoeren realiseren we aan de hand van leds. Op elk vakje brengenwe twee leds aan, bijvoorbeeld een rode en groene. We maken de afspraak dat indien de rode led brandt, ereen cirkel op het respectievelijke vak staat. Wanneer de groene led brandt stelt dit een kruis voor. Wanneergeen van de twee leds brandt is het vakje leeg. In het vorige hoofdstuk hebben we reeds beargumenteerd datmen niet zomaar leds aan de uitgang van een poort kan schakelen. We voorzien dus een relay-mechanimsmemet behulp van transistoren6. We dienen dus een schakeling te realiseren zoals op Figuur 9.8.

Om te communiceren met de spelers is meer hardware nodig. Zo is het nuttig dat de schakeling aangeeftwie aan zet is, of de gespeelde zet legaal is en wie er gewonnen heeft. Daarom voorzien we nog twee leds:een rode en een groene. Wanneer een rode let brandt, is de eerste speler aan zet, in het geval van de groeneled speelt de tweede speler. Wanneer een speler gewonnen is knippert de overeenkomstige led. Wanneer eenspeler een onmogelijke zet speelt, branden beide leds voor een korte periode allebei.

Invoer We kunnen ervoor opteren om per vak een schakelaar te voorzien. Wanneer een speler dan opde schakelaar drukt, zal de schakeling de overeenkomstige led laten branden. Dit betekent echter dat we9 schakelaars moeten voorzien. We hebben daarom besloten om aan de rand van de twee dimensies elk3 schakelaars te voorzien. 3 schakelaars laten dus toe om de rij te specificeren, met de overige 3 kan eengebruiker de kolom aangeven. Ook vanuit educatief standpunt is deze beslissing positief: men zal immersmeer logica moeten voorzien om de invoer te interpreteren.

Spelverloop

5Niet alle toestanden zijn mogelijk: wanneer bijvoorbeeld de tweede speler wint, is er altijd een vakje niet toegekend. Eensituatie waarbij alle vakjes zijn opgevuld en er drie kruiss op een rij staan is bijgevolg niet mogelijk.

6We kunnen in principe ook echte relays gebruiken. Leds hebben echter een laag verbruik waardoor de taak ook doortransistoren kan worden uitgevoerd.

9.3. TIC TAC TOE-MACHINE 309

1k

red

i0,0,0

1k

green

i0,0,1

1k

red

i0,1,0

1k

green

i0,1,1

1k

red

i0,2,0

1k

green

i0,2,1

1k

red

i1,0,0

1k

green

i1,0,1

1k

red

i1,1,0

1k

green

i1,1,1

1k

red

i1,2,0

1k

green

i1,2,1

1k

red

i2,0,0

1k

green

i2,0,1

1k

red

i2,1,0

1k

green

i2,1,1

1k

red

i2,2,0

1k

green

i2,2,1

VDD

VSS

Figuur 9.8: Een led-matrix en invoer-component voor het tic tac toe spel.

Deel VI

Appendices

311

(a) Nand.

x y f

0 0 10 1 11 0 11 1 0

(b) Nor.

x y f

0 0 10 1 01 0 01 1 0

(c) Xor.

x y f

0 0 00 1 11 0 11 1 0

(d) Xnor.

x y f

0 0 10 1 01 0 01 1 1

Tabel A.1: Waarheidstabellen voor complexe poorten.

313

314 BIJLAGE A. CONVENTIES EN SCHEMAS

Bijlage A

Conventies en Schemas

A.1 Waarheidstabellen van basisschakelingen

A.1.1 Eenvoudige poorten

A.1.2 Complexe poorten

A.2 Lijst van component interfaces

Poorten

Rekenkundig

Rekenkundig

Andere basisschakelingen

Andere basisschakelingenAND-poort

OR-poort

NOT-poort

NAND-poort

NOR-poort

XOR-poort

XNOR-poort

Halve Opteller

Volledige Opteller

Carry-Lookahead Opteller (CLA)

Carry-Lookahead Opteller-Generator

Multiplexer

Decoder

Demultiplexer

Encoder

Vergelijker

xy

f

xy

f

x f

xy

f

xy

f

xy

f

xy

f

HA

x y

s

co

FA

x y

s

co ci

s c

x y

pg

x y

g p

cs

c0

p0g0

c1

p1g1

c2

p2g2

c3

g0,2p0,2

p0g0p1g1p2g2

c1c2c3

g0,2

p0,2 c

d0d1d2d3

s0s1 s0

s1

f

Decoder

Demux

Encoder

Figuur A.1: Lijst van component interfaces.

A.3. CONVENTIES 315

BasispoortenNOT

zx

AND

zxy

OR

zxy

Complexe PoortenNAND

xy

NOR

xy

XOR

xy

Figuur A.2: Samenvattend schema: poorten en componenten (deel 1)

A.3 Conventies

A.4 Poorten

A.4.1 Basispoorten

A.4.2 Complexe Poorten

A.5 Componenten

A.5.1 Rekenkundige schakelingen

A.5.2 Geheugen schakelingen

A.5.3 Andere schakelingen

Multiplexer

A.6 Kostprijs van de Componenten


f

MU

LT

IPL

EX

ER

s0s1

d0d1d2d3

(a) Multiplexer

DE

CO

DE

R

enable

a0a1

s0s1s2s3

(b) Decoder

DE

MU

X

s1s0

f

d0d1d2d3

(c) Demultiplexer

EN

CO

DE

R

s0s1s2s3

f0f1

any

(d) Encoder

Figuur A.3: Andere combinatorische schakelingen

A.6. KOSTPRIJS VAN DE COMPONENTEN 317

Component Transistors Logische blokken

Absolute waarde 32/bit 2/bitAbsolute waarde&Maximum 62/bit 4/bitAftrekker 38/bitAftrekker&Maximum 48/bit 2/bitAftrekker&Opteller 48/bit 2/bitAND-poort 6/bit 1/bitFull adder 36/bit 2/bitMaximum 32/bit 2/bitMaximum&Aftrekker 48/bit 2/bitMaximum&Absolute waarde 62/bit 4/bitMaximum&Opteller 66/bit 5/bitMinimax 32/bit 2/bitMinimum 32/bit 2/bitNAND-poort 4/bit 1/bitNOT-poort 2/bit 1/bitOpteller 36/bitOpteller&Aftrekker 48/bit 2/bitOpteller&Maximum 66/bit 5/bitRegister 44/bitTeken aftrekking 20/bit 1/bitTri-state buffer 10/bit 1/bitVaste schuifoperatie 0/bit2-naar-1 multiplexer 12/bit 1/bit4-naar-1 multiplexer 4 18/bit 2/bitn-naar-1 multiplexer 2 · n+ 2 · dlog2 ne+ 2 · dlog2 n+ 1e · n

Tabel A.2: De kostprijs van de verschillende componenten.

Bijlage B

Softwarepakketten

Mensen die bezig zijn met software, zouden hun eigen hardwaremoeten bouwen.“

”- Alan Kay, Amerikaans informaticus (1940-)

Bij het schrijven van de cursus Digitale Elektronica en Processo-ren werden enkele softwarepakketten geschreven. Deze software laattoe aan de lezer om zelf oefeningen te maken, oplossingen te con-troleren en op een geautomatiseerde manier kleine combinatorischeen sequentiele te realiseren alsook een processor te bouwen. In dithoofdstuk geven we een kort overzicht van deze software. Voor hetLinux besturingssysteem bestaat ook software die helpt bij het con-creet realiseren van een schakeling op bijvoorbeeld een printplaat ofhet simuleren van een schakeling. Deze software wordt kort bespro-ken in enkele secties.

B.1 Geschreven software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

B.1.1 De software installeren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

B.1.2 Invoer en Uitvoer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Commentaar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Bit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Bit-sequenties (bitstring) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Tabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Schakeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

Karnaugh-kaart . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

Assembler code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

Binaire code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

B.1.3 Uitvoer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

B.1.4 Ondersteunde functies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

B.1.5 Functiecompositie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

B.2 Andere software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

319

320 BIJLAGE B. SOFTWAREPAKKETTEN

B.1 Geschreven software

B.1.1 De software installeren

De software is geschreven in Haskell en kan worden gedownload op volgend adres: http://goo.gl/tkyilf.De code staat onder git-subversiebeheer. Bijdragen aan de software wordt aangemoedigd. Men kan desoftware gebruiken door de Makefile te draaien. Dit doet men door in de desbetreffende map het commandomake te typen. Standaard wordt de software niet geınstalleerd op het systeem: de commando’s kunnen alleenin de map zelf uitgevoerd worden. Indien men de programma’s in om het even welke map wenst uit te voeren,kan men make install draaien.

B.1.2 Invoer en Uitvoer

Het programma neemt tekst als invoer en geeft tekst of diagrammen als uitvoer. We overlopen in de volgendesubsubsecties de verschillende vormen van invoer.

Commentaar

Om toe te laten de invoer te annoteren met commentaar, worden alle lijnen die beginnen met een hash-symbool (#) genegeerd. Dit is conform Linux Bourne Again Shell (bash). Het verschil is echter dat enkellijn die beginnen met het hash-symbool daarvoor in aanmerking komen.

Bit

Een bit is een logische waarde waarmee doorheen het volledige programma wordt gerekend. Een bit kentdrie toestanden: waar (1), onwaar (0) en don’t care (-). Het programma is echter in staat op verschillendemanieren een bit te lezen. Zo stellen t, T en 1 alle drie waar voor; f, F en 0 duiden onwaar aan; en d, D, x,X, - betekenen allemaal don’t care.

Bit-sequenties (bitstring)

Meestal beperkt een toestand, invoer en uitvoer zich niet tot een bit. Een bitstring is een sequentie vannul of meer bits. Men schrijft een bitstring eenvoudigweg aan de hand van een sequentie van voorstellingenvoor bits zonder spaties of andere tekens. Een voorbeeld is t-TX1xfDFd0 een geldige representatie van eenbitstring.

Tuples

In het geval van een Mealy-toestandstabel schrijven we in een cel niet alleen de volgende toestand, maar ookde te genereren uitvoer. Met andere woorden een koppel van twee bitsstrings. Koppels stellen we voor aande hand van de elementen, gescheiden door een slash (/).

Tabel

Een tabel is een twee dimensionale structuur. Een tabel is onderverdeeld in cellen. Een horizontale groepcellen noemt men een rij, een verticale groep een kolom. De bovenste rij noemt men doorgaans de hoofdingen verklaart meestal de inhoud van de cellen eronder.

Cellen worden verticaal opgedeeld aan de hand van een verticaal streepje (|), horizontaal worden ze vanelkaar onderscheiden door een nieuwe lijn. Optioneel kan men tussen twee lijnen ook een reeks streepjes (-)zetten, optioneel aangevuld met plus (+) en asterisk (*), een dergelijke lijn wordt eenvoudigweg genegeerd.Lijnen die echter enkel horizontale en verticale streepjes bevatten worden niet genegeerd: immers kan methet streepje als een don’t care interpreteren en het verticale streepje als een nieuwe kolom. De verticalestreepjes hoeven niet op elkaar uitgelijnd te zijn: men kan bijvoorbeeld in de ene rij het eerste verticalestreepje op positie 2 zetten terwijl dit in de lijn erna op positie 20 staat, maar het wordt toch aangeradenconsistent te zijn.

B.1. GESCHREVEN SOFTWARE 321

Voorbeeld Een voorbeeld van een tabel is de volgende code:

dit| is | een | 001001-DXXD

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

geldige| 01111 | Tabel | a/0010 | Ook

al | is | de | tabel | 111

---------+-----+-------+--------+----

moeilijk| leesbaar | | |

Soorten tabellen Een tabel bevat data die door het programma verwerkt kan worden. Om een tabel tekunnen verwerken dient deze niet alleen syntax-matig in orde te zijn. Het is ook belangrijk wat er waar inde tabellen staat. Hieronder geven we een kort overzicht van de verschillende types tabellen:

1. Combinatorische tabel : Een tabel die uit twee kolommen bestaat. Alle cellen bestaan uit bit-sequenties.De lengte van de bit-sequenties van alle linkse cellen moet gelijk zijn, alsook deze uit de rechtse cellen.Een combinatorische tabel wordt geparsed van boven naar onder. Alle resultaten worden eerst opdon’t cares gezet. Telkens wanneer men een rij inleest, wordt de bijbehorende invoer1 aangepast aande overeenkomstige uitvoer. Wanneer dus een invoer tweemaal gespecificeerd wordt - bijvoorbeeld eerstaan de hand van een don’t care en daarna voluit - telt de laatste rij. Zoals gezegd tellen horizontalelijnen niet.

2. Toestandstabel : In de eerste kolom staan vanaf de tweede rij toestanden (tekst die geen bitstringvoorstelt). Toestandstabellen komen verder in twee gedaantes voor: de Moore-toestandstabel en deMealy-toestandstabel.

3. Moore-toestandstabel : Dit is een toestandstabel waarbij vanaf de tweede rij, de tweede tot en metde voorlaatste kolommen uit toestanden (tekst bestaat). In deze tabel staan in de eerste rij vanafde 2-de tot en met de voorlaatste kolom bitstrings die invoer weergeven. De toestanden moeten ookgedefinieerd zijn ergens in een rij in de eerste kolom. In de laatste kolom staan vanaf de tweede rijbitstrings.

4. Mealy-toestandstabel : Dit is een toestandstabel waarbij vanaf de tweede rij, de tweede tot en met delaatste kolommen uit toestanden (tekst bestaat) gepaard met bitstrings. De toestand en de bitstringworden van elkaar onderscheiden door middel van een slash (/). De toestanden moeten ook gedefinieerdzijn ergens in een rij in de eerste kolom.

5. Coderingstabel : In de eerste kolom staan vanaf de tweede rij bitstrings. Coderingstabellen komenverder in twee gedaantes voor: de Moore-coderingstabel en de Mealy-coderingstabel.

6. Moore-coderingstabel: Dit is een coderingstabel die volledig uit bitstrings bestaat. In deze tabel staanin de eerste rij vanaf de 2-de tot en met de voorlaatste kolom bitstrings die invoer weergeven. De tabelbevat buiten de behalve de eerste rij en buitenste kolommen bitstrings die verwijzen naar toestanden.Deze toestanden moeten ook gedefinieerd zijn. In de laatste kolom staan vanaf de tweede rij bitstrings.

7. Mealy-toestandstabel : Dit is een toestandstabel waarbij vanaf de tweede rij, de tweede tot en met delaatste kolommen uit 2-tuples van bitstrings bestaat. De twee bitstrings worden van elkaar onderschei-den door middel van een slash (/). De toestanden moeten ook gedefinieerd zijn ergens in een rij in deeerste kolom.

Schakeling

Een schakeling beschrijft op poort-niveau, en soms op hoger niveau hoe verschillende componenten gegevensuitwisselen. Om het programma eenvoudig te houden werd niet geopteerd voor een grafische schil, maarvoor tekstuele invoer. Een schakeling bestaat daarom uit twee delen:

1. Een lijst met componenten; en

1Dit kunnen er meerdere zijn in het geval de invoer een don’t care bevat.


2. een lijst met verbindingen tussen deze componenten.

Karnaugh-kaart

Een Karnaugh-kaart is een grafische voorstelling van een booleaanse-functie. Karnaugh-kaarten worden enkelgeproduceerd als uitvoer.

Assembler code

Assembler-code is een datastructuur die is afgeleid uit het hoofdstuk rond programmeerbare processoren (zieHoofdstuk 6).

Binaire code

In hetzelfde hoofdstuk hebben we ook een binair equivalent beschouwd: namelijk per instructie wordt deinstructie vertaalt naar een hoeveelheid bits, alsook de argumenten. Binaire code is niets anders dan eenlange binaire sequentie.

B.1.3 Uitvoer

Standaard wordt de uitvoer in tekstvorm op de standaard uitvoer (stdout) geschreven. Men kan natuurlijkde shell functionaliteiten gebruiken om de uitvoer naar een bestand of een ander programma te schrijven.Afhankelijk van de functie kan men soms ook een ander formaat specificeren met de --ascii en --svg

vlaggen om de uitvoer respectievelijk als webpagina of LATEX-code weer te geven.

B.1.4 Ondersteunde functies

De naam van het programma is dep. Aan de hand van een Linux alias kan men het commando dep ookassocieren met dat programma. Men dient het programma op te roepen met een instructie, bijvoorbeelddep showKarnaugh. Met dep --help schrijft men een pagina met een lijst van ondersteunde functies naarde terminal.

Men kan elke instructie ook aanroepen met de --help parameter om een overzicht te krijgen van wat defunctie precies doet en de ondersteunde uitvoerformaten.

1. expand: neemt als invoer een combinatorische tabel en breidt deze uit zodat de don’t cares in de linksekolom verdwijnen.

2. reduce: neemt als invoer een combinatorische tabel en reduceert deze enigszins. De reductie is nietminimaal maar is computationeel goedkoop en levert redelijke resultaten op.

3. lookup: neemt als invoer een combinatorische tabel en als query een bitstring en geeft als uitvoer -indien de don’t cares in de query geen problemen opleveren - een bitstring van uitvoer terug.

4. showKarnaugh: toont een of meerdere Karnaugh-kaarten aan de hand van een ingegeven tabel. Dekaarten worden standaard op de stdout geschreven. Men kan ook gebruik maken van de --svg optieom een grafische uitvoer te genereren.

5. synthesize: neemt als invoer een combinatorische tabel en genereert een beschrijving een “sum-of-products” om deze combinatorische schakeling te bouwen.

6. reduceFSM: neemt als invoer een toestandstabel of coderingstabel (Moore of Mealy mode) en stelt deminimale variant van de gegeven toestandstabel op. De resulterende toestandstabel is gegarandeerdminimaal in aantal toestanden.

B.2. ANDERE SOFTWARE 323

B.1.5 Functiecompositie

Wanneer men een lijst van verschillende commando’s na elkaar beschrijft, worden de commando’s van rechtsnaar links uitgevoerd en wordt de uitvoer van de eerste (meest rechtse) functie doorgegeven als invoer naar detweede functie, enzovoort. Een compositie van verschillende functies kan efficienter zijn dan de commando’szelf afzonderlijk uit te voeren via “pipes” in de Linux shell: allereerst worden de interne structuren niettelkens omgezet naar tekstvorm en terug en bovendien kunnen composities ook sneller worden uitgevoerdomdat een Haskell omgeving enkel termen zal uitrekenen wanneer deze echt nodig zijn.

B.2 Andere software

Het hoeft niet te verbazen dat gebruikers van het Linux besturingssysteem soms ook amateur elektrotechnicizijn, en zelf een omgeving ontwikkelen waarin men elektronica kan ontwikkelen, simuleren tot en met hetontwerpen van een printplaat.

Bijlage C

Oplossingen van de Oefeningen

C.1 Hoofdstuk 1

C.2 Hoofdstuk 2

C.3 Hoofdstuk 3

C.3.1 Karnaugh-kaarten

Invullen van Karnaugh-kaarten

w

x

y

z

w

x

y

z

w

x

y

z

a

0 0 0 0

1 1 1 1

1 1 1 1

1 1 1 1

b

0 1 1 1

0 0 0 0

1 1 1 1

0 1 1 1

c

1 1 1 0

0 1 1 1

- - - -

1 - - 1

d

1 1 1 1

1 0 1 0

- - - -

1 - - 1

e

1 0 1 1

1 1 1 1

- - - -

1 - - 1

f

1 1 1 0

0 1 0 1

- - - -

1 - - 1

g

1 1 0 0

0 1 0 0

- - - -

1 - - 0

h

1 0 0 0

1 1 0 1

- - - -

1 - - 1

i

0 1 1 0

1 1 0 1

- - - -

1 - - 1

Figuur C.1: Oplossingen van het invullen van de Karnaugh-kaarten.

325

326 BIJLAGE C. OPLOSSINGEN VAN DE OEFENINGEN

Lijst van tabellen

1.1 Waarheidstabellen van de basisoperaties. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.2 Waarheidstabel voor de implementatie van een XOR. . . . . . . . . . . . . . . . . . . . . . . . 71.3 Implementatie van de basispoorten met behulp van NAND en NOR poorten. . . . . . . . . . 81.4 Booleaanse algebra zonder variabelen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.5 Booleaanse algebra met een variabele. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.6 Booleaanse algebra met meerdere variabelen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.7 Waarheidstabel voor het synthese-voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.8 Sum-of-Products methode toegepast op het voorbeeld. . . . . . . . . . . . . . . . . . . . . . . 121.9 Product-of-Sums methode toegepast op het voorbeeld. . . . . . . . . . . . . . . . . . . . . . . 12

2.1 Verschil tussen positieve en negatieve logica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3.1 Waarheidstabellen voor de leidende voorbeelden. . . . . . . . . . . . . . . . . . . . . . . . . . 533.2 Samenvatting van de verschillende implementaties. . . . . . . . . . . . . . . . . . . . . . . . . 583.3 Radix-conversie van hexadecimaal en octaal naar binair. . . . . . . . . . . . . . . . . . . . . . 603.4 Voorbeeld van algemene radix-omzetting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623.5 Betekenis van de binaire getallen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703.6 Instructieset van een typische arithmetic-logic unit (ALU). . . . . . . . . . . . . . . . . . . . . 733.7 IEEE 754-1985 Floating Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 793.8 Decimale cijfers en hun BCD equivalent. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 813.9 ASCII standaard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.10 Waarheidtabellen van een encoder en prioriteitsencoder. . . . . . . . . . . . . . . . . . . . . . 853.11 Instructieset voor de schuifoperaties over 1 bit. . . . . . . . . . . . . . . . . . . . . . . . . . . 89

4.1 Toestandstabellen van de leidende voorbeelden. . . . . . . . . . . . . . . . . . . . . . . . . . . 1104.2 Geminimaliseerde toestandstabellen van de leidende voorbeelden. . . . . . . . . . . . . . . . . 1124.3 Codering van de Mealy-machine van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . 1154.4 Codering van de Moore-machine van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . 1154.5 Keuze van het type flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1164.6 Excitatietabellen van de verschillende flipflops . . . . . . . . . . . . . . . . . . . . . . . . . . . 1174.7 Voorstelling van de transitiefunctie van de Moore-machine. . . . . . . . . . . . . . . . . . . . 1184.8 Implementatie van de Mealy-schakeling met verschillende soorten flipflops. . . . . . . . . . . . 1204.9 Uitgangslogica van de Moore- en Mealy-machine naast hun coderingstabellen. . . . . . . . . . 1204.10 Formele beschrijving van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . 1244.11 Configuratie- en toestandstabel van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . 1254.12 Evolutie van de toestandstabel bij het minimaliseren voor en na partitioneren. . . . . . . . . 1284.13 Evolutie van de toestandstabel bij het minimaliseren voor en na twee iteraties. . . . . . . . . 1294.14 Evolutie van de toestandstabel bij een alternatieve minimalisering voor en na twee iteraties. . 1304.15 Toestandstabellen van de leidende voorbeelden bij de asynchrone toestandscodering. . . . . . 1324.16 Coderingstabellen van het voorbeeld na het toepassen van de eerste methode. . . . . . . . . . 1334.17 Coderingstabellen van het voorbeeld na het toepassen van de tweede methode. . . . . . . . . 1354.18 Coderingstabel van het voorbeeld na het toepassen van de derde methode. . . . . . . . . . . . 136

327

328 LIJST VAN TABELLEN

4.19 Coderingstabel van het voorbeeld met initiele toestand voor de overgangstoestand. . . . . . . 1374.20 Coderingstabel van de schakeling uit Figuur 4.38. . . . . . . . . . . . . . . . . . . . . . . . . . 142

5.1 Toestand-actie tabel van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . 1535.2 Simulatie van het algoritme met behulp van de toestand-actie tabel (tabel 5.1). . . . . . . . . 1545.3 Typische vertragingstijden voor RAM-geheugens. . . . . . . . . . . . . . . . . . . . . . . . . . 1635.4 Toestandstabel van de controller van het leidend voorbeeld via de basisprincipes. . . . . . . . 1705.5 Samenvatting van de kostprijs van de belangrijkste componenten . . . . . . . . . . . . . . . . 1795.6 Levensduurtabel van het vierkantswortel voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . 1795.7 De evolutie van de in [n]- en out [n]-set op basis van het leidend voorbeeld (zie figuur 5.22) . . 1805.8 Functionele-eenhedentabel van het leidend voorbeeld (zie figuur 5.22) . . . . . . . . . . . . . . 1815.9 Verbindingentabel van het leidend voorbeeld (zie figuur 5.22) . . . . . . . . . . . . . . . . . . 1825.10 Invoer- en uitvoertabellen van het leidend voorbeeld (zie figuur 5.22) . . . . . . . . . . . . . . 1835.11 Stuursignalen voor de verschillende toestanden na samenvoegen van registers. . . . . . . . . . 1875.12 Multiplexer selectie-ingangen bij abs&max. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1915.13 Multiplexer selectie-ingangen bij add&max. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1935.14 Multiplexer selectie-ingangen bij abs&add&max. . . . . . . . . . . . . . . . . . . . . . . . . . 1945.15 Multiplexer selectie-ingangen bij abs&add&max&sub. . . . . . . . . . . . . . . . . . . . . . . 1965.16 Multiplexer selectie-ingangen bij min&sub. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1975.17 Multiplexer selectie-ingangen bij abs&min&sub. . . . . . . . . . . . . . . . . . . . . . . . . . . 1985.18 Operand- en resultaten-tabel van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . 2025.19 Registertoegangstabel van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . 2055.20 Registerbank-configuraties voor het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . 2055.21 Vergelijking van de kostprijs na de verschillende optimalisaties. . . . . . . . . . . . . . . . . . 206

6.1 De registerinstructies van de CISC-processor (type 00). . . . . . . . . . . . . . . . . . . . . . . 2316.2 De verplaatsinstructies van de CISC-processor (type 01). . . . . . . . . . . . . . . . . . . . . . 2316.3 De spronginstructies van de CISC-processor (type 10). . . . . . . . . . . . . . . . . . . . . . . 2326.4 De overige instructies van de CISC-processor (type 11). . . . . . . . . . . . . . . . . . . . . . 2336.5 Frequentietabel bij het uitvoeren van het voorbeeldprogramma. . . . . . . . . . . . . . . . . . 237

7.1 Gereserveerde woorden in VHDL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2667.2 Scheidingstekens in VHDL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2667.3 Overzicht van belangrijke types en afgeleide types in VHDL. . . . . . . . . . . . . . . . . . . . . 2677.4 Resolutie-tabel voor std logic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274

8.1 Lijst met populaire geıntegreerde circuits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2868.2 De verschillende kleurcodes bij een weerstand. . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

9.1 Toestandstabel van de oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . . . . . . . 3029.2 Coderingstabel van de oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . . . . . . . 3029.3 De oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3039.4 Toestandstabel van het fietslicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3069.5 Coderingstabel van het fietslicht. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307

A.1 Waarheidstabellen voor complexe poorten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313A.2 De kostprijs van de verschillende componenten. . . . . . . . . . . . . . . . . . . . . . . . . . . 317

Lijst van figuren

1 Link naar de meest recente versie van deze cursus. . . . . . . . . . . . . . . . . . . . . . . . . x

1.1 Basis van het lamp-model. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.2 Implementatie van de basispoorten volgens het lamp-model. . . . . . . . . . . . . . . . . . . . 51.3 XOR-poort in het lamp-model. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.4 Basispoorten en uitbreidingen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.5 Complexe poorten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.6 Poorten met geınverteerde ingangen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.7 Voorbeeld van het tijdsgedrag van een logische schakeling met een “glitch”. . . . . . . . . . . 91.8 Herleiden naar standaard vorm van voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . 131.9 Standaard vorm en alternatief. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.10 Standaardvorm van het voorbeeld met NAND en NOR’s. . . . . . . . . . . . . . . . . . . . . 141.11 Typisch verloop van een digitaal ontwerp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.12 De verschillende lagen bij de synthese. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.13 Digitaal ontwerpen met CAD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.14 Voorbeeldcircuit voor VHDL code. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.1 Schematisch bereik van “High” en “Low” spanning. . . . . . . . . . . . . . . . . . . . . . . . . 242.2 Notatie van een schakelaar (met stuursignaal). . . . . . . . . . . . . . . . . . . . . . . . . . . 252.3 Werking van NMOS en PMOS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262.4 NOT poort geımplementeerd in NMOS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.5 Open-Drain Poort in NMOS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.6 NAND en NOR poort geımplementeerd met NMOS. . . . . . . . . . . . . . . . . . . . . . . . 282.7 NOT poort geımplementeerd met CMOS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282.8 NAND en NOR poorten geımplementeerd met CMOS. . . . . . . . . . . . . . . . . . . . . . . 292.9 Kortsluiting bij wired poort implementaties met CMOS. . . . . . . . . . . . . . . . . . . . . . 292.10 AND-OR-Inverter (AOI) en OR-AND-Inverter (OAI) in CMOS. . . . . . . . . . . . . . . . . 302.11 Implementatie van populaire alternatieve poorten in CMOS. . . . . . . . . . . . . . . . . . . . 312.12 Ontwerp met standaard cellen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332.13 Schematische voorstelling van een Programmable Logic Array (PLA). . . . . . . . . . . . . . 352.15 Schematische voorstelling van een Complex Programmable Logic Device (CPLD). . . . . . . . 352.14 Schematische voorstelling van een Programmable Logic Device (PLD). . . . . . . . . . . . . . 362.16 Schematische voorstelling van een Field Programmable Gate Array (FPGA). . . . . . . . . . 372.17 Werking van ruismarge bij CMOS en TTL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382.18 Transferfuncties en Schmitt-Trigger ingangen. . . . . . . . . . . . . . . . . . . . . . . . . . . . 382.19 Dynamisch gedrag bij twee sequentiele NOT poorten. . . . . . . . . . . . . . . . . . . . . . . 392.20 Het dynamisch gedrag van een NOT-poort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412.21 Buffer geımplementeerd met omgekeerde transistoren: NMOS is een slechte pull-up. . . . . . 422.22 Tri-state buffer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

3.1 N-kubus voor dimensies 1 tot 4. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503.2 Van N -kubus naar Karnaugh-kaart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513.3 Karnaugh-kaarten voor verschillende dimensies met binaire waarden. . . . . . . . . . . . . . . 51

329

330 LIJST VAN FIGUREN

3.4 Terminologie van een Karnaugh-kaart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523.5 Ingevulde Karnaugh-kaarten voor de uitgangen van het leidend voorbeeld. . . . . . . . . . . . 533.6 Karnaugh-kaarten met priemimplicanten van het leidend voorbeeld. . . . . . . . . . . . . . . 543.7 Karnaugh-kaarten met essentiele priemimplicanten van het leidend voorbeeld. . . . . . . . . . 543.8 Werking van het greedy algoritme bij het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . 553.9 Voorbeelden van dambordpatronen in Karnaugh-kaarten. . . . . . . . . . . . . . . . . . . . . 553.10 Karnaugh-kaart met don’t cares van led A en B van een seven-segment display. . . . . . . . . 563.11 Duale methode met Karnaugh-kaarten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573.12 Verschillende implementaties van dezelfde logische functie. . . . . . . . . . . . . . . . . . . . . 593.13 Half adder (HA). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 633.14 Full adder (FA). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643.15 Schematische voorstelling van een n-bit Ripple-carry opteller. . . . . . . . . . . . . . . . . . . 643.16 Carry-Lookahead Opteller (CLA). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653.17 CLA-generator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.18 Een mogelijke implementatie voor een CLA-generator met n = 3. . . . . . . . . . . . . . . . . 673.19 Optelling en aftrekking van gehele getallen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713.20 Opteller-aftrekker voor 2-complement getallen. . . . . . . . . . . . . . . . . . . . . . . . . . . 723.21 Schematisch implementatie van een arithmetic-logic unit (ALU). . . . . . . . . . . . . . . . . 723.22 Synthese van de ALE en CIG. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 743.23 Parallelle vermenigvuldigers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 753.24 Underflow van een vlottende komma voorstelling. . . . . . . . . . . . . . . . . . . . . . . . . . 783.25 Mogelijke implementatie van een BCD opteller. . . . . . . . . . . . . . . . . . . . . . . . . . . 813.26 Multiplexer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833.27 Decoder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.28 Multiplexer en bus gesynthetiseerd met decoders. . . . . . . . . . . . . . . . . . . . . . . . . . 843.29 Demultiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.30 Encoder en Prioriteitsencoder. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863.31 Vergelijker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 873.32 Speciale gevallen van vergelijkers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 883.33 Implementatie van een schuifoperator over 1 bit. . . . . . . . . . . . . . . . . . . . . . . . . . 903.34 Implementatie van een 8-bit barrel left rotator. . . . . . . . . . . . . . . . . . . . . . . . . . . 91

4.1 Set-reset latch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 964.2 Geklokte SR-latch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974.3 Geklokte D-latch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 974.4 Tijdsgrafieken van een D-latch. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984.5 Metastabiliteit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 984.6 Master-slave flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.7 Edge-triggered flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.8 Set-reset flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1014.9 Data-flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.10 Toggle-flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.11 Jack-Kilby flipflop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1024.12 Overzicht van de interfaces van geheugencomponenten. . . . . . . . . . . . . . . . . . . . . . . 1034.13 Interface en implementatie van een 4-bit register. . . . . . . . . . . . . . . . . . . . . . . . . . 1044.14 Implementatie van een 4-bit schuifregister. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1044.15 Asynchrone 4-bit teller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054.16 Synchrone 4-bit teller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1054.17 Parallel-laadbare bidirectionele 4-bit teller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1064.18 4-bit modulo-tellers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1074.19 Toestandsdiagrammen van de leidende voorbeelden. . . . . . . . . . . . . . . . . . . . . . . . 1094.20 Geminimaliseerde toestandsdiagrammen van de leidende voorbeelden. . . . . . . . . . . . . . 1124.21 Een 2-bit en 3-bit Gray-code teller en zijn straightforward equivalent. . . . . . . . . . . . . . 115

LIJST VAN FIGUREN 331

4.22 Implementatie van de Moore-schakeling met verschillende soorten flipflops. . . . . . . . . . . . 1194.23 Implementatie van de Mealy-schakeling met verschillende soorten flipflops. . . . . . . . . . . . 1214.24 Volledige implementatie van de Mealy-machine met D-flipflops. . . . . . . . . . . . . . . . . . 1224.25 Toestandsdiagram van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1264.26 Flowchart van het minimalisatieproces van asynchrone schakelingen. . . . . . . . . . . . . . . 1274.27 Merger-diagrammen van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . 1294.28 Voorbeelden van een cycle en critical race. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1314.29 Transitiediagramma van het voorbeeld na het toepassen van de eerste methode. . . . . . . . . 1344.30 Transitiediagramma van het voorbeeld na het toepassen van de tweede methode. . . . . . . . 1354.31 Transitiediagram van het voorbeeld na het toepassen van de derde methode. . . . . . . . . . . 1374.32 Statische hazards. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1384.33 Dynamische hazards. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1394.34 Karnaugh-kaart bij het leidende voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1404.35 Het invoeren van redundante termen elimineert statische 1-hazards. . . . . . . . . . . . . . . . 1414.36 Dambord patroon. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1414.37 Realisatie van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1424.38 Essentiele hazard van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

5.1 Opbouw van een processor en datapad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1495.2 Voorstelling van de verschillende ASM-elementen . . . . . . . . . . . . . . . . . . . . . . . . . 1555.3 ASM-schema van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1565.4 Traditionele valkuilen bij het maken van ASM-schema’s. . . . . . . . . . . . . . . . . . . . . . 1575.5 Toestandsgebaseerd ASM-schema van het leidend voorbeeld. . . . . . . . . . . . . . . . . . . . 1595.6 Implementatie van een Register File Cell (RFC) met 2 lees- en 2 schrijfpoorten . . . . . . . . 1595.7 Implementatie van een 4× 3 registerbank met 2 schrijf- en 3 leespoorten.?? . . . . . . . . . . 1605.8 Tijdsgedrag van RAM-geheugens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1625.9 Conceptueel voorbeeld van een stapelgeheugen. . . . . . . . . . . . . . . . . . . . . . . . . . . 1635.10 Demonstratie van een stapelgeheugen met tellers. . . . . . . . . . . . . . . . . . . . . . . . . . 1645.11 Implementatie van een stapelgeheugen met behulp van RAM-geheugen. . . . . . . . . . . . . 1655.12 Conceptueel voorbeeld van een buffergeheugen. . . . . . . . . . . . . . . . . . . . . . . . . . . 1665.13 Demonstratie van een buffergeheugen met tellers. . . . . . . . . . . . . . . . . . . . . . . . . . 1665.14 Implementatie van een buffergeheugen met behulp van RAM-geheugen. . . . . . . . . . . . . 1675.15 Implementatie van het datapad van het leidend voorbeeld via de basisprincipes. . . . . . . . . 1695.16 Toestandsdiagram van de controller van het leidend voorbeeld via de basisprincipes. . . . . . 1705.17 Algemene vorm van een controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1725.18 Controller met natuurlijke volgorde van toestanden. . . . . . . . . . . . . . . . . . . . . . . . 1735.19 Controller met natuurlijke volgorde van toestanden en subroutines. . . . . . . . . . . . . . . . 1745.20 Controller met one-hotcodering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1755.21 Microprogrammeerbare controller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1765.22 ASM-schema van het vierkantswortel-benaderingsalgoritme. . . . . . . . . . . . . . . . . . . . 1775.23 Implementatie van het datapad van de benaderende vierkantswortel volgens de basisprincipes. 1785.24 De evolutie van de compatibiliteitsgraaf voor de variabelen. . . . . . . . . . . . . . . . . . . . 1855.25 Implementatie van het datapad van het leidend voorbeeld na het minimaliseren van de varia-

belen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1865.26 Oorspronkelijke compatibiliteitsgrafe bij het samenvoegen van bewerkingen. . . . . . . . . . . 1885.27 Minimaliseren van bewerkingen introduceert multiplexers. . . . . . . . . . . . . . . . . . . . . 1895.28 Implementatie van een minimum-component. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1895.29 Implementatie van abs en abs&max. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1905.30 Het combineren van abs1 en max1 introduceert een multiplexer. . . . . . . . . . . . . . . . . . 1915.31 Implementatie van een opteller, aftrekker en opteller/aftrekker. . . . . . . . . . . . . . . . . . 1925.32 De implementatie van add&max per bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1935.33 De implementatie van abs&add&max per bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1945.34 Methodes bij het introduceren van een multiplexer bij een samengestelde functionele eenheid. 195


5.35 De implementatie van min&sub per bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1965.36 De implementatie van abs&min&sub per bit. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1975.37 De uiteindelijke compatibiliteitsgrafe bij het samenvoegen van bewerkingen. . . . . . . . . . . 1995.38 Implementatie van het datapad na optimalisatie van de bewerkingen. . . . . . . . . . . . . . . 2005.39 Het samenvoegen van verbindingen kan multiplexers elimineren. . . . . . . . . . . . . . . . . . 2015.40 De compatibiliteitsgrafes bij het samenvoegen van verbindingen. . . . . . . . . . . . . . . . . 2035.41 De implementatie van het datapad na het minimaliseren van de verbindingen. . . . . . . . . . 2045.42 Een voorbeeld van een instructiewoord. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2065.43 De chaining-transformatie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2085.44 De multicycling-transformatie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2085.45 De verschillende uitvoeringsstrategieen: sequentieel, parallel en pipelining. . . . . . . . . . . . 2095.46 De pipelining-transformatie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2105.47 Terugkoppeling verhindert pipelining. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2115.48 Laadbaar registers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2135.49 Synchronisatie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2155.50 De verschillende componenten van de “metastability resolution time”. . . . . . . . . . . . . . 2155.51 Metastabiliteit oplossen door een opeenvolging van flipflops. . . . . . . . . . . . . . . . . . . . 216

6.1 De structuur van een programmeerbare processor. . . . . . . . . . . . . . . . . . . . . . . . . 2196.2 Indirecte adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2266.3 Relatieve adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2266.4 Geındexeerde adressering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2276.5 Geındexeerde adressering met autoincrement/autodecrement. . . . . . . . . . . . . . . . . . . 2286.6 De processorontwerp-cyclus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2296.7 De bitstructuur van de CISC instructieset. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2306.8 Het instructieset-stroomschema van de CISC processor. . . . . . . . . . . . . . . . . . . . . . 2486.9 Stroomschema naar ASM-schema voor de ASR-instructie. . . . . . . . . . . . . . . . . . . . . 2496.10 Stroomschema naar ASM-schema voor de LOAD constante-instructie. . . . . . . . . . . . . . 2496.11 Stroomschema naar ASM-schema voor de LOAD direct-instructie. . . . . . . . . . . . . . . . 2506.12 Stroomschema naar ASM-schema voor de LOAD indirect-instructie. . . . . . . . . . . . . . . 2516.13 Stroomschema naar ASM-schema voor de JSR-instructie. . . . . . . . . . . . . . . . . . . . . 2526.14 Stroomschema naar ASM-schema voor de RTS-instructie. . . . . . . . . . . . . . . . . . . . . 2526.15 Het ontwerp van een CISC-controller met programmateller, geheugen en instructieregister. . . 2536.16 Het ontwerp van een CISC-controller met interne eindige toestandsautomaat. . . . . . . . . . 2536.17 Controller met samengevoegd geheugen en stapelgeheugen. . . . . . . . . . . . . . . . . . . . 2546.18 Controller met extern geheugen (Von Neumann-architectuur). . . . . . . . . . . . . . . . . . . 2546.19 De basis datapad-ontwerp van de CISC-processor. . . . . . . . . . . . . . . . . . . . . . . . . 2556.20 De uiteindelijke controller van de CISC-processor. . . . . . . . . . . . . . . . . . . . . . . . . 2556.21 Het datapad-ontwerp na het aanbrengen van verbindingen van de CISC-processor. . . . . . . 2566.22 De structuur van de 8086 microprocessor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2576.23 De structuur van de 8051 microcontroller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2586.24 De structuur van de ARM7 microprocessor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2596.25 De pipelining-structuur van de ARM11 microprocessor. . . . . . . . . . . . . . . . . . . . . . 259

8.1 DIP packing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2858.2 De uitlijning en betekenis van de verschillende kleurbanden. . . . . . . . . . . . . . . . . . . . 2888.3 De realisatie van een condensator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2888.4 De realisatie van een spoel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2898.5 Een voorbeeld van een matrixbord. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2908.6 Structuur van een europrintplaat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2918.7 Een voorbeeld van een printed circuit board (pcb). . . . . . . . . . . . . . . . . . . . . . . . . 2928.8 De pinout van de 555-timer en 556-timer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2938.9 Schakeling voor de implementatie van een kloksignaal met een 555-timer . . . . . . . . . . . . 2948.10 Astabiele multivibrator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295

LIJST VAN FIGUREN 333

8.11 PCB-weergave van populaire componenten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

9.1 Een toestandsdiagram voor k = 5. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3009.2 Implementatie van een tuimelschakelaar. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3029.3 Karnaugh-kaarten voor de oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . . . . . 3039.4 Mogelijke implementatie voor de oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . 3049.5 Printplaat-ontwerp voor de oneindige vermenigvuldiger. . . . . . . . . . . . . . . . . . . . . . 3049.6 De verschillende standen van een Hema-fietslicht . . . . . . . . . . . . . . . . . . . . . . . . . 3059.7 De IO-module van het fietslicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3059.8 Een led-matrix en invoer-component voor het tic tac toe spel. . . . . . . . . . . . . . . . . . . 309

A.1 Lijst van component interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314A.2 Samenvattend schema: poorten en componenten (deel 1) . . . . . . . . . . . . . . . . . . . . . 315A.3 Andere combinatorische schakelingen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316

C.1 Oplossingen van het invullen van de Karnaugh-kaarten. . . . . . . . . . . . . . . . . . . . . . 325

Lijst van VHDL-Codes

1.1 8-bit comparator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201.2 Voorbeeldcode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211.3 Configuratie van de voorbeeldcode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216.1 Hoog niveau beschrijving van het min-max-sum

algoritme.234 6.2 Het min-max-sum algoritme in as-sembleertaal.235 6.3 Het min-max-sum algoritme inmachinetaal.236

7.1 Definieren van types door opsomming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2687.2 Definieren van types door subtypering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2687.3 Definieren van fysische types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2697.4 Definieren van matrix types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2707.5 Definieren van constanten. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2717.6 Werken met variabelen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2727.7 Werken met signalen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2727.8 De definitie van std logic en std ulogic (IEEE 1164). . . . . . . . . . . . . . . . . . . . . . 2737.9 Implementatie van de std logic resolutie-functie in VHDL. . . . . . . . . . . . . . . . . . . . . 2757.10 Vector aaneenschakeling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2767.11 Vector matrixdeling. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2767.12 Voorbeeld van een “package declaration”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2777.13 Voorbeeld van een “package body”. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2777.14 2-naar-1-multiplexer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2787.15 n-bit Opteller. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2797.16 Beschrijving van de procedure om de sha1 uit te rekenen. . . . . . . . . . . . . . . . . . . . . 281

335

336 LIJST VAN VHDL-CODES

Woordenlijst

Symbols

fix 〈i, f〉 De notatie voor een vaste komma voorstel-ling met i cijfers voor het gehele gedeelte, en fcijfers voor het fractionele gedeelte. Deze no-tatie wordt gebruikt om te redeneren over hetaantal cijfers die men voor beide delen moet re-serveren om bijvoorbeeld een optelling volledigte kunnen berekenen.. 77

float 〈m, e〉 De notatie voor een vlottende komma voor-stelling met m cijfers voor de mantisse, en ecijfers voor de exponent. Deze notatie wordtgebruikt om te redeneren over het aantal cijfersdie men voor beide delen moet reserveren ombijvoorbeeld een vermenigvuldiging foutloos tekunnen berekenen.. 78

mod zie modulo. 76

rem zie remainder. 76

n-and Een basisschakeling met n ingangen. 〈1, 1, . . . , 1〉wordt afgebeeld op 1; en alle overige configura-ties op 0.. 7

n-or Een basisschakeling met n ingangen. 〈0, 0, . . . , 0〉wordt afgebeeld op 0; alle overige configuratiesop 1.. 7

double zie dubbele precisie. 78

float zie enkele precisie. 78

single zie enkele precisie. 78

0-maxtermen 0-maxtermen is de verzameling vanmaxtermen voor de rijen waar de waarheidsta-bel 0 is.. 11

1-complement zie cijfer-complement. 68

1-mintermen 1-mintermen is de verzameling vanmintermen voor de rijen waar de waarheidsta-bel 1 is.. 11

2-complement zie radix-complement. 69

3-state buffer zie . 43

A

adres-ingangen ai Een reeks ingangen waardoor meneen component kan meegeven aan een compo-nent. Componenten met adres-ingangen zijnbijvoorbeeld de decoder en het RAM geheugen.De adres-ingang bepaald welke cel wordt uitge-lezen/weggeschreven of welke data-uitgang wordtgeactiveerd.. 82

algebraısch manipuleren Het aanpassen van eengegeven algebraısche expressie zodat het resul-taat equivalent is met het origineel. Aan dehand van algebraısche manipulatie kan men eenexpressie echter in een meer wenselijke vormbrengen. Algebraısche manipulatie wordt somsgebruikt in de zoektocht naar een goedkope im-plementatie voor een booleaanse functie.. 57

American Standard Code for Information Interchange (ASCII)Een formaat om tekst voor te stellen. ASCIIomvat 128 karakters. Tekst wordt dan karakterper karakter voorgesteld.. 80

Analyse Een stap in het ontwerpproces waarbij mentest of een synthese voldoet aan alle vereistespecificaties.. 16

AND Een populaire basisschakeling met twee ingan-gen. 〈0, 0〉, 〈0, 1〉 en 〈1, 0〉 worden afgebeeld op0; en 〈1, 1〉 wordt afgebeeld op 1.. 4

AND-matrix Een raster dat gebruikt wordt voorprogrammeerbare chips. Men beschouwt n in-gangen en m n-AND-poorten, voor elke ingangen elke AND poort is er een zekering waar-door men kan beslissen welke ingangen er aanwelke AND-poort worden gehangen. Een AND-matrix wordt ondermeer gebruikt bij een pro-grammable logic array (PLA).. 34

AND-OR-Invert (AOI) Een schakelin gemaakt uittransistoren die een tweelagige structuur om-vat met op het eerste niveau een reeks AND-poorten, de uitgangen van deze AND poortenpasseren vervolgens door een NOR poort. Men

337

338 Woordenlijst

kan de schakelin echter zeer goedkoop realise-ren.. 29

any-uitgang a Een uitgang van een component dieeen 1 aanlegt in het geval een of meerdere data-ingangen een 1 aanleggen. Voorbeelden vancomponenten met een any-uitgang zijn de en-coder en prioriteitsencoder.. 85

Arabisch getalsysteem Een manier om getallen voorte stellen. Met het Arabisch getalsysteem stel-len we getallen voor als een opeenvolging vancijfers. Elk cijfer heeft een bepaald gewicht datafhangt van de plaats van dat cijfer in de se-quentie: de waarde van het i-de getal van rechts- inclusief 0 - is ri met r de radix.. 59

Arithmetic-Logic Extender (ALE) Een deelcom-ponent van een arithmetic logic unit (ALU).Een ALE mapt telkens twee bits van de operan-den ai en bi en het instructiewoord naar tweenieuwe bits xi en yi, vaak door logische bewer-kingen toe te passen. De resulterende getallenA en B gaan dan door een opteller om tot eenfinaal resultaat te komen.. 72

Arithmetic-Logic Unit (ALU) Een component dieop basis van een opteller en een arithmetic-logic extender in staat is een reeks populaireinstructies uit te voeren zoals optellen, aftrek-ken, increment, decrement samen met bitge-wijze logische operaties (NOT, AND, OR,...).Veel processoren beschikken over een of meer-dere ALUs.. 72

Aritmetisch schuiven Een variant van schuiven waar-bij we schuiven zien als een vermenigvuldigingof deling door een macht van twee. Bij bijvoor-beeld de 2-complement voorstelling leidt dit toteen ander gedrag dan bij logisch schuiven. Indat geval zullen we bij aritmetisch schuiven naarrechts de hoogste bit van het originele getal inrekening brengen, en deze waarde op de vrijge-komen plaatsen invullen.. 89

B

barrel left rotator Een component die een rotatiekan uitvoeren over een willekeurig aantal bits.Dit doet men door voor een n bit getal, log2 nlagen te beschouwen. Voor elke laag i maaktmen aan de hand van multiplexers de keuze omhet getal door te laten of 2i posities naar linkste rotereren,. 89

Basis zie Gate. 25

basisoperaties Set van operaties waaruit andere ope-raties zijn opgebouwd: in de booleaanse algebrazijn dit de NOT, AND en OR.. 4

binair stelsel Een Arabisch getalstelsel met radixr = 2.. 59

Binary Coded Decimal (BCD) Een formaat omgetallen mee voor te stellen. Bij een binarycoded decimal wordt elk cijfer in het decimaalstelsel voorgesteld door vier bits. Men zet duselk cijfer van de decimale voorstelling om in zijnbinair equivalent. Rekenen met binary codeddecimals is complexer. Het voordeel is dat menelk getal dat decimaal kan worden voorgesteld,ook in bcd notatie exact kan voorstellen. Hetformaat is dan ook populair in de financiele we-reld.. 80

blackbox Een systeem waarvan de inwendige wer-king niet bekend is, men weet enkel hoe hetsysteem communiceert met zijn omgeving, ensoms zijn ook enkele specificaties over het sys-teem bekend.. 20

booleaanse algebra De tak van de wiskunde diezich bezighoudt met logische bewerkingen.. 9

bronradix Bij omzetting van een getal tussen tweeArabische getalstelsels de radix van het origi-nele getalstelsel.. 60

buffer Een poort met een ingang waarbij 0 wordtafgebeeld op 0; en 1 op 1. Een buffer is dusequivalent aan een draad, maar wordt gebruiktom de fan-out onder controle te houden.. 30,341

buren De buren van een knoop k in een graaf is deverzameling van knopen zodat er een boog be-staat tussen k en de knoop in kwestie.. 50

bus Een bus is een coponent die het mogelijk maaktom over een geleider signalen van verschillendebronnen naar andere componenten over te stu-ren. Een bus maakt gebruik van tri-state buf-fers. Op ieder moment is er hoogstens een bronwaarvoor de overeenkomstige tri-state buffer ac-tief is.. 44, 83

C

canonieke vorm Een implementatie van een logi-sche functie aan de hand van Sum-of-Productsof Product-of-Sums waarbij men geen pogingdoet de min- of maxtermen verder te optimali-seren.. 12

Woordenlijst 339

Capaciteit C De capaciteit van een geleider ont-staat door de geometrie van de chip: de ge-leider en zijn positie tegenover geleiders van degrond en bron. Men probeert deze capaciteit zolaag mogelijk te houden om de tijdsconstantete verlagen en bijgevolg de chip sneller te latenschakelen. Typisch zal een lange geleider ookeen hogere capaciteit hebben. Daarom probeertmet het aantal lange lijnen op een geleider toteen minimum te beperken.. 40

carry zie overdracht. 62

Carry Input Generator (CIG) Een deelcomponentvan een arithmetic logic unit (ALU). Een CIGberekent welke overdracht c0 er voor de optellermoet worden gegenereerd, en doet dit op basisvan het instructiewoord.. 72

carry-generate gi Een uitgang van een carry-lookaheadopteller; 1 indien er carry gengereerd zal wor-den door xi en yi. Dit is het geval wanneerbeide ingangen een 1 aanleggen. In het anderegeval staat er 0 op deze uitgang.. 64

Carry-lookahead opteller (CLA) Een uitbreidingop de full adder. In plaats van een carry uit-gang ci, heeft de carry-lookahead opteller eengenerate uitgang gi en een popagate uitgang pi.Deze uitgangen berekenen of er op deze bit eencarry zal gegenereerd worden - wanneer zowelxi als yi 1 zijn, of wanneer een carry van devorige bit zal gepropageerd worden: wanneerminstens een van de twee ingangen xi of yi 1is.. 64

carry-propagate pi Een uitgang van een carry-lookaheadopteller; 1 indien er carry gepropageerd zal wor-den door xi en yi en niet gegenereerd. Dit ishet geval wanneer een van de twee ingangen 1aanlegt. In het andere geval staat er 0 op deuitgang.. 64

cascade Het organiseren van componenten op meer-dere lagen. Een dergelijke organisatie leidt vaaktot efficientie, zowel in doorvoersnelheid als inkostprijs. Concrete voorbeelden van cascade or-ganisatie vinden we terug bij een CLA-generator,multiplexers en vergelijkers.. 82

chipoppervlakte C De totale oppervlakte die eenchip inneemt, en waarop transistoren en bedra-ding wordt gezet. Het dynamisch vermogenver-bruik schaalt lineair met de chipoppervlakte..42

cijfer-complement Een complement voorstelling waar-bij men negatieve getallen voorstelt door elk cij-fer i te vervangen door het complement r−i−1met radix r.. 68, 337, 340

cijferen Een verzameling van technieken die in hetlager onderwijs worden aangeleerd om bewer-kingen zoals optellen, aftrekken, vermenigvul-digen en delen uit te voren op grote getallen.In plaats van de bewerking in een keer op detwee getallen uit te voeren, wordt een bepaaldemethode cijfer per cijfer uitgevoerd. Cijferenkomt ook terug in digitale logica wanneer menrekenkundige circuits implementeert.. 62

CLA-generator Een component met ingangen 〈c0, g0, . . . , gn−1, p0, . . . , pn−1〉die overdracht doorrekent en die de carry-lookaheadoptellers van de waarde voor de overdracht-ingangvoorziet. De uitgangen zijn dan ook 〈c1, . . . , cn, g0,n−1, p0,n−1〉.Door een cascade van CLA-generatoren te be-schouwen, kan men een optelling realiseren diein O (log n) werkt, in plaats van in O (n).. 65

Collector zie Source. 25

Combinatorische Schakelingen Schakelingen waar-bij een bitvector aan de uitgangen uitsluitendwordt bepaald aan de hand van een bitvectoraan de ingangen. Er zijn met andere woor-den geen geheugencomponenten en de schake-ling houdt bijgevolg geen toestand bij. On-der combinatorische schakelingen vinden we bij-voorbeeld optellers, vergelijkers en multiplexers..47

comparator zie vergelijker. 86

complement voorstellingen Een reeks voorstellin-gen voor negatieve getallen. Bij elk van dezecomplement voorstellingen neemt men de bit-gewijze negatie van het getal, eventueel wordter nog een 1 opgeteld om te vermijden dat ertwee voorstellingen voor het getal 0 bestaan.Er zijn twee soort complement voorstelling: 1-complement en 2-complement.. 68

Complex Programmable Logic Device (CPLD)Een programmeerbare chip die bestaat uit eenaantal programmable logic devices (PLDs) sa-men met een manier om glue logic uit te druk-ken, dit aan de hand van een schakelmatrix enin- en uitvoer modules.. 35

Computer Aided Design (CAD) Een techniek waar-bij men een product ontwerpt en sommige ta-ken automatiseert met behulp van een compu-

340 Woordenlijst

ter. Bijvoorbeeld het simuleren of (gedeeltelijk)synthetiseren van een logische schakeling.. 16

Concurrency zie Gelijktijdigheid. 22

Configurable Logic Blocks (CLB) Een uitbreidingop het Logical Block (LB) die men in field pro-grammable gate arrays (FPGAs) aantreft. EenCLB bestaat uit vier slices, twee van deze sli-ces kunnen worden geconfigureerd als schuifre-gisters, geheugencellen of logische blokken. Deoverige slices ondersteunen enkel logische blok-ken.. 36

cover zie dekking. 52

Custom Design zie maatwerk. 33

D

Daaltijd tf De tijd die een geleider nodig heeft omvan een hoge spanning naar een lage spanning tedalen. Omdat de spanning van de bron of grondvaak niet bereikt wordtn, neemt men vaak waar-den van respectievelijk 90% en 10% tussen debasisspanning en de topspanning.. 41, 342

dambordpatroon Een veel voorkomend patroon waar-bij wisselend in een ene rij men 0 en 1 tegen-komt, na enkele rijen wisselt het patroon naar 1en 0. Wanneer het dambordpatroon voorkomtop een Karnaugh-kaart kan dit vaak effectiefworden gerealiseerd met behulp van XOR poor-ten. De grootte van de vlakken bepaalt welkeingangen aan deze XOR poorten moeten wor-den gezet.. 55

data-ingang d Een ingang bij een component diegegevens (een bit dus) bevat die verwerkt moetworden. Deze ingang komt bijvoorbeeld voorbij geheugens zoals een flipflop, maar ook bijbijvoorbeeld een demultiplexer. De gegevensworden vaak ofwel opeslagen, ofwel - zonderveel aanpassingen - doorgestuurd naar een an-dere uitgang.. 84

data-ingangen di Een reeks ingangen bij een multi-plexer. Afhankelijk van de waarde op de selectie-ingangen wordt de waarde van een van de data-ingangen doorgegeven naar de uitgang van demultiplexer.. 82

Datatypes Een verzameling van soorten van signa-len: bijvoorbeeld vectoren, getallen met gepara-metriseerde grootte,... Deze datatypes wordenonder meer ondersteund in VHDL.. 22

decimale stelsel Een Arabisch getalstelsel met ra-dix r = 10.. 59

decoder Een component met een enable-ingang ena-ble ingang e, n adres-ingangen ai en 2n selectie-uitgangen si. Wanneer op de enable-ingang een0 staat, staan op alle selectie-uitgangen een 0.Wanneer er 1 op de enable-ingang wordt gezet,en de binaire waarde van de adres-ingangen isA, dat staat er 1 op selectie-uitgang sA; op deoverige selectie-uitgangen staat een 0.. 82

decrement Het aftellen van een getal met 1.. 72

dekking Een verzameling van implicanten voor eengegeven functie (en bijbehorende Karnaugh-kaart)zodat voor elke cel waar de functie 1 is, deze celminstens wordt omvat door een implicant in deverzameling. Bovendien is er geen enkele celwaar de functie 0 is die omvat wordt door eenimplicant in de verzameling.. 52, 340

deling Een rekenkundige bewerking op twee getallenwaarbij men zoekt hoeveel maal het eerste getalin het tweede getal past.. 76

demultiplexer Een component met een data-ingangd, n selectie-ingangen ai en en 2n data-uitgangensi. Afhankelijk van de binaire waarde A die opde selectie-ingangen ai staat, wordt het signaaldat op de data-ingang d staat doorgegeven aande data-uitgang sA. Op de overige uitgangenwordt een 0 gezet. Een demultiplexer is functi-oneel equivalent aan een decoder.. 84, 340

demux zie demultiplexer. 84

diminished-radix complement zie cijfer-complement.68

documentatie Documentatie beschrijft het gebouwdeproduct. Dit is bijvoorbeeld een handleidinghoe het product kan aanestuurd worden, of eendocument met ontwerpdetails indien we het pro-duct als component aan een ander bedrijf ver-kopen. Documentatie wordt soms ook internbijgehouden in een bedrijf.. 16

doelradix Bij omzetting van een getal tussen tweeArabische getalstelsels de radix van het getal-stelsel naar waar we de omzetting willen doen..60

don’t care Don’t care is een derde waarde in eenwaarheidstabel, die zoveel betekent als: ”hetmaakt niet uit of hier een 0 of 1 staat.”. Wan-neer de don’t care bij de ingangen staat, bete-kent dit dat het rechter lid van deze rij geldt

Woordenlijst 341

voor zowel 0 als 1. Wanneer de don’t care aande rechterkant van de waarheidstabel staat (bijde uitgangen) betekent dit dat we vrij mogenkiezen of we een 0 of een 1 gebruiken. De Don’tcare is nuttig bij het optimaliseren van logischeschakelingen.. 11, 55

doorvoer Een metriek van de snelheid van een lo-gische schakeling: het aantal resultaten per se-conde.. 16, 349

doperen Het introduceren van alternatieve atomenin een substraat. In de context van een transis-tor worden substraten van siliciumdioxide ne-gatief of positief edopeerd.. 26

Drain Een connectie van een FET transistor.. 24,25, 341

drijvendekommagetal zie vlottende komma voor-stelling. 77

driver zie buffer. 30

dualiteit Een eigenschap van de Booleaanse alge-bra dat elke wet in de booleaanse algebra, doorAND met OR te verwisselen en 0 met 1, eenandere geldige wet uitkomt.. 10

dubbele precisie Een voorstelling voor vlottende kom-magetallen met 64-bit beschreven in IEEE 754met 11 bit voor de exponent en 52 bit voor demantisse. Enkele precisie wordt ook double ge-noemd.. 78, 337

dynamisch gedrag Het gedrag die eigen is aan defysieke realisatie van een chip. Omdat geleiderskunnen gemodelleerd worden als RC ketenen,betekent dit dat zelfs bij een directe omschake-ling van de poort, het signaal traag en geleide-lijk door de geleider zal propageren.. 39

Dynamisch vermogenverbruik Het vermogen dieeen chip verbruikt als gevolg van het veranderenvan de waarde aan de ingang(en) of het klok-signaal. Dit vermogen dient bijvoorbeeld om depoorten om te schakelen. Bij alle technologieen(NMOS, CMOS,...) is er sprake van dynamischvermogenverbruik.. 42

E

Emitter zie Drain. 25

Enable E Een ingang die bij veel componenten zo-als tellers wordt gebruikt. De enable ingang

beslist of het component in kwestie op dat mo-ment een taak uitvoert (bijvoorbeeld de tellerophogen bij het volgende kloksignaal). De ena-ble ingang wordt ook gebruikt bij een tri-statebuffer om te bepalen of de waarde aan de in-gang wordt doorgegeven aan de uitgang; of datde uitgang in zwevende modus hoort te verke-ren.. 43

enable-ingang e Een ingang bij verschillende com-ponenten. Wanneer men 0 op de enable-ingangzet, zal de component meestal geen logica uit-voeren, en bijvoorbeeld een 0 op alle uitgangenzetten. Indien er 1 op de anble-ingang staat, zalhet component meestal een logische functie uit-rekenen. Componenten met een enable-ingangzijn bijvoorbeeld het tri-state buffer, de deco-der, registerbanken, RAM-geheugens en tellers.Sommige componenten die verschillende takenkunnen uitvoeren hebben verschillende enable-ingangen. De specifieke naam van de ingangverduidelijkt dan welke functie welke ingang heeft..82

encoder Een component met 2n data-ingangen, eenany-uitgang a en n selectie-uitgangen fi. In-dien er op een van de data-ingangen een 1 staat,staat er ook een 1 op de any-uitgan en viceversa. Wanneer juist een data-ingang di een1 aanlegt, geven de selectie-uitgangen binair dewaarde van deze index weer. Indien meer data-ingangen op 1 staan, is het gedrag onbepaald..85

enkele precisie Een voorstelling voor vlottende kom-magetallen met 32-bit beschreven in IEEE 754met 8 bit voor de exponent en 23 bit voor demantisse. Enkele precisie wordt ook single offloat genoemd.. 78, 337

Espresso heuristic logic minimizer Een algoritmedie voor een gegeven logische functie - bijvoor-beeld aan de hand van een waarheidstabel - eenimplementatie zoekt die vrij efficient is. Eenheuristiek garandeert niet dat de oplossing op-timaal is, maar vaak wel dicht genoeg bij hetoptimum voor praktische doeleinden.. 57

essentiele priemimplicant Een priemimplicant dievoor een cel in de Karnaugh-kaart 1 bevat, enwaar er geen enkele andere priemimplicant voordeze cel 1 geeft.. 52

excess formaat Een manier om negatieve getallenvoor te stellen. Men beschouwd een parameter:de excess-bias B, men encodeert het getal als

342 Woordenlijst

een natuurlijk getal, maar virtueel trekt mentelkens de excess-bias van het getal af. Indiende excess-bias bijvoorbeeld 12 is, dan betekent00002 dus 12, wanneer het getal 01002 mapt danop −8 en 11102 op 2. Men dient in dat gevaloptellers aan te passen zodat men de excess-bias ook optelt: wanneer we 01002 optellen met11102 dienen we dus 01102 uit te komen.. 68

excess-bias B Een parameter bij het excess formaat.Men dient het getal te interpreteren als een po-sitief getal, maar men trekt er vervolgens deexcess-bias virtueel vanaf.. 68

exponent E Een reeks bits bij de vlottende kommavoorstelling. De exponent E geeft aan dat wehet getal van de mantisse M (vereikt met design-bit s) moeten vermenigvuldigen met rE

met r de radix van het getalstelsel.. 77

F

Factoranalyse Het algebraısche manipuleren van een(booleaanse) expressie met bijvoorbeeld de wet-ten van De Morgan. We gaan op zoek naar va-riabelen die verschillende keren voorkomen inde expressie en proberen deze af te zonderen.Factoranalyse wordt soms gebruikt in een zoek-tocht naar een goedkope implementatie van eenbooleaanse functie. Vaak bekoment men imple-mentaties met een beperkte fan-in.. 57

fall time zie Daaltijd tf . 41

fan-in Het aantal ingangen van een bepaalde poortin een digitale schakeling.. 43

fan-out Het aantal ingangen van poorten die de uit-gang van een bepaalde poort aanstuurt... 43

Field Programmable Gate Array (FPGA) Eenprogrammeerbare chip die bestaat uit program-meerbare logische blokken, schakelmatrices; eninvoer- en uitvoer modules.. 36

fixed point zie Vaste komma voorstelling. 77

Flash-programmeerbaar Een techniek voor pro-grammeerbare chips. Er worden hierbij ladin-gen aangebracht als een geheugen. Deze ladin-gen bepalen een stuursignaal voor transistoren.De toestand van deze transistoren - open of ge-sloten - bepaalt dan verder het gedrag van dechip.. 34

floating-point number zie vlottende komma voor-stelling. 77

fractionele gedeelte Een deel van een getal bij vastekomma voorstell. Het fractioneel deel is de reekscijfers die na de komma staat. Het aantal cijfersstaat vooraf vast.. 77

full adder (FA) Een component die voor drie gege-ven bits xi, yi en ci - twee echte bits en meestalde overdracht van de vorige opteller - de bitsi = xi ⊕ yi ⊕ ci uitrekent die onder de sommoet komen te staan, samen met de overdrachtvoor de volgende bit ci+1. Een full adder wordtgebruikt bij het optellen en aftrekken van tweegetallen.. 63

Functionele ontbinding Het zoeken van deelfunc-ties in een functie en deze er vervolgens uit weg-substitueren. Gegeven een functie ~f (~x) zoeken

we dus naar een equivalente functie ~h (~g (~x) , ~x).Functionele ontbinding wordt vaak toegepast inde zoektocht naar een goedkope en efficiente im-plementatie: men zoekt structuren die verschil-lende keren terugkomen in de originele functieen deze dienen we dan slechts eenmaal te bere-kenen.. 57

G

Gate Een van de aansluitingen van een transistor.De gate regelt of er een verbinding tussen desource en de drain tot stand komt.. 25, 338

Gate Array Een techniek om specifieke cellen te re-aliseren. Men beschouwt een tweedimensionaalrooster met identieke poorten, elke poort heeftbijgevolg ook identieke afmetingen. Er wordtruimte tussen de poorten gelaten voor de bedra-ding. De bedrading - uniek voor elke applicatie- wordt dan handmatig gelegd.. 33

geınverteerde ingangen Een conventie die wordtgebruikt om het aantal getekende NOT poortenin een schema drastisch te verminderen. Menzet hierbij cirkels bij de ingangen van een poort.Deze cirkels duiden dan op een invertering (endus eventueel een NOT poort) voor deze in-gang.. 8

geheel deel Een deel van een getal bij vaste kommavoorstelling. Het geheel deel is de reeks cijfersdie voor de komma staan. Het aantal cijfersstaat vooraf vast.. 77

Geheugen-programmeerbaar Een techniek voorprogrammeerbare chips. Hierbij bevat de chip

Woordenlijst 343

een geheugen, bijvoorbeeld SRAM. Het stuur-signaal van sommige transistoren wordt dan ge-koppeld aan de toestand van eeen bepaalde bitin dat geheugen. Men kan dit geheugen bijnaeindeloos herprogrammeren, en soms zelfs dy-namisch aanpasssen. Men dient wel voortdu-rend spanning op dit geheugen aan te leggen..34

Gelijktijdigheid Het feit dat alle hardwarecompo-nenten parallel werken: wanneer de ingang ver-andert, zullen alle poorten die door deze in-gang worden aangestuurd, tegelijk de verande-ring doorrekenen. Gelijktijdigheid is een eigen-schap in VHDL die niet overeen komt met klas-sieke programmeertalen.. 22, 340

Genormaliseerde vlottende komma voorstellingEen familie van vlottende komma voorstellin-gen. Bij deze familie geldt een extra beperkingdat de waarde van de mantisse M ligt tussen1 ≤M < r met radix r. Bij het binaire systeemimpliceert dit dat de eerste bit van de mantissedus altijd op 1 zo staan. Daarom wordt dezebit weggelaten, maar bestaat ze wel nog virtu-eel. Deze bit wordt dan vervangen door eenextra bit in het fractionele gedeelte.. 78

gesloten Een toestand bij een schakelaar waarbij erstroom vloeit door de schakelaar.. 25

glitch Een fenomeen waar bij de verandering van eenof meerdere ingangen van een logische circuitdoor het verschil in tijdsgedrag van de poorten,er tijdelijk een foute waarde op een van de uit-gangen (of tussensignalen) komt te staan.. 9

Glue Logic Een schakeling die nodig is om twee chipsmet elkaar te kunnen laten samenwerken en/ofcommuniceren.. 32

greedy algorithm zie gulzige strategie. 54

gulzige strategie Een methode om een probleemop te lossen door het op te delen in verschil-lende beslissingen. Bij elke beslissing kiezen wede optie die ons onmiddellijk het meeste ople-vert. Het is echter niet gezegd dat dit tot deuiteindelijke beste oplossing zal leiden, omdateen eerste beslissing er voor kan zorgen dat eentweede beslissing tot minder winst kan worden..54, 343

H

half adder (HA) Een component die voor twee ge-geven bits x en y het binaire cijfer van de soms = x⊕ y uitrekent, en de overdracht c = x · y.Een half-adder wordt soms gebruikt om de laat-ste bit bij een optelling van twee getallen te be-rekenen. De rest van de bits worden met eenfull adder berekend.. 62

hexadecimaal stelsel Een Aratisch getalstelsel metradix r = 16.. 59

High De fysische waarde die we associeren met een1 of 0 (bij negatieve logica); bij een implemen-tatie met elektronica is dat meestal een hogespanning.. 24

hoog impedant zie zwevende modus Z. 43

hysteresis Een hysteresis is een mogelijke eigenschapvan een transferfunctie. Het gedrag van de transfer-functie hangt dan af of de spanning van hoognaar laag gaat; of van laag naar hoog. Men ge-bruikt een hysteresis soms om te voorkomen datbij een chaotische ingang, de uitgang eenveel (ofzelfs versterkte) chaos toont.. 39

I

implicant Een implicant is een productterm, zodater minstens een cel op de Karnaugh-kaart is diezelf 1 is en waarvoor de functie - beschrevendoor deze productterm - ook 1 is. De functie-waarde voor cellen die 0 zijn op de Karnaugh-kaart horen ook 0 te zijn. De cellen op deKarnaugh-kaart die 1 zijn, hoeven niet - op eencel na - een functie-waarde 1 te hebben.. 52

in- en uitvoer modules Een module die erop ge-richt is een circuit te laten communiceren metzijn omgeving. Dit zijn bijvoorbeeld modulesdie signalen in een geheugen klokken, maar somsook Ethernet of USB interfaces.. 35

increment Het ophogen van een getal met 1.. 72

Ingangsimpedantie RI De ingangsimpedantie is devirtuele weerstand die bij een poort tussen eeningang van die poort en de grond staat. Er iseen zeker streven naar een hoge ingangsimpe-dantie omdat dit ervoor zorgt dat een geleidervaak zal opgeladen worden tot aan de spanningdie op de drain staat, bovendien perkt dit hetstatisch vermogensverbruik van de poort in.. 40

instructieset Een verzameling instructies die een arith-metic logic unit (ALU) of processor moet kun-nen uitvoeren. Een instructieset dient voor elke

344 Woordenlijst

instructie, de semantische betekenis van de in-structie te beschrijven. Men dient ook deze in-structies te encoderen op een instructiewoord:een sequentie bits waarmee we aan de processorof ALU duidelijk maken welke instructie op datmoment moet worden uitgevoerd.. 73

instructiewoord Een reeks bits die bepalen welkeinstructie een processor of een arithmetic logicunit (ALU) uit moet voeren.. 73

interface Een interface is een deel van een systeemdat communiceert met de buitenwereld. Bij-voorbeeld een USB poort van een computer, ofeen API van een computerprogramma.. 14

inverterende poorten Poorten waar conceptueel ophet einde een inverter staat. Inverterende poor-ten zijn INV, NAND, NOR, AOI en OAI.. 49

K

K-kaarten zie Karnaugh-kaarten. 50

Karnaugh-kaarten De projectie van een N -kubusin twee dimensies. Karnaugh-kaarten vormeneen visueel hulpmiddel bij de synthese van eencombinatorische schakeling voor een gegeven boole-aanse functie met twee lagen.. 50, 344

klokfrequentie f De frequentie waarmee de klok -een component die de schakeling aan de handvan het verlopen van de tijd aanstuurt - werkt.Het dynamisch vermogenverbruik schaalt line-air met de klokfrequentie.. 42

kopies Een manier om Karnaugh-kaarten voor testellen indien het aantal dimensies stijgt bo-ven de vier. In dat geval worden er twee 4 × 4rasters beschouwd. Beide rasters gebruiken de-zelfde positionering van de variabelen.. 51

kostprijs De kostprijs van een schakeling is een (ruwe)schatting van het aantal transistoren (of logi-sche blokken in het geval van een FPGA) diemen nodig heeft om deze schakeling te realise-ren. Meestal schaalt deze kostprijs ook met definanciele kostprijs om de schakeling fysiek terealiseren.. 8

kritische pad Een pad van ingang tot uitgang ineen schakeling die de grootste vertraging heeft.Het is mogelijk dat een schakeling verschillendekritische paden heeft, al deze paden hebben dandezelfde (theoretische) vertraging.. 49

L

lange lijnen Verbindingen die over een groot deelvan het chipoppervlak lopen. Lange lijnen zijnvaak ongewenst in chipdesign omdat ze de pro-pagatie van het signaal afremmen, en hierdoorde maximale klokfrequentie verminderen.. 36

lekstroom Stroom die wegvloeit in een schakeling,bijvoorbeeld omdat een transistor gesloten is bijeen poort geımplementeerd met NMOS techno-logie.. 42

Logical Blocks (LB) Een deelcomponent van eenfield programmable gate array (FPGA). Een lo-gische blok bestaat typisch uit 4 ingangen enbevat dan een 16-bit look-up table (LUT) eneen geheugencomponent om het resultaat vande vorige klokcyclus ook te kunnen aanleggen..36

Logisch schuiven Een variant van schuiven. Bij lo-gisch schuiven worden de vrijgekomen plaatsenopgevuld door een constante, meestal 0. Somswordt zelfs in detail bepaald welke waarde menop welke vrijgekomen bit zet.. 89

logische schakelingen Een netwerk van logische poor-ten.. 8

Look-Up Table (LUT) Een programmeerbaar ge-heugen met n ingangen. Wanneer er op de in-gangen binair k staat, wordt de k-de cel op deuitgang aangelegd.. 36

Low De fysische waarde die we associeren met een0 of een 1 (bij negatieve logica); bij een imple-mentatie met elektronica is dat meestal een lagespanning.. 24

M

maatwerk Een technologie om specifieke chips teontwerpen. Bij maatwerk ontwerpen we tot ophet transistorniveau. We stellen transistorendan voor als rechthoeken die we op het chipop-pervlak plaatsen. Met deze techniek kunnen wetot het beste ontwerp komen, zowel qua snel-heid, vermogenverbruik en afmetingen. Dezetechniek is niet haalbaar voor complexe scha-kelingen.. 33, 340

mantisse M Een reeks bits bij de vlottende kommavoorstelling. De mantisse zelf wordt voorge-steld als een vlottend komma getal. Dit getalwordt vermenigvuldigt met het teken dat wordtbepaald door de sign-bit en de exponent.. 77

Woordenlijst 345

maximale frequentie fmax De maximale snelheidwaarop een elektronische schakeling een cycluskan uitvoeren: van het veranderen van een ofmeer ingang(en) of het kloksignaal, tot het aan-passen van geheugens en het aanleggen van an-dere waardes op de uitgangen. De maximalefrequentie wordt bepaalt door het logische cir-cuit zelf, maar ook de organisatie van de chipen bijvoorbeeld de fan-out van de poorten.. 43

maximale stroomsterkte IOmax De maximale hoe-veelheid stroom die door een uitgang van eenpoort kan stromen per tijdseenheid. Deze stroom-sterkte hangt grotendeels af van de parasitairecapaciteit. De maximale stroomsterkte heefttot gevolg dat een poort maar met een beperktefan-out kan werken.. 43

maxtermen Een maxterm is een logische functie diewaar is voor alle configuraties behalve een con-figuratie. Het is een booleaanse som van alle in-gangen (waarbij een deel van de ingangen even-tueel geınverteerd zijn). Indien de maxtermbijvoorbeeld enkel onwaar hoort te zijn voor〈x, y, z, t〉 = 〈1, 0, 1, 1〉, is de maxterm x′ + y +z′ + t′.. 11

mintermen Een minterm is een logische functie dieslechts waar is voor juist een configuratie vaningangen. Het is een booleaanse product vanalle ingangen (waarbij een deel van de ingangeneventueel ggeınverteerd zijn). Indien de min-term bijvoorbeeld enkel waar hoort te zijn voor〈x, y, z, t〉 = 〈1, 0, 1, 1〉, is de minterm x ·y′ ·z ·t..11

modulo Een rekekundige bewerking op twee getal-len. Modulo berekent de rest. Indien de restnegatief is, is het resultaat een getal tussen 0en abs b− 1 (inclusief) die equivalent is met derest.. 76, 337

multiplexer Een component dat bestaat uit n selectie-ingangen si, 2n data-ingangen di en een uitgangf . Wanneer de binaire waarde van het getal Sop de selectie-ingangen wordt aangelegd, wordtde waarde van data-ingang DS op de uitganggezet.. 82, 345, 348

MUX zie multiplexer. 82

N

NAND Een basisschakeling met 2 ingangen. Deconfiguratie 〈1, 1〉 wordt afgebeeld op 0; de ove-rige configuraties worden afgebeeld op 1.. 7

Negatief oneindig −∞ Een element bij de vlottendekomma voorstelling van IEEE 754. Negatief on-eindig wordt voorgesteld met de tekenbit op 1,0 voor de mantisse, en het hoogst mogelijk voorte stellen getal van de exponent. Berwerkingendie tot overflow leiden in het negatieve, gevennegatief oneindig.. 79

negatieve logica Een vorm van implementeren vanlogica waarbij we een hoge spanning associerenmet een 0 en een lage spanning met een 1.. 25

Niet-genormaliseerde vlottende komma voorstellingEen familie van vlottende komma voorstellin-gen. Hierbij wordt de waarde van de mantisseM niet begrensd. De niet-genormaliseerde vlot-tende komma voorstelling kan meer getallen voor-stellen, maar veel getallen kunnen ook op ver-schillende manieren worden voorgesteld. Dit le-vert complexere logica op bij bijvoorbeeld hetimplementeren van een vergelijker.. 78

niet-inverterende poorten Poorten waar concep-tueel op het einde geen inverter staat. Niet-inverterende poorten zijn AND en OR.. 49

NMOS Een variant van een automatische schake-laar waarbij de schakelaar gesloten is indien hetstuursignaal hoog is; en open indien het stuur-signaal laag is.. 25

NOR Een basisschakeling met 2 ingangen. De con-figuratie 〈0, 0〉 wordt afgebeeld op 1; de overigeconfiguraties op 0. 7

NOT Een populaire bassischakeling die 0 afbeelt op1; en 1 op 0.. 4

Not a Number (NaN) Een speciaal getal bij ge-tallen met vlottende komma volgens IEEE 754.NaN stelt het resultaat voor van een bewerkingdie wiskundig niet correct is. Bijvoorbeeld hetdelen door nul, het verschil tussen twee onein-dige getallen, de vierkantswortel van een nega-tief getal, enzovoort.. 79

Nul (0) Het kleinste natuurlijke getal. Dit getal isniet voor te stellen bij een genormaliseerde vlot-tende komma voorstelling. Men introduceerdehiervoor een regel dat indien zowel de exponentals de mantisse nul zijn, het getal ook nul is..79

O

octaal stelsel Een Arabisch getalstelsel met radixr = 8.. 59

346 Woordenlijst

open Een toestand bij een schakelaar waarbij er geenstroom door de schakelaar vloeit.. 25

Open-Drain Poort Een poort die bestaat uit meer-dere parallel geschakelde NMOS transistoren.Vanaf het moment dat een van de NMOS tran-sistoren gesloten wordt, vloeit er stroom van debron naar de grond. Enkel wanneer alle schake-laars open zijn, wordt er dus een hoge spanningop de uitgang aangelegd.. 27

OR Een populaire basisschakeling met twee ingan-gen. 〈0, 0〉 wordt afgebeeld op 0; en 〈0, 1〉, 〈1, 0〉en 〈1, 1〉 worden afgebeeld op 1.. 4

OR-AND-Invert (OAI) Een schakeling gemaaktuit transistoren die een tweelaggie structuur om-vat met het eerste een reeks OR-poorten, deuitgan van dezeOR poorten passeren vervolensdoor een NAND poort. Men kan deze schakelinechter zeer goedkoop realiseren.. 29

OR-matrix Een raster dat gebruikt wordt voor pro-grammeerbare chips. Men beschouwt n ingan-gen en m n-OR-poorten, voor elke ingang enelke AND poort is er een zekering waardoormen kan beslissen welke ingangen er aan welkeOR-poort worden gehangen. Een OR-matrixwordt ondermeer gebruikt bij een programma-ble logic array (PLA).. 34

overdracht Een restproduct dat ontstaat wanneerwe twee cijfers x en y optellen, en de het resul-taat is groter dan de radix r. In dat geval is deoverdracht b(x+ y) /rc. De overdracht wordtgebruikt als toevoeging bij de optelling van hetvolgend cijfer.. 62, 339

overflow Een signaal dat na een bewerking - bijvoor-beeld een optelling - het resultaat niet meer vol-ledig voor te stellen valt op de gegeven bits. Ditis bijvoorbeeld het geval bij een 8-bit opteller,waarbij het resultaat groter is dan 255.. 63

P

parallelle vermenigvuldiger Een component die voortwee getallen het product berekent. Dit doethet op een manier die vergelijkbaar is met cij-feren. Voor elke bit van het tweede getal wordteen opteller voorzien. Indien de overeenkom-stige bit 1 is, wordt het eerste getal opgeteld,voldoende opgeschoven naar links. Een paral-lelle vermenigvuldiger kost veel hardware en isbovendien meestal niet sneller dan andere vor-men van vermenigvuldigers.. 74

placement Een deelproces bij het bouwen van spe-cifieke chips aan de hand van standaardcellen.Bij placement probeert men de componenten zote plaatsen dat het ontwerp optimaal is.. 33

PLD talen Een verzameling talen die een schake-ling beschrijven op het niveau van poorten vooreen specifieke technologie. PLD talen beschrij-ven dus details over de implementatie, dit integenstelling tot bijvoorbeeld VHDL die eerderhet gedrag beschrijft. Voorbeelden van PLDtalen zijn Abel en Palasm.. 18

PMOS Een variant van een automatische schake-laar waarbij de schakelaar gesloten is indien hetstuursignaal laag is; en open indien het stuur-signaal hoog is.. 25

Positief oneindig +∞ Een element bij de vlottendekomma voorstelling van IEEE 754. Positief on-eindig wordt voorgesteld met de tekenbit op 0,0 voor de mantisse, en het hoogst mogelijk voorte stellen getal van de exponent. Berwerkingendie tot overflow leiden in het positieve, gevenpositief oneindig.. 79

positieve logica Een vorm van implementeren vanlogica waarbij we een hoge spanning associerenmet een 1 en een lage spanning met een 0.. 25

priemimplicant Een implicant die geen onderdeelis van een andere implicant met strikt mindervariabelen.. 52

prioriteitsencoder Een variant van een encoder. Eencomponent met 2n data-ingangen di, een any-uitgang a en n selectie-uitgangen fi. Indiener op minstens een van de data-ingangen een1 staat, staat er ook een 1 op de any-uitganen vice versa. Wanneer er op een of meerderedata-ingang di een 1 staat, geven de selectie-uitgangen binair de waarde van deze index vande hoogste data-ingang met 1 weer.. 85

Product-of-Sums (POS) Een machinale manier omuit een waarheidstabel een logische functie tegenereren die gebruik maakt van 0-maxtermen.Men berekent eerst de 0-maxtermen van de waar-heidstabel, en neemt vervolgens het booleaanseproduct van deze 0-maxtermen.. 11

Programmable Array Logic (PAL) Een variantop een programmable logic array (PLA). Hier-bij staat de OR-matrix echter vast (deze kanniet geprogrammeerd worden door zekeringendoor te branden).. 34

Woordenlijst 347

Programmable Logic Array (PLA) Een program-meerbare chip die werkt op basis van zekerin-gen. Deze chip bevat twee rasters van poorten:een AND- en OR-matrix. Voor elk van itemin het raster is er een zekering die doorgebrandkan worden.. 34

Programmable Logic Device (PLD) Een program-meerbare chip waarbij men een programmablearray logic (PAL) gebruikt, maar aangevuld metflipflops bij de uitgangen en een gedeeltelijk feedback-mechanisme: een deel van de uitvoer, wordt te-rug als invoer hergebruikt.. 34

Programmable Read Only Memory (PROM)Een variant op een programmable logic array(PLA). Hierbij staat de AND-matrix vast (dezekan dus niet geprogrammeerd worden). De AND-matrix is gestructureerd als een adresdecoder:wanneer de invoer binair het getal n voorstelt,is de n-de uitgang actief.. 34

Programmeerbare Chips Een technologie waarbijmet een chip realiseert door naar het geheu-gen van een programmeerbare chip te schrijven.Het gedrag van de chip hangt dan ondermeeraf dat geheugen. Vaak deelt men een dergelijkechip op in logische blokken met elk een kleinehoeveelheid geheugen. Sommige programmeer-bare chips bevatten 2 miljoen logische cellen..32

programmeerbare chips Chips met een vorm vangeheugen. Het gedrag van deze chips hangt danaf van de waarden in dat geheugen. Dit geheu-gen hoeft geen RAM, ROM, of flash geheugente zijn; het al dan niet doorbranden van eenzekering is ook een vorm van geheugen.. 34

propagation delay zie Vertragingstijd tp. 41

Pull-Down Network (PDN) Het principe dat weeen lage spanning aanleggen op een uitgang metbehulp van een transistor die zich sluit, waar-door de stroom een alternatieve route naar degrond kan vinden, en dus niet langer een poten-tiaal op de uitang zet.. 26

Pull-Up Network (PUN) Het principe dat we eenhoge spanning aanleggen op een uitgang metbehulp van een transistor die zich sluit. Hier-door wordt de uitgang verbonden met de hogespanning.. 28

Q

Quine-McCluskey algoritme Een algoritme die vooreen gegeven logische functie - bijvoorbeeld aande hand van een waarheidstabel - een minimaleimplementatie zoekt. Het algoritme is groten-deels equivalent aan minimalisatie met behulpvan Karnaugh-kaarten, maar werkt aan de handvan patronen, in plaats van visuele hulpmidde-len. Het algoritme is aanwezig in de meesteCAD-paketten.. 56

R

radix r Een eigenschap van een Arabisch getalsys-teem. De radix wijst op het gewicht die eencijfer in een getal heeft ten opzichte van hetvolgende cijfer. Het i-de cijfer van rechts - in-clusief 0 - heeft een waarde van ri.. 59

radix-complement Een complement voorstelling waar-bij men negatieve getallen voorstelt door ze voorte stellen als het getal D∗ = rm −D met D deabsolute waarde van het getal, r de radix vande getalvoorstelling, en m het aantal cijfers vanhet getal.. 68, 337

RC-keten Een schakeling in de analoge elektronicadie bestaat uit een condensator en een weer-stand. Wanneer men spanning op deze scha-keling aanbrengt, wordt de condensator opge-laden. Wanneer men later de spanningsbronontkoppelt en de kring sluit, zal de condensa-tor ook traag leeglopen. De snelheid waarmeedit zal gebeuren, hangt af van de weerstand Ren de capaciteit van de condensator C.. 39

Register-Transfer-Level (RTL) ComponentenEen laag van componenten voor synthese. Hier-onder vallen ondermeer optellers, tellers en schuif-regissters vallen.. 15

remainder Een rekenkundig bewerking op twee ge-tallen waarbij het resultaat de rest na delingvoorstelt. Voor de getallen a en b betekent ditdus a rem b ≡ a− ba/bc · b.. 76, 337

Ripple-carry opteller Een component die aan dehand van full adders en optioneel een half adder,twee getallen in binaire notatie optelt. Dit doenmen door de full adders aan elkaar te schakelenzodat elke adder twee bits van de getallen opdezelfde positie verwerkt, en de carry van bitsop positie i als carry ingang voor de volgendebit wordt gebruikt.. 63

rise time zie Stijgtijd tr. 40

348 Woordenlijst

roteren Een variant van een schuifoperatie waarbijde bits die buiten het bereik van het nieuwe ge-tal vallen, aan de andere kant op de vrijgekomenplaatsen worden gezet.. 89

routing Een deelproces bij het bouwen van speci-fieke chips aan de hand van standaardcellen.Bij routing legt men de bedrading tussen deverschillende componenten.. 33

S

schakelaars Een component waar - afhankelijk vaneen stuursignaal of toestand - er al dan nietstroom door vloeit.. 25

schakelmatrix Een schakelmatrix is een program-meerbare component waarin verbindingen sa-menkomen. Afhankelijk van de manier hoe mende matrix programmeert zijn sommige ingangenwel of niet met elkaar verbonden. Men gebruiktschakelmatrices vaak als een deel van program-meerbare chips zoals een complex programma-ble logic device (CPLD) of een field program-mable gate array (FPGA).. 35

Schmitt-trigger ingangen Een component die menbij de invoer van een chip plaatst. Schmitt-trigger ingangen hebben een hysteresis. Dezehysteresis probeert het probleem op te lossendat bij een chaotische overgang van 0 naar 1, erverschillende binaire waarden doorheen de chipzouden propageren.. 39

schuifoperaties Een reeks operaties waarbij men bitsopschuift in een getal naar links of naar rechts.Afhankelijk van het soort schuifoperaties zal menbepaalde bits op de vrijgekomen plaatsen in-vullen en bepaalde bewerkingen uitvoeren opde bits die uit de getalvoorstelling vallen. On-der schuifoperaties rekenen we logisch schuiven,aritmetisch schuiven en roteren. Deze operatieskomen telkens voor in twee richtingen: links enrechts. Bij een schuifoperatie van m bits naarlinks zullen de waardes van de bits xi wordenverplaatst naar yi+m = xi, maar enkel indienzowel i als i+m binnen het bereik liggen. Water met de overige bits en de vrijgekomen plaat-sen zal gebeuren, hangt af van de variant vande schuifoperatie.. 88

schuiven Een variant van een schuifoperatie waarbijde bits van het originele getal die na schuivenniet langger in het bereik van het resultaat lig-gen, genegeerd worden. Er is dus verlies aan

data. Wat er met de vrijgekomen plaatsen ge-beurt is niet gespecificeerd, dit hangt af van deconcrete variant. Er zijn twee soort schuiven:logisch schuiven en aritmetisch schuiven.. 89

Sea of Gates Een tweedimensionaal rooster met iden-tieke poorten en ruimte tussen de poorten. Desea of gates wordt gebuikt bij het realiseren vanschakelinen met de gate array techniek.. 33

selectie-ingangen si Ingangen bij een multiplexerde waarde die op de selectie-ingangen wordengezet bepalen welke data-ingang van de multi-plexer wordt doorgegeven op de uitgang.. 82

selectie-uitgangen si Een reeks uitgangen bij bij-voorbeeld een decoder. Wanneer bij een deco-der de adres-ingangen ai het binaire getal Avormen, en op de enable-ingang e staat 1, zalop de selectie-uitgang sA ook een 1 staan; enop de overige selectie-uitgangen 0. Wanneer erop de enable-ingang een 0 staat, staan op alleselectie-uitgangen nullen.. 82, 85

selector zie multiplexer. 82

sequentiele schakeling Een schakeling waarbij dewaardes die op de uitgangen worden gezet, nietenkel afhangen van de waardes die aan de in-gang staan, maar ook aan een interne toestandvan de schakeling. Deze toestand wordt bijge-houden door een geheugencomponent. De toe-stand van een sequentiele schakeling kan ver-anderen door veranderingen aan de invoer, ofdoor een klokflank.. 94

seven-segment display Een component die zevenleds plaatst in de vorm van een acht. Men kanaan de hand van een seven-segment display elkcijfer van 0 tot 9 weergeven.. 56

sign-bit s Een bit bij de vlottende komma voorstel-ling. De tekenbit geeft - zoals bij een sign-magnitude voorstelling - aan of we de rest vanhet getal als positief (0) of negatief (1) moeteninterpreteren.. 77, 349

sign-magnitude Een manier om negatieve getallenvoor te stellen. Men plaatst hierbij een bit voorhet getal - de tekenbit - en indien deze 1 is, die-nen we het getal als zijn negatie te interprete-ren. Wanneer de bit 0 is, is het getal positief..68

slices De delen van een configurable logic block (CLB)..36

Woordenlijst 349

Source Een connectie van een FET transistor.. 24,25, 339

Spartan-3 Een populaire field programmable gatearray (FPGA) chip.. 36

Specificatie Een document die de functionaliteitenbeschrijft van hardware.. 14

Specifieke Chips (ASIC) Een technologie waarbijchips die volledig zelf fysiek gerealiseerd wor-den. Men maakt een masker aan en belazerdevervolgens de chip zodat er poorten ontstaan.Deze techniek is erg duur en wordt enkel toege-past bij chips met grote oplage.. 32

spiegelt Een manier om Karnaugh-kaarten voor testellen indien het aantal dimensies stijgt bovende vier. In dat geval worden twee 4 × 4 ras-ters beschouwd. Het tweede raster spiegelt devariabelen over de as tussen de twee rasters.. 51

standaard cellen Een technologie om specifieke chipste ontwerpen. Bij standaardcellen maken we ge-bruik van componenten uit een bibliotheek dieallemaal eenzelfde hoogte, maar een variabelebreedte hebben. Bovenaan deze componentenbevinden zich de ingangen, onderaan de uitgan-gen. We leggen deze componenten in rijen (eenproces dat placement wordt genoemd), waarnamen de bedradingg tussen de componenten legt(dit noemt men routing).. 33

Standaard Chips Een technologgie bij het realise-ren van een elektronische schakeling. Hierbijkoopt men eenvodige chips (bijvoorbeeld poor-ten en optellers) die specifieke functies vervul-len. Men dient dan enkel nog deze chips metelkaar te verbinden.. 32

standaard vorm Een implementatie van een logi-sche functie aan de hand van Sum-of-Productsof Products-of-Sum, maar waarbij men aan dehand van de wetten van De Morgan het aantalpoorten reduceert. De standaard vorm is altijdgoedkoper dan de canonieke vorm.. 12

Statisch vermogenverbruik Het vermogen die eenchip continu verbruikt, en die niet afkomstig isvan bijvoorbeeld veranderingen aan de ingangof het kloksignaal. Bij NMOS is dit de lek-stroom bij gesloten transistoren. Bij CMOS ishet statisch vermogenverbruik praktisch onbe-staand.. 42

Stijgtijd tr De tijd die een geleider nodig heeft omvan een lage spanning naar een hoge spanning

te stijgen. Omdat de spanning van de bronof grond vaak niet bereikt worden, neemt menvaak waarden van respectievelijk 10% en 90%tussen de basisspanning en de topspanning.. 40,347

stuursignaal Een signaal bij een generische transis-tor. Het stuursignaal (vaak “basis” genoemd)beslist of er stroom tussen de collector en deemitor stroomt.. 25

Sum-of-Products (SOP) Een machinale methodeom uit een waarheidstabel een logische functiete genereren die gebruik maakt van 1-mintermen.Men berekent eerst de 1-mintermen van de waar-heidstabel, en neemt vervolgens de booleansesom van deze 1-mintermen.. 11

Synthese De vertaling van specificaties van een hoogen abstract niveau naar een lager niveau. Erzijn verschillende lagere niveaus. Het gekozenniveau hangt af van de beschikbare componen-ten in de bibliotheek. Zo is er het RTL niveau,het ASIC niveau, etc.. 15

systeemsynthese De hoogste laag van de synthesepyramide. Hier worden processoren, geheugensen ASIC componenten gecombineerd in een vol-ledig systeem.. 15

T

technology mapping Het realiseren van een gege-ven schakeling in een bepaalde technologie. Bij-voorbeeld met behulp van poorten, logische blok-ken,... Afhankelijk van de gekozen technolo-gie verschilt de kostprijs en ook de doelen bijeen implementatie. Bij een FPGA bijvoorbeeldstaat het aantal poorten in een logisch blokvast, en proberen we enkel de implementatiete optimaliseren tot deze in de beschikbare lo-gische blokken past.. 58

tekenbit s zie sign-bit s. 77

threshold spanning VT Het minimale verschil in span-ning die men tussen de gate en de source moetaanleggen bij een NMOS zodat er een verbin-ding tussen de source en de gate ontstaat.. 26

throughput zie doorvoer. 16

Tijdsconcept Een eigenschap van VHDL die nietvan toepassing is bij klassieke programmeerta-len. De eigenschap stelt dat alle hardware con-tinue werkt, en dat er ook een specifieke ver-traging in de tijd is bij het doorrekenen vanveranderende signalen.. 22

350 Woordenlijst

tijdsconstante τ Een parameter die beschrijft hoesnel een systeem zich aanpast aan een nieuwetoestand aan de invoer. Systemen zoals hetdynamische systeem van een geleider gedragenzich typisch exponentieel. In dat geval zal hetgedrag dus beschreven worden aan de hand vanV (t) = V∞ ·

(1− et/τ

)ofwel V (t) = V0 · e−t/τ ..

39

Transferfunctie Een transfer-functie van een logi-sche poort of circuit mapt de spanning aan deingang(en) op de spanning die op dat momentaan de uitgang(en). Deze functie hangt af vanondermeer het productieproces om de poort temaken, maar ook van omgevingsfactoren zoalswarmte. Idealiter beogen we discreet gedragaan de uitgang. In werkelijkheid is dit gedrageerder continu.. 38

transistoren Automatische schakelaars. Een tran-sistor heeft drie verbindingen, de collector ende emittter vormen een schakelaar, en de ba-sis stuurt deze schakelaar aan. Afhankelijk vande soort transistor gelden er andere regels overwanneer de schakelaar gesloten wordt, en vol-gens welk patroon.. 25

transmission gate Een component die functioneertals een schakelaar. De component heeft drieingangen: x, s en s. Indien s = 0 en s = 1, isde ingang x niet verbonden met de uitgang f ; inalle overige gevallen, is x verbonden met f . Eentransmission gate wordt ondermeer gebruikt omeen tri-state buffer te realiseren.. 44

Tri-state buffer Een uitbreiding op een buffer. Eentri-state buffer heeft een extra enable ingangE. Indien op deze ingang een 1 staat, wordtde waarde aan de ingang ook op de uitgang ge-zet. In het andere geval wordt er een zwevendetoestand Z op de uitgang gezet.. 43

trial-and-error Een strategie waarbij men een pro-bleem oplost door een reeks - al dan niet popu-laire - methodes op het probleem toepast en ver-volgens de resultaten van deze methodes verge-lijkt. Daarna kiest men de meest voordelige op-lossing. Ervaring laat toe om vaak niet alle me-thodes te moeten uitproberen, en dus op voor-hand te weten welke methodes zeker niet toteen betere oplossing zullen leiden.. 57

U

Uitgangsimpedantie RO De virtuele weerstand dietussen de bron of de grond enerzijds en de uit-gang van een poort staat. We streven ernaar deuitgangsimpedantie zo laag mogelijk te houden,zodat de tijdsconstante van de geleider naarandere ingangen lager is en de chip bijgevolgsneller zal schakelen. Een nadeel bij een lageingangsimpedantie is een hoger dynamisch ver-mogenverbruik.. 40

underflow Het fenomeen dat kleine getallen – in dezin van te dicht bij 0 – niet voor te stellen zijndoor alle getalvoorstellingen, dit is bijvoorbeeldeen belangrijk fenomeen bij vlottende komma-getallen.. 78

universiele poorten Een poort waarmee men elkefunctie kan bouwen. In de booleaanse logicakomt dit er op neer dat men een NOT en ANDmoet kunnen bouwen. Voorbeelden van uni-versiele poorten zijn de NAND en NOR.. 7

V

Vaste komma voorstelling Een voorstellingswijzevoor kommagetallen. De voorstelling van eengetal bestaat in dat geval uit twee delen: eengeheel deel een fractioneel deel. Tussen de tweedelen wordt een punt (.) gezet. Beide delenkrijgen een vast aantal cijfers, wat we noterenmet fix 〈i, f〉: i bits voor het geheel deel, f voorhet fractioneel deel. Omdat het aantal bits vaststaat kunnen getallen met vaste komma maareen beperkte hoeveelheid getallen voorstellen.Het voordeel is echter dat men optellers en an-dere componenten niet hoeft aan te passen.. 77,342

verborgen bits Bits die alleen virtueel bestaan, bij-voorbeeld bij de interpretatie van een getal. Inhet geval van IEEE 754 is de eerste bit in de“semantisch” interpretatie van de mantisse ver-boren: deze wordt niet expliciet voorgesteld..79

vergelijker Een component die als invoer twee ge-tallen krijgt en een reeks testen uitvoert. Welketesten men concreet bekijkt staat niet vast. Meestalzal men kijken of het ene getal groter is dan hettweede en/of omgekeerd.. 86, 339

Verilog Een concurrent van VHDL. Verilog is vooralpopulair in de Verenigde Staten en gestandaar-diseerd in IEEE 1364.. 18

Woordenlijst 351

vermogenverbruik De hoeveelheid energie per tijds-eenheid die een schakeling nodig heeft om tekunnen functioneren. Het vermogenverbruik wordtopgedeeld in statisch vermogenverbruik en dy-namisch vermogenverbruik.. 41

Vertragingstijd tp De tijd die een poort nodig heefttussen het moment waarop de spanning aan deingang de 50% tussen de de basisspanning entopspanning bereikt, en de tijd dat de spanningaan de uitvoer dat punt bereikt.. 41, 347

verwerkingskracht De verwerkingskracht van eenschakeling duidt op hoe snel een veranderin aande ingang van de schakeling kan worden doorge-rekend ofwel gepropageerd naar de uitgangen..8

VHDL Afkortin voor VHSIC Hardware DescriptionLanguage. Een programmeertaal die wordt ge-bruikt om het specificeren, ontwikkelen en ana-lyseren van hardware.. 17

VHDL Analog and Mixed Signals (VHDL-AMS)Een uitbreiding van VHDL die het mogelijk maaktniet alleen met digitale, maar ook met analogesignalen te rekenen. Het is dus een superset vanVHDL.. 17

vlottende komma voorstelling Een manier om eenkommagetal voor te stellen met een bereik tus-sen zeer kleine en zeer grote getallen. Men enco-deert het getal op een wetenschappelijke manierin bits met een tekenbit s, een mantisse M eneen exponent. Getallen met drijvende kommazijn gestandaardiseerd in IEEE-754.. 77, 341,342, 351

voedingsspanning V Het spanningsverschil van devoeding waarmee een chip haar werk uitvoert.Het dynamisch vermogenverbruik schaalt kwa-dratisch met de voedingsspanning.. 42

W

Wet van Moore Een geobserveerde wet dat het aan-tal transistoren op een chip gemiddeld elke 24maanden verdubbelt.. 16

wetten van De Morgan Twee wetten in de boole-aanse algebra. De eerste wet stelt dat de nega-tie van een AND, een OR is met geınverteerdeingangen. De tweede wet is zijn duale: de nega-tie van een OR is een AND met geınverteerdeingangen. Formeel schrijven we de wetten als(x · y)

′= x′ + y′ en (x+ y)

′= x′ · y′.. 10

Write Once Read Many (WORM) Een principewaarbij men slechts eenmaal naar een geheugenkan schrijven, maar de gegevens in dat geheu-gen dan meermaals kan lezen.. 32

X

XNOR Een poort met twee ingangen die de geınverteerdeis van de XOR poort. 〈0, 0〉 en 〈1, 1〉 worden af-gebeeld op 1 de overige configuraties op 0.. 29

XOR Een populaire basisschakeling met twee ingan-gen. Hierbij worden 〈0, 0〉 en 〈1, 1〉 afgebeeld op0; en 〈0, 1〉 en 〈1, 0〉 afgebeeld op 1.. 6

Z

Zekeringen Een geleider, maar die makkelijk dooroverbelasting kan worden doorgebrand. Zeke-ringen zijn een vorm van programmeerbaar ge-heugen: door het doorbranden van bepaalde ze-keringen kan het gedrag van een programmeer-bare chip wijzigen.. 34

zwevende modus Z Een waarde die op een gelei-der staat. Bij een zwevende modus staat er geen0 of 1 op de geleider. Deze toestand is nuttigwanneer verschillende poorten eenzelfde gelei-der willen aansturen. Wanneer er bijvoorbeeldtwee poorten een uitgang verbinden met een ge-leider, en de ene poort zit in zwevende modus,en de andere poort legt 1 aan, dan staat er 1 opde geleider. De zwevende modus kan men beko-men met een tri-state buffer en wordt gebruiktbij de implementatie van bussen.. 43, 343

zwevendekommagetal zie vlottende komma voor-stelling. 77

Index

N -kubus, 50fix⊗Ai, f B, 77

float⊗Am, e B, 78

mod , 76rem, 76m× n registerbank, 159n-and, 7n-or, 7double, 78float, 78single, 78VHDL

’-’, 273, 274’0’, 273, 274’1’, 273, 274’H’, 273, 274’L’, 273, 274’U’, 273, 274’W’, 273, 274’X’, 273, 274’Z’, 273–275’, 265**, 267*, 267+, 267,, 270-, 267., 264/=, 267/, 267:=, 271:, 271, 272;, 271, 272<=, 267, 272<>, 270<, 267=, 267>=, 267>, 267ABS, 267AND, 267BIT VECTOR, 267BIT, 267B, 265

CHARACTER, 267DELAY LENGTH, 267E, 265INTEGER’HIGH, 267INTEGER, 267MOD, 267NAND, 267NATURAL, 267NOR, 267NOT, 267NULL literal, 264OR, 267O, 265POSITIVE, 267REAL, 267REM, 267ROL, 267ROR, 267SLA, 267SLL, 267SRA, 267SRL, 267STRING, 267TIME’HIGH, 267TIME, 267XNOR, 267XOR, 267X, 265&, 267, 276, 265‘0’, 277abstract literal, 264and, 275architecture, 20array, 265, 270a, 265base#literal#exp, 265bit string literal, 265bit vector, 20, 269, 275, 277bitreeks, 265bit, 20, 267, 269, 272, 273, 275boolean, 275byte, 267b, 265

352

INDEX 353

case, 265character literal, 265character, 268component, 20constant, 271c, 265delimiter, 265downto, 265, 268d, 265end, 269entity, 20enumeration literals, 264e, 265fs, 267function, 274f, 265hr, 267identifier, 265integer, 268, 277in, 20is, 267, 268, 270length, 274low, 275map, 20min, 267ms, 267nand, 265, 275natural, 270nor, 275not, 275ns, 267of, 270or, 275out, 20physical types, 264port, 20ps, 267range, 268, 270, 275real, 270scheidingsteken, 265sec, 267signal, 265, 272sla, 265std logic vector, 275std logic, 273–275std ulogic vector, 274, 275std ulogic, 273string literal, 265subtype, 268to, 268type, 267, 269, 270units, 269universal integer, 264

universal real, 264use entity, 21us, 267variable, 271xnor, 275xor, 275

0-maxtermen, 111-complement, 681-mintermen, 112-complement, 693-state buffer, 43

Absorptie, 10Accumulator (ACC), 223Actie-notatie, 220Add-instructie, 221Adres, 218Adres-ingangen ai, 82Adresbus, 242Adresdecoder, 34Adresregister (AR), 239Adresseermode, 220Algebraısch manipuleren, 57Algorithmic-State-Machine Chart, 154American Standard Code for Information Interchange

(ASCII), 80Analyse, 16AND, 4AND-matrix, 34AND-OR-Invert (AOI), 29Any-uitgang a, 85Application Specific IC (ASIC) componenten, 15Arabisch getalsysteem, 59Arithmetic-Logic Extender (ALE), 72Arithmetic-Logic Unit (ALU), 72Aritmetisch schuiven, 89Array aggregate, 269ASM-blok, 155ASM-elementen, 154ASM-schema, 154Assembleerprogramma, 233Assembleertaal, 233Assignatie, 271Associativiteit, 10Asynchrone sequentiele schakelingen, 95Asynchrone set en reset, 101Asynchrone teller, 105Asynchronous counter, 105Autodecrement, 227Autoincrement, 227

Bal-en-heuvel-analogie, 99Barrel left rotator, 89Basis, 25

354 INDEX

Basisadres, 226Basisoperaties, 4BCD-teller, 107Beslissingskader, 154Bidirectionele teller, 104Bidirectionial counter, 104Binair stelsel, 59Binaire signalen, 3Binary Coded Decimal (BCD), 80Blackbox, 20Booleaanse algebra, 9Bronradix, 60Buffer, 30Buffergeheugen, 162Buren, 50Bus, 44, 83Bus sharing, 177, 200

Call stack, 174Canonieke vorm, 12Capaciteit C, 40Carry, 62Carry Input Generator (CIG), 72Carry-generate gi, 64Carry-lookahead opteller (CLA), 64Carry-propagate pi, 64Cascade, 82Chaining, 207Character, 265Chip Select-ingang CS, 161Chipoppervlakte C, 42Cijfer-complement, 68Cijferen, 62CLA-generator, 65x CLR∗, 101Clock skew, 213CLRA-instructie, 225CMOS, 26Coderen, 113Collector, 25Combinatorische Schakelingen, 47Commentaar, 264Commutativiteit, 10Comparator, 86Compatibele toestanden, 126Compatibiliteitsgraaf, 184Complement voorstellingen, 68Complex Instruction Set Computer (CISC), 228Complex Programmable Logic Device (CPLD), 35Computer Aided Design (CAD), 16Concurrency, 22Conditional box, 155Conditioneel kader, 155Configurable Logic Blocks (CLB), 36

Constante, 270Controle-ingangen, 149Controle-signalen, 149Controle-uitgangen, 149Controller, 149Cover, 52Critical race, 131Custom Design, 33Cycle, 131

D-flipflop, 101Daaltijd tf , 41Dalende flank, 95, 124Dambordpatroon, 55Data Flip-Flop (D-FF), 36Data-flipflop, 101Data-ingang D, 97Data-ingang d, 84Data-ingangen, 149Data-ingangen di, 82Data-uitgangen, 149Data-uitwisseling, 220Databus, 242Datapad, 149Datatypes, 22Decimale stelsel, 59Decision box, 154Declaratie, 271Decoder, 82Decrement, 72, 104Dekking, 52Deling, 76Demultiplexer, 84Demux, 84Diminished-radix complement, 68Directe adressering, 225Distributiviteit, 10Documentatie, 16Doelradix, 60Don’t care, 11, 55Doorvoer, 16Doperen, 26Down-counter, 104Down-Up D/U∗, 104Drain, 24, 25Drijvendekommagetal, 77Driver, 30Dual port registerbank, 160Dualiteit, 10Dubbele precisie, 78Duty cycle, 95Dynamisch gedrag, 39Dynamisch RAM, 161Dynamisch vermogenverbruik, 42

INDEX 355

Dynamische hazard, 138

Edge-triggered flipflop, 99Eindige-toestanden machine, 94Emitter, 25Empty, 165Enable E, 43Enable-ingang e, 82Encoder, 85Enkele precisie, 78Espresso heuristic logic minimizer, 57Essentiele hazard, 142Essentiele priemimplicant, 52Excess formaat, 68Excess-bias B, 68Excitatiefuncties, 117Excitatietabel, 101, 116Excitatietabellen, 117Execution stack, 241Exponent E, 77

Factoranalyse, 57Fall time, 41Falling edge, 95Fan-in, 43Fan-out, 43Field Programmable Gate Array (FPGA), 34, 36Finite state machine (FSM), 94Finite State Machine with Data path (FSMD), 149First-In-First-Out (LIFO), 166Fixed point, 77Flankgevoelig, 99Flash-programmeerbaar, 34Flipflop, 94, 96Floating-point number, 77Flow table, 125Fractionele gedeelte, 77Full, 165Full adder (FA), 63Functional Units (FU), 150Functional-unit sharing, 188Functionele Eenheden, 150Functionele ontbinding, 57Functionele-eenhedentabel, 181Fundamental mode restriction, 123Fundamentele modus, 123

Gate, 25Gate Array, 33Geındexeerde adressering, 227Geınverteerde ingangen, 8Gecombineerde lees-schrijfpoort R/W ∗, 161Geconditioneerde sprong (CJMP), 232Geheel deel, 77

Geheugen-programmeerbaar, 34Geheugencomponent, 94Geklokte D-latch, 97Geklokte SR-latch, 96Gelijk aan (EQ), 232Gelijktijdigheid, 22Generische instructiecyclus, 211Genormaliseerde vlottende komma voorstelling, 78Gesloten, 25Glitch, 9Glitches, 114Glue Logic, 32, 35Gray-code teller, 114Greedy algorithm, 54Groter dan (GT), 232Groter dan of gelijk aan (GE), 232Gulzige strategie, 54

Half adder (HA), 62Hamming distance, 132Hammingafstand, 132Hazards, 138Hexadecimaal stelsel, 59High, 24, 37Hoog impedant, 43Houdtijd, 98Hysteresis, 39

Identifiers, 264IEEE 1164, 273Implicant, 52Impliciete adressering, 225In- en uitvoer modules, 35Incompatibiliteitsranden, 184Increment, 72, 104Indirecte adressering, 225Ingangscombinatie, 108Ingangsimpedantie RI , 40Initalisatie, 108Inputgebaseerd ASM-schema, 158Inputgebonden sequentiele schakelingen, 95Instantie, 270Instructie, 218Instructiedecoder, 237Instructieformaat, 220Instructieregister (IR), 221Instructieset, 73, 221Instructieset-stroomschema, 237Instructietype, 220Instructiewoord, 73, 149, 206Instruction Set Flowchart, 237Interface, 14Interpretatie, 233Inverter, 5

356 INDEX

Inverterende poorten, 49Invoer- en uitvoertabellen, 182Invoer-ingangen Iij , 159

Jack Kilby-flipflop, 102JK-flipflop, 102

K-kaarten, 50Karakter, 265Karakteristieke tabel, 101Karakterreeks, 265Karnaugh-kaarten, 50Kleiner dan (LT), 232Kleiner dan of gelijk aan (LE), 232Kliek, 185Kliek Kn, 127Klokbuffer, 213Klokfrequentie, 16, 95Klokfrequentie f , 42Klokingang, 95Klokperiode, 95Knopen, 184Kopies, 51Kostprijs, 8, 49Kritische pad, 49

Label, 233Lange lijnen, 36Last-In-First-Out (LIFO), 163Latency time, 211Leeg/empty, 163Lees (R), 203Lees/schrijf (RW), 203Leesadres, 164Leespoorten, 159Lekstroom, 42Levensduur, 179Levensduurtabel, 179Literals, 264Load, 231Load-instructie, 223Logical Blocks (LB), 36Logisch schuiven, 89Logische poorten, 7Logische schakelingen, 4, 8Look-Up Table (LUT), 36Low, 24, 37

Maatwerk, 33Machinetaal, 233Mantisse M , 77Marginale triggering, 99Mask, 230Master-slave flipflop, 99

Max-cut graph partitioning, 185Maxtermen, 11Mealy machine, 95Mealy-FSM, 95Merger diagram, 128Metastabiele toestand, 99Metastabiliteit, 98Metastability resolution time tr, 215Microprogrammeerbare controller, 172Minimal-bit-change, 114Mintermen, 11Mnemonische notatie, 220Modulo, 76Modulo-teller, 107Moore machine, 95Moore-FSM, 95Mov-instructie, 222Mul-instructie, 221Multicycling, 207Multiplexer, 82MUX, 82

NAND, 7Natuurlijke volgorde, 172Negatief oneindig −∞, 79Negatieve logica, 25Next State Logic, 172Niet gelijk aan (NE), 232Niet-genormaliseerde vlottende komma voorstelling,

78Niet-inverterende poorten, 49Niet-programmeerbare processor, 149NMOS, 25No Operation (NOP), 230Nodes, 184NOR, 7NOT, 4Not a Number (NaN), 79Nul (0), 79

Object, 270Octaal stelsel, 59Offset, 226One-hot codering, 113Ongeconditioneerde sprong (JMP), 232Onmiddellijke adressering, 225Opcode, 220Open, 25Open-Drain Poort, 27Operand-tabel, 201Operanden, 201Operandverbindingen, 150Operation code, 220OR, 4

INDEX 357

OR-AND-Invert (OAI), 29OR-matrix, 34Output Logic, 173Overdracht, 62Overflow, 63Overgangstoestanden, 132Overloading, 277

Parallel laadbaar, 106Parallel-laadbare bidirectionele teller, 106Parallelle uitvoering, 209Parallelle vermenigvuldiger, 74Pass-transistoren, 36Pipelining, 209Placement, 33PLD talen, 18PMOS, 25Pop, 163Positief oneindig +∞, 79Positieve logica, 25Positieve terugkoppeling, 94x PR∗, 101Priemimplicant, 52Primitive flow table, 125Prioriteitsencoder, 85Prioriteitsranden, 185Product-of-Sums (POS), 11Program counter (PC), 218Programma, 219Programmable Array Logic (PAL), 34Programmable Logic Array (PLA), 34Programmable Logic Device (PLD), 34Programmable Read Only Memory (PROM), 34Programmageheugen, 218Programmateller, 218Programmeerbare Chips, 32Programmeerbare chips, 34Propagation delay, 41Pull-Down Network (PDN), 26Pull-Up Network (PUN), 28Push, 163

Queue, 162Quine-McCluskey algoritme, 56

Race, 96, 131Radix r, 59Radix-complement, 68Random Access, 161Random Access Memory (RAM), 161RC-keten, 39Read, 165x RAia, 160x REi, 160

Read-Enabled, 158Read/write∗-ingang, 167Recursie, 174Reduced Instruction Set Computer (RISC), 228Redundante termen, 140Register, 94, 103Register Access Table, 203Register file cell, 158Register port sharing, 203Register-geındexeerde adressering, 227Register-indirecte adressering, 225Register-relatieve adressering, 226Register-Transfer-Level (RTL) Componenten, 15Registerbank, 159Registerinstructies, 230Registertoegangstabel, 203Registertransfer, 150Relatieve adressering, 226Remainder, 76Reset, 96, 163, 165Reset register (ClrR), 232Reset status (ClrS), 232Resultaatverbindingen, 150Resultaten, 201Resultaten-tabel, 201Ripple Carry Output (RCO), 105Ripple counter, 105Ripple-carry opteller, 63Rise time, 40Rising edge, 95Roteren, 89Routing, 33Ruismarge, 38

Schakelaars, 25Schakelmatrix, 35, 36Scheidingstekens, 264Schmitt-trigger ingangen, 39Schrijf (W), 203Schrijfadres, 164Schrijfpoorten, 159Schuifoperaties, 88Schuifregister, 103Schuiven, 89Sea of Gates, 33Selectie-ingangen si, 82Selectie-uitgangen si, 82, 85Selector, 82Sequentiele schakeling, 94Sequentiele uitvoering, 209Set, 96Set-reset flipflop, 101Set-reset latch, 96Set-up-tijd, 97

358 INDEX

Seven-segment display, 56Sign-bit s, 77Sign-magnitude, 68Signaal, 270Skew, 142Sleutelwoorden, 265Slices, 36Source, 24, 25Spartan-3, 36Specificatie, 14Specifieke Chips (ASIC), 32Spiegelt, 51Spronginstructies, 230SR-flipflop, 101SR-latch, 96SRAM, 34Stabiel, 125Stabiele toestanden, 99Stack, 162Standaard cellen, 33Standaard Chips, 32Standaard vorm, 12Stapelgeheugen, 162Stapelteller, 242State box, 154State Register, 172Statisch RAM, 161Statisch vermogenverbruik, 42Statische 0-hazard, 138Statische 1-hazard, 138Statische hazard, 138Statusregister, 232Statussignalen, 149Statusvlag, 232Stijgende flank, 95, 124Stijgtijd tr, 40Store, 231Store-instructie, 223Straightforward codering, 113Stuursignaal, 25Sub-instructie, 221Subroutine, 172Subroutine sprong (JSR), 232Subroutine terugkeer (RTS), 232Sum-of-Products (SOP), 11, 34Symbolische adressen, 233Synchrone sequentiele schakelingen, 95Synchrone teller, 105Synthese, 15Systeemsynthese, 15

T-flipflop, 101Technology mapping, 58Tekenbit s, 77

Teller, 104Terugkeertoestand, 174x T, 26Throughput, 16, 211Tijdelijke geheugens, 150Tijdsconcept, 22Tijdsconstante τ , 39, 99Toestand S, 94Toestand-Actie Tabel, 152Toestanden, 108Toestandsdiagram, 108Toestandsgebaseerd ASM-schema, 158Toestandsgebonden sequentiele schakelingen, 95Toestandskader, 154Toestandsregister, 172Toestandstabel, 109Toggle, 101Toggle-flipflop, 101Tokens, 264Top, 163Totale gewicht, 185Transferfunctie, 38Transistoren, 25Transitie-functie, 127Transitiediagram, 133Transities, 108Transmission gate, 44Transparant, 99Transparantie-probleem, 96, 99Tri-state buffer, 43Trial-and-error, 57Tussentoestanden, 132

Uitgangscombinatie, 109Uitgangsimpedantie RO, 40Uitvoer logica, 173Uitvoer-uitgangen Oij , 160Uitvoerstapel, 241Underflow, 78Underscores, 265Universiele poorten, 7Up-counter, 104

Variabele, 270Vaste komma voorstelling, 77Velden, 220Verbindingen, 150Verbindingentabel, 181Verborgen bits, 79Vergelijker, 86Verilog, 18Vermogenverbruik, 41Verplaatsinstructies, 230Vertragingstijd tp, 41

INDEX 359

Verwerkingskracht, 8Very High Speed Integrated Circuit, 17VHDL, 17VHDL Analog and Mixed Signals (VHDL-AMS), 17VHSIC Hardware Description Language, 17Vierkantswortel, 230Vlottende komma voorstelling, 77Voedingsspanning V , 42Vol/full, 163

Waarheidstabellen, 6Wet van De Morgan, 10Wet van Moore, 16Wetten van De Morgan, 10Wrap-around, 104Write, 165Write Once Read Many (WORM), 32x WAia, 159x WEi, 159Write-Enabled, 158

XNOR, 29XOR, 6

Zekeringen, 34Zet status (SetS), 232Zwevende modus Z, 43Zwevendekommagetal, 77

360 INDEX

Cursus Digitale Elektronica en Processoren [Work in Progress]

Documents

Transcript of Cursus Digitale Elektronica en Processoren [Work in Progress]