Praktikum Systementwurf mit VHDL“ - eda.ei.tum.de · Praktikum ” Systementwurf mit VHDL“...

Praktikum

”Systementwurf mit VHDL“

Lehrstuhl fur Entwurfsautomatisierung

Technische Universitat Munchen

1998-2011 – Ulrich Seidl, Klaus Eckl, Josef Fleischmann, Martin Strasser, Ning Chen

Praktikum

”Systementwurf mit VHDL“

Hardware-Implementierung

eines Chiffrierverfahrens

Prof. Dr.-Ing. Ulf Schlichtmann

6. Mai 2011

Lehrstuhl fur EntwurfsautomatisierungTechnische Universitat Munchen

Arcisstr. 21, 80333 MunchenTel.: (089) 289 23666

c©Weitergabe an Dritte nur mit Zustimmung des Lehrstuhls.

INHALTSVERZEICHNIS i

Inhaltsverzeichnis

1 Checkliste zur Durchfuhrung des Praktikums 1

2 Einleitung 4

2.1 Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.2 Zielsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.3 Uberblick Kryptographie . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.4 Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Direkter Algorithmus 12

3.1 Beispiel: Inverter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

3.2 XOR-Modul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.3 Addierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4 Modulo-Multiplizierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.4.1 Der Low-High-Algorithmus . . . . . . . . . . . . . . . . . . . . . . 24

3.4.2 Implementierung Modulo-Multiplizierer . . . . . . . . . . . . . . . 25

3.5 Rundenmodul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.6 Ausgabetransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.7 Verschlusselung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4 Hardwarenahe Implementierung 28

4.1 Synthese und Implementierung des direkten Algorithmus . . . . . . . . . 31

4.2 Resource Constrained Scheduling I . . . . . . . . . . . . . . . . . . . . . 32

4.2.1 16-Bit-Register . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.2 2-zu-1 Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.3 Schlusselgenerator . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.2.4 Kontrolleinheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.2.5 Der neue IDEA-Algorithmus - Resource Constrained Scheduling I 35

4.2.6 Bindeglied zur Außenwelt - UART . . . . . . . . . . . . . . . . . 36

4.3 Resource Constrained Scheduling II . . . . . . . . . . . . . . . . . . . . . 39

4.3.1 4-zu-1 Multiplexer . . . . . . . . . . . . . . . . . . . . . . . . . . 42

4.3.2 Die Steuerlogik fur eine Runde . . . . . . . . . . . . . . . . . . . 42

4.3.3 Datenpfad des Rundenmoduls . . . . . . . . . . . . . . . . . . . . 43

4.3.4 Das getaktete Rundenmodul . . . . . . . . . . . . . . . . . . . . . 43

ii INHALTSVERZEICHNIS

4.3.5 Das erweiterte Rundenmodul . . . . . . . . . . . . . . . . . . . . 44

4.3.6 Implementierung des Rundenzahlers . . . . . . . . . . . . . . . . 46

4.3.7 Hardwarenahe Implementierung des IDEA-Algorithmus . . . . . . 48

4.3.8 UART - Resource Constrained Scheduling II . . . . . . . . . . . . 49

5 Laufzeitabschatzung 50

5.1 Zielarchitektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.1.1 Laufzeitabschatzung 16-Bit-XOR . . . . . . . . . . . . . . . . . . 51

5.1.2 Laufzeitabschatzung 16-Bit-Addierer . . . . . . . . . . . . . . . . 51

5.1.3 Laufzeit Modulo-Multiplizierer . . . . . . . . . . . . . . . . . . . . 53

5.1.4 Laufzeitabschatzung Register . . . . . . . . . . . . . . . . . . . . 53

5.1.5 Laufzeitabschatzung Multiplexer . . . . . . . . . . . . . . . . . . 54

5.1.6 Laufzeiten der einfachen IDEA-Implementierung . . . . . . . . . . 54

5.1.7 Laufzeiten der hardwarenahen IDEA-Implementierung . . . . . . 54

5.2 Vergleich der unterschiedlichen Implementierungen . . . . . . . . . . . . 55

Literaturverzeichnis 57

ABBILDUNGSVERZEICHNIS iii

Abbildungsverzeichnis

1 Entwurfsablauf elektronischer Schaltungen . . . . . . . . . . . . . . . . . 5

2 Symmetrische Verschlusselung . . . . . . . . . . . . . . . . . . . . . . . . 7

3 Asymmetrische Verschlusselung . . . . . . . . . . . . . . . . . . . . . . . 7

4 IDEA-Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

5 Die Runde im IDEA-Algorithmus . . . . . . . . . . . . . . . . . . . . . . 9

6 Die Ausgabetransformation im IDEA-Algorithmus . . . . . . . . . . . . . 9

7 Erzeugung der Teilschlussel . . . . . . . . . . . . . . . . . . . . . . . . . 10

8 Entwurfsumgebung nach dem Start . . . . . . . . . . . . . . . . . . . . . 12

9 Anlegen eines neuen Projekts mit dem Wizard . . . . . . . . . . . . . . . 13

10 Konfiguration des FPGAs sowie des Synthese- und Simulationswerkzeuges 13

11 Abschließende Zusammenfassung des Wizards . . . . . . . . . . . . . . . 14

12 Entwurfsumgebung nach dem Anlegen des neuen Projekts . . . . . . . . 14

13 Auswahl des Dateityps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

14 Definition der Ein- und Ausgange des Moduls . . . . . . . . . . . . . . . 15

15 Zusammenfassung der neuen Quellendatei . . . . . . . . . . . . . . . . . 16

16 Entwurfsumgebung nach dem Anlegen einer neuen Quellendatei . . . . . 16

17 Erstellen der Testbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

18 Auswahl der zu testenden Datei . . . . . . . . . . . . . . . . . . . . . . . 18

19 Abschließen der Testbench . . . . . . . . . . . . . . . . . . . . . . . . . . 19

20 Die IDE nach Erstellen der Testbench . . . . . . . . . . . . . . . . . . . . 20

21 Starten der Verhaltenssimulation . . . . . . . . . . . . . . . . . . . . . . 20

22 Gestarteter Simulator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

23 Toolbar zur Steuerung des Simulators . . . . . . . . . . . . . . . . . . . . 21

24 Verfeinerte Zeitachse im Simulator . . . . . . . . . . . . . . . . . . . . . 21

25 Aufbau eines Xilinx-FPGA . . . . . . . . . . . . . . . . . . . . . . . . . . 28

26 Design-Flow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

27 Die geanderte Schaltung mit nur noch einem Rundenmodul . . . . . . . . 32

28 Verhalten der Kontrolleinheit . . . . . . . . . . . . . . . . . . . . . . . . 35

29 Optionen beim Offnen von Xilinx R© iMPACTTM . . . . . . . . . . . . . . 37

30 Die erkannten Chips in der JTAG-Kette . . . . . . . . . . . . . . . . . . 37

31 Das Testprogramm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

iv TABELLENVERZEICHNIS

32 Aufteilung der Runde in 4 Teilschritte . . . . . . . . . . . . . . . . . . . 39

33 Datenpfad des Rundenmoduls . . . . . . . . . . . . . . . . . . . . . . . . 40

34 Steuerlogik fur eine Runde . . . . . . . . . . . . . . . . . . . . . . . . . . 42

35 Datenpfad fur Runden-Berechnung und Ausgabetransformation . . . . . 44

36 Steuerlogik fur die erweiterte Runde, Trafo = 1 . . . . . . . . . . . . . . 45

37 Realisierung des IDEA-Algorithmus . . . . . . . . . . . . . . . . . . . . . 47

38 Spezifikation des Rundenzahlers als Endlicher Automat . . . . . . . . . . 47

39 Der interne Zahler auch als Endlicher Automat . . . . . . . . . . . . . . 48

40 Vereinfachter Aufbau eines SLICE. . . . . . . . . . . . . . . . . . . . . . 50

41 Volladdierer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

42 Laufzeiteigenschaften Register . . . . . . . . . . . . . . . . . . . . . . . . 53

43 Zweistufiger 4-zu-1 Multiplexer . . . . . . . . . . . . . . . . . . . . . . . 54

Tabellenverzeichnis

1 Ressourcenbedarf der IDEA-Grundmodule . . . . . . . . . . . . . . . . . 29

2 Ressourcenbedarf der getakteten Runde . . . . . . . . . . . . . . . . . . . 44

3 Laufzeiten SLICE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

1

1 Checkliste zur Durchfuhrung des Praktikums

1. Versuchsauswertung

Erstellen Sie bitte folgendes:

• Ausarbeitung, die die Antworten zu den Vorbereitungsfragen (markiert mitFragezeichen) sowie die Simulationsplots enthalten soll. Bei den Simulati-onsplots bitte mit allen relevanten Signalen, mit allen Stimuli, mit gekenn-zeichnetem Endergebnis fur folgende Module: direkte Implementierung (3.7),die Kontrolleinheit der RCS1 (4.2.4), Ergebnis RCS1 (4.2.5), die Steuerlogik(4.3.2) sowie die Erweiterung (4.3.5), den Rundenzahler (4.3.6) und ErgebnisRCS2 (4.3.7).

• VHDL-Code: bitte Name und Kennung als Kommentar einfugen; der Codezu jedem Projekt soll nach Abgabe der Gesamtausarbeitung noch lauffahigsein; laden Sie das ganze ISE-Projekt hoch (siehe Punkt 5.

2. Schriftlichee Prufung

• Termin: wird bekannt gegeben

• Dauer: 60 min

• Keine Unterlagen erlaubt

3. Bewertung

Sowohl die Teilnahme an der Prufung als auch die Abgabe der Ausarbeitung unddes VHDL-Codes ist Voraussetzung fur das erfolgreiche Bestehen des Praktikums,wobei die Ausarbeitung, der VHDL-Code und die Prufung jeweils mit 30%, 30%und 40% gewichtet sind.

4. Das Tool Xilinx R© ISE WebPackTM

Alle Versuche, die im Rahmen dieses Praktikums durchgefuhrt werden, mussen inder integrierten Entwicklungsumgebung (IDE) Xilinx R© ISE WebPackTM durchge-fuhrt werden. Diese konnen Sie entweder am Lehrstuhl im Praktikumsraum star-ten, oder sie nach einer kurzen Registrierung kostenlos bei http://www.xilinx.comherunterladen. Am Lehrstuhl kann das Tool gestartet werden, indem Sie das Skriptstart_ise aufrufen. Wie in Linux ublich, wechseln Sie bitte auf einer Konsole inihr Heimatverzeichnis, und fuhren dann das Skript aus:

cd ~ ; ./start_ise

5. Projektlaufwerk

Alle Versuche mussen in Ihrem Projektlaufwerk (LRZ-Kennung und Passwort)abgelegt werden. Nur die darin gespeicherten Dateien werden bewertet! Sie konnendieses Laufwerk sowohl unter Windows als auch unter Linux einbinden.

http://www.xilinx.com

2 1 CHECKLISTE ZUR DURCHFUHRUNG DES PRAKTIKUMS

• Am Lehrstuhl stehen Ihnen Linux-Rechner im Praktikumsraum zur Verfu-gung. Diese binden Ihr Projektlaufwerk automatisch beim Login als Verzeich-nis work unter Ihrem Home ein.

• Wenn Sie an Ihrem eigenen Linux-Rechner arbeiten mochten, stellen Sie bittesicher, dass sie mit dem Internet und dem VPN des Munchener Wissenschafts-netzwerks verbunden sind. Starten Sie daher also zuerst den VPN-Client des

LRZ. Binden Sie dann per CIFS-Mount das Laufwerk

\\nas.ads.mwn.de\tuei\eda-psv\psv\ihre_lrzkennung ein. Dies geschieht,abhangig von der verwendeten Distribution, mit einem Kommando wie bei-spielsweise:mount -t cifs -ouser=ihre_lrzkennung,uid=lokaler_benutzer,

file_mode=0700,dir_mode=0700

//nas.ads.mwn.de/tuei/eda-psv/psv/ihre_lrzkennung mountpunkt. Le-sen Sie fur weitere Informationen bitte in der Dokumentation Ihrer Linux-Distribution nach.

• Wenn Sie an Ihrem eigenen Windows-Rechner arbeiten mochten, stellen Siebitte ebenfalls sicher, dass sie mit dem Internet und dem VPN des MunchenerWissenschaftsnetzwerks verbunden sind. Starten Sie also erst den VPN-Client

des LRZ. Verbinden Sie sich dann mit dem Laufwerk\\nas.ads.mwn.de\tuei\eda-psv\psv\ihre_lrzkennung, indem Sie im Win-dows-Explorer im Menu Extras den Punkt

”Netzwerklaufwerk verbinden...“

wahlen. Geben Sie dann das entsprechende Laufwerk an und wahlen Sie einenLaufwerksbuchstaben. Beim Einbinden des Laufwerks werden Sie dann nachIhrer LRZ-Kennung und Ihrem Passwort gefragt. Wichtig: Stellen Sie bittehier Ihrer LRZ-Kennung als Prafix ads\ (Bezeichnung der Active-Directory-Domane) voran.

Haben Sie das Laufwerk in Ihr System erfolgreich integriert, dann konnen Siedarauf Ihre Versuche beginnen. Bei langsamen Internet-Verbindungen kann esvorteilhaft sein, die Versuche lokal durchzufuhren und im Anschluss das lokaleProjektverzeichnis auf das Projektlaufwerk zu kopieren. Stellen Sie aber in jedemFall sicher, dass bei der Abgabe alle relevanten Daten auf dem Projektlaufwerkgespeichert sind, denn nur dieser Quellcode kann bewertet werden!

6. Unterlagen

Sie finden die Unterlagen auf der Lerhstuhlwebseite (http://www.eda.ei.tum.de).Folgende Punkte sind enthalten:

• Zeitplan, den Sie einhalten sollen.

• Referenzmodelle fur alle Teile des IDEA-Algorithmus. Dazu brauchen SieJava und Java-Script in Ihrem Web-Browser zu aktivieren.

• Vorlagen fur den im Praktikum verwendeten UART

http://www.eda.ei.tum.de

3

• Das Testprogramm IDEA-Tester: Mit dem IDEA-Tester konnen Sie Datenseriell zu Ihrem Praktikums-Board ubertragen um den Algorithmus in Hard-ware zu testen. Der IDEA-Tester steht Ihnen hier als ausfuhrbares Programmfur Linux zum Download zur Verfugung.

• Einen Link zur Information des Boards.

• Einen Link, uber den Sie das Handbuch uber VHDL herunterladen konnen.

Sie konnen auch den Foliensatz fur die drei Termine herunterladen.

7. Betreuung

Sollten Sie bei der Praktikumsdurchfuhrung auf Probleme stoßen, schreiben Siean die folgende Email-Adresse:

[email protected]

Beachten Sie bitte, dass Sie Ihr LRZ-Login immer im Betreff der Email eintragen.

Sie konnen auch am Mittwoch, 15:00-17:00, im Raum 2977, zur Tutorstunde kom-men oder den Praktikumsbetreuer verstandigen:

Dipl.-Ing. Ning ChenRaum 2908Tel.: (089) - 289 23689E-Mail: [email protected]

4 2 EINLEITUNG

2 Einleitung

2.1 Grundlagen

Mit den heute zur Verfugung stehenden Fertigungstechnologien lassen sich Schaltungeneiner Komplexitat fertigen, die durch den manuellen Entwurf nicht mehr zu beherrschensind. Dies erzwingt den Einsatz von Entwurfswerkzeugen, die den Entwickler in allenPhasen des Schaltungsentwurfs unterstutzen. Der Einsatzbereich dieser Werkzeuge er-streckt sich von der Validierung einer gegebenen Spezifikation durch Simulation uberdie Umsetzung der Spezifikation in eine Implementierung bis hin zur Erzeugung der furdie Fertigung notwendigen Layoutdaten.

Durch den Einsatz moderner Entwurfswerkzeuge konnen Entwurfsdauer und Entwurfs-kosten deutlich gesenkt werden. Da mittlerweile auch kostengunstige Zieltechnologienin Form der programmierbaren Gate-Arrays (FPGAs) vorliegen, ist der Entwurf auchkomplexer anwendungsspezifischer Hardware mit akzeptablem Aufwand moglich gewor-den.

Als standardisierte Hardwarebeschreibungssprache wird VHDL in weiten Teilen der In-dustrie fur den Entwurf von hochstintegrierten Schaltungen verwendet. Im wesentlichenist VHDL eine von der Programmiersprache ADA abgeleitete Sprache und besitzt Kon-strukte, die speziell fur die Beschreibung von Hardware notig sind. Dies sind unteranderem:

• Beschreibung nebenlaufigen Verhaltens

• Modellierung des Zeitverhaltens

• Beschreibung von Schaltungsstrukturen mit Unterstutzung der Modularisierungund Hierarchiebildung wahrend des Entwurfs

VHDL bietet weiterhin die Moglichkeit, eine Schaltung auf verschiedenen Abstrakti-onsebenen zu beschreiben (Abb. 1). Dies ermoglicht dem Entwickler, in verhaltnismaßigkurzer Zeit eine Systembeschreibung auf algorithmischer Ebene zu erstellen und die kor-rekte Funktionsweise zu verifizieren. Dadurch werden bereits in einem sehr fruhen Ent-wurfsstadium eventuell vorhandene prinzipielle Designfehler oder Schwachen erkannt.Die Simulation auf algorithmischer Ebene ist noch verhaltnismaßig ungenau, da keineInformationen uber die letztendliche Realisierung und die Zielhardware mit eingehen.In diesem Entwurfsstadium sind z.B. noch keine Informationen uber Gatter- und Ver-drahtungslaufzeiten vorhanden.

Nach und nach wird die algorithmische Beschreibung zu einer Register-Transfer-Be-schreibung verfeinert. Auf dieser Schaltungsebene konnen erstmals die Laufzeiten derSchaltungskomponenten in die Simulation mit einfließen. Die Simulation wird dadurchgenauer, aber auch aufwendiger und beansprucht dadurch mehr Rechenzeit.

2.1 Grundlagen 5

Layout-Synthese (Plazieren & Verdrahten)

Aufgabenstellung,Spezifikation

algorithmischeVerhaltensbeschreibung

Logik-Synthese

GatternetzlisteLogikebene

Maskendaten

Fertigung der Schaltung

BeschreibungRegister-Transfer-

in VHDLBeschreibung

Backannotation

Simulation

Simulation

Simulation

Highlevel-Synthese

Abbildung 1: Entwurfsablauf elektronischer Schaltungen

Aus einer Beschreibung auf Register-Transfer-Ebene kann entweder mittels manuellerModellierung in VHDL oder durch automatische Synthese eine Netzliste erzeugt werden.Diese besteht aus einfachen Gattern, die auf der Zielhardware realisiert werden konnen.

Beim Layout werden diese Gatter zuerst auf dem Chip geometrisch platziert und an-schließend verdrahtet. Nach dem Layout sind neben den Gatterlaufzeiten nun auch dieexakten Verdrahtungslaufzeiten bekannt. Nach Zurucklesen der Verdrahtungslaufzeiten(Backannotation) kann in einer weiteren Simulation auf Gatterebene nun uberpruft wer-den, ob sich die zu fertigende Schaltung auch in der Realitat wie gewunscht verhalt. Istdie korrekte Funktion sichergestellt, so kann mit den vorhandenen Maskendaten derChip gefertigt werden.

6 2 EINLEITUNG

2.2 Zielsetzung

Das Ziel dieses Praktikums ist, wesentliche Aspekte des Rechnergestutzten Schaltungs-entwurfs unter Verwendung der Hardwarebeschreibungssprache VHDL zu vermitteln.Ausgehend von einfachen Komponenten auf unterschiedlichen Beschreibungsebenen wer-den komplexere Komponenten erstellt, die schließlich einen Chiffrieralgorithmus imple-mentieren. In zwei nachfolgenden Schritten wird die Implementierung so verandert, daßsie auf einer vorgegebenen Zielarchitektur realisiert werden kann. Der VHDL-Code wirddann dazu verwendet, einen FPGA zu programmieren um die erstellte Schaltung als ech-te Hardware zu testen. Anschließend werden die Signallaufzeiten der einzelnen Moduleabgeschatzt und verwendet, um die maximal erreichbare Verschlusselungsgeschwindig-keit abschatzen zu konnen. Der Hauptaspekt dieses Praktikums ist die Schaltungsbe-schreibung und Simulation in VHDL.

2.3 Uberblick Kryptographie

Durch die geradezu explosionsartig ansteigende Zahl von Transaktionen, die uber dasInternet abgewickelt werden, gewinnen die Aspekte des Datenschutzes immer mehr anBedeutung. Es stellt sich vermehrt die Aufgabe, vertrauliche Daten uber ein unsiche-res Medium auszutauschen. Die Forderungen beschranken sich jedoch nicht nur auf denSchutz der Vertraulichkeit von Daten sondern auch auf die Sicherstellung der Integritat.Gerade bei Diensten wie Telebanking oder Online-Shopping sind auch Fragen der siche-ren Authentifizierung und der Gewahrleistung der Verbindlichkeit von Transaktionenvon existenzieller Bedeutung.

Die Bedeutung der kryptographischen Verfahren zeigt sich nicht zuletzt in der Vielzahlder verfugbaren Programme und der darin verwendeten Algorithmen. Anwendungen wieSecure Socket Layer, Secure Shell und PGP sind weithin bekannt.

Eine Aufgabe der Kryptographie ist, Klartext-Nachrichten so zu verschlusseln, daß sienur noch von einem bestimmten Personenkreis entschlusselt werden konnen. Ublicher-weise ist der Ver- und Entschlusselungsalgorithmus ebenso wie der Chiffretext offentlichbekannt. Wenn fur die Entschlusselung des Chiffretextes der gleiche Schlussel beno-tigt wird wie fur die Verschlusselung, spricht man von symmetrischer Verschlusselung(Abb. 2). Sind zwei unterschiedliche Schlussel notig, so handelt es sich um ein asymme-trisches Verfahren (Abb. 3).

Symmetrische Verfahren sind meist schneller als asymmetrische, bieten aber den Nach-teil, daß der Schlussel auf einem sicheren Kanal zu dem Empfanger ubertragen werdenmuss. Ist der Schlussel bekannt, so kann jeder den Chiffretext entschlusseln. Bei einemasymmetrischen Verfahren gibt es 2 Schlussel, wovon einer der geheime und der andereder offentliche ist. Will nun eine Person A einer Person B eine geheime Nachricht zusen-den, so benutzt Person A den offentlichen Schlussel von Person B um den Klartext zuverschlusseln. Person B kann den empfangenen Chiffretext mit dem eigenen geheimenSchlussel entschlusseln.

2.4 Aufgabenstellung 7

VerschlusselungChiffretext

EntschlusselungKlartextKlartext

geheimer Schlussel

Person A Person B

Abbildung 2: Symmetrische Verschlusselung

VerschlusselungChiffretext

EntschlusselungKlartextKlartext

offentlicher Schlussel B geheimer Schlussel B

Person BPerson A

Abbildung 3: Asymmetrische Verschlusselung

2.4 Aufgabenstellung

Ausgehend von einem Softwareprototypen in Java wird im Rahmen dieses Praktikumsder seit 1990 bekannte IDEA-Algorithmus [10] mit der HardwarebeschreibungsspracheVHDL implementiert und simuliert. Es handelt sich hierbei um einen symmetrischenVerschlusselungs-Algorithmus, d.h. es wird sowohl fur die Ver-, als auch fur die Ent-schlusselung der gleiche Schlussel benutzt. Bei diesem Algorithmus werden in einemDurchlauf 4 Klartextblocke zu je 16 Bit verschlusselt (Abb. 4). Insgesamt besteht derIDEA-Algorithmus aus 8 Verschlusselungsschritten (auch Runden genannt) mit anschlie-ßender Ausgabetransformation. Die benotigten Teilschlussel fur jede Runde und fur dieAusgabetransformation werden aus einem 128 Bit langen Schlussel erzeugt.

In jeder Runde (Abb. 5) werden folgende Module benotigt:

• Bitweise XOR-Verknupfung von 16 Bit langen Teilblocken

• Addition von 16-Bit-Zahlen modulo 216

• Multiplikation von 16-Bit-Zahlen modulo 216 + 1,wobei die Eingangsbelegung 0 durch 216 ersetzt wird

Die Variablen X(r)i , Y

(r)i und Z

(r)i sind jeweils 16 Bit breit. X

(r)i bezeichnet die Einga-

bedaten der Runde r, Y(r)i die Ausgabedaten und Z

(r)i die Teilschlussel aus dem Schlus-

selgenerator.

8 2 EINLEITUNG

Runde 8

Ausgabe Transformation

Chiffretext

Runde 2

Sch

luss

elge

ner

ator

Klartext

Runde 1

Schlussel

128

6*16

6*16

16

1616 16 16

161616

16 16 16

6*16

4*16

16 16 16 16

16161616

16 16 16 16

16

Abbildung 4: IDEA-Algorithmus

In der Ausgabetransformation (Abb. 6) werden folgende Module benotigt:

• Addition von 16-Bit-Zahlen modulo 216

• Multiplikation von 16-Bit-Zahlen modulo 216 + 1,wobei die Eingangsbelegung 0 durch 216 ersetzt wird

Der Schlusselgenerator erzeugt aus einem 128 Bit langen Eingabewert 52 Teilschlusselzu je 16 Bit. Fur die Verschlusselung wird der 128 Bit lange Eingabewert in 8 Blocke zuje 16 Bit aufgespalten, die als die ersten 8 Teilschlussel verwendet werden (Abb. 7).


Z(r)4

X(r)4

Z(r)3Z

(r)2

Z(r)5

Z(r)6

X(r)2 X

(r)3

Y(r)2 Y

(r)3

X(r)1

Y(r)1

Addierer

MultipliziererModulo-

XOR

Y(r)4

Z(r)1

Abbildung 5: Die Runde im IDEA-Algorithmus

Y(9)1 Y

(9)2 Y

(9)3 Y

(9)4

Z(9)2 Z

(9)3 Z

(9)4

X(9)4X

(9)3X

(9)2X

(9)1

Addierer

Modulo-Multiplizierer

Z(9)1

Abbildung 6: Die Ausgabetransformation im IDEA-Algorithmus

10 2 EINLEITUNG

Z(1)1 Z

(1)2 Z

(1)3 Z

(1)4 Z

(1)5 Z

(1)6 Z

(2)1 Z

(2)2

Z(2)3 Z

(2)4 Z

(2)5 Z

(2)6 Z

(3)1 Z

(3)2 Z

(3)3 Z

(3)4

25 Bits zyklisch schieben

10311862238547086102 119

Z(3)5 Z

(3)6 Z

(4)1 Z

(4)2 Z

(4)3 Z

(4)4 Z

(4)5 Z

(4)6


78931091251329456177 126





127 111 95 79 63 47 31 15 0

Teilschlussel

Grenze der 8 BlockeEingabeschlussels an derBitnummer desEingabeschlussel mit 128 Bit Lange

Abbildung 7: Erzeugung der Teilschlussel

Die Reihenfolge der Teilschlussel ist dabei wie folgt:

Z(1)1 , Z

(1)2 , . . . , Z

(1)6 , Z

(2)1 , . . . , Z

(2)6 , . . . , Z

(8)1 , . . . , Z

(8)6 , Z

(9)1 , Z

(9)2 , Z

(9)3 , Z

(9)4

Nach Entnahme der ersten 8 Teilschlussel wird der 128 Bit lange Eingabewert um 25Bit zyklisch nach links geschoben (rotiert) und wiederum in 8 Blocke aufgeteilt. Die

neuen Blocke werden fur die nachsten 8 Teilschlussel verwendet. (Dieses mal Z(2)3 , . . . ,

Z(2)6 , Z

(3)1 , . . . , Z

(3)4 .) Dieser Vorgang wird so lange wiederholt, bis alle 52 benotigten

Teilschlussel erzeugt sind.

Der IDEA-Algorithmus kann unverandert auch fur die Entschlusselung verwendet wer-den. Lediglich der Schlusselgenerator liefert andere Teilschlussel. Die Teilschlussel furdie Entschlusselung sind entweder das multiplikative oder das additive Inverse der Ver-schlusselungs-Teilschlussel in umgekehrter Reihenfolge. An dieser Stelle soll nicht naherauf die Erzeugung der Teilschlussel fur die Entschlusselung eingegangen werden.


Vorbereitung: ? 1

• Was zeichnet die Variablen X(1)i und Y

(9)i mit i ∈ {1 . . . 4} aus?

• Von welchen Ausgangen werden die Eingange X(r+1)i , r ∈ {1, . . . , 7}, ganz allge-

mein getrieben?

12 3 DIREKTER ALGORITHMUS

3 Direkter Algorithmus

Im Rahmen dieses Praktikums werden verschiedene arithmetische Module fur die Imple-mentierung des Chiffrierverfahrens benotigt. Diese sind zuerst auf algorithmischer Ebenezu erstellen, um moglichst fruhzeitig einen ersten Entwurf des kompletten Algorithmussimulieren zu konnen. Im Verlauf des Praktikums werden diese einfachen ersten Modelleweiter verfeinert und nach und nach in eine Beschreibung auf Register-Transfer-Ebeneumgesetzt, die auch die Signallaufzeiten der einzelnen Module modelliert. Ublicherweisewerden je Versuch 2 Dateien angelegt. Die erste Datei dient zur Beschreibung des jewei-ligen Moduls. In der zweiten Datei ist eine Testumgebung zu erstellen, um die Funktiondes jeweiligen Moduls durch Simulation zu uberprufen und sicherzustellen.

3.1 Beispiel: Inverter

Im Folgenden ist ein einfaches Beispiel zu realisieren: ein 1-Bit-Inverter samt zugehorigerTestumgebung. Anhand dieses Beispiels soll gezeigt werden, wie die EntwurfsumgebungXilinx R© ISE WebPackTM zum Eingeben und Simulieren des VHDL-Codes verwendetwird.

Zu Beginn wird ein neues Projekt angelegt. Die einzelnen Schritte sind in den Abbildun-gen 8 bis 12 dargestellt. Starten Sie die XilinxR© ISE WebPackTM mit dem Kommandostart_ise auf einer Konsole. Das Programm wird daraufhin geladen, und es erscheinteine leere Entwurfsumgebung, wie in Abbildung 8 gezeigt.

Abbildung 8: Entwurfsumgebung nach dem Start

3.1 Beispiel: Inverter 13

Abbildung 9: Anlegen eines neuen Projekts mit dem Wizard

Abbildung 10: Konfiguration des FPGAs sowie des Synthese- und Simulationswerkzeuges

Legen Sie nun ein neues Projekt an, indem Sie im Menu File den Punkt New Pro-

ject... wahlen oder drucken Sie hierzu die Schaltflache New Project.... Es erscheintder in Abbildung 9 dargestellte Wizard. Tragen Sie dort als Projektname idea einund wahlen Sie HDL als Top-level source type. Als Projektort geben Sie ein Unter-


Abbildung 11: Abschließende Zusammenfassung des Wizards

Abbildung 12: Entwurfsumgebung nach dem Anlegen des neuen Projekts

verzeichnis idea in Ihrem Heimatverzeichnis an. Diesen Pfad mussen Sie gemaß Ihres


Heimatverzeichnisses anpassen. Im anschließenden Schritt wird der zu programmierendeFPGA sowie der Simulator ausgewahlt. Geben Sie hier, wie in Abbildung 10 gezeigt, alsFamily

”Spartan3E“, als Device

”XC3S500E“, als Package

”FG320“, als Speed

”4“, als

Synthesis Tool”XST (VHDL/Verilog)“, als Simulator

”ISim (VHDL/Verilog)“ und

als Preferred Language”VHDL“ an.

Drucken Sie auf Next, um zur abschließenden Zusammenfassung (siehe Abbildung 11)zu gelangen. Mit einem Klick auf Finish wird das Projekt angelegt. Abbildung 12 zeigtdie Entwurfsumgebung nach dem Erstellen des Projekts.

Legen Sie nun eine neue Quellendatei an, indem Sie im Menu Project den PunktNew Source wahlen. Es erscheint das in Abbildung 13 gezeigte Fenster, in dem SieVHDL Module als Dateityp auswahlen. Geben Sie als Name der Datei inverter an.

Abbildung 13: Auswahl des Dateityps

Abbildung 14: Definition der Ein- und Ausgange des Moduls


Abbildung 15: Zusammenfassung der neuen Quellendatei

Im nachsten Schritt konnen die Ein- und Ausgange des VHDL-Moduls definiert werden.Erstellen Sie einen Eingang I sowie einen Ausgang O, wie dies in Abbildung 14 dargestelltist. Diese Einstellungen konnen spater im VHDL-Code jederzeit geandert werden. Miteinem Klick auf Next wird die Zusammenfassung der neuen Quellendatei gezeigt (sieheAbbildung 15).

Abbildung 16: Entwurfsumgebung nach dem Anlegen einer neuen Quellendatei


Der Wizard danach (siehe Abbildung 16) hat bereits eine erste Rohversion Ihres VHDL-Moduls anhand Ihrer Angaben erstellt. Erweitern Sie den Code um eine Zeile, die dasSignal I invertiert an das Signal O ubertragt. Der resultierende Code sollte anschließendso aussehen (ohne Kommentarzeilen):

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

entity inverter is

Port ( I : in STD_LOGIC;

O : out STD_LOGIC)

end inverter;

architecture Behavioral of inverter is

begin

O <= not I;

end Behavioral;

Abbildung 17: Erstellen der Testbench

Zum Testen des Inverters muss eine testbench generiert werden. Hierzu verwenden Sieim Menu Project den Eintrag New Source. Im anschließend erscheinenden DialogfensterNew Source Wizard wahlen Sie den Typ VHDL Test Bench und geben als Dateinametb_inverter an. Es empfiehlt sich, folgende Namenskonvention einzuhalten: Eine Test-bench zu einer VHDL-Datei wird so benannt, dass tb_ vor den Namen der zu testendenDatei gestellt wird. Abbildung 17 zeigt das entsprechende Dialogfenster.


Abbildung 18: Auswahl der zu testenden Datei

Nach einem Klick auf Next werden Sie aufgefordert, die zu testende VHDL-Datei auseiner Liste auszuwahlen. Diese Liste enthalt im Moment nur ein Element, den Inverter.Abbildung 18 zeigt das entsprechende Fenster.

Mit einem weiteren Klick auf Next gelangen Sie abschließend zu dem in Abbildung 19 ge-zeigten Fenster, das Sie mit einem Klick auf Finish quittieren. Xilinx R© ISE WebPackTM

generiert nun einen Rahmen fur die Testbench. Klicken Sie Simulation fur View. Abbil-dung 20 zeigt die IDE mit der neu hinzugefugten Testbench. Diese muss nun so editiertwerden, dass sie folgenden Code enthalt (ohne Kommentarzeilen):

LIBRARY ieee;

USE ieee.std_logic_1164.ALL;

USE ieee.std_logic_unsigned.all;

ENTITY tb_inverter IS

END tb_inverter;

ARCHITECTURE behavior OF tb_inverter IS

-- Component Declaration for the Unit Under Test (UUT)

COMPONENT inverter

PORT(

I : IN std_logic;

O : OUT std_logic

);

END COMPONENT;

--Inputs

signal I : std_logic := ’0’;


Abbildung 19: Abschließen der Testbench

--Outputs

signal O : std_logic;

constant I_period : time := 10 ns;

BEGIN

-- Instantiate the Unit Under Test (UUT)

uut: inverter PORT MAP (

I => I,

O => O

);

I_process : process

begin

I <= ’0’;

wait for I_period/2;

I <= ’1’;

wait for I_period/2;

end process;

END;

Die Testbench generiert ein oszillierendes Signal am Eingang I mit 100 MHz.

Selektieren Sie nun die Quelldatei tb_inverter. Im darunter liegenden Fenster werdennun alle Prozesse angezeigt, die mit dieser Datei gestartet werden konnen, wie in Ab-bildung 21 dargestellt. Dazu zahlt der Eintrag ISim Simulator. Dessen Unterpunktesind Behavioral Check Syntax und Simulate Behavioral Model. Es ist zu empfeh-len, nach jeder Veranderung des VHDL-Codes die Richtigkeit des Syntax durch einenDoppelklick auf Behavioral Check Syntax uberprufen zu lassen. Wirft diese Uberpru-fung keine Fehler auf, dann kann der Simulator mit einem Doppelklick auf Simulate Be-


Abbildung 20: Die IDE nach Erstellen der Testbench

Abbildung 21: Starten der Verhaltenssimulation

havioral Model gestartet werden. Der Start des Simulators kann einige Sekunden inAnspruch nehmen. Standardmaßig werden dabei die ersten 1000ns bereits simuliert.Abbildung 22 zeigt das Fenster mit gestartetem Simulator.


Abbildung 22: Gestarteter Simulator

Abbildung 23: Toolbar zur Steuerung des Simulators

Abbildung 24: Verfeinerte Zeitachse im Simulator

Normalerweise ist es notwendig, mehr als die ersten 1000ns zu simulieren. Zur Steuerungdes Simulators befindet sich die in Abbildung 23 gezeigte Toolbar im oberen Bereich derIDE. Dort konnen Sie die Simulationszeit eintragen und die Simulation neu starten. Siekonnen auch eventual die Zeitachse verfeinern und vergroßern oder auf volle Ansichteinstellen.


Verfeinern Sie nun die Zeitachse soweit, bis die einzelnen Signalverlaufe angezeigt wer-den, wie dies in Abbildung 24 dargestellt ist. Anhand der Signalverlaufe konnen Sie nundie korrekte Funktion Ihres Inverters uberprufen. Das Beispiel des Inverters ist selbst-verstandlich sehr trivial. Fur die nachfolgend zu erstellenden VHDL-Codes sei an dieserStelle erwahnt, dass diese Codes naturlich eine Vielzahl von Ein- und Ausgangssignalensowie interne Signale haben konnen. Standardmaßig werden aber nur die Ein- und Aus-gangssignale automatisch angezeigt. Interne Signale konnen sie anzeigen lassen, indemSie sie in der Liste im linken Teil der IDE in das schwarze Simulationsfenster per

”Drag-

and Drop“ ziehen. Die Simulation muss anschließend neu gestartet werden.

3.2 XOR-Modul

Im IDEA-Verfahren werden 48 XOR-Module fur die 16 Bit breiten Eingabe- und Ausga-beworte benotigt. Erstellen Sie ein XOR-Modul mit zwei Eingangs- und einem Ausgangs-vektor vom Typ std_logic_vector zu 16 Bit Breite samt zugehoriger Testumgebung.Gehen Sie dabei wie folgt vor:

• Erstellen Sie die VHDL-Datei xor.vhd.VHDL 1

• Erstellen Sie eine entity xorop, welche die Eingange und die Ausgange des XOR-Moduls beschreibt.

• Beschreiben Sie in einer architecture das Verhalten des XOR-Moduls im Rah-men eines process.

• Nach dem Speichern der Datei starten Sie den Prozess Check Syntax. KorrigierenSie eventuelle Fehler und starten Sie den Syntax-Check bei Bedarf erneut, bis erkeine weiteren Fehler mehr anzeigt.

Nachdem das XOR-Modul erstellt wurde, ist eine Testumgebung zu implementieren, dieunterschiedliche Eingangsmuster an das Modul anlegt. Durch Vergleich der Ausgabe-werte des XOR-Moduls mit den Sollwerten kann uberpruft werden, ob das XOR-Modulwie gewunscht funktioniert. Zur Implementierung der Testumgebung gehen Sie wie folgtvor:

• Erstellen Sie in einer VHDL-Testbench tb_xor.vhd eine entity tb_xorop. Ist esVHDL 2

notwendig, in der entity der Testumgebung Eingange oder Ausgange nach außenzu definieren?

• Erstellen Sie eine architecture behavior, in der Sie das XOR-Modul xorop alszu testendes VHDL-Modul angeben und damit als component einbinden sowieunterschiedliche Testsignale an den Eingangen des Moduls anlegen.

Nachdem Sie das XOR-Modul samt Testumgebung erfolgreich auf Syntax-Fehler uber-pruft haben, konnen Sie den Xilinx R© ISE Simulator wie im Beispiel des 1-Bit-Invertersstarten.

3.3 Addierer 23

3.3 Addierer

Weiterhin werden im IDEA-Algorithmus 34 Module benotigt, die eine 16-Bit-Additionmodulo 216 zur Verfugung stellen. In diesem Versuch soll ein Addierer-Modul erstelltwerden, das diese Funktionalitat bereitstellt. Bearbeiten Sie dabei folgende Punkte:

• Erstellen Sie ein VHDL-Modul addop.vhd mit einer entity addop mit Eingangen VHDL 3

und Ausgang vom Typ std_logic_vector

• Beschreiben Sie in einer architecture das Verhalten des Addierer-Moduls imRahmen eines process.

• Um eine + Operation durchzufuhren, mussen Sie entweder das PackageIEEE.std_logic_unsigned.all benutzen oder intern mit Variablen vom Typunsigned rechnen.

Wenn Sie das Addierer-Modul ubersetzt haben, erstellen Sie dafur eine Testumgebung:

• Erstellen Sie eine VHDL-Testbench tb_addop mit einer entity tb_addop. VHDL 4

• Erstellen Sie eine architecture behavior, in der Sie das Addierer-Modul addopals zu testendes VHDL-Modul angeben, womit es als component eingebunden wird.Legen Sie unterschiedliche Testsignale an den Eingangen des Moduls an. Uberpru-fen Sie insbesondere, wie sich der Addierer verhalt, wenn sich ein Uberlauf einstellt(d.h. das Ergebnis nicht mehr in 16 Bit gespeichert werden kann).

Uberprufen Sie das Addierer-Modul mit dem Simulator.

3.4 Modulo-Multiplizierer

Das komplexeste Modul im IDEA-Algorithmus ist der Modulo-Multiplizierer, der ins-gesamt 34 mal benotigt wird. Zwei 16-Bit-Eingangsvektoren werden hierzu miteinandermultipliziert, wobei eine Eingangsbelegung von 0 jeweils durch eine Belegung von 216 er-setzt wird. Das 33 Bit breite Ergebnis der Multiplikation wird modulo 216+1 genommenund danach auf 16 Bit begrenzt.

Bei einer getrennten Implementierung von Multiplikation und Modulo-Operation wur-den zwei sehr komplexe und damit in der Realisierung sehr teure Hardwaremodule ent-stehen. Weiterhin musste fur die Verbindung der Module ein 33 Bit breiter Datenpfadbereitgestellt werden. Als Alternative zur getrennten Realisierung von Multiplikations-Modul und Modulo-Modul bietet sich die Verwendung des Low-High-Algorithmus an,der die Multiplikation und die anschließende Modulo-Bildung mit einem einzigen, mo-difizierten Multiplizierer zulasst.


3.4.1 Der Low-High-Algorithmus

Seien a und b zwei ganze Zahlen aus der Menge {1, . . . , 2n}, dann gilt:

ab mod (2n + 1) =

{

(ab mod 2n) − (ab div 2n), (ab mod 2n) ≥ (ab div 2n)(ab mod 2n) − (ab div 2n) + 2n + 1, (ab mod 2n) < (ab div 2n)

(1)

wobei (ab div 2n) den ganzzahligen Anteil des Quotienten bezeichnet, wenn ab durch 2n

dividiert wird.

Vorbereitung:? 2

• Wie bestimmen sich a bzw. b aus den Eingabevektoren X(r)i und Z

(r)i des Modulo-

Multiplizierers?

• a und b seien im folgenden zwei ganze Zahlen aus {1, . . . , 2n}. Wieviele Bits werdenfur die binare Darstellung der Zahlen a und b und wieviele fur die Darstellung desProdukts ab maximal benotigt?

• Wie ist n fur den Modulo-Multiplizierer im IDEA-Algorithmus zu wahlen?

• Welche Bits des Produkts werden durch die modulo-2n-Bildung ausmaskiert, wel-che bleiben ubrig? Wieviele Bits werden benotigt, um das Ergebnis (ab mod 2n)darzustellen?

• Welcher einfachen Bit-Operation entspricht die Operation (ab div 2n). Welche Bitsdes Produktes ab bleiben ubrig? Wo befinden sich diese nach der Division? WievieleBits werden benotigt, um das Ergebnis darzustellen? Berucksichtigen Sie auch denFall, daß a und b den Wert 2n annehmen konnen.

• Welches Ergebnis ergibt sich fur (ab mod (2n+1)), wenn (ab mod 2n) = (ab div 2n)?Kann dieses Ergebnis auftreten, wenn a und b ganze Zahlen aus {1, . . . , 2n} sindund 2n + 1 eine Primzahl ist? Begrunden Sie Ihre Antwort.

Beweis: Unter der Voraussetzung, daß a und b ganze Zahlen aus {1, . . . , 2n} sind,existiert fur jedes a und b eine eindeutige Belegung fur die ganzen Zahlen q und p, sodaß gilt:

ab = q(2n + 1) + p,0 ≤ p < 2n + 10 ≤ q < 2n . (2)

Daraus lasst sich folgern: q + p < 2n+1 und p = ab mod (2n + 1).Weiterhin lasst sich durch Einsetzen von (2) zeigen1, daß

1Anmerkung: (q ∗ 2n) div 2n = q

(q ∗ 2n) mod 2n = 0

3.4 Modulo-Multiplizierer 25

(ab div 2n) =

{

q, q + p < 2n

q + 1, q + p ≥ 2n (3)

und

(ab mod 2n) =

{

q + p, q + p < 2n

q + p − 2n, q + p ≥ 2n . (4)

Aus Gleichung (3) und (4) folgt

p =

{

(ab mod 2n) − (ab div 2n), q + p < 2n

(ab mod 2n) − (ab div 2n) + 2n + 1, q + p ≥ 2n , (5)

wobei q + p genau dann kleiner 2n ist, wenn (ab mod 2n) ≥ (ab div 2n).Dies ergibt sich aus Gleichung (5), da nach (2) immer p ≥ 0 gilt.

3.4.2 Implementierung Modulo-Multiplizierer

Erstellen Sie einen Multiplizierer mit integrierter modulo-216 + 1-Operation unter Ver-wendung des Low-High-Algorithmus. Beachten Sie dabei folgende Punkte:

• Erstellen Sie ein VHDL-Modul mulop.vhd mit einer entity mulop mit Eingangen VHDL 5

und Ausgang vom Typ std_logic_vector.

• Beschreiben Sie in einer architecture das Verhalten des Modulo-Multiplizierer-Moduls im Rahmen eines process. Beachten Sie dabei, daß eine Eingangsbelegungvon 0 durch 216 ersetzt wird. Wie viele Bit werden benotigt, um 216 darzustellen?Welches Ergebnis muss sich einstellen, wenn an einem bzw. an beiden Eingangeneine 0 anliegt?

• Beachten Sie bei Zuweisungen, daß die Variablen jeweils die gleiche Bitbreite ha-ben. Bei der Multiplikation hat das Ergebnis die doppelte Bitbreite.

• Hinweis: Mit dem & Operator konnen Sie Bitvektoren aneinander hangen. Benut-zen Sie das VHDL-Konstrukt zur Bereichseinschrankung, um in einem Vektor diejeweiligen Bits auszuwahlen. Beispiel: a := b (7 downto 4)

• Initialisieren Sie alle Signale und Variablen.


Erstellen Sie eine Testumgebung:

• Erstellen Sie eine VHDL-Testbench tb_mulop.vhd mit einer entity tb_mulop.VHDL 6

• Erstellen Sie eine architecture behavior in der Sie das Multiplizierer-Modulmulop als zu testendes Modul auswahlen und somit als component einbinden.Legen Sie unterschiedliche Testsignale an den Eingangen des Moduls an.

• Uberprufen Sie insbesondere, wie sich der Multiplizierer verhalt, wenn an einemEingang bzw. wenn an beiden Eingangen die Belegung 0 anliegt.

Uberprufen Sie das Multiplizierer-Modul mit dem Simulator.

3.5 Rundenmodul

Fur einen Ver- bzw. Entschlusselungsvorgang werden im IDEA-Algorithmus 8 Run-denmodule benotigt. Erstellen Sie ein Rundenmodul wie in Abbildung 5 auf Seite 9.Verwenden Sie dazu die bereits erstellten arithmetischen Grundmodule. Beachten Siefolgende Punkte:

• Erstellen Sie ein VHDL-Modul round.vhd mit einer entity round, welche dieVHDL 7

6 Teilschlussel und die Eingabe- und Ausgabedaten in Form von jeweils 16 Bitbreiten std_logic_vector Signalen verarbeitet.

• Erstellen Sie eine architecture und binden Sie die Module xorop, addop undmulop als component ein.

Erstellen Sie eine Testumgebung und uberprufen Sie fur mehrere Eingabebelegungen, obVHDL 8

die Ergebnisse mit den Sollwerten ubereinstimmen. (Sie konnen in der Online-Prakti-kumsoberflache den Punkt Referenzmodell anwahlen und mit der schematischen Dar-stellung Sollwerte berechnen.)

3.6 Ausgabetransformation

Weiterhin wird im IDEA-Algorithmus eine Ausgabetransformation benotigt. ErstellenSie ein Modul, das die Ausgabetransformation wie in Abbildung 6, Seite 9 realisiert.Beachten Sie die folgenden Punkte:

• Erstellen Sie ein VHDL-Modul trafo.vhd mit einer entity trafo, welche die 4VHDL 9

Teilschlussel und die entsprechenden Eingabe- und Ausgabedaten in Form von 16Bit breiten std_logic_vector Signalen verarbeitet.

• Binden Sie in der architecture die Module addop und mulop als component ein.

• Erzeugen Sie die benotigten Modulinstanzen und verbinden Sie diese.

Erstellen Sie eine Testumgebung und uberprufen Sie fur mehrere Eingabebelegungen,VHDL 10

ob die Ergebnisse mit den Sollwerten ubereinstimmen.

3.7 Verschlusselung 27

3.7 Verschlusselung

Nachdem alle benotigten Module fur die Verschlusselung vorhanden sind, soll in diesemVersuch eine erste simulierbare Implementierung des Verschlusselungsvorgangs fur einenfesten Schlussel erstellt werden. Gehen Sie dabei wie folgt vor:

• Erstellen Sie ein VHDL-Modul namens idea.vhd. Binden Sie die Module round VHDL 11

und trafo als component ein.

• Erzeugen Sie die benotigten Modulinstanzen und verbinden Sie diese.

• Definieren Sie ein Eingangssignal key als Schlussel. Verbinden Sie die erzeugtenTeilschlussel mit den entsprechenden Eingangen der Rundenmodule und der Aus-gabetransformation.

• Uberprufen Sie das Ergebnis Ihrer Verschlusselung mit den Werten, die das Refe-renzmodell berechnet.

28 4 HARDWARENAHE IMPLEMENTIERUNG

4 Hardwarenahe Implementierung

Nachdem im vorangegangenen Teil des Praktikums eine erste simulierbare Implementie-rung des IDEA-Algorithmus entstanden ist, soll in diesem Abschnitt eine Beschreibungerstellt werden, die auf einem FPGA-Chip realisiert werden kann. Anwenderprogram-mierbare Gate Arrays (FPGAs2) gewinnen heute gegenuber klassischen ASICs immermehr an Bedeutung. FPGAs sind sogenannte Semicustom Chips, die es dem Anwenderermoglichen, in sehr kurzer Zeit komplexe Systeme zu entwickeln und auch nachtraglichnoch Anderungen daran vorzunehmen. So wird neben der kurzeren Fertigungszeit aucheine Einzelfertigung finanziell erschwinglich. Das Spektrum der realisierbaren Applika-tionen reicht dabei von schlichten Logikschaltungen wie Zahler, Addierer und Dekodiererbis hin zu umfangreichen Prozessoren. Eine besonders verbreitete Architekturform sindWertetabellen-basierte FPGAs, wie z.B. die Spartan 3E-Typen der Firma Xilinx. EinChip aus dieser Baureihe (XC3S500E) befindet sich auf dem Testboard, das Ihnen furdas Praktikum zur Verfugung steht.

Switch Matrix

I/O Pad

Logic BlockConfigurable

ResourcenVerdrahtungs

Abbildung 25: Aufbau eines Xilinx-FPGA

Wie aus Abbildung 25 zu ersehen ist, bestehen Xilinx-FPGAs aus einer schachbrett-artigen Anordnung von Logikblocken, auch CLBs3 genannt, und Switching Elementen.Weiterhin sind noch I/O-Pads zur Einspeisung externer, bzw. zum Abgreifen internerSignale vorhanden. Mit Hilfe der Switching Elemente und der Verdrahtungsressourcenkonnen die Logikblocke untereinander, als auch mit den I/O-Pads verbunden werden.

Die CLBs selbst bestehen im Wesentlichen aus vier Slices, insgesamt aus acht StatischenRAM4-Bausteinen, von denen jeder eine beliebige kombinatorische Funktion mit maxi-mal 4 Eingangsvariablen in Form einer Look-Up Tabelle (LUT) realisiert. In dieser

2Field-Programmable Gate Array3Configurable Logic Block4Random Access Memory

29

Look-Up Tabelle ist jeder Eingangsbelegung ein Ergebniswert zugeordnet. Um eine be-stimmte kombinatorische Funktion zu programmieren mussen lediglich 16 Bit — das istdie Zahl der moglichen Eingangsbelegungen — in den SRAM-Baustein geladen werden.

Zur Verdrahtung dienen folgende Leitungstypen, die mittels der bereits erwahnten Swit-ching Elemente auch untereinander verbunden werden konnen:

• Direct Connects verbinden benachbarte CLBs.

• Single Length Lines verbinden benachbarte Switching Elemente.

• Double Length Lines verbinden jedes zweite Switching Element einer Spalte bzw.einer Zeile

• Quad Length Lines verbinden jedes vierte Switching Element einer Spalte bzw.einer Zeile.

• Long Lines erstrecken sich uber die gesamte Lange bzw. Breite des FPGA-Bausteins.

Um einen FPGA zu programmieren, mussen zum einen die Logikblocke und zum anderenauch die Switching Elemente konfiguriert werden.

Fur die Implementierung des IDEA-Algorithmus soll die bisherige Beschreibung so an-gepasst werden, dass der Algorithmus auf einem FPGA der Firma Xilinx vom TypXC3S500E-FG320 realisiert werden kann. Dieser FPGA stellt 1.164 Logikblocke (CLBs)und damit 9.312 LUTs zur Verfugung, auf die uber maximal 232 Eingabe- bzw. Ausga-bepins zugegriffen werden kann. Weiterhin sind auf dem FPGA 9.312 FlipFlops, 74.496Bits S-RAM und 20 Hardware-Multiplizierer verfugbar. In Tabelle 1 ist aufgefuhrt wieviele Ressourcen die elementaren Module des IDEA-Algorithmus in etwa benotigen. Furden Modulo-Multiplizierer gibt es dabei zwei Alternativen. Entweder wird als erste Al-ternative einer der 20 Hardware-Multiplizierer verwendet, oder die Multiplikation mussmit Hilfe von LUTs in CLBs als zweite Alternative realisiert werden.

Modul LUTs FlipFlops Hardware-Multiplizierer

XOR 16 0 0Addierer 16 0 0Modulo-Multiplizierer 1 106 0 1Modulo-Multiplizierer 2 390 0 0

Tabelle 1: Ressourcenbedarf der IDEA-Grundmodule

Unter Design-Flow versteht man den ganzen Entwurfsprozess, wonach ein lauffahigesDesign fur einen FPGA entsteht. Wesentliche Schritte dieses Prozesses sind in ISE soangeordnet (wie in Abbildung 26 dargestellt), dass sie nacheinander aufgerufen werdensollen.


Abbildung 26: Design-Flow

Nachdem man den Code z.B. in VHDL geschrieben hat, soll man zuerst den Codesynthetisieren, damit eine Netzliste aus logischen Elementen entsteht. Diese Netzlisteist unabhangig von einer bestimmten FPGA-Technologie. Der Begriff SSyntheseıst hiereigentlich die Logiksyntheseım normalen Sprachgebrauch.

Nach der Synthese wird das Design implementiert. Hier hat der Begriff”Implementie-

rung“ von Xilinx die ahnliche Bedeutung wie”Layoutsynthese“. In diesem Schritt sind

drei Teilschritte enthalten, die im Folgenden erklart werden:

• TRANSLATE: In diesem Teilschritt wird die technologieunabhangige Netzli-ste von der Synthese in eine sogenannte

”Xilinx Native Generic Database (NGD)“

Datei umgewandelt, wobei die logische Beschreibung des Entwurfs, z.B. von Gat-tern, sowie die ursprungliche Entwurfshierarchie enthalten sind. Man kann die indiesem Schritt generierte Datei als eine neue spezifisch auf Xilinx-FPGA bezogeneNetzliste verstehen.

• MAP: In diesem Schritt werden die logischen Elemente, z.B. NAND-Gatter, denKomponenten einer bestimmten FPGA-Zieltechnologie, z.B. LUTs, zugeordnet.

• PLACE & ROUTE: In diesem Schritt wird der Entwurf platziert und verdrah-tet.

Nach der Implementierung sind alle Informationen uber den Entwurf, bezogen auf ei-ne bestimmte FPGA-Zieltechnologie vorhanden. Eine sogenannte Bitstream-Datei wird

4.1 Synthese und Implementierung des direkten Algorithmus 31

dann generiert, um den FPGA zu programmieren. Diese Datei wird mithilfe des ToolsXilinx R© iMPACTTM auf den FPGA geladen.

Nahere Informationen finden Sie im”Development System Reference Guide“, das von

der Online-Praktikumsoberflache heruntergeladen werden kann.

4.1 Synthese und Implementierung des direkten Algorithmus

Wenn die Simulation des VHDL-Moduls idea.vhd erfolgreich abgeschlossen wurde, kon-nen Sie versuchen, dieses Modul nun zu synthetisieren. Bei der Synthese wird der VHDL-Code so ubersetzt, dass alle darin definierten Schaltkreise auf einem FPGA realisiertwerden konnen. Allerdings sind die Ressourcen des FPGAs beschrankt.

• Synthetisieren Sie das VHDL-Modul idea.vhd. Starten Sie dazu den Prozess VHDL 12

Synthesize - XST und anschließend den Prozess Map.

• Kann die Schaltung in ihrer jetzigen Form synthetisiert bzw. implementiert wer-den? Wenn nein, welche Ressource verhindert die Synthese bzw. die Implementie-rung? Hinweis: Starten Sie den Prozess View Design Summary. Dort wird Ihnenein Uberblick uber den Ressourcenverbrauch angezeigt.

Bei einer Implementierung der bisherigen Beschreibung mit insgesamt 48 XOR-Modulen(768 LUTs), 34 Addierern (544 LUTs) und ebenso vielen Modulo-Multiplizierern (3.604LUTs + 34 Hardware-Multiplizierer) wurden insgesamt etwa 4916 LUTs benotigt wer-den. Es sind zwar nominell ausreichend LUTs vorhanden, jedoch reichen die Hardware-Multiplizierer nicht aus, um das Design zu implementieren. Werden die verbleibenden 14Multiplizierer mit LUTs realisiert, so benotigt man insgesamt 8.892 LUTs. Der FPGAware damit zu uber 95% ausgelastet. Hinzu kommt noch der Schlusselgenerator, der auseinem Eingangsvektor mit einer Breite von 128 Bit insgesamt 52 Teilschlussel mit je16 Bit erzeugt. Dies ubersteigt dann sowohl die Anzahl der verfugbaren LUTs als auchdie verfugbaren Verdrahtungsressourcen. Der vorliegende direkte IDEA-Algorithmus istdaher nicht implementierbar.

Es ist also notwendig, die Beschreibung dahingehend abzuandern, dass sie weniger CLBsbzw. Multiplizierer benotigt und auf der Zielarchitektur realisiert werden kann.

Da der Modulo-Multiplizierer das mit Abstand großte Modul ist und daruber hinauseinen nur in geringer Zahl verfugbaren (20) Hardware-Multiplizierer verwendet, liegt esnahe, eine Beschreibungsform zu erstellen, die moglichst wenige Modulo-Multipliziererbenotigt. Deshalb wird im folgenden die Schaltung auf zwei verschiedene Arten veran-dert: Erst wird in Abschnitt 4.2 eine Schaltung erstellt, die nur noch ein Rundenmodulund eine Ausgabetransformation benotigt. Anschließend wird in Abschnitt 4.3 ein Run-denmodul erstellt, das nur noch einen Modulo-Multiplizierer benotigt. Spater wird dieseseine Modul verwendet, um alle 8 Rundenberechnungen und die Ausgabetransformationdurchzufuhren.


4.2 Resource Constrained Scheduling I

Schlussel

128

Rundenmodul

Klartext

6*16

16 161616

16 16 16 16

1616 16 16

0 1 0 1 0 1 0 1

Ausgabe Transformation

Chiffretext

4*16

16 16 16 16

161616 16

Sch

luss

elge

ner

ator

S

EnableRound4

Kontrolleinheit

ReadyStart

R1 R2 R3 R4

Abbildung 27: Die geanderte Schaltung mit nur noch einem Rundenmodul

Als ersten Schritt hin zu einer implementierbaren Schaltung soll nun die Schaltung soabgeandert werden, dass nur noch eine einzelne Runde sowie die Ausgangstransformationrealisiert werden mussen. Da alle Rundenmodule baugleich sind, ist es moglich, dieAusgange jedes Rundenmoduls in Registern zu speichern, und die gespeicherten Werteim nachsten Schritt wieder als Eingange zu verwenden. Nach 8 Runden werden diegespeicherten Werte dann der Augabetransformation ubergeben. Dieser Ablauf muss voneiner Kontrolleinheit gesteuert werden. Abbildung 27 zeigt die geanderte Schaltung, diemit nur noch einer Runde und einer Ausgabetransformation auskommt. Diese Aufteilungeiner Schaltung in Teilschritte mit einer vorgegebenen Menge an Ressourcen wird alsRessource Constrained Scheduling bezeichnet. Die Mehrfachverwendung von Modulenfur mehrere Berechnungen nennt man dabei Resource Sharing.

Die Kontrolleinheit und die geanderte Schaltung sollen nun implementiert werden. Da-zu sollen zuerst das Register, ein 2-zu-1 Multiplexer und ein neuer Schlusselgeneratorentworfen werden.

4.2 Resource Constrained Scheduling I 33

4.2.1 16-Bit-Register

Erstellen Sie eine Beschreibung fur ein 16-Bit-Register mit einem Clock- und Enable- VHDL 13

Eingang vom Typ std_logic sowie je einem 16 Bit breiten Ein- und Ausgang vom Typstd_logic_vector. Das Register soll, wenn das Enable-Signal gesetzt ist, bei einer stei-genden Taktflanke den Eingangswert ubernehmen und auf den Ausgang durchschalten.

pegelgesteuertes Register (Latch) taktflankengesteuertes Register

process (Clock, D, ENABLE)

begin

if (Clock=’1’) then

if (ENABLE=’1’) then

Q <= D;

end if;

end if;

end process;

process (Clock)

begin

if (Clock=’1’ and Clock’EVENT ) then

if (ENABLE=’1’) then

Q <= D;

end if;

end if;

end process;

Hinweis: Durch die Aufnahme des Clock-Signals in der sensitivity-list einesprocess konnen Sie sicherstellen, dass der process nur bei einer Signalwertanderung,d.h. in diesem Fall einer Taktflanke ausgefuhrt wird. Sie mussen dann noch uberpru-fen, ob es sich um eine steigende Flanke handelt, indem Sie den aktuellen Wert desClock-Signals abfragen. Bei einer steigenden Flanke muss dieser ’1’ sein. Um auch beider Synthese ein taktflankengesteuertes und nicht pegelgesteuertes Register zu erhalten,muss neben der Uberprufung des Clock-Signals auf ’1’ noch einmal eine Uberprufungauf ein Clock’EVENT durchgefuhrt werden. Fur die Simulation alleine ware dies nichtnotwendig, da der process in der Simulation nur dann ausgefuhrt wird, wenn sich dieSignale in der sensitivity-list andern.

Uberprufen Sie die korrekte Funktionsweise des Registers, indem Sie eine Testumgebung VHDL 14

erstellen und diese simulieren.

4.2.2 2-zu-1 Multiplexer

Erstellen Sie eine Beschreibung fur einen 2-zu-1 Multiplexer mit einem 1 Bit breiten VHDL 15

Steuereingang S vom Typ std_logic anhand dessen einer der beiden 16 Bit Eingangevom Typ std_logic_vector auf den 16 Bit breiten Ausgang geschaltet wird. Verwen-den Sie die case-Anweisung zur Realisierung des Multiplexers. Beachten Sie, dass beiVerwendung von case alle moglichen Signalwerte abgefragt werden mussen. Wenn S un-definierte Signalwerte fuhrt, so sollen die einzelnen Bits des Ausgangs jeweils den Wert Xerhalten. (Hilfreich ist dazu das Konstrukt when others.) Uberprufen Sie durch Simula-tion insbesondere das Verhalten des Multiplexers, wenn sich bei konstantem Steuerein-gang ein Eingangssignal andert.


4.2.3 Schlusselgenerator

Fur den Aufbau des kompletten Verschlusselungsalgorithmus wird neben den 8 Runden-berechnungen und der Ausgabetransformation auch ein Schlusselgenerator benotigt. Dazur Realisierung des Algorithmus nur ein erweitertes Rundenmodul zur Berechnung aller8 Runden und der Ausgabetransformation verwendet werden kann, ist es sinnvoll denSchlusselgenerator so zu implementieren, dass er abhangig vom 128 Bit breiten Einga-beschlussel und der gerade durchzufuhrenden Operation nur die gerade benotigten Teil-schlussel erzeugt. Der Schlusselgenerator wird durch einen Rundenzahler angesteuert. Jenach Belegung des 4 Bit breiten Ausgangs des Rundenzahlers sollen die entsprechendenBits im 128 Bit breiten Eingabeschlussel angewahlt und somit die 6 Teilschlussel zu 16Bit erzeugt werden. Dabei soll die Belegung "0000" die Schlussel fur die erste Run-de anwahlen, "0001" die Schlussel fur die zweite Runde usw. "1000" soll die Schlusselfur die Ausgabetransformation berechnen. Die genaue Vorschrift fur die Erzeugung derTeilschlussel wurde bereits auf der Seite 8 vorgestellt.

Implementieren Sie den Schlusselgenerator mit einem 128-Bit-Eingang fur den Eingabe-VHDL 16

schlussel, einem 4-Bit-Eingang fur die Auswahl der Berechnungsvorschrift fur die Teil-schlussel entsprechend der aktuellen Runde ("0000" bis "0111" fur die Runde 1 bis 8,"1000" fur die Ausgabetransformation) und 6 Ausgangen fur die 16 Bit breiten Teil-schlussel.

Der 128-Bit-Eingabeschlussel ist mit dem hexadezimalen Wert0001 0002 0003 0004 0005 0006 0007 0008 vorbelegt. Uberprufen Sie durch Simulati-on die erzeugten Teilschlussel fur alle 8 Runden und die Ausgabetransformation mitdenen des Referenzmodells.

4.2.4 Kontrolleinheit

Zur Steuerung des Datenpfades muss eine Kontrolleinheit geschaffen werden. BeachtenSie dabei folgende Punkte:

• Erstellen Sie ein VHDL-Modul control.vhd mit einer entity control. EingangeVHDL 17

sind die Signale fur Clock und Start, die die Kontrolleinheit steuern. Ausgangeder Kontrolleinheit sollen die Signale Round, Ready, Enable und S sein. Liegt amSignal Start der Wert 1 an wenn die Clock von 0 auf 1 wechselt, dann soll dieVerschlusselung gestartet werden und das Signal Ready auf 0 gesetzt werden. Istdie Verschlusselung beendet, soll das Signal Ready auf 1 gehen. Das Signal Enablesteuert die Register, S steuert die Multiplexer.

• Beschreiben Sie in einer architecture das Verhalten der Kontrolleinheit im Rah-men eines process. Die Kontrolleinheit muss das Rundenmodul acht mal ver-wenden, anschließend muss das Modul fur die Ausgabetransformation verwendetwerden. Das Signal Round wird dazu verwendet, die zugehorigen Teilschlussel zuerzeugen. Die Kontrolleinheit liefert daruber hinaus Steuersignale fur die Registerund die Multiplexer. Abbildung 28 beschreibt das Verhalten der Kontrolleinheit.


Clock

Start

Ready

S

Enable

0000 0001 0010 0011 0100 0101 0110 0111Round 10001000

Abbildung 28: Verhalten der Kontrolleinheit


• Erstellen Sie eine Testumgebung tb_control und uberprufen Sie die Kontrollein-heit.

4.2.5 Der neue IDEA-Algorithmus - Resource Constrained Scheduling I

Beachten Sie folgende Punkte:

• Erstellen Sie ein VHDL-Modul idea_single.vhd mit einer entity idea_single. VHDL 18

Die Eingange und Ausgange sollen mit denen des zuvor erstellten VHDL-Modulsidea.vhd ubereinstimmen. Lediglich Signale fur Clock, Start und Ready, die dieKontrolleinheit steuern, mussen hinzugefugt werden.

• Binden Sie sowohl das Rundenmodul als auch die Ausgabetransformation alscomponent ein.

• Erzeugen Sie aus dem Signal Round die richtigen Teilschlussel fur die Runde unddie Ausgabetransformation.


• Erstellen Sie eine Testumgebung tb_idea_single. Am Ende der Berechnungenmuss das Resultat mit dem direkten Algorithmus aus idea.vhd identisch sein.


4.2.6 Bindeglied zur Außenwelt - UART

Das VHDL-Modul idea_single.vhd ist zum jetzigen Zeitpunkt fur den FPGA am Prak-tikumsboard implementierbar. Um den Algorithmus nun erstmals mit echter Hardwarezu testen, muss noch ein Interface geschaffen werden, das Daten von einem PC emp-fangt, die Verschlusselung startet und anschließend die verschlusselten Daten wieder anden PC sendet. Als Interface wurde wegen seiner Einfachheit der EIA-232-Standard5

gewahlt. Auf dem FPGA ist dabei ein sogenannter UART6 notwendig. Auf der Prak-tikumsoberflache im Internet finden Sie hierfur die benotigten VHDL-Dateien, die sieeinbinden mussen (wahlweise in Paketen als .tar.gz-Datei oder als .zip-Datei):

• Die Datei clk_div.vhd dient zur Taktgenerierung fur den UART.

• rxcver.vhd ist der Empfangsteil des UART.

• txmit.vhd ist der Sendeteil des UART.

• Die Datei uart.vhd stellt den eigentlichen UART dar und verwendet die Dateienrxcver.vhd und txmit.vhd.

• idea_com_inner.vhd brindet den UART und den hardwarenahen IDEA-Algortihmuszusammen. Diese Datei mussen Sie an Ihre Definition des IDEA-Algorithmus an-passen.

• In idea_com.vhd sind sowohl der Taktgenerator als auch das Modul idea_com_inner.vhdeingebunden. Diese Datei muss als

”Top module“ gesetzt werden. Klicken Sie dazu

mit der rechten Maustaste auf das eingebundene Modul idea_com.vhd und wahlenSie in dem Pop-up Menu den Punkt

”Set as top module“.

Um dem Synthesewerkzeug mitzuteilen, wie die Ein- und Ausgange des Top-Level-Entities mit den Anschlussen des FPGAs zu verbinden sind, muss ein User Cons-

traint File (Dateiendung ucf) erstellt werden. Fugen Sie dazu fur Ihr aktuelles Top-Level-Modul eine neue Quellendatei hinzu, wobei der Datei-Typ Implementation Cons-

traints File ausgewahlt werden soll. Wahlen Sie im Processes-Fenster User Cons-

traints/Edit Constraints(Text). Nun konnen sie die Datei editieren. Eine Verbin-dung zwischen einem Ein- beziehungsweise Ausgang der Entity und einem Anschlusspindes FPGAs kann dort mit dem

”Pin Assignment“-Kommando LOC hergestellt werden:

NET "<port_name>" LOC=<pin_location>;

Der Name des Ein- oder Ausganges wird dabei als port_name bezeichnet, pin_locationsteht fur den Namen des Anschlusspins. Das im Praktikum verwendete Board besitzt

5Siehe dazu http://de.wikipedia.org/wiki/EIA-2326Universal Asynchronous Receiver and Transmitter, siehe http://de.wikipedia.org/wiki/UART

http://de.wikipedia.org/wiki/EIA-232

http://de.wikipedia.org/wiki/UART


eine serielle Schnittstelle. Der FPGA-Pin R7 ist mit RxD, der FPGA-Pin M14 mit TxD ver-bunden7. Nahere Informationen hierzu bietet Ihnen die Online-Hilfe unter dem StichwortUCF beziehungsweise die Dokumentation des Praktikumsboards.

Abbildung 29: Optionen beim Offnen von Xilinx R© iMPACTTM

Abbildung 30: Die erkannten Chips in der JTAG-Kette

• Erstellen Sie alle”Pin Assignment“-Kommandos in der UCF-Datei. Hinweis: Auf VHDL 19

dem Praktikumsboard ist ein Taktgenerator integriert. Dieser liefert ein Signal miteiner Frequenz von 50MHz. Es liegt am FPGA-Pin C9 an. Eine Template-Dateiidea_hw.ucf steht auch zur Verfugung.

7Die Namen der entsprechenden FPGA-Pins sind neben vielen Bauteilen des Praktikumsboards aufdie Platine aufgedruckt. Die LED LD0 ist beispielsweise mit dem FPGA-Pin F12 verbunden.


• Wahlen Sie den Punkt Generate Programming File. Damit wird ein Bitstromerzeugt, der zur Programmierung des FPGAs verwendet wird. Außerdem wird dasProgramm Xilinx R© iMPACTTM gestartet, mit dem der Bitstrom ubertragen wird.

• Programmieren Sie nun den FPGA. Stecken Sie dafur das Praktikumsboard uberdas USB-Kabel an Ihren PC an. H inweis: Da das Praktikumsboard bei der Regi-strierung als USB-Gerat einen gewissen Stromverbrauch angibt, ist es nicht mog-lich, das Board an einem sogenannten

”Bus-powered“ Hub anzustecken. Stecken

Sie das Board daher immer direkt an Ihren PC an. Warten Sie nun, bis der PCdie Firmware zur Programmierung des FPGA auf das Praktikumsboard geladenhat. Ist die Firmware bereit, so beginnt eine grune LED neben der USB-Buchsedes Praktikumsboards zu leuchten.

• Wahlen Sie anschließend den Eintrag”Manage Configuration Project (iMPACT)“

aus dem Processes-Fenster (siehe Abbildung 26). Hiermit wird Xilinx R© iMPACTTM

gestartet. Wahlen Sie nun”Boundary-Scan (JTAG)“ und dann

”Initilize Chain“,

wie in Abbildung 29 gezeigt. Das Programm sucht dann automatisch nach ange-schlossenen FPGAs. Verlauft die Suche erfolgreich, dann werden Ihnen drei Chipsangezeigt, die am Praktikumsboard vorhanden sind und uber Xilinx R© iMPACTTM

programmiert werden konnen (siehe Abbildung 30). Der erste Chip ist der FPGA,der in diesem Praktikum verwendet wird. Er soll hier direkt vom PC aus pro-grammiert werden. Da der FPGA keinen nichtfluchtigen Speicher enthalt, gehtdas Programm bei einem Reset wieder verloren. Der zweite Chip ist ein Platform-Flash-Speicher, der ein Programm dauerhaft speichern kann. Dieser wird in diesemPraktikum aber nicht verwendet. (Darin ist nur ein Test-Programm abgelegt, daszur Uberprufung des Praktikumsboards dient. Dieses Testprogramm wird jedesmal, wenn Sie das Praktikumsboard neu einstecken, automatisch in den FPGAgeladen.) Der dritte Chip kommt im Praktikum nicht zum Einsatz.

• Sie werden nun von Xilinx R© iMPACTTM aufgefordert, die Dateien anzugeben, diein die jeweiligen Chips geschrieben werden sollen. Fur den ersten Chip wahlenSie bitte die .bit-Datei, die in Ihrem Projektverzeichnis liegt. Fur die restlichenbeiden Chips ist keine Programmierung erforderlich, wahlen Sie daher bei diesenChips

”Bypass“.

• Klicken Sie nun mit der rechten Maustaste auf den ersten Chip. Es erscheint einPop-up-Menu. Wahlen Sie darin

”Program“ und anschließend

”OK“. Der FPGA

wird daraufhin programmiert. Am Ende sollte die Meldung”Program Succeeded“

ausgegeben werden.

• Testen Sie den Algorithmus nun mit der Software ideaTester, die am Lehrstuhlinstalliert ist und Ihnen online zum Download zur Verfugung steht. Diese Softwareschickt Daten zur Verschlusselung an den FPGA. Sie empfangt die vom FPGAgesendeten Daten und uberpruft, ob die Verschlusselung korrekt ist. Abbildung 31zeigt das Programmfenster.

4.3 Resource Constrained Scheduling II 39

Abbildung 31: Das Testprogramm

4.3 Resource Constrained Scheduling II

X(r)4

Z(r)3

X(r)2 X

(r)3X

(r)1

Z(r)5

Addierer

MultipliziererModulo-

XOR

Y(r)4

Z(r)6

Y(r)2 Y

(r)3Y

(r)1

R Register

R8R7

R6 R4

R5R1

Z(r)2 Z

(r)4

Tei

lsch

ritt

0Tei

lsch

ritt

1Tei

lsch

ritt

2Tei

lsch

ritt

3

Z(r)1

R3

R2

Abbildung 32: Aufteilung der Runde in 4 Teilschritte


0 1 2 3 0 1 2 3

0 1 2 3 0 1 2 3

X(r)1 X

(r)4 Z

(r)1 Z

(r)4Z

(r)5 Z

(r)6 R5 R8

S S

X(r)3 X

(r)2 Z

(r)3 Z

(r)2R6 R7

S S

Y(r)2

R4

Y(r)4Y

(r)3

R1

Y(r)1

R3 R2

Abbildung 33: Datenpfad des Rundenmoduls

Die im vorangegangenen Kapitel erstellte Schaltung ist zwar implementierbar, sie be-notigt aber immer noch einen großen Teil der Ressourcen des FPGAs. Haufig wird aufeinem FPGA aber nicht nur eine einzelne Funktion realisiert, sondern auch komplexeSchaltungen wie Prozessoren integriert. In diesem Kapitel wird angenommen, dass derIDEA-Algorithmus als Hardwarebeschleuniger fur einen ebenfalls auf dem FPGA zu syn-thetisierenden RISC-Prozessor entworfen werden soll. Dabei soll der IDEA-Algorithmusnicht mehr als 5% (etwa 465 LUTs) der Ressourcen des FPGA verbrauchen durfen.

In diesem Kapitel wird daher ein Rundenmodul erstellt, das sich aus einem Datenpfadund einer Steuerlogik zusammensetzt. Die Steuerlogik realisiert eine Ablaufkontrolle,welche die Berechnungen im Datenpfad ansteuert. Im Datenpfad werden samtliche Be-rechnungen ausgefuhrt und evtl. Zwischenergebnisse gespeichert. Der Datenpfad soll nurnoch einen Multiplizierer und einen Addierer benotigen, um eine vollstandige Runden-berechnung durchfuhren zu konnen. Hierzu ist es notig, das Rundenmodul in mehrerenTeilschritten abzuarbeiten, so dass mit einem Multiplizierer bzw. Addierer die 4 be-notigten Multiplikationen bzw. Additionen nacheinander durchgefuhrt werden konnen.Deshalb wird das Rundenmodul zunachst in 4 Teilschritte unterteilt, wobei in jedemSchritt genau eine Modulo-Multiplikation und eine Addition ausgefuhrt werden. Da furjede Runde mehr XOR-Module als Addierer bzw. Modulo-Multiplizierer benotigt wer-


den und diese nur sehr wenige Logikblocke benotigen, sollen fur jeden Teilschritt mehrereXOR-Module zulassig sein. Um die Aufteilung in die 4 Teilschritte vorzunehmen, wirdvon Abbildung 5 auf Seite 9 ausgegangen. Durch Einfuhrung von drei Trennlinien wirddas Rundenmodul in 4 Teilschritte zerlegt.

Um nun in jedem Teilschritt genau einen Modulo-Multiplizierer und genau einen Addie-rer zu erhalten, mussen Modulo-Multiplizierer und Addierer uber eine Trennlinie nachoben bzw. nach unten verschoben werden. Dies geschieht solange bis in jedem Teilschrittgenau ein Modulo-Multiplizierer und ein Addierer zu liegen kommt. Weiterhin ist natur-lich zu beachten, dass die vorgegebene Datenflussrichtung von oben nach unten eingehal-ten wird. Die Zwischenergebnisse des Modulo-Multiplizierers und des Addierers, ebensowie davon abhangige Ergebnisse, mussen am Ende des jeweiligen Schrittes in Registern8

gespeichert werden, wenn sie spater noch einmal benotigt werden. In Abbildung 32 isteine mogliche Aufteilung der Runde in 4 Teilschritte abgebildet. Gegenuber Abbildung 5wurden der grau hinterlegte Modulo-Multiplizierer und der Addierer uber die Trennliniein den Teilschritt 1 verschoben.

Nach der Aufteilung der Runde in 4 Teilschritte soll nun mit Hilfe von Multiplexern eineSchaltung fur den Datenpfad entwickelt werden, die eine Rundenberechnung mit einemModulo-Multiplizierer, einem Addierer und mehreren XOR-Modulen ermoglicht. Hier-zu wird ein Modulo-Multiplizierer und ein Addierer vorgegeben, wobei deren Eingangejeweils an den Ausgang eines 4-zu-1 Multiplexers angeschlossen sind. Durch ein Steu-ersignal S werden die Eingangsdaten des jeweiligen Teilschrittes an die Rechenmoduledurchgeschaltet.

Vorbereitung: ? 3

• Wie wurden Sie die Runde aufteilen, wenn Sie in jedem Teilschritt 2 Modulo-Multiplizierer, 2 Addierer und beliebig viele XOR-Module verwenden konnten?Skizzieren Sie Ihre Aufteilung (vgl. Abb. 32).

• Wie viele Teilschritte waren fur eine solche Rundenberechnung notig.

• An welchen Stellen mussen Sie Register einfugen?

• Erstellen Sie eine Schaltung fur den Datenpfad, wenn in jedem Teilschritt 2 Modulo-Multiplizierer und 2 Addierer verwendet werden konnen (vgl. Abb. 33).

Das getaktete Rundenmodul setzt sich aus dem Datenpfad und der Steuerlogik zusam-men. Fur die Implementierung des Datenpfades wird ein neues Modul benotigt: Ein4-zu-1 Multiplexer.

8Es werden taktflankengesteuerte Register mit Load/Enable verwendet. Die Clock- und Enable-Signale sind in der Abbildung 32 und 33 der Ubersichtlichkeit wegen ausgelassen worden.


4.3.1 4-zu-1 Multiplexer

Erstellen Sie eine Beschreibung fur einen 4-zu-1 Multiplexer mit einem 2 Bit breitenVHDL 20

Steuereingang S vom Typ std_logic_vector anhand dessen einer der vier 16 Bit Ein-gange vom Typ std_logic_vector auf den 16 Bit breiten Ausgang geschaltet wird.Uberprufen Sie durch Simulation insbesondere das Verhalten des Multiplexers, wennsich bei konstantem Steuereingang ein Eingangssignal andert.

4.3.2 Die Steuerlogik fur eine Runde

Clock

Init

Enable

Enable

Enable

Multiplexer00 01 10 11control

Result

000 001 010 011 100 101 110 111Internal

State

R1 R2 R5

R3 R4 R6

R7 R8

S

Abbildung 34: Steuerlogik fur eine Runde

Fur die Ansteuerung der Multiplexer und der Register wird eine Steuerlogik benotigt.Nach einem Startimpuls Init soll diese bei der steigenden Taktflanke zuerst die Mul-tiplexer auf den jeweils nachsten Eingang zyklisch weiterschalten. Bei der folgendensteigenden Taktflanke wird das Enable-Signal fur die entsprechenden Register gesetzt,so dass das jeweilige Zwischenergebnis bei der nachsten steigenden Taktflanke ubernom-men wird (Abb. 34). Bei der nachsten steigenden Taktflanke wird das Enable-Signalfur die Register zuruckgenommen. Mit der nun folgenden Taktflanke wird der nachste


Teilschritt durchgefuhrt. Wenn alle Teilschritte durchgefuhrt sind, soll ein Result-Signalanzeigen, daß eine Rundenberechnung abgeschlossen ist. Das Zeitdiagramm der Steuer-signale ist in Abbildung 34 dargestellt.

Fur die Implementierung der Steuerlogik ist es sinnvoll, jeden Teilschritt in 2 Zyklenaufzuteilen. Am Anfang des ersten Zyklus werden die Steuersignale der Multiplexer ge-schaltet und somit die jeweiligen Daten an die Rechenmodule durchgeschaltet. Nach derBerechnung des Ergebnisses wird dieses zu Beginn des zweiten Zyklus in die Registerubernommen. Fur die Realisierung der 4 Teilschritte mit jeweils 2 Zyklen wird ein in-terner Zustand eingefuhrt, der sowohl den aktuellen Teilschritt als auch den aktuellenZyklus des Teilschrittes beschreibt (Abb. 34, Interner Zustand).

Erstellen Sie die Beschreibung fur die Steuerlogik. Realisieren Sie dabei jeden der fol- VHDL 21

genden Punkte in einem eigenen process und verwenden Sie case-Anweisungen wennmoglich.

• Erstellen Sie fur die Steuerlogik einen 3-Bit-Zahler, der den internen Zustand wie-dergibt. Der Zahler soll bei jeder steigenden Flanke des Clock-Signals um 1 inkre-mentiert werden, solange bis er den Wert "111" annimmt. Auf den Wert "000"

wird er zuruckgesetzt, wenn der aktuelle Zustand "111" ist, das Init-Signal anliegtund eine steigende Clock-Flanke festgestellt wird. Initialisieren sie den 3-Bit-Zahlermit "111".

• Setzen Sie in Abhangigkeit von dem internen Zustand die 3 Enable-Signale fur dieRegister und das Result-Signal.

• Erzeugen Sie aus dem internen Zustand auf moglichst einfache Weise das SignalS fur die Multiplexeransteuerung.

Erstellen Sie eine Testumgebung und uberprufen Sie die Steuerlogik fur die Runde. VHDL 22

4.3.3 Datenpfad des Rundenmoduls

Erstellen Sie den Datenpfad des Rundenmoduls nach Abbildung 33. Binden Sie die VHDL 23

benotigten Module als component ein. Beachten Sie, daß das Datenpfad-Modul Eingangefur die Ansteuerung der Register und der Multiplexer benotigt, welche die Steuerlogikzur Verfugung stellt. Weiterhin wird ein Clock-Signal benotigt. Fur den Datenpfad istes nicht notig, eine eigene Testumgebung zu erstellen.

4.3.4 Das getaktete Rundenmodul

Erstellen Sie das getaktete Rundenmodul, das sich aus Steuerlogik und Datenpfad VHDL 24

zusammensetzt. Binden Sie die beiden Module als component ein. Erstellen Sie eineTestumgebung und uberprufen Sie das getaktete Rundenmodul.


4.3.5 Das erweiterte Rundenmodul

Durch Resource Sharing konnte der LUT-Bedarf der Runde erheblich verringert werden.Bei der jetzigen Implementierung werden in etwa 401 LUTs benotigt (siehe Tabelle 2).

Modul LUTs je Modul LUTs insgesamt

5 * XOR 16 801 * Addierer 16 161 * Modulo-Multiplizierer 106 1068 * 16-Bit-Register 16 1284 * 4-zu-1 16-Bit-Multiplexer 32 1281 * Steuerlogik 7 7∑

465

Tabelle 2: Ressourcenbedarf der getakteten Runde

0 1 2 30 1 2 3

0 1 2 3 0 1 2 3

X(r)1 X

(r)4 Z

(r)5 Z

(r)6

S

Z(r)1 Z

(r)4 R5 R8

S

X(r)3 X

(r)2 R6 R7 Z

(r)3 Z

(r)2

R3 R4 R1

Y(r)3

Y(9)3 Y

(9)2

Y(r)2

Y(9)4

Y(r)4

Y(9)1

Y(r)1

S

R2

St

Abbildung 35: Datenpfad fur Runden-Berechnung und Ausgabetransformation


000 001 010 011 110 111Internal

state

EnableR7 R8

Enable

Enable

Init

Clock

01

01 1100

00 10controlMultiplexer

controlMultiplexer

S

Result

R1 R2 R5

R3 R4 R6

ST

Abbildung 36: Steuerlogik fur die erweiterte Runde, Trafo = 1

Betrachtet man die Ausgabetransformation (Abbildung 6, Seite 9) und vergleicht diesemit dem Rundenmodul, so kann man erkennen, daß die ersten beiden Schritte jederRunde ahnlich ablaufen wie die Ausgabetransformation. Zuerst wird X

(9)1 mit Z

(9)1 mul-

tipliziert und X(9)3 mit Z

(9)2 addiert, dann wird X

(9)4 mit Z

(9)4 multipliziert und X

(9)2 mit

Z(9)3 addiert. Vergleicht man dies mit der Schaltung aus Abbildung 33, so stellt man fest,

daß dies genau die ersten beiden Schritte einer Rundenberechnung sind, wenn man dieTeilschlussel Z

(9)2 und Z

(9)3 vertauscht. Die Ergebnisse der Ausgabetransformation liegen

nach dem zweiten Schritt in den Registern R1 bis R4.

Der Datenpfad und die Steuerlogik der Runde sollen nun so erweitert werden, daß miteinem Eingangssignal Trafo der Betrieb des getakteten Rundenmoduls umgeschaltetwerden kann, so daß dieses die Ausgabetransformation berechnet. Fur die Berechnungder Ausgabetransformation ist es notwendig, daß der vierte Multiplexer im ersten Teil-schritt den Eingang 1 (Z

(9)2 ) durchschaltet und im zweiten Teilschritt den Eingang 0

(Z(9)3 ). Hierfur ist in der Steuerlogik aus dem Signal S ein Signal St fur den vierten

Multiplexer zu erzeugen, indem das niederwertigste Bit von S invertiert wird, wenn am


Eingang Trafo der Signalwert ’1’ anliegt. Beachten Sie auch, daß bei Trafo gleich’1’ die internen Zustande "100" und "101" in der Steuerlogik nicht auftreten. Um dasErgebnis der Ausgabetransformation, das in den Registern R1 bis R4 liegt, abgreifen zukonnen sind 4 weitere Ausgangssignale im Datenpfad-Modul notwendig. In Abbildung 35sind die Anderungen gegenuber dem bisherigen Datenpfad-Modul aus Abbildung 33 grauhinterlegt.

Erweitern Sie die Steuerlogik fur das Rundenmodul um das Eingangssignal Trafo. BeiVHDL 25

gesetztem Trafo-Signal soll die Steuerlogik die Multiplexer- und die Register-Signalewie in Abbildung 36 dargestellt erzeugen. Bei nicht gesetztem Trafo-Signal soll dieSteuerlogik die Multiplexer- und Register-Signale wie bisher generieren (Abb. 34). Indiesem Fall stimmt das St-Signal mit dem Signal S uberein. Uberprufen Sie mit einerTestumgebung die Funktionsweise der Steuerlogik sowohl im Modus fur die Rundenbe-rechnung als auch im Modus fur die Berechnung der Ausgabetransformation.

Erweitern Sie den bisherigen Datenpfad so, daß er vier zusatzliche Ausgange erhalt, mitVHDL 26

denen die Register R1 bis R4 abgegriffen werden konnen. Verwenden Sie das St-Signal,um den vierten Multiplexer anzusteuern.

Uberprufen Sie das erweiterte getaktete Rundenmodul mit einer Testumgebung sowohlVHDL 27

im Modus fur die Rundenberechnung als auch im Modus fur die Berechnung der Ausga-betransformation. Um fur einige X

(r)i - und Z

(r)i -Belegungen die zugehorigen Sollwerte fur

Y(r)i zu berechnen, konnen Sie die schematische Darstellung (Punkt Referenzmodell)

fur die Projekte Runde und Transformation verwenden.

4.3.6 Implementierung des Rundenzahlers

Um den vollstandigen Algorithmus aufzubauen, muss eine Steuerlogik erstellt werden,welche die 8 Rundenberechnungen und die anschließende Ausgabetransformation ebensowie den Schlusselgenerator ansteuert. Diese soll in einem Rundenzahler realisiert werden.Das Rundenmodul ist weiterhin so zu beschalten, daß es im ersten Schritt von außen mitEingangswerten geladen werden kann. Fur die Berechnung der Runden 2 bis 8 und derAusgabetransformation werden die Ergebnisse der vorangegangenen Rundenberechnungin Registern zwischengespeichert und als Eingabewerte fur die neue Berechnung verwen-det. Der komplette IDEA-Algorithmus soll wie in Abbildung 37 dargestellt aufgebautwerden. Der Rundenzahler soll auch verwendet werden, um die benotigten Steuersignalefur die 4 Eingangsmultiplexer und das erweiterte Rundenmodul zu erzeugen.

Der Rundenzahler stellt zusatzlich zu dem aktuellen Rundenwert auch die Signale Init

und Trafo zur Verfugung, mit dem das erweiterte Rundenmodul angesteuert wird. Wei-terhin soll mit dem Signal Ready angezeigt werden, daß der gesamte Verschlusselungs-vorgang beendet ist und das Ergebnis an Y

(9)1 bis Y

(9)4 anliegt. Das Result-Signal des

Rundenmoduls informiert den Rundenzahler, daß die aktuelle Berechnung abgeschlos-sen ist und die nachste durchgefuhrt werden kann. Der Anstoß zur Verschlusselung derEingabedaten X

(1)1 bis X

(1)4 wird durch das Start-Signal gegeben.

Der Rundenzahler wird als Endlicher Automat mit den 3 Zustanden Sleep, Setup und


R1

R2

R3

R4

Y(9)4Y

(9)3Y

(9)1

Y(r)4

Y(r)3

Y(r)2

Y(r)1

Z(r)6

Z(r)5

Z(r)4

Z(r)3

Z(r)2

Z(r)1

X(r)4X

(r)3X

(r)2X

(r)1

GeneratorSchlussel

X(1)1 X

(1)2 X

(1)3 X

(1)4

Result

T rafo

Init

erweitertes

mit Steuerlogik

Rundenmodul

Y(9)2 Start

Ready

Si

Si Si Si Si

128 bit Schlussel

Runden-Zahler

Round

Abbildung 37: Realisierung des IDEA-Algorithmus

and Result=1 and

Round=1000

and Result=0

and Start=1Round!=1000Setup

Init <= 1

Ready <= 0

Sleep Calc

Init <= 0

Ready <= 1 Init <= 0

Start

and Result=1 and

Clock=1 and Clock’EVENT

Abbildung 38: Spezifikation des Rundenzahlers als Endlicher Automat

Calc spezifiziert (Abb. 38). Im Ruhezustand Sleep wartet der Rundenzahler auf dasStart-Signal und geht bei steigender Flanke in den Zustand Setup uber. Hier wirddas Init-Signal auf 1 gesetzt und somit die Berechnung des erweiterten Rundenmodulsangestoßen. Bei der folgenden steigenden Taktflanke wird in den Zustand Calc uberge-


gangen. Ist das Result-Signal 0, so bleibt der endliche Automat in diesem Zustand. Istdas Result-Signal 1, so wird bei einer steigenden Taktflanke in den Zustand Sleep uber-gegangen, wenn der Rundenzahler "1000" enthalt, sonst wird Setup erneut ausgefuhrt.Im Sleep-Zustand ist der Rundenzahler immer auf dem Wert "1000".

Der interne 4 Bit breite Zahler kann auch als Endlicher Automat verstanden werden(Abb.. 39). Er wird bei einer steigenden Taktflanke um 1 inkrementiert, wenn das Result-Signal 1 ist. Beinhaltet der Zahler den Wert "1000" so wird er auf "0000" zuruckgesetzt.Dieser Zahler entspricht dem Signal Round.

and Result=1

and Start=1

0000 0001

01111000

and Result=1

and Result=1

Abbildung 39: Der interne Zahler auch als Endlicher Automat

Die Signale Trafo fur das erweiterte Rundenmodul und Si fur die Ansteuerung der Ein-gangsmultiplexer sollen aus dem aktuellen Wert des Rundenzahlers abgeleitet werden.Das hochstwertige Bit des Rundenzahlers kann direkt als Trafo-Signal verwendet wer-den. Das Signal Si zur Ansteuerung der Eingangsmultiplexer muss genau dann gesetztsein, wenn im Rundenzahler der Wert "0000" vorliegt. Das Ready-Signal soll nur danngesetzt werden, wenn die Verschlusselung vollstandig durchgefuhrt worden ist, d.h. wennsich der Rundenzahler im Zustand Sleep befindet. Dies ist der Fall, wenn das Ergebnisder letzten Berechnung des Rundenmoduls (Ausgabetransformation) an den Ausgangen

Y(9)1 bis Y

(9)4 ansteht (Rundenzahler im Zustand Sleep).

Implementieren Sie den Rundenzahler wie beschrieben und uberprufen Sie dessen Funk-VHDL 28

tionsweise mit einer Testumgebung.

4.3.7 Hardwarenahe Implementierung des IDEA-Algorithmus

Implementieren Sie den kompletten IDEA-Algorithmus wie in der Abbildung 37 dar-VHDL 29

gestellt. Als Eingangsmultiplexer sind die bereits erstellten 4-zu-1 Multiplexer zu ver-wenden. Beachten Sie, daß nur 2 Eingange benotigt werden, und mit dem 1 Bit breitenSignal Si einer von beiden ausgewahlt werden kann. Legen Sie das hoherwertige Bit desAuswahlsignals ebenso wie die nicht benotigten Eingange der 4-zu-1 Multiplexer aufeinen konstanten Wert.

Die Ubernahme der Zwischenwerte in die Register R1 bis R4 soll genau dann erfol-gen, wenn das Rundenmodul signalisiert, daß die letzte Berechnung durchgefuhrt wor-


den ist und die Ergebnisse an den Ausgangen Y(r)1 bis Y

(r)4 anliegen. Hierzu wird das

Enable-Signal der Register mit dem Result-Signal der Runden-Steuerlogik verschaltet.Der Clock-Eingang wird mit dem globalen Clock-Signal belegt.

Erstellen Sie eine Testumgebung und uberprufen Sie die korrekte Funktionsweise der VHDL 30

Implementierung. Verwenden Sie fur die Eingabewerte X(1)1 bis X

(1)4 "0000", "0001",

"0002" und "0003".

4.3.8 UART - Resource Constrained Scheduling II

Bei der Synthese des VHDL-Moduls des nun implementierten IDEA-Algorithmus wer-den weniger Ressourcen benotigt als beim ersten synthetisierbaren Entwurf. Um denAlgorithmus erneut mit echter Hardware zu testen, muss wieder ein Interface geschaffenwerden, das Daten von einem PC empfangt, die Verschlusselung startet und anschlie-ßend die verschlusselten Daten wieder an den PC sendet. Fugen Sie hierzu wieder dasUART-Modul, wie in Abschnitt 4.2.6 beschrieben.

Programmieren Sie nun den FPGA und testen Sie ihre Implementierung, wie dies zuvor VHDL 31

in Abschnitt 4.2.6 beschrieben wurde.

50 5 LAUFZEITABSCHATZUNG

5 Laufzeitabschatzung

In diesem Teil des Praktikums sollen die Laufzeiten der einzelnen Module abgeschatztwerden, um eine Beurteilung der Performance der implementierten Algorithmen machenzu konnen. Hierzu ist es notwendig, sich mit der Zielarchitektur naher auseinanderzu-setzen.

G1

G2

G3

G4

Cout

F1

F2

F3

F4

Cin

Y

X

Gi4

Gi3

Gi2

Gi1

Fi4

Fi3

Fi2

Fi1

G

GCarry

F

FCarry

Y Sel

XSel

CSel

CSel

Abbildung 40: Vereinfachter Aufbau eines SLICE.

5.1 Zielarchitektur

Der IDEA-Algorithmus liegt inzwischen in einer Beschreibung vor, die auf einem Xilinx-FPGA vom Typ Spartan 3E XC3S500E realisiert werden kann. Dieses FPGA besitzt9312 LUTs auf die uber maximal 232 Eingabe- bzw. Ausgabepins zugegriffen werdenkann. Ein CLB besteht im wesentlichen aus 4 SLICEs, die jeweils 2 Funktionsgeneratoren

5.1 Zielarchitektur 51

F und G und eine spezielle Carry Logic zur Verfugung stellen. Die beiden Funktionsgene-ratoren sind als Look-Up Tabelle (LUT) realisiert und konnen so programmiert werden,daß sie jede beliebige Logikfunktion in Abhangigkeit der vier Eingange F1 bis F4 bzw.G1 bis G4 realisieren. Weiterhin sind in jedem CLB 8 D-FlipFlops vorhanden. In Ab-bildung 40 ist eine vereinfachte Darstellung eines SLICEs gegeben9. Die Verschaltungder CLBs untereinander erfolgt durch die frei programmierbaren Verdrahtungsressour-cen. Diese Verdrahtungstypen sind in unterschiedlicher Anzahl verfugbar und weisenein sehr unterschiedliches Laufzeitverhalten auf. Eine Abschatzung der verdrahtungsbe-dingten Signallaufzeiten in einem fruhen Stadium des Entwurfsvorgangs ist schwierig,da diese Laufzeiten sowohl von der Anzahl als auch vom Typ der verwendeten Verdrah-tungsressourcen stark abhangig sind. Typischerweise betragt die verdrahtungsbedingteSignallaufzeit 20-60% der Gesamtlaufzeit. Diese verdrahtungsbedingten Signallaufzeitensind erst nach dem Platzieren und Verdrahten der Schaltung (Layout) bekannt. Diesogenannte

”Post-Route Simulation“ ist leider aufwandig durchzufuhren und fuhrte bei

Versuchen in aktuellen Versionen von Xilinx R© ISE WebPackTM zum Teil zu falschen Er-gebnissen. Leitungslaufzeiten sollen daher im Folgenden vernachlassigt werden. Weiter-hin benotigen auch die Eingabe-/Ausgabetreiber, uber welche die Signale in das FPGAeingespeist, bzw. ausgegeben werden, eine bestimmte Zeit, um die Signale durchzuschal-ten. Auch diese Zeiten sollen vernachlassigt werden.

5.1.1 Laufzeitabschatzung 16-Bit-XOR

In jedem SLICE (Abb. 40) stehen zwei Funktionsgeneratoren (F und G) zur Verfugung.Diese werden benutzt, um jeweils eine XOR-Operation auszufuhren. Wieviele SLICEs ? 4

werden somit benotigt, um eine 16-Bit XOR-Operation zu realisieren?

Zur Abschatzung der Logiklaufzeiten sollen die in Tabelle 3 angegebenen Signallaufzeitenfur die einzelnen SLICE-Komponenten verwendet werden. Wie viel Rechenzeit benotigt ? 5

eine 16-Bit XOR-Operation? Ist diese Rechenzeit abhangig von der Bitbreite?

SLICE-Komponente Signallaufzeit

F/G-Funktionsgenerator 3 nsF/G-Carry 1 nsCSel/XSel/YSel-Multiplexer 0 ns

Tabelle 3: Laufzeiten SLICE

5.1.2 Laufzeitabschatzung 16-Bit-Addierer

Die Addition von mehrstelligen Dualzahlen kann mit verschiedenen Addierer-Architek-turen realisiert werden. In diesem Praktikum soll die Ripple-Carry Architektur naher

9Eine vollstandige Spezifikation konnen Sie sich als PDF-Datei unter folgender Adresse herunterla-den: http://www.xilinx.com/support/documentation/user guides/ug331.pdf

http://www.xilinx.com/support/documentation/user_guides/ug331.pdf


betrachtet werden10. Im allgemeinen Fall benotigt man fur jedes Bit einen Volladdierermit den Eingangen xn, yn und cn und den beiden Ausgangen sn und cn+1. Der Ausgangsn ist der Summenausgang, der Ausgang cn+1 der Ubertrag. Fur die Ausgange sn undcn+1 ergeben sich folgende logische Funktionen:

sn = xn ⊕ yn ⊕ cn

cn+1 = xnyn + xncn + yncn(6)

Die schaltungstechnische Realisierung eines Volladdierers kann in 2 Blocke aufgeteiltwerden (Abb. 41). Die Berechnung der Summe (in den Funktionsgeneratoren F und G)und die Berechnung des Ubertrags (Carry Logic). Eine mogliche Realisierung ist inAbbildung 41 aufgezeigt. Um einen n-Bit-Addierer zu realisieren, werden n Volladdiererbenotigt. Diese sind so zu verschalten, daß der Ubertrag-Ausgang den Ubertrag-Eingangdes nachsten hoherwertigen Volladdierers treibt.

F / G

Carry Logic

cn

yn

xn

sn

cn+1

Abbildung 41: Volladdierer

Mit jedem SLICE der Zielarchitektur konnen 2 Volladdierer realisiert werden. Die Logikzur Berechnung des Ubertrags ist in den SLICEs bereits fest verdrahtet vorgegeben undmuss nur durch die entsprechende Wahl des CSel-Signals aktiviert werden. Mit denbeiden Funktionsgeneratoren wird die Summenbildung realisiert. Die Signallaufzeit furdie Carry Logic ist eine Nanosekunde, die der Funktionsgeneratoren 3 Nanosekunden.Die Laufzeit fur die Multiplexer kann vernachlassigt werden.

Schließen Sie durch Uberlegung auf die maximale Addierzeit eines 16-Bit-Addierers. Wel-? 6

10Eine weitere, sehr verbreitete Architektur ist der Carry-Look-Ahead Addierer. Siehe auch [8].

5.1 Zielarchitektur 53

cher Pfad verursacht die maximale Verzogerungszeit? Beachten Sie, dass zum Zeitpunktt = 0 bereits alle Eingange gultig anliegen.

In den weiteren Aufgaben soll angenommen werden, dass bei der Synthese des FPGAdie Hardware-Addierer statt LUT-basierten Ripple-Carry-Addierern eingesetzt werden.Nehmen Sie eine Verzogerungszeit von 10ns fur die 16-Bit-Addition an.

5.1.3 Laufzeit Modulo-Multiplizierer

Eine Referenzimplementierung des Modulo-Multiplizierers wurde nach einer vollautoma-tischen Synthese platziert und verdrahtet, um die Laufzeiteigenschaften dieses Modulsbestimmen zu konnen11. Dabei ergab sich eine maximale Logiklaufzeit von 22 Nanose-kunden.

5.1.4 Laufzeitabschatzung Register

D

t Setu

p

t Hold

Clock

Q

tDelay

Abbildung 42: Laufzeiteigenschaften Register

Die Laufzeiteigenschaften von Registern werden durch 3 Zeiten charakterisiert. Dies istdie Schaltzeit tDelay, die Set-Up-Zeit tSetup und die Hold-Zeit tHold (siehe Abbildung 42).Die Schaltzeit ist diejenige Zeit, die vergeht, bis nach der steigenden Taktflanke dasEingangsdatum D am Ausgang Q stabil anliegt. Die Set-Up-Zeit gibt an, wie langedas Eingangsdatum vor der aktiven Taktflanke stabil anliegen muss, wahrend die Hold-Zeit die entsprechende Zeitdauer nach der aktiven Flanke festlegt. Nur die Einhaltungbeider Zeiten garantiert eine korrekte Ubernahme des Eingangsdatums. Weiterhin mussnaturlich neben dem Eingangsdatum auch das Enable-Signal rechtzeitig vor der aktivenTaktflanke anliegen.

11Die 16-Bit Multiplikation wurde mit einem Hardware-Multiplizierer durchgefuhrt.


Fur die Implementierung des 16-Bit-Registers auf einem XC3S500E FPGA soll die Set-Up-Zeit zu 4 Nanosekunden angenommen werden. Die Schaltzeit und die Hold-Zeitkonnen vernachlassigt werden. Ebenso ist es notwendig, daß das Enable-Signal bereits4 Nanosekunden vor der aktiven Taktflanke stabil anliegt.

5.1.5 Laufzeitabschatzung Multiplexer

Einen 4-zu-1 Multiplexer kann man wie in Abbildung 43 gezeigt auch zweistufig mit 2-zu-1 Multiplexern realisieren. Uberlegen Sie sich, wie die zweistufige Realisierung eines4-zu-1 Multiplexer mit genau einem SLICE aus Abbildung 40 (ohne Verwendung derCarry Logic) realisiert werden kann. Beschreiben Sie Ihren Losungsvorschlag. Schließen? 7

Sie ausgehend von Ihren Uberlegungen auf das Laufzeitverhalten eines 16 Bit breiten4-zu-1 Multiplexers.

Abbildung 43: Zweistufiger 4-zu-1 Multiplexer

5.1.6 Laufzeiten der einfachen IDEA-Implementierung

Bestimmen Sie, welche Rechenzeit fur einen kompletten Verschlusselungsvorgang notig? 8

ware, wenn der IDEA-Algorithmus direkt, d.h. wie in Abschnitt 3.7 beschrieben, imple-mentiert werden konnte. Verwenden Sie die Modullaufzeiten aus den Abschnitten 5.1.1bis 5.1.5. Beschreiben Sie, wie die Rechenzeit zustande kommt (langster Pfad). Wie vieleVerschlusselungsvorgange waren mit dieser Implementierung je Sekunde moglich? Warees moglich — evtl. auch mit Hilfe von zusatzlich eingefugten Registern — bereits miteiner neuen Berechnung zu beginnen, selbst wenn der aktuelle Verschlusselungsvorgangnoch nicht abgeschlossen ist? Begrunden Sie Ihre Antwort.

5.1.7 Laufzeiten der hardwarenahen IDEA-Implementierung

Die Performance der Realisierung des IDEA-Algorithmus nach Abbildung 37 (ResourceConstrained Scheduling II) wird im wesentlichen durch die Rechenzeit des erweitertenRundenmoduls bestimmt. Um die Abschatzung der Gesamtperformance zu erleichtern,

5.2 Vergleich der unterschiedlichen Implementierungen 55

sollen die ohnehin geringen Laufzeiten der Runden-Steuerlogik und des Rundenzah-lers vernachlassigt werden. Weiterhin sollen auch die verdrahtungsbedingten Laufzeitenaußer acht gelassen werden, da deren Abschatzung ohne Durchfuhrung des Layout-Vorganges nur sehr ungenau erfolgen konnte.

Getaktete Runde Bestimmen Sie durch Uberlegung den kurzesten Clock-Zyklus, ? 9

fur den das getaktete Rundenmodul gerade noch richtig arbeitet. Beachten Sie, daßes je nach Steuersignal durch jeden Multiplexer 4 verschiedene Pfade gibt. Weiterhinsoll ein Register nur dann als Ende eines kombinatorischen Pfades angesehen werden,wenn es auch den im jeweiligen Teilschritt berechneten Wert ubernimmt. Zeigen Sie auf,wie der langste Pfad zustande kommt. Wie werden die Multiplexer in diesem Zustandangesteuert? Welches Register ist am Ende des Pfades?

Ware es moglich, das getaktete Rundenmodul mit einem hoheren Durchsatz zu betrei- ? 10

ben, wenn man die Ansteuerung der Register (Enable-Signal) und Multiplexer(Select-Signal) verandert? Begrunden Sie Ihre Antwort.

Vollstandige Verschlusselung Bestimmen Sie durch Uberlegung den kurzesten ? 11

Clock-Zyklus, fur den die hardwarenahe Realisierung des IDEA-Algorithmus (erwei-tertes Rundenmodul, Register R1 bis R4, Eingangsmultiplexer Si Rundenzahler undSchlusselgenerator) gerade noch richtig arbeitet. Ist der minimale Clock-Zyklus großerals der kleinste Zyklus des getakteten Rundenmoduls, wenn dieses ohne außere Beschal-tung betrieben wird? Wenn ja, wodurch wird der langere Zyklus verursacht? Zeigen Sieauf, wie der kritische Pfad zustande kommt.

Bestimmen Sie die Zahl der Clock-Zyklen, welche die hardwarenahe IDEA-Implementier- ? 12

ung benotigt, um eine komplette Verschlusselung zu berechnen. Nehmen Sie hierzu an,daß das externe Startsignal bei der steigenden Clock-Flanke mit der Nummer 0 aktiv warund eine Verschlusselung angestoßen hat. Bei welchen steigenden Clock-Flanken sind dieSignale Init und Result aktiv? Bei welcher Clock-Flanke wird mit Ready signalisiert,daß die Verschlusselung vollstandig ist?

Wie lange dauert ein kompletter Verschlusselungsvorgang bei Verwendung der hardwa- ? 13

renahen IDEA-Implementierung aus Kapitel 4.3? Wie viele Verschlusselungen sind proSekunde moglich?

5.2 Vergleich der unterschiedlichen Implementierungen

Im Folgenden sollen die verschiedenen angesprochenen Implementierungen gegeneinan-der verglichen werden. Als Kriterien werden die moglichen Verschlusselungen pro Sekun-de und die benotigten Hardwareressourcen gegenubergestellt. Als vierter Faktor soll dieEffizienz aufgefuhrt werden. Diese sei der Quotient aus der Zahl der Verschlusselungenpro Sekunde und der benotigten SLICEs. Benutzen Sie die Ergebnisse aus Ihren bishe-rigen Uberlegungen, bzw. treffen Sie soweit es notig sein sollte Abschatzungen um die


folgende Tabelle zu vervollstandigen. Der Flachenbedarf und die Laufzeit des Schlussel- ? 14

generators, der Steuerlogik, als auch des Rundenzahlers sind zu vernachlassigen. Fur dieSchatzwerte ist es ausreichend, die Großenordnung wiederzugeben. Begrunden Sie auchIhre Schatzwerte.

Implementierung 1 2 3 4 5

Verschlusselungen / Sekunde

Flachenbedarf in SLICEs

Benotigten Eingabe- / Ausgabe-PINs

Effizienz

1 Direkte Implementierung (Abschnitt 5.1.6)

2 Direkte Implementierung bei gleichzeitiger Berechnungmehrerer Verschlusselungen (Abschnitt 5.1.6)

3 Hardwarenahe Implementierung - Resource Constrained Scheduling I(Abschnitt 4.2)

4 Hardwarenahe Implementierung - Resource Constrained Scheduling II(Abschnitt 4.3)

5 Hardwarenahe Implementierung - Resource Constrained Scheduling IImit geanderter Registeransteuerung (Abschnitt 5.1.7)

LITERATUR 57

Literatur

[1] ANSI, IEEE Standards Board, IEEE Standard VHDL Language Reference Manual:IEEE Std 1076-1993 , New York, 1988, ISBN 1559373768

[2] Peter J. Ashenden, Designer’s Guide to Vhdl, Morgan Kaufmann Publishers, 1995,ISBN 1558602704

[3] Lehmann, Wunder, Selz, Schaltungsdesign mit VHDL, Franzis-Verlag,Poing, 1994, ISBN 3772361633, http://www-itiv.etec.uni-karlsruhe.de/

FORSCHUNG/VEROEFFENTLICHUNGEN/lws94/lws94.html

[4] Giovanni De Micheli, Synthesis and Optimization of Digital Circuits, McGraw-HillBook Company, 1994, ISBN 0070163332

[5] David R. Coelho, The VHDL Handbook, Kluwer Academic Publishers, Boston,1989, ISBN 0792390318

[6] Jayaram Bhasker, A VHDL Primer, Prentice Hall, Englewood Cliffs, 1998, ISBN0130965758

[7] Roger Lipsett, Carl Schaefer, Cary Ussery, VHDL: Hardware Description andDesign, Kluwer Academic Publishers, Boston/Dordrecht/London, 1989, ISBN079239030X

[8] Michael John Sebastian Smith, Application-Specific Integrated Circuits, Addison-Wesley Verlag, Juni 1997, ISBN 0201500221

[9] Bruce Schneider, Angewandte Kryptographie, Addison-Wesley Verlag, Bonn, 1996,ISBN 3893198547

[10] Xuejia Lai, On the Design and Security of Block Ciphers, Hartung-Gorre Verlag,Wissenschaftliche Publikationen, 1992

[11] Michael Welschenbach, Kryptographie in C und C++, Springer-Verlag, Berlin,1998, ISBN 3540644040

[12] Richard E. Smith, Internet- Kryptographie, Addison-Wesley, Bonn, 1998, ISBN3827313449

[13] Jens-Peter Kaps, Christof Paar, Fast DES Implementations for FPGAs and itsapplication to a Universal Key-Search Machine, SAC’ 98

Praktikum Systementwurf mit VHDL“ - eda.ei.tum.de · Praktikum ” Systementwurf mit VHDL“...

Documents

Transcript of Praktikum Systementwurf mit VHDL“ - eda.ei.tum.de · Praktikum ” Systementwurf mit VHDL“...