diplomarbeit -...
Post on 03-Nov-2019
6 Views
Preview:
TRANSCRIPT
Christian-Albrechts-Universität zu Kiel
Diplomarbeit
DiplomarbeitHW/SW Co-Design für einen reaktiven Prozessor
cand.-Ing. Sascha Gädtke
4. Mai 2007
Institut für InformatikLehrstuhl für Echtzeitsysteme und Eingebettete Systeme
betreut durch:Prof. Dr. Reinhard von Hanxleden,
Dipl.-Inf. Claus Traulsen
ii
Eidesstattliche Erklärung
Hiermit erkläre ich an Eides statt, dass ich die vorliegende Arbeit selbstständig ver-fasst und keine anderen als die angegebenen Hilfsmittel verwendet habe.
Kiel,
iv
Inhaltsverzeichnis
1. Einleitung 1
2. Grundlagen 52.1. Reaktive Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52.2. Esterel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2.1. Synchronizität in Esterel . . . . . . . . . . . . . . . . . . . . . 62.2.2. Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72.2.3. Semantiken von Esterel . . . . . . . . . . . . . . . . . . . . . 12
2.3. Synthese von Esterel . . . . . . . . . . . . . . . . . . . . . . . . . . . 142.3.1. Software- und Hardwaresynthese . . . . . . . . . . . . . . . . 142.3.2. Co-Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152.3.3. Reaktive Prozessoren . . . . . . . . . . . . . . . . . . . . . . . 15
2.4. Kiel Esterel Prozessor (KEP) . . . . . . . . . . . . . . . . . . . . . . 162.4.1. Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.4.2. Befehlssatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.4.3. Esterel2KASM Compiler . . . . . . . . . . . . . . . . . . . . . 19
2.5. Logikminimierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.5.1. Datenstrukturen und Algorithmen . . . . . . . . . . . . . . . 222.5.2. Softwarepakete zur Logikminimierung (und -synthese) . . . . 25
2.6. Hardwarebeschreibungssprachen . . . . . . . . . . . . . . . . . . . . . 252.6.1. BLIF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252.6.2. VHDL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3. HW/SW Co-Synthese 313.1. Problemstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.2. Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333.3. Partitionierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.1. Schwierigkeiten bei der Partitionierung . . . . . . . . . . . . . 343.3.2. Partitionierungsansatz mit lokalen Hardwaremodulen . . . . . 393.3.3. Transformationsregeln . . . . . . . . . . . . . . . . . . . . . . 40
3.4. Zwischenschritt: Logikminimierung . . . . . . . . . . . . . . . . . . . 433.5. Software- und Hardwaresynthese . . . . . . . . . . . . . . . . . . . . 44
3.5.1. Softwaresynthese . . . . . . . . . . . . . . . . . . . . . . . . . 443.5.2. Hardwaresynthese . . . . . . . . . . . . . . . . . . . . . . . . 46
3.6. Schnittstelle zwischen Logikblock und KEP . . . . . . . . . . . . . . 483.6.1. Inkrementelle Entwicklung und Partielle Rekonfiguration . . . 50
v
Inhaltsverzeichnis
3.7. Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4. Experimentelle Auswertung 53
5. Zusammenfassung 59
6. Literaturverzeichnis 61
A. Kommentierter Programmcode 65A.1. HW/SW Co-Synthese . . . . . . . . . . . . . . . . . . . . . . . . . . 65
A.1.1. Partitionierung des Esterel Programms . . . . . . . . . . . . . 65A.1.2. CoDesign-partitioner.cpp . . . . . . . . . . . . . . . . . . . . 67A.1.3. CoDesignDataStructures.hpp . . . . . . . . . . . . . . . . . . 68A.1.4. CoDesignDataStructures.cpp . . . . . . . . . . . . . . . . . . 69A.1.5. CoDesignEsterelPreprocessor.hpp . . . . . . . . . . . . . . . . 70A.1.6. CoDesignEsterelPreprocessor.cpp . . . . . . . . . . . . . . . . 72A.1.7. CoDesignEsterelPrinter.hpp . . . . . . . . . . . . . . . . . . . 77A.1.8. CoDesignEsterelPrinter.cpp . . . . . . . . . . . . . . . . . . . 79A.1.9. Zwischenschritt: Logikminimierung . . . . . . . . . . . . . . . 91A.1.10.CoDesignLogicMinimization.hpp . . . . . . . . . . . . . . . . 92A.1.11.CoDesignLogicMinimization.cpp . . . . . . . . . . . . . . . . 93A.1.12.HW/SW Synthese . . . . . . . . . . . . . . . . . . . . . . . . 99A.1.13.CoDesign-hwswsynthesis.cpp . . . . . . . . . . . . . . . . . . 100A.1.14.CoDesignHWSWPrinter.hpp . . . . . . . . . . . . . . . . . . 101A.1.15.CoDesignHWSWPrinter.cpp . . . . . . . . . . . . . . . . . . . 103
A.2. Wiederherstellung von Signalabhängigkeiten im CKAG . . . . . . . . 115A.2.1. ExtDependencyHandler.cpp . . . . . . . . . . . . . . . . . . . 116
A.3. Interfacemodul des KEP . . . . . . . . . . . . . . . . . . . . . . . . . 117A.3.1. blkinterface.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . 118
vi
1. Einleitung
Reaktive Systeme müssen permanent auf Eingaben aus ihrer physischen Umgebungreagieren, wobei die Geschwindigkeit der Reaktion von der Umgebung bestimmtwird. Die Anforderungen an reaktive Systeme unterscheiden sich grundsätzlich vonden Anforderungen an herkömmliche Softwaresysteme. Die Bedeutung von Rechen-leistung tritt gegenüber funktional und zeitlich vorhersagbarem Verhalten in denHintergrund. Genau wie in der physischen Welt Vorgänge parallel ablaufen, beste-hen reaktive Systeme häufig aus mehreren nebenläufigen Threads, deren zeitlichesVerhalten jeweils von der Umgebung bestimmt wird. Das Scheduling der Threadssollte statisch erfolgen und die Ausführungszeiten einen möglichst geringen Versatzaufweisen, um ein deterministisches Verhalten zu gewährleisten. In vielen eingebet-teten Anwendungen spielt zudem ein geringer Energieverbrauch eine wichtige Rolle.
Herkömmliche Programmiersprachen und Entwicklungswerkzeuge sind nicht odernur bedingt für die Entwicklung reaktiver Systeme geeignet, da sie den besonderenAnforderungen nicht gerecht werden. Synchrone Sprachen [4] sind an die Anforde-rungen von reaktiven Systemen angepasst und stellen insbesondere Konstrukte zumAusdruck von Nebenläufigkeit und Preemption bereit. Synchrone Sprachen basierenauf der Synchronizitäts-Hypothese, in der angenommen wird, dass die Berechnungeiner Reaktion keine Zeit kostet bzw. in einem definierten Zeitintervall erfolgt, dasverglichen mit der Zeit der Signaländerungen klein ist. Dies erlaubt die Definitioneiner formalen Semantik.
Eine synchrone Sprache ist Esterel [6]. Esterel benutzt ein besonderes Aus-führungsmodell, das die Ausführung in diskrete (logische) Ticks oder Instanzen un-terteilt. Die Kommunikation zwischen mehreren Threads innerhalb eines Programmsund die Kommunikation mit der Umwelt erfolgt über Signale. Es wird angenommen,dass alle Signale während eines Ticks genau einen Zustand haben. In der Syntax vonEsterel sind Konstrukte zum Ausdruck von Preemption und Nebenläufigkeit ent-halten. Esterel kann nicht direkt ausgeführt werden, sondern wird üblicherweise ineine andere Programmiersprache wie C oder Java zur Softwaresynthese oder in eineHardwarebeschreibungssprache wie VHDL zur Hardwaresynthese übersetzt. Ausfüh-rungsplattform bei der Softwaresynthese ist im Allgemeinen ein herkömmlicher Pro-zessor. Neuere Ansätze für die Softwaresynthese benutzen reaktive Prozessoren, dieim Gegensatz zu herkömmlichen Prozessoren reaktive Kontrollflussstrukturen direktunterstützen und ein vorhersagbares zeitliches Verhalten aufweisen.
Ein spezieller reaktiver Prozessor ist der Kiel Esterel Processor (KEP) [35], des-sen Instruktionssatz eng an die Esterel Syntax und Semantik angelehnt ist. Diemeisten Esterel Statements werden direkt unterstützt und können innerhalb einesInstruktionszyklus abgearbeitet werden. Dies macht die Ausführung von Esterel
1
1. Einleitung
Programmen sehr effizient. Die Berechnung von komplexen Ausdrücken muss aufdem KEP, wie auch auf anderen Prozessoren, in mehrere Instruktionen sequenziali-siert werden und ist im Gegensatz zu einer Hardwareimplementierung als Schaltnetzaufwändig.
Das Ziel dieser Arbeit ist es, durch die Auslagerung der Berechnung von kom-plexen Ausdrücken in einen mit dem KEP verbundenen Logikblock die Anzahl derbenötigten Instruktionen reduzieren zu können und damit eine beschleunigte Pro-grammausführung zu erreichen. Bei dem vorgestellten HW/SW Co-Synthese-Ansatzwerden alle komplexen Ausdrücke aus einem gegebenen Esterel Programm ex-trahiert und in Hardware synthetisiert. Die Ausgangssignale der Logik werden alszusätzliche Eingangssignale in den KEP geführt. Auf dem KEP wird eine modifi-zierte Programmversion ausgeführt, in der alle komplexen Ausdrücke durch die imLogikblock berechneten zusätzlichen Signale ersetzt sind. Die Partitionierung des ge-gebenen Programms in Software- und Hardwareteile erfolgt auf Esterel Ebene, umden Ansatz möglichst lange hardwareunabhängig zu halten und die Verwendung vonherkömmlichen Verifikations- und Synthesewerkzeugen zu erlauben. In einem zwei-ten Schritt wird aus dem Hardwareteil die Logik synthetisiert und der Softwareteilauf dem KEP ausgeführt.
Durch das Co-Design gibt es keine negative Beeinflussung der Taktfrequenz desKEP, da die Laufzeit des kritischen Pfades im Logikblock auch für große Ausdrückedeutlich unter der Dauer für einen Instruktionszyklus liegt. Der zusätzliche Hardwa-reaufwand für den KEP ist gering und im Vergleich zur Größe des KEP zu vernach-lässigen. In den Experimenten kann gezeigt werden, dass durch die Beseitigung vonBerechnungen von komplexen Ausdrücken aus dem Programm der Energieverbrauchpro Tick gesenkt und die Worst Case Reaction Time (WCRT) deutlich verbessertwerden können.
Ein älterer Stand dieser Arbeit [19] wurde im Rahmen einer Posterpräsentation fürStudenten auf der Konferenz Languages, Compilers, and Tools for Embedded Systems(LCTES’06 ) veröffentlicht. Ein weiteres Paper mit dem Titel HW/SW Co-Design forReactive Processing [20] wurde zur Veröffentlichung auf der International Conferenceon Hardware - Software Codesign and System Synthesis (CODES+ISSS’07 ) einge-reicht.
Die Ausarbeitung unterteilt sich in folgende Kapitel: Kapitel 2 führt in die Grund-lagen dieser Arbeit ein. Es gibt eine Einführung in die synchrone Sprache Esterelund stellt verschiedene Verfahren zur Ausführung von Esterel vor, darunter an-dere Co-Design-Ansätze und reaktive Prozessoren. Als spezieller reaktiver Prozessorwird der KEP, auf dessen Basis die Co-Synthese von Esterel implementiert werdensoll, sowie der dazugehörige Compiler zur Übersetzung von Esterel in den KEPInstruktionssatz eingeführt. Darüber hinaus werden Algorithmen und Werkzeuge zurLogikminimierung und Hardwarebeschreibungssprachen vorgestellt, die für die Im-plementierung der Co-Synthese verwendet werden.
Kapitel 3 beschreibt das Verfahren zur Co-Synthese in den einzelnen SchrittenPartitionierung, Logikminimierung und HW/SW Synthese und geht dabei auf ver-schiedene auftretende Probleme ein.
2
Kapitel 4 schließlich quantifiziert die Vor- bzw. Nachteile des Co-Synthese Ansatzesim Vergleich zur reinen Softwaresynthese eines Esterel Programms auf dem KEP.
3
1. Einleitung
4
2. Grundlagen
2.1. Reaktive Systeme
Rechnergestützte Systeme lassen sich in drei Kategorien einteilen [4]:
• Transformative Systeme berechnen Ausgabewerte aufgrund von Eingabewertenund stoppen dann (z.B. Compiler).
• Interaktive Systeme stehen in ständiger Interaktion mit der Umwelt. Das zeitli-che Verhalten wird durch das System bestimmt. Es gibt keine Garantie für dieVerfügbarkeit der Services, das zeitliche Verhalten oder die Determiniertheit.Beispiele sind Betriebssysteme, Datenbanksysteme oder das Internet.
• Reaktive Systeme stehen wie interaktive Systeme in ständiger Interaktion mitihrer Umwelt. Die Umgebung stellt Anforderungen an die Verfügbarkeit, daszeitliche Verhalten und die Determiniertheit. Beispiele sind Prozesssteuerungenoder Signalprozessoren.
Große Systeme lassen sich oft nicht eindeutig zuordnen, sondern bestehen aus meh-reren Subsystemen, die den verschiedenen Kategorien angehören.
Bei reaktiven Systemen unterscheidet man weiter zwischen datenverarbeitenden(data handling) und steuerungsdominierten (control dominant) reaktiven Systemen.Datenverarbeitende reaktive Systeme produzieren permanent Ausgabewerte zu ihrenEingabewerten. Ein typisches Beispiel sind Signalprozessoren, z.B. in Audio- undVideoanwendungen als Filter oder zum En- und Decodieren. Steuerungsdominiertereaktive Systeme produzieren diskrete Ausgabesignale zu Eingabesignalen. Man fin-det solche Systeme z.B. in der Prozesssteuerung, in Eingebetteten Systemen, bei derÜberwachung von komplexen Systemen (z.B. als Sicherheitssystem um Fehlbedie-nungen und andere Anomalien zu erkennen) oder in Treibern und Controllern.
Genau wie in der physischen Welt verschiedene Ereignisse gleichzeitig ablaufen,müssen in Reaktiven Systemen oft mehrere Prozesse nebenläufig modelliert wer-den. Preemptionmechanismen werden benötigt, um einzelnen Prozessen dauerhaftoder temporär den Kontrollfluss zu entziehen. Um ein deterministisches Verhaltenzu gewährleisten, sollte ein statisches Scheduling der Prozesse möglich sein, und dieAusführungszeit sollte möglichst geringe Schwankungen (Jitter) aufweisen.
Synchrone Programmiersprachen [4] sind speziell auf diese Bedürfnisse zugeschnit-ten.
5
2. Grundlagen
2.2. Esterel
Esterel [6] ist eine nebenläufige, synchrone und imperative Programmiersprache,die auf die Implementierung von steuerungsdominierten Reaktiven Systemen zuge-schnitten ist.
J.-P. Marmorat und J.-P. Rigault stellten 1982 bei der Entwicklung eines auto-nomen Roboterautos fest, dass herkömmliche Programmiersprachen keine zufrie-denstellenden Ausdrucksmechanismen zur Darstellung zeitlicher Zusammenhängebereitstellten [18]. Sie erkannten die Notwendigkeit von Delay- und Preemption-Mechanismen und forderten, dass Signale (der Eingabe- und Ausgabe-, sowie Kom-munikationsmechanismus in Esterel) nur in diskreten Zeiteinheiten (Instanzen)wiederholt werden dürften. Daraufhin wurde von einer Forschergruppe unter Lei-tung von Gérard Berry am Centre de Mathématiques Appliqueés an der Ecole desMines in Paris die Sprache Esterel, sowie eine formale Semantik, erste Verifikati-onswerkzeuge und Compiler entwickelt.
Der Name der Programmiersprache leitet sich ab von dem Namen des französischenMittelgebirges „Esterel“, das zwischen Cannes und Saint-Raphaël an der Côte d’Azurgelegen ist. Der Name klingt ein wenig wie das französische Wort für Echtzeit: temps-réel. Esterel wird stetig weiterentwickelt und ist aktuell in der Version 7, welchezur Zeit als IEEE Standard bearbeitet wird. Die vorliegende Arbeit basiert auf demälteren Esterel V5 Standard, da dieser sehr etabliert und durch eine Vielzahl vonfreien Werkzeugen unterstützt wird. Version 7 unterscheidet sich hauptsächlich in derbesseren Unterstützung von Datentypen und einigen syntaktischen Erweiterungen.
Esterel wird herkömmlicherweise entweder nach C [8][29][16] oder eine Hardwa-rebeschreibung [5] in z.B. Verilog oder VHDL übersetzt. Im ersten Fall wird der CCode mit einem herkömmlichen Compiler für das Zielsystem (i.A. ein eingebette-ter Mikrocontroller) übersetzt. Im zweiten Fall dient die Hardwarebeschreibung zurKonfiguration eines FPGA oder Synthese eines ASIC.
Weitere synchrone Programmiersprachen sind Lustre [22] und Signal [21], derenEntwicklung ebenfalls auf die achtziger Jahre zurückgeht und deren Entwickler engmit der Esterel-Arbeitsgruppe zusammengearbeitet haben.
Eine grafische synchrone Sprache, die eng mit Esterel verwandt ist, ist Sync-Charts [1].
2.2.1. Synchronizität in Esterel
Bei herkömmlichen Programmiersprachen ist es schwierig, wenn nicht unmöglich, daszeitliche Verhalten oder die Determiniertheit zu beweisen. Synchrone Sprachen wieEsterel bedienen sich eines besonderen Formalismus zur Modellierung des zeitli-chen Verhaltens.
Definition 1 (Perfekte Synchronizität) Ein System arbeitet perfekt synchron,wenn alle Reaktionen des Systems ohne Zeitverzögerung ausgeführt werden. d.h. Aus-gaben werden zeitgleich zu den Eingaben produziert.
6
2.2. Esterel
Das Ideal der perfekten Synchronizität lässt sich in der Praxis nicht realisieren. Hierist „ohne Zeitverzögerung“ durch „rechtzeitig“, d.h. vor der nächsten Eingabe zu er-setzen. Im synchronen Programmiermodell wird die kontinuierliche physische Zeit ineine logische Zeitrepräsentation diskretisiert. Diese besteht aus abzählbaren Interak-tionen mit der Umwelt, den bereits in der Einleitung erwähnten Instanzen oder logi-schen Ticks. Innerhalb einer Instanz hat jedes Signal einen eindeutigen Status bzw.Wert und die Berechnung der Reaktion erfolgt – zumindest hypothetisch – unendlichschnell. Instanzen werden typischerweise in einer bestimmten Frequenz ausgeführt;die Intervallänge T zwischen zwei Ticks wird dabei von den Echtzeitanforderungendes Systems bestimmt. Jede Instanz besteht aus einer endlichen Anzahl von State-ments, die keine datenabhängigen Schleifen enthalten dürfen. Dies ermöglicht eineWorst Case Execution Time Analyse (WCET ) für die Dauer einer Instanz.
Esterel Statements, die in einer Instanz t ∈ N gestartet werden, enden in einerInstanz t + δ. Ist δ = 0, so spricht man von einem instantanen oder transientenStatement, ansonsten von einem delayed (verzögerten) oder temporalen Statement.
2.2.2. Syntax
In den folgenden Abschnitten wird eine kurze Beschreibung von Esterel V5 gege-ben, eine ausführliche Darstellung gibt der Esterel V5 Language Primer [7].
Signale und Sensoren
Der Nachrichtenaustausch innerhalb des Programms und mit der Umwelt erfolgtüber Signale und Sensoren. Signale lassen sich unterscheiden in Pure Signals undValued Signals:
• Pure Signals besitzen nur einen Status, der in Abhängigkeit, ob das Signal inder jeweiligen Instanz emittiert wurde, present oder absent sein kann.
• Valued Signals besitzen zusätzlich zum Status noch einen Wert. Es gibt nur fünfvordefinierte Datentypen zwischen denen keine implizite Konvertierung mög-lich ist: boolean, integer, float, double und string. Für valued Signals kannzusätzlich eine Combine-Funktion angegeben werden, die kommutativ und as-soziativ sein muss. Vordefiniert sind and und or für boolsche Signale und +und * für integer, float und double. Wird ein Signal ohne Combine Funkti-on mehrmals in einer Instanz emittiert, so ist dies ein Laufzeitfehler. Ist eineCombine Funktion angegeben, wird diese dazu genutzt, einen eindeutigen Wertzu ermitteln. Wird der Wert innerhalb einer Instanz mehrere Male abgefragt,ist der Wert immer der selbe.
Interface Signale können von der Art input, output, inputoutput oder returnsein. Zu beachten ist, dass input-Signale emittiert und output-Signale getestet bzw.gelesen werden können. Ein return Signal ist ein spezielles Eingangssignal. Es signa-lisiert die Beendigung eines externen Tasks, der mit dem exec-Statement ausgeführt
7
2. Grundlagen
wurde. Wie jedes andere input Signal können return-Signale einen Wert haben undes kann eine Combine-Funktion angegeben werden.
Im Interface können zusätzlich Input Relations angegeben werden. Input Rela-tions stellen weitere Bedingungen an input- bzw. return- Signale. Die Relationrelation A # B ist eine Inkompatibilitäts- oder Ausschlussrelation. Sie gibt an, dassdie Signale A und B nicht gleichzeitig auftreten dürfen. Die Relation relation A => Bist eine Implikationsrelation. Das Signal B darf nur present sein, wenn A present ist.
Im Gegensatz zu valued Signals als Eingangssignal besitzen Sensoren nur einenWert und keinen Status. Sie können jederzeit im Programm gelesen werden.
module EXAMPLE:input A; % deklariert Pure Signal A als Eingangssignalinput B := 0 : integer; % Eingangssignal B vom Typ ’integer’ mit initialem Wert ’0’input C : combine integer with +; % Eingangssignal C vom Typ ’integer’ mit Addition als Com-output O : integer; % Ausgangssignal O vom Typ ’integer’ \\ binefunktion
...
end module
Lokale Signale können überall innerhalb eines Programms deklariert werden. Diesgeschieht ähnlich wie für Interface Signale. Ein lokales Signal ist nur innerhalb desRumpfes der Deklaration gültig. Ein Signal kann innerhalb des Rumpfes erneut de-klariert werden, dabei ist das Signal der äußeren Deklaration in diesem Bereich nichtsichtbar. Steht eine lokale Signaldeklaration innerhalb einer Schleife, kann diese meh-rere Male in einer Instanz ausgeführt werden. Hierbei wird jedesmal eine neue Kopiedes Signals erstellt. Dieses Verhalten wird Reinkarnation genannt.
...loopsignal S inpresent S then emit O end present;pause;emit S;end signal
end loop...
Das vorstehende Programmfragment zeigt die lokale Deklaration des Signals Sinnerhalb einer Schleife. Der Status wird vor dem pause-Statement getestet und istin der ersten Instanz absent. Nach dem pause-Statement wird S emittiert, die Schleifeterminiert und startet den Rumpf instantan erneut. Obwohl S in der selben Instanzgetestet wird, ist es aufgrund der Reinkarnation absent.
Variablen
Im Gegensatz zu Signalen haben Variablen nur einen Wert und keinen Status undkönnen mehrere aufeinanderfolgende Werte innerhalb einer Instanz erhalten. Genauwie valued Signals können sie vom Typ boolean, integer, float, double oder stringsein. Sie können überall innerhalb des Programms deklariert werden. Ihr Gültigkeits-bereich ist der Rumpf p der Deklaration. Wird innerhalb des Rumpfes die Variable
8
2.2. Esterel
erneut deklariert, so ist die im äußeren Gültigkeitsbereich deklarierte Variable nichtsichtbar.
Im Gegensatz zu Signalen können sich mehrere Prozesse nicht eine Variable mitlesendem und schreibendem Zugriff teilen. Wird eine Variable in einem Thread ver-ändert, so kann der andere weder lesend noch schreibend auf die Variable zugreifen.Deshalb können Variablen nicht zur Kommunikation zwischen Threads eingesetztwerden.
Expressions
Es gibt in Esterel drei Arten von Expressions: Signal Expressions, Data Expressionsund Delay Expressions.
Signal Expressions sind Boolsche Ausdrücke über den Status mehrerer Signale.Sie sind das Argument eines present Signal Tests (s. Kap. 2.2.2) oder einer DelayExpression. Zur Verknüpfung sind die Operatoren not, and und or möglich und dieAusdrücke sind beliebig klammerbar. Auf den Status eines Signals oder einer SignalExpression in der vorigen Instanz kann mit pre() zugegriffen werden.
Data Expressions kombinieren die Werte von Signalen, Sensoren, Konstanten,Traps und Variablen. Auf Konstanten und Variablen kann direkt unter ihrem Namenzugegriffen werden. Den Wert eines Signals oder Sensors S erhält man über ?S undden Wert einer Trap1 T über ??T. Operatoren sind die folgenden:
• Boolsche Operatoren: not, and und or
• Vergleichsoperatoren: = für Gleichheit, <> für Ungleichheit, <, <=, > und >=
• Arithmetische Operatoren: +, -, * und /.
Außerdem sind die Ausdrücke beliebig klammerbar. Auf ein Signal S kann mitpre(?S) auf den Wert in der vorigen Instanz zugegriffen werden.
Delay Expressions werden in temporalen Statements wie await oder abort einge-setzt. Es gibt drei Formen von Delays:
• Standard Delays werden durch eine einfache Signal Expression angegeben, z.B.Meter and not Second. Delay Expressions können nicht in der ersten Instanzerfüllt werden, sondern erst in der nächsten Instanz, in der die Signal Expres-sion present ist.
• Immediate Delays können schon in der ersten Instanz erfüllt werden. Ein Im-mediate Delay startet mit dem Schlüsselwort immediate gefolgt von einemSignal Identifier oder von einer in eckigen Klammern [] geklammerten SignalExpression. Beispiel: immediate[Meter and not Second].
• Count Delays werden definiert durch einen ganzzahligen Zähler gefolgt voneinem Signal Identifier oder von einer in eckigen Klammern [] geklammertenSignal Expression.
1Traps sind der Exception-Handling Mechanismus in Esterel (s.Kap. 2.2.2)
9
2. Grundlagen
Beispiel:...await I1; emit O1
||await immediate I2; emit O2
||await 3 I3; emit O3
...
Der pre-Operator liefert den Status eines Signals oder einer Signal Expression bzw.Wert eines Signals in der vorigen Instanz:
• Den Status eines Signals S oder einer Signal Expression e in der vorigen Instanzerhält man mit pre(S) bzw. pre(e).
• Den Wert eines Signals S in der vorigen Instanz erhält man mit pre(?S)
Eine Schachtelung von pre-Operatoren ist dabei nicht erlaubt. In der ersten Instanzeines Signals S ist der Status pre(S)=absent. Ist das Argument jedoch eine SignalExpression e, werden zur Definition zwei Hilfsoperatoren verwendet: pre0(S) liefertden Wert von S in der vorigen Instanz mit dem Wert absent in der ersten Instanzund pre1(S) liefert den Wert von S in der vorigen Instanz mit dem Wert present inder ersten Instanz. pre(e) ist dann wie folgt definiert:
pre(e) = pre0(e)prei(e or e′) = prei(e) or prei(e
′)prei(e and e′) = prei(e) and prei(e
′)prei(not e) = notpre¬i(e)
Dabei gilt: ¬0 = 1 und ¬1 = 0.
Statements
Im Folgenden werden nur die wichtigsten Esterel Statements besprochen. Eineumfassende Dokumentation liefert der Esterel Primer [7].
• Sequenz und Paralleloperator
– p;q : p und q werden sequenziell ausgeführt: Ist p beendet, wird instantanq gestartet.
– p||q : Der Paralleloperator führt p und q als nebenläufige Threads aus.Er terminiert erst, wenn beide Threads terminiert sind.
• Instantane Statements
– nothing: Macht nichts und terminiert sofort.
– loop p end: Wiederholt den Rumpf p der Schleife unendlich. Der Rumpfselbst darf jedoch nicht instantan sein.
10
2.2. Esterel
– signal S in p end: Mit diesem Statement kann an jeder Stelle im Pro-gramm ein lokales Signal S deklariert werden. Der Gültigkeitsbereich istder Rumpf p. Wie im Abschnitt Signale schon besprochen wurde, könnenSignale redeklariert werden. Das Signal im äußeren Gültigkeitsbereich istim inneren Gültigkeitsbereich nicht sichtbar. Wird ein lokales Signal in-nerhalb einer Schleife deklariert, kann es zu mehreren Reinkarnationendes Signals kommen: D.h. es wird jedes mal eine neue Kopie des Signalsinstantiiert.
– emit S, emit S(e): Emittiert das Signal S, ein valued Signal ggf. mitdem Wert des Ausdrucks e.
– present S then p else q end: Testet den Status der Signal ExpressionS. Ist S present geht der Kontrollfluss instantan nach p, anderenfalls nachq.
– if E then p else q end: Ist die Data Expression E wahr, wird p unmit-telbar gestartet, ansonsten q.
• Delay Statements
– pause: Das pause-Statement terminiert in der nächsten Instanz.
– await delay do p end: Das await verzögert bis die Delay Expressiondelay zutrifft. Dann wird der optionale Rumpf p ausgeführt.
– every delay do p end: Das every Statement ist ein temporales Schleifen-konstrukt. Es wartet auf die Delay Expression delay und führt dann denRumpf p aus. Tritt die Delay Expression erneut auf, bevor p terminiertist, wird die Ausführung von p neu gestartet.
– sustain S, sustain S(e): Bleibt für immer aktiv und emittiert das SignalS (ggf. mit dem Wert der Expression e) in jeder Instanz. sustain S isteine Kurzschreibweise für loop emit S; pause end.
• Preemptive Statements
– suspend p when delay : Der Rumpf p wird suspendiert, wenn die DelayExpression delay zutrifft, ansonsten wird er wieder fortgesetzt. Dabei istzu beachten: Da die Zeit innerhalb von p angehalten wird, beginnt für eininnerhalb von p lokal definiertes Signal S nach dem Fortsetzen die nächsteInstanz, egal wie viele Instanzen global vergangen sind. D.h. pre(S) bzw.pre(?S) hat den Status bzw. den Wert zur Zeit der Suspendierung.
– [weak] abort p when delay : Beendet den Rumpf p, wenn die Delay Ex-pression zutrifft. Im Falle eines weak abort erhält der Rumpf ein letztesMal die Kontrolle.
• Exception Handling
11
2. Grundlagen
– trap T in p handle T do q end: Der Trap-Mechanismus ist der Exception-Handling Mechanismus von Esterel. trap T in p entspricht dem try{}-Block in C++ oder Java. Der Rumpf p wird instantan abgebrochen, wenninnerhalb von p ein exit(T) Statement ausgeführt wird. Dies entsprichtdem throw Statement in C++ oder Java. Optional kann für jeden Trapein bestimmter Handler aufgerufen werden. Dies entspricht dem catch inC++ oder Java. Als Erweiterung unterstützt Esterel Valued Traps mitdenen zusätzlich ein Fehlercode geworfen werden kann.
Als Pure Esterel wird eine Teilsprache von Esterel bezeichnet. In Pure Es-terel gibt es nur Pure Signals und keine valued Signals. Die Menge der State-ments ist reduziert auf eine nicht-redundante Teilmenge aller Esterel Statements,aus denen sich die übrigen Statements ableiten lassen. Die Menge dieser so ge-nannten Kernel Statements umfasst folgende Elemente: nothing, emit S, pause,present S then p else q, suspend p when S, p;q, loop p end, p || q,trap T in p end, exit T und signal S in p end.
2.2.3. Semantiken von Esterel
Bevor ein Esterel Programm kompiliert wird, muss zunächst eine semantische Ana-lyse erfolgen, da ein syntaktisch korrektes Esterel Programm nicht in jedem Fallsemantisch korrekt ist. Gründe hierfür sind die instantane Signal- und Kontroll-übertragung innerhalb einer Instanz. Im Laufe der Entwicklung von Esterel wur-den verschiedene Semantiken entwickelt: Logical Behavioral Semantics, ConstructiveBehavioral Semantics, Logic/Constructive State Behavioral Semantics, ConstructiveOperational Semantics und Constructive Circuit Semantics, wobei die konstruktivenSemantiken äquivalent sind. Eine formale Einführung in diese Thematik findet sichin [6].
Logische Korrektheit
Ein Programm ist logisch reaktiv bezüglich einer Eingabe, wenn mindestens ein lo-gisch kohärenter globaler Zustand existiert. Ein Programm ist logisch deterministischbezüglich einer Eingabe, wenn höchstens ein logisch kohärenter globaler Zustand exis-tiert. Logische Kohärenz bedeutet, dass ein Signal genau dann den Status presenthat, wenn es in der selben Instanz emittiert wurde.
Definition 2 Ein Programm ist logisch korrekt, wenn es logisch reaktiv und deter-ministisch ist.
Das bedeutet, dass es in jeder Instanz zu einer Eingabe genau eine mögliche Reaktiongibt. Das folgende Listing2 zeigt ein logisch korrektes Programm:
module P2:signal S in
2Quelle für die alle Listings im Abschnitt 2.2.3: The Constructive Semantics of Pure Esterel [6]
12
2.2. Esterel
emit S;present O thenpresent S thenpause
end;emit O
endend signalend module
Die einzig logisch kohärente Annahme ist S present und O absent : Würde man bei-spielsweise O als present annehmen, würden die Statustests present O und present Szutreffen und das pause Statement ausgeführt werden. Die Anweisung emit O würdeerst in der nächsten Instanz ausgeführt werden, was im Widerspruch zu der AnnahmeO present steht.
Die folgenden beiden Programme sind nicht logisch korrekt:module P3:output O;
present O else emit O endend
module P4:output O;
present O then emit O end
Das erste Programm ist nicht reaktiv, da für alle Belegungen von O kein logisch ko-härenter Zustand existiert; das zweite ist nicht deterministisch, da beide AnnahmenO absent und O present logisch kohärent sind.
Nachteil der Analyse auf logische Korrektheit ist die wenig intuitive self-justification.Zum Beispiel möchte man, dass das im folgenden Listing gezeigte, logisch korrekteProgramm, das eine Kombination aus P3 und P4 darstellt, abgelehnt wird:
module P9:present O1 then emit O1 end
||present O1 thenpresent 02 else emit O2 end
end
Hier gibt es genau eine logisch kohärente Annahme: O1 und O2 absent. Hier recht-fertigt z.B. die Annahme O1 absent, dass emit O1 nicht ausgeführt wird.
Konstruktivität
Bei der Konstruktivitätsanalyse wird die Kausalität des Informationsflusses berück-sichtigt, es werden keine spekulativen Annahmen gemacht. Es wird für jedes Signalin einer Instanz statisch berechnet, ob es emittiert werden muss (must) oder nichtemittiert werden kann (cannot). Kann über ein Signal keine Aussage getroffen wer-den, wird das Programm abgelehnt. Konstruktivität stellt ein schärferes Kriteriumzum Annehmen bzw. Ablehnen eines Programms dar, als die Logische Korrektheit.Dabei gilt: Jedes konstruktive Programm ist auch logisch korrekt.
Bei der Konstruktivitätsanalyse wird das Programm P9 abgelehnt, da für O1 undO2 kein Status ermittelt werden kann.
13
2. Grundlagen
Sowohl die Überprüfung von logischer Korrektheit als auch die Überprüfung vonKonstruktivität sind sehr aufwändig. Der Nachweis der logischen Korrektheit ist NP-Vollständig, die Konstruktivitätsanalyse ist quadratisch zur Programmgröße. Daherwird häufig lediglich gefordert, dass das Programm zyklenfrei ist, d.h. dass keinezyklischen Signalabhängigkeiten existieren. Da die azyklischen Programme eine Teil-menge der konstruktiven Programme bilden, ist damit sicher gestellt, dass das Pro-gramm konstruktiv ist. Es existieren aber auch Programme mit zyklischen Signalab-hängigkeiten, die konstruktiv sind. Ein Beispiel dafür ist der Token Ring Arbiter [7,S. 93]. Allerdings kann jedes konstruktive, zyklische Programm in ein äquivalentesazyklisches umgewandelt werden [25].
2.3. Synthese von Esterel
Ein Esterel Programm wird herkömmlicherweise in eine andere nicht-synchroneSprache wie C oder VHDL übersetzt und dann in Software oder Hardware syntheti-siert. Co-Designs sind hybride Ansätze aus Software- und Hardwaresynthese. Einenneueren Ansatz stellen Reaktive Prozessoren dar, deren Befehlssatz eine direkte Aus-führung von Esterel oder einer anderen Synchronen Sprache erlauben.
2.3.1. Software- und Hardwaresynthese
Bei der Softwaresynthese [8][16][29] wird ein Esterel Programm zunächst in eineandere Programmiersprache wie C oder Java übersetzt und anschließend mit einementsprechenden Compiler für das Zielsystem übersetzt. Das Zielsystem kann z.B. eineingebetteter Mikrocontroller oder auch ein PC sein. Bei der Hardwaresynthese [5]wird ein Esterel Programm in die Beschreibung eines elektronischen Schaltkreises(z.B. in BLIF, Verilog oder VHDL) überführt. Aus der Hardwarebeschreibung kannein ein anwendungsspezifischer Schaltkreis (ASIC) oder ein Schaltkreis auf einemField Programmable Gate Array (FPGA) synthetisiert werden. Die Übersetzungerfolgt über Automaten-, Netzlisten- und Kontrollflussgraphen-basierte Ansätze.
• Automaten-basiert : Jedes Esterel Programm lässt sich als einzelner Zustands-automat oder als eine Kombination aus mehreren Zustandsautomaten darstel-len. In einem weiteren Schritt wird die Beschreibung des Zustandsautoma-ten zur Softwaresynthese in eine gewöhnliche Programmiersprache wie C, oderzur Hardwaresynthese in eine Hardwarebeschreibungssprache wie VHDL (vgl.VHDL-Synthese Kap.6) übersetzt. Implementiert wird dieses Verfahren bei-spielsweise durch den Esterel V5 Compiler. Der erzeugte Code ist zwar sehrschnell, kann aber schon für kleine Programme sehr groß werden, da sich bei derKombination von mehreren parallelen Automaten ihre Zustände multiplizierenkönnen, was zu einem exponentiellen Wachstum führt, der sog. Zustandsexplo-sion.
• Netzlisten-basiert : Die Transformation eines Esterel Programms in eine Netz-liste erfolgt analog zu der Constructive Circuit Semantics. Für jedes Esterel
14
2.3. Synthese von Esterel
Statement sind bestimmte Hardware-Templates definiert, so dass die Überset-zung in eine Netzliste „mechanisch“ erfolgen kann. Dieser Schaltkreis kann dannentweder simuliert oder in Hardware synthetisiert werden. Implementiert wirddieses Verfahren beispielsweise durch den Esterel V5 Compiler. Der Code ist li-near mit der Größe des Esterel Programms und damit wesentlich kompakterals bei dem Automaten-basierten Ansatz, aber auch deutlich langsamer.
• Kontrollflussgraphen-basiert : Aus dem Esterel Programm wird als Zwischen-repräsentation ein nebenläufiger Kontrollflussgraph generiert. Dieser wird zu-nächst in einen sequenziellen Kontrollflussgraphen transformiert, um ein Pro-gramm mit einem statischen Scheduling zu erzeugen. Der generierte Code istkompakt und schnell, die Anforderungen an das Esterel Programm sind je-doch restriktiver. So werden beispielsweise Programme mit zyklischen Signal-abhängigkeiten abgelehnt.
Softwaresynthese ist zwar sehr flexibel und kostengünstig, es ist jedoch sehr auf-wändig, reaktive Kontrollflussstrukturen und Nebenläufigkeit für einen SequentiellenProzessor zu modellieren. Bei der Hardwaresynthese muss auch bei kleinen Änderun-gen am Programm die gesamte Hardware neu synthetisiert werden; datenintensiveBerechnungen lassen sich in Hardware nur ungünstig implementieren. Für EsterelV5 lässt sich zudem nur Pure Esterel in Hardware implementieren.
2.3.2. Co-Design
Co-Design-Ansätze, wie z.B. Polis oder Metropolis [2, 3], vereinen Ansätze fürSoftware- und Hardwaresynthese. Die Ausführungsplattform besteht aus einem Mi-krocontroller und einer mit ihm verbundenen, benutzerspezifischen Hardware. EinEsterel Programm wird partitioniert in einen Hardware- und Softwareteil, sowieein Interface zwischen Hard- und Software. Die Partitionierung richtet sich danach,ob bestimmte Programmmodule besser in Software oder in Hardware synthetisiertwerden können. Dadurch lassen sich einige Nachteile der reinen Hardware- und Soft-warelösungen beseitigen. Man erbt jedoch die geringe Flexibilität der Hardwarelö-sung und behält einen hohen Aufwand für die Implementierung von Kontrollstruk-turen.
2.3.3. Reaktive Prozessoren
Bei der reinen Softwaresynthese erhält man durch die aufwändige Implementierungreaktiver Kontrollstrukturen einen sehr unhandlichen Programmcode. Mit so genann-ten Gepatchten Reaktiven Prozessoren, wie im RePIC oder ReFLIX [13, 31]-Ansatz,versucht man diesem Problem zu begegnen. Hierbei handelt es sich um gewöhnli-che Mikrocontroller mit einem Patch. Der Patch ist ein externer Hardwareblock, derden Befehlssatz des Mikrocontrollers um reaktive Instruktionen erweitert. ReFLIXunterstützt jedoch nicht die direkte Ausführung von Esterel und hält auch nichtvollständig die Esterel Semantik ein. RePIC unterstützt nur eine Teilmenge von
15
2. Grundlagen
Esterel, es fehlen Konstrukte für Suspendierung und Multithreading. Eine Multi-prozessorerweiterung von RePIC stellt der EMPEROR [14] dar, der die Behandlungdes Paralleloperators erlaubt.
Ein Reaktiver Prozessor, dessen Befehlssatz und Architektur speziell auf die Syntaxund Semantik von Esterel ausgelegt sind, wird im folgenden Kapitel vorgestellt.
2.4. Kiel Esterel Prozessor (KEP)
Der Befehlssatz und die Architektur des Kiel Esterel Processors KEP [35, 23] sindim Gegensatz zu den gepatchten reaktiven Prozessoren speziell für die Syntax undSemantik von Esterel ausgelegt.
Zur Unterstützung von Preemptions verfügt der KEP über eine konfigurierbareAnzahl von Wächtern (Watcher). Diese überwachen das Auftreten von Signalen, dieeine Preemption triggern, sofern sich der Programmzähler im Rumpf der Preemptionbefindet.
Zur Unterstützung von Nebenläufigkeit verwaltet der KEP für jeden Thread eineneigenen Programmzähler. Das Scheduling erfolgt prioritätsbasiert: In jedem Instruk-tionszyklus wird der Thread mit der höchsten Priorität ausgeführt. Prioritäten wer-den bei der Initialisierung von Threads vergeben und können über spezielle State-ments für den aktiven Thread geändert werden (s. Kap. 2.4.2).
2.4.1. Architektur
Abb. 2.1.: Schematische Darstellung der KEP Architektur (Quelle: [24])
In Anlehnung an die drei Ebenen (interface layer, reactive kernel und data handlinglayer), aus denen ein reaktives Programm besteht, bilden drei Blöcke die Haupt-
16
2.4. Kiel Esterel Prozessor (KEP)
komponenten der KEP Architektur: Der Data Handlig Block, der Reactive Multi-Threading Core und der Interface Block. Eine schematische Darstellung der KEPArchitektur ist in Abbildung 2.1 zu sehen.
Der Data Handling Block ermöglicht die Berechnung von Expressions. Er bestehtaus einem Register zum Speichern von Variablenwerten und Zwischenergebnissenund einer ALU.
Der Reactive Multi-Threading Core steuert den Kontrollfluss des Programms. Erstellt Strukturen zur Behandlung von Nebenläufigkeit, Preemption, Exceptions undDelays bereit.
Im Interface Block werden zum einen der Status und der Wert aller Signale, auchder lokalen Signale, gespeichert und zum anderen bildet er die Schnittstelle zur Um-welt. Zur Speicherung des Status der Signale dient das SinoutReg Register. Die Wertevon valued Signals werden in einem RAM, dem SDatReg, gespeichert.
Der KEP führt Ticks (Instanzen) mit einer festen Frequenz aus. Bis zum Be-ginn des nachfolgenden Ticks müssen alle Instruktionen des aktuellen Ticks abge-arbeitet sein. Alle KEP Assembler Instruktionen benötigen physikalisch bedingt ei-ne bestimmte Zeit, können aber innerhalb eines Instruktionszyklus (entspricht dreiProzessortaktzyklen) ausgeführt werden. Der TickManager steuert die Initiierungneuer Ticks. Das reservierte Signal _TICKLEN gibt dem TickManager die Dauer einesTicks in Prozessortaktzyklen an. Das Signal wird am Anfang des Programms überemit _TICKLEN,x gesetzt. Sind alle Instruktionen einer Instanz abgearbeitet, wartetder Prozessor bis zum Anfang der nächsten Instanz. Die minimale _TICKLEN ist diemaximal mögliche Anzahl an KEP Assembler Instruktionen, die pro Instanz ausge-führt werden können. Eine konservative Näherung für diesen Wert liefert die WorstCase Reaction Time Analyse (WCRT) [9]; sie berechnet eine obere Schranke für dieminimale _TICKLEN.
2.4.2. Befehlssatz
Der Befehlssatz des KEP umfasst die Esterel Kernel Statements sowie eine Aus-wahl an komplexeren Statements, um den resultierenden Code möglichst kompakthalten zu können. Hinzu kommt die Unterstützung von Esterel Expressions, ins-besondere Delay Expressions (standard, immediate, count), sowie die Unterstützungvon valued Signals und des pre-Operators. Da sich die meisten Esterel Statementsdirekt in KEP Assembler Instruktionen abbilden lassen, können die meisten Este-rel Statements innerhalb eines Instruktionszyklus abgearbeitet werden.
17
2. Grundlagen
Esterel Syntax KEP Assembler Anmerkungen
[p1
||
...||
pn
]
PAR prio1, startAddr1, id1...
PAR prion, startAddrn, idn
PARE endAddrstartAddr1:
...startAddrn:
...endAddr:JOIN
Die PAR Anweisung erzeugt einen neu-en Thread mit der Priorität priox undder Threadnummer idx. Der Threadstartet im Speicher bei der Adres-se startAddrx und endet vor derStartadresse des nächsten Threads.PARE initialisiert das Ende des letztenThreads und JOIN wartet auf das ter-minieren aller in diesem Block erzeug-ten Threads.
PRIO prioSetzt die Priorität des aktuellenThreads.
signal S in ... end SIGNAL S Initialisiert ein lokales Signal S.emit S[(val)] EMIT S [, {#data|reg}] Emittiert ein (valued) Signal S.
sustain S[(val)] SUSTAIN S [, {#data|reg}]Emittiert in jeder Instanz ein (valued)Signal S.
present S then ... end PRESENT S, elseAddrPRESENT ist implementiert als be-dingter Sprung: Springt zu AdresseelseAddr, falls S absent ist.
nothing NOTHING Führt keine Operation aus.halt HALT Wird für immer ausgeführt.loop ... end loop GOTO addr Unbedingter Sprung zu addr.
pause PAUSEWartet auf ein Signal. AWAIT TICK istäquivalent zu PAUSE.await [count] S AWAIT [count] S
await immediate S AWAITI S
awaitcase [immediate] S1 do p1...case [immediate] Sn do pn
end await
CAWAIT[I] S1, addr1...
CAWAIT[I] Sn, addrn
CAWAITE
Wartet gleichzeitig auf mehrere Signa-le.
[weak] abort...
when [count] S
[W]ABORT [count] S endAddr...
endAddr: Delayed und immediate Version desABORT Statements. Der Body des ABORTStatements endet bei endAddr.[weak] abort
...when immediate S
[W]ABORTI S endAddr...
endAddr:
suspend...
when [{immediate|count}] S
SUSPEND[{I| count}] S, endAddr...
endAddr:
Delayed und immediate Versiondes SUSPEND Statements. Der Bodydes SUSPEND Statements endet beiendAddr.
trap T in...exit T...
end trap
startAddr:...EXIT exitAddr, startAddr...
exitAddr:
EXIT beendet einen Trap Scope der beistartAddr beginnt und bei exitAddrendet. Im Gegensatz zu GOTO werdennebenläufige EXITs berücksichtigt undeingeschlossene || Operatoren been-det.
Tab. 2.1.: Einige wichtige Esterel Statements und ihre Entsprechungen in KEP(3a)Assembler Code
18
2.4. Kiel Esterel Prozessor (KEP)
EMIT S
suc_c
(a) transient
A0
suc_c
(b) label
PAUSE
suc_c suc_s
s
suc_w
w
suc_e
e
(c) delay
PAR*
suc_c
(d) fork
JOIN
suc_c suc_e
e
(e) join
Abb. 2.2.: Nodes and edges of a Concurrent KEP Assembler Graph (CKAG).
Tabelle 2.1 gibt einen Überblick über wichtige Esterel Statements und ihrenEntsprechungen in KEP Assembler Code. Für alle Statements, die sich nicht direkt inKEP Assembler Instruktionen abbilden lassen, gibt es wohldefinierte Übersetzungenin Kernel Statements bzw. vorhandene KEP Assembler Statements. Ein Beispielfür ein im KEP Instruktionssatz fehlendes Esterel Statement ist z.B. every. Dasfolgende Beispiel zeigt die Übersetzung des Statements every S do p end:
...await Sloopp
each S...
...await Sloopabortphalt
when Send loop...
...abortloop
pauseend loop
when S;loopabort
plooppause
end loopwhen S
end loop...
Im Prinzip werden alle im zweiten Übersetzungsschritt auftretenden Statementsdurch den KEP unterstützt. In einigen Fällen ist es für die Festlegung eines korrektenSchedulings bei Delay Statements, die über mehrere Instanzen hinweg gültig seinkönnen, jedoch notwendig, diese noch weiter aufzulösen. Sollte ein solcher Fall nichteintreten, so wird der entsprechende Code wieder kollabiert.
2.4.3. Esterel2KASM Compiler
Um ein Esterel Programm auf dem KEP ausführen zu können, muss dieses mitHilfe des Esterel2KASM Compilers [23] zunächst in ein äquivalentes KEP Assemb-ler Programm übersetzt werden. Der Esterel2KASM Compiler kann dabei nur einebestimmte Teilmenge der zyklenfreien Esterel Programme übersetzen. Nach ei-ner Expansion aller run Statements durch die entsprechenden Module als Vorver-arbeitungsschritt werden zunächst alle Esterel Statements in die entsprechendenAssemblerinstruktionen aufgelöst.
Gleichzeitig wird der zu dem Programm gehörige Concurrent KEP AssemblerGraph (CKAG) aufgebaut. Die CKAG Datenstruktur ist ein ungerichteter Graph,
19
2. Grundlagen
die aus verschiedenen Knoten- und Kantentypen gebildet wird. Die Datenstrukturwird als Zwischenrepräsentation des Esterel Programms benutzt, die während desKompiliervorgangs für die Berechnung des Schedulings (durch Zuweisung von Pro-zessprioritäten), für die Eliminierung von nicht erreichbarem Code, für Optimierun-gen des KEP Assembler Codes und für die Berechnung der Worst Case Reaction Time(WCRT) benutzt wird. Transiente Knoten (in der grafischen Darstellung repräsen-tiert durch ein Rechteck) repräsentieren instantane Statements, Delay Knoten (Acht-eck) repräsentieren Statements, die für eine oder mehrere Instanzen verzögern, Fork-und Joinknoten (Dreieck) repräsentieren Nebenläufigkeit und Label Knoten (Ellipse)repräsentieren Sprungmarken oder den Beginn bestimmter Blöcke. Zu jedem Knotenn gibt es eine Menge von Nachfolgeknoten n.suc_c im sequenziellen Programmfluss.Diese werden über durchgezogene Kanten in der grafischen Darstellung repräsentiert.Nachfolgeknoten beim Auftreten einer Preemption sind n.suc_s bei Strong Aborts,n.suc_w bei Weak Aborts und n.suc_t bei Exceptions, die als gestrichelte Kantenrepräsentiert sind. Je nach Kontext werden bei der Erstellung von Delay Knotenzusätzlich Abort- und Exceptionkanten erzeugt. Ein weiterer Kantentyp sind De-pendency Kanten (gepunktete Kanten), die Signalabhängigkeiten zwischen Threadsdarstellen. Eine Dependency Kante zeigt dabei vom Writer eines Signals (z.B. emitoder sustain) zum Reader eines Signals (z.B. present oder every). Reader-WriterBeziehungen werden benötigt, um bei der Berechnung des Schedulings die Thread-prioritäten so zu vergeben, dass Writer eines Signals vor den Readern ausgeführtwerden.
1 module CKAGexample:2
3 input SET_A;4 output O;5
6 signal A in7 [8 await SET_A do9 emit A
10 end11 ||12 abort13 sustain O14 when A15 ]16 end signal17
18 end module
[L0,T0,P1] module: CKAGexample
[L3,T0,P1/1] PAR*
[L4,T2,P1] A0
1
[L7,T1,P1] A1
1
[L5,T2,P1/1] AWAIT SET_A
[L6,T2,P1] EMIT A
[L9,T1,P1/1] SUSTAIN O
d
[L13,T0,P1] JOIN 0
[L8,T1,P1] ABORT A,A5
[L10,T1,P1] A5
As
[L11,T1,P1] NOTHING
[L14,T0,P1/1] HALT
1 %% module CKAGexample:2
3 INPUT SET_A4 OUTPUT O5 SIGNAL A6 EMIT _TICKLEN,#77
8 [L01,T0,P1] PAR 1,A0,29 [L02,T0,P1] PAR 1,A1,1
10 [L03,T0,P1/1] PARE A2,111 [L04,T2] A0: AWAIT SET_A12 [L05,T2,P1] EMIT A13 [L06,T1,P1] A1: ABORT A,A514 [L07,T1] SUSTAIN O15 [L08,T1,P1] A5: NOTHING16 [L09,T0,P1] A2: JOIN 017 [L10,T0,P1/1] HALT
Abb. 2.3.: CKAG Beispiel
20
2.5. Logikminimierung
Abbildung 2.3 zeigt für ein einfaches Beispielprogramm den Aufbau des zugehö-rigen CKAG. Das Esterel Programm besteht aus zwei Threads. Der erste Threadwartet auf das Auftreten des Eingangssignals SET_A und emittiert dann das lokaleSignal A. Das sustain O Statement des zweiten Threads liegt innerhalb eines abortRumpfes, der beendet wird, wenn A present ist.
Im CKAG wird der Kontrollfluss über einen Forkknoten in zwei Threads aufgeteiltund am Ende der Threads über einen Joinknoten wieder zusammengeführt. Der Co-de für den ersten Thread beginnt bei Label A0 und für den zweiten bei Label A1. Dersequenzielle Programmfluss im ersten Thread geht vom Labelknoten A0 über den De-lay Knoten await SET_A und den transienten Knoten emit A in den Joinknoten. Imzweiten Thread deklariert der transiente Knoten abort A,A5 den Beginn des abortRumpfes an dieser Stelle, das Ende des Rumpfes bei Label A5 und das TriggersignalA. Der Delay Knoten sustain O liegt im Rumpf des abort ... when A Statements.Über eine Strong Abort Kante, die durch das Signal A getriggert wird, kann vomKnoten sustain O der Labelknoten A5 erreicht und damit der Rumpf des abortStatements beendet werden. Die Dependency Kante zwischen dem emit A Knotenund dem sustain O Knoten im zweiten Thread zeigt an, dass der sustain O Knotenein Reader von A ist und dass infolgedessen emit A zuerst ausgeführt werden muss.
2.5. Logikminimierung
In der digitalen Schaltungstechnik unterscheidet man zwischen Schaltnetzen (combi-natorial circuit) und Schaltwerken (sequential circuit). Schaltnetze verknüpfen meh-rere Eingangssignale (Pegel logisch Null oder eins) zu einem oder mehreren Ausgangs-signalen. Schaltnetze sind „gedächtnisfrei“; der Pegel der Ausgangssignale ergibt sichdirekt aus den Eingangssignalen. Im Gegensatz zu Schaltnetzen haben Schaltwerkeein „Gedächtnis“. Dies erreicht man durch eine zeitlich verzögerte Rückkopplung derAusgangssignale.
Mathematisch lässt sich das Ein-/Ausgabeverhalten von Schaltnetzen durch durchBoolsche Funktionen beschreiben. Eine Boolsche Funktion ist wie folgt definiert:
Definition 3 f : {0, 1}n → {0, 1}m heißt Boolsche Funktion mit n Variablen und mAusgängen.
Jede Boolsche Funktion mit m Ausgängen lässt sich auch als ein m-dimensionalerVektor (f1, ..., fm) von Boolschen Funktionen mit n Variablen und einem Ausgangauffassen.
Als ON-Menge einer Boolschen Funktion f mit n Variablen und einem Ausgangbezeichnet man alle Elemente α ∈ {0, 1}n für die f(α) = 1 gilt. Die Elemente vonON(f) bezeichnet man als Minterme. Als OFF-Menge von f bezeichnet man alleElemente α ∈ {0, 1}n für die f(α) = 0 gilt.
Eine Beschreibungsmöglichkeit für Boolsche Funktionen sind Boolsche Ausdrücke.
Definition 4 Die Menge der Boolschen Ausdrücke über der Variablenmenge X =
21
2. Grundlagen
{x1, ..., xn} ist die kleinste Teilmenge der endlichen Folgen über dem Alphabet X ∪{0, 1, ·,+, (, ), a} für die gilt:
1. Die Literale 0 und 1 sind Boolsche Ausdrücke
2. Die Variablen x1, ..., xn sind Boolsche Ausdrücke
3. Sind ω1, ..., ωk Boolsche Ausdrücke, dann auch die Konjunktion (ω1 · ... · ωk)und die Disjunktion (ω1 + ... + ωk)
4. Ist ω ein Boolscher Ausdruck, dann auch die Negation bzw. das Komplementω
Es gibt 22n verschiedene Boolsche Funktionen aber eine unendliche Anzahl ver-schiedener Ausdrücke. So geben z.B. die Ausdrücke f(x, y) = x+y = xy+xy+xy =xx + xy + y die gleiche Boolsche Funktion f wieder.
Ziel der Logikminimierung ist es, eine möglichst günstige Repräsentation einerBoolschen Funktion zu finden. Kostenkriterien sind dabei der Verbrauch von Chip-fläche, die Laufzeit des kritischen Pfades, der Stromverbrauch usw. In den folgendenAbschnitten werden verschiedene Verfahren für die zwei- und mehrstufige Logiksyn-these vorgestellt. Eine gute Einführung in die Thematik liefern z.B. Molitor undScholl [27].
2.5.1. Datenstrukturen und Algorithmen
Die Minimierungsstrategie ist abhängig von der eingesetzten Technologie auf der dieFunktion implementiert werden soll.
Programmable Logical Arrays (PLA) erlauben zweistufige Realisierungen von Lo-gikfunktionen. In der ersten Stufe (AND-Feld) werden Konjunktionen von den nicht-negierten und negierten Eingangssignalen gebildet. In der zweiten Stufe (OR-Feld)werden die Zwischenergebnisse durch Disjunktionen zusammengefasst. ZweistufigeRealisierungen werden allgemein über Polynome beschrieben.
Definition 5 Literal, Monom, Polynom Sei X = {x1, ..., xn} die Variablenmenge.
• Ein Boolscher Ausdruck xi ist ein positives und xi ein negatives Literal.
• Ein Monom ist ein Produkt von Literalen. Die Länge eines Monoms Länge(mj)ist gegeben durch die Anzahl der in diesem Produkt verwendeten Literale.
• Ein Polynom ist eine Summe von Monomen.
Monome und Polynome lassen sich anschaulich als n-dimensionale Würfel darstel-len. Der Grad n richtet sich nach der Anzahl der Eingangsvariablen. Jedem Eckkno-ten ist eine Variablenbelegung zugeordnet. Liegt die Variablenbelegung eines Knotensin der Menge ON(f), so wird der Knoten markiert. Abbildung 2.4 zeigt die Darstel-lung der Funktion f : B3 → B = x1x2x3 + x3 als Würfel. Rechnerintern werdenPolynome als Matrix dargestellt.
22
2.5. Logikminimierung
000 100
010 110
001 101
011 111
Abb. 2.4.: Würfeldarstellung der Funktion f : B3 → B = x1x2x3 + x3
Field Programmable Gate Arrays (FPGA) erlauben mehrstufige Realisierungenvon Logikfunktionen. Sie bestehen aus einer Matrix von konfigurierbaren Logik-blöcken (CLB), die über horizontale und vertikale Verdrahtungskanäle miteinanderverdrahtet werden können. Je nach Hersteller sind die CLBs look-up table basiert(Xilinx) oder Multiplexer basiert (Actel).
Datenstrukturen, die zur Synthese mehrstufiger Realisierungen eingesetzt werden,sind Logische Netzwerke und Binäre Entscheidungsgraphen (Binary Decision Dia-gram, BDD).
Ein logisches Netzwerk besteht aus Eingangsknoten (den Variablen der Funktion),Ausgangsknoten (den Funktionswerten) und inneren Knoten, die eine Teilfunktionberechnen. Es gibt genau dann eine Kante zwischen vom Knoten v1 zu v2, wenn derAusdruck in v2 die Variable v1 enthält. Logische Netzwerke werden im Rahmen vonalgebraischen Methoden zur mehrstufigen Logiksynthese eingesetzt.
Eine spezielle Form von BDDs, die reduzierten geordneten binären Entscheidungs-graphen, wurden 1986 von Bryant [11] eingeführt. BDDs finden in vielen Bereichendes logischen Entwurfs digitaler Schaltungen Anwendung, z.B. bei der formalen Ve-rifikation oder der zwei- und der mehrstufigen Logiksynthese. Zudem lässt sich dieBDD Darstellung einer boolschen Funktion fast eins-zu-eins auf Multiplexer basier-ten FPGAs implementieren. Bei Funktionen mit vielen Mintermen liefern BDDs ofteine wesentlich günstigere Repräsentation.
Minimierung zweistufiger Realisierungen
Bei der Zweistufigen Logikminimierung wird versucht, eine Überdeckung der in ei-nem n-dimensionalen Würfel markierten Knoten zu finden, die aus möglichst we-nigen maximalen Teilwürfeln besteht und keine nichtmarkierten Knoten enthaltendarf. Die bekanntesten exakten Verfahren zur zweistufigen Logikminimierung sindKarnaugh-Veitch-Diagramme (KV-Diagramme) und das Verfahren von Quine undMcCluskey. Exakte Verfahren zur Logikminimierung sind exponentiell [27, Abschnitt3.3]. Wesentlich schnellere Berechnungen bei nicht garantierter Optimalität liefertdas Espresso [10] Verfahren. Espresso II ist eines der bekanntesten und effizientesten
23
2. Grundlagen
heuristischen Verfahren zur zweistufigen Logikminimierung. Es entstand 1979 auseiner gemeinsamen Arbeit vom IBM Watson Research Center und der University ofCalifornia Berkeley.
Neben den Würfelbasierten Minimierungsverfahren gibt es auch exakte und heu-ristische zweistufige Minimierungsverfahren auf Basis von BDDs. Als heuristischesVerfahren ist das Verfahren von Minato [26] zu nennen. Insbesondere bei Funktionenmit vielen Mintermen stellt dieses Verfahren eine Alternative zu Espresso dar.
Minimierung mehrstufiger Realisierungen
Zweistufige Verfahren zur Logikminimierung sind sehr etabliert und gut erforscht.Zweistufige Realisierungen lassen sich zudem direkt auf PLAs implementieren. In vie-len Fällen sind mehrstufige Realisierungen einer Boolschen Funktion jedoch kosten-günstiger als ihre minimierte zweistufige Realisierung. Bei Boolschen Funktionen mitmehreren Ausgängen können beispielsweise gemeinsame Faktoren in der Berechnungmehrerer Ausgänge auftreten. Auch für Boolsche Funktionen mit nur einem Ausgangkann eine mehrstufige Realisierung wesentlich kostengünstiger sein als die zweistufige.Ein Beispiel hierfür ist die Paritätsfunktion parity(x1, ..., xn) = (
∑ni=1 xi) mod 2.
Das Minimalpolynom dieser Funktion besteht aus 2n−1 Primimplikanten. Bei einerMehrstufigen Implementierung kommt man mit n − 1 xor-Gattern mit je zwei Ein-gängen aus.
Das Hauptproblem bei der mehrstufigen Synthese ist es, eine geeignete Zerlegungder boolschen Funktion zu finden. Weit verbreitet sind algebraische Verfahren, wiesie von Brayton, Hachtel und Sangiovanni Vincentelli [10] eingeführt wurden. Dasin dieser Arbeit benutzte Programm MV-SIS benutzt algebraische Verfahren zurfunktionalen Zerlegung. Eine Funktion wird als logisches Netzwerk repräsentiert.Operationen, zur Optimierung eines logischen Netzwerkes sind:
• Lokale Optimierung Hierbei wird auf den einzelnen Knoten des Netzwerkeseine zweistufige Logikminimierung (z.B. Espresso) angewandt. In MV-SIS wirddies durch die Kommandos simplify oder fullsimp erreicht.
• Eliminierung von Knoten Hat ein innerer Knoten den Ausgangsgrad 1, d.h.ist nur ein anderer Knoten von ihm abhängig, kann es u.U. kostengünstiger sein,ihn zu eliminieren und im abhängigen Knoten zu substituieren.
• Zerlegung eines Knotens Statt der Eliminierung von Knoten kann es auchsinnvoll sein, einen Knoten in zwei Teilknoten zu zerlegen.
• Extraktion gemeinsamer Teilausdrücke Enthalten mehrere Knoten ge-meinsame Faktoren, ergeben sich durch die Zerlegung große Kosteneinspa-rungspotentiale. In MV-SIS findet z.B. die Funktion fxu (fast extract unate)gute Gemeinsame Faktoren in einem logischen Netz. Die Funktion decomp führteine vollständige Faktorisierung des Netzwerkes durch.
In der letzten Zeit gewinnen auf Binary Decision Diagrams basierte Verfahren zurfunktionalen Zerlegung an Bedeutung.
24
2.6. Hardwarebeschreibungssprachen
2.5.2. Softwarepakete zur Logikminimierung (und -synthese)
MV-SIS
MV-SIS wurde von der MVSIS Arbeitsgruppe unter der Leitung von Robert K.Brayton an der University of California in Berkeley entwickelt und ist eine Wei-terentwicklung des SIS Paketes (ebenfalls UC Berkeley). MV-SIS ist ein interaktivesSystem zur mehrstufigen, mehrwertigen Logiksynthese. MV-SIS war ursprünglich alsSoftwarepaket zur Minimierung mehrwertiger Logik gedacht, hat sich jedoch darüberhinaus zu einem vollwertigen Werkzeug zur Synthese und Verifikation entwickelt undenthält die meisten der in der Arbeitsgruppe entwickelten Algorithmen.
Das Ein- und Ausabeformat für binäre bzw. mehrwertige logische Netze ist BLIFbzw. MV-BLIF (s. Abschnitt 2.6.1). Zur zwei- bzw.mehrstufigen Minimierung kombi-natorischer Netzwerke stellt MV-SIS-2.0 verschiedene Würfel- BDD- und Netzlistenbasierte Verfahren zur Verfügung (s. Abschnitt 2.5.1): z.B. Espresso oder das Ver-fahren von Minato zur zweistufigen oder algebraische Methoden zur mehrstufigenLogikminimierung. Verfahren zur Minimierung von sequentiellen Schaltkreisen oderzur Abbildung auf eine Zielplattform werden ab Version 3.0 unterstützt.
Die Steuerung von MV-SIS erfolgt über eine Eingabeaufforderung, über Komman-dozeilenparameter oder per Skript.
2.6. Hardwarebeschreibungssprachen
Mit Hilfe von Hardwarebeschreibungssprachen lassen sich komplexe integrierte Schalt-kreise auf eine formale Art und Weise beschreiben. Ihre Syntax und Semantik bein-halten Konstrukte zur Beschreibung von Nebenläufigkeit und zur Festlegung deszeitlichen Verhaltens.
VHDL und Verilog HDL sind verbreitete Hochsprachen zur Hardwarebeschrei-bung, die ein hohes Abstraktionsniveau bieten. BLIF ist eine sehr hardwarenaheSprache zur textuellen Beschreibung von Netzlisten. Sie wurde ursprünglich zur Be-schreibung von PLAs entwickelt und dient den Logikminimierungs- und Logiksyn-theseprogrammen espresso, SIS und MV-SIS als Ein- und Ausgabeformat. BLIF undVHDL werden im Folgenden kurz eingeführt.
2.6.1. BLIF
Das Berkeley Logic Interchange Format (BLIF) [34] wurde an der University of Ca-lifornia, Berkeley entwickelt. Es dient zur textuellen Beschreibung von hierarchischaufgebauten Schaltnetzen oder Schaltwerken auf Logikebene. Ein Schaltkreis wirddabei als gerichteter Graph von kombinatorischen und sequenziellen Logikknotenbetrachtet.
Ein Modell ist das Hauptstrukturelement in BLIF. Ein Modell ist die Beschreibungeines hierarchischen Schaltkreises. Es besteht aus einer Deklaration des Interfaces zurUmwelt und der funktionalen Beschreibung.
25
2. Grundlagen
.model <Modell-Name>
.inputs <Liste der Eingangssignale>
.outputs <Liste der Ausgangssignale>
.clock <Liste der verwendeten Clocks>
...<commands>....end
Mit den .input-, .output- und .clock-Anweisungen wird das Interface des Mo-dells deklariert. Nach jeder dieser Anweisungen steht eine Liste von Signalen. DieElemente der Listen werden durch Leerzeichen getrennt. Ein Backslash ’\’ konka-teniert zwei aufeinanderfolgende Zeilen. Bei der Deklaration mehrerer Eingangs-,Ausgangs- oder Clock-Listen werden diese miteinander konkateniert.
Die Verhaltensbeschreibung erfolgt auf einem sehr hardwarenahen Niveau. BLIFstellt Konstrukte zur Implementierung von Logikgattern, Auffangregistern (Latches)und endlichen Automaten zur Verfügung. Endliche Automaten werden im KISS-Format beschrieben. Zusätzlich lassen sich Modelle aus der selben oder aus eineranderen Datei innerhalb eines Modells referenzieren, so dass eine hierarchische Ent-wicklung der Schaltungsbeschreibung möglich ist. Über Clock-Constraints wird dasVerhalten simulierter Clocks gesetzt und das Verhalten von Clock-Ereignissen relativzueinander beschrieben. Über Delay-Constraints lassen sich Signallaufzeiten festle-gen.
Die Deklaration von Logikgattern erfolgt über die .names-Anweisung. Ein Logik-gatter assoziiert eine Logikfunktion mit einem Signal im Modell. Hinter der .names-Anweisung folgt in der selben Zeile eine Liste der n Eingangssignale und abschließenddas Ausgangssignal. Die Funktion wird durch eine Wahrheitstabelle repräsentiert. Je-de Zeile ist eine mögliche Ein-/Ausgabebelegung. Die n Bit weite Eingabebelegungwird durch ein Leerzeichen von der ein Bit weiten Ausgabe getrennt. Alle Zeilen miteiner 1 in der Ausgabe gehören zum ON-Set der Funktion, die mit einer 0 zu OFF-Setder Funktion. Eine ’1’ bedeutet, dass die Eingabe nicht komplementiert wird, eine ’0bedeutet, dass die Eingabe komplementiert wird und ein’-’ bedeutet, dass die Einga-be nicht benutzt wird. Die Elemente einer Eingabebelegung werden und-Verknüpftund die Eingabebelegungen werden oder-Verknüpft. Das folgende Beispiel zeigt dieImplementierung der Funktion O = A or B or not C:
.model EXAMPLE
.inputs A B C
.outputs O
.name A B C O1-- 1-1- 1--0 1.end
2.6.2. VHDL
VHDL steht für Very High Speed Integrated Circuit Hardware Description Language.Ihre Entwicklung begann Anfang der 80er Jahre initiiert durch das US-Verteidigungs-
26
2.6. Hardwarebeschreibungssprachen
ministerium. In den Jahren 1987 und 1993 wurde VHDL durch den Standard IEEE-1076 als herstellerunabhängige Hochsprache definiert und wird seitdem regelmäßigüberarbeitet.
VHDL ermöglicht die Beschreibung und Simulation von digitalen Schaltungen aufeiner sehr hohen Abstraktionsebene. Entwurfsziel können dabei verschiedene rekon-figurierbare Logikbausteine wie beispielsweise ein FPGA (Field Programmable GateArray) oder CPLD (Complex Programmable Logic Device), ein ASIC (ApplicationSpecific Integrated Circuit) oder ganze Platinen sein. Durch ihr hierarchisches Kon-zept ist es innerhalb kurzer Zeit möglich, auch komplexe Schaltkreise wie Prozessorenmit einigen Millionen Gattern zu entwickeln.
Nicht der volle Sprachstandard von VHDL ist synthetisierbar, sondern nur eine be-stimmte Teilmenge. Man unterscheidet zwischen synthetisierbarem und funktionalemCode. Letzterer ist ausschließlich simulierbar und dient der Spezifikation von Verhal-tensmodellen oder für Simulations- und Debuggingzwecke. Der praktisch häufigsteFall von nicht-synthetisierbarem Code ist die Erzeugung von Testumgebungen (sog.Testbenches). Welcher Code synthetisierbar ist und welcher nicht, hängt aber auchvon den Fähigkeiten des verwendeten Synthesetools und der Zielplattform ab. DieHardwaresynthese aus VHDL entspricht im Wesentlichen einer Mustererkennung. Soist es teilweise notwendig, bestimmte Implementationsmuster Templates zu benut-zen, um die Logik auf bestimmte Hardwareressourcen der Zielplattform abzubilden.Ein Beispiel hierfür ist der Ripple Carry Adder, der speziell für die effiziente Imple-mentierung auf FPGAs zugeschnitten ist.
Syntax
Im Folgenden wird eine kurze Einführung in VHDL gegeben. Diese beschränkt sichauf die Sprachteile, die zur Implementierung von Schaltnetzen benutzt werden. Einegute Einführung geben z.B. Reichhardt und Schwarz [30].
Einbinden von Paketen Mit der library Anweisung können in einem VHDL Pro-gramm zusätzliche Bibliotheken eingebunden werden. Bibliotheken sind eine meistvorkompilierte Sammlung von VHDL Einheiten. Sie können eigene Deklarationen,aber auch Teilentwürfe oder ganze Komponenten (Intellectual Property (IP)) enthal-ten. Bibliotheken zur Erweiterung des Sprachstandards werden von den Synthese-werkzeugherstellern oder von Arbeitsgruppen der IEEE zur Verfügung gestellt. DieBibliothek ieee umfasst u.a. folgende Packages:
• std_logic_1164 Definiert die Datentypen std_logic bzw. std_ulogic undstd_logic_vector bzw. std_ulogic_vector für mehrwertige Logik, sowie ei-nige Funktionen auf diesen Datentypen.
• std_logic_signed und std_logic_unsigned: Definiert vorzeichenlose undvorzeichenbehaftete Operationen für den Datentyp std_(u)logic_vector. Esist keine Mischung von vorzeichenloser mit vorzeichenbehafteter Arithmetikerlaubt.
27
2. Grundlagen
• numeric_std bzw. std_logic_arith: Definiert die Datentypen signed undunsigned, arithmetische Operationen und Vergleichsoperationen auf diesen Da-tentypen sowie Konvertierungsfunktionen.
Mit der library ieee; Anweisung wird die IEEE-Bibliothek deklariert. Ein be-stimmtes Paket der Bibliothek muss vor jeder Entity, in der es benutzt wird, mit Hilfeder use Anweisung eingebunden werden (z.B. use ieee.std_logic_1164.all;).
Datenobjekte und Datentypen Als Objektklassen für Daten stellt VHDL Kon-stanten, Variablen und Signale zur Verfügung:
• Konstanten wird bei der Initialisierung einmal ein fester Wert zugewiesen.
• Variablen werden bei der Verhaltensbeschreibung mit sequentiellen Anweisun-gen innerhalb von Prozessen, die der algorithmischen Struktur von Program-miersprachen entsprechen, eingesetzt.
• Signale dienen zur Kommunikation zwischen Prozessen oder als Datenleitungenzwischen Funktionsblöcken. Ähnlich wie bei Esterel wird bei der Simulationvon VHDL die zeitliche Ordnung von Interaktionen über Signale geregelt.
VHDL ist stark typisiert. Signale und Variablen erhalten bei ihrer Deklarationeinen festen Typ. Bei der Wertzuweisung von Signalen oder Variablen unterschied-lichen Typs muss eine explizite Typkonvertierungsfunktion angegeben werden. Diewichtigsten Datentypen, die z.T. nicht zum Standardsprachumfang gehören sondernüber zusätzliche Pakete eingebunden werden müssen, sind:
• bit/bit_vector: Der Datentyp bit besteht aus den logischen Werten ’0’ oder’1’. Nach der Deklaration hat ein Signal standardmäßig den Wert ’0’. Der Typbit_vector ist ein vordefinierter Array-Typ zu bit.
• std_[u]logic und std_[u]logic_vector: Der IEEE-Standard 1164-1993 führtdie Datentypen std\_logic und std_ulogic mit einer neunwertigen Logik ein,die folgende Werte umfasst: ’U’ (nicht initialisiert), ’X’ (undefiniert, mehre-re aktive Signaltreiber), ’0’ (starke logische ’0’ (vgl. bit)), ’1’ (starke logische’1’(vgl bit)), ’Z’ (hochohmig (Tri-State Ausgang)), ’W’ (schwach unbekannt),’L’ (schwache logische ’0’), ’H’ (schwache logische ’1’) und ’-’ (don’t care (kannfür Logikminimierung verwendet werden)). Im Gegensatz zum Typ std_ulogicsind für Signale vom Typ std_logic mehrere Treiber erlaubt, d.h. es dür-fen mehrere nebenläufige Signalzuweisungen erfolgen. In diesem Fall wird beider Simulation der resultierende Wert über eine Auflösungsfunktion bestimmt.Der Datentyp std_logic findet insbesondere bei bidirektionalen Bussen Ver-wendung. Der Typ std_[u]logic_vector ist ein vordefinierter Array-Typ zustd_[u]logic.
28
2.6. Hardwarebeschreibungssprachen
• boolean: Der Datentyp boolean kann die Werte true oder false annehmen. ImGegensatz zu bit dient er in der Praxis hauptsächlich dazu, architekturspezifi-sche, logische Ausdrücke zu erzeugen, weniger dazu, die elektrischen Pegel vonSignalen zu erzeugen.
• integer: Der Datentyp integer wird in den meisten CAE-Systemen durch32 Bit repräsentiert. Er sollte nur für den indizierten Zugriff auf Vektor- oderFeldkomponenten und innerhalb von Verhaltensmodellen oder Testumgebun-gen eingesetzt werden.
• signed und unsigned: Der ergänzende IEEE 1076.3 Standard spezifiziert dieDatentypen signed und unsigned. Sie sind eine arithmetische Interpretationdes Typs std_logic_vector. Negative Zahlen werden im Zweierkomplementdargestellt.
Zusätzlich lassen sich komplexe Datentypen, wie Arrays oder Records, oder aberSubtypen von bestehenden Typen definieren.
Signalzuweisungen erfolgen über den Signalzuweisungsoperator <=:A <= ’0’; -- Zuweisung an ein Signal vom Typ bit bzw. std_logicB <= true; -- Zuweisung an ein Signal vom Typ booleanC <= "1010"; -- Zuweisung an einen bit_vector oder std_logic_vector mit 4 Bit Breite
D(0) <= ’0’; -- Zuweisung an Bit 0 in einem Vektor
Eine Wertzuweisung an Variablen erfolgt mit dem Zuweisungsoperator :=.
Ausdrücke Für die Datentypen boolean, bit und std_logic stehen die logischenOperatoren not, and, nand, or, nor, xor und xnor zur Verfügung. Der Operator nothat die höchste Priorität, die Priorität der übrigen Operatoren muss durch Klamme-rung festgelegt werden.
Für die oben vorgestellten ganzzahligen Typen definieren die entsprechenden Bi-bliotheken Vergleichsoperatoren =,/= (ungleich),<,<=,> und >= (alle synthetisierbar)und arithmetische Operatoren +,-,abs,*,/ (Division meist nicht synthesefähig),**(Zweierpotenz), mod und rem (Divisionsrest nur in Spezialfällen synthetisierbar).
Strukturelemente Neben dem schon erwähnten package sind entity und architecturegrundlegende Strukturelemente einer VHDL-Beschreibung.
Eine entity beschreibt die Schnittstelle eines VHDL-Funktionsblocks nach außen.Die Deklaration der Anschlüsse erfolgt mit der port Anweisung:
entity MUX2x1 isport(S: in std_logic; -- Zur Selektion des EingangsI: in std_logic_vector(1 downto 0); -- 2 Bit EingangsvektorO: out std_logic; -- Ausgangssignal
end MUX2x1;
Innerhalb einer architecture wird die Funktionalität eines Blocks beschrieben.Jeder entity muss mindestens eine solche Implementierung zugeordnet sein. Einearchitecture besteht aus einem Deklarationsteil, sowie konkurrenten Anweisungenzur Verhaltensbeschreibung:
29
2. Grundlagen
architecture MUX of MUX2x1 is-- Deklarationsteil
begin-- konkurrente Anweisungen
end MUX;
Im Deklarationsteil erfolgen u.a. Typdeklarationen, Konstantendeklarationen, loka-le Signaldeklarationen oder Komponentendeklarationen. Konkurrente Anweisungensind z.B. Signalzuweisungen, Prozesse oder Instanzen von Komponenten. Signalzu-weisungen können unbedingt (A <= "1010";) oder bedingt erfolgen:
architecture MUX of MUX2x1 isbeginwith S selectO <= I(0) when ’0’,
I(1) when ’1’;end MUX;
Innerhalb von Prozessen erfolgt die Funktionsbeschreibung über sequenzielle An-weisungen, ähnlich einer gewöhnlichen Programmiersprache:
architecture MUX of MUX2x1 isbeginMUXPROC: process (S)
begincase S iswhen ’0’ => O <= I(0);when ’1’ => O <= I(1);
end case;end process MUXPROC;
end MUX;
VHDL erlaubt den hierarchischen Aufbau der Sytembeschreibung. Dazu lassensich entity/architecture-Paare in einem übergeordneten Funktionsblock instan-tiieren. Eine zu nutzende Komponente (component) wird im Deklarationsteil derarchitecture zunächst mit ihrer Schnittstelle (port) deklariert und anschließendim Architekturrumpf instantiiert. Existieren mehrere Implementierungen für eineentity, so kann mit Hilfe der for ... use entity ...-Anweisung eine bestimmteImplementierung ausgesucht werden.
architecture MUX4x1_impl of MUX4x1 iscomponent MUX2x1port( -- _ MUX_0S: in std_logic; -- I(0)-| \I: in std_logic_vector(1 downto 0); -- | |--+O: out std_logic; -- I(1)-|_/ | _ MUX_2
end component; -- | +--| \signal O_INT: std_logic_vector(1 downto 0); -- S(0)--+ | |-- Obegin -- | +--|_/MUX_0: MUX2x1 port map(S(0), I(1 downto 0), O_INT(0)); -- I(2)-| \ | |MUX_1: MUX2x1 port map(S(0), I(3 downto 2), O_INT(1)); -- | |--+ S(1)MUX_2: MUX2x1 port map(S(1), O_INT, O); -- I(3)-|_/end MUX4x1_impl; -- MUX_1
30
3. HW/SW Co-Synthese
In diesem Kapitel wird ein Verfahren zur HW/SW Co-Synthese von Esterel Pro-grammen vorgestellt, das komplexe Expressions aus dem gegebenen Programm ex-trahiert und diese in einem mit dem KEP verbundenen Logikblock berechnet. Zu-sätzlich wird eine modifizierte Programmversion erzeugt, die dann wie gewöhnlichauf dem erweiterten KEP ausgeführt werden kann. In Kapitel 4 wird für verschiede-ne Programme untersucht, wie sich das vorgestellte Verfahren auf die Ticklänge, denRessourcenverbrauch und den Energieverbrauch auswirkt.
3.1. Problemstellung
Die wichtigsten Esterel Statements werden durch den Befehlssatz des KEP di-rekt unterstützt oder lassen sich leicht auf diesen zurückführen. Die Berechnungvon komplexen Expressions ist vergleichsweise aufwändig, da diese nicht innerhalbeiner Instruktion ausgewertet werden können, sondern in mehrere KEP AssemblerInstruktionen zerlegt werden müssen. Die Berechnung von komplexen Expressionsin KEP Assembler ist exemplarisch in den oberen beiden Listings in Abbildung 3.1dargestellt.
Das Listing Original Esterel Programm enthält den Esterel Programmcode unddas Listing KEP Assembler Code den resultierenden KEP Assembler Code. Daspresent (A or B) and C then ... end present Statement in Zeile 10 im Pro-grammcode wird zerlegt in die KEP Assembler Instruktionen in Zeilen 13 bis 16im KEP Assembler Code. PRESENT S, Addr ist in KEP Assembler ein bedingterSprung, der als „Springe zu Addr, wenn S absent ist“ zu interpretieren ist. PRESENTC,A0 testet das Signal C. Ist es absent, ist die ganze Signal Expression absent unddas Programm wird bei A1 fortgeführt. Ist es jedoch present, ist noch (A or B) aus-zuwerten. Ist nun beispielsweise A present, wird die folgende GOTO A1 Instruktionausgeführt und O1 emittiert. In den Zeilen 18 bis 27 im KEP Assembler Code wirdder if-Test if (?D or (?E and ?F)) then ... berechnet. In Zeile 18 wird zunächstder Wert von Signal D ins Register REG0 geladen. CMPS REG0,#1 vergleicht den Inhaltdes Registers mit der Konstanten 1 (true). JW EE,A5 ist ein bedingter Sprung. Ergabder letzte Vergleich equal (EE), wird GOTO A4 ausgeführt und schließlich O2 mit demWert 1 (true) emittiert, ansonsten wird zu A5 gesprungen. Die Interpretation derübrigen Instruktionen bleibt dem Leser überlassen.
Wie das Beispiel zeigt, werden für die Berechnung der Signal Expression vier undfür die Berechnung der valued Expressions sogar zehn Instruktionen benötigt, dazum Laden eines Signalwerts in ein Register und für den Vergleich des Registerin-
31
3. HW/SW Co-Synthese
Original Esterel Programm
KEP Assembler Code
SW-Modul
VHDL Beschreibung des Logikblocks
KEP Assembler Code des SW-Moduls
2. Schritt: HW/SW Synthese
1. Schritt: Partitionierung
C/Java-Code
HDL
HW-Module
Wird auf dem KEP ausgeführt
Schematische Darstellung des KEP mit Logikblock
Hardwaresynthese des Logikblocks
Abb. 3.1.: Überblick über den Co-Synthese Prozess: Die gestrichelten Pfade zei-gen die bisherigen Esterel Syntheseansätze. Dies sind zum einen die traditionelleSoftware- und Hardwaresynthese, als auch die reine Softwaresynthese für den KEP(KEP Assembler). Die durchgezogenen Pfade veranschaulichen den in dieser Arbeitvorgestellten Co-Synthesefluss.
32
3.2. Lösungsansatz
halts mit einer Konstanten zwei zusätzliche Instruktionen benötigt werden, bevoraufgrund des Vergleichsergebnisses ein bedingter Sprung ausgeführt wird. Die An-zahl der Instruktionen im KEP Assembler Code wird also erheblich von der Anzahlund der Komplexität der in einem Programm auftretenden Expressions beeinflusst,was sich üblicherweise auch negativ auf die WCRT des Programmes und damit aufdie minimale Ticklänge auswirkt.
Im Folgenden wird ein Lösungsansatz für die effizientere Berechnung von komple-xen Expressions vorgestellt.
3.2. Lösungsansatz
Die Grundidee besteht darin, die Berechnung von komplexen Expressions in einen mitdem KEP verbundenen Logikblock auszulagern, der für jedes Esterel Programmindividuell generiert wird. Über ein spezielles Interface erhält der Logikblock Zugriffauf alle für die Berechnung der Expressions benötigten Status- und Signalwerte undgibt die Ergebnisse der Berechnung als zusätzliches Eingangssignal an den KEPzurück. Auf dem KEP wird eine modifizierte Programmversion ausgeführt, in deralle komplexen Expressions durch das entsprechende Hilfssignal ersetzt sind.
Diese Hardware/Software Co-Synthese eines Esterel Programms erfolgt in zweiSchritten mit einem optionalen Zwischenschritt:
• Schritt 1 (Partitionierung): Das gegebene Esterel Programm wird zunächst inein semantisch äquivalentes Esterel Programm transformiert, das die Software-und Hardwareteile in unterschiedlichen Modulen modelliert. Die Partitionie-rung auf Esterel Basis soll den Syntheseprozess möglichst lange hardware-unabhängig halten und eine vollständige Verifizierbarkeit dieses Schrittes mitvorhandenen Werkzeugen, wie z.B. EsterelStudio [17], ermöglichen.
• Optionaler Zwischenschritt (Logikminimierung): Durch die Logikminimierungsollen einzelne Ausdrücke im Logikblock vereinfacht und gemeinsame Teilaus-drücke identifiziert werden, um den resultierenden Logikblock möglichst kleinzu halten.
• Schritt 2 (HW/SW Synthese): Der Softwareteil des partitionierten Program-mes wird wie gewohnt mit dem Esterel2KASM Compiler für die Ausführungauf dem KEP kompiliert, der Hardwareteil wird in die VHDL Beschreibungdes Logikblocks konvertiert, in Hardware synthetisiert und mit dem KEP ver-bunden.
Für die Implementierung des oben skizzierten Ansatzes sind diverse, nicht offen-sichtliche Schwierigkeiten zu lösen auf die im Folgenden kurz eingegangen werdensoll. Eine erste Schwierigkeit besteht darin, ein Verfahren für die korrekte Partitio-nierung des Esterel Programms in Software- und Hardwaremodule zu finden. Umeine komplexe Expression auswerten zu können, müssen alle Signale, die zur Berech-nung notwendig sind, im Hardwaremodul bekannt sein. Als Kommunikationsmecha-nismus zwischen den Modulen kommen nur Signale in Frage, was die Modellierung
33
3. HW/SW Co-Synthese
einer korrekten Kommunikation erschwert, wenn die zu berechnende Expression lo-kale Signale enthält. Dies hängt damit zusammen, dass lokale Signale schizophrensein können, d.h. dass sie während einer Instanz verschiedene Werte haben können.Dieses als Reinkarnation bekannte Problem, sowie ein weiteres Problem mit lokalenSignaldeklarationen innerhalb von suspend-Blöcken werden im folgenden Abschnittdetailliert erörtert. Darüber hinaus werden zwei verschiedene Partitionierungsansätzevorgestellt und im Bezug auf die Lösung der o.g. Probleme gegeneinander abgewogen.
Eine weitere Schwierigkeit ergibt sich bei der Softwaresynthese, da der Esterel2KASMCompiler das Scheduling für das modifizierte Programm nicht korrekt berechnenkann. Pro Instanz müssen in konkurrierenden Threads die schreibenden Statementseines Signals vor den lesenden ausgeführt werden. Der Compiler ist nicht in der La-ge festzustellen, von welchen Signalen die Berechnung eines Hilfssignals abhängt,da die Berechnung nicht mehr durch das Programm selbst, sondern durch den fürden Compiler unbekannten Logikblock durchgeführt wird. Abschnitt 3.5.1 zeigt, wiedieses Problem durch eine Modifikation des Compilers gelöst werden kann.
3.3. Partitionierung
Wie im vorigen Abschnitt bereits angesprochen wurde, muss eine Methode gefun-den werden, mit der auch aus Programmen mit komplexen Expressions, die lokaleSignale enthalten, ein äquivalentes partitioniertes Programm erzeugt werden kann.Anhand einer einfachen Partitionierugsmethode werden zunächst die auftretendenProbleme erörtert. Da diese einfache Methode auch durch verschiedene Workaroundskeine zufriedenstellenden Ergebnisse liefert, wird anschließend ein enger an der Se-mantik von Signalen in Esterel ausgerichtetes Verfahren vorgestellt. Abschließendwird ausführlich auf die Implementierung der Transformation von Signal- und valuedExpressions eingegangen.
3.3.1. Schwierigkeiten bei der Partitionierung
Ein erster naheliegender Partitionierungsansatz wäre die Aufteilung des EsterelProgramms in drei Module, ein Softwaremodul, ein Hardwaremodul und ein Main-modul. Das Softwaremodul entspricht im Wesentlichen dem Originalprogramm, eswurden jedoch auftretende komplexe Expressions durch Hilfssignale ersetzt, die imHardwaremodul berechnet werden. Das Mainmodul startet das Software- und dasHardwaremodul parallel. Ein Beispiel für diese Partitionierung ist in Abbildung 3.2dargestellt.
Das Softwaremodul enthält alle Statements des Originalprogramms. Die kom-plexen Expressions A and C or B and C und A or B wurden hier durch die bei-den Hilfssignale A_and_C_or_B_and_C und A_or_B ersetzt, die im Interface als neueinput-Signale deklariert werden. Die Berechnung der Hilfssignale erfolgt im Hardwa-remodul in parallelen every immediate SigExp do emit AuxSig end every State-ments. Diese emittieren die Hilfssignale AuxSig in jeder Instanz, in der die SignalExpression SigExp present ist. Alle für die Berechnung notwendigen Signale werden
34
3.3. Partitionierung
1 module EXAMPLE:2 input A, B, C;3 output O, P;4
5 signal A_and_C_or_B_and_C,6 A_or_B in7 run EXAMPLE_SW8 ||9 run EXAMPLE_HW
10 end signal11
12 end module
module EXAMPLE:input A, B, C;output O, P;
signal A_and_C_or_B_and_C,A_or_B in
run EXAMPLE_SW||run EXAMPLE_HW
end signal
end module
module EXAMPLE_SW:output O;output P;input A_and_C_or_B_and_C;input A_or_B;
present A_and_C_or_B_and_C thenemit O
end present;present A_or_B then
emit Pend present
end module
module Example_HW:input A, C, B;output A_and_C_or_B_and_C, A_or_B;
every immediate [A_or_B and C] doemit A_and_C_or_B_and_C
end every||
every immediate [B or A] doemit A_or_B
end everyend module
Abb. 3.2.: Aufteilung eines (Esterel) Programms in Main-, SW- und HW-Modul
im Interface des Hardwaremoduls als Eingang und die Hilfssignale als Ausgang de-klariert. Das Mainmodul führt das Software- und das Hardwaremodul parallel ausund verfügt, da es als neue Schnittstelle des partitionierten Programms zur Umweltfungiert, über das gleiche Interface wie das Originalprogramm. Hilfssignale, die zwi-schen dem Soft- und dem Hardwaremodul geteilt werden, werden im Mainmodullokal deklariert.
Dieser Ansatz erlaubt es im Allgemeinen nicht, Expressions mit lokalen Signalenzu behandeln, da ihr Status nicht korrekt an das Hardwaremodul übermittelt wer-den kann. Das lokale Signal einfach global im Interface zu deklarieren, führt in vielenFällen nicht zum gewünschten Ergebnis, da dies die Semantik des Programms ver-ändern kann. Gründe hierfür sind das mögliche Auftreten von Schizophrenie durchReinkarnation des lokalen Signals oder die Suspendierung des Blocks, in dem daslokale Signal deklariert ist.
Nach der Semantik von Esterel haben alle Signale in einem Programm pro In-stanz genau einen Status. Wird jedoch ein lokales Signal innerhalb eines Schleifen-rumpfes deklariert, so wird es in jedem Schleifenzyklus neu instantiiert. Auf diese Artund Weise können zwei simultane Inkarnationen eines Signals pro Instanz existieren.
35
3. HW/SW Co-Synthese
Das folgende Beispiel illustriert dieses Verhalten:...loopsignal S in
present S then ...pause;emit S;
end signalend loop...
Das Signal S wird innerhalb einer Schleife lokal deklariert. In der ersten Instanzist es absent und der Signaltest fällt negativ aus. In der folgenden Instanz wirddas Signal emittiert und der Rumpf der Schleife instantan neu gestartet. Die neueInkarnation von S hat wieder den Status absent. Abbildung 3.3 zeigt die offensichtlichfalsche Partitionierung des Programms LocalSig, in der das Hilfssignal ab der zweitenInstanz immer den falschen Status present hat.
Ein weiteres Problem mit lokalen Signalen tritt bei der Deklaration innerhalb eines
1 module LocalSig:2 input A,B;3 output O;4
5 loop6 signal S in7 present (A and B) or S then8 emit O9 end present;
10 pause;11 emit S12 end signal13 end loop14
15 end module
module EXAMPLE:input A, B;output O;
signal A_and_B_or_S,S in
run LocalSig_SW||run LocalSig_HW
end signal
end module
module LocalSig_SW:input A_and_B_or_S;output S,O;
looppresent A_and_B_or_S thenemit O
end present;pause;emit S
end loop
end module
module LocalSig_HW:input A,B,S;output A_and_B_or_S;
every immediate [(A and B) or S] doemit A_and_B_or_S
end every
end module
Abb. 3.3.: Fehlerhafte Partitionierung in HW-, SW- und Mainmodule
36
3.3. Partitionierung
suspend Statements auf. Im folgenden Beispiel liefert etwa der Ausdruck pre(S) denStatus von S in der vorigen Instanz, in der das signal Statement aktiv war.
...suspendsignal S in...present pre(S) then ......
end signalwhen I...
Im Hardwaremodul kann bei der Berechnung des Ausdrucks pre(S) nicht entschiedenwerden, ob das Signal S suspendiert ist. Dies ließe sich jedoch durch die Einführungeines weiteren Signals LocalTick lösen, das parallel zum Rumpf des suspend-Blocksin jeder Instanz (in der der Block aktiv ist) emittiert wird. Es kann aber auch hierbei einer eventuellen Reinkarnation von S der korrekte Wert in der vorigen Instanznicht berechnet werden.
Das eigentliche Problem besteht also in der korrekten Behandlung von schizophre-nen Signalen. Dazu wurde ein Workaround für diesen Ansatz eingeführt, bei demzwischen den Modulen keine Daten von lokalen Signalen ausgetauscht werden müs-sen. Die eigentliche Berechnung des Teilausdrucks mit dem lokalen Signal verbleibtim Softwaremodul, das Hardwaremodul berechnet für alle hypothetischen Signalbe-legungen der lokalen Signale, die in der Expression vorkommen, ein Hilfssignal.
Die Idee für die Hilfskonstruktion wird anhand des in Abbildung 3.4 gezeigten Bei-spiels LocalSig skizziert. Das lokale Signal S wird innerhalb einer Schleife instantanredeklariert. Sein Status bzw. Wert kann daher nicht über ein Interfacesignal an dasHardwaremodul übermittelt werden. Stattdessen werden im Hardwaremodul zweiHilfssignale A_and_B_or_S_true und A_and_B_or_S_false für beide möglichen Wer-te von S, present oder absent, berechnet. Die Fallunterscheidung für S present oderabsent erfolgt im Softwaremodul: Ist S present wird das Hilfssignal A_and_B_or_Semittiert, wenn A_and_B_or_S_true present ist, ist S absent wird das HilfssignalA_and_B_or_S emittiert, wenn A_and_B_or_S_false present ist. Die Verwendungvon Variablen zur Kommunikation zwischen den Modulen ist nicht möglich, da einschreibender Zugriff auf Variablen in konkurrierenden Threads nicht erlaubt ist.
Die Repräsentation von lokalen Signalen und Interfacesignalen ist im KEP iden-tisch. Vom Logic Block aus kann also ohne Probleme auf den Status- bzw. Signalwerteines lokalen Signals zugegriffen werden. Bei der Hardwaresynthese kann daher dieBerechnung der beiden Hilfssignale A_and_B_or_S_true und A_and_B_or_S_falsedurch die Berechnung des eigentlichen Hilfssignals A_and_B_or_S substituiert werden.Bei der Softwaresynthese kann der komplette present S then ... else ... endBlock weggelassen werden.
Der Aufwand für die Hilfskonstruktion steigt jedoch quadratisch mit der Anzahlder verwendeten lokalen Signale in der Expression und ist ungeeignet für valuedSignals. Eine klare Partitionierung in Software- und Hardwareteile findet außerdemnur unvollständig statt, da die Berechnung von Teilausdrücken mit lokalen Signalenim Softwaremodul verbleibt und die endgültige Partitionierung bei der HW/SW
37
3. HW/SW Co-Synthese
1 module LocalSig:2 input A,B;3 output O;4
5 loop6 signal S in7 present (A and B) or S then8 emit O9 end present;
10 pause;11 emit S12 end signal13 end loop14
15 end module
(a)
1 module LocalSig_HW:2 input A,B;3 output A_and_B_or_S_true,A_and_B_or_S_false;4
5 every immediate [A and B] do6 emit A_and_B_or_S_false7 end every8 ||9 every immediate [tick] do
10 emit A_and_B_or_S_true11 end every12
13 end module
(b)
1 module LocalSig_SW:2 input A,B;3 input A_and_B_or_S_true, A_and_B_or_S_false;4 output O;5
6 loop7 signal S, A_and_B_or_S in8 trap done in9 loop
10 present S then11 present A_and_B_or_S_true then12 emit A_and_B_or_S13 end present14 else15 present A_and_B_or_S_false then16 emit A_and_B_or_S17 end present18 end present;19 pause20 end loop21 ||22 present A_and_B_or_S then emit O23 end present;24 pause; emit S; exit done25 end trap26 end signal27 end loop28
29 end module
(c)
Abb. 3.4.: Hilfskonstruktion für lokale Signale: (a) Programmbeispiel mit lokalemSignal S, (b) Hilfskonstruktion im Hardwaremodul, (c) Hilfskonstruktion im Softwa-remodul
Synthese vollzogen werden muss.Eine weitere Möglichkeit besteht darin, Quellen von Schizophrenie in einem vor-
geschalteten Schritt aufzulösen. Die hierzu betrachteten Verfahren arbeiten jedochentweder nicht auf Esterel Ebene [6, Kapitel 12] oder basieren auf Erweiterungenbzw. Dialekten von Esterel [32, 33]. Die Beseitigung von Schizophrenie geht miteinem Anwachsen des Codes einher, das im schlimmsten Fall quadratisch sein kann.Ein Anwachsen des Codes steht jedoch dem gesetzten Ziel einer Laufzeitverbesserungentgegen.
Aufgrund der mit diesem Ansatz verbundenen Schwierigkeiten ist der vorgestellteAnsatz nicht praktikabel. Ein an der Semantik von lokalen Signalen in Esterelausgerichtetes Verfahren wird im folgenden Kapitel vorgestellt.
38
3.3. Partitionierung
3.3.2. Partitionierungsansatz mit lokalen Hardwaremodulen
Der in der Arbeit verwendete Lösungsansatz verwendet eine Partitionierung des Es-terel Programms in ein Software- und mehrere Hardwaremodule. Für jeden Gül-tigkeitsbereich eines Signals, d.h. für die globale und für jede lokale Signaldeklara-tion, existiert ein eigenes Hardwaremodul. Jedes Hardwaremodul wird parallel zumRumpf des jeweiligen signal-Statements ausgeführt. Das Hilfssignal zu einer Ex-pression wird in dem hierarchisch niedrigsten Signal-Gültigkeitsbereichs deklariertund in dem zugehörigen Hardwaremodul berechnet, in dem alle Signale der Expres-sion bekannt sind. Werden beispielsweise drei lokale Signale A, B und C durch dreiineinandergeschachtelte signal-Statements deklariert, so wird eine Expression A orB in dem zur Signaldeklaration von B gehörigen Hardwaremodul berechnet. Damitsoll erreicht werden, dass das Hilfssignal in einem möglichst großen Gültigkeitsbe-reich sichtbar ist und eine ggf. häufiger vorkommende Expression mehrmals ersetzenkann. Alle in der Expression verwendeten Signale werden als Eingangssignale desHardwaremoduls deklariert, das Hilfssignal als Ausgangssignal. Im Gegensatz zu derim vorigen Abschnitt vorgestellten Partitionierungsmethode mit nur einem paral-lel zum Softwaremodul ausgeführten Hardwaremodul, können in diesem Ansatz dasSoftware- und die Hardwaremodule über lokale Signale miteinander kommunizieren,da eine Signalreinkarnation immer auch eine Reinkarnation des in dem Gültigkeits-bereich ausgeführten Hardwaremoduls zur Folge hat.
Abbildung 3.5 zeigt die Partitionierung des Beispiels LocalSig mit einer lokalenSignaldeklaration. Das Hardwaremodul LocalSig_HW_2 wird innerhalb des Gül-tigkeitsbereichs des lokalen Signals S parallel zum ursprünglichen Rumpf der lo-kalen Signaldeklaration gestartet. Alle zur Berechnung notwendigen Signale kön-nen nun direkt im Interface des Hardwaremoduls deklariert werden. Das HilfssignalA_and_B_or_C, das die Expression A and B or C im present Statustest ersetzt, wirdim gleichen Gültigkeitsbereich deklariert. Da die Hilfssignale im Hardwaremodul ineiner Endlosschleife berechnet werden, terminiert die Ausführung des Hardwaremo-duls und damit das Parallelstatement nicht. Die Terminierung wird daher durch eintrap Statement, das das Parallelstatement umgibt, erzwungen. Ist das Ende der ur-sprünglichen Signaldeklaration erreicht, initiiert eine exit Anweisung die Beendigungder trap Anweisung.
Da die Repräsentation von lokalen Signalen und Interfacesignalen im KEP iden-tisch ist, können alle Hardwaremodule in einen Logikblock synthetisiert werden. DasSoftwaremodul könnte fast direkt in ein KEP Assembler Programm kompiliert wer-den, lediglich die run Anweisungen müssten durch z.B. nothing ersetzt werden. Dieneu eingeführten Parallel-, trap- und exit- Statements sind dann jedoch überflüssigund werden vor der Softwaresynthese ebenfalls entfernt. Alle bei der Partitionierungeingeführten trap- und exit-Statements beginnen mit dem reservierten Präfix „CO-SYN_TRAP“, über das sie später identifiziert werden. Das run-Statement ist daserste Statement nach dem trap und wird ebenfalls entfernt.
39
3. HW/SW Co-Synthese
1 module LocalSig:2 input A,B;3 output O;4 loop5 signal S in6 present (A and B) or S then7 emit O8 end present;9 pause;
10 emit S11 end signal12 end loop13
14 end module
1 module LocalSig_HW_2:2 input A;3 input B;4 input S;5 output A_and_B_or_S;6
7 every immediate [A and B or S] do8 emit A_and_B_or_S9 end every
10
11 end module
1 module LocalSig_SW:2 input A;3 input B;4 output O;5
6 loop7 signal S,8 A_and_B_or_S in9 trap CoSyn_T in
10 run LocalSig_HW_211 ||12 present A_and_B_or_S then13 emit O14 end present;15 pause;16 emit S;17 exit CoSyn_T18 end trap19 end signal20 end loop21
22 end module
Abb. 3.5.: Partitionierungsansatz mit lokalen Hardwaremodulen
3.3.3. Transformationsregeln
Grundvoraussetzung für die Transformation ist, dass das Esterel Programm in ei-nem Modul vorliegt. Alle im Programm verwendeten Symbolnamen müssen eindeutigsein, damit im KEP alle Signale eineindeutig einer bestimmten Adresse zugeordnetwerden können. Zudem ist zu beachten, dass der KEP Compiler bei Symbolnamennicht zwischen Groß- und Kleinschreibung unterscheidet, bzw. keine Kleinbuchsta-ben verwendet werden dürfen. Dazu wird das Programm entsprechend vorverarbei-tet: Mit dem CEC [15] Modul cec-expandmodules wird das Programm zunächst in einModul expandiert, ein weiterer Vorverarbeitungsschritt ersetzt in allen vorkommen-den Symbolnamen Kleinbuchstaben durch Großbuchstaben und benennt alle Namendurch Anhängen eines nummerierten Postfixes global eindeutig.
Signal Expressions
Signal Expressions werden wie im einführenden Beispiel behandelt. Zusätzlich zuden Operatoren and, or und not kann zusätzlich noch der pre Operator verwendetwerden. In Signal Expressions ist das Argument des pre Operators entweder ein ein-
40
3.3. Partitionierung
faches Signal oder eine Signal Expression. Eine Schachtelung von pre Operatorenist nicht erlaubt. Der pre Operator ist distributiv gegenüber and und or, jedochnicht gegenüber not. Für die erste Instanz der Gültigkeit eines Signals S gilt nämlichpre(not S) = absent. Es gelten die Regeln aus Abschnitt 2.2.2 auf Seite 10. Der preWert eines Signals kann nicht innerhalb des mit dem KEP verbundenen Logik Blocksberechnet werden. Es ist auf Hardwareebene nicht feststellbar, ob das Signal rein-karniert wurde, oder ob die Signaldeklaration innerhalb eines suspend Blocks liegt.Gemäß des Esterel Primers wird daher parallel zum Rumpf der Signaldeklaration einHilfssignal mit dem Status des Signals in der vorigen Instanz berechnet.
Signal Expressions sind Bestandteil eines present Signaltests oder einer Delay Ex-pression. Während der Partitionierung wird beim Auftreten von Signal Expressionseine Funktion aufgerufen, die folgende Transformation durchführt:
1. Führe ein neues Hilfssignal s mit einem eindeutigen Namen ein und ersetze dieSignal Expression e durch dieses Signal.
2. Multipliziere alle in der Expression e enthaltenen pre Operatoren entsprechendder o.g. Regeln aus, bis sie nur noch auf ein Signal angewendet werden.
3. Ersetze alle in der Expression e vorkommenden Anwendungen pre(S) bzw.pre_0(S) und pre_1(S) durch ein Hilfssignal pre_S bzw. pre0_S und pre1_S.Wenn dieses Signal nicht schon berechnet wird, deklariere es auf der gleichenEbene, wie das Signal S und berechne seinen Status pre0 oder pre1 parallelzum Rumpf der jeweiligen Deklaration.
4. Finde den hierarchisch niedrigsten Gültigkeitsbereich, in dem alle Signale derSignal Expression e bekannt sind. Deklariere in dem Gültigkeitsbereich zusätz-lich das Hilfssignal s. Deklariere in dem korrespondierenden Hardwaremodulalle in der Signal Expression vorkommenden Signale als input und das Hilfssi-gnal s als output.
5. Füge zum Rumpf des Hardwaremoduls einen Thread hinzu, der das Hilfssignalin jeder Instanz emittiert, in der die Signal Expression e present ist.
Data Expressions
Data Expressions werden in if Anweisungen, bei der Emittierung von Signalen mitWert (valued Signals), bei Wertzuweisungen an Variablen oder beim Behandeln vonExceptions benutzt. Eine Data Expression wird gemäß Esterel Primer [7, Abschnitt7.4.1] nach den folgenden Regeln produziert:
DataExpression :={
Constant |?SignalIdentifier |??ExceptionIdentifier |
41
3. HW/SW Co-Synthese
pre(?SignalIdentifier) |Variable |(DataExpression) |DataExpression ◦ DataExpression |not DataExpression |- DataExpression |FunctionCall
}
Als Verknüpfungsoperator (◦) zwischen zwei Data-Expressions sind boolsche (and,or),arithmetische (+,-,*,/,mod) und Vergleichsoperatoren (=,<>,<,<=,>,>=) erlaubt. Func-tionCalls, d.h. der Aufruf einer externen Funktion in nativem Programmcode, werdenvom KEP z.Zt. nicht unterstützt und werden daher nicht berücksichtigt.
Die Implementierung von Addition und Subtraktion sowie von Vergleichsoperato-ren ist in sequenzieller Logik zwar möglich, aber mit einem hohen Hardwareaufwandverbunden, da jedes verwendete Signal (32 Bit) mit der Hardware verbunden wer-den muss, und da die Implementierung der Schaltfunktionen mit einem enorm hohenPlatzbedarf verbunden ist. Die Berechnung von arithmetischen und Vergleichsfunk-tionen sollte daher weiter mit Hilfe der ALU des KEP stattfinden.
Variablen stellen ein zusätzliches Problem dar: Nach der Spezifikation von Este-rel sind sie im Gegensatz zu Signalen nicht zur Kommunikation zwischen Threadsgeeignet und können ihren Wert während einer Instanz mehrmals ändern. Verschie-dene Threads können sie zwar lesen aber nicht schreiben. Auch die Implementierungim KEP unterscheidet sich grundlegend von Signalen. Während Signale mit glei-chem Namen eindeutig einer Speicherstelle zugeordnet sind, werden Variablenwertenur temporär innerhalb von Registern gespeichert.
Hat eine Data Expression ein nicht boolsches Ergebnis, wird sie nicht von derHW/SW Co-Synthese berücksichtigt. Anderenfalls werden Teilberechnungen, dieVergleichs- und arithmetische Operatoren oder Variablen enthalten, extrahiert unddurch ein Hilfssignal ersetzt. Diese Hilfssignale werden unmittelbar vor der DataExpression mit dem entsprechenden Wert emittiert und sind pro Instanz und DataExpression eindeutig.
Der pre(?S) Operator liefert den Wert des Signals in der vorigen Instanz und darfnur auf einfache Signale angewandt werden.
Beim Auftreten von Data Expressions wird die folgende Transformation durchge-führt:
1. Ist das Ergebnis der Data Expression nicht boolsch, lasse sie unverändert.
2. Ansonsten führe ein neues Hilfssignal s mit einem eindeutigen Namen ein undersetze die Data Expression e durch dieses Signal.
3. Ersetze alle in der Expression e vorkommenden Anwendungen pre(?S) durchein Hilfssignal preV_S. Wenn dieses Signal nicht schon berechnet wird, dekla-riere es auf der gleichen Ebene, wie das Signal S und berechne seinen Statusund Wert parallel zum Rumpf der jeweiligen Deklaration.
42
3.4. Zwischenschritt: Logikminimierung
4. Extrahiere alle Teilausdrücke px, die auf oberster Ebene eine Vergleichsope-ration ausführen oder eine boolsche Variable sind und ersetze sie durch einHilfssignal ax. Das Hilfssignal muss pro Instanz und Data Expression eindeu-tig sein. Emittiere die (boolschen) Hilfssignale mit dem entsprechenden Wertunmittelbar vor der Data Expression (emit ax(px)). Ist die Data Expressi-on Bestandteil eines sustain Statements, muss es in diesem Fall dismantledwerden.
5. Finde den hierarchisch niedrigsten Gültigkeitsbereich, in dem alle Signale derData Expression e bekannt sind. Deklariere in dem Gültigkeitsbereich zusätz-lich die Hilfssignale s und ax. Deklariere in dem korrespondierenden Hardwa-remodul alle in der Data Expression vorkommenden Signale als input und dasHilfssignal s als output.
6. Füge zum Rumpf des Hardwaremoduls einen Thread hinzu, der das Hilfssignals mit dem Wert der Data Expression e in jeder Instanz emittiert. Initialisiereaußerdem alle nicht initialisierten Signale aus e mit dem Wert false.
3.4. Zwischenschritt: Logikminimierung
Um aus den Hardwaremodulen einen möglichst minimalen Logikblock synthetisierenzu können, werden in einem optionalen Zwischenschritt vor der Software- und Hard-waresynthese die in den Hardwaremodulen berechneten Expressions minimiert. DieLogikminimierung basiert auf dem MV-SIS Logiksynthesesystem, das als Ein- undAusgabeformat das BLIF Format benutzt.
Anhand des Beispiels in Abbildung 3.6 sollen die einzelnen Schritte der Logikmi-nimierung veranschaulicht werden.
Das Hardwaremodul berechnet den Status der Hilfssignale A_OR_B_AND_B_OR_Cund A_OR_B. In der BLIF Datei werden zunächst alle Eingangs- und Ausganssignaledeklariert. Danach wird mit dem Schlüsselwort .names die Funktion A_OR_B_AND_B_OR_Cmit den Parametern A, B und C deklariert. Auf Basis der Signal Expression (A or B)and (C or D) wird die Implementierung der Funktion in Form einer Wertetabelleberechnet und im Anschluss an die Funktionsdeklaration in die Datei geschrieben.Das Verfahren hierzu ist sehr einfach gehalten und testet sämtliche Signalbelegun-gen durch. Der Code für die zweite Funktion wird analog erzeugt. Anschließend wirdMV-SIS mit der erzeugten BLIF Datei als Eingabe und Parametern zur zweistufigenLogikminimierung und zur Extraktion von gemeinsamen Teilausdrücken gestartet.Das Ergebnis ist in der BLIF Datei rechts unten in Abbildung 3.6 zu sehen. Mankann erkennen, dass A or B als gemeinsamer Teilausdruck beider Funktionen erkanntwurde, da der Parameter A in der ersten Funktion durch den Funktionswert A_or_Bder zweiten Funktion ersetzt wurde.
Die Rücktransformation in ein Hardwaremodul erfolgt analog zur Transformationmit folgenden Erweiterungen: Werden in der BLIF Datei lokale Funktionen (als ex-trahierte Teilausdrücke) erzeugt, so werden lokale Signale mit den Funktionsnamen
43
3. HW/SW Co-Synthese
1 module example_2_hw_1:2 input A;3 input B;4 input C;5 output A_OR_B_AND_B_OR_C;6 output A_OR_B;7
8 every immediate [(A or B) and (B or C)] do9 emit A_OR_B_AND_B_OR_C
10 end every11 ||12 every immediate [A or B] do13 emit A_OR_B14 end every15
16 end module
1 .model example_2_cosyn.blif2 .inputs A B C3 .outputs A_OR_B_AND_B_OR_C A_OR_B4 .names A B C A_OR_B_AND_B_OR_C5 010 16 011 17 101 18 110 19 111 1
10 .names A B A_OR_B11 01 112 10 113 11 114
15 .end
MV-SIS1 module example_2_hw_1:2 input A,B,C;3 output A_OR_B_AND_B_OR_C;4 inputoutput A_OR_B;5
6 every immediate [A_OR_B or B and C] do7 emit A_OR_B_AND_B_OR_C8 end every9 ||
10 every immediate [B or A] do11 emit A_OR_B12 end every13
14 end module
1 .model example_2_cosyn.blif2 .inputs A B C3 .outputs A_OR_B_AND_B_OR_C A_OR_B4 .names B C A_OR_B A_OR_B_AND_B_OR_C5 1-- 16 -11 17 .names A B A_OR_B8 -1 19 1- 1
10 .end
Abb. 3.6.: Logikminimierung
im Hardwaremodul deklariert. In dem rücktransformierten Hardwaremodul wurdedas Signal A_OR_B als inputoutput deklariert, da es innerhalb des Hardwaremodulsgelesen wird. Das Lesen eines Ausgangssignals ist zwar in Esterel erlaubt, in VHDLjedoch nicht. Das Signal wird daher auf diese Art und Weise markiert, um es bei derSoftwaresynthese gesondert identifizieren zu können.
3.5. Software- und Hardwaresynthese
3.5.1. Softwaresynthese
Zur Ausführung des Softwaremoduls auf dem KEP muss dieses zunächst wie andereEsterel Programme mit dem Esterel2KASM Compiler [23] von Esterel nach KEPAssembler Code (KASM) übersetzt werden. Der KEP Assember Compiler generiertdanach aus dem KASM den maschinenlesbaren Operationscode.
Durch die Partitionierung gehen jedoch Informationen, die der Esterel2KASM
44
3.5. Software- und Hardwaresynthese
1 module missing_deps:2
3 input SET_A, B;4 output O;5
6 signal A in7
8 present SET_A then9 emit A
10 end present11 ||12 present A or B then13 emit O14 end present15
16 end signal17
18 end module
[L0,T0,P1] module: missing_deps
[L3,T0,P1/1] PAR*
[L4,T2,P1] A0
1
[L9,T1,P1] A1
1
[L5,T2,P1] PRESENT SET_A,A3
[L6,T2,P1] EMIT A
t
[L7,T2,P1] A3
f
[L10,T1,P1] PRESENT A,A6
i
[L8,T2,P1] NOTHING
[L19,T0,P1] JOIN 0
[L11,T1,P1] GOTO A5
t
[L12,T1,P1] A6
f
[L14,T1,P1] A5
[L13,T1,P1] PRESENT B,A4
t
[L16,T1,P1] A4
f
[L15,T1,P1] EMIT O
[L17,T1,P1] NOTHING
[L20,T0,P1/1] HALT
1 %%% Esterel Module: missing_deps2
3 INPUT SET_A,B4 OUTPUT O5 SIGNAL A6
7 EMIT _TICKLEN,#128
9 [L01,T0,P1] PAR 1,A0,210 [L02,T0,P1] PAR 1,A1,111 [L03,T0,P1/1] PARE A2,112 [L04,T2,P1] A0: PRESENT SET_A,A313 [L05,T2,P1] EMIT A14 [L06,T2,P1] A3: NOTHING15 [L07,T1,P1] A1: PRESENT A,A616 [L08,T1,P1] GOTO A517 [L09,T1,P1] A6: PRESENT B,A418 [L10,T1,P1] A5: EMIT O19 [L11,T1,P1] A4: NOTHING20 [L12,T0,P1] A2: JOIN 021 [L13,T0,P1/1] HALT
1 module missing_deps_sw:2 input SET_A;3 input B;4 output O;5
6 signal A,7 A_OR_B in8
9 [10 present SET_A then11 emit A12 end present13 ||14 present A_OR_B then15 emit O16 end present17 ];18
19
20 end signal21
22 end module
[L0,T0,P1] module: missing_deps_sw
[L3,T0,P1/1] PAR*
[L4,T1,P1] A0
1
[L9,T2,P1] A1
1
[L5,T1,P1] PRESENT SET_A,A3
[L6,T1,P1] EMIT A
t
[L7,T1,P1] A3
f
[L8,T1,P1] NOTHING
[L15,T0,P1] JOIN 0
[L10,T2,P1] PRESENT A_OR_B,A4
[L11,T2,P1] EMIT O
t
[L12,T2,P1] A4
f
[L13,T2,P1] NOTHING
[L16,T0,P1/1] HALT
1 %%% Esterel Module: missing_deps_sw2
3 INPUT SET_A,B4 OUTPUT O5 SIGNAL A,A_OR_B6
7 EMIT _TICKLEN,#118
9 [L01,T0,P1] PAR 1,A0,110 [L02,T0,P1] PAR 1,A1,211 [L03,T0,P1/1] PARE A2,112 [L04,T1,P1] A0: PRESENT SET_A,A313 [L05,T1,P1] EMIT A14 [L06,T1,P1] A3: NOTHING15 [L07,T2,P1]
A1: PRESENT A_OR_B,A416 [L08,T2,P1] EMIT O17 [L09,T2,P1] A4: NOTHING18 [L10,T0,P1] A2: JOIN 019 [L11,T0,P1/1] HALT
Abb. 3.7.: Oben: Esterel Programm mit Reader-/Writer Abhängigkeit zwischen zweiThreads, daneben der resultierende CKAG mit Abhängigkeitskante (gestrichelt) undder resultierende KASM Code; Unten: Das aus der Partitionierung resultierende SW-Modul, daneben der resultierende CKAG mit fehlender Abhängigkeitskante und dasresultierende KASM Programm mit falschem Scheduling
45
3. HW/SW Co-Synthese
Compiler zur Berechnung von Abhängigkeiten zwischen Threads benötigt, verloren.Dies soll mit Hilfe des in Abbildung 3.7 gezeigten Beispiels erläutert werden. DasProgramm missing_deps besteht aus zwei Threads. Im ersten Thread wird das lo-kale Signal A emittiert, wenn das Eingangssignal SET_A in der ersten Instanz presentist. In dem parallelen Thread wird in der ersten Instanz der Status der Signal Expres-sion A or B getestet und für den present Fall das Ausgangssignal O emittiert. DasStatement emit A im ersten Thread ist ein sog. Writer von A, present A or B then... ist ein sog. Reader von A. Ein Writer eines Signals muss vor dem Reader aus-geführt werden, was bei der Berechnung des statischen Schedulings berücksichtigtwerden muss. In Abbildung 3.7 Mitte oben ist der zum Programm korrespondie-rende Concurrent KEP Assembler Graph (CKAG) dargestellt, auf dessen Basis derEsterel2KASM Compiler das Scheduling berechnet. Die gestrichelte Kante stellt dieAbhängigkeit des present Knotens von dem emit Knoten dar. Der KEP führt beigleicher Priorität den Thread mit der höchsten ThreadID zuerst aus, anderenfallsden Thread mit der höchsten Priorität. In dem Beispiel hat Thread 1 die Priorität 2und Thread 2 die Priorität 1. Der erste Thread wird also vor dem zweiten ausgeführt.
Bei der HW/SW Co-Synthese wird die Signal Expression A or B durch das Hilfs-signal A_OR_B ersetzt. Das Hilfssignal wird innerhalb des mit dem KEP verknüpftenLogikblocks berechnet. Dem Esterel2KASM Compiler fehlt die Information, dassA_OR_B von A abhängt, d.h. dass present A_OR_B then ... Reader von A, bzw. dassemit A Writer von A_OR_B ist. Abbildung 3.7 Mitte unten zeigt den zum SW Modulkorrespondierenden CKAG, der keine Abhängigkeit zwischen den Threads enthält.Das Scheduling kann nun nicht mehr korrekt berechnet werden, es resultiert der inAbbildung 3.7 rechts unten gezeigte KASM Code, der für Thread 1 und 2 die gleichePriorität aufweist. Der Thread mit der höheren ThreadID, also Thread 2 wird nunfälschlicherweise zuerst ausgeführt.
Um das Scheduling trotzdem korrekt berechnen zu können, müssen die fehlendenAbhängigkeiten im CKAG) ergänzt werden. Dazu werden die Abhängigkeiten derHilfssignale während der Transformation in eine Datei geschrieben, die vom Este-rel2KASM Compiler zur Rekonstruktion der fehlenden Abhängigkeiten eingelesenwird. Abbildung 3.8 zeigt den CKAG mit den rekonstruierten Abhängigkeiten undden korrekten KASM Code.
3.5.2. Hardwaresynthese
Prinzipiell könnte man mit Hilfe des CEC den Esterel Code jedes Hardwaremo-duls in eine Hardwarebeschreibung synthetisieren. Dabei würde zunächst ein endli-cher Automat aus den Modulen erzeugt werden, der dann in Hardware synthetisiertwerden würde. Der dabei entstehende Overhead für die Implementierung des Au-tomaten wäre jedoch viel zu groß. Stattdessen genügt es, aus den Expressions eineinfaches Schaltnetz zu erzeugen, über das die Hilfssignale berechnet werden. DieImplementierung wird anhand des Beispiels aus der Übersichtsgrafik in Abbildung3.1 beschrieben, das der Übersichtlichkeit halber in Abbildung 3.9 noch einmal ab-gebildet ist.
46
3.5. Software- und Hardwaresynthese
1 module missing_deps_sw:2 input SET_A;3 input B;4 output O;5
6 signal A,7 A_OR_B in8
9 [10 present SET_A then11 emit A12 end present13 ||14 present A_OR_B then15 emit O16 end present17 ];18
19
20 end signal21
22 end module
[L0,T0,P1] module: missing_deps_sw
[L3,T0,P1/1] PAR*
[L4,T2,P1] A0
1
[L9,T1,P1] A1
1
[L5,T2,P1] PRESENT SET_A,A3
[L6,T2,P1] EMIT A
t
[L7,T2,P1] A3
f
[L10,T1,P1] PRESENT A_OR_B,A4
i
[L8,T2,P1] NOTHING
[L15,T0,P1] JOIN 0
[L11,T1,P1] EMIT O
t
[L12,T1,P1] A4
f
[L13,T1,P1] NOTHING
[L16,T0,P1/1] HALT
1 %%% Esterel Module: missing_deps_sw2
3 INPUT SET_A,B4 OUTPUT5 SIGNAL A,A_OR_B6
7 EMIT _TICKLEN,#118
9 [L01,T0,P1] PAR 1,A0,210 [L02,T0,P1] PAR 1,A1,111 [L03,T0,P1/1] PARE A2,112 [L04,T2,P1] A0: PRESENT SET_A,A313 [L05,T2,P1] EMIT A14 [L06,T2,P1] A3: NOTHING15 [L07,T1,P1]
A1: PRESENT A_OR_B,A416 [L08,T1,P1] EMIT O17 [L09,T1,P1] A4: NOTHING18 [L10,T0,P1] A2: JOIN 019 [L11,T0,P1/1] HALT
Abb. 3.8.: CKAG des SW Moduls mit rekonstruierter Abhängigkeit zwischen denThreads und resultierender KASM Code mit korrektem Scheduling
1 module intro_example_hw_1:2 input D := false : boolean;3 input E := false : boolean;4 input F := false : boolean;5 output D_OR_E_AND_F := false : boolean;6
7 sustain D_OR_E_AND_F(?D or ?E and ?F)8
9 end module
1 module intro_example_hw_2:2 input A,B,C;3 output A_OR_B_AND_C;4
5 every immediate [(A or B) and C] do6 emit A_OR_B_AND_C7 end every8
9 end module
1 library IEEE;2 use IEEE.STD_LOGIC_1164.ALL;3 use IEEE.STD_LOGIC_ARITH.ALL;4 use IEEE.STD_LOGIC_UNSIGNED.ALL;5
6 entity intro_example is7 port(8 A:in std_logic;9 B:in std_logic;
10 C:in std_logic;11 D:in std_logic_vector(1 downto 0);12 E:in std_logic_vector(1 downto 0);13 F:in std_logic_vector(1 downto 0);14 A_OR_B_AND_C:out std_logic;15 D_OR_E_AND_F:out std_logic_vector(1 downto 0)16 );17 end intro_example;18
19 architecture intro_example_BEH of intro_example is20 begin21 D_OR_E_AND_F(1) <= (D(1) or (E(1) and F(1)));22 A_OR_B_AND_C <= A or (B and C);23 end intro_example_BEH;
Abb. 3.9.: Hardwaresynthese
47
3. HW/SW Co-Synthese
Zunächst einmal ist festzustellen, dass aus den zwei Hardwaremodulen ein einzi-ger Logikblock erzeugt werden kann. Im Gegensatz zur Esterel-Ebene gibt es aufKEP-Ebene keine semantischen Probleme mit lokalen Signalen, da Schnittstellensi-gnale und lokale Signale im KEP in der gleichen Datenstruktur repräsentiert sind.Da alle Symbolnamen im Programm global eindeutig sind (was als Vorbedingungzur Transformation gefordert war und die neu eingeführten Hilfssignale ebenfallseindeutig benannt wurden), sind alle Signale eindeutig adressierbar.
Die Anweisungen zum Einbinden von Bibliotheken sind vor der Deklaration ei-ner neuen Entwurfseinheit obligatorisch. Der Name der entity bildet sich aus demOriginalnamen des Programms.
Alle Interfacesignale der Logikblöcke werden in der port-Deklaration der neuenEntwurfseinheit deklariert. Die Signale A, B und C werden vom Typ std_logic alsEingang deklariert, da sie als pure signals nur einen Statuswert besitzen. Das Si-gnal A_OR_B_AND_C wird analog als Ausgang deklariert. Die boolschen Signale D, Eund F besitzen zusätzlich zu ihrem Status einen Signalwert. Sie werden vom Typstandard_logic_vector(1 downto 0) als Eingang mit zwei Bit Breite deklariert.Bit 0 trägt den Statuswert und Bit 1 den boolschen Wert. Das AusgangssignalD_OR_E_AND_F wird analog als Ausgang deklariert.
In der anschließenden Verhaltensimplementierung wird ein einfaches Schaltnetzbeschrieben. Das Statement every immediate SigExp do emit AuxSig end imple-mentiert eine permanente Statuszuweisung des Ergebnisses der Signal ExpressionSigExp an das Hilfssignal AuxSig. Stark vereinfacht kann dies in VHDL als schlichteSignalzuweisung AuxSig <= SigExp implementiert werden. Dabei ist auf eine voll-ständige Klammerung der Signal Expression zu achten, da and und or in VHDL diegleiche Präzedenz haben. In dem Beispiel ergibt sich für every immediate [A or(B and C)] do emit A_OR_B_AND_C end die Signalzuweisung A_OR_B_AND_C <= (Aor B) and C. Eine sustain AuxSig(ValExpr) Anweisung emittiert in jeder Instanzdas Signal AuxSig mit dem Wert der Expression ValExp. Stark vereinfacht ergibtsich in VHDL die Signalzuweisung AuxSig(1) <= ValExpr. Der Wert jedes Signalsin ValExp wird über den Index 1 indiziert. Es ist ebenfalls auf eine vollständigeKlammerung zu achten. In dem Beispiel ergibt sich für sustain D_OR_E_AND_F(?Dor ?E and ?F) in VHDL die Signalzuweisung D_OR_E_AND_F(1) <= D(1) or (E(1)and F(1)).
Im Falle einer mehrstufigen Logikminimierung eingeführte lokale Signale werdenin der VHDL Architekturbeschreibung ebenfalls als lokale Signale deklariert.
3.6. Schnittstelle zwischen Logikblock und KEP
Der bei der Co-Synthese generierte Logikblock ist als einfaches Schaltnetz implemen-tiert. Bei der Verknüpfung mit dem KEP muss von außen sicher gestellt werden, dassalle Eingänge des Logikblocks korrekt belegt sind und dass dem KEP die Ausgängewieder zugänglich gemacht werden. Alle Daten für lokale und Interfacesignale werdenin bestimmten Hardwarestrukturen innerhalb des Interfaceblocks des KEP gespei-
48
3.6. Schnittstelle zwischen Logikblock und KEP
Sinout
SDat
Da
Re
gS
t
Interface Block
Da
StB
oo
lea
n
io
tRe
Sn
ug
KEP Logic Block Environment
innerSinoutFlagor
SDir
SDatID/SDatClk/SDatWR
tick 01
Abb. 3.10.: Schematische Darstellung des erweiterten Interfaceblocks des KEP ohnepre-Unterstützung mit angeschlossenem Logikblock
chert. Im Folgenden wird zunächst der Aufbau des Interfaceblocks beschrieben undanschließend notwendige Erweiterungen für eine Verknüpfung mit dem Logikblockvorgestellt.
Abhängig von seiner Konfiguration unterstützt der KEP eine feste maximale An-zahl von n Signalen. Die Statuswerte von lokalen und Ausgangssignalen werden indem n Bit weiten SinoutReg Register gespeichert. Je nach Konfiguration des KEPwerden zusätzlich die Statuswerte der vorigen Instanz im preSinoutReg vorgehal-ten. Die Speicherung der Signalwerte erfolgt in einem Dual-Port Block RAM mit32 Bit Datenwortbreite. Die Schnittstelle zur Umgebung ist folgendermaßen aufge-baut: Über den n Bit weiten bidirektionalen Datenbus Sinout kann lesend auf dieStatuswerte zugegriffen werden bzw. der Signalstatus von Eingangssignalen gesetztwerden. Die Richtung des Busses wird über die Eingangsleitung SDir gesteuert. ImGegensatz zu den Statuswerten kann auf die 32 Bit weiten Signalwerte nicht parallelzugegriffen werden, da dies einen enormen Hardwarebedarf zur Folge hätte. Für densequenziellen Zugriff auf den RAM steht ein bidirektionaler 32 Bit weiter DatenbusSDat, eine Adressleitung SDatID, eine Taktleitung SDatClk und eine Leitung zurInitiierung des Schreibvorgangs SDatWR zur Verfügung. Die Umwelt erhält nur zwi-schen zwei Ticks Zugriff auf die Signaldaten. Während des Assemblierens durch denKEP Assembler Compiler erfolgt eine eindeutige Zuordnung der Signalnamen aufeine Speicheradresse. Sind alle Signalnamen eindeutig gewählt, ist diese Abbildungbijektiv.
Um den Logikblock mit dem Interfaceblock verknüpfen zu können, muss dieser ge-eignet erweitert werden und die Abbildung von Signalnamen auf Adressen bekanntsein. Eingangs- und Ausgangssignale des Logikblocks sind vom Typ std_logic bzw.
49
3. HW/SW Co-Synthese
std_logic_vector(1 downto 0). Der Typ std_logic wird für pure Signals verwen-det und der Typ std_logic_vector(1 downto 0) für valued Signals. Dabei enthältBit 0 den Status und Bit 1 den boolschen Wert des Signals. Alle Ausgänge der Logik,die einen Statuswert führen, werden mit dem Eingang des SinoutReg verbunden. DasRegister übernimmt den Wert am Ende jedes Instruktionszyklus. Der Ausgang desSinoutReg wird konjunktiv verknüpft mit dem Datenbus Sinout und auf den inter-nen Datenbus innerSinoutFlag gelegt. Der Bus ermöglicht damit einen Zugriff auf dieStatuswerte aller Signale. Die Statuseingänge des Logikblocks werden mit den ent-sprechenden Signalleitungen des innerSinoutFlag verknüpft. Um auf die boolschenWerte parallel zugreifen zu können, wird das zusätzliche SDatBoolean Register ein-geführt. In diesem Register wird parallel zum RAM eine Kopie des nullten Bits allerSignale (entspricht bei boolschen Signalen dem boolschen Wert) abgelegt. Auf dieAusgänge des Registers kann wie im SinoutReg parallel zugegriffen werden. Die Ein-und Ausgänge des Logikblocks, die einen boolschen Ausdruck berechnen, werden mitden entsprechenden Aus- und Eingängen des SDatBoolean Registers verknüpft.
3.6.1. Inkrementelle Entwicklung und Partielle Rekonfiguration
Ein Nachteil dieses Co-Synthese Ansatzes ist, dass für jedes Esterel Programm einindividueller Logikblock generiert werden muss. Da der KEP zur Zeit als VHDL Codevorliegt und mit Hilfe eines Synthesewerkzeugs für eine FPGA basierte Zielplattformsynthetisiert wird, ist die Flexibilität dieses Ansatzes gewährleistet. Soll nicht dergesamte KEP bei jeder Änderung des Logikblocks neu synthetisiert werden, bietetdie Xilinx ISE Entwicklungsumgebung [38] spezielle Designmethoden an:
• Bei der inkrementellen Entwicklung [37, Kapitel 3] wird das gesamte Design inunterschiedliche Entwurfseinheiten unterteilt. Diese werden auf oberster Ebenezusammengeführt. In diesem Fall ist nur einmalig eine Synthese des gesamtenDesigns nötig, anschließend werden nur die Entwurfseinheiten neu synthetisiert,in denen eine Veränderung aufgetreten ist. Voraussetzung für die inkrementel-le Synthese ist ein festes Interface zwischen den einzelnen Entwurfseinheiten.Zusätzlich wird für ein inkrementelles Platzieren und Verdrahten (place androute) gefordert, dass alle Entwurfseinheiten festen Bereichen auf dem FPGAzugeordnet werden (über area constraints), die sich nicht überschneiden dürfen,und dass die Größe der Entwurfseinheiten nur begrenzt variiert.
• Bei der Partiellen Rekonfiguration [37, Kapitel 5] ist es auf bestimmten FPGATypen möglich, nur bestimmte Bereiche des FPGA neu zu konfigurieren. Diesist sogar im laufenden Betrieb möglich. Die Anforderungen in Bezug auf Inter-face und Fläche sind jedoch restriktiver, als bei der inkrementellen Entwicklung:Die Fläche eines partiell rekonfigurierbaren Moduls hat immer die volle Bau-steinhöhe und die Breite ist ein Vielfaches von 4 Slices. Module können nur aufeiner geraden 4 Slice Grenze platziert werden. Die Kommunikation über dieGrenzen eines partiell rekonfigurierbaren Moduls hinweg mit anderen parti-ell rekonfigurierbaren oder statischen Modulen muss über festgelegte, statische
50
3.6. Schnittstelle zwischen Logikblock und KEP
Abb. 3.11.: Oben: Aufteilung in rekonfigurierbare und statische Module, Unten: Im-plementierung des Bus Makros (Beide Graphiken aus [37])
Routingressourcen erfolgen, die über sog. Bus-Makros instantiiert werden. EinBus-Makro ist ein bereits geroutetes Hard-Makro, das eine feste Routingbrückezwischen zwei Modulen spezifiziert. Jede Zeile eines partiell rekonfigurierbarenFPGAs (z.B. VirtexII oder VirtexII Pro) besitzt vier sog. TBUF Longlines,über die ein Signal von rechts nach links oder umgekehrt wandern kann. Je-de Slice verfügt über zwei Tri-State Buffer (TBUF), über die auf eine der vierLonglines geschrieben werden kann. Das Standard Bus-Makro benutzt acht Tri-State Buffer, so dass pro Zeile vier Bit über eine Modulgrenze hinweg geroutetwerden können. Daraus ergibt sich eine Breite von vier Slices pro Bus-Makro.
Die verwendete ISE Entwicklungsumgebung unterstützt jedoch den Designfluss fürdie partielle Rekonfiguration nur unvollständig; für eine vollständige Unterstützungwären weitere Tools notwendig. Für den inkrementellen Designfluss ist eine Anpas-sung des KEP Designs nötig, da nur Module auf oberster Ebene getrennt synthetisiertwerden können. In einer festen Konfiguration des KEP in Form eines ASIC wäre es
51
3. HW/SW Co-Synthese
denkbar, diesen mit einem rekonfigurierbaren Logikbaustein (z.B. FPGA, PLA) zuverbinden, oder eine rekonfigurierbare Logik im Design des KEP zu integrieren.
3.7. Implementierung
Die Implementierung der HW/SW Co-Synthese basiert auf dem quelloffenen Colum-bia Esterel Compiler (CEC) [15], der von der Languages and Compilers Group umS.A. Edwards an der Columbia University entwickelt wurde. Der CEC unterstützteine Teilmenge von Esterel V5 und generiert wahlweise C Code für die Softwa-resynthese oder eine Verilog bzw. BLIF Beschreibung eines Schaltkreises. Der CECist in C++ programmiert und durch seinen modularen Aufbau einfach zu erweitern.Jeder Verarbeitungsschritt erfolgt durch ein eigenständiges Programm. Die einzelnenModule des CEC repräsentieren ein Esterel Programm in einer baumartigen Daten-struktur, dem Abstract Syntax Tree (AST). Der Esterel Parser und die Klasse ASTwerden mit Hilfe des Parsergenerators ANTLR automatisch erzeugt. Um auf demAST zu arbeiten, wird das Visitor Entwurfsmuster benutzt. Dazu muss die abstrakteKlasse Visitor geeignet implementiert werden.
Eine Unterstützung des pre Operators fehlt im CEC; der Operator kann wedergeparst werden, noch ist ein entsprechendes Feld im AST vorgesehen. Daher wurdedie zugrunde liegende Grammatik um den pre Operator erweitert und der AST undder Esterel Parser mit Hilfe von ANTLR neu erzeugt. Auf eine weitere Dokumen-tation wird hier verzichtet, weil es sich um minimale Änderungen in der Grammatikhandelt.
Die HW/SW Co-Synthese setzt nach den Schritten Parsen (cec-strlxml) und Mo-dulexpansion (cec-expandmodules) an. Die einzelnen Module im- und exportierenden AST als XML Datei.
52
4. Experimentelle Auswertung
In diesem Kapitel soll quantifiziert werden, welche Auswirkungen sich durch denCo-Syntheseansatz ergeben. Die Vorteile dieses Ansatzes variieren von Programmzu Programm und sind üblicherweise vor allem dort zu erwarten, wo viele komplexeAusdrücke vorkommen. Daher wurde für die Versuche ein Satz von Programmen alsBenchmark ausgewählt, die eine entsprechende Anzahl an komplexen Ausdrückenaufweisen. Programme ohne Signalausdrücke können auf dem KEP bereits effizientausgeführt werden.
Den Vorteil der Reduktion von Instruktionszyklen pro Tick und einem damit ver-bundenen verringerten Stromverbrauch oder einer verbesserten WCRT erkauft mansich mit einem leicht erhöhten Ressourcenverbrauch auf dem KEP und der Ausfüh-rungsplattform.
Ein weiterer interessanter Punkt ist die Laufzeit des längsten Pfades im Logik-block. Jedes Schaltnetz hat physikalisch bedingt eine bestimmte Gatterlaufzeit, diemit der Schachtelungstiefe ansteigt. Die Eingangssignale des KEP werden jeweils zuBeginn eines neuen Ticks abgetastet und stehen ab diesem Zeitpunkt auch dem Lo-gikblock zur Verfügung. Die Berechnung des Logikblocks muss zu Beginn des erstenInstruktionszyklus vorliegen, der um einen Systemtakt verzögert nach dem Tick be-ginnt. Ist der zu ersetzende Ausdruck tief verschachtelt, kann dies in Extremfällenzu einer Verschlechterung der maximalen Taktfrequenz des KEP führen. Dies ist imNormalfall aber nicht zu erwarten und tritt bei den untersuchten Beispielen nichtauf.
Bei den Experimenten werden die folgenden Werte für die normale Ausführungeines Esterel Programms und für den Co-Design Ansatz miteinander verglichen:
• Ticklänge: Die „WCRT“, die vom Esterel2KASM Compiler durchgeführt wird,ermittelt analytisch eine konservative obere Schranke für den Wert für _TICKLEN.Die „AVE“ und „MAX“ Werte geben die gemessenen Durchschnitts- und Ma-ximalwerte an, die mit automatisch und manuell generierten Testszenarien alsEingabevektoren ermittelt wurden. Mit Hilfe von EsterelStudio [17] lassen sichTestszenarien für ein Esterel Programm automatisch erzeugen. Diese be-stehen aus einem oder mehreren Tests, die wiederum für eine oder mehrereInstanzen verschiedene Eingangssignalbelegungen enthalten. Die Testszenarienwerden so erzeugt, dass alle Zustände in dem jeweiligen Esterel Programmerreicht werden.
• Signale: Diese Spalte gibt an, wie viele Hilfssignale benötigt wurden, um dieExpressions zu ersetzen. Die Menge an maximal zur Verfügung stehenden Si-gnalen ist von der Konfiguration des KEP abhängig. Die Leistungsaufnahme
53
4. Experimentelle Auswertung
steigt mit der in der Konfiguration des KEP unterstützten Anzahl von Signa-len und sollte daher möglichst klein gehalten werden. Die Anzahl der für dasCo-Design zur Verfügung stehenden Hilfssignale ist also begrenzt.
• FPGA Ausnutzung: Für die Logik und insbesondere für die Erweiterung desInterfaces zum KEP steigt die Gesamtgröße des Designs. Für den FPGA alsZielplattform wird die FPGA Ausnutzung durch die Anzahl der belegten Slicesund der 4 Input Look Up Tables (LUTs) angegeben.
• Energieverbrauch: Die Leistungsaufnahme P des KEP und des Co-Designs wirdmit Hilfe des Xilinx WEB Power Tools [36] berechnet, das die Leistungsaufnah-me auf Basis des verwendeten FPGA Typs, der verwendeten FPGA Ressourcenund der Taktfrequenz der Logik approximiert. Jeder Instruktionszyklus hat eineDauer von drei Prozessortakten. Dazu kommt die Zeit zum Lesen und Schreibender Signale. Der Energieverbrauch pro Tick ergibt sich aus der Leistungsaufnah-me P multipliziert mit der Dauer eines Ticks , Ttick = (3V_TICKLEN + 2)Tosc.Für die Berechnung der Spitzenleistungsaufnahme Ppeak wird eine Taktfre-quenz der Logik von 40 MHz angenommen. Für die Berechnung der Leistungs-aufnahme im unbeschäftigten Zustand Pidle, d.h. in der Zeit vom Ende derAbarbeitung der Instruktionen eines Ticks bis zum Start des nachfolgendenTicks, wird eine Frequenz von 0 MHz angenommen. Die Leistungsaufnahmeverringert sich in diesem Fall auf die Ruheleistung des FPGA. „WCRT“ gibtden im Extremfall größten zu erwartenden Wert für den Energieverbrauch proTick an, wenn die Ticklänge gleich der WCRT ist. „AVE“ und „MAX“ basierenauf den gemessenen Durchschnitts- und Maximalwerten für die Ticklänge.
• Delay: Die Signallaufzeit des längsten Pfades der Logik in Nanosekunden wirdmit Hilfe des ISE Entwicklungsumgebung berechnet.
Ausführungsplattform für die Experimente ist ein KEP der bis zu 85 Signale und60 Threads unterstützt. Der KEP bzw. KEP und Logikblock wurden in allen Ex-perimenten für den Xilinx Virtex II Pro (xc2vp30-6ff896) FPGA synthetisiert undauf diesem ausgeführt. Der KEP in dieser Größe benötigt in etwa ein Drittel der aufdem FPGA vorhandenen Ressourcen.
In den Experimenten werden folgende fünf Benchmarks miteinander verglichen:Das TCINT Programm aus der Estbench [12], zwei azyklische Versionen des TokenRing Arbiters mit 3 und 10 Stationen, das Programm SyntheticExample [28], daseinen Filter modelliert und das BACKHOE Programm, welches für die Simulationeines Baggers benutzt wird.
Die Ergebnisse der Experimente sind in Tabelle 4.1 gezeigt. Der Co-Design An-satz reduziert verglichen mit der normalen Ausführung auf dem KEP sowohl dieanalytisch berechnete WCRT zwischen 17.6% und 58.9%, als auch die experimen-tell ermittelten Durchschnitts- und Maximalwerte zwischen 9.8% und 43.7% bzw.zwischen 11.9% bzw. 31.2%.
Andererseits erkauft man sich die aufgezeigten Vorteile durch einen erhöhten Res-sourcenverbrauch in Form von Signalen auf dem KEP und in Form eines erhöhten
54
Ben
chm
ark
Des
ign
Tic
klen
gth
Sign
als
FP
GA
Uti
lizat
ion
Ene
rgy/
Tic
k[µ
Ws]
Del
ay[n
s]W
CRT
AV
EM
AX
InO
utLoc
al#
slic
es#
4in
put
LU
Ts
WC
RT
AV
EM
AX
Tci
nt
KE
Pon
ly15
559
101
1920
1251
4475
919.
574
7.23
78.
270
-C
o-D
esig
n11
551
8919
2025
5247
7751
7.14
75.
591
6.54
65.
285
Diff
-40
-8-1
2+
13+
103
+16
0-2
.399
-1.6
46-1
.724
-%
Diff
-25.
8-1
3.6
-11.
9+
25.5
+2.
0+
2.1
-25.
062
-22.
741
-20.
849
-
Tok
enR
ing
Arb
iter
(3st
atio
ns)
KE
Pon
ly74
5161
33
1651
4475
914.
592
4.05
14.
297
-C
o-D
esig
n61
4650
33
1952
5477
353.
820
3.46
93.
569
11.8
52D
iff-1
3-5
-11
+3
+11
0+
144
-0.7
72-0
.582
-0.7
28-
%D
iff-1
7.6
-9.8
-18.
0+
13.6
+2.
1+
1.9
-16.
806
-14.
360
-16.
931
-
Tok
enR
ing
Arb
iter
(10
stat
ions
)
KE
Pon
ly25
617
220
110
1051
5144
7591
17.7
8513
.743
14.4
57-
Co-
Des
ign
208
148
155
1010
6152
1477
6212
.943
11.4
6011
.636
18.8
50D
iff-4
8-2
4-4
6+
10+
70+
171
-2.8
42-2
.284
-2.8
21-
%D
iff-1
8.75
-14.
0-2
2.9
+19
.6+
1.4
+2.
3-1
8.00
7-1
6.61
6-1
9.51
4-
Synt
heti
cE
xam
ple
KE
Pon
ly13
394
101
167
1451
4475
918.
221
7.28
67.
458
-C
o-D
esig
n90
7783
167
4052
1777
625.
624
5.32
25.
472
5.77
4D
iff-4
3-1
7-1
8+
26+
73+
170
-2.5
92-1
.964
-1.9
86-
%D
iff-3
2.3
-18.
1-1
7.8
+70
.2+
1.4
+2.
2-3
1.59
1-2
6.95
9-2
6.62
4-
Bac
khoe
KE
Pon
ly20
916
3212
153
5144
7591
12.8
958.
171
8.56
5-
Co-
Des
ign
869
2212
155
5254
7734
5.36
93.
465
3.79
04.
402
Diff
-123
-7-1
0+
2+
110
+14
3-7
.526
-4.7
07-4
.775
-%
Diff
-58.
9-4
3.7
-31.
2+
6.7
+2.
1+
1.9
-58.
362
-57.
599
-55.
745
-
Tab
.4.1
.:Ver
such
serg
ebni
sse
55
4. Experimentelle Auswertung
Hardwareaufwands für den Logikblock und seine Anbindung an den KEP. Der zu-sätzliche Hardwareaufwand des Co-Designs verglichen mit dem KEP liegt zwischen1.4% bis 2.1% für die Anzahl der Slices und zwischen 1.9% bis 2.2% für die An-zahl der 4 Input LUTs und fällt damit kaum ins Gewicht. Die Leistungsaufnahmedes FPGA im Ruhezustand beträgt für beide Designs Pidle = 492mW und im be-schäftigten Zustand Ppeak = 820mW für den KEP und ca. Ppeak = 827mW für dasCo-Design (Werte nicht in der Tabelle ersichtlich). Der zusätzliche Hardwarebedarfhat somit einen zu vernachlässigenden Einfluss auf den Energieverbrauch pro Tick.Hier überwiegen die Einsparungen, die aus der Reduzierung der WCRT, als auch ausder Reduzierung der Durchschnitts- und Maximalwerte für die Ticklänge resultieren.Für den analytisch ermittelten maximalen Energieverbrauch ergeben sich Einsparun-gen zwischen 16.8% und 58.4%. Im experimentell ermittelten Durchschnitt reduziertsich der Energieverbrauch um 14.3% bis 57.6%.
Signale sind eine begrenzte Ressource; ihre maximale Anzahl hängt von der Kon-figuration des KEP ab (hier 85 Signale). In der Praxis würde man eine KEP Konfi-guration wählen, die bestmöglich zu der Anwendung passt. Der Signalbedarf steigtje nach Benchmark z.T. erheblich zwischen 6.7% für den BACKHOE-Benchmarkund 70.2%.für den SyntheticExample-Benchmark. Während bei allen Beispielen voneiner statischen KEP Konfiguration ausgegangen wurde, soll für das SyntheticExam-ple sowohl für die reine Softwaresynthese, als auch für das Co-Design eine minimaleKonfiguration des KEP für die Berechnung des Energieverbrauchs zugrunde gelegtwerden. Der KEP unterstützt in beiden Fällen 12 Threads. Für die Softwaresynthesewerden 37 Signale benötigt und für das Co-Design 63. Es wurden folgende WerteErmittelt:
• nur KEP: #slices: 2913, #4 Input LUTs: 4390, Energy/Tick [µWs]: 6,687(WCRT), 6,199 (AVE), 6,291 (MAX).
• Co-Design: #slices: 3174,#4 Input LUTs: 4633, Energy/Tick [µWs]: 4,638(WCRT), 4,477 (AVE), 4,562 (MAX).
Damit egibt sich eine Verbesserung des durchschnittlichen Energieverbrauchs um27,78 % (gegenüber 26,95 % in der festen Konfiguration), da eine Variation derdurch die KEP-Konfiguration unterstützten Signale nur minimale Änderungen imStromverbrauch bewirkt und der Basisstromverbrauch des FPGA sehr hoch ist.
Die höchste Laufzeit für den Logikblock von 18.85 ns wurde für das azyklische To-ken Ring Arbiter Programm mit zehn Stationen ermittelt. Die Periodendauer einesSystemtaktes ist die Zeit, in der das Berechnungsergebnis des Logikblocks spätestensvorliegen muss. Dies entspricht genau der Dauer zwischen dem Beginn eines neuenTicks (zu dem alle Eingangssignale gelesen werden) und dem Beginn des ersten In-struktionszyklus. Die Dauer zwischen den einzelnen Instruktionszyklen ist größer/-gleich dieser Dauer. Die Periodendauer für eine Taktfrequenz von 40 MHz beträgt25 ns und liegt damit 6.15 ns über der höchsten ermittelten Laufzeit. Das Ergebnisliegt also für alle getesteten Beispiele rechtzeitig vor. Der Token Ring Arbiter ist
56
ein bekanntes Beispiel für ein konstruktives Esterel Programm, das zyklische Si-gnalabhängigkeiten enthält. Bei der Konvertierung solcher Programme in azyklischeentstehen jedoch sehr tief verschachtelte Signalausdrücke; so ergibt sich für diesesBeispiel eine Schachtelung von 30 Gatterebenen. Auch wenn in der Praxis vergleich-bare Anwendungen eher selten sind, kann die Laufzeit der Logik in einzelnen Fällenein limitierender Faktor sein.
Aus den experimentellen Ergebnissen kann man ablesen, dass die Effektivität desCo-Design Ansatzes stark von dem Programm abhängt. Es konnte in allen Fällen eineVerkürzung der WCRT und eine Verringerung des Energieverbrauchs nachgewiesenwerden.
57
4. Experimentelle Auswertung
58
5. Zusammenfassung
Der KEP ist sehr effizient in der Ausführung von Esterel Statements, da diese größ-tenteils direkt in KEP Assembler Instruktionen abgebildet werden können. KomplexeExpressions, die auf dem KEP in mehrere sequenzielle Instruktionen sequenzialisiertwerden müssen, lassen sich sehr effizient in Form von Schaltnetzen in Hardwareimplementieren. Es wurde ein Ansatz vorgestellt, mit dem sich Expressions aus Es-terel Programmen extrahieren lassen, ohne dabei die Semantik des Programms zuverändern. Dazu wird das Programm zunächst auf Esterel Code Basis in Software-und Hardwarebestandteile zerlegt. Das eigentliche Programm mit den durch Hilfssi-gnale ersetzten Expressions bildet das neue Softwaremodul. Die Hilfssignale werdenin einem bzw. mehreren Hardwaremodulen berechnet. Im zweiten Schritt wird ausden Hardwaremodulen eine kombinatorische Logik gebildet, die mit dem KEP ver-bunden wird. Das Softwaremodul wird nach KEP Assembler übersetzt und auf demKEP mit Logikblock ausgeführt.
Arithmetische Ausdrücke können nicht effizient in der vorgestellten Weise in Hard-ware abgebildet werden. Sowohl für die Bereitstellung der Signalwerte, als auch fürdie Implementierung einzelner Berechnungen würde sich ein enormer Ressourcenver-brauch ergeben.
In den Experimenten konnte nachgewiesen werden, dass für Programme, die kom-plexe Ausdrücke enthalten, z.T. deutliche Verbesserungen der Ticklänge und desEnergieverbrauchs erzielt werden können. Der zu erreichende Vorteil hängt maßgeb-lich davon ab, an welchen Stellen im Programm die komplexen Ausdrücke auftretenund ob durch ihre Beseitigung der längste Pfad bei der WCRT Analyse verkürzt wer-den kann. Ein Nachteil Co-Design Ansatzes ist die hohe Zahl von zusätzlich benötig-ten Hilfssignalen. Hier ist es denkbar, Hilfssignale, die in unterschiedlichen Instanzenauftreten, wiederzubenutzen. Eine andere Möglichkeit besteht darin, bevorzugt langeAusdrücke oder günstige, gemeinsame Teilausdrücke ausfindig zu machen und nurdiese in der Logik zu behandeln. Es ist auch denkbar, mit Hilfe der WCRT Analyseiterativ Ausdrücke in den Instanzen zu ersetzen, die die WCRT maßgeblich negativbeeinflussen.
Synthetisiert man KEP und Logik für die Ausführung auf einem FPGA, ergebensich im Gegensatz zu den anderen Co-Design Ansätzen keine Nachteile in Bezugauf Flexibilität. Nutzt man inkrementelle Syntheseflüsse, so müssen nur geänder-te Module neu synthetisiert werden. Nutzt man die Möglichkeit vieler FPGAs zurpartiellen Rekonfiguration, lässt sich gezielt der Logikblock überschreiben. FPGAswerden jedoch eher im Entwicklungsprozess eingesetzt; in der Praxis wird der KEPin einer statischen Form z.B. als ASIC vorliegen. Um das Co-Design auch hier nut-zen zu können, ist es denkbar, den KEP mit einer vorgeschalteten rekonfigurierbaren
59
5. Zusammenfassung
Logik in Form eines PLA oder eines kleinen FPGA zu kombinieren. Eine andereMöglichkeit besteht darin, im KEP selbst eine rekonfigurierbare Logik einzubetten,die z.B. über bestimmte Leitungen oder Instruktionen konfigurierbar ist.
60
6. Literaturverzeichnis
[1] Charles André. SyncCharts: A Visual Representation of Reactive Behaviors.Technical Report RR 95–52, rev. RR (96–56), I3S, Sophia-Antipolis, France,Rev. April 1996. http://www.i3s.unice.fr/~andre/CAPublis/SYNCCHARTS/SyncCharts.pdf.
[2] Felice Balarin, Paolo Giusto, Attila Jurecska, Claudio Passerone, Ellen M. Sen-tovich, Bassam Tabbara, Massimiliano Chiodo, Harry Hsieh, Luciono Lavagno,Alberto Sangiovanni-Vincentelli, and Kei Suzuki. Hardware-Software Co-Designof Embedded Systems, The POLIS Approach. Kluwer Academic Publishers, April1997.
[3] Felice Balarin, Yosinori Watanabe, Harry Hsieh, Luciano Lavagno, Claudio Pa-serone, and Alberto L. Sangiovanni-Vincentelli. Metropolis: an integrated elec-tronic system design environment. IEEE Computer, 36(4):45–52, April 2003.
[4] Albert Benveniste, Paul Caspi, Stephen A. Edwards, Nicolas Halbwachs, Paul LeGuernic, and Robert de Simone. The Synchronous Languages Twelve Years La-ter. In Proceedings of the IEEE, Special Issue on Embedded Systems, volume 91,pages 64–83, January 2003.
[5] Gérard Berry. Esterel on Hardware. Philosophical Transactions of the RoyalSociety of London, 339:87–104, 1992.
[6] Gérard Berry. The Constructive Semantics of Pure Esterel. Draft Book, 1999.
[7] Gérard Berry. The Esterel v5 Language Primer, Version v5_91. Centre deMathématiques Appliquées Ecole des Mines and INRIA, 06565 Sophia-Antipolis,2000.
[8] Gérard Berry and Georges Gonthier. The Esterel Synchronous ProgrammingLanguage: Design, Semantics, Implementation. Science of Computer Program-ming, 19(2):87–152, 1992.
[9] Marian Boldt, Claus Traulsen, and Reinhard von Hanxleden. Worst case reacti-on time analysis of concurrent reactive programs. In Proceedings of the Workshopon Model-driven High-level Programming of Embedded Systems (SLA++P07),Braga, Portugal, March 2007.
[10] R.K. Brayton, G.D. Hachtel, , and A.L. Sangiovanni-Vincentelli. Logic Mini-mization Algorithms for VLSI Synthesis. The Kluwer International Series inEngineering and Computer Science, Kluwer Academic Publishers, 1984.
61
6. Literaturverzeichnis
[11] Randal E. Bryant. Graph-based algorithms for boolean function manipulation.IEEE Transactions on Computers, C-35(8):677–691, 1986.
[12] Estbench Esterel Benchmark Suite. http://www1.cs.columbia.edu/~sedwards/software/estbench-1.0.tar.gz.
[13] C.M.Edmund Chow, Joyce S.Y.Tong, M.W.Sajeewa Dayaratne, Partha S Roop,and Zoran Salcic. RePIC - A New Processor Architecture Supporting Direct Es-terel Execution. School of Engineering Report No. 612, University of Auckland,2004.
[14] M. W. Sajeewa Dayaratne, Partha S. Roop, and Zoran Salcic. Direct Execu-tion of Esterel Using Reactive Microprocessors. In Proceedings of SynchronousLanguages, Applications, and Programming (SLAP), April 2005.
[15] Stephen A. Edwards. CEC: The Columbia Esterel Compiler. http://www1.cs.columbia.edu/~sedwards/cec/.
[16] Stephen A. Edwards. Compiling Esterel into Sequential Code. In Proceedings ofthe 7th International Workshop on Hardware/Software Codesign (CODES 99),May 1999.
[17] Esterel Technologies. Esterel studio. http://www.esterel-technologies.com/products/esterel-studio/overview.html.
[18] Esterel.org. Esterel history. http://www-sop.inria.fr/esterel.org/Html/History/History.htm.
[19] Sascha Gädtke, Xin Li, Marian Boldt, and Reinhard von Hanxleden. HW/SWCo-Design for a Reactive Processor. In Proceedings of the Student Poster Sessi-on at the ACM SIGPLAN/SIGBED Conference on Languages, Compilers, andTools for Embedded Systems (LCTES’06), Ottawa, Canada, June 2006.
[20] Sascha Gädtke, Claus Traulsen, and Reinhard von Hanxleden. Hw/sw co-designfor reactive processing. Submitted.
[21] Paul Le Guernic, Thierry Goutier, Michel Le Borgne, and Claude Le Maire.Programming real time applications with SIGNAL. Proceedings of the IEEE,79(9), September 1991.
[22] Nicolas Halbwachs, Paul Caspi, Pascal Raymond, and Daniel Pilaud. The syn-chronous data-flow programming language LUSTRE. Proceedings of the IEEE,79(9):1305–1320, September 1991.
[23] Xin Li, Marian Boldt, and Reinhard von Hanxleden. Mapping Esterel ontoa multi-threaded embedded processor. In Proceedings of the 12th InternationalConference on Architectural Support for Programming Languages and OperatingSystems (ASPLOS’06), San Jose, CA, October 21–25 2006.
62
6. Literaturverzeichnis
[24] Xin Li and Reinhard von Hanxleden. A concurrent reactive Esterel proces-sor based on multi-threading. In Proceedings of the 21st ACM Symposium onApplied Computing (SAC’06), Special Track Embedded Systems: Applications,Solutions, and Techniques, Dijon, France, April 23–27 2006.
[25] Jan Lukoschus. Removing Cycles in Esterel Programs. PhD thesis, Christian-Albrechts-Universität Kiel, Department of Computer Science, July 2006. http://e-diss.uni-kiel.de/tech-fak.html.
[26] S. Minato, N. Ishiura, and S. Yajima. Shared binary decision diagram withattributed edges for efficient boolean function manipulation. Design AutomatonConference, pages 52–57, 1990.
[27] Paul Molitor and Christoph Scholl. Datenstrukturen und effiziente Algorith-men für die Logiksynthese kombinatorischer Schaltungen. Teubner, Stuttgart,Leipzig, 1999.
[28] Markus Nilsson. A tool for automatic formal analysis of fault tolerance. Master’sthesis, Linköping University, 2005.
[29] Dumitru Potop-Butucaru and Robert de Simone. Optimization for faster execu-tion of Esterel programs, pages 285–315. Kluwer Academic Publishers, Norwell,MA, USA, 2004.
[30] Jürgen Reichardt and Bernd Schwarz. VHDL-Synthese. Oldenbourg Wissen-schaftsverlag, München, 2003.
[31] Z. Salcic, P. S. Roop, M. Biglari-Abhari, and A. Bigdeli. REFLIX: A Proces-sor Core with Native Support for Control Dominated Embedded Applications.Elsevier Journal of Microprocessors and Microsystems, 28:13–25, 2004.
[32] K. Schneider and M. Wenz. A new method for compiling schizophrenic syn-chronous programs. In International Conference on Compilers, Architecture,and Synthesis for Embedded Systems (CASES), pages 49–58, Atlanta, Georgia,USA, November 2001. ACM.
[33] Olivier Tardieu and Robert de Simone. Curing schizophrenia by program rewri-ting in Esterel. In Proceedings of the Second ACM-IEEE International Confe-rence on Formal Methods and Models for Codesign, San Diego, CA, USA, 2004.
[34] University of California, Berkeley. Berkeley Logic Interchange Format, 2005.http://www.cs.uic.edu/~jlillis/courses/cs594/spring05/blif.pdf.
[35] Reinhard von Hanxleden. The Kiel Esterel Processor Homepage. http://www.informatik.uni-kiel.de/rtsys/kep/.
[36] Xilinx, Inc. Xilinx virtex-ii pro web power tool version 8.1.01. http://www.xilinx.com/cgi-bin/power_tool/power_Virtex2p.
63
6. Literaturverzeichnis
[37] Xilinx, Inc. Development System Reference Guide, 2005.
[38] Xilinx, Inc. Xilinx ISE 8 Software Manuals and Help - PDF Collection, 2005.
64
A. Kommentierter Programmcode
A.1. HW/SW Co-Synthese
A.1.1. Partitionierung des Esterel Programms
Der erste Schritt der HW/SW Co-Synthese ist die Partitionierung des gegebenen Pro-gramms auf Esterel Codebasis in ein äquivalentes Programm bestehend aus einemSoftwaremodul und mehreren Hardwaremodulen. Dabei werden aus dem Original-programm Signal- und Datenausdrücke extrahiert und durch ein Hilfssignal ersetzt.Die Hilfssignale werden in den Hardwaremodulen berechnet.
Das Programm CoDesign-partitioner erfüllt diese Aufgabe. Es erwartet zwei undeinen dritten optionalen Parameter:
1. Den Dateinamen einer AST Datei, die das bereits expandierte Esterel Pro-gramm enthält
2. Einen Dateinamen für das partitionierte Programm
3. Einen Dateinamen für das partitionierte Programm mit minimierten Hardwa-remodulen
Zusätzlich wird eine weitere Datei *_.dep geschrieben. Diese gibt für alle währendder Partitionierung erzeugten Hilfssignale an, von welchen Signalen der Ausdruck,den sie ersetzen, abhängt. Diese Datei wird vom Esterel2KASM Compiler benötigt,um während der Übersetzung des Softwaremoduls verloren gegangene Signalabhän-gigkeiten wiederherzustellen.
In den Dateien CoDesignDataStructures.{cpp,hpp} werden Datenstrukturen im-plementiert, die vom CoDesignEsterelPrinter benötigt werden. Die KlasseExtSymbolTable erweitert den AST::SymbolTable um zwei nützliche Funktionen.Die Klasse HWModuleTree erlaubt es, alle Gültigkeitsbereiche von Signalen in einerBaumstruktur zu repräsentieren. Jeder Knoten enthält u.a. einen Pointer auf diescope Anweisung und das zugehörige Hardwaremodul. Die Klasse erlaubt den direk-ten Zugriff auf den aktuellen Gültigkeitsbereich und auf den hierarchisch niedrigs-ten Gültigkeitsbereich, in dem alle Symbole einer gegebenen Menge von Symbolenbekannt sind. Letzteres erlaubt es, ein Hilfssignal für einen möglichst großen Gül-tigkeitsbereich sichtbar zu machen. Dies kann sinnvoll sein, wenn das Programmmehrere äquivalente Ausdrücke enthält.
Die Klassen CoDesignEsterelPreprocessor und CoDesignEsterelPrinter imple-mentieren die Klasse AST::Visitor und sind Modifikationen des EsterelPrinters.Mit Hilfe der Klasse CoDesignEsterelPreprocessor wird das gegebene Programm
65
A. Kommentierter Programmcode
vorverarbeitet: Die Namen aller im Programm verwendeten Symbole werden in Groß-buchstaben konvertiert und global eindeutig umbenannt. Alle verwendeten Symbolewerden in einer Liste im Hilfsobjekt CoDesignData gespeichert. Mit Hilfe der KlasseCoDesignEsterelPrinter erfolgt die eigentliche Partitionierung.
66
A.1. HW/SW Co-Synthese
A.1
.2.
CoD
esig
n-pa
rtitio
ner.cp
p
#inc
lude
"IR
.hpp"
#inc
lude
"AST
.hpp"
#inc
lude
"Este
relP
rinte
r.h
pp"
#inc
lude
"CoDesignEst
ere
lPrinte
r.h
pp"
#inc
lude
"CoDesignEst
ere
lPre
pro
cess
or.h
pp"
#inc
lude
"CoDesignData
Structu
res.h
pp"
#inc
lude
"CoDesignLogicM
inim
ization.h
pp"
#inc
lude
<ios
trea
m>#i
nclu
de<s
tdli
b.h>
10#i
nclu
de<f
stre
am>
void
usag
e()
{st
d::c
err
<<"Usa
ge:\
n";
std:
:cer
r<<
"CoDes
ign−part
itio
nin
g␣In
putF
ile(∗
.exp)\
n"
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣Outp
utF
ile(∗
_co
syn.strl
)\n"
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣[minim
ized␣Outp
utF
ile(∗
_co
syn_min
.strl
)]\
n";
} usin
gna
mesp
ace
CoDe
sign
;
20/ *
This
prog
ram
read
sth
eAS
Tof
the
orig
inal
Este
rel
prog
ram
from
XML
file
and
perf
orms
the
*pa
rtit
ioni
ngin
sw-
and
hw-m
odul
esan
dwr
ites
the
resu
ltas
Este
rel
file
.Th
ein
form
atio
non
*wh
ich
sign
als
the
intr
oduc
edau
xili
ary
sign
als
depe
ndon
iswr
itte
mto
a’ *
_sw.
dep’
file
.
*Th
isfi
leis
read
byth
eEs
tere
l2KE
PCo
mpil
erin
orde
rto
rest
ore
sign
alde
pend
enci
eslo
stdu
ring
*th
epa
rtit
ioni
ng.
*Ad
diti
onal
lyan
opti
onal
logi
cmi
nimi
zati
onst
epca
nbe
perf
orme
d.Th
ere
sult
isal
sowr
itte
n
*to
anEs
tere
lfi
le.
* *@p
aram
name
ofth
eAS
Tfi
le30
*@p
aram
name
ofth
epa
rtit
ione
dEs
tere
lpr
ogra
m
*@p
aram
name
ofth
epa
rtit
ione
dEs
tere
lpr
ogra
mwi
thmi
nimi
zed
hwmo
dule
s
*(t
his
para
mete
ris
opti
onal
)
*/ int
main
(int
argc
,ch
ar*ar
gv[]
){tr
y{
if(3
<=ar
gc<=
4){
std:
:str
ing
base
file
name
(arg
v[1]
);st
d::i
fstr
eam
infi
le(a
rgv[
1]);
40st
d::o
fstr
eam
outf
ile(
argv
[2])
;if
(!in
file
){s
td::
cerr
<<"Can
’t␣open
␣in
put␣fi
le␣"
<<ar
gv[1
]<<
"\n";
}if
(!ou
tfil
e){s
td::
cerr
<<"Can
’t␣open
␣outp
ut␣
file
␣"
<<ar
gv[2
]<<
"\n";
}IR
::XM
List
ream
r(in
file
);IR
::No
de*n
;r
>>n;
AST:
:AST
Node
*an
=dy
nami
c_ca
st<A
ST::
ASTN
ode *
>(n)
;if
(!an
)th
row
IR::
Erro
r("Root␣
node␣is
␣not␣
an␣A
ST␣node")
;
50Co
Desi
gnDa
ta*
csd
=ne
wCo
Desi
gnDa
ta()
;Co
Desi
gnEs
tere
lPre
proc
esso
rpp
(csd
);an
->we
lcom
e(pp
);
CoDe
sign
::Co
Desi
gnEs
tere
lPri
nter
p(ou
tfil
e,cs
d);
an->
welc
ome(
p);
outf
ile.
flus
h();
outf
ile.
clos
e();
base
file
name
=ba
sefi
lena
me.e
rase
(bas
efil
enam
e.si
ze()
-4,b
asef
ilen
ame.
size
());
60st
d::o
fstr
eam
depf
ile(
(bas
efil
enam
e+"_
sw.d
ep")
.c_s
tr()
);if
(!de
pfil
e){s
td::
cerr
<<"Can
’t␣open
␣outp
ut␣
file
␣"
<<ba
sefi
lena
me<<
"_sw
.dep
\n";
}de
pfil
e<<
csd-
>sig
nalD
epen
denc
ies.
str(
);de
pfil
e.fl
ush(
);de
pfil
e.cl
ose(
);
if(a
rgc
==4)
{st
d::o
fstr
eam
mino
utfi
le(a
rgv[
3]);
if(!
mino
utfi
le)
{std
::ce
rr<<
"Can
’t␣open
␣fi
le␣fo
r␣minim
ized␣outp
ut␣
"<<
argv
[3]
<<"\n";
}Lo
gicM
inim
izat
ion:
:MVS
ISmv
sis;
70ba
sefi
lena
me+=
"_co
syn";
mvsi
s.mi
nimi
ze(c
sd,b
asef
ilen
ame)
;AS
T::E
ster
elPr
inte
rp(
mino
utfi
le);
(csd
->co
nvMo
dule
s).w
elco
me(p
);mi
nout
file
.flu
sh()
;mi
nout
file
.clo
se()
;}
}el
se{
std:
:cer
r<<
"Wrong
␣number␣of␣
arg
uments
!\n\n";
usag
e();
80}
} catc
h(I
R::E
rror
&e)
{st
d::c
err
<<e.
s<<
std:
:end
l;ex
it(-
1);
} retu
rn0;
}
67
A. Kommentierter Programmcode
A.1
.3.
CoD
esig
nDat
aStr
uctu
res.hp
p
#ifn
def
_COD
ESIG
NDAT
ASTR
UCTU
RES_
HPP_
#def
ine
_COD
ESIG
NDAT
ASTR
UCTU
RES_
HPP_
#inc
lude
"AST
.hpp"
#inc
lude
<ios
trea
m>#i
nclu
de<s
stre
am>
#inc
lude
<vec
tor>
#inc
lude
<map
>
10us
ing
name
spac
eAS
T;us
ing
std:
:vec
tor;
usin
gst
d::m
ap;
usin
gst
d::s
trin
g;
name
spac
eCo
Desi
gn{
/ *Th
ecl
ass
ExtS
ymbo
lTab
leex
tend
sth
ecl
ass
AST:
:Sym
bolT
able
bytw
one
wfu
ncti
ons
*fo
rad
ding
aco
mple
teSy
mbol
Tabl
ean
dfo
rex
pand
ing
ast
ring
with
apo
stfi
xif
one
*sy
mbol
inth
eta
ble
has
the
same
name
20*/ clas
sEx
tSym
bolT
able
:pu
blic
AST:
:Sym
bolT
able
{pu
blic
:vo
idad
dSym
bols
(Sym
bolT
able
*);
stri
ngge
tUni
queS
igNa
me(s
trin
g);
}; //Th
iscl
ass
stor
esa
(HW)
Modu
lean
dth
elo
cal
Sign
al-/
Vari
able
Scop
eit
belo
ngs
tocl
ass
HWMo
dule
Tree
Node
{30
publ
ic:
HWMo
dule
Tree
Node*
pare
nt;
//Po
inte
rto
the
pare
ntel
emen
tve
ctor
<HWM
odul
eTre
eNod
e *>
chil
dren
;//
Poin
ter
toth
ech
ild
elem
ents
Scop
eSta
teme
nt*sc
opeS
tate
ment
;//
Sign
al-
orVa
riab
le-s
cope
the
modu
le//
belo
ngs
toMo
dule*
hwMo
dule
;//
HWMo
dule
corr
espo
ndin
gto
the
scop
e
Para
llel
Stat
emen
tLis
t *pr
eFun
ctio
ns;
40bo
olha
sInt
erse
ctio
n(Sy
mbol
Tabl
e *);
}; / *Th
iscl
ass
isus
edfo
rst
orin
ga
tree
ofal
llo
cal
sign
alsc
opes
used
inth
epr
ogra
m
*It
give
sea
syac
cess
toth
ecu
rren
tsc
ope
that
iscu
rren
tly
proc
esse
dby
the
part
itio
ner
*or
toth
elo
west
scop
ein
that
all
sign
als
ofan
expr
essi
onar
ede
clar
ed
*/ clas
sHW
Modu
leTr
ee{
publ
ic:
int
tree
Size
;//
numb
erof
node
sin
the
tree
50HW
Modu
leTr
eeNo
de*c
urre
ntNo
de;
//th
ela
stno
deen
tere
dor
set
byse
tCur
rent
Node
()st
d::v
ecto
r<HW
Modu
leTr
eeNo
de*>
hwMo
dule
s;//
vect
oral
lows
easi
erit
erat
ion
thro
ugh
the
tree
HWMo
dule
Tree
(){
tree
Size
=0;
curr
entN
ode
=NU
LL;
} //ad
da
chil
dto
curr
ent
node
and
make
itcu
rren
tHW
Modu
leTr
eeNo
de*ad
dChi
ld(s
td::
stri
ng,
Scop
eSta
teme
nt*)
;
60//
Get
HWMo
dule
inth
elo
west
poss
ible
scop
e-le
vel
inwh
ich
all
Symb
ols
are
decl
ared
HWMo
dule
Tree
Node
*ge
tLow
estN
ode(
Symb
olTa
ble *
);
//se
tth
ecu
rren
tsc
ope
leve
lvo
idse
tCur
rent
Node
(HWM
odul
eTre
eNod
e*n)
{cu
rren
tNod
e=n;
} //ge
tth
ecu
rren
tsc
ope
leve
lHW
Modu
leTr
eeNo
de*ge
tCur
rent
Node
(){
70re
turn
curr
entN
ode;
} //re
turn
spo
inte
rto
the
root
node
HWMo
dule
Tree
Node
*ge
tRoo
tNod
e()
{re
turn
dyna
mic_
cast
<HWM
odul
eTre
eNod
e *>(*h
wMod
ules
.beg
in()
);}
};
80/ *
This
data
stru
ctur
eis
used
for
stor
ing
glob
alda
tadu
ring
the
CoSy
nthe
sis
proc
ess
* */ clas
sCo
Desi
gnDa
ta{
publ
ic:
Modu
le*sw
Modu
le;
//po
inte
rto
the
SW-M
odul
eHW
Modu
leTr
eehw
Modu
leTr
ee;
//st
ores
seve
ral
HW-M
odul
es,
one
for
each
scop
est
d::s
trin
ghw
Modu
leNa
mePr
efix
;
Modu
les
conv
Modu
les;
//Po
inte
rto
the
conv
erte
dAS
T90
ExtS
ymbo
lTab
le*u
sedS
ymbo
ls;
//st
ores
all
symb
ols
used
inth
ees
tere
lpr
ogra
mEx
tSym
bolT
able
*use
dPre
Symb
ols;
//st
ores
all
auxi
liar
ysy
mbol
sfo
rpr
eex
pres
sion
s
std:
:str
ings
trea
msi
gnal
Depe
nden
cies
;//
stor
essi
gnal
depe
nden
cies
for
the
intr
oduc
edau
xili
ary
//si
gnal
s
CoDe
sign
Data
(){
used
Symb
ols
=ne
wEx
tSym
bolT
able
();
used
PreS
ymbo
ls=
new
ExtS
ymbo
lTab
le()
;}
100
};} #e
ndif
//_C
ODES
IGND
ATAS
TRUC
TURE
S_HP
P_
68
A.1. HW/SW Co-Synthese
A.1
.4.
CoD
esig
nDat
aStr
uctu
res.cp
p
#inc
lude"CoDesignData
Structu
res.h
pp"
name
spac
eCo
Desi
gn{
//Ad
dssy
mbol
sin
the
give
nSy
mbol
Tabl
e’s
ourc
e’to
’des
t’vo
idEx
tSym
bolT
able
::ad
dSym
bols
(Sym
bolT
able
*sou
rce)
{if
(sou
rce!
=NUL
L){
for(
unsi
gned
int
x=0;
x<so
urce
->si
ze()
;x++
){
AST:
:Sym
bol
*sym
;10
sym
=*(
sour
ce->
symb
ols.
begi
n()+
x);
if(!
this
->lo
cal_
cont
ains
(sym
->na
me))
{th
is->
ente
r(sy
m);
}}
}} //
Test
sif
’nam
e’is
uniq
uein
’st’
.In
this
case
’nam
e’is
retu
rned
,//
othe
rwis
ea
post
fix,
cons
isti
ngof
anun
ders
core
and
anu
mber
,is
appe
nded
to’n
ame’
.20
stri
ngEx
tSym
bolT
able
::ge
tUni
queS
igNa
me(s
trin
gna
me){
stri
ngpo
stfi
x="";
int
x=0;
whil
e(th
is->
loca
l_co
ntai
ns(n
ame+
post
fix)
){st
d::o
stri
ngst
ream
s;s
<<"_
"<<
x;po
stfi
x=
s.st
r();
x++;
} retu
rnna
me+p
ostf
ix;
30} / *
Retu
rns
true
if’s
t’an
dth
ese
tof
Symb
ols
inth
esc
ope
decl
arat
ion
inte
rsec
t
*/ bool
HWMo
dule
Tree
Node
::ha
sInt
erse
ctio
n(Sy
mbol
Tabl
e *st
){Sy
mbol
Tabl
e *sc
opeS
ymbo
ls=
scop
eSta
teme
nt->
symb
ols;
vect
or<S
ymbo
l *>:
:ite
rato
ri
=sc
opeS
ymbo
ls->
symb
ols.
begi
n();
for(
;i!=
scop
eSym
bols
->sy
mbol
s.en
d();
i++)
{ve
ctor
<Sym
bol *>:
:ite
rato
rj
=st
->sy
mbol
s.be
gin(
);40
for(
;j!=
st->
symb
ols.
end(
);j+
+){
if((
(Sym
bol *
)(*i
))->
name
.com
pare
(((S
ymbo
l *)(
*j))
->na
me)=
=0)
retu
rntr
ue;
}} re
turn
fals
e;}
/ *Ad
dsa
new
chil
dto
the
tree
*@p
aram
name
Pref
ixPr
efix
for
the
hw-m
odul
ena
me
*@p
aram
scop
eA
poin
ter
toth
elo
cal
sign
alde
clar
atio
n50
*@r
etur
nRe
turn
sa
poin
ter
toth
ene
wch
ild
node
*/ HWMo
dule
Tree
Node*
HWMo
dule
Tree
::ad
dChi
ld(s
td::
stri
ngna
mePr
efix
,Sc
opeS
tate
ment
*sc
ope)
{HW
Modu
leTr
eeNo
de*ne
wNod
e=
new
HWMo
dule
Tree
Node
();
std:
:ost
ring
stre
ams;
tree
Size
++;
s<<
tree
Size
;ne
wNod
e->h
wMod
ule
=ne
wMo
dule
(new
Modu
leSy
mbol
(nam
ePre
fix+"_
hw_"+
s.st
r())
);ne
wNod
e->h
wMod
ule-
>con
stan
ts=
new
Symb
olTa
ble(
);ne
wNod
e->h
wMod
ule-
>fun
ctio
ns=
new
Symb
olTa
ble(
);60
newN
ode-
>hwM
odul
e->p
roce
dure
s=
new
Symb
olTa
ble(
);ne
wNod
e->h
wMod
ule-
>tas
ks=
new
Symb
olTa
ble(
);ne
wNod
e->h
wMod
ule-
>typ
es=
new
Symb
olTa
ble(
);ne
wNod
e->h
wMod
ule-
>var
iabl
es=
new
Symb
olTa
ble(
);ne
wNod
e->h
wMod
ule-
>sig
nals
=ne
wEx
tSym
bolT
able
();
newN
ode-
>hwM
odul
e->b
ody
=ne
wPa
rall
elSt
atem
entL
ist(
);ne
wNod
e->p
reFu
ncti
ons
=ne
wPa
rall
elSt
atem
entL
ist(
);ne
wNod
e->s
cope
Stat
emen
t=
scop
e;ne
wNod
e->p
aren
t=
curr
entN
ode;
if(h
wMod
ules
.siz
e()=
=0)
{70
curr
entN
ode
=ne
wNod
e;} el
se{
curr
entN
ode-
>chi
ldre
n.pu
sh_b
ack(
newN
ode)
;cu
rren
tNod
e=
newN
ode;
} hwMo
dule
s.pu
sh_b
ack(
newN
ode)
;re
turn
newN
ode;
}
80/ *
Get
HWMo
dule
Tree
Node
inth
elo
west
poss
ible
leve
lin
whic
hal
lSy
mbol
sar
ede
clar
ed
*(T
his
isth
eNo
dein
the
lowe
stor
der
scop
e,wh
ere
the
set
ofus
edSy
mbol
s
*in
the
expr
essi
onan
dth
ese
tof
decl
ared
symb
ols
inth
esc
ope
inte
rsec
t.)
*/ HWMo
dule
Tree
Node*
HWMo
dule
Tree
::ge
tLow
estN
ode(
Symb
olTa
ble *
st){
HWMo
dule
Tree
Node
*no
de=
curr
entN
ode;
whil
e((n
ode
!=th
is->
getR
ootN
ode(
))&&
(!no
de->
hasI
nter
sect
ion(
st))
)no
de=
node
->pa
rent
;re
turn
node
;}
90}
69
A. Kommentierter Programmcode
A.1
.5.
CoD
esig
nEst
erel
Pre
proc
esso
r.hp
p
#ifn
def
CODE
SIGN
ESTE
RELP
REPR
OCES
SOR_
HPP_
#def
ine
CODE
SIGN
ESTE
RELP
REPR
OCES
SOR_
HPP_
#inc
lude
"AST
.hpp"
#inc
lude
<ios
trea
m>#i
nclu
de<s
stre
am>
#inc
lude
<vec
tor>
#inc
lude
<map
>#i
nclu
de<c
asse
rt>
10#i
nclu
de<a
lgor
ithm
>#i
nclu
de"CoDesignData
Structu
res.h
pp"
usin
gna
mesp
ace
AST;
usin
gst
d::v
ecto
r;us
ing
std:
:map
;us
ing
std:
:str
ing;
/ *Th
iscl
ass
impl
emen
tsa
vist
orfo
rth
eAS
T,th
atis
used
topr
epro
cess
the
Este
rel
prog
ram
befo
re
*th
eCo
Synt
hesi
s.Wh
ile
trav
ersi
ngth
roug
hth
eAS
Tit
does
the
foll
owin
g:20
*-
make
all
symb
olna
mes
uppe
rca
sean
dun
ique
*-
stor
eal
lfo
und
symb
ols
inth
eCo
Desi
gnDa
tada
tast
ruct
ure
*/ name
spac
eCo
Desi
gn{
clas
sCo
Desi
gnEs
tere
lPre
proc
esso
r:
publ
icAS
T::V
isit
or{
unsi
gned
int
inde
ntle
vel;
std:
:vec
tor<
int>
prec
eden
ce;
std:
:map
<str
ing,
int>
leve
l;st
d::m
ap<s
trin
g,in
t>un
aryl
evel
;30
CoDe
sign
Data
*co
synd
ata;
publ
ic:
CoDe
sign
Este
relP
repr
oces
sor(
CoDe
sign
Data
*);
virt
ual
~CoD
esig
nEst
erel
Prep
roce
ssor
(){
} usin
gVi
sito
r::v
isit
;//
Brin
gth
eVi
sito
r’s
visi
tme
thod
into
scop
e
40vo
idpr
oces
s(AS
TNod
e *n)
{as
sert
(n);
n->w
elco
me( *
this
);}
void
stat
emen
t(St
atem
ent
*);
void
expr
essi
on(E
xpre
ssio
n*)
;vo
idsi
gexp
ress
ion(
Expr
essi
on*)
;
stat
icco
nst
int
sequ
enti
alPr
eced
ence
=2;
stat
icco
nst
int
para
llel
Prec
eden
ce=
1;
bool
push
_pre
cede
nce(
int)
;vo
idpo
p_pr
eced
ence
();
50St
atus
visi
t(Mo
dule
Symb
ol&)
;
Stat
usvi
sit(
Vari
able
Symb
ol&)
;St
atus
visi
t(Bu
ilti
nCon
stan
tSym
bol&
);St
atus
visi
t(Bu
ilti
nSig
nalS
ymbo
l&);
Stat
usvi
sit(
Buil
tinT
ypeS
ymbo
l&);
Stat
usvi
sit(
Buil
tinF
unct
ionS
ymbo
l&);
Stat
usvi
sit(
Type
Rena
ming
&);
Stat
usvi
sit(
Cons
tant
Rena
ming
&);
Stat
usvi
sit(
Func
tion
Rena
ming
&);
60St
atus
visi
t(Pr
oced
ureR
enam
ing
&);
Stat
usvi
sit(
Sign
alRe
nami
ng&)
;St
atus
visi
t(Pr
edic
ated
Stat
emen
t&)
;St
atus
visi
t(Ta
skCa
ll&)
;
Stat
usvi
sit(
Modu
le&)
;St
atus
visi
t(Ex
clus
ion&
);St
atus
visi
t(Im
plic
atio
n&);
Stat
usvi
sit(
Modu
les&
);St
atus
visi
t(Sy
mbol
Tabl
e&);
70St
atus
visi
t(Ty
peSy
mbol
&);
Stat
usvi
sit(
Cons
tant
Symb
ol&)
;St
atus
visi
t(Si
gnal
Symb
ol&)
;St
atus
visi
t(Fu
ncti
onSy
mbol
&);
Stat
usvi
sit(
Proc
edur
eSym
bol&
);St
atus
visi
t(Ta
skSy
mbol
&);
Stat
usvi
sit(
Stat
emen
tLis
t&);
Stat
usvi
sit(
Para
llel
Stat
emen
tLis
t&);
80St
atus
visi
t(No
thin
g&);
Stat
usvi
sit(
Paus
e&);
Stat
usvi
sit(
Halt
&);
Stat
usvi
sit(
Emit
&);
Stat
usvi
sit(
Sust
ain&
);St
atus
visi
t(As
sign
&);
Stat
usvi
sit(
Star
tCou
nter
&);
Stat
usvi
sit(
Proc
edur
eCal
l&);
Stat
usvi
sit(
Exec
&);
90St
atus
visi
t(Pr
esen
t&);
Stat
usvi
sit(
If&)
;St
atus
visi
t(Lo
op&)
;St
atus
visi
t(Re
peat
&);
Stat
usvi
sit(
Abor
t&);
Stat
usvi
sit(
Awai
t&);
Stat
usvi
sit(
Loop
Each
&);
Stat
usvi
sit(
Ever
y&);
Stat
usvi
sit(
Susp
end&
);St
atus
visi
t(Do
Watc
hing
&);
100
Stat
usvi
sit(
DoUp
to&)
;St
atus
visi
t(Tr
ap&)
;St
atus
visi
t(Ex
it&)
;St
atus
visi
t(Va
r&);
70
A.1. HW/SW Co-Synthese
Stat
usvi
sit(
Sign
al&)
;St
atus
visi
t(Ru
n&);
Stat
usvi
sit(
Unar
yOp&
);St
atus
visi
t(Bi
nary
Op&)
;St
atus
visi
t(Lo
adVa
riab
leEx
pres
sion
&);
110
Stat
usvi
sit(
Load
Sign
alEx
pres
sion
&);
Stat
usvi
sit(
Load
Sign
alVa
lueE
xpre
ssio
n&);
Stat
usvi
sit(
Lite
ral&
);St
atus
visi
t(Fu
ncti
onCa
ll&)
;St
atus
visi
t(De
lay&
);
Stat
usvi
sit(
Chec
kCou
nter
&);
Stat
usvi
sit(
IfTh
enEl
se&)
;
void
inde
nt()
{in
dent
leve
l+=
2;}
120
void
unin
dent
(){
inde
ntle
vel
-=2;
}};
} #end
if/ *
CODE
SIGN
ESTE
RELP
REPR
OCES
SOR_
HPP_
*/
71
A. Kommentierter Programmcode
A.1
.6.
CoD
esig
nEst
erel
Pre
proc
esso
r.cp
p
#inc
lude
"CoDesignEst
ere
lPre
pro
cess
or.h
pp"
#inc
lude
<cas
sert
>
name
spac
eCo
Desi
gn{
CoDe
sign
Este
relP
repr
oces
sor:
:CoD
esig
nEst
erel
Prep
roce
ssor
(CoD
esig
nDat
a *cs
d):
inde
ntle
vel(
0),
cosy
ndat
a(cs
d){
prec
eden
ce.p
ush_
back
(0);
10le
vel["or"
]=
1;le
vel["an
d"]
=2;
unar
ylev
el["not"
]=
3;un
aryl
evel
["pre
"]=
3;
leve
l["=
"]=
4;le
vel["<
>"]
=4;
leve
l["<
"]=
4;le
vel[">
"]=
4;le
vel["<
="]
=4;
20le
vel[">
="]
=4;
leve
l["+
"]=
5;le
vel["−
"]=
6;
leve
l["∗"]
=7;
leve
l["/"]
=8;
leve
l["m
od"]
=8;
unar
ylev
el["−
"]=
9;30
} void
CoDe
sign
Este
relP
repr
oces
sor:
:sta
teme
nt(S
tate
ment
*s)
{as
sert
(s);
s->w
elco
me( *
this
);} vo
idCo
Desi
gnEs
tere
lPre
proc
esso
r::e
xpre
ssio
n(Ex
pres
sion
*e)
{pr
eced
ence
.pus
h_ba
ck(0
);pr
oces
s(e)
;40
prec
eden
ce.p
op_b
ack(
);} vo
idCo
Desi
gnEs
tere
lPre
proc
esso
r::s
igex
pres
sion
(Exp
ress
ion
*e)
{pr
eced
ence
.pus
h_ba
ck(0
);pr
oces
s(e)
;pr
eced
ence
.pop
_bac
k();
} bool
CoDe
sign
Este
relP
repr
oces
sor:
:pus
h_pr
eced
ence
(int
p){
50bo
olne
edBr
acke
ts=
(p<
prec
eden
ce.b
ack(
))||
((p
==pr
eced
ence
.bac
k())
&&((
p==l
evel
["−
"])
||(p
==le
vel["/"]
)));
prec
eden
ce.p
ush_
back
(p);
retu
rnne
edBr
acke
ts;
} void
CoDe
sign
Este
relP
repr
oces
sor:
:pop
_pre
cede
nce(
){
prec
eden
ce.p
op_b
ack(
);} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(M
odul
eSym
bol
&){
asse
rt(0
);}
60St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(V
aria
bleS
ymbo
l&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(T
ypeR
enam
ing
&){
asse
rt(0
);}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Con
stan
tRen
amin
g&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(F
unct
ionR
enam
ing
&){
asse
rt(0
);}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Pro
cedu
reRe
nami
ng&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(S
igna
lRen
amin
g&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(P
redi
cate
dSta
teme
nt&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(T
askC
all
&){
asse
rt(0
);}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Bui
ltin
Cons
tant
Symb
ol&)
{re
turn
Stat
us()
;}
70St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(B
uilt
inSi
gnal
Symb
ol&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Bui
ltin
Type
Symb
ol&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Bui
ltin
Func
tion
Symb
ol&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Mod
ule
&m)
{as
sert
(m.s
ymbo
l);
//ac
kqui
real
lus
edgl
obal
symb
ols
in’u
sedS
ymbo
ls’
ExtS
ymbo
lTab
leus
edSy
mbol
s;co
synd
ata-
>use
dSym
bols
->ad
dSym
bols
(m.t
ypes
);us
edSy
mbol
s.ad
dSym
bols
(m.c
onst
ants
);80
cosy
ndat
a->u
sedS
ymbo
ls->
addS
ymbo
ls(m
.fun
ctio
ns);
cosy
ndat
a->u
sedS
ymbo
ls->
addS
ymbo
ls(m
.pro
cedu
res)
;co
synd
ata-
>use
dSym
bols
->ad
dSym
bols
(m.t
asks
);us
edSy
mbol
s.ad
dSym
bols
(m.s
igna
ls);
used
Symb
ols.
addS
ymbo
ls(m
.var
iabl
es);
//ma
kesy
mbol
name
sup
per
case
and
uniq
uean
dwr
ite
them
//to
cosy
ndat
a->u
sedS
ymbo
lsfo
r(un
sign
edin
tx=
0;x<
used
Symb
ols.
size
();x
++)
{AS
T::S
ymbo
l*sym
;st
d::s
trin
gsy
mNam
e;90
sym
=*(
used
Symb
ols.
symb
ols.
begi
n()+
x);
symN
ame
=sy
m->n
ame;
std:
:cer
r<<
symN
ame
<<"\n";
tran
sfor
m(s
ymNa
me.b
egin
(),
symN
ame.
end(
),//
sour
cesy
mNam
e.be
gin(
),//
dest
inat
ion
toup
per)
;//
oper
atio
nsy
mNam
e=
cosy
ndat
a->u
sedS
ymbo
ls->
getU
niqu
eSig
Name
(sym
Name
);if
(!((
sym-
>nam
e==
"tick")
||(s
ym->
name
=="true")
||(s
ym->
name
=="fa
lse")
))sy
m->
name
=sy
mNam
e;co
synd
ata-
>use
dSym
bols
->en
ter(
sym)
;}
100
proc
ess(
m.bo
dy);
retu
rnSt
atus
();
}
72
A.1. HW/SW Co-Synthese
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Mod
ules
&m)
{ve
ctor
<Mod
ule *
>::i
tera
tor
i=
m.mo
dule
s.be
gin(
);wh
ile
(i
!=m.
modu
les.
end(
))
{as
sert
( *i)
;as
sert
((*i
)->s
ymbo
l);
proc
ess(*i
);11
0i+
+;} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(E
xclu
sion
&e)
{re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(I
mpli
cati
on&
e){
120
asse
rt(e
.pre
dica
te);
asse
rt(e
.imp
lica
tion
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(S
ymbo
lTab
le&t
){
for
(Sy
mbol
Tabl
e::c
onst
_ite
rato
ri
=t.
begi
n()
;i
!=t.
end(
);
i++
){
proc
ess(*i
);} re
turn
Stat
us()
;13
0} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(T
ypeS
ymbo
l&s
){
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Con
stan
tSym
bol
&s)
{re
turn
Stat
us()
;}
140
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Sig
nalS
ymbo
l&s
){
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Fun
ctio
nSym
bol
&s)
{re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(P
roce
dure
Symb
ol&s
){
retu
rnSt
atus
();
150
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Tas
kSym
bol
&s)
{re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(S
tate
ment
List
&l)
{pu
sh_p
rece
denc
e(se
quen
tial
Prec
eden
ce);
vect
or<S
tate
ment
*>::
cons
t_it
erat
ori
=l.
stat
emen
ts.b
egin
();
whil
e(
i!=
l.st
atem
ents
.end
())
{16
0pr
oces
s(*i);
i++;
} pop_
prec
eden
ce()
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(P
aral
lelS
tate
ment
List
&l)
{bo
olne
edBr
acke
ts=
push
_pre
cede
nce(
para
llel
Prec
eden
ce);
170
vect
or<S
tate
ment
*>::
cons
t_it
erat
ori
=l.
thre
ads.
begi
n();
whil
e(
i!=
l.th
read
s.en
d()
){
proc
ess(
*i);
i++;
} pop_
prec
eden
ce()
;re
turn
Stat
us()
;}
180
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Not
hing
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(P
ause
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(H
alt
&){
retu
rnSt
atus
();
}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Emi
t&e
){
asse
rt(e
.sig
nal)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(S
tart
Coun
ter
&s)
{19
0as
sert
(s.c
ount
er);
expr
essi
on(s
.cou
nt);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Sus
tain
&e)
{as
sert
(e.s
igna
l);
retu
rnSt
atus
();
}
200
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Ass
ign
&a)
{as
sert
(a.v
aria
ble)
;as
sert
(a.v
alue
);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Pro
cedu
reCa
ll&c
){
asse
rt(c
.pro
cedu
re);
210
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Exe
c&e
){
73
A. Kommentierter Programmcode
for
(ve
ctor
<Tas
kCal
l *>:
:con
st_i
tera
tor
i=
e.ca
lls.
begi
n()
;i
!=e.
call
s.en
d()
;i+
+){
asse
rt( *
i);
asse
rt((
*i)-
>pro
cedu
re);
asse
rt((
*i)-
>sig
nal)
;22
0if
((*i
)->b
ody)
{pr
oces
s(( *
i)->
body
);}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Pre
sent
&p)
{if
(p.c
ases
.siz
e()
==1)
{//
Simp
leif
-the
n-el
se23
0Pr
edic
ated
Stat
emen
t*p
s=
p.ca
ses[
0];
asse
rt(p
s);
sige
xpre
ssio
n(ps
->pr
edic
ate)
;if
(ps-
>bod
y){
stat
emen
t(ps
->bo
dy);
}}
else
{//
Mult
iple
case
sfo
r(v
ecto
r<Pr
edic
ated
Stat
emen
t *>:
:con
st_i
tera
tor
i=
p.ca
ses.
begi
n()
;i
!=p.
case
s.en
d()
;i+
+){
240
asse
rt( *
i);
asse
rt((
*i)-
>pre
dica
te);
sige
xpre
ssio
n(( *
i)->
pred
icat
e);
if((
*i)-
>bod
y){
proc
ess(
( *i)
->bo
dy);
}}
} if(p
.def
ault
_stm
t){
stat
emen
t(p.
defa
ult_
stmt
);25
0} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(I
f&s
){
vect
or<P
redi
cate
dSta
teme
nt*>::
cons
t_it
erat
ori
=s.
case
s.be
gin(
);as
sert
(i!=
s.ca
ses.
end(
));
expr
essi
on((
*i)-
>pre
dica
te);
if((
*i)-
>bod
y){
stat
emen
t(( *
i)->
body
);26
0} fo
r(
i++
;i
!=s.
case
s.en
d()
;i+
+)
{as
sert
( *i)
;ex
pres
sion
((*i
)->p
redi
cate
);st
atem
ent(
( *i)
->bo
dy);
} if(s
.def
ault
_stm
t){
stat
emen
t(s.
defa
ult_
stmt
);} re
turn
Stat
us()
;27
0}
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Loo
p&l
){
stat
emen
t(l.
body
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(R
epea
t&r
){
expr
essi
on(r
.cou
nt);
stat
emen
t(r.
body
);28
0re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(A
bort
&a)
{st
atem
ent(
a.bo
dy);
if(a
.cas
es.s
ize(
)==
1){
//Si
mple
abor
tco
ndit
ion
Pred
icat
edSt
atem
ent
*ps
=a.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e);
290
if(p
s->b
ody)
{st
atem
ent(
ps->
body
);}
}el
se{
//Ab
ort
case
s
for
(ve
ctor
<Pre
dica
tedS
tate
ment
*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
asse
rt( *
i);
sige
xpre
ssio
n(( *i)
->pr
edic
ate)
;30
0if
((*i)-
>bod
y){
proc
ess(
( *i)
->bo
dy);
}}
} retu
rnSt
atus
();
}31
0St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(A
wait
&a)
{if
(a.c
ases
.siz
e()
==1)
{//
Simp
leab
ort
cond
itio
nPr
edic
ated
Stat
emen
t*ps
=a.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e);
if(p
s->b
ody)
{st
atem
ent(
ps->
body
);}
320
}el
se{
for
(ve
ctor
<Pre
dica
tedS
tate
ment
*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
asse
rt( *
i);
sige
xpre
ssio
n(( *i)
->pr
edic
ate)
;if
((*i)-
>bod
y){
74
A.1. HW/SW Co-Synthese
proc
ess(
( *i)
->bo
dy);
330
}}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Loo
pEac
h&l
){
stat
emen
t(l.
body
);si
gexp
ress
ion(
l.pr
edic
ate)
;34
0re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(E
very
&e)
{si
gexp
ress
ion(
e.pr
edic
ate)
;st
atem
ent(
e.bo
dy);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Sus
pend
&s)
{35
0st
atem
ent(
s.bo
dy);
sige
xpre
ssio
n(s.
pred
icat
e);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(DoW
atch
ing
&d)
{st
atem
ent(
d.bo
dy);
sige
xpre
ssio
n(d.
pred
icat
e);
if(d
.tim
eout
){
stat
emen
t(d.
time
out)
;36
0} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(D
oUpt
o&d
){
stat
emen
t(d.
body
);si
gexp
ress
ion(
d.pr
edic
ate)
;re
turn
Stat
us()
;}
370
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Tra
p&t
){
asse
rt(t
.sym
bols
);//
make
symb
olna
mes
uppe
rca
sean
dun
ique
and
writ
eth
em//
toco
synd
ata-
>use
dSym
bols
for(
unsi
gned
int
x=0;
x<t.
symb
ols-
>siz
e();
x++)
{AS
T::S
ymbo
l*sym
;st
d::s
trin
gsy
mNam
e;sy
m=*(
t.sy
mbol
s->s
ymbo
ls.b
egin
()+x
);sy
mNam
e=
sym-
>nam
e;tr
ansf
orm
(sym
Name
.beg
in()
,sy
mNam
e.en
d(),
//so
urce
380
symN
ame.
begi
n(),
//de
stin
atio
nto
uppe
r);
//op
erat
ion
symN
ame
=co
synd
ata-
>use
dSym
bols
->ge
tUni
queS
igNa
me(s
ymNa
me);
sym-
>nam
e=
symN
ame;
cosy
ndat
a->u
sedS
ymbo
ls->
ente
r(sy
m);
} stat
emen
t(t.
body
);fo
r(v
ecto
r<Pr
edic
ated
Stat
emen
t *>:
:con
st_i
tera
tor
i=
t.ha
ndle
rs.b
egin
();
i!=
t.ha
ndle
rs.e
nd()
;i+
+)
{39
0as
sert
( *i)
;ex
pres
sion
((*i
)->p
redi
cate
);st
atem
ent(
( *i)
->bo
dy);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Exi
t&e
){
asse
rt(e
.tra
p);
400
asse
rt(e
.tra
p->k
ind
==Si
gnal
Symb
ol::
Trap
);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Var
&v)
{//
make
symb
olna
mes
uppe
rca
sean
dun
ique
and
writ
eth
em//
toco
synd
ata-
>use
dSym
bols
for(
unsi
gned
int
x=0;
x<v.
symb
ols-
>siz
e();
x++)
{AS
T::S
ymbo
l*s
ym;
410
std:
:str
ing
symN
ame;
sym
=*(v.
symb
ols-
>sym
bols
.beg
in()
+x);
symN
ame
=sy
m->n
ame;
tran
sfor
m(s
ymNa
me.b
egin
(),
symN
ame.
end(
),//
sour
cesy
mNam
e.be
gin(
),//
dest
inat
ion
toup
per)
;//
oper
atio
nsy
mNam
e=
cosy
ndat
a->u
sedS
ymbo
ls->
getU
niqu
eSig
Name
(sym
Name
);sy
m->n
ame
=sy
mNam
e;co
synd
ata-
>use
dSym
bols
->en
ter(
sym)
;}
420
stat
emen
t(v.
body
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(S
igna
l&s
){
//ma
kesy
mbol
name
sup
per
case
and
uniq
uean
dwr
ite
them
//to
cosy
ndat
a->u
sedS
ymbo
lsfo
r(un
sign
edin
tx=
0;x<
s.sy
mbol
s->s
ize(
);x+
+){
AST:
:Sym
bol
*sym
;43
0st
d::s
trin
gsy
mNam
e;sy
m=
*(s.
symb
ols-
>sym
bols
.beg
in()
+x);
symN
ame
=sy
m->n
ame;
tran
sfor
m(s
ymNa
me.b
egin
(),
symN
ame.
end(
),//
sour
cesy
mNam
e.be
gin(
),//
dest
inat
ion
toup
per)
;//
oper
atio
nsy
mNam
e=
cosy
ndat
a->u
sedS
ymbo
ls->
getU
niqu
eSig
Name
(sym
Name
);sy
m->n
ame
=sy
mNam
e;co
synd
ata-
>use
dSym
bols
->en
ter(
sym)
;
75
A. Kommentierter Programmcode
}44
0st
atem
ent(
s.bo
dy);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Run
&r)
{/ *
The
run
stat
emen
tsh
ould
not
appe
arin
the
prog
ram
anym
ore
beca
use
*it
isbe
eing
expa
nded
befo
repr
epro
cess
ing.
*/re
turn
Stat
us()
;45
0} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(U
nary
Op&u
){
asse
rt(u
nary
leve
l.fi
nd(u
.op)
!=un
aryl
evel
.end
());
proc
ess(
u.so
urce
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(B
inar
yOp
&b)
{as
sert
(lev
el.f
ind(
b.op
)!=
leve
l.en
d())
;46
0pr
oces
s(b.
sour
ce1)
;pr
oces
s(b.
sour
ce2)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(L
oadV
aria
bleE
xpre
ssio
n&e
){
asse
rt(e
.var
iabl
e);
retu
rnSt
atus
();
}
470
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Loa
dSig
nalE
xpre
ssio
n&e
){
asse
rt(e
.sig
nal)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(L
oadS
igna
lVal
ueEx
pres
sion
&e)
{as
sert
(e.s
igna
l);
retu
rnSt
atus
();
}
480
Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Lit
eral
&l)
{as
sert
(l.t
ype)
;
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Fun
ctio
nCal
l&e
){
asse
rt(e
.cal
lee)
;ve
ctor
<Exp
ress
ion *
>::c
onst
_ite
rato
ri
=e.
argu
ment
s.be
gin(
);wh
ile
(i!=
e.ar
gume
nts.
end(
)){
expr
essi
on( *
i);
490
i++;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPre
proc
esso
r::v
isit
(Del
ay&e
){
if(e
.is_
imme
diat
e){
asse
rt(e
.cou
nt==
NULL
);}
else
{ex
pres
sion
(e.c
ount
);50
0} si
gexp
ress
ion(
e.pr
edic
ate)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(C
heck
Coun
ter
&e)
{as
sert
(e.c
ount
er);
expr
essi
on(e
.pre
dica
te);
retu
rnSt
atus
();
}51
0St
atus
CoDe
sign
Este
relP
repr
oces
sor:
:vis
it(I
fThe
nEls
e&s
){
expr
essi
on(s
.pre
dica
te);
if(s
.the
n_pa
rt)
{st
atem
ent(
s.th
en_p
art)
;} if
(s.e
lse_
part
){
stat
emen
t(s.
else
_par
t);
} retu
rnSt
atus
();
520
}
}
76
A.1. HW/SW Co-Synthese
A.1
.7.
CoD
esig
nEst
erel
er.h
pp
//#l
ine
27"Este
relP
rinte
r.nw"
#ifn
def
_COD
ESIG
N_ES
TERE
L_PR
INTE
R_HP
P#d
efin
e_C
ODES
IGN_
ESTE
REL_
PRIN
TER_
HPP
#inc
lude
"AST
.hpp"
#inc
lude
<ios
trea
m>#i
nclu
de<v
ecto
r>#i
nclu
de<m
ap>
#inc
lude
<sst
ream
>10
#inc
lude
"CoDesignEst
ere
lPre
pro
cess
or.h
pp"
#inc
lude
"CoDesignData
Structu
res.h
pp"
#inc
lude
<alg
orit
hm>
usin
gna
mesp
ace
AST;
name
spac
eCo
Desi
gn{
clas
sCo
Desi
gnEs
tere
lPri
nter
:pu
blic
Visi
tor
{st
d::o
stre
am&o
;un
sign
edin
tin
dent
leve
l;20
std:
:vec
tor<
int>
prec
eden
ce;
std:
:map
<str
ing,
int>
leve
l;st
d::m
ap<s
trin
g,in
t>un
aryl
evel
;
CoDe
sign
Data
*co
synd
ata;
//St
atem
ent *
*cu
rren
tNod
e;//
Poin
ter
toth
ecu
rren
tst
atem
ent
inth
eAS
Tpu
blic
:/ * *
@par
amos
trea
mOu
tput
stre
amfo
rpr
etty
prin
ting
the
conv
erte
dpr
ogra
m30
*@p
aram
CoDe
sign
Data
*/ CoDe
sign
Este
relP
rint
er(s
td::
ostr
eam
&,Co
Desi
gnDa
ta*)
;vi
rtua
l~C
oDes
ignE
ster
elPr
inte
r()
{}
usin
gVi
sito
r::v
isit
;//
Brin
gth
eVi
sito
r’s
visi
tme
thod
into
scop
e
//Me
mber
func
tion
sar
eco
mmen
ted
inth
e.c
ppfi
levo
idpr
oces
s(AS
TNod
e *n)
{as
sert
(n);
n->w
elco
me( *
this
);}
void
stat
emen
t(St
atem
ent
*);
40vo
idge
tUse
dSym
bols
(AST
::Ex
pres
sion
*,Sy
mbol
Tabl
e&);
Expr
essi
on*
getD
elay
Exp(
Expr
essi
on*)
;St
atem
entL
ist *
deco
mpos
eExp
ress
ion(
Expr
essi
on*,Ex
pres
sion
**);
void
expr
essi
on(E
xpre
ssio
n*,Ex
pres
sion
**);
void
sige
xpre
ssio
n(Ex
pres
sion
*,Ex
pres
sion
**);
stri
ngge
tCom
poun
dSig
Name
(Exp
ress
ion
*);
stri
ngge
tUni
queS
igNa
me(s
trin
g,Sy
mbol
Tabl
e *);
Expr
essi
on*
appl
yPre
(Exp
ress
ion *
,boo
l);
void
subs
tPre
(Exp
ress
ion *
,Ex
pres
sion
**);
50st
atic
cons
tin
tse
quen
tial
Prec
eden
ce=
2;st
atic
cons
tin
tpa
rall
elPr
eced
ence
=1;
bool
push
_pre
cede
nce(
int)
;vo
idpo
p_pr
eced
ence
();
Stat
usvi
sit(
Modu
leSy
mbol
&);
Stat
usvi
sit(
Vari
able
Symb
ol&)
;St
atus
visi
t(Bu
ilti
nCon
stan
tSym
bol&
);60
Stat
usvi
sit(
Buil
tinS
igna
lSym
bol&
);St
atus
visi
t(Bu
ilti
nTyp
eSym
bol&
);St
atus
visi
t(Bu
ilti
nFun
ctio
nSym
bol&
);St
atus
visi
t(Ty
peRe
nami
ng&)
;St
atus
visi
t(Co
nsta
ntRe
nami
ng&)
;St
atus
visi
t(Fu
ncti
onRe
nami
ng&)
;St
atus
visi
t(Pr
oced
ureR
enam
ing
&);
Stat
usvi
sit(
Sign
alRe
nami
ng&)
;St
atus
visi
t(Pr
edic
ated
Stat
emen
t&)
;St
atus
visi
t(Ta
skCa
ll&)
;70
Stat
usvi
sit(
Modu
le&)
;St
atus
visi
t(Ex
clus
ion&
);St
atus
visi
t(Im
plic
atio
n&);
Stat
usvi
sit(
Modu
les&
);St
atus
visi
t(Sy
mbol
Tabl
e&);
Stat
usvi
sit(
Type
Symb
ol&)
;St
atus
visi
t(Co
nsta
ntSy
mbol
&);
Stat
usvi
sit(
Sign
alSy
mbol
&);
80St
atus
visi
t(Fu
ncti
onSy
mbol
&);
Stat
usvi
sit(
Proc
edur
eSym
bol&
);St
atus
visi
t(Ta
skSy
mbol
&);
Stat
usvi
sit(
Stat
emen
tLis
t&);
Stat
usvi
sit(
Para
llel
Stat
emen
tLis
t&);
Stat
usvi
sit(
Noth
ing&
);St
atus
visi
t(Pa
use&
);St
atus
visi
t(Ha
lt&)
;90
Stat
usvi
sit(
Emit
&);
Stat
usvi
sit(
Sust
ain&
);St
atus
visi
t(As
sign
&);
Stat
usvi
sit(
Star
tCou
nter
&);
Stat
usvi
sit(
Proc
edur
eCal
l&);
Stat
usvi
sit(
Exec
&);
Stat
usvi
sit(
Pres
ent&
);St
atus
visi
t(If
&);
Stat
usvi
sit(
Loop
&);
Stat
usvi
sit(
Repe
at&)
;10
0St
atus
visi
t(Ab
ort&
);St
atus
visi
t(Aw
ait&
);St
atus
visi
t(Lo
opEa
ch&)
;St
atus
visi
t(Ev
ery&
);St
atus
visi
t(Su
spen
d&);
77
A. Kommentierter Programmcode
Stat
usvi
sit(
DoWa
tchi
ng&)
;St
atus
visi
t(Do
Upto
&);
Stat
usvi
sit(
Trap
&);
Stat
usvi
sit(
Exit
&);
Stat
usvi
sit(
Var&
);11
0St
atus
visi
t(Si
gnal
&);
Stat
usvi
sit(
Run&
);
Stat
usvi
sit(
Unar
yOp&
);St
atus
visi
t(Bi
nary
Op&)
;St
atus
visi
t(Lo
adVa
riab
leEx
pres
sion
&);
Stat
usvi
sit(
Load
Sign
alEx
pres
sion
&);
Stat
usvi
sit(
Load
Sign
alVa
lueE
xpre
ssio
n&);
Stat
usvi
sit(
Lite
ral&
);
Stat
usvi
sit(
Func
tion
Call
&);
120
Stat
usvi
sit(
Dela
y&);
Stat
usvi
sit(
Chec
kCou
nter
&);
Stat
usvi
sit(
IfTh
enEl
se&)
;
void
inde
nt()
{in
dent
leve
l+=
2;}
void
unin
dent
(){
inde
ntle
vel
-=2;
}vo
idta
b()
{fo
r(u
nsig
ned
int
i=
0;
i<
inde
ntle
vel
;i+
+)o
<<’
’;}
};}
130
#end
if
78
A.1. HW/SW Co-Synthese
A.1
.8.
CoD
esig
nEst
erel
er.c
pp
#inc
lude
"CoDesignEst
ere
lPrinte
r.h
pp"
#inc
lude
"Este
relP
rinte
r.h
pp"
#inc
lude
<cas
sert
>
name
spac
eCo
Desi
gn{
CoDe
sign
Este
relP
rint
er::
CoDe
sign
Este
relP
rint
er(s
td::
ostr
eam
&oo,
CoDe
sign
Data
*cs
d):
o(oo
),in
dent
leve
l(0)
,co
synd
ata(
csd)
{pr
eced
ence
.pus
h_ba
ck(0
);10
cosy
ndat
a->c
onvM
odul
es=M
odul
es()
;
leve
l["or"
]=
1;le
vel["an
d"]
=2;
unar
ylev
el["not"
]=
3;un
aryl
evel
["pre
"]=
3;le
vel["=
"]=
4;le
vel["<
>"]
=4;
leve
l["<
"]=
4;le
vel[">
"]=
4;20
leve
l["<
="]
=4;
leve
l[">
="]
=4;
leve
l["+
"]=
5;le
vel["−
"]=
6;
leve
l["∗"]
=7;
leve
l["/"]
=8;
leve
l["m
od"]
=8;
30un
aryl
evel
["−
"]=
9;} vo
idCo
Desi
gnEs
tere
lPri
nter
::st
atem
ent(
Stat
emen
t*s
){
asse
rt(s
);s-
>wel
come
( *th
is);
} / *Ge
tsal
lus
edSi
gnal
Symb
ols
inEx
pres
sion
’e’
and
stor
esth
emin
’use
dSym
bols
’
*by
recu
rsin
gov
erth
eEx
pres
sion
’e’
40*/ void
CoDe
sign
Este
relP
rint
er::
getU
sedS
ymbo
ls(A
ST::
Expr
essi
on*e,
Symb
olTa
ble
&use
dSym
bols
){if
(dyn
amic
_cas
t<AS
T::L
oadS
igna
lExp
ress
ion *
>(e)
){
AST:
:Sig
nalS
ymbo
l *Si
g=
dyna
mic_
cast
<AST
::Lo
adSi
gnal
Expr
essi
on*>
(e)-
>sig
nal;
if(!
used
Symb
ols.
loca
l_co
ntai
ns(S
ig->
name
)){
used
Symb
ols.
ente
r(Si
g);
}} if
(dyn
amic
_cas
t<AS
T::L
oadS
igna
lVal
ueEx
pres
sion
*>(e
)){
AST:
:Sig
nalS
ymbo
l *Si
g=
dyna
mic_
cast
<AST
::Lo
adSi
gnal
Valu
eExp
ress
ion *
>(e)
->si
gnal
;50
if(!
used
Symb
ols.
loca
l_co
ntai
ns(S
ig->
name
)){
used
Symb
ols.
ente
r(Si
g);
}} if
(dyn
amic
_cas
t<AS
T::L
oadV
aria
bleE
xpre
ssio
n *>(
e))
{AS
T::V
aria
bleS
ymbo
l *Va
r=
dyna
mic_
cast
<AST
::Lo
adVa
riab
leEx
pres
sion
*>(e
)->v
aria
ble;
if(!
used
Symb
ols.
loca
l_co
ntai
ns(V
ar->
name
)){
used
Symb
ols.
ente
r(Va
r);
}}
60if
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
){
getU
sedS
ymbo
ls(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e)->
sour
ce1,
used
Symb
ols)
;ge
tUse
dSym
bols
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
2,us
edSy
mbol
s);
} if(d
ynam
ic_c
ast<
AST:
:Una
ryOp
*>(e
)){
getU
sedS
ymbo
ls(d
ynam
ic_c
ast<
AST:
:Una
ryOp
*>(e
)->s
ourc
e,us
edSy
mbol
s);
}} / *
retu
rns
adi
sjun
ctio
nte
rmof
all
Sign
alSy
mbol
sin
’e’
70*/ Expr
essi
on*Co
Desi
gnEs
tere
lPri
nter
::ge
tDel
ayEx
p(Ex
pres
sion
*e){
Expr
essi
on*de
lay=
new
Load
Sign
alEx
pres
sion
(NUL
L,ne
wSi
gnal
Symb
ol("tick",
NULL
,AST
::Si
gnal
Symb
ol::
Inpu
t,NU
LL,
NULL
));
Symb
olTa
ble
sign
alTa
ble;
getU
sedS
ymbo
ls(e
,sig
nalT
able
);fo
r(un
sign
edin
ti
=0;
i<
sign
alTa
ble.
size
();
i++)
{if
(i==
0)de
lay
=ne
wLo
adSi
gnal
Expr
essi
on(N
ULL,
(Sig
nalS
ymbo
l *)s
igna
lTab
le.s
ymbo
ls[i
]);
else
dela
y=
new
Bina
ryOp
(NUL
L,80
"or"
,de
lay,
new
Load
Sign
alEx
pres
sion
(NUL
L,(S
igna
lSym
bol *
)sig
nalT
able
.sy
mbol
s[i]
));
} retu
rnde
lay;
} / *De
comp
oses
the
give
nex
pres
sion
ein
tobo
olea
nan
dno
nbo
olea
npa
rts:
*Bo
olea
nva
riab
les,
func
tion
call
swi
thbo
olea
nre
turn
valu
esan
dsu
bexp
ress
ions
that
map
from
90*(n
on-b
oole
an,n
on-b
oole
an)
tobo
olea
nar
ere
plac
edby
bool
ean
auxi
liar
ysi
gnal
s.A
list
ofem
it
*st
atem
ents
that
emit
thes
eau
xili
ary
sign
als
with
the
acco
rdin
gva
lue
isre
turn
ed
* *Th
isis
achi
eved
byre
curs
ivel
ywa
lkin
gth
roug
hth
eex
pres
sion
* *@p
aram
ePo
inte
rto
the
expr
essi
onto
bede
comp
osed
;th
eex
pres
sion
must
eval
uate
tobo
olea
n!
*@p
aram
peDo
uble
Poin
ter
used
tomo
dify
the
expr
essi
on
*@r
etur
nA
list
ofem
itst
atem
ents
*/
79
A. Kommentierter Programmcode
Stat
emen
tLis
t *Co
Desi
gnEs
tere
lPri
nter
::de
comp
oseE
xpre
ssio
n(Ex
pres
sion
*e,E
xpre
ssio
n**pe
){
100
Stat
emen
tLis
t *sl
=ne
wSt
atem
entL
ist(
);//
stor
esas
sign
ment
sof
auxi
liar
ysi
gnal
s//
ifth
ero
otno
deis
abi
nary
oper
ator
if(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e))
{//
ifth
ebi
nary
oper
ator
isa
bool
ean
oper
ator
{and
,or
}if
(lev
el[d
ynam
ic_c
ast<
Bina
ryOp
*>(e
)->o
p]<
leve
l["=
"]){
//ap
ply
this
func
tion
recu
rsiv
ely
toth
etw
oop
eran
ds..
Stat
emen
tLis
t *sl
1;St
atem
entL
ist *
sl2;
sl1
=de
comp
oseE
xpre
ssio
n(dy
nami
c_ca
st<A
ST::
Bina
ryOp
*>(e
)->s
ourc
e1,
&dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
1);
110
sl2
=de
comp
oseE
xpre
ssio
n(dy
nami
c_ca
st<A
ST::
Bina
ryOp
*>(e
)->s
ourc
e2,
&dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
2);
//..
and
stor
eth
efo
und
auxi
liar
ysi
gnal
assi
gnme
nts
if(s
l1->
stat
emen
ts.s
ize(
)>0)
{
*sl
<<sl
1;} if
(sl2
->st
atem
ents
.siz
e()>
0){
*sl
<<sl
2;}
}12
0//
ifth
ebi
nary
oper
ator
isco
mpar
isio
nop
erat
orel
se{
if(l
evel
[dyn
amic
_cas
t<Bi
nary
Op*>
(e)-
>op]
==le
vel["=
"])
{//
intr
oduc
ene
wau
xili
ary
sign
alSi
gnal
Symb
ol*s
=ne
wSi
gnal
Symb
ol(c
osyn
data
->us
edSy
mbol
s->g
etUn
ique
SigN
ame(
getC
ompo
undS
igNa
me(e
)),
new
Type
Symb
ol("boolean")
,Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);
//de
clar
eau
xili
ary
sign
alin
the
curr
ent
loca
lsi
gnal
scop
eco
synd
ata-
>hwM
odul
eTre
e.ge
tCur
rent
Node
()->
scop
eSta
teme
nt->
symb
ols-
>ent
er(s
);co
synd
ata-
>use
dSym
bols
->en
ter(
s);
130
//em
itth
esi
gnal
just
befo
reth
eex
pres
sion
*sl
<<ne
wEm
it(s
,e);
//su
bsti
tute
the
sube
xpre
ssio
nwi
thth
ene
wsi
gnal
*pe
=ne
wLo
adSi
gnal
Valu
eExp
ress
ion(
s);
}}
} //if
the
root
node
isan
unar
yop
erat
orel
seif
(dyn
amic
_cas
t<AS
T::U
nary
Op*>(e
)){
//if
unar
yop
erat
oris
out
of{p
re,
not}
140
if(u
nary
leve
l[dy
nami
c_ca
st<U
nary
Op*>(e
)->o
p]<
unar
ylev
el["−
"])
{//
appl
yth
isfu
ncti
onre
curs
ivel
yto
the
oper
and
..St
atem
entL
ist *
sl1;
sl1
=de
comp
oseE
xpre
ssio
n(dy
nami
c_ca
st<A
ST::
Unar
yOp *
>(e)
->so
urce
,&d
ynam
ic_c
ast<
AST:
:Una
ryOp
*>(e
)->s
ourc
e);
//an
dst
ore
the
foun
dau
xili
ary
sign
alas
sign
ment
sif
(sl1
->st
atem
ents
.siz
e()>
0){
*sl
<<sl
1;}
}15
0//
ifth
eun
ary
oper
ator
ismi
nus
(thi
ssh
ould
n’t
occu
r)el
se{
asse
rt(0
);//
minu
sop
erat
orno
tal
lowe
d!}
} //if
eis
afu
ncti
onca
ll(a
ctua
lly
not
supp
orte
dby
the
KEP)
else
if(d
ynam
ic_c
ast<
AST:
:Fun
ctio
nCal
l *>(
e))
{Si
gnal
Symb
ol*s
=ne
wSi
gnal
Symb
ol(c
osyn
data
->us
edSy
mbol
s->
getU
niqu
eSig
Name
(dyn
amic
_cas
t<AS
T::F
unct
ionC
all *
>(e)
->ca
llee
->na
me),
160
new
Type
Symb
ol("boolean")
,Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);
cosy
ndat
a->h
wMod
uleT
ree.
getC
urre
ntNo
de()
->sc
opeS
tate
ment
->sy
mbol
s->e
nter
(s);
cosy
ndat
a->u
sedS
ymbo
ls->
ente
r(s)
;
*sl
<<ne
wEm
it(s
,e);
*pe
=ne
wLo
adSi
gnal
Valu
eExp
ress
ion(
s);
} //if
eis
ava
riab
le(o
rco
nsta
nt)
else
if(d
ynam
ic_c
ast<
AST:
:Loa
dVar
iabl
eExp
ress
ion *
>(e)
){
Vari
able
Symb
ol*va
r=
dyna
mic_
cast
<AST
::Lo
adVa
riab
leEx
pres
sion
*>(e
)->v
aria
ble;
if(!
dyna
mic_
cast
<AST
::Co
nsta
ntSy
mbol
*>(v
ar))
{17
0//
ente
rne
wbo
olea
nau
xili
ary
sign
alin
the
curr
ent
sign
alsc
ope
Sign
alSy
mbol
*s
=ne
wSi
gnal
Symb
ol(c
osyn
data
->us
edSy
mbol
s->g
etUn
ique
SigN
ame(
getC
ompo
undS
igNa
me(e
)),
new
Type
Symb
ol("boolean")
,Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);
cosy
ndat
a->h
wMod
uleT
ree.
getC
urre
ntNo
de()
->sc
opeS
tate
ment
->sy
mbol
s->e
nter
(s);
cosy
ndat
a->u
sedS
ymbo
ls->
ente
r(s)
;//
emit
this
new
sign
alwi
thth
eva
riab
leva
lue
*sl
<<ne
wEm
it(s
,e);
//su
bsti
tute
the
vari
able
with
the
new
sign
al
*pe
=ne
wLo
adSi
gnal
Valu
eExp
ress
ion(
s);
180
}} re
turn
sl;
} / *Ha
ndle
san
expr
essi
on:
*-
term
inat
esif
expr
essi
onis
non-
bool
ean
*-
subs
titu
tes
all
occu
rren
ces
ofpr
e(?S
)wi
than
auxi
liar
ysi
gnal
preV
_San
dde
clar
esan
d
*ca
lcul
ates
itwi
thin
the
sign
alsc
ope
ofS
*-
subs
titu
tes
all
comp
aris
ion
expr
essi
ons
and
bool
ean
vari
able
sin
ewi
thau
xili
ary
sign
als
190
*a_
xan
dem
itth
emwi
thth
eac
cord
ing
valu
eim
medi
atel
ybe
fore
the
expr
essi
on
*-
subs
titu
teth
eco
rres
pond
ing
expr
essi
one
with
anau
xili
ary
sign
als
*-
decl
are
the
auxi
liar
ysi
gnal
sa_
xan
ds
inth
elo
west
sign
alsc
ope,
inwh
ich
all
sign
als
*ar
ekn
own.
Decl
are
all
sign
als
ine
asin
puts
and
sas
outp
utto
the
hard
ware
modu
le
*-
corr
espo
ndin
gto
the
scop
e.
*-
Sust
ain
swi
thth
eva
lue
ofe
with
ina
new
thre
adin
the
HW-M
odul
ean
din
itia
lize
all
non
*in
itia
lize
dsi
gnal
sou
tof
ewi
thfa
lse
*/ void
CoDe
sign
Este
relP
rint
er::
expr
essi
on(E
xpre
ssio
n*e
,Ex
pres
sion
**pe
){
proc
ess(
e);
200
if(d
ynam
ic_c
ast<
Unar
yOp *
>(e)
||dy
nami
c_ca
st<B
inar
yOp *
>(e)
){//
get
new
sign
alna
mefo
rth
eev
alua
ted
expr
essi
onSt
atem
entL
ist
*sl;
bool
isBo
ol=
fals
e;//
cons
ider
only
comp
lex
expr
essi
ons
for
deco
mpos
itio
nif
(dyn
amic
_cas
t<Un
aryO
p *>(
e))
{//
Only
bool
ean
(sub
-)ex
pres
sion
sca
nbe
calc
ulat
edin
HW
80
A.1. HW/SW Co-Synthese
if(u
nary
leve
l[dy
nami
c_ca
st<U
nary
Op*>(e
)->o
p]<
unar
ylev
el["−
"])
sl=
deco
mpos
eExp
ress
ion(
e,pe
);is
Bool
=tr
ue;
210
} else
if(d
ynam
ic_c
ast<
Bina
ryOp
*>(e
)){
//On
lybo
olea
n(s
ub-)
expr
essi
ons
can
beca
lcul
ated
inHW
if(l
evel
[dyn
amic
_cas
t<Bi
nary
Op*>
(e)-
>op]
<le
vel["=
"])
sl=
deco
mpos
eExp
ress
ion(
e,pe
);is
Bool
=tru
e;} if
(isB
ool)
{if
(sl-
>sta
teme
nts.
size
()>0
){
Sust
ain *
sust
=dy
nami
c_ca
st<S
usta
in*>
( *cu
rren
tNod
e);
220
if(s
ust
!=NU
LL)
{
*sl
<<ne
wEm
it(s
ust-
>sig
nal,
e);
*cur
rent
Node
=ne
wLo
op(s
l);
} else
{
*sl
<<*c
urre
ntNo
de;
*cur
rent
Node
=(S
tate
ment
*)sl
;}
} //su
bsti
tute
all
pre
oper
ator
sin
e23
0su
bstP
re( *
pe,p
e);
e=*p
e;//
get
new
sign
alna
mefo
rth
eev
alua
ted
expr
essi
onst
ring
comp
SigN
ame
=co
synd
ata-
>use
dSym
bols
->ge
tUni
queS
igNa
me(g
etCo
mpou
ndSi
gNam
e(e)
);//
stor
eal
lsy
mbol
sus
edin
ein
the
symb
olta
ble
stSy
mbol
Tabl
e*s
t=
new
Symb
olTa
ble(
);ge
tUse
dSym
bols
(e, *
st);
//fi
ndco
rres
pond
ing
scop
eHW
Modu
leTr
eeNo
de*hw
m=
cosy
ndat
a->h
wMod
uleT
ree.
getL
owes
tNod
e(st
);Mo
dule*
hwMo
dule
=hw
m->h
wMod
ule;
240
//di
tera
teov
eral
lsy
mbol
sin
the
expr
essi
onst
d::v
ecto
r<Sy
mbol
*>::
iter
ator
i=
st->
symb
ols.
begi
n();
whil
e(i
!=st
->sy
mbol
s.en
d())
{//
add
cons
tant
decl
arat
ion
tohw
-mod
ule
if(C
onst
antS
ymbo
l *c
=dy
nami
c_ca
st<C
onst
antS
ymbo
l *>(*i
)){
if(!
hwMo
dule
->co
nsta
nts-
>loc
al_c
onta
ins(
c->n
ame)
){
hwMo
dule
->co
nsta
nts-
>ent
er(c
);}
} if(S
igna
lSym
bol *
s=
dyna
mic_
cast
<Sig
nalS
ymbo
l *>(
*i))
{25
0//
add
init
iali
zer
tono
nin
itia
lize
dsi
gnal
sif
(!s-
>ini
tial
izer
){
s->i
niti
aliz
er=
new
Load
Vari
able
Expr
essi
on(
new
Cons
tant
Symb
ol("fa
lse",
new
Type
Symb
ol("boolean")
,ne
wLi
tera
l("0",
new
Type
Symb
ol("boolean
"))
));
}26
0//
add
inpu
tsi
gnal
decl
arat
ion
tohw
-mod
ule
if(!
hwMo
dule
->si
gnal
s->l
ocal
_con
tain
s(s-
>nam
e))
{
std:
:cer
r<<
s->n
ame
<<"␣"
<<s-
>typ
e->n
ame
<<"␣"
<<s-
>kin
d<<
"\n";
hwMo
dule
->si
gnal
s->e
nter
( new
Sign
alSy
mbol
(s->
name
,s-
>typ
e,(s
->ki
nd==
Sign
alSy
mbol
::Se
nsor
)?(
Sign
alSy
mbol
::Se
nsor
):(S
igna
lSym
bol:
:Inp
ut),
s->c
ombi
ne,
s->i
niti
aliz
er)
);27
0} //
stor
esi
gnal
depe
nden
ies
cosy
ndat
a->s
igna
lDep
ende
ncie
s<<
comp
SigN
ame
<<"␣"
<<s-
>nam
e<<
"\n";
} i++;
} //de
clar
eth
eau
xili
ary
sign
alth
atsu
bsti
tute
se
asou
tput
toth
ehw
-mod
ule
...
Sign
alSy
mbol
*co
mpHW
Sig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,
280
new
Type
Symb
ol("boolean")
,AS
T::S
igna
lSym
bol:
:Out
put,
NULL
,NU
LL);
comp
HWSi
g->i
niti
aliz
er=
new
Load
Vari
able
Expr
essi
on( ne
wCo
nsta
ntSy
mbol
("fa
lse",
new
Type
Symb
ol("boolean")
,29
0ne
wLi
tera
l("0",
new
Type
Symb
ol("
boolean")
))
);( *hw
Modu
le->
sign
als)
.ent
er(c
ompH
WSig
);co
synd
ata-
>use
dSym
bols
->en
ter(
comp
HWSi
g);
//..
.an
dsu
stai
nit
ina
new
thre
adwi
thin
the
hw-m
odul
eSu
stai
n *su
stai
n=
new
Sust
ain(
comp
HWSi
g,e)
;dy
nami
c_ca
st<P
aral
lelS
tate
ment
List
*>(h
wMod
ule-
>bod
y)->
thre
ads.
push
_bac
k(su
stai
n);
300
//Su
bsti
tute
the
Sign
alEx
pres
sion
inth
eso
ftwa
remo
dule
by//
the
newl
yge
nera
ted
sign
alSi
gnal
Symb
ol*co
mpSW
Sig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,
new
Type
Symb
ol("boolean")
,AS
T::S
igna
lSym
bol:
:Loc
al,
NULL
,NU
LL);
comp
SWSi
g->i
niti
aliz
er=
310
new
Load
Vari
able
Expr
essi
on( ne
wCo
nsta
ntSy
mbol
("fa
lse",
new
Type
Symb
ol("boolean")
,ne
wLi
tera
l("0",
new
Type
Symb
ol("
boolean")
)
81
A. Kommentierter Programmcode
));
hwm-
>sco
peSt
atem
ent-
>sym
bols
->en
ter(
comp
SWSi
g);
*pe
=ne
wLo
adSi
gnal
Valu
eExp
ress
ion(
comp
SWSi
g);
320
}}
} / *Ge
nera
tes
ava
lid
Este
rel
Sign
alId
enti
fier
from
agi
ven
Sign
alEx
pres
sion
*@p
aram
eAn
expr
essi
on
*@r
etur
nA
stri
ngbu
ilt
from
the
expr
essi
onby
subs
titu
ting
oper
ator
swi
thal
phab
etic
char
acte
rs
*an
dsp
aces
with
anun
ders
core
.Th
est
ring
iscr
oppe
dto
40ch
arac
ters
*/ stri
ngCo
Desi
gnEs
tere
lPri
nter
::ge
tCom
poun
dSig
Name
(Exp
ress
ion
*e){
330
std:
:ost
ring
stre
amco
mp;
Este
relP
rint
erep
(com
p);
ep.p
rint
(e);
stri
ngco
mpSt
r=
comp
.str
();
for(
unsi
gned
int
x=0;
x<co
mpSt
r.si
ze()
;x++
){
if((
comp
Str.
subs
tr(x
,1)=
="␣")
)co
mpSt
r.re
plac
e(x,
1,"_
");
else
if((
comp
Str.
subs
tr(x
,1)=
=")"
)||(
comp
Str.
subs
tr(x
,1)=
="("
)){
comp
Str.
repl
ace(
x,1,"")
;x--
;}el
seif
((co
mpSt
r.su
bstr
(x,1
)=="=
"))
comp
Str.
repl
ace(
x,1,"E
Q")
;el
seif
((co
mpSt
r.su
bstr
(x,2
)=="<
>")
)co
mpSt
r.re
plac
e(x,
2,"N
EQ")
;34
0el
seif
((co
mpSt
r.su
bstr
(x,1
)=="<
"))
comp
Str.
repl
ace(
x,1,"L
T")
;el
seif
((co
mpSt
r.su
bstr
(x,2
)=="<
=")
)co
mpSt
r.re
plac
e(x,
2,"L
ET")
;el
seif
((co
mpSt
r.su
bstr
(x,1
)==">
"))
comp
Str.
repl
ace(
x,1,"G
T")
;el
seif
((co
mpSt
r.su
bstr
(x,2
)==">
=")
)co
mpSt
r.re
plac
e(x,
2,"G
ET")
;el
seif
((co
mpSt
r.su
bstr
(x,1
)=="+
"))
comp
Str.
repl
ace(
x,1,"A
DD")
;el
seif
((co
mpSt
r.su
bstr
(x,1
)=="−
"))
comp
Str.
repl
ace(
x,1,"S
UB")
;el
seif
((co
mpSt
r.su
bstr
(x,1
)=="∗")
)co
mpSt
r.re
plac
e(x,
1,"M
UL"
);el
seif
((co
mpSt
r.su
bstr
(x,1
)=="?")
){c
ompS
tr.r
epla
ce(x
,1,"")
;x--;
}el
seif
((co
mpSt
r.su
bstr
(x,2
)=="??
"))
{com
pStr
.rep
lace
(x,2
,"")
;x-
-;}
}35
0co
mpSt
r=co
mpSt
r.su
bstr
(0,4
0);
tran
sfor
m(c
ompS
tr.b
egin
(),
comp
Str.
end(
),//
sour
ceco
mpSt
r.be
gin(
),//
dest
inat
ion
toup
per)
;//
oper
atio
nif
(com
pStr
[com
pStr
.siz
e()-
1]==
’_’)
comp
Str.
eras
e(co
mpSt
r.si
ze()
-1);
retu
rnco
mpSt
r;} / *
Appl
ies
’pre
’to
Sign
alEx
pres
sion
’e’
reku
rsiv
ely
acco
rdin
gto
the
rule
s
*in
the
Este
rel
Prim
erCh
apte
r4.
6.2.
The
flag
’i’
isth
ein
dex
ofth
e36
0*cu
rren
tpr
eop
erat
orpr
e0or
pre1
(see
Este
rel
Prim
erch
apte
r4.
6.2)
.
*@r
etur
nEx
pres
sion
with
expa
nded
pre(
)op
erat
ors
*/ Expr
essi
on*Co
Desi
gnEs
tere
lPri
nter
::ap
plyP
re(E
xpre
ssio
n *e,
bool
i){
Bina
ryOp
*b;
Unar
yOp
*u;
if((
dyna
mic_
cast
<Loa
dSig
nalE
xpre
ssio
n *>(
e)!=
NULL
)&&
!i)
retu
rnne
wUn
aryO
p(NU
LL,"pre_0"
,e);
else
if((
dyna
mic_
cast
<Loa
dSig
nalE
xpre
ssio
n *>(
e)!=
NULL
)&&
i)re
turn
new
Unar
yOp(
NULL
,"
pre_1",
e);
else
if((
u=
dyna
mic_
cast
<Una
ryOp
*>(e
))!=
NULL
)re
turn
new
Unar
yOp(
NULL
,"not"
,app
lyPr
e(u-
>sou
rce,
!i))
;37
0el
se{
b=
dyna
mic_
cast
<Bin
aryO
p *>(
e);
if(b
->op
.com
pare
("an
d")
==0)
retu
rnne
wBi
nary
Op(N
ULL,"an
d",
appl
yPre
(b->
sour
ce1,
i),a
pply
Pre(
b->s
ourc
e2,i
));
if(b
->op
.com
pare
("or"
)==0
)re
turn
new
Bina
ryOp
(NUL
L,"or"
,app
lyPr
e(b-
>sou
rce1
,i),
appl
yPre
(b->
sour
ce2,
i));
} retu
rnNU
LL;
}
380
/ *Su
bsti
tute
all
’pre
(S)’
and
’pre
(?S)
’Ex
pres
sion
sin
’e’
with
new
Sign
alpr
e_S
and
preV
_S
*re
spec
tive
ly.
New
Sign
als
pre_
San
dpr
eV_S
are
calc
ulat
edin
the
HW-m
odul
eof
the
same
scop
e
*wh
ere
Sis
decl
ared
.
*Va
lued
Expr
essi
ons
(see
Prim
erch
apte
r4.
6):
*-
pre(
?S)
give
sth
eva
lue
ofS
inth
epr
evio
usin
stan
ce,
Sis
Sign
alId
enti
fier
*Si
gnal
Expr
essi
ons:
*-
argu
ment
ofpr
eis
asi
gnal
expr
essi
on
*-
rule
sin
Este
rel
Prim
erCh
apte
r4.
6.2
hold
*/ //vo
idCo
Desi
gnEs
tere
lPri
nter
::su
bstP
re(E
xpre
ssio
n*e,
Expr
essi
on**
pe,
Modu
le*
hwMo
dule
){39
0vo
idCo
Desi
gnEs
tere
lPri
nter
::su
bstP
re(E
xpre
ssio
n*e
,Ex
pres
sion
**pe
){if
(dyn
amic
_cas
t<Un
aryO
p *>
(e))
{Un
aryO
p*u
=dy
nami
c_ca
st<U
nary
Op*>
(e);
stri
ngco
mpSi
gNam
e;//
ifop
erat
oris
the
pre(
)op
erat
or..
.if
(u->
op.c
ompa
re(0
,3,"pre
")==
0){
Load
Sign
alVa
lueE
xpre
ssio
n *ls
ve=N
ULL;
stri
ngco
mpSi
gNam
e;Si
gnal
Symb
ol*pr
eSig
;//
ifpr
eis
appl
ied
tova
lued
sign
al40
0if
((ls
ve=
dyna
mic_
cast
<Loa
dSig
nalV
alue
Expr
essi
on*>
(u->
sour
ce))
!=NU
LL)
{//
get
uniq
uesi
gnal
name
cons
isti
ngof
apr
efix
"preV
_"
the
sign
alna
mean
dan
//op
tion
alnu
mber
comp
SigN
ame
=co
synd
ata-
>use
dSym
bols
->ge
tUni
queS
igNa
me("preV
_"
+ls
ve->
sign
al->
name
);//
reus
epr
eV_S
ifit
isal
read
yca
lcul
ated
if(c
osyn
data
->us
edPr
eSym
bols
->lo
cal_
cont
ains
(com
pSig
Name
)){
preS
ig=
(Sig
nalS
ymbo
l *)
cosy
ndat
a->u
sedP
reSy
mbol
s->g
et(c
ompS
igNa
me);
//if
(!hw
Modu
le->
sign
als-
>loc
al_c
onta
ins(
comp
SigN
ame)
)//
hwMo
dule
->si
gnal
s->e
nter
(pre
Sig)
;//
ifpr
eV_S
isno
tca
lcul
ated
yet
410
}el
se{
//in
trod
uce
new
sign
alna
med
’pre
V_S’
preS
ig=
new
Sign
alSy
mbol
(com
pSig
Name
,lsv
e->s
igna
l->t
ype,
AST:
:Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);//
get
the
scop
ewh
ere
Swa
sde
clar
edSy
mbol
Tabl
e *st
=ne
wSy
mbol
Tabl
e();
getU
sedS
ymbo
ls(u
->so
urce
, *st
);HW
Modu
leTr
eeNo
de*to
pHWM
odul
e=
cosy
ndat
a->h
wMod
uleT
ree.
getL
owes
tNod
e(st
);//
decl
are
sign
al’p
reV_
S’in
that
scop
eto
pHWM
odul
e->s
cope
Stat
emen
t->s
ymbo
ls->
ente
r(pr
eSig
);42
0
82
A.1. HW/SW Co-Synthese
//cl
acul
ate
’pre
V_S’
inth
eco
rres
pond
ing
Scop
eVa
riab
leSy
mbol
*var
=ne
wVa
riab
leSy
mbol
("pre
val"
,lsv
e->s
igna
l->t
ype,
u->s
ourc
e);
Var
*lvd
=ne
wVa
r();
lvd-
>sym
bols
=ne
wSy
mbol
Tabl
e();
lvd-
>sym
bols
->en
ter(
var)
;St
atem
entL
ist
*sl
=ne
wSt
atem
entL
ist(
);Lo
adSi
gnal
Expr
essi
on*
lse
=ne
wLo
adSi
gnal
Expr
essi
on(l
sve-
>sig
nal-
>typ
e,ls
ve->
sign
al); Ever
y *es
t=
new
Ever
y(lv
d,ne
wDe
lay(
NULL
,lse
,NUL
L,tr
ue,N
ULL)
);lv
d->b
ody
=sl
;43
0sl
->st
atem
ents
.pus
h_ba
ck(n
ewPa
use(
));
sl->
stat
emen
ts.p
ush_
back
(new
Emit
(pre
Sig,
new
Load
Vari
able
Expr
essi
on(v
ar))
);to
pHWM
odul
e->p
reFu
ncti
ons-
>thr
eads
.pus
h_ba
ck(e
st);
//de
clar
esi
gnal
’pre
V_S’
asin
put
inth
eHW
Modu
lewh
ere
itis
used
preS
ig=
new
Sign
alSy
mbol
(com
pSig
Name
,lsv
e->s
igna
l->t
ype,
AST:
:Sig
nalS
ymbo
l::I
nput
,NUL
L,NU
LL);//
hwMo
dule
->si
gnal
s->e
nter
(pre
Sig)
;//
ente
rsi
gnal
’pre
V_S’
inus
edPr
eSym
bols
cosy
ndat
a->u
sedP
reSy
mbol
s->e
nter
(pre
Sig)
;44
0} *p
e=
new
Load
Sign
alVa
lueE
xpre
ssio
n(pr
eSig
);//
ifpr
eis
appl
ied
toa
pure
sign
al}
else
if(d
ynam
ic_c
ast<
Load
Sign
alEx
pres
sion
*>(u
->so
urce
)){
if((
u->o
p.co
mpar
e("pre_0")
==0)
||(u
->op
.com
pare
("pre
")==
0))
{//
get
uniq
uesi
gnal
name
cons
isti
ngof
apr
efix
"pre0_"
the
sign
alna
mean
dan
//op
tion
alnu
mber
comp
SigN
ame
=co
synd
ata-
>use
dSym
bols
->ge
tUni
queS
igNa
me("pre0_"
+ge
tCom
poun
dSig
Name
(u->
sour
ce))
;//
reus
epr
e0_S
ifit
isal
read
yca
lcul
ated
450
if(c
osyn
data
->us
edPr
eSym
bols
->lo
cal_
cont
ains
(com
pSig
Name
)){
preS
ig=
(Sig
nalS
ymbo
l *)
cosy
ndat
a->u
sedP
reSy
mbol
s->g
et(c
ompS
igNa
me);
//if
pre0
_Sis
not
calc
ulat
edye
t}
else
{//
intr
oduc
ene
wsi
gnal
name
d’p
re0_
S’pr
eSig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,N
ULL,
AST:
:Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);
//ge
tth
esc
ope
wher
eS
was
decl
ared
Symb
olTa
ble *
st=
new
Symb
olTa
ble(
);ge
tUse
dSym
bols
(u->
sour
ce, *
st);
HWMo
dule
Tree
Node
*to
pHWM
odul
e=
cosy
ndat
a->h
wMod
uleT
ree.
getL
owes
tNod
e(st
);46
0//
decl
are
sign
al’p
re0_
S’in
that
scop
eto
pHWM
odul
e->s
cope
Stat
emen
t->s
ymbo
ls->
ente
r(pr
eSig
);//
clac
ulat
e’p
re0_
S’in
the
corr
espo
ndin
gHW
Modu
leSt
atem
entL
ist
*sl
=ne
wSt
atem
entL
ist(
);sl
->st
atem
ents
.pus
h_ba
ck(n
ewPa
use(
));
sl->
stat
emen
ts.p
ush_
back
(new
Emit
(pre
Sig,
NULL
));
topH
WMod
ule
->pr
eFun
ctio
ns->
thre
ads.
push
_bac
k(ne
wEv
ery(
sl,
new
Dela
y(NU
LL,u
->so
urce
,NUL
L,tr
ue,N
ULL)
));
//de
clar
esi
gnal
’pre
0_S’
asin
put
inth
eHW
Modu
lewh
ere
itis
used
470
preS
ig=
new
Sign
alSy
mbol
(com
pSig
Name
,NUL
L,AS
T::S
igna
lSym
bol:
:Inp
ut,N
ULL,
NULL
);//
hwMo
dule
->si
gnal
s->e
nter
(pre
Sig)
;//
ente
rsi
gnal
’pre
0_S’
inus
edPr
eSym
bols
cosy
ndat
a->u
sedP
reSy
mbol
s->e
nter
(pre
Sig)
;}
}el
se{
//ge
tun
ique
sign
alna
meco
nsis
ting
ofa
pref
ix"pre1_"
the
sign
alna
mean
dan
//op
tion
alnu
mber
comp
SigN
ame
=co
synd
ata-
>use
dSym
bols
->ge
tUni
queS
igNa
me(
480
"pre1_"
+ge
tCom
poun
dSig
Name
(u->
sour
ce))
;//
reus
epr
e1_S
ifit
isal
read
yca
lcul
ated
if(c
osyn
data
->us
edPr
eSym
bols
->lo
cal_
cont
ains
(com
pSig
Name
)){
preS
ig=
(Sig
nalS
ymbo
l *)
cosy
ndat
a->u
sedP
reSy
mbol
s->g
et(c
ompS
igNa
me);
//if
pre1
_Sis
not
calc
ulat
edye
t}
else
{//
intr
oduc
ene
wsi
gnal
name
d’p
re1_
S’pr
eSig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,N
ULL,
AST:
:Sig
nalS
ymbo
l::L
ocal
,NUL
L,NU
LL);
//ge
tth
esc
ope
wher
eS
was
decl
ared
Symb
olTa
ble *
st=
new
Symb
olTa
ble(
);49
0ge
tUse
dSym
bols
(u->
sour
ce, *
st);
HWMo
dule
Tree
Node
*to
pHWM
odul
e=
cosy
ndat
a->h
wMod
uleT
ree.
getL
owes
tNod
e(st
);//
decl
are
sign
al’p
re1_
S’in
that
scop
eto
pHWM
odul
e->s
cope
Stat
emen
t->s
ymbo
ls->
ente
r(pr
eSig
);//
clac
ulat
e’p
re1_
S’in
the
corr
espo
ndin
gHW
Modu
leSt
atem
entL
ist*s
l_0
=ne
wSt
atem
entL
ist(
);St
atem
entL
ist*s
l_1
=ne
wSt
atem
entL
ist(
);sl
_0->
stat
emen
ts.p
ush_
back
(new
Emit
(pre
Sig,
NULL
));
sl_1
->st
atem
ents
.pus
h_ba
ck(n
ewPa
use(
));
sl_1
->st
atem
ents
.pus
h_ba
ck(n
ewEm
it(p
reSi
g,NU
LL))
;50
0sl
_0->
stat
emen
ts.p
ush_
back
(new
Ever
y(sl
_1,
new
Dela
y(NU
LL,u
->so
urce
,NUL
L,tr
ue,
NULL
)));to
pHWM
odul
e->p
reFu
ncti
ons-
>thr
eads
.pus
h_ba
ck(s
l_0)
;//
decl
are
sign
al’p
re1_
S’as
inpu
tin
the
HWMo
dule
wher
eit
isus
edpr
eSig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,N
ULL,
AST:
:Sig
nalS
ymbo
l::I
nput
,NUL
L,NU
LL);
//hw
Modu
le->
sign
als-
>ent
er(p
reSi
g);
//en
ter
sign
al’p
re1_
S’in
used
PreS
ymbo
lsco
synd
ata-
>use
dPre
Symb
ols-
>ent
er(p
reSi
g);
}} *p
e=
new
Load
Sign
alEx
pres
sion
(NUL
L,pr
eSig
);51
0}
else
{//
ifpr
eis
appl
ied
toa
sign
alex
pres
sion
e=
*pe
=ap
plyP
re(u
->so
urce
,fal
se);
//su
bstP
re(e
,&e,
hwMo
dule
);su
bstP
re(e
,&e)
;}
} //el
sesu
bstP
re(u
->so
urce
,&(u
->so
urce
),hw
Modu
le);
else
subs
tPre
(u->
sour
ce,&
(u->
sour
ce))
;}
520
else
if(d
ynam
ic_c
ast<
Bina
ryOp
*>(e
)){
Bina
ryOp
*b=
dyna
mic_
cast
<Bin
aryO
p *>
(e);
//su
bstP
re(b
->so
urce
1,&(
b->s
ourc
e1),
hwMo
dule
);su
bstP
re(b
->so
urce
1,&(
b->s
ourc
e1))
;//
subs
tPre
(b->
sour
ce2,
&(b-
>sou
rce2
),hw
Modu
le);
subs
tPre
(b->
sour
ce2,
&(b-
>sou
rce2
));
}
83
A. Kommentierter Programmcode
} / *53
0*-
Subs
titu
tes
the
sign
alex
pres
sion
ewi
than
auxi
liar
ysi
gnal
s
*-
expa
ndal
lpr
e()
oper
ator
sin
the
expr
essi
onun
til
they
are
appl
ied
toju
ston
esi
gnal
*-
subs
titu
teal
lpr
e(),
pre_
0()
and
pre_
1()
with
anau
xili
ary
sign
alpr
e_S,
pre0
_San
dpr
e1_S
*an
dde
clar
ean
dca
lcul
ate
thes
esi
gnal
swi
thin
para
llel
toth
esc
opes
body
that
decl
ares
S
*-
Find
the
hier
arch
ical
lylo
west
scop
ein
that
all
sign
als
ine
are
know
nan
dde
clar
eth
e
*au
xili
ary
sign
als
with
inth
issc
ope.
Decl
are
inth
ehw
-mod
ule
corr
espo
ndig
toth
atsc
ope
*al
lsi
gnal
sus
edin
eas
inpu
tan
ds
asou
tput
*-
Add
ane
wth
read
toth
ehw
-mod
ule
that
emit
ss
ever
ytim
eth
eex
pres
sion
eis
pres
ent
*/ void
CoDe
sign
Este
relP
rint
er::
sige
xpre
ssio
n(Ex
pres
sion
*e,E
xpre
ssio
n**pe
){
540
//co
mple
xsi
gnal
expr
essi
onor
not?
if(d
ynam
ic_c
ast<
Dela
y *>(
e)||
dyna
mic_
cast
<Loa
dSig
nalE
xpre
ssio
n *>(
e)){
proc
ess(
e);
} else
{//
expa
ndal
lpr
eop
erat
ors
and
subs
titi
ute
them
with
auxi
liar
ysi
gnal
ssu
bstP
re( *
pe,p
e);
//ge
tne
wsi
gnal
name
for
the
eval
uate
dex
pres
sion
stri
ngco
mpSi
gNam
e=
cosy
ndat
a->u
sedS
ymbo
ls->
getU
niqu
eSig
Name
(get
Comp
ound
SigN
ame(
e));
//st
ore
all
sign
als
used
inth
eex
pres
sion
inst
550
Symb
olTa
ble
*st
=ne
wSy
mbol
Tabl
e();
getU
sedS
ymbo
ls(e
, *st
);//
get
the
corr
espo
ndin
gsi
gnal
scop
eHW
Modu
leTr
eeNo
de*hw
m=
cosy
ndat
a->h
wMod
uleT
ree.
getL
owes
tNod
e(st
);Mo
dule
*hw
Modu
le=
hwm-
>hwM
odul
e;st
d::v
ecto
r<Sy
mbol
*>::
iter
ator
i=
st->
symb
ols.
begi
n();
//de
clar
eus
edsy
mbol
sin
the
sige
xpre
ssio
nas
inpu
tto
the
HWMo
dule
//an
dwr
ite
sign
alde
pend
enci
eswh
ile
(i!=
st->
symb
ols.
end(
)){
Sign
alSy
mbol
*s
=dy
nami
c_ca
st<S
igna
lSym
bol *
>(*i
);56
0if
(s->
kind
!=Si
gnal
Symb
ol::
Inpu
t){
*i=
new
Sign
alSy
mbol
(s->
name
,s->
type
,Sig
nalS
ymbo
l::I
nput
,s->
comb
ine,
s->i
niti
aliz
er);
} i++;
cosy
ndat
a->s
igna
lDep
ende
ncie
s<<
comp
SigN
ame
<<"␣"
<<s-
>nam
e<<
"\n";
} ((Ex
tSym
bolT
able
*)hw
Modu
le->
sign
als)
->ad
dSym
bols
(st)
;//
decl
are
the
auxi
liar
ysi
gnal
asou
tput
toth
ehw
-mod
ule
Sign
alSy
mbol
*co
mpHW
Sig
=ne
wSi
gnal
Symb
ol(c
ompS
igNa
me,N
ULL,
AST:
:Sig
nalS
ymbo
l::O
utpu
t,NU
LL,N
ULL)
;57
0( *hw
Modu
le->
sign
als)
.ent
er(c
ompH
WSig
);co
synd
ata-
>use
dSym
bols
->en
ter(
comp
HWSi
g);
//Th
eha
rdwa
remo
dule
emit
sth
ene
wsi
gnal
ever
ytim
e//
the
Sign
alEx
pres
sion
istr
uedy
nami
c_ca
st<P
aral
lelS
tate
ment
List
*>(h
wMod
ule-
>bod
y)->
thre
ads.
push
_bac
k(ne
wEv
ery(
new
Emit
(com
pHWS
ig,N
ULL)
,new
Dela
y(NU
LL,e
,NUL
L,tr
ue,N
ULL)
));
//Su
bsti
tute
the
Sign
alEx
pres
sion
inth
eso
ftwa
remo
dule
by//
the
newl
yge
nera
ted
sign
alSi
gnal
Symb
ol*co
mpSW
Sig
=
new
Sign
alSy
mbol
(com
pSig
Name
,NUL
L,AS
T::S
igna
lSym
bol:
:Loc
al,N
ULL,
NULL
);58
0hw
m->s
cope
Stat
emen
t->s
ymbo
ls->
ente
r(co
mpSW
Sig)
;
*pe
=ne
wLo
adSi
gnal
Expr
essi
on(N
ULL,
comp
SWSi
g);
}} bo
olCo
Desi
gnEs
tere
lPri
nter
::pu
sh_p
rece
denc
e(in
tp)
{bo
olne
edBr
acke
ts=
p<
prec
eden
ce.b
ack(
);pr
eced
ence
.pus
h_ba
ck(p
);re
turn
need
Brac
kets
;}
590
void
CoDe
sign
Este
relP
rint
er::
pop_
prec
eden
ce()
{pr
eced
ence
.pop
_bac
k();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Modu
leSy
mbol
&){
asse
rt(0
);}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Vari
able
Symb
ol&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Ty
peRe
nami
ng&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Co
nsta
ntRe
nami
ng&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Fu
ncti
onRe
nami
ng&)
{as
sert
(0);
}60
0St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Pr
oced
ureR
enam
ing
&){
asse
rt(0
);}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Sign
alRe
nami
ng&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Pr
edic
ated
Stat
emen
t&)
{as
sert
(0);
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Ta
skCa
ll&)
{as
sert
(0);
}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Buil
tinC
onst
antS
ymbo
l&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Buil
tinS
igna
lSym
bol
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Bu
ilti
nTyp
eSym
bol
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Bu
ilti
nFun
ctio
nSym
bol
&){
retu
rnSt
atus
();
}
610
/ * *Pe
rfor
msth
epa
rtit
ioni
ngof
the
orig
inal
prog
ram
into
sw-
and
hw-m
odul
es
*/ Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Modu
le&m
){
asse
rt(m
.sym
bol)
;//
Firs
tcr
eate
the
sw-m
odul
eas
aco
pyof
the
orig
inal
modu
leco
synd
ata-
>swM
odul
e=ne
wMo
dule
(new
Modu
leSy
mbol
(m.s
ymbo
l->n
ame+"_
sw")
);co
synd
ata-
>hwM
odul
eNam
ePre
fix
=m.
symb
ol->
name
;Si
gnal
*de
faul
tSco
pe=
new
Sign
al()
;de
faul
tSco
pe->
symb
ols
=ne
wSy
mbol
Tabl
e();
620
cosy
ndat
a->h
wMod
uleT
ree.
addC
hild
(cos
ynda
ta->
hwMo
dule
Name
Pref
ix,d
efau
ltSc
ope)
;/ *
Data
Obje
cts
*///
func
tion
s,pr
oced
ures
,ta
sks
cosy
ndat
a->s
wMod
ule-
>fun
ctio
ns=
m.fu
ncti
ons;
cosy
ndat
a->s
wMod
ule-
>pro
cedu
res
=m.
proc
edur
es;
cosy
ndat
a->s
wMod
ule-
>tas
ks=
m.ta
sks;
//ty
pes
(mus
tbe
decl
ared
wher
eth
eyar
eus
ed)
cosy
ndat
a->s
wMod
ule-
>typ
es=
m.ty
pes;
//co
nsta
nts
(mus
tbe
decl
ared
wher
eth
eyar
eus
ed)
cosy
ndat
a->s
wMod
ule-
>con
stan
ts=
m.co
nsta
nts;
630
/ *Si
gnal
s,Se
nsor
san
dRe
lati
ons
*///
the
inte
rfac
esi
gnal
smu
stbe
decl
ared
inth
ema
in(i
.eSW
-)mo
dule
//an
dwh
ere
they
are
used
cosy
ndat
a->s
wMod
ule-
>sig
nals
=m.
sign
als;
84
A.1. HW/SW Co-Synthese
//re
lati
ons
(mus
tbe
decl
ared
inth
ema
inmo
dule
)co
synd
ata-
>swM
odul
e->r
elat
ions
=m.
rela
tion
s;
/ *Bo
dy*/
//Th
ebo
dyof
the
soft
ware
modu
leis
simi
lar
toth
eor
igin
almo
dule
body
.64
0//
Only
Sign
alEx
pres
sion
swi
llbe
subs
titu
ted,
ever
yby
ane
wau
xili
ary
sign
al.
//Th
isau
xili
ary
sign
alis
emit
ted
inth
eha
rdwa
remo
dule
ever
ytim
eth
e//
orig
inal
expr
essi
onis
true
(see
sige
xpre
ssio
n())
cosy
ndat
a->s
wMod
ule-
>bod
y=
m.bo
dy;
//st
art
the
part
itio
ning
proc
ess(
cosy
ndat
a->s
wMod
ule-
>bod
y);
//Ru
nHW
-an
dSW
-Mod
ules
para
llel
toth
ebo
dyof
thei
rco
rres
pond
ing
sign
alsc
opes
.//
The
newl
yge
nera
ted
body
look
sli
keth
is:
650
//tr
apCO
SYN_
TRAP
in//
run
HW-M
odul
e//
||//
Calc
ulat
ion
ofau
xili
ary
sign
als
subs
titu
ting
pre
oper
ator
s//
||//
orig
inal
body
;//
exit
COSY
N_TR
AP//
end
trap
vect
or<H
WMod
uleT
reeN
ode *
>::i
tera
tor
i=
cosy
ndat
a->h
wMod
uleT
ree.
hwMo
dule
s.be
gin(
);i
=co
synd
ata-
>hwM
odul
eTre
e.hw
Modu
les.
begi
n();
660
whil
e(
i!=
cosy
ndat
a->h
wMod
uleT
ree.
hwMo
dule
s.en
d()
){
HWMo
dule
Tree
Node*
hwMo
dule
=((
HWMo
dule
Tree
Node
*)( *i)
);if
((dy
nami
c_ca
st<P
aral
lelS
tate
ment
List
*>(h
wMod
ule-
>hwM
odul
e->b
ody)
)->t
hrea
ds.s
ize(
)>0)
{Si
gnal
Symb
ol*tr
apSy
mbol
;
Para
llel
Stat
emen
tLis
t*p
sl=
new
Para
llel
Stat
emen
tLis
t();
psl-
>thr
eads
.pus
h_ba
ck(n
ewRu
n(hw
Modu
le->
hwMo
dule
->sy
mbol
->na
me,N
ULL)
);if
(hwM
odul
e->p
reFu
ncti
ons-
>thr
eads
.siz
e()>
0){
psl-
>thr
eads
.pus
h_ba
ck(h
wMod
ule-
>pre
Func
tion
s);
670
trap
Symb
ol=
new
Sign
alSy
mbol
(cos
ynda
ta->
used
Symb
ols-
>get
Uniq
ueSi
gNam
e("C
OSY
N_TRAP_PRE")
,NU
LL,
Sign
alSy
mbol
::Tr
ap,
NULL
,NU
LL);
cosy
ndat
a->u
sedS
ymbo
ls->
ente
r(tr
apSy
mbol
);} el
se{
trap
Symb
ol=
680
new
Sign
alSy
mbol
(cos
ynda
ta->
used
Symb
ols-
>get
Uniq
ueSi
gNam
e("C
OSY
N_TRAP")
,NU
LL,
Sign
alSy
mbol
::Tr
ap,
NULL
,NU
LL);
cosy
ndat
a->u
sedS
ymbo
ls->
ente
r(tr
apSy
mbol
);} Tr
ap*tr
ap=
new
Trap
();
trap
->sy
mbol
s=
new
Symb
olTa
ble(
);tr
ap->
symb
ols-
>ent
er(t
rapS
ymbo
l);
690
Stat
emen
tLis
t *sl
=ne
wSt
atem
entL
ist(
);
if(i
==co
synd
ata-
>hwM
odul
eTre
e.hw
Modu
les.
begi
n())
{sl
->st
atem
ents
.pus
h_ba
ck((
Stat
emen
t *)c
osyn
data
->sw
Modu
le->
body
);sl
->st
atem
ents
.pus
h_ba
ck(n
ewEx
it(t
rapS
ymbo
l,NU
LL))
;ps
l->t
hrea
ds.p
ush_
back
(sl)
;tr
ap->
body
=ps
l;
hwMo
dule
->sc
opeS
tate
ment
->bo
dy=
trap
;co
synd
ata-
>swM
odul
e->b
ody
=hw
Modu
le->
scop
eSta
teme
nt;
cosy
ndat
a->c
onvM
odul
es.a
dd(h
wMod
ule-
>hwM
odul
e);
700
}el
se{
sl->
stat
emen
ts.p
ush_
back
(hwM
odul
e->s
cope
Stat
emen
t->b
ody)
;sl
->st
atem
ents
.pus
h_ba
ck(n
ewEx
it(t
rapS
ymbo
l,NU
LL))
;ps
l->t
hrea
ds.p
ush_
back
(sl)
;tr
ap->
body
=ps
l;hw
Modu
le->
scop
eSta
teme
nt->
body
=tr
ap;
cosy
ndat
a->c
onvM
odul
es.a
dd(h
wMod
ule-
>hwM
odul
e);
}} i+
+;71
0} co
synd
ata-
>con
vMod
ules
.add
(cos
ynda
ta->
swMo
dule
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Mo
dule
s&m
){
//pr
epro
cess
the
code
and
get
tabl
eof
used
symb
ols
vect
or<M
odul
e *>:
:ite
rato
ri
=m.
modu
les.
begi
n();
whil
e(
i!=
m.mo
dule
s.en
d()
){
asse
rt( *
i);
720
asse
rt((
*i)-
>sym
bol)
;pr
oces
s(*i);
i++;
} //Pr
etty
Prin
tth
eco
nver
ted
Este
rel
code
AST:
:Est
erel
Prin
ter
p(o)
;co
synd
ata-
>con
vMod
ules
.wel
come
(p);
retu
rnSt
atus
();
730
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Excl
usio
n&e)
{re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Im
plic
atio
n&e)
{re
turn
Stat
us()
;}
740
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Symb
olTa
ble
&t)
{fo
r(
Symb
olTa
ble:
:con
st_i
tera
tor
i=
t.be
gin(
);
i!=
t.en
d()
;i+
+)
{pr
oces
s(*i);
} retu
rnSt
atus
();
}
85
A. Kommentierter Programmcode
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Type
Symb
ol&s
){
retu
rnSt
atus
();
}75
0St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Co
nsta
ntSy
mbol
&s)
{if
(s.i
niti
aliz
er)
{ex
pres
sion
(s.i
niti
aliz
er,N
ULL)
;} as
sert
(s.t
ype)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Si
gnal
Symb
ol&s
){
760
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Func
tion
Symb
ol&s
){
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Proc
edur
eSym
bol
&s)
{re
turn
Stat
us()
;}
770
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Task
Symb
ol&s
){
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Stat
emen
tLis
t&l
){
vect
or<S
tate
ment*>
::co
nst_
iter
ator
i=
l.st
atem
ents
.beg
in()
;wh
ile
(i
!=l.
stat
emen
ts.e
nd()
){
curr
entN
ode
=(S
tate
ment
**)
&(*i
);pr
oces
s(*i);
780
i++;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Para
llel
Stat
emen
tLis
t&l
){
vect
or<S
tate
ment*>
::co
nst_
iter
ator
i=
l.th
read
s.be
gin(
);wh
ile
(i
!=l.
thre
ads.
end(
))
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(*i
);pr
oces
s(*i);
790
i++;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Noth
ing
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Pa
use
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Ha
lt&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Emit
&e)
{80
0as
sert
(e.s
igna
l);
if(e
.val
ue)
{ex
pres
sion
(e.v
alue
,&(e
.val
ue))
;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Star
tCou
nter
&s)
{as
sert
(s.c
ount
er);
expr
essi
on(s
.cou
nt,&
(s.c
ount
));
810
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Sust
ain
&e)
{as
sert
(e.s
igna
l);
if(e
.val
ue)
{ex
pres
sion
(e.v
alue
,&(e
.val
ue))
;} re
turn
Stat
us()
;}
820
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Assi
gn&a
){
asse
rt(a
.var
iabl
e);
asse
rt(a
.val
ue);
expr
essi
on(a
.val
ue,&
(a.v
alue
));
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Proc
edur
eCal
l&c
){
asse
rt(c
.pro
cedu
re);
830
vect
or<E
xpre
ssio
n *>:
:con
st_i
tera
tor
j=
c.va
lue_
args
.beg
in()
;wh
ile
(j!=
c.va
lue_
args
.end
())
{ex
pres
sion
( *j,
(Exp
ress
ion *
*)&(
*j))
;j+
+;} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Ex
ec&e
){
for
(ve
ctor
<Tas
kCal
l *>:
:con
st_i
tera
tor
i=
e.ca
lls.
begi
n()
;84
0i
!=e.
call
s.en
d()
;i+
+){
asse
rt( *
i);
asse
rt((
*i)-
>pro
cedu
re);
vect
or<V
aria
bleS
ymbo
l *>:
:con
st_i
tera
tor
k=
( *i)
->re
fere
nce_
args
.beg
in()
;wh
ile
(k!=
( *i)
->re
fere
nce_
args
.end
())
{k+
+;} ve
ctor
<Exp
ress
ion *
>::c
onst
_ite
rato
rj
=( *
i)->
valu
e_ar
gs.b
egin
();
whil
e(j
!=( *
i)->
valu
e_ar
gs.e
nd()
){
expr
essi
on( *
j,(E
xpre
ssio
n **)&(
*j))
;85
0j+
+;} as
sert
((*i
)->s
igna
l);
if((
*i)-
>bod
y){
curr
entN
ode
=(S
tate
ment
**)
&(( *i)
->bo
dy);
proc
ess(
( *i)
->bo
dy);
}} re
turn
Stat
us()
;
86
A.1. HW/SW Co-Synthese
}86
0St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Pr
esen
t&p
){
if(p
.cas
es.s
ize(
)==
1){
Pred
icat
edSt
atem
ent
*ps
=p.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e,&(
ps->
pred
icat
e));
if(p
s->b
ody)
{cu
rren
tNod
e=
(Sta
teme
nt**
)&(
ps->
body
);st
atem
ent(
ps->
body
);}
870
}el
se{
for
(vec
tor<
Pred
icat
edSt
atem
ent *
>::c
onst
_ite
rato
ri
=p.
case
s.be
gin(
);
i!=
p.ca
ses.
end(
);
i++)
{as
sert
( *i)
;as
sert
((*i)-
>pre
dica
te);
sige
xpre
ssio
n(( *
i)->
pred
icat
e,&(
( *i)
->pr
edic
ate)
);if
((*i)-
>bod
y){
curr
entN
ode
=(S
tate
ment
**)
&(( *
i)->
body
);pr
oces
s(( *
i)->
body
);}
880
}} if
(p.d
efau
lt_s
tmt)
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(p.
defa
ult_
stmt
);st
atem
ent(
p.de
faul
t_st
mt);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
If&s
){
890
vect
or<P
redi
cate
dSta
teme
nt*>
::co
nst_
iter
ator
i=
s.ca
ses.
begi
n();
asse
rt(i
!=s.
case
s.en
d())
;ex
pres
sion
((*i)-
>pre
dica
te,&
((*i)-
>pre
dica
te))
;if
((*i
)->b
ody)
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(( *
i)->
body
);st
atem
ent(
( *i)
->bo
dy);
} for
(i+
+;
i!=
s.ca
ses.
end(
);
i++
){
asse
rt( *i)
;ex
pres
sion
((*i)-
>pre
dica
te,&
((*i)-
>pre
dica
te))
;90
0cu
rren
tNod
e=
(Sta
teme
nt**)
&(( *
i)->
body
);st
atem
ent(
( *i)
->bo
dy);
} if(s
.def
ault
_stm
t){
curr
entN
ode
=(S
tate
ment
**)
&(s.
defa
ult_
stmt
);st
atem
ent(
s.de
faul
t_st
mt);
} retu
rnSt
atus
();
}
910
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Loop
&l)
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(l.
body
);st
atem
ent(
l.bo
dy);
retu
rnSt
atus
();
}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Repe
at&r
){
expr
essi
on(r
.cou
nt,&
(r.c
ount
));
curr
entN
ode
=(S
tate
ment
**)
&(r.
body
);st
atem
ent(
r.bo
dy);
920
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Abor
t&a
){
stat
emen
t(a.
body
);if
(a.c
ases
.siz
e()
==1)
{Pr
edic
ated
Stat
emen
t*p
s=
a.ca
ses[
0];
asse
rt(p
s);
sige
xpre
ssio
n(ps
->pr
edic
ate,
&(ps
->pr
edic
ate)
);if
(ps-
>bod
y){
930
curr
entN
ode
=(S
tate
ment
**)
&(ps
->bo
dy);
stat
emen
t(ps
->bo
dy);
}}
else
{//
Abor
tca
ses
for
(ve
ctor
<Pre
dica
tedS
tate
ment
*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
tab(
);as
sert
( *i)
;si
gexp
ress
ion(
( *i)
->pr
edic
ate,
&(( *
i)->
pred
icat
e));
940
if((
*i)-
>bod
y){
curr
entN
ode
=(S
tate
ment
**)
&(( *
i)->
body
);pr
oces
s(( *
i)->
body
);}
}} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Aw
ait&
a){
950
if(a
.cas
es.s
ize(
)==
1){
//Si
mple
abor
tco
ndit
ion
Pred
icat
edSt
atem
ent
*ps
=a.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e,&(
ps->
pred
icat
e));
if(p
s->b
ody)
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(ps
->bo
dy);
stat
emen
t(ps
->bo
dy);
}}
else
{96
0fo
r(
vect
or<P
redi
cate
dSta
teme
nt*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
asse
rt( *
i);
sige
xpre
ssio
n(( *
i)->
pred
icat
e,&(
( *i)
->pr
edic
ate)
);if
((*i
)->b
ody)
{cu
rren
tNod
e=
(Sta
teme
nt**)
&(( *
i)->
body
);pr
oces
s(( *
i)->
body
);}
}}
970
retu
rnSt
atus
();
87
A. Kommentierter Programmcode
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Loop
Each
&l)
{cu
rren
tNod
e=
(Sta
teme
nt**
)&(
l.bo
dy);
stat
emen
t(l.
body
);si
gexp
ress
ion(
l.pr
edic
ate,
&(l.
pred
icat
e));
retu
rnSt
atus
();
}
980
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Ever
y&e
){
sige
xpre
ssio
n(e.
pred
icat
e,&(
e.pr
edic
ate)
);cu
rren
tNod
e=
(Sta
teme
nt**
)&(
e.bo
dy);
stat
emen
t(e.
body
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Su
spen
d&s
){
curr
entN
ode
=(S
tate
ment
**)
&(s.
body
);st
atem
ent(
s.bo
dy);
990
sige
xpre
ssio
n(s.
pred
icat
e,&(
s.pr
edic
ate)
);re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Do
Watc
hing
&d)
{cu
rren
tNod
e=
(Sta
teme
nt**
)&(
d.bo
dy);
stat
emen
t(d.
body
);si
gexp
ress
ion(
d.pr
edic
ate,
&(d.
pred
icat
e));
if(d
.tim
eout
){
curr
entN
ode
=(S
tate
ment
**)
&(d.
time
out)
;10
00st
atem
ent(
d.ti
meou
t);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
DoUp
to&d
){
curr
entN
ode
=(S
tate
ment
**)
&(d.
body
);st
atem
ent(
d.bo
dy);
sige
xpre
ssio
n(d.
pred
icat
e,&(
d.pr
edic
ate)
);re
turn
Stat
us()
;10
10} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Tr
ap&t
){
asse
rt(t
.sym
bols
);Sy
mbol
Tabl
e::c
onst
_ite
rato
ri
=t.
symb
ols-
>beg
in()
;cu
rren
tNod
e=
(Sta
teme
nt**
)&(
t.bo
dy);
stat
emen
t(t.
body
);fo
r(v
ecto
r<Pr
edic
ated
Stat
emen
t *>:
:con
st_i
tera
tor
i=
t.ha
ndle
rs.b
egin
();
i!=
t.ha
ndle
rs.e
nd()
;i+
+)
{as
sert
( *i)
;10
20ex
pres
sion
((*i
)->p
redi
cate
,&((
*i)-
>pre
dica
te))
;cu
rren
tNod
e=
(Sta
teme
nt**)
&(( *i)
->bo
dy);
stat
emen
t(( *
i)->
body
);} re
turn
Stat
us()
;}
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Exit
&e)
{as
sert
(e.t
rap)
;10
30as
sert
(e.t
rap-
>kin
d==
Sign
alSy
mbol
::Tr
ap);
if(e
.val
ue)
{ex
pres
sion
(e.v
alue
,&(e
.val
ue))
;} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Va
r&v
){
cosy
ndat
a->h
wMod
uleT
ree.
addC
hild
(cos
ynda
ta->
hwMo
dule
Name
Pref
ix,&
v);
curr
entN
ode
=(S
tate
ment
**)
&(v.
body
);10
40st
atem
ent(
v.bo
dy);
//st
ore
the
curr
ent
scop
eco
synd
ata-
>hwM
odul
eTre
e.se
tCur
rent
Node
(cos
ynda
ta->
hwMo
dule
Tree
.get
Curr
entN
ode(
)->p
aren
t);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Sign
al&s
){
cosy
ndat
a->h
wMod
uleT
ree.
addC
hild
(cos
ynda
ta->
hwMo
dule
Name
Pref
ix,&
s);
curr
entN
ode
=(S
tate
ment
**)
&(s.
body
);st
atem
ent(
s.bo
dy);
1050
//st
ore
the
curr
ent
scop
eco
synd
ata-
>hwM
odul
eTre
e.se
tCur
rent
Node
(cos
ynda
ta->
hwMo
dule
Tree
.get
Curr
entN
ode(
)->p
aren
t);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Run
&r)
{if
(r.
type
s.si
ze()
+r.
cons
tant
s.si
ze()
+r.
func
tion
s.si
ze()
+r.
proc
edur
es.s
ize(
)+
r.ta
sks.
size
()+
r.si
gnal
s.si
ze()
>0
){
bool
more
=fa
lse;
1060
if(r
.typ
es.s
ize(
)>
0){
vect
or<T
ypeR
enam
ing *
>::c
onst
_ite
rato
ri
=r.
type
s.be
gin(
);wh
ile
(i!=
r.ty
pes.
end(
)){
asse
rt( *
i);
asse
rt((
*i)-
>new
_typ
e);
i++;
} more
=tr
ue;
}10
70if
(r.c
onst
ants
.siz
e()
>0
){
vect
or<C
onst
antR
enam
ing *
>::c
onst
_ite
rato
ri
=r.
cons
tant
s.be
gin(
);wh
ile
(i!=
r.co
nsta
nts.
end(
)){
asse
rt( *
i);
asse
rt((
*i)-
>new
_val
ue);
expr
essi
on((
*i)-
>new
_val
ue,&
((*i
)->n
ew_v
alue
));
i++;
} more
=tr
ue;
1080
} if(r
.fun
ctio
ns.s
ize(
)>
0){
88
A.1. HW/SW Co-Synthese
vect
or<F
unct
ionR
enam
ing *
>::c
onst
_ite
rato
ri
=r.
func
tion
s.be
gin(
);wh
ile
(i!=
r.fu
ncti
ons.
end(
)){
asse
rt( *
i);
asse
rt((
*i)-
>new
_fun
c);
i++;
} more
=tr
ue;
1090
} if(r
.pro
cedu
res.
size
()>
0){
vect
or<P
roce
dure
Rena
ming
*>::
cons
t_it
erat
ori
=r.
proc
edur
es.b
egin
();
whil
e(i
!=r.
proc
edur
es.e
nd()
){
asse
rt( *
i);
asse
rt((
*i)-
>new
_pro
c);
i++;
} more
=tr
ue;
1100
} if(r
.tas
ks.s
ize(
)>
0){
vect
or<P
roce
dure
Rena
ming
*>::
cons
t_it
erat
ori
=r.
task
s.be
gin(
);wh
ile
(i!=
r.ta
sks.
end(
))
{as
sert
( *i)
;as
sert
((*i)-
>new
_pro
c);
i++;
} more
=tr
ue;
1110
} if(r
.sig
nals
.siz
e()
>0)
{ve
ctor
<Sig
nalR
enam
ing *
>::c
onst
_ite
rato
ri
=r.
sign
als.
begi
n();
whil
e(i
!=r.
sign
als.
end(
))
{as
sert
( *i)
;as
sert
((*i)-
>new
_sig
);i+
+;}
}11
20} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Un
aryO
p&u
){
asse
rt(u
nary
leve
l.fi
nd(u
.op)
!=un
aryl
evel
.end
());
proc
ess(
u.so
urce
);re
turn
Stat
us()
;}
1130
Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Bina
ryOp
&b)
{as
sert
(lev
el.f
ind(
b.op
)!=
leve
l.en
d())
;pr
oces
s(b.
sour
ce1)
;pr
oces
s(b.
sour
ce2)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Lo
adVa
riab
leEx
pres
sion
&e)
{as
sert
(e.v
aria
ble)
;
retu
rnSt
atus
();
1140
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Load
Sign
alEx
pres
sion
&e)
{as
sert
(e.s
igna
l);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Load
Sign
alVa
lueE
xpre
ssio
n&e
){
asse
rt(e
.sig
nal)
;11
50re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(Li
tera
l&l
){
asse
rt(l
.typ
e);
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Func
tion
Call
&e)
{11
60as
sert
(e.c
alle
e);
vect
or<E
xpre
ssio
n *>:
:con
st_i
tera
tor
i=
e.ar
gume
nts.
begi
n();
whil
e(i
!=e.
argu
ment
s.en
d())
{ex
pres
sion
( *i,
(Exp
ress
ion *
*)&(
*i))
;i+
+;} re
turn
Stat
us()
;} St
atus
CoDe
sign
Este
relP
rint
er::
visi
t(De
lay
&e)
{11
70if
(e.i
s_im
medi
ate)
{as
sert
(e.c
ount
==NU
LL);
}el
se{
expr
essi
on(e
.cou
nt,&
e.co
unt)
;} si
gexp
ress
ion(
e.pr
edic
ate,
&(e.
pred
icat
e));
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
Chec
kCou
nter
&e)
{11
80as
sert
(e.c
ount
er);
expr
essi
on(e
.pre
dica
te,&
(e.p
redi
cate
));
retu
rnSt
atus
();
} Stat
usCo
Desi
gnEs
tere
lPri
nter
::vi
sit(
IfTh
enEl
se&s
){
expr
essi
on(s
.pre
dica
te,&
(s.p
redi
cate
));
if(s
.the
n_pa
rt)
{st
atem
ent(
s.th
en_p
art)
;}
1190
if(s
.els
e_pa
rt)
{st
atem
ent(
s.el
se_p
art)
;} re
turn
Stat
us()
;}
89
A. Kommentierter Programmcode
}
90
A.1. HW/SW Co-Synthese
A.1.9. Zwischenschritt: Logikminimierung
Mit Hilfe der Klasse MVSIS lassen sich zweistufige und mehrstufige Logikminimie-rungsverfahren auf die zu berechnenden Ausdrücke in den Hardwaremodulen anwen-den. Die Klasse implementiert dazu keine eigenen Algorithmen zur Logikminimie-rung, sondern bedient sich des externen Tools MVSIS. MVSIS unterstützt zur Ein-und Ausgabe von Logikbeschreibungen das BLIF Format. Die Funktion writeBLIFkonvertiert alle in einem Hardwaremodul vorkommenden Ausdrücke in eine BLIFDatei. Die Funktion readBLIF liest die BLIF Datei mit der minimierten Logik wie-der ein und konvertiert die Logikbeschreibung zurück nach Esterel.
91
A. Kommentierter Programmcode
A.1
.10.
CoD
esig
nLog
icM
inim
izat
ion.
hpp
#ifn
def
_LOG
ICMI
NIMI
ZATI
ON_H
PP_
#def
ine
_LOG
ICMI
NIMI
ZATI
ON_H
PP_
#inc
lude
"AST
.hpp"
#inc
lude
"CoDesignData
Structu
res.h
pp"
#inc
lude
<cma
th>
name
spac
eLo
gicM
inim
izat
ion
{
10cl
ass
Sort
edSy
mbol
Tabl
e:
publ
icAS
T::S
ymbo
lTab
le{ pu
blic
:So
rted
Symb
olTa
ble(
){}
//en
ter
symb
olal
phab
etic
ally
sort
edvo
iden
ter(
AST:
:Sym
bol
*);
//re
turn
spo
siti
onin
the
list
int
getP
os(s
td::
stri
ng);
};
20/ *
* *An
obje
ctof
this
clas
sis
thro
wnif
aner
ror
occu
rsdu
ring
logi
cmi
nimi
zati
on
*/ clas
sMV
SISE
rror
{pu
blic
:
std:
:str
ing
s;MV
SISE
rror
(std
::st
ring
ss)
:s(
ss)
{}}; / *
Perf
orms
amu
lti-
leve
llo
gic
mini
miza
tion
onea
chhw
-mod
ule
byca
llin
gth
efu
ncti
on"
minim
ize"
30*/ clas
sMV
SIS
{ priv
ate:
//Me
mber
func
tion
sar
eco
mmen
ted
inth
e.c
ppim
plem
enta
tion
file
bool
eval
uate
(AST
::Ex
pres
sion
*,So
rted
Symb
olTa
ble&
,ch
ar*
term
);vo
idge
tUse
dSym
bols
(AST
::Ex
pres
sion
*,So
rted
Symb
olTa
ble&
);Ex
pres
sion
*ge
tDel
ayEx
p(Ex
pres
sion
*);
int
writ
eOnS
et(A
ST::
Expr
essi
on*,
std:
:ost
ream
&);
int
writ
eBli
f(Mo
dule
*,st
d::s
trin
g);
40vo
idre
adBl
if(M
odul
e *,
std:
:str
ing)
;pu
blic
:MV
SIS(
);vo
idmi
nimi
ze(C
oDes
ign:
:CoD
esig
nDat
a *,
std:
:str
ing)
;};
} #end
if
92
A.1. HW/SW Co-Synthese
A.1
.11.
CoD
esig
nLog
icM
inim
izat
ion.
cpp
#inc
lude
"CoDesignLogicM
inim
ization.h
pp"
#inc
lude
<ios
trea
m>#i
nclu
de<c
stri
ng>
#inc
lude
<fst
ream
>#i
nclu
de<s
stre
am>
#inc
lude
<sys
/typ
es.h
>#i
nclu
de<u
nist
d.h>
#inc
lude
<wai
t.h>
#inc
lude
<std
lib.
h>10
name
spac
eLo
gicM
inim
izat
ion{
/ *In
sert
sa
Symb
olal
phab
etic
ally
into
the
sort
edsy
mbol
tabl
e
*/ void
Sort
edSy
mbol
Tabl
e::e
nter
(AST
::Sy
mbol
*s)
{as
sert
(s);
asse
rt(!
loca
l_co
ntai
ns(s
->na
me))
;fo
r(in
tx=
0;ab
s(x)
<si
ze()
;x+
+){
if((
*(sy
mbol
s.be
gin(
)+x)
)->n
ame.
comp
are(
s->n
ame)
>=0)
{20
symb
ols.
inse
rt(s
ymbo
ls.b
egin
()+x
,s);
retu
rn;
}} sy
mbol
s.pu
sh_b
ack(
s);
} / *Gi
ves
the
posi
tion
inth
esy
mbol
tabl
e
*/ int
Sort
edSy
mbol
Tabl
e::g
etPo
s(st
d::s
trin
gs)
{30
for(
int
x=0;
abs(
x)<
size
();
x++)
{if
((*(sy
mbol
s.be
gin(
)+x)
)->n
ame=
=s)
retu
rnx;
} retu
rn-1
;} MV
SIS:
:MVS
IS()
{}
40/ *
Calc
ulat
esth
ere
sult
ofa
Bool
ean
Func
tion
(giv
enin
expr
essi
one)
*de
pend
ing
onth
ein
put
assi
gnme
nt(g
iven
inte
rm)
*/ bool
MVSI
S::e
valu
ate(
AST:
:Exp
ress
ion *
e,So
rted
Symb
olTa
ble
&use
dSym
bols
,ch
ar*te
rm){
if(d
ynam
ic_c
ast<
AST:
:Loa
dSig
nalE
xpre
ssio
n *>(
e))
{AS
T::S
igna
lSym
bol *
Sig
=dy
nami
c_ca
st<A
ST::
Load
Sign
alEx
pres
sion
*>(e
)->s
igna
l;if
(ter
m[us
edSy
mbol
s.ge
tPos
(Sig
->na
me)]
==’0
’)re
turn
fals
e;el
sere
turn
true
;} if
(dyn
amic
_cas
t<AS
T::L
oadS
igna
lVal
ueEx
pres
sion
*>(e
)){
50AS
T::S
igna
lSym
bol *
Sig
=dy
nami
c_ca
st<A
ST::
Load
Sign
alVa
lueE
xpre
ssio
n *>(
e)->
sign
al;
if(t
erm[
used
Symb
ols.
getP
os(S
ig->
name
)]==
’0’)
retu
rnfa
lse;
else
retu
rntr
ue;
} if(d
ynam
ic_c
ast<
AST:
:Loa
dVar
iabl
eExp
ress
ion *
>(e)
){
Load
Vari
able
Expr
essi
on*
lve
=dy
nami
c_ca
st<A
ST::
Load
Vari
able
Expr
essi
on*>(e
);Co
nsta
ntSy
mbol
*cs
=dy
nami
c_ca
st<A
ST::
Cons
tant
Symb
ol*>
(lve
->va
riab
le);
asse
rt(c
s);
Lite
ral *
l;if
(l=
dyna
mic_
cast
<AST
::Li
tera
l *>(
cs->
init
iali
zer)
);
60el
seif
(lve
=dy
nami
c_ca
st<A
ST::
Load
Vari
able
Expr
essi
on*>
(cs-
>ini
tial
izer
)){
cs=
dyna
mic_
cast
<AST
::Co
nsta
ntSy
mbol
*>(l
ve->
vari
able
);as
sert
(cs)
;l
=dy
nami
c_ca
st<A
ST::
Lite
ral *
>(cs
->in
itia
lize
r);
} asse
rt(l
);//
std:
:cer
r<<
cs->
name
<<"␣"
<<l-
>val
ue<<
"\n";
if(l
->va
lue
=="1")
retu
rntr
ue;
else
retu
rnfa
lse;
}70
if(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e))
{bo
ole1
,e2;
e1=
eval
uate
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
1,us
edSy
mbol
s,te
rm);
e2=
eval
uate
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
2,us
edSy
mbol
s,te
rm);
if(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e)->
op=="or"
)re
turn
(e1|
|e2)
;if
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->op
=="an
d")
retu
rn(e
1&&e
2);
} if(d
ynam
ic_c
ast<
AST:
:Una
ryOp
*>(e
)){
retu
rn!e
valu
ate(
dyna
mic_
cast
<AST
::Un
aryO
p *>(
e)->
sour
ce,
used
Symb
ols,
term
);80
} retu
rnfa
lse;
} / *Ge
tsal
lSy
mbol
sex
pres
sion
’e’
depe
nds
onan
dst
ores
them
in’u
sedS
ymbo
ls’
*/ void
MVSI
S::g
etUs
edSy
mbol
s(AS
T::E
xpre
ssio
n *e,
Sort
edSy
mbol
Tabl
e&u
sedS
ymbo
ls){
if(d
ynam
ic_c
ast<
AST:
:Loa
dSig
nalE
xpre
ssio
n *>(
e))
{AS
T::S
igna
lSym
bol *
Sig
=dy
nami
c_ca
st<A
ST::
Load
Sign
alEx
pres
sion
*>(e
)->s
igna
l;if
(!us
edSy
mbol
s.lo
cal_
cont
ains
(Sig
->na
me))
{90
used
Symb
ols.
ente
r(Si
g);
}} if
(dyn
amic
_cas
t<AS
T::L
oadS
igna
lVal
ueEx
pres
sion
*>(e
)){
AST:
:Sig
nalS
ymbo
l *Si
g=
dyna
mic_
cast
<AST
::Lo
adSi
gnal
Valu
eExp
ress
ion *
>(e)
->si
gnal
;if
(!us
edSy
mbol
s.lo
cal_
cont
ains
(Sig
->na
me))
{us
edSy
mbol
s.en
ter(
Sig)
;}
} if(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e))
{10
0ge
tUse
dSym
bols
(dyn
amic
_cas
t<AS
T::B
inar
yOp *
>(e)
->so
urce
1,us
edSy
mbol
s);
getU
sedS
ymbo
ls(d
ynam
ic_c
ast<
AST:
:Bin
aryO
p *>(
e)->
sour
ce2,
used
Symb
ols)
;} if
(dyn
amic
_cas
t<AS
T::U
nary
Op*>
(e))
{ge
tUse
dSym
bols
(dyn
amic
_cas
t<AS
T::U
nary
Op*>
(e)-
>sou
rce,
used
Symb
ols)
;
93
A. Kommentierter Programmcode
}} / *
retu
rns
adi
sjun
ctio
nte
rmof
all
Sign
alSy
mbol
sin
’e’
*/11
0Ex
pres
sion
*MV
SIS:
:get
Dela
yExp
(Exp
ress
ion
*e){
Expr
essi
on*de
lay
=ne
wLo
adSi
gnal
Expr
essi
on(N
ULL,
new
Sign
alSy
mbol
("tick",
NULL
,AST
::Si
gnal
Symb
ol::
Inpu
t,NU
LL,
NULL
));
Sort
edSy
mbol
Tabl
esi
gnal
Tabl
e;ge
tUse
dSym
bols
(e,s
igna
lTab
le);
for(
unsi
gned
int
i=
0;i
<si
gnal
Tabl
e.si
ze()
;i+
+){
if(i
==0)
dela
y=
new
Load
Sign
alEx
pres
sion
(NUL
L,(S
igna
lSym
bol *
)sig
nalT
able
.sym
bols
[i])
;el
sede
lay
=ne
wBi
nary
Op(N
ULL,
120
"or"
,de
lay,
new
Load
Sign
alEx
pres
sion
(NUL
L,(S
igna
lSym
bol *
)sig
nalT
able
.sym
bols
[i])
);} re
turn
dela
y;} / *
Calc
late
sth
emi
nter
msof
afu
ncti
ongi
ven
inex
pres
sion
’e’
and
writ
esth
emto
the
*ou
tput
file
stre
am’o
fs’
*@r
etur
n-1
ifca
lcul
atio
nfa
ils
130
*/ int
MVSI
S::w
rite
OnSe
t(AS
T::E
xpre
ssio
n *e,
std:
:ost
ream
&os
){
int
z,n,
numb
erOf
Ones
;So
rted
Symb
olTa
ble
used
Symb
ols;
getU
sedS
ymbo
ls(e
,use
dSym
bols
);if
(use
dSym
bols
.siz
e()
>20
)re
turn
-1;
//to
oma
nysy
mbol
sfo
r(i
ntmi
nter
m=0;
mint
erm
<po
w(2,
used
Symb
ols.
size
());
mint
erm+
+){
z=mi
nter
m;nu
mber
OfOn
es=
0;14
0ch
ar*
term
=ne
wch
ar[u
sedS
ymbo
ls.s
ize(
)+1]
;te
rm[u
sedS
ymbo
ls.s
ize(
)]=’
\0’;
for
(int
x=us
edSy
mbol
s.si
ze()
-1;
x>=0
;x-
-){
n=z%
2;z=
z/2;
if(n
==0)
{te
rm[x
]=’0
’;} el
se{
term
[x]=
’1’;
150
numb
erOf
Ones
++;
}} if
(eva
luat
e(e,
used
Symb
ols,
term
)){
os<<
term
<<"␣1\n";
}} re
turn
0;}
160
/ * *Wr
ites
all
expr
essi
ons
inth
ehw
-mod
ule
toa
file
inbl
iffo
rmat
usin
gth
efo
llow
ing
patt
ern:
*-
sust
ain
s(e)
:s
isth
efu
ncti
ons
name
and
eth
efu
ncti
on
*-
ever
ye
doem
its
end:
sis
the
func
tion
name
and
eis
the
func
tion
* *@p
aram
mTh
ehw
-mod
ule
*@p
aram
file
The
dest
inat
ion
file
name
*@r
etur
nRe
turn
s-1
ifwr
itin
gfa
ils,
0ot
herw
ise
*/17
0in
tMV
SIS:
:wri
teBl
if(A
ST::
Modu
le*m
,std
::st
ring
file
){st
d::o
stri
ngst
ream
inpu
ts;
std:
:ost
ring
stre
amou
tput
s;st
d::o
stri
ngst
ream
trut
htab
le;
Sort
edSy
mbol
Tabl
ein
putS
ymbo
ls;
AST:
:Par
alle
lSta
teme
ntLi
st*ps
l;AS
T::S
tate
ment
List
*ss
l;AS
T::E
very
*es
t;AS
T::S
usta
in*su
st;
180
//br
ing
hw.m
odul
ein
toa
unif
orm
stru
ctur
e//
(thi
sis
nece
ssar
ywh
enth
ehw
-mod
ule
has
just
one
thre
ad)
if((
psl=
dyna
mic_
cast
<AST
::Pa
rall
elSt
atem
entL
ist *
>(m-
>bod
y)))
;el
seif
((es
t=dy
nami
c_ca
st<A
ST::
Ever
y *>(
m->b
ody)
)){
psl=
new
AST:
:Par
alle
lSta
teme
ntLi
st()
;ps
l->t
hrea
ds.p
ush_
back
(est
);m-
>bod
y=ps
l;} el
seif
((su
st=d
ynam
ic_c
ast<
AST:
:Sus
tain
*>(m
->bo
dy))
){
190
psl=
new
AST:
:Par
alle
lSta
teme
ntLi
st()
;ps
l->t
hrea
ds.p
ush_
back
(ssl
);m-
>bod
y=ps
l;} el
seif
(dyn
amic
_cas
t<AS
T::V
aria
bleS
ymbo
l *>(
m->b
ody)
);
else
thro
wMV
SISE
rror
("MVSIS
Error:␣
Error␣
in␣H
WMod
ule␣
stru
ctu
re")
;
//wr
ite
comb
inat
oria
llo
gic
func
tion
sfo
r(un
sign
edin
tx=
0;x
<ps
l->t
hrea
ds.s
ize(
);x+
+){
//i.
e.if
sign
alex
pres
sion
isca
lcul
ated
200
if((
est
=dy
nami
c_ca
st<A
ST::
Ever
y *>(
psl-
>thr
eads
[x])
)){
AST:
:Del
ay*de
=dy
nami
c_ca
st<A
ST::
Dela
y *>(
est-
>pre
dica
te);
Sort
edSy
mbol
Tabl
eus
edSy
mbol
s;AS
T::E
xpre
ssio
n*e
=de
->pr
edic
ate;
getU
sedS
ymbo
ls(e
,us
edSy
mbol
s);
//de
clar
eth
ene
wfu
ncti
on..
.tr
utht
able
<<".nam
es␣";
for(
unsi
gned
int
y=0;
y<us
edSy
mbol
s.si
ze()
;y++
){21
0//
...
byfi
rst
writ
ing
ali
stof
para
mete
rs..
.tr
utht
able
<<dy
nami
c_ca
st<A
ST::
Sign
alSy
mbol
*>( *
(use
dSym
bols
.sym
bols
.beg
in()
+y))
->na
me<<
"␣";
if(!
inpu
tSym
bols
.loc
al_c
onta
ins(
94
A.1. HW/SW Co-Synthese
dyna
mic_
cast
<AST
::Si
gnal
Symb
ol*>
( *(u
sedS
ymbo
ls.s
ymbo
ls.b
egin
()+y
))->
name
)){
inpu
tSym
bols
.ent
er(d
ynam
ic_c
ast<
AST:
:Sig
nalS
ymbo
l *>(*(
used
Symb
ols.
symb
ols.
begi
n()+
y))
);}
} //..
.fo
llow
edby
the
func
tion
name
trut
htab
le<<
dyna
mic_
cast
<AST
::Em
it*>(e
st->
body
)->s
igna
l->n
ame;
220
//de
clar
efu
ncti
onna
meas
outp
utou
tput
s<<
dyna
mic_
cast
<AST
::Em
it*>
(est
->bo
dy)-
>sig
nal-
>nam
e<<
"␣";
//wr
ite
the
trut
htab
leof
the
func
tion
trut
htab
le<<
"\n";
if(w
rite
OnSe
t(e,
trut
htab
le)
==-1
)re
turn
-1;
} //if
data
expr
essi
onis
calc
ulat
edel
se{
sust
=dy
nami
c_ca
st<A
ST::
Sust
ain *
>(ps
l->t
hrea
ds[x
]);
230
Sort
edSy
mbol
Tabl
eus
edSy
mbol
s;AS
T::E
xpre
ssio
n*e
=su
st->
valu
e;ge
tUse
dSym
bols
(e,
used
Symb
ols)
;
//de
clar
ene
wfu
ncti
on..
.tr
utht
able
<<".nam
es␣";
//..
.ad
dpa
rame
ter
name
sbe
ginn
ing
with
anun
ders
core
toid
enti
fyda
taex
pres
sion
sdu
ring
//re
adin
g..
.fo
r(un
sign
edin
ty=
0;y<
used
Symb
ols.
size
();y
++){
Sign
alSy
mbol
*ar
gume
nt=
dyna
mic_
cast
<AST
::Si
gnal
Symb
ol*>( *
(use
dSym
bols
.sym
bols
.beg
in()
+y))
;24
0Si
gnal
Symb
ol*
bool
Argu
ment
=ne
wSi
gnal
Symb
ol("_
"+ar
gume
nt->
name
,ar
gume
nt->
type
,(A
ST::
Sign
alSy
mbol
::ki
nds)
argu
ment
->ki
nd,
NULL
,NU
LL);
trut
htab
le<<
bool
Argu
ment
->na
me<<
"␣";
if(!
inpu
tSym
bols
.loc
al_c
onta
ins(
bool
Argu
ment
->na
me))
{in
putS
ymbo
ls.e
nter
(boo
lArg
umen
t);
}25
0} //
...
foll
owed
byth
efu
ctio
nna
me(a
lso
begi
nnin
gwi
than
unde
rsco
re)
trut
htab
le<<
"_"
<<su
st->
sign
al->
name
;ou
tput
s<<
"_"
<<su
st->
sign
al->
name
<<"␣";
trut
htab
le<<
"\n";
if(w
rite
OnSe
t(e,
trut
htab
le)
==-1
)re
turn
-1;
}}
260
for(
unsi
gned
int
y=0;
y<in
putS
ymbo
ls.s
ize(
);y+
+){
inpu
ts<<
dyna
mic_
cast
<AST
::Si
gnal
Symb
ol*>
( *(i
nput
Symb
ols.
symb
ols.
begi
n()+
y))-
>nam
e<<
"␣
";} //
Open
outp
utfi
lean
dwr
ite
data
std:
:ofs
trea
mof
s(fi
le.c
_str
());
if(!
ofs)
thro
wMV
SISE
rror
("MVSIS
Error:␣
Can
’t␣open
␣outp
ut␣
file
:␣"+
file
);of
s<<
".mod
el␣"
<<fi
le<<
"\n";
ofs
<<".inp
uts␣";
270
ofs
<<in
puts
.str
();
ofs
<<"\n.outp
uts
␣";
ofs
<<ou
tput
s.st
r();
ofs
<<"\n"
<<tr
utht
able
.str
();
ofs
<<"\n.e
nd\n";
ofs.
flus
h();
ofs.
clos
e();
retu
rn0;
}
280
void
MVSI
S::r
eadB
lif(
Modu
le*m,
std:
:str
ing
file
){st
d::s
trin
gli
ne,l
ongl
ine,
toke
n;So
rted
Symb
olTa
ble
func
Args
;AS
T::S
igna
lSym
bol
*loc
alSi
gnal
,*f
uncS
ymbo
l;AS
T::E
xpre
ssio
n*exp
ress
ion,
*ter
m,*var
;AS
T::L
oadV
aria
bleE
xpre
ssio
n*c
onst
True
, *co
nstF
alse
;bo
olis
Pure
=tr
ue;
//tr
ueif
func
tion
ispu
re
AST:
:Par
alle
lSta
teme
ntLi
st*bo
dy=
new
AST:
:Par
alle
lSta
teme
ntLi
st()
;AS
T::S
igna
l*s
cope
=NU
LL;
290
//De
clar
eco
nsta
nts
true
and
fals
eco
nstT
rue
=ne
wLo
adVa
riab
leEx
pres
sion
(ne
wCo
nsta
ntSy
mbol
("true",
new
Type
Symb
ol("boolean")
,ne
wLi
tera
l("1",
new
Type
Symb
ol("boolean")
)))
;co
nstF
alse
=ne
wLo
adVa
riab
leEx
pres
sion
(ne
wCo
nsta
ntSy
mbol
(30
0"fa
lse",
new
Type
Symb
ol("boolean")
,ne
wLi
tera
l("0",
new
Type
Symb
ol("boolean")
))
);
//op
enin
put
file
std:
:ifs
trea
mif
s(fi
le.c
_str
());
if(!
ifs)
thro
wMV
SISE
rror
("MVSIS
Error:␣
Can
’t␣open
␣in
put␣fi
le:␣
"+fi
le);
310
std:
:get
line
(ifs
,lin
e,’\
n’);
//re
adfi
rst
inpu
tli
ne//
whil
een
dof
file
isn’
tre
ache
dwh
ile(
(lin
e.co
mpar
e(".end")
!=0)
&&(l
ine.
comp
are(".e")
!=0)
){//
reas
semb
lewr
appe
dli
nes
whil
e(l
ine[
line
.siz
e()-
1]==
’\\’
){
long
line
=li
ne;
std:
:get
line
(ifs
,lin
e,’\
n’);
long
line
.rep
lace
(lon
glin
e.si
ze()
-1,l
ongl
ine.
size
()-1
,lin
e);
line
=lo
ngli
ne;
}32
0st
d::i
stri
ngst
ream
line
Str(
line
);
95
A. Kommentierter Programmcode
line
Str
>>to
ken;
//re
adfi
rst
toke
nfr
omin
put
line
//re
adin
func
tion
decl
arat
ion
(par
amet
ers
and
name
)if
(tok
en.c
ompa
re(".nam
es")
==0)
{wh
ile(
line
Str
>>to
ken)
{if
(tok
en[0
]==’
_’)
{is
Pure
=fa
lse;
toke
n=
toke
n.er
ase(
0,1)
;st
d::c
err
<<to
ken
<<"\n";
330
} //if
sign
alis
not
loca
lif
(!((
toke
n[0]
==’[
’)&&
(tok
en[t
oken
.siz
e()-
1]==
’]’)
)){
if(m
->si
gnal
s->l
ocal
_con
tain
s(to
ken)
){
//th
ela
stto
ken
isth
efu
ncti
onna
meif
(!li
neSt
r.eo
f())
{fu
ncAr
gs.e
nter
(m->
sign
als-
>get
(tok
en))
;Si
gnal
Symb
ol*s
;if
((s
=dy
nami
c_ca
st<A
ST::
Sign
alSy
mbol
*>(m
->si
gnal
s->g
et(t
oken
)))-
>kin
d==
Sign
alSy
mbol
::Ou
tput
)s-
>kin
d=
Sign
alSy
mbol
::In
puto
utpu
t;34
0} el
sefu
ncSy
mbol
=dy
nami
c_ca
st<A
ST::
Sign
alSy
mbol
*>(m
->si
gnal
s->g
et(t
oken
));
}el
se{
func
Args
.ent
er(s
cope
->sy
mbol
s->g
et(t
oken
));
}} //
else
(if
sign
alis
loca
li.
e.if
aco
mmon
sube
xpre
ssio
nwa
sex
trac
ted)
else
{if
(sco
pe==
NULL
){
scop
e=
new
AST:
:Sig
nal(
);35
0sc
ope-
>sym
bols
=ne
wAS
T::S
ymbo
lTab
le()
;sc
ope-
>bod
y=bo
dy;
} //co
nver
tsi
gnal
name
into
ava
lid
este
rel
sign
alna
meto
ken.
eras
e(0,
1);
toke
n.er
ase(
toke
n.si
ze()
-1,1
);to
ken="temp_
"+to
ken;
//ma
kesi
gnal
name
uniq
uewi
thin
the
modu
lest
d::s
trin
gpo
stfi
x="";
int
x=0;
360
whil
e(m-
>sig
nals
->lo
cal_
cont
ains
(tok
en+p
ostf
ix))
{st
d::o
stri
ngst
ream
s;s
<<"_
"<<
x;po
stfi
x=
s.st
r();
x++;
} toke
n+=p
ostf
ix;
if(s
cope
->sy
mbol
s->l
ocal
_con
tain
s(to
ken)
){
loca
lSig
nal
=(S
igna
lSym
bol *
)sc
ope-
>sym
bols
->ge
t(to
ken)
;37
0}
else
{if
(isP
ure)
{lo
calS
igna
l=
new
AST:
:Sig
nalS
ymbo
l(to
ken,
NULL
,AST
::Si
gnal
Symb
ol::
Loca
l,NU
LL,N
ULL)
;}
else
{lo
calS
igna
l=
new
AST:
:Sig
nalS
ymbo
l(to
ken,
new
Type
Symb
ol("boolean")
,AST
::Si
gnal
Symb
ol::
Loca
l,NU
LL,N
ULL)
;} //
ifno
tal
read
yin
clud
ed,
add
to’s
igna
l’-s
tate
ment
if(!
scop
e->s
ymbo
ls->
loca
l_co
ntai
ns(t
oken
)){s
cope
->sy
mbol
s->e
nter
(loc
alSi
gnal
);}
380
} //th
ela
stsi
gnal
name
isth
efu
ctio
nna
meif
(!li
neSt
r.eo
f())
{fu
ncAr
gs.e
nter
(loc
alSi
gnal
);} el
sefu
ncSy
mbol
=lo
calS
igna
l;}
} if(s
cope
==NU
LL)
{m-
>bod
y=bo
dy;
390
}el
se{
m->b
ody=
scop
e;} //
iffu
ncti
onis
cons
tant
if(f
uncA
rgs.
size
()==
0){
std:
:get
line
(ifs
,lin
e,’\
n’);
//ge
tfi
rst
cube
from
trut
hta
ble
if(l
ine.
comp
are("1")
==0)
{//
iffu
ncti
onis
cons
tant
fals
eif
(fun
cSym
bol-
>typ
e==
NULL
){//
iffu
ncti
onis
sign
alex
pres
sion
body
->th
read
s.pu
sh_b
ack(
new
AST:
:Sus
tain
(fun
cSym
bol,
NULL
));
400
}el
se{
//if
func
tion
isbo
olea
nbo
dy->
thre
ads.
push
_bac
k(ne
wAS
T::S
usta
in(f
uncS
ymbo
l,co
nstT
rue)
);} st
d::g
etli
ne(i
fs,l
ine,
’\n’
);} el
se{
//if
func
tion
isco
nsta
nttr
ueif
(!fu
ncSy
mbol
->ty
pe==
NULL
){//
iffu
ncti
onis
sign
alex
pres
sion
body
->th
read
s.pu
sh_b
ack(
new
AST:
:Sus
tain
(fun
cSym
bol,
cons
tFal
se))
;} st
d::g
etli
ne(i
fs,l
ine,
’\n’
);41
0}
} //el
sebu
ild
SoP
from
the
trut
hta
ble
else
{st
d::g
etli
ne(i
fs,l
ine,
’\n’
);//
get
firs
tcu
befr
omtr
uth
tabl
ein
tx=
0;//
whil
eth
ere
are
cube
son
the
trut
hta
ble
ofth
ecu
rren
tfu
ncti
onwh
ile(
(lin
e.co
mpar
e(".end")
!=0)
&&(l
ine.
comp
are(".e")
!=0)
&&(l
ine.
find
(".nam
es")
==st
d::s
trin
g::n
pos)
)42
0{
term
=NUL
L;fo
r(i
ntpo
s=0;
abs(
pos)
<fun
cArg
s.si
ze()
;pos
++)
{va
r=NU
LL;
//if
para
mete
ris
nega
ted
for
this
prod
uct
term
if(l
ine[
pos]
==’0
’){
if(f
uncS
ymbo
l->t
ype
==NU
LL)
{//
iffu
ncti
onis
sign
alex
pres
sion
var=
new
AST:
:Una
ryOp
(NUL
L,"not"
,ne
wAS
T::L
oadS
igna
lExp
ress
ion(
96
A.1. HW/SW Co-Synthese
430
NULL
,(AS
T::S
igna
lSym
bol *
) *(f
uncA
rgs.
symb
ols.
begi
n()+
pos)
));
}el
se{
//if
func
tion
isva
lued
expr
essi
onva
r=ne
wAS
T::U
nary
Op(N
ULL,
"not"
,ne
wAS
T::L
oadS
igna
lVal
ueEx
pres
sion
((A
ST::
Sign
alSy
mbol
*)*(
func
Args
.sym
bols
.beg
in()
+pos
)));
}}
440
//if
para
mete
ris
nega
ted
for
this
prod
uct
term
if(l
ine[
pos]
==’1
’){
if(f
uncS
ymbo
l->t
ype
==NU
LL)
{//
iffu
ncti
onis
sign
alex
pres
sion
var=
new
AST:
:Loa
dSig
nalE
xpre
ssio
n(NU
LL,(
AST:
:Sig
nalS
ymbo
l *) *
(fun
cArg
s.sy
mbol
s.be
gin(
)+po
s));
} else
{//
iffu
ncti
onis
valu
edex
pres
sion
var=
new
AST:
:Loa
dSig
nalV
alue
Expr
essi
on(
(AST
::Si
gnal
Symb
ol*)*(
func
Args
.sym
bols
.beg
in()
+pos
)45
0);
}} //
add
para
mete
rto
the
prod
uct
term
if(v
ar!=
NULL
){if
(!((
dyna
mic_
cast
<AST
::Bi
nary
Op*>
(ter
m))|
|(d
ynam
ic_c
ast<
AST:
:Loa
dSig
nalE
xpre
ssio
n *>(
term
))||
(dyn
amic
_cas
t<AS
T::L
oadS
igna
lVal
ueEx
pres
sion
*>(t
erm)
)||
(dyn
amic
_cas
t<AS
T::U
nary
Op*>(t
erm)
)))
460
{te
rm=
var;
}el
se{
term
=ne
wAS
T::B
inar
yOp(
NULL
,"an
d",
term
,var
);}
}
} //su
mup
term
sif
(x==
0){
470
expr
essi
on=
term
;} el
se{
expr
essi
on=
new
AST:
:Bin
aryO
p(NU
LL,"or"
,exp
ress
ion,
term
);} st
d::g
etli
ne(i
fs,l
ine,
’\n’
);x+
+;}
//if
func
tion
symb
olis
pure
if(f
uncS
ymbo
l->t
ype
==NU
LL){
480
body
->th
read
s.pu
sh_b
ack(
new
AST:
:Eve
ry(n
ewAS
T::E
mit(
func
Symb
ol,N
ULL)
,ne
wAS
T::D
elay
(NUL
L,ex
pres
sion
,NUL
L,tr
ue,N
ULL)
));
}
//if
func
tion
symb
olis
valu
edel
se{
Sust
ain *
sust
ain
=ne
wSu
stai
n(fu
ncSy
mbol
,exp
ress
ion)
;bo
dy->
thre
ads.
push
_bac
k(su
stai
n);
}49
0fu
ncAr
gs.c
lear
();
isPu
re=
true
;}
} else
std:
:get
line
(ifs
,lin
e,’\
n’);
}} / *
500
*Pe
rfor
msa
mult
i-le
vel
logi
cmi
nimi
zati
onon
each
hw-m
odul
e
*@p
aram
csd
*@p
aram
file
name
_pre
fix
Apr
efix
tona
meth
ebl
iffi
les
*/ void
MVSI
S::m
inim
ize(
CoDe
sign
::Co
Desi
gnDa
ta*cs
d,st
d::s
trin
gfi
lena
me_p
refi
x){
//Ge
tth
emo
dule
list
cons
titu
ting
the
part
itio
ned
prog
ram
from
the
shar
edda
tast
ruct
ure
AST:
:Mod
ules
modu
les
=cs
d->c
onvM
odul
es;
AST:
:Mod
ule *
m;st
d::v
ecto
r<AS
T::M
odul
e *>:
:ite
rato
ri;
//it
erat
eov
erHW
-mod
ules
510
for(
i=
modu
les.
modu
les.
begi
n();
i!=
(mod
ules
.mod
ules
.end
()-1
);i+
+){
m=
dyna
mic_
cast
<AST
::Mo
dule
*>( *
i);
//wr
ite
hw-m
odul
eto
blif
file
if(w
rite
Blif
(m,f
ilen
ame_
pref
ix+".bli
f")
==0)
{
//ca
llmv
sis
inor
der
tomi
nimi
zeth
ebl
iffi
levi
ath
eex
ecvp
syst
emca
llpi
d_t
cpid
;in
tst
atus
;ch
ar*ar
gs[]
={"mvsis\0",
"−t\
0",
"blif\0",
"−T\0",
"blif\0",
"−c\0",
"fu
llsim
p;fx
u\0",
"−o\0",
"\0",
"\0",
NULL
};52
0st
d::s
trin
gmv
sisE
xe="mvsis";
std:
:str
ing
fn1,
fn2,
pwd;
pwd
=ge
tenv
("PWD")
;pw
d+=
"/";
fn1
=pw
d+fi
lena
me_p
refi
x+".bli
f";
fn2
=pw
d+fi
lena
me_p
refi
x+"_min.blif";
args
[8]
=co
nst_
cast
<cha
r *>(
fn2.
c_st
r())
;ar
gs[9
]=
cons
t_ca
st<c
har *
>(fn
1.c_
str(
));
530
swit
ch(c
pid
=fo
rk()
){ ca
se-1
:th
row
MVSI
SErr
or("MVSIS
Error:␣
Execution␣of␣
mvsis␣fa
iled")
;ca
se0:
exec
vp(m
vsis
Exe.
c_st
r(),
args
);br
eak;
defa
ult:
if(w
aitp
id(c
pid,
&sta
tus,
0)==
-1)
thro
w
97
A. Kommentierter Programmcode
540
MVSI
SErr
or("MVSIS
Error:␣
Execution␣of␣
mvsis␣fa
iled")
;if
(!WI
FEXI
TED(
stat
us))
thro
wMV
SISE
rror
("MVSIS
Error:␣
Execution␣of␣
mvsis␣fa
iled.␣
Sta
tus␣is
:␣"+
stat
us);
} std:
:cer
r<<
"MVSIS␣finished.␣
Reading...\
n";
//re
admi
nimi
zed
hw-m
odul
efr
ombl
iffi
le
read
Blif
(m,f
ilen
ame_
pref
ix+"_min.blif")
;} el
sest
d::c
err
<<"Module␣"
<<m-
>sym
bol-
>nam
e<<
"␣not␣
minim
ized.\
n";
550
} std:
:cer
r<<
"minim
ize()
␣finished.\
n";
}}
98
A.1. HW/SW Co-Synthese
A.1.12. HW/SW Synthese
Im zweiten Schritt der Co-Synthese wird aus den Hardwaremodulen des partitionier-ten Esterel Programms eine VHDL Beschreibung des Logikblocks erzeugt. Ausdem Softwaremodul werden zunächst einige überflüssige Statements entfernt (vgl.Abschnitt 3.3.2) bevor es direkt ausgegeben wird.
99
A. Kommentierter Programmcode
A.1
.13.
CoD
esig
n-hw
swsy
nthe
sis.cp
p
#inc
lude
"IR
.hpp"
#inc
lude
"AST
.hpp"
#inc
lude
"CoDesignHW
SW
Printer.h
pp"
#inc
lude
<ios
trea
m>#i
nclu
de<s
tdli
b.h>
#inc
lude
<fst
ream
>
/ *Th
ispr
ogra
mre
ads
inth
eAS
Tof
the
part
itio
ned
Este
rel
prog
ram
from
anXM
Lfi
lean
dwr
ites
*th
emo
difi
edEs
tere
lpr
ogra
mfo
rsw
synt
hesi
sto
’std
out’
and
aVH
DLde
scri
ptio
nof
the
logi
c10
*bl
ock
for
hwsy
nthe
sis
toa
file
*@p
aram
name
for
the
VHDL
file
*/ int
main
(int
argc
,ch
ar*
argv
[])
{tr
y{
IR::
XMLi
stre
amr(
std:
:cin
);IR
::No
de*n
;r
>>n;
20if
(arg
c!=
2)th
row
IR::
Erro
r("Wrong
␣number␣of␣
arg
uments
");
std:
:ofs
trea
mhw
Out(
argv
[1])
;if
(!hw
Out)
thro
wIR
::Er
ror("Can
’t␣open
␣outp
ut␣
file
");
AST:
:AST
Node
*an
=dy
nami
c_ca
st<A
ST::
ASTN
ode *
>(n)
;if
(!an
)th
row
IR::
Erro
r("Root␣
node␣is
␣not␣
an␣A
ST␣node")
;
CoDe
sign
::Co
Desi
gnHW
SWPr
inte
rp(
std:
:cou
t,hw
Out)
;30
an->
welc
ome(
p);
hwOu
t.cl
ose(
);
}ca
tch
(IR:
:Err
or&e
){
std:
:cer
r<<
e.s
<<st
d::e
ndl;
exit
(-1)
;} re
turn
0;40
}
100
A.1. HW/SW Co-Synthese
A.1
.14.
CoD
esig
nHW
SW
er.h
pp
#ifn
def
_COD
ESIG
N_VH
DL_P
RINT
ER_H
PP#
defi
ne_C
ODES
IGN_
VHDL
_PRI
NTER
_HPP
#in
clud
e"A
ST.h
pp"
#in
clud
e<i
ostr
eam>
#in
clud
e<v
ecto
r>#
incl
ude
<map
>#
incl
ude
<sst
ream
>
10na
mesp
ace
CoDe
sign
{
usin
gst
d::v
ecto
r;us
ing
std:
:map
;us
ing
std:
:str
ing;
usin
gna
mesp
ace
AST;
clas
sVH
DLLo
gicB
lock
{pu
blic
:20
VHDL
Logi
cBlo
ck()
{};
~VHD
LLog
icBl
ock(
){};
stri
ngna
me;
Symb
olTa
ble
inpu
tSig
nals
;Sy
mbol
Tabl
eva
lued
Inpu
tSig
nals
;Sy
mbol
Tabl
eou
tput
Sign
als;
Symb
olTa
ble
valu
edOu
tput
Sign
als;
Symb
olTa
ble
loca
lSig
nals
;st
d::o
stri
ngst
ream
impl
emen
tati
on;
frie
ndst
d::o
stre
am&
oper
ator
<<(s
td::
ostr
eam
&o,
cons
tVH
DLLo
gicB
lock
&lb)
;30
}; / *Th
iscl
ass
isus
edin
the
seco
ndst
epfo
rsw
-an
dhw
-syn
thes
is
*Gi
ven
the
AST
ofth
epa
rtit
ione
dpr
ogra
mto
the
’pro
cess
’fu
ncti
on,
the
swmo
dule
is
*pr
ited
toth
eou
tput
stre
amo
and
the
VHDL
desc
ript
ion
ofth
elo
gic
bloc
kis
prin
ted
to
*th
ehw
Modu
leou
tst
ream
.Du
ring
prin
ting
the
sw-m
odul
esu
perf
luou
sst
atem
ents
are
omit
ted.
*Th
elo
gic
bloc
kis
gene
rate
dfr
omth
ehw
-mod
ules
.
* */ clas
sCo
Desi
gnHW
SWPr
inte
r:
publ
icVi
sito
r{
40st
d::o
stre
am&o
;//
Outp
utSt
ream
for
SWMo
dule
std:
:ost
ream
&hwM
odul
eOut
;//
Outp
utSt
ream
for
HWMo
dule
unsi
gned
int
inde
ntle
vel;
std:
:vec
tor<
int>
prec
eden
ce;
std:
:map
<str
ing,
int>
leve
l;st
d::m
ap<s
trin
g,in
t>un
aryl
evel
;
VHDL
Logi
cBlo
ckvh
dlCo
de;
50bo
olis
SWMo
dule
;//
flag
indi
cate
sif
SW-
orHW
-Mod
ule
iscu
rren
tly
proc
esse
d,//
for
prin
ting
the
sw-m
odul
e,th
evi
sito
rme
thod
sar
e
//si
mila
rto
the
CEC’
sEs
tere
lPri
nter
exce
ptso
mech
ange
s//
for
remo
ving
some
supe
rflu
ous
stat
emen
tsSy
mbol
Tabl
e*u
sedS
ymbo
ls;
//st
ores
all
inth
eEs
tere
lpr
ogra
mus
edsy
mbol
spu
blic
:Co
Desi
gnHW
SWPr
inte
r(st
d::o
stre
am&,
std:
:ost
ream
&);
virt
ual
~CoD
esig
nHWS
WPri
nter
(){}
stri
ngge
tUni
queS
igNa
me(s
trin
g,Sy
mbol
Tabl
e *);
60us
ing
Visi
tor:
:vis
it;
//Br
ing
the
Visi
tor’
svi
sit
meth
odin
tosc
ope
void
proc
ess(
ASTN
ode *
n){
asse
rt(n
);n-
>wel
come
( *th
is);
}vo
idst
atem
ent(
Stat
emen
t*)
;vo
idex
pres
sion
(Exp
ress
ion
*);
void
sige
xpre
ssio
n(Ex
pres
sion
*);
stat
icco
nst
int
sequ
enti
alPr
eced
ence
=2;
stat
icco
nst
int
para
llel
Prec
eden
ce=
1;
70bo
olpu
sh_p
rece
denc
e(in
t);
void
pop_
prec
eden
ce()
;
Stat
usvi
sit(
Modu
leSy
mbol
&);
Stat
usvi
sit(
Vari
able
Symb
ol&)
;St
atus
visi
t(Bu
ilti
nCon
stan
tSym
bol&
);St
atus
visi
t(Bu
ilti
nSig
nalS
ymbo
l&);
Stat
usvi
sit(
Buil
tinT
ypeS
ymbo
l&);
Stat
usvi
sit(
Buil
tinF
unct
ionS
ymbo
l&);
Stat
usvi
sit(
Type
Rena
ming
&);
80St
atus
visi
t(Co
nsta
ntRe
nami
ng&)
;St
atus
visi
t(Fu
ncti
onRe
nami
ng&)
;St
atus
visi
t(Pr
oced
ureR
enam
ing
&);
Stat
usvi
sit(
Sign
alRe
nami
ng&)
;St
atus
visi
t(Pr
edic
ated
Stat
emen
t&)
;St
atus
visi
t(Ta
skCa
ll&)
;
Stat
usvi
sit(
Modu
le&)
;St
atus
visi
t(Ex
clus
ion&
);St
atus
visi
t(Im
plic
atio
n&);
90St
atus
visi
t(Mo
dule
s&);
Stat
usvi
sit(
Symb
olTa
ble&
);
Stat
usvi
sit(
Type
Symb
ol&)
;St
atus
visi
t(Co
nsta
ntSy
mbol
&);
Stat
usvi
sit(
Sign
alSy
mbol
&);
Stat
usvi
sit(
Func
tion
Symb
ol&)
;St
atus
visi
t(Pr
oced
ureS
ymbo
l&);
Stat
usvi
sit(
Task
Symb
ol&)
;
100
Stat
usvi
sit(
Stat
emen
tLis
t&);
Stat
usvi
sit(
Para
llel
Stat
emen
tLis
t&);
101
A. Kommentierter Programmcode
Stat
usvi
sit(
Noth
ing&
);St
atus
visi
t(Pa
use&
);St
atus
visi
t(Ha
lt&)
;St
atus
visi
t(Em
it&)
;St
atus
visi
t(Su
stai
n&);
Stat
usvi
sit(
Assi
gn&)
;St
atus
visi
t(St
artC
ount
er&)
;11
0St
atus
visi
t(Pr
oced
ureC
all&
);St
atus
visi
t(Ex
ec&)
;St
atus
visi
t(Pr
esen
t&);
Stat
usvi
sit(
If&)
;St
atus
visi
t(Lo
op&)
;St
atus
visi
t(Re
peat
&);
Stat
usvi
sit(
Abor
t&);
Stat
usvi
sit(
Awai
t&);
Stat
usvi
sit(
Loop
Each
&);
Stat
usvi
sit(
Ever
y&);
120
Stat
usvi
sit(
Susp
end&
);St
atus
visi
t(Do
Watc
hing
&);
Stat
usvi
sit(
DoUp
to&)
;St
atus
visi
t(Tr
ap&)
;St
atus
visi
t(Ex
it&)
;St
atus
visi
t(Va
r&);
Stat
usvi
sit(
Sign
al&)
;St
atus
visi
t(Ru
n&);
Stat
usvi
sit(
Unar
yOp&
);13
0St
atus
visi
t(Bi
nary
Op&)
;St
atus
visi
t(Lo
adVa
riab
leEx
pres
sion
&);
Stat
usvi
sit(
Load
Sign
alEx
pres
sion
&);
Stat
usvi
sit(
Load
Sign
alVa
lueE
xpre
ssio
n&);
Stat
usvi
sit(
Lite
ral&
);St
atus
visi
t(Fu
ncti
onCa
ll&)
;St
atus
visi
t(De
lay&
);St
atus
visi
t(Ch
eckC
ount
er&)
;
Stat
usvi
sit(
IfTh
enEl
se&)
;14
0vo
idin
dent
(){
inde
ntle
vel
+=2;
}vo
idun
inde
nt()
{in
dent
leve
l-=
2;}
void
tab(
){
for
(uns
igne
din
ti
=0
;i
<in
dent
leve
l;
i++)
o<<
’’;
}};
} #end
if
102
A.1. HW/SW Co-Synthese
A.1
.15.
CoD
esig
nHW
SW
er.c
pp
#inc
lude
"CoDesignHW
SW
Printer.h
pp"
#inc
lude
<cas
sert
>
name
spac
eCo
Desi
gn{
/ *Th
isfu
ncti
onov
erlo
ads
the
stre
amou
tput
oper
ator
for
writ
ing
anob
ject
ofty
peVH
DLLo
gicB
lock
*/ std:
:ost
ream
&op
erat
or<<
(std
::os
trea
m&o
,con
stVH
DLLo
gicB
lock
&lb)
{bo
olpr
ev=
fals
e;10
//in
clud
eso
meVH
DLli
brar
ies
o<<
"\nlibra
ry␣IE
EE;\
nuse
␣IE
EE.S
TD_LO
GIC_11
64.A
LL;\
nuse
␣IE
EE.
STD_LO
GIC_ARITH.A
LL;\
nuse
␣IE
EE.STD_LO
GIC_UNSIGNED
.ALL
;\n\n";
//de
clar
eth
elo
gicb
lock
asne
wen
tity
o<<
"entity
␣"
<<lb
.nam
e<<
"␣is
\n";
o<<
"␣␣␣port
(\n";
prev
=fa
lse;
//de
clar
epu
rein
put
sign
als
for
(uns
igne
din
tx=
0;x<
lb.i
nput
Sign
als.
size
();
x++)
{if
(pre
v){p
rev
=fa
lse;
o<<
";\
n";
}20
o<<
"␣␣␣␣␣␣"
<<(d
ynam
ic_c
ast<
Symb
ol*>
(lb.
inpu
tSig
nals
.sym
bols
[x])
)->n
ame
<<":in
␣st
d_lo
gic
";pr
ev=
true
;} //
decl
are
bool
ean
inpu
tsi
gnal
sas
vect
orof
size
2://
s[0]
isth
est
ate,
s[1]
isth
ebo
olea
nva
lue
for
(uns
igne
din
tx=
0;x<
lb.v
alue
dInp
utSi
gnal
s.si
ze()
;x+
+){
if(p
rev)
{pre
v=
fals
e;o
<<";\
n";
}o
<<"␣␣␣␣␣␣"
<<(d
ynam
ic_c
ast<
Symb
ol*>
(lb.
valu
edIn
putS
igna
ls.s
ymbo
ls[x
]))-
>nam
e<<
":in
␣st
d_lo
gic_vecto
r(1
␣downto
␣0)"
;30
prev
=tr
ue;
} //de
clar
epu
reou
tput
sign
als
for
(uns
igne
din
tx=
0;x<
lb.o
utpu
tSig
nals
.siz
e();
x++)
{if
(pre
v){p
rev
=fa
lse;
o<<
";\
n";
}o
<<"␣␣␣␣␣␣"
<<(d
ynam
ic_c
ast<
Symb
ol*>
(lb.
outp
utSi
gnal
s.sy
mbol
s[x]
))->
name
<<":o
ut␣
std_lo
gic
";pr
ev=
true
;}
40//
decl
are
bool
ean
outp
utsi
gnal
sas
vect
orof
size
2://
s[0]
isth
est
ate,
s[1]
isth
ebo
olea
nva
lue
for
(uns
igne
din
tx=
0;x<
lb.v
alue
dOut
putS
igna
ls.s
ize(
);x+
+){
if(p
rev)
{pre
v=
fals
e;o
<<";\
n";
}o
<<"␣␣␣␣␣␣"
<<(d
ynam
ic_c
ast<
Symb
ol*>
(lb.
valu
edOu
tput
Sign
als.
symb
ols[
x]))
->na
me<<
":o
ut␣
std_lo
gic_vecto
r(1
␣downto
␣0)"
;pr
ev=
true
;} o
<<"\n␣␣␣);\
n";
50o
<<"en
d␣"
<<lb
.nam
e<<
";\
n\n";
//wr
ite
the
impl
emen
tati
onof
the
enti
tyo
<<"arc
hitectu
re␣"
<<lb
.nam
e<<
"_BEH
␣of␣
"<<
lb.n
ame
<<"␣is
\n";
//wr
ite
the
decl
arat
ion
oflo
cal
sign
als
for
(uns
igne
din
tx=
0;x<
lb.l
ocal
Sign
als.
size
();
x++)
{if
((dy
nami
c_ca
st<S
igna
lSym
bol *
>(l
b.lo
calS
igna
ls.s
ymbo
ls[x
]))-
>typ
e){
o<<
"␣␣␣sig
nal␣
"<<
(dyn
amic
_cas
t<Sy
mbol
*>(l
b.lo
calS
igna
ls.s
ymbo
ls[x
]))-
>nam
e<<
":␣
std_lo
gic_vecto
r)(1
␣downto
␣0);\
n";
}60
else
{o
<<"␣␣␣sig
nal␣
"<<
(dyn
amic
_cas
t<Sy
mbol
*>(l
b.lo
calS
igna
ls.s
ymbo
ls[x
]))-
>nam
e<<
":␣
std_lo
gic
;\n";
}} o
<<"begin
\n";
//wr
ite
the
func
tion
albe
havi
our
o<<
lb.i
mple
ment
atio
n.st
r();
o<<
"en
d␣"
<<lb
.nam
e<<
"_BEH
;\n";
70re
turn
o;} / *
The
VHDL
Prin
ter
synt
hesi
zes
aa
VHDL
Desc
ript
ion
ofth
elo
gic
bloc
kfr
omth
ehw
-mod
ules
*an
dwr
ites
out
asi
mpli
fied
vers
ion
ofth
esw
-mod
ule
for
exec
utio
non
the
KEP
*in
the
HW/S
WCo
-Des
ign
* *@p
aram
ooOu
tput
stre
amfo
rth
esw
-mod
ule
*@p
aram
hwMo
dule
Out
Outp
utst
ream
for
the
Logi
cBl
ock
*/80
CoDe
sign
HWSW
Prin
ter:
:CoD
esig
nHWS
WPri
nter
(std
::os
trea
m&o
o,st
d::o
stre
am&h
wMod
):
o(oo
),hw
Modu
leOu
t(hw
Mod)
,in
dent
leve
l(0)
{pr
eced
ence
.pus
h_ba
ck(0
);
used
Symb
ols
=ne
wSy
mbol
Tabl
e();
leve
l["or"
]=
1;le
vel["an
d"]
=2;
unar
ylev
el["not"
]=
3;un
aryl
evel
["pre
"]=
3;
90le
vel["=
"]=
4;le
vel["<
>"]
=4;
leve
l["<
"]=
4;le
vel[">
"]=
4;le
vel["<
="]
=4;
leve
l[">
="]
=4;
leve
l["+
"]=
5;le
vel["−
"]=
6;
100
leve
l["∗"]
=7;
leve
l["/"]
=8;
103
A. Kommentierter Programmcode
leve
l["m
od"]
=8;
unar
ylev
el["−
"]=
9;} / *
Ifa
symb
olwi
thth
ena
me’n
ame’
isco
ntai
ned
inth
eSy
mbol
tabl
e,th
efu
ncti
onse
arch
esfo
ra
*nu
mber
edpo
stfi
xth
atma
kes
’nam
e’un
ique
.
*11
0*@p
aram
name
*@p
aram
st
*/ stri
ngCo
Desi
gnHW
SWPr
inte
r::g
etUn
ique
SigN
ame(
stri
ngna
me,S
ymbo
lTab
le*st)
{st
ring
post
fix="";
int
x=0;
whil
e(st
->lo
cal_
cont
ains
(nam
e+po
stfi
x)){
std:
:ost
ring
stre
ams;
s<<
"_"
<<x;
post
fix
=s.
str(
);12
0x+
+;} re
turn
name
+pos
tfix
;} vo
idCo
Desi
gnHW
SWPr
inte
r::s
tate
ment
(Sta
teme
nt*s)
{as
sert
(s);
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{13
0o
<<’\
n’;
inde
nt()
;ta
b();
s->w
elco
me( *
this
);o
<<’\
n’;
unin
dent
();
tab(
);} el
se{
s->w
elco
me( *
this
);14
0}
} void
CoDe
sign
HWSW
Prin
ter:
:exp
ress
ion(
Expr
essi
on*e)
{pr
eced
ence
.pus
h_ba
ck(0
);pr
oces
s(e)
;pr
eced
ence
.pop
_bac
k();
} void
CoDe
sign
HWSW
Prin
ter:
:sig
expr
essi
on(E
xpre
ssio
n*e)
{15
0//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
prec
eden
ce.p
ush_
back
(0);
//wr
ite
[]
orno
t?
if(d
ynam
ic_c
ast<
Dela
y *>(
e)||
dyna
mic_
cast
<Loa
dSig
nalE
xpre
ssio
n *>(
e))
proc
ess(
e);
else
{
o<<’
[’;
proc
ess(
e);
o<<’
]’;
160
} prec
eden
ce.p
op_b
ack(
);} el
se{
prec
eden
ce.p
ush_
back
(0);
proc
ess(
e);
prec
eden
ce.p
op_b
ack(
);}
}
170
bool
CoDe
sign
HWSW
Prin
ter:
:pus
h_pr
eced
ence
(int
p){
bool
need
Brac
kets
=(p
<pr
eced
ence
.bac
k())
||((
p==
prec
eden
ce.b
ack(
))&&
((p=
=lev
el["−
"])
||(p
==le
vel["
/"]
)));
prec
eden
ce.p
ush_
back
(p);
retu
rnne
edBr
acke
ts;
} void
CoDe
sign
HWSW
Prin
ter:
:pop
_pre
cede
nce(
){
prec
eden
ce.p
op_b
ack(
);}
180
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Mod
uleS
ymbo
l&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(V
aria
bleS
ymbo
l&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(T
ypeR
enam
ing
&){
asse
rt(0
);}
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Con
stan
tRen
amin
g&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(F
unct
ionR
enam
ing
&){
asse
rt(0
);}
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Pro
cedu
reRe
nami
ng&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(S
igna
lRen
amin
g&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(P
redi
cate
dSta
teme
nt&)
{as
sert
(0);
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(T
askC
all
&){
asse
rt(0
);}
190
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Bui
ltin
Cons
tant
Symb
ol&)
{re
turn
Stat
us()
;}
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Bui
ltin
Sign
alSy
mbol
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(B
uilt
inTy
peSy
mbol
&){
retu
rnSt
atus
();
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(B
uilt
inFu
ncti
onSy
mbol
&){
retu
rnSt
atus
();
}
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Mod
ule
&m)
{as
sert
(m.s
ymbo
l);
//if
curr
ent
modu
leis
ahw
-mod
ule
std:
:cer
r<<
"Pro
cess
ing␣module␣\""␣<
<␣m
.sym
bol−>na
me␣<<␣"\
"\n";
200
if((
(m.s
ymbo
l->n
ame.
find
("_
hw")
!=st
d::s
trin
g::n
pos)
&&(m
.sym
bol-
>nam
e.fi
nd("_
sw")
==st
d::s
trin
g::n
pos)
)||
(m.s
ymbo
l->n
ame.
find
_las
t_of
("_
hw")
>m.s
ymbo
l->n
ame.
find
_las
t_of
("_
sw")
)){
isSW
Modu
le=
fals
e;as
sert
(m.s
igna
ls);
proc
ess(
m.si
gnal
s);
//ad
din
terf
ace
sign
als
toth
elo
gic
bloc
kas
sert
(m.b
ody)
;pr
oces
s(m.
body
);//
conv
ert
body
toco
mbin
ator
ial
func
tion
s} //
ifcu
rren
tmo
dule
isth
esw
modu
leus
eth
eor
igin
alCE
CPr
inte
rsme
thod
210
if((
(m.s
ymbo
l->n
ame.
find
("_
sw")
!=st
d::s
trin
g::n
pos)
&&(m
.sym
bol-
>nam
e.fi
nd("_
hw")
==st
d::s
trin
g::n
pos)
)
104
A.1. HW/SW Co-Synthese
||(m
.sym
bol-
>nam
e.fi
nd_l
ast_
of("_
sw")
>m.s
ymbo
l->n
ame.
find
_las
t_of
("_
hw")
)){
isSW
Modu
le=
true
;as
sert
(m.s
ymbo
l);
tab(
);o
<<"module␣"
<<m.
symb
ol->
name
<<":\
n";
proc
ess(
m.ty
pes)
;pr
oces
s(m.
cons
tant
s);
proc
ess(
m.fu
ncti
ons)
;22
0pr
oces
s(m.
proc
edur
es);
proc
ess(
m.ta
sks)
;pr
oces
s(m.
sign
als)
;fo
r(
vect
or<I
nput
Rela
tion*>
::co
nst_
iter
ator
i=
m.re
lati
ons.
begi
n()
;i
!=m.
rela
tion
s.en
d()
;i+
+)
{as
sert
( *i)
;pr
oces
s(*i);
} o<<
’\n’
;ta
b();
230
proc
ess(
m.bo
dy);
o<<
"\n\n";
tab(
);o
<<"en
d␣module\n";
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Mod
ules
&m)
{ve
ctor
<Mod
ule *
>::i
tera
tor
i=
m.mo
dule
s.be
gin(
);24
0//
prin
tth
esw
-mod
ule
firs
twh
ile
(i
!=m.
modu
les.
end(
))
{as
sert
( *i)
;as
sert
((*i
)->s
ymbo
l);
if((
((*i
)->s
ymbo
l->n
ame.
find
("_
sw")
!=st
d::s
trin
g::n
pos)
&&((
*i)-
>sym
bol-
>nam
e.fi
nd("_
hw")
==st
d::s
trin
g::n
pos)
)||
((*i
)->s
ymbo
l->n
ame.
find
_las
t_of
("_
sw")
>(*i
)->s
ymbo
l->n
ame.
find
_las
t_of
("_
hw")
)){//
take
the
sw-m
odul
esna
mewi
thou
tth
epo
stfi
x’_
sw’
asna
mefo
rth
elo
gic
vhdl
Code
.nam
e=
( *i)
->sy
mbol
->na
me.s
ubst
r(0,
( *i)
->sy
mbol
->na
me.f
ind_
last
_of("_
sw")
-2);
250
proc
ess(
*i);
}i+
+;} i
=m.
modu
les.
begi
n();
//co
nver
thw
-mod
ules
toVH
DLco
deof
the
logi
cbl
ock
whil
e(
i!=
m.mo
dule
s.en
d()
){
asse
rt( *i)
;as
sert
((*i
)->s
ymbo
l);
260
if((
((*i
)->s
ymbo
l->n
ame.
find
("_
hw")
!=st
d::s
trin
g::n
pos)
&&((
*i)-
>sym
bol-
>nam
e.fi
nd("_
sw")
==st
d::s
trin
g::n
pos)
)||
((*i
)->s
ymbo
l->n
ame.
find
_las
t_of
("_
hw")
>(*i
)->s
ymbo
l->n
ame.
find
_las
t_of
("_
sw")
))pr
oces
s(*i);
i++;
if(
i!=
m.mo
dule
s.en
d()
)o
<<’\
n’;
}
hwMo
dule
Out
<<vh
dlCo
de;
//pr
int
the
VHDL
code
ofth
elo
gic
bloc
kre
turn
Stat
us()
;}
270
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Exc
lusi
on&
e){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{o
<<"re
lation␣";
vect
or<S
igna
lSym
bol *
>::c
onst
_ite
rato
ri
=e.
sign
als.
begi
n();
whil
e(
i!=
e.si
gnal
s.en
d()
){
asse
rt( *
i);
o<<
( *i)
->na
me;
i++;
280
if(
i!=
e.si
gnal
s.en
d()
)o
<<"␣#
␣";
} o<<
";\
n";
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Imp
lica
tion
&e)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
290
asse
rt(e
.pre
dica
te);
asse
rt(e
.imp
lica
tion
);o
<<"re
lation␣";
o<<
e.pr
edic
ate-
>nam
e<<
"␣=
>␣"
<<e.
impl
icat
ion-
>nam
e<<
";\
n";
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Sym
bolT
able
&t)
{fo
r(
Symb
olTa
ble:
:con
st_i
tera
tor
i=
t.be
gin(
);
i!=
t.en
d()
;i+
+)
{30
0if
( *i
!=NU
LL)
{as
sert
( *i)
;pr
oces
s(*i
);}a
sser
t(*i
);} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(T
ypeS
ymbo
l&s
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{31
0o
<<"ty
pe␣"
<<s.
name
<<";\
n";
} //co
llec
tus
edsy
mbol
sif
(!us
edSy
mbol
s->l
ocal
_con
tain
s(s.
name
))us
edSy
mbol
s->e
nter
(&s)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(C
onst
antS
ymbo
l&s
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{32
0o
<<"const
ant␣
"<<
s.na
me;
if(s
.ini
tial
izer
){
o<<
"␣=
␣";
105
A. Kommentierter Programmcode
expr
essi
on(s
.ini
tial
izer
);} as
sert
(s.t
ype)
;o
<<"␣:␣
"<<
s.ty
pe->
name
<<";\
n";
} //co
llec
tus
edsy
mbol
sif
(!us
edSy
mbol
s->l
ocal
_con
tain
s(s.
name
))us
edSy
mbol
s->e
nter
(&s)
;33
0re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(S
igna
lSym
bol
&s)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
swit
ch(s
.kin
d){
case
Sign
alSy
mbol
::In
put:
o<<
"in
put";
brea
k;ca
seSi
gnal
Symb
ol::
Outp
ut:
o<<
"outp
ut"
;br
eak;
case
Sign
alSy
mbol
::In
puto
utpu
t:o
<<"in
puto
utp
ut";
brea
k;34
0ca
seSi
gnal
Symb
ol::
Sens
or:
o<<
"se
nso
r";
brea
k;ca
seSi
gnal
Symb
ol::
Retu
rn:
o<<
"re
turn
";br
eak;
defa
ult:
asse
rt(0
);br
eak;
} o<<
’’
<<s.
name
;if
(s.i
niti
aliz
er)
{o
<<"␣:=
␣";
expr
essi
on(s
.ini
tial
izer
);as
sert
(s.t
ype)
;}
350
if(s
.typ
e){
o<<
"␣:␣
";if
(s.c
ombi
ne)
o<<
"co
mbine␣";
o<<
s.ty
pe->
name
;if
(s.c
ombi
ne)
o<<
"␣with␣"
<<s.
comb
ine-
>nam
e;} o
<<";\
n";
} else
{//
add
sign
alde
clar
atio
nto
the
inte
rfac
eof
the
logi
cbl
ock
360
swit
ch(s
.kin
d){
case
Sign
alSy
mbol
::In
put:
if(!
s.ty
pe)
{if
(!vh
dlCo
de.i
nput
Sign
als.
loca
l_co
ntai
ns(s
.nam
e))
vhdl
Code
.inp
utSi
gnal
s.en
ter(
&s);
}el
se{
if(!
vhdl
Code
.val
uedI
nput
Sign
als.
loca
l_co
ntai
ns(s
.nam
e))
vhdl
Code
.val
uedI
nput
Sign
als.
ente
r(&s
);} br
eak;
370
case
Sign
alSy
mbol
::Ou
tput
:if
(!s.
type
){
if(!
vhdl
Code
.out
putS
igna
ls.l
ocal
_con
tain
s(s.
name
))vh
dlCo
de.o
utpu
tSig
nals
.ent
er(&
s);
}el
se{
if(!
vhdl
Code
.val
uedO
utpu
tSig
nals
.loc
al_c
onta
ins(
s.na
me))
vhdl
Code
.val
uedO
utpu
tSig
nals
.ent
er(&
s);
} brea
k;
case
Sign
alSy
mbol
::In
puto
utpu
t:38
0if
(!s.
type
){
if(!
vhdl
Code
.out
putS
igna
ls.l
ocal
_con
tain
s(s.
name
))vh
dlCo
de.o
utpu
tSig
nals
.ent
er(&
s);
}el
se{
if(!
vhdl
Code
.val
uedO
utpu
tSig
nals
.loc
al_c
onta
ins(
s.na
me))
vhdl
Code
.val
uedO
utpu
tSig
nals
.ent
er(&
s);
} brea
k;de
faul
t:as
sert
(0);
brea
k;}
390
} //co
llec
tus
edsy
mbol
sif
(!us
edSy
mbol
s->l
ocal
_con
tain
s(s.
name
))us
edSy
mbol
s->e
nter
(&s)
;re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(F
unct
ionS
ymbo
l&s
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{o
<<"fu
nction␣"
<<s.
name
<<’(
’;40
0ve
ctor
<Typ
eSym
bol *
>::c
onst
_ite
rato
ri
=s.
argu
ment
s.be
gin(
);wh
ile
(i!=
s.ar
gume
nts.
end(
)){
asse
rt( *
i);
o<<
( *i)
->na
me;
i++;
if(i
!=s.
argu
ment
s.en
d())
o<<
",␣
";} as
sert
(s.r
esul
t);
o<<
")␣
:␣"
<<s.
resu
lt->
name
<<";\
n";
}41
0re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(P
roce
dure
Symb
ol&s
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{o
<<"pro
cedure
␣"
<<s.
name
<<’(
’;ve
ctor
<Typ
eSym
bol *
>::c
onst
_ite
rato
ri
=s.
refe
renc
e_ar
gume
nts.
begi
n();
whil
e(i
!=s.
refe
renc
e_ar
gume
nts.
end(
)){
asse
rt( *
i);
420
o<<
( *i)
->na
me;
i++;
if(i
!=s.
refe
renc
e_ar
gume
nts.
end(
))o
<<",␣
";} o
<<")("
;i
=s.
valu
e_ar
gume
nts.
begi
n();
whil
e(i
!=s.
valu
e_ar
gume
nts.
end(
)){
asse
rt( *
i);
o<<
( *i)
->na
me;
i++;
430
if(i
!=s.
valu
e_ar
gume
nts.
end(
))o
<<",␣
";} o
<<");\
n";
} retu
rnSt
atus
();
106
A.1. HW/SW Co-Synthese
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Tas
kSym
bol
&s)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
440
o<<
"ta
sk␣"
<<s.
name
<<’(
’;ve
ctor
<Typ
eSym
bol *
>::c
onst
_ite
rato
ri
=s.
refe
renc
e_ar
gume
nts.
begi
n();
whil
e(i
!=s.
refe
renc
e_ar
gume
nts.
end(
)){
asse
rt( *
i);
o<<
( *i)
->na
me;
i++;
if(i
!=s.
refe
renc
e_ar
gume
nts.
end(
))o
<<",␣
";} o
<<")("
;i
=s.
valu
e_ar
gume
nts.
begi
n();
450
whil
e(i
!=s.
valu
e_ar
gume
nts.
end(
)){
asse
rt( *
i);
o<<
( *i)
->na
me;
i++;
if(i
!=s.
valu
e_ar
gume
nts.
end(
))o
<<",␣
";} o
<<");\
n";
} retu
rnSt
atus
();
}46
0St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(S
tate
ment
List
&l)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
push
_pre
cede
nce(
sequ
enti
alPr
eced
ence
);ve
ctor
<Sta
teme
nt*>
::co
nst_
iter
ator
i=
l.st
atem
ents
.beg
in()
;wh
ile
(i
!=l.
stat
emen
ts.e
nd()
){
proc
ess(
*i);
i++;
if(i
!=l.
stat
emen
ts.e
nd()
){
o<<
";\
n";
tab(
);}
470
} pop_
prec
eden
ce()
;}
else
{//
depr
ecat
ed:
ahw
modu
les
body
shou
ldbe
aPa
rall
elSt
atem
ntLi
stor
asi
ngle
//ev
ery
orsu
stai
nst
atem
ent
push
_pre
cede
nce(
sequ
enti
alPr
eced
ence
);ve
ctor
<Sta
teme
nt*>
::co
nst_
iter
ator
i=
l.st
atem
ents
.beg
in()
;wh
ile
(i
!=l.
stat
emen
ts.e
nd()
){
proc
ess(
*i);
i++;
480
} pop_
prec
eden
ce()
;} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(P
aral
lelS
tate
ment
List
&l)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
bool
need
Brac
kets
=pu
sh_p
rece
denc
e(pa
rall
elPr
eced
ence
);49
0
if(n
eedB
rack
ets)
{o
<<"[\
n";
tab(
);} ve
ctor
<Sta
teme
nt*>::
cons
t_it
erat
ori
=l.
thre
ads.
begi
n();
whil
e(
i!=
l.th
read
s.en
d()
){
inde
nt()
;o
<<"␣␣";
//in
dent
does
n’t
take
effe
ctun
til
the
next
tab(
)50
0pr
oces
s(*i
);un
inde
nt()
;i+
+;if
(i!=
l.th
read
s.en
d()
){
o<<
’\n’
;ta
b();
o<<
"||\n";
tab(
);}
} if(n
eedB
rack
ets)
{o
<<’\
n’;
tab(
);o
<<’]
’;51
0} po
p_pr
eced
ence
();
} else
{//
the
comm
onbo
dyof
ahw
modu
leis
aPa
rall
elSt
atem
entL
ist
cons
isti
ng//
ofsu
stai
nan
dev
ery
stat
emen
tsve
ctor
<Sta
teme
nt*>::
cons
t_it
erat
ori
=l.
thre
ads.
begi
n();
whil
e(
i!=
l.th
read
s.en
d()
){
proc
ess(
*i);
520
i++;
}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Not
hing
&){
o<<
"noth
ing";
retu
rnSt
atus
();
}St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(P
ause
&){
o<<
"pause
";re
turn
Stat
us()
;}
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Hal
t&)
{o
<<"halt";
retu
rnSt
atus
();
}53
0St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(E
mit
&e)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
asse
rt(e
.sig
nal)
;o
<<"emit␣"
<<e.
sign
al->
name
;if
(e.v
alue
){
o<<
’(’;
expr
essi
on(e
.val
ue);
o<<
’)’;
540
}} el
se{
//NO
TE:
For
HW-M
odul
esth
eem
itst
atem
ent
isha
ndle
din
the
ever
yvi
sito
r} re
turn
Stat
us()
;}
107
A. Kommentierter Programmcode
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Sta
rtCo
unte
r&s
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
ed55
0if
(isS
WMod
ule)
{as
sert
(s.c
ount
er);
o<<
"Sta
rtCounte
r␣";
expr
essi
on(s
.cou
nt);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Sus
tain
&e)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
560
if(i
sSWM
odul
e){
asse
rt(e
.sig
nal)
;o
<<"su
stain
␣"
<<e.
sign
al->
name
;if
(e.v
alue
){
o<<
’(’;
expr
essi
on(e
.val
ue);
o<<
’)’;
}} //
NOTE
:Fo
rHW
-Mod
ules
the
sust
ain
visi
tor
isca
lled
for
bool
ean
sign
als
only
!57
0el
se{
asse
rt(e
.sig
nal)
;if
(e.v
alue
){
vhdl
Code
.imp
leme
ntat
ion
<<"␣␣␣";
//if
asi
gnal
isan
outp
utof
the
logi
cbu
tal
soac
cess
edin
tern
ally
,//
itis
decl
ared
asin
put/
outp
ut.
Whil
eac
cess
ing
anou
tput
sign
alin
este
rel
isal
lowe
d,//
this
isno
tal
lowe
din
VHDL
.So
ane
wlo
cal
VHDL
sign
alis
intr
oduc
ed,
//th
eco
mbin
ator
ial
func
tion
isas
sign
edto
the
loca
lsi
gnal
and
fina
lly
assi
gnth
elo
cal
//si
gnal
toth
esu
stai
ned
sign
alif
(e.s
igna
l->k
ind
==Si
gnal
Symb
ol::
Inpu
tout
put)
{58
0vh
dlCo
de.i
mple
ment
atio
n<<
getU
niqu
eSig
Name
(e.s
igna
l->n
ame
+"_
tmp"
,use
dSym
bols
);vh
dlCo
de.i
mple
ment
atio
n<<
"(1
)␣<
=␣";
expr
essi
on(e
.val
ue);
vhdl
Code
.imp
leme
ntat
ion
<<";\
n";
vhdl
Code
.imp
leme
ntat
ion
<<"␣␣␣";
vhdl
Code
.imp
leme
ntat
ion
<<e.
sign
al->
name
;vh
dlCo
de.i
mple
ment
atio
n<<
"␣<
=␣";
vhdl
Code
.imp
leme
ntat
ion
<<ge
tUni
queS
igNa
me(e
.sig
nal-
>nam
e+"_
tmp"
,use
dSym
bols
)<<
";\
n";
vhdl
Code
.loc
alSi
gnal
s.en
ter(
new
Sign
alSy
mbol
(ge
tUni
queS
igNa
me(e
.sig
nal-
>nam
e+"_
tmp"
,use
dSym
bols
),
590
e.si
gnal
->ty
pe,
Sign
alSy
mbol
::Lo
cal,
NULL
,NUL
L));
}el
se{
//if
the
sust
aine
dsi
gnal
isan
outp
utsi
gnal
vhdl
Code
.imp
leme
ntat
ion
<<e.
sign
al->
name
;vh
dlCo
de.i
mple
ment
atio
n<<
"(1
)␣<
=␣";
expr
essi
on(e
.val
ue);
vhdl
Code
.imp
leme
ntat
ion
<<";\
n";
}}
}60
0re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(A
ssig
n&a
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{as
sert
(a.v
aria
ble)
;as
sert
(a.v
alue
);o
<<a.
vari
able
->na
me<<
"␣:=
␣";
expr
essi
on(a
.val
ue);
610
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Pro
cedu
reCa
ll&c
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{as
sert
(c.p
roce
dure
);o
<<"call␣"
<<c.
proc
edur
e->n
ame
<<’(
’;ve
ctor
<Var
iabl
eSym
bol *
>::c
onst
_ite
rato
ri
=c.
refe
renc
e_ar
gs.b
egin
();
620
whil
e(i
!=c.
refe
renc
e_ar
gs.e
nd()
){
o<<
( *i)
->na
me;
i++;
if(i
!=c.
refe
renc
e_ar
gs.e
nd()
)o
<<",␣
";} o
<<")("
;ve
ctor
<Exp
ress
ion *
>::c
onst
_ite
rato
rj
=c.
valu
e_ar
gs.b
egin
();
whil
e(j
!=c.
valu
e_ar
gs.e
nd()
){
expr
essi
on( *
j);
j++;
630
if(j
!=c.
valu
e_ar
gs.e
nd()
)o
<<",␣
";} o
<<’)
’;} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(E
xec
&e)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
640
o<<
"exec";
inde
nt()
;fo
r(
vect
or<T
askC
all *
>::c
onst
_ite
rato
ri
=e.
call
s.be
gin(
);
i!=
e.ca
lls.
end(
);
i++)
{as
sert
( *i)
;as
sert
((*i)-
>pro
cedu
re);
o<<
’\n’
;ta
b();
o<<
"case
␣"
<<( *
i)->
proc
edur
e->n
ame
<<’(
’;ve
ctor
<Var
iabl
eSym
bol *
>::c
onst
_ite
rato
rk
=( *
i)->
refe
renc
e_ar
gs.b
egin
();
650
whil
e(k
!=( *i)
->re
fere
nce_
args
.end
())
{o
<<( *
k)->
name
;k+
+;if
(k!=
( *i)
->re
fere
nce_
args
.end
())
o<<
",␣
";}
108
A.1. HW/SW Co-Synthese
o<<
")("
;ve
ctor
<Exp
ress
ion *
>::c
onst
_ite
rato
rj
=( *
i)->
valu
e_ar
gs.b
egin
();
whil
e(j
!=( *i)
->va
lue_
args
.end
())
{ex
pres
sion
( *j)
;j+
+;66
0if
(j!=
( *i)
->va
lue_
args
.end
())
o<<
",␣
";} as
sert
((*i)-
>sig
nal)
;o
<<")␣
retu
rn␣"
<<( *
i)->
sign
al->
name
;if
((*i)-
>bod
y){
o<<
"␣do\n";
inde
nt()
;ta
b();
proc
ess(
( *i)
->bo
dy);
unin
dent
();
670
}} o
<<’\
n’;
unin
dent
();
tab(
);o
<<"en
d␣exec";
} retu
rnSt
atus
();
}
680
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Pre
sent
&p)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"pre
sent␣";
if(p
.cas
es.s
ize(
)==
1){
//Si
mple
if-t
hen-
else
Pred
icat
edSt
atem
ent
*ps
=p.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e);
o<<
’’;
690
if(p
s->b
ody)
{o
<<"th
en";
stat
emen
t(ps
->bo
dy);
}}
else
{//
Mult
iple
case
sin
dent
();
for
(vec
tor<
Pred
icat
edSt
atem
ent *
>::c
onst
_ite
rato
ri
=p.
case
s.be
gin(
);
i!=
p.ca
ses.
end(
);
i++)
{o
<<’\
n’;
700
tab(
);o
<<"case
␣";
asse
rt( *
i);
asse
rt((
*i)-
>pre
dica
te);
sige
xpre
ssio
n(( *
i)->
pred
icat
e);
if((
*i)-
>bod
y){
o<<
"␣do\n";
inde
nt()
;ta
b();
proc
ess(
( *i)
->bo
dy);
710
unin
dent
();
}} un
inde
nt()
;o
<<’\
n’;
tab(
);} if
(p.d
efau
lt_s
tmt)
{o
<<"else";
stat
emen
t(p.
defa
ult_
stmt
);72
0} o
<<"en
d␣pre
sent";
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(If
&s)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"if
␣";
730
vect
or<P
redi
cate
dSta
teme
nt*>
::co
nst_
iter
ator
i=
s.ca
ses.
begi
n();
asse
rt(i
!=s.
case
s.en
d())
;ex
pres
sion
((*i
)->p
redi
cate
);o
<<’
’;if
((*i
)->b
ody)
{o
<<"th
en";
stat
emen
t(( *
i)->
body
);} fo
r(
i++
;i
!=s.
case
s.en
d()
;i+
+)
{as
sert
( *i)
;74
0o
<<"els
if␣";
expr
essi
on((
*i)-
>pre
dica
te);
o<<
"␣th
en";
stat
emen
t(( *
i)->
body
);} if
(s.d
efau
lt_s
tmt)
{o
<<"else";
stat
emen
t(s.
defa
ult_
stmt
);} o
<<"en
d␣if
";75
0} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(L
oop
&l)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"loop";
stat
emen
t(l.
body
);o
<<"en
d␣loop";
760
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Rep
eat
&r)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
109
A. Kommentierter Programmcode
if(r
.is_
posi
tive
)o
<<"positiv
e␣";
o<<
"re
peat␣
";ex
pres
sion
(r.c
ount
);77
0o
<<"␣times";
stat
emen
t(r.
body
);o
<<"en
d␣re
peat"
;} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(A
bort
&a)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
780
if(a
.is_
weak
)o
<<"wea
k␣";
o<<
"abort
";st
atem
ent(
a.bo
dy);
o<<
"when
";if
(a.c
ases
.siz
e()
==1)
{//
Simp
leab
ort
cond
itio
nPr
edic
ated
Stat
emen
t*p
s=
a.ca
ses[
0];
o<<
’’;
asse
rt(p
s);
sige
xpre
ssio
n(ps
->pr
edic
ate)
;79
0if
(ps-
>bod
y){
o<<
"␣do";
stat
emen
t(ps
->bo
dy);
goto
Prin
tEnd
;}
}el
se{
//Ab
ort
case
sin
dent
();
for
(ve
ctor
<Pre
dica
tedS
tate
ment
*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
800
o<<
’\n’
;ta
b();
asse
rt( *
i);
o<<
"case
␣";
sige
xpre
ssio
n(( *
i)->
pred
icat
e);
if((
*i)-
>bod
y){
o<<
"␣do\n";
inde
nt()
;ta
b();
proc
ess(
( *i)
->bo
dy);
810
unin
dent
();
}} un
inde
nt()
;o
<<’\
n’;
tab(
);Pr
intE
nd:
o<<
"en
d";
if(a
.is_
weak
)o
<<"␣wea
k";
o<<
"␣abort
";82
0}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Awa
it&
a){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{o
<<"await␣";
if(a
.cas
es.s
ize(
)==
1){
830
//Si
mple
abor
tco
ndit
ion
Pred
icat
edSt
atem
ent
*ps
=a.
case
s[0]
;as
sert
(ps)
;si
gexp
ress
ion(
ps->
pred
icat
e);
if(p
s->b
ody)
{o
<<"␣do";
stat
emen
t(ps
->bo
dy);
o<<
"en
d␣await";
}}
else
{84
0in
dent
();
for
(ve
ctor
<Pre
dica
tedS
tate
ment
*>::
cons
t_it
erat
ori
=a.
case
s.be
gin(
);
i!=
a.ca
ses.
end(
);
i++
){
o<<
’\n’
;ta
b();
asse
rt( *
i);
o<<
"case
␣";
sige
xpre
ssio
n(( *
i)->
pred
icat
e);
if((
*i)-
>bod
y){
o<<
"␣do\n";
850
inde
nt()
;ta
b();
proc
ess(
( *i)
->bo
dy);
unin
dent
();
}} un
inde
nt()
;o
<<’\
n’;
tab(
);o
<<"en
d␣await";
860
}} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(L
oopE
ach
&l)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"loop";
stat
emen
t(l.
body
);87
0o
<<"each
␣";
sige
xpre
ssio
n(l.
pred
icat
e);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Eve
ry&e
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{
110
A.1. HW/SW Co-Synthese
o<<
"every
␣";
880
sige
xpre
ssio
n(e.
pred
icat
e);
o<<
"␣do";
stat
emen
t(e.
body
);o
<<"en
d␣every
";} el
se{
std:
:cer
r<<
"every
\n";
Emit
*est
=dy
nami
c_ca
st<E
mit *
>(e.
body
);as
sert
(est
);//
ifa
sign
alis
anou
tput
ofth
elo
gic
but
also
acce
ssed
inte
rnal
ly,
890
//it
isde
clar
edas
inpu
t/ou
tput
.Wh
ile
acce
ssin
gan
outp
utsi
gnal
ines
tere
lis
allo
wed
, //th
isis
not
allo
wed
inVH
DL.
Soa
new
loca
lVH
DLsi
gnal
isin
trod
uced
,//
the
comb
inat
oria
lfu
ncti
onis
assi
gned
toth
elo
cal
sign
alan
dfi
nall
yth
elo
cal
//si
gnal
isas
sign
edto
the
emit
ted
sign
alif
(est
->si
gnal
->ki
nd==
Sign
alSy
mbol
::In
puto
utpu
t){
vhdl
Code
.imp
leme
ntat
ion
<<"␣␣␣";
vhdl
Code
.imp
leme
ntat
ion
<<ge
tUni
queS
igNa
me(e
st->
sign
al->
name
+"_
tmp"
,use
dSym
bols
);vh
dlCo
de.i
mple
ment
atio
n<<
"␣<
=␣";
sige
xpre
ssio
n(e.
pred
icat
e);
vhdl
Code
.imp
leme
ntat
ion
<<";\
n";
900
vhdl
Code
.imp
leme
ntat
ion
<<"␣␣␣";
vhdl
Code
.imp
leme
ntat
ion
<<es
t->s
igna
l->n
ame;
vhdl
Code
.imp
leme
ntat
ion
<<"␣<
=␣";
vhdl
Code
.imp
leme
ntat
ion
<<ge
tUni
queS
igNa
me(e
st->
sign
al->
name
+"_
tmp"
,use
dSym
bols
)<<
";\
n";
vhdl
Code
.loc
alSi
gnal
s.en
ter(
new
Sign
alSy
mbol
(ge
tUni
queS
igNa
me(e
st->
sign
al->
name
+"_
tmp"
,use
dSym
bols
),es
t->s
igna
l->t
ype,
Sign
alSy
mbol
::Lo
cal,
NULL
,NUL
L));
}el
se{
//if
the
emit
ted
sign
alis
anou
tput
sign
al91
0vh
dlCo
de.i
mple
ment
atio
n<<
"␣␣␣"
<<es
t->s
igna
l->n
ame
<<"␣<
=␣";
sige
xpre
ssio
n(e.
pred
icat
e);
vhdl
Code
.imp
leme
ntat
ion
<<";\
n";
}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Sus
pend
&s)
{92
0//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"su
spend";
stat
emen
t(s.
body
);o
<<"when
␣";
sige
xpre
ssio
n(s.
pred
icat
e);
} retu
rnSt
atus
();
}
930
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(DoW
atch
ing
&d)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"do";
stat
emen
t(d.
body
);o
<<"watc
hing␣";
sige
xpre
ssio
n(d.
pred
icat
e);
//o
<<’]
’;if
(d.t
imeo
ut)
{o
<<"␣timeout"
;94
0st
atem
ent(
d.ti
meou
t);
o<<
"en
d␣timeout"
;}
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(DoU
pto
&d)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
950
o<<
"do";
stat
emen
t(d.
body
);o
<<"upto
␣";
sige
xpre
ssio
n(d.
pred
icat
e);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Tra
p&t
){
if(i
sSWM
odul
e){
960
asse
rt(t
.sym
bols
);Sy
mbol
Tabl
e*t
st=
t.sy
mbol
s;Si
gnal
Symb
ol*t
s=
dyna
mic_
cast
<Sig
nalS
ymbo
l *>(*(ts
t->b
egin
()))
;as
sert
(ts)
;as
sert
(ts-
>kin
d==
Sign
alSy
mbol
::Tr
ap);
//if
the
trap
was
crea
ted
duri
ngth
epa
rtit
ioni
g..
if((
ts->
name
.sub
str(
0,10
)=="C
OSY
N_TRAP")
){
Para
llel
Stat
emen
tLis
t*psl
=dy
nami
c_ca
st<P
aral
lelS
tate
ment
List
*>(t
.bod
y);
asse
rt(p
sl);
//..
remo
veru
nst
atem
ent
that
runs
the
hw-m
odul
e97
0as
sert
(dyn
amic
_cas
t<Ru
n *>(*(
psl-
>thr
eads
.beg
in()
)));
psl-
>thr
eads
.era
se(p
sl->
thre
ads.
begi
n())
;} //
ifno
pre
oper
ator
swe
resu
bsti
tute
din
this
scop
e..
.if
((ts
->na
me.s
ubst
r(0,
10)=
="C
OSY
N_TRAP")
&&(t
s->n
ame.
subs
tr(0
,14)
!="
COSY
N_TRAP_PRE")
){
//..
.re
move
the
trap
stat
emen
t(t.
body
);} el
se{
//..
.ot
herw
ise
keep
the
trap
and
prin
tit
asco
mmon
980
o<<
"trap␣";
Symb
olTa
ble:
:con
st_i
tera
tor
i=
t.sy
mbol
s->b
egin
();
whil
e(
i!=
t.sy
mbol
s->e
nd()
){
Symb
ol*s
=*i;
asse
rt(s
);Si
gnal
Symb
ol*t
s=
dyna
mic_
cast
<Sig
nalS
ymbo
l *>(
s);
asse
rt(t
s);
asse
rt(t
s->k
ind
==Si
gnal
Symb
ol::
Trap
);
111
A. Kommentierter Programmcode
o<<
ts->
name
;if
(ts-
>ini
tial
izer
){
990
o<<
"␣:=
␣";
expr
essi
on(t
s->i
niti
aliz
er);
} if(t
s->t
ype)
{o
<<"␣:␣
"<<
ts->
type
->na
me;
} i++;
if(
i!=
t.sy
mbol
s->e
nd()
){
o<<
",\
n";
tab(
);10
00o
<<"␣␣␣␣␣";
}} o
<<"␣in
";st
atem
ent(
t.bo
dy);
for
(vec
tor<
Pred
icat
edSt
atem
ent *
>::c
onst
_ite
rato
ri
=t.
hand
lers
.beg
in()
;i
!=t.
hand
lers
.end
();
i++
){
asse
rt( *
i);
o<<
"handle
␣";
expr
essi
on((
*i)-
>pre
dica
te);
1010
o<<
"␣do";
stat
emen
t(( *
i)->
body
);} o
<<"en
d␣trap";
}} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(E
xit
&e)
{10
20if
(isS
WMod
ule)
{//
don’
tpr
int
the
exit
stat
emen
tif
itwa
sin
trod
uced
duri
ngpa
rtit
ioni
ng//
and
nopr
eop
erat
ors
were
subs
titu
ted
inth
issc
ope
if(!
((e.
trap
->na
me.s
ubst
r(0,
10)=
="C
OSY
N_TRAP")
&&(e
.tra
p->n
ame.
subs
tr(0
,14)
!="C
OSY
N_TRAP_PRE")
)){
o<<
"exit
␣";
asse
rt(e
.tra
p);
asse
rt(e
.tra
p->k
ind
==Si
gnal
Symb
ol::
Trap
);o
<<e.
trap
->na
me;
if(e
.val
ue)
{10
30o
<<’(
’;ex
pres
sion
(e.v
alue
);o
<<’)
’;}
}} re
turn
Stat
us()
;} St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(V
ar&v
){
1040
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{o
<<"var␣
";Sy
mbol
Tabl
e::c
onst
_ite
rato
ri
=v.
symb
ols-
>beg
in()
;
whil
e(
i!=
v.sy
mbol
s->e
nd()
){
Symb
ol*s
=*i
;as
sert
(s);
Vari
able
Symb
ol*vs
=dy
nami
c_ca
st<V
aria
bleS
ymbo
l *>(
s);
asse
rt(v
s);
o<<
vs->
name
;10
50if
(vs-
>ini
tial
izer
){
o<<
"␣:=
␣";
expr
essi
on(v
s->i
niti
aliz
er);
} asse
rt(v
s->t
ype)
;o
<<"␣:␣
"<<
vs->
type
->na
me;
i++;
if(
i!=
v.sy
mbol
s->e
nd()
){
o<<
",\
n";
tab(
);10
60o
<<"␣␣␣␣";
}} o
<<"␣in
";st
atem
ent(
v.bo
dy);
o<<
"en
d␣var"
;} re
turn
Stat
us()
;}
1070
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Sig
nal
&s)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
o<<
"sig
nal␣
";Sy
mbol
Tabl
e::c
onst
_ite
rato
ri
=s.
symb
ols-
>beg
in()
;wh
ile
(i
!=s.
symb
ols-
>end
())
{Sy
mbol
*sy
=*i;
asse
rt(s
y);
Sign
alSy
mbol
*ss
=dy
nami
c_ca
st<S
igna
lSym
bol *
>(sy
);as
sert
(ss)
;10
80o
<<ss
->na
me;
if(s
s->i
niti
aliz
er)
{o
<<"␣:=
␣";
expr
essi
on(s
s->i
niti
aliz
er);
} if(s
s->t
ype)
{o
<<"␣:␣
";if
(ss-
>com
bine
)o
<<"co
mbine␣";
o<<
ss->
type
->na
me;
if(s
s->c
ombi
ne)
o<<
"␣with␣"
<<ss
->co
mbin
e->n
ame;
1090
} i++;
if(
i!=
s.sy
mbol
s->e
nd()
){
o<<
",\
n";
tab(
);o
<<"␣␣␣␣␣␣␣";
}if
(!us
edSy
mbol
s->l
ocal
_con
tain
s(ss
->na
me))
used
Symb
ols-
>ent
er(s
s);
} o<<
"␣in
";
112
A.1. HW/SW Co-Synthese
1100
stat
emen
t(s.
body
);o
<<"en
d␣sig
nal"
;} el
se{
//En
ter
loca
lsi
gnal
sde
clar
edin
the
hw-m
odul
eto
the
loca
lsi
gnal
decl
arat
ion
ofth
eVH
DL//
code
.Re
name
the
sign
alif
nece
ssar
ySy
mbol
Tabl
e::c
onst
_ite
rato
ri
=s.
symb
ols-
>beg
in()
;wh
ile
(i
!=s.
symb
ols-
>end
())
{Sy
mbol
*sy
=*i;
asse
rt(s
y);
1110
Sign
alSy
mbol
*ss
=dy
nami
c_ca
st<S
igna
lSym
bol *
>(sy
);ss
->na
me=
getU
niqu
eSig
Name
(ss-
>nam
e,us
edSy
mbol
s);
if(!
used
Symb
ols-
>loc
al_c
onta
ins(
ss->
name
))us
edSy
mbol
s->e
nter
(ss)
;vh
dlCo
de.l
ocal
Sign
als.
ente
r(ss
);i+
+;} st
atem
ent(
s.bo
dy);
} retu
rnSt
atus
();
}11
20St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(R
un&r
){
asse
rt(0
);//
run
stat
emen
tsh
ould
n’t
occu
rin
the
swmo
dule
retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Una
ryOp
&u)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
asse
rt(u
nary
leve
l.fi
nd(u
.op)
!=un
aryl
evel
.end
());
1130
push
_pre
cede
nce(
unar
ylev
el[u
.op]
);//
High
est:
pare
nthe
sis
neve
rne
eded
o<<
u.op
;if
(u.o
p.co
mpar
e("pre
")==
0)o
<<"("
;el
seo
<<’
’;pr
oces
s(u.
sour
ce);
if(u
.op.
comp
are("pre
")==
0)o
<<")"
;po
p_pr
eced
ence
();
} else
{as
sert
(una
ryle
vel.
find
(u.o
p)!=
unar
ylev
el.e
nd()
);pu
sh_p
rece
denc
e(un
aryl
evel
[u.o
p]);
//Hi
ghes
t:pa
rent
hesi
sne
ver
need
ed11
40vh
dlCo
de.i
mple
ment
atio
n<<
u.op
;if
(u.o
p.co
mpar
e("not"
)==0
)vh
dlCo
de.i
mple
ment
atio
n<<
’’;
proc
ess(
u.so
urce
);po
p_pr
eced
ence
();
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Bin
aryO
p&b
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
ed11
50if
(isS
WMod
ule)
{as
sert
(lev
el.f
ind(
b.op
)!=
leve
l.en
d())
;bo
olne
edPa
ren
=pu
sh_p
rece
denc
e(le
vel[
b.op
]);
if(n
eedP
aren
)o
<<’(
’;pr
oces
s(b.
sour
ce1)
;
o<<
’’
<<b.
op<<
’’;
proc
ess(
b.so
urce
2);
if(n
eedP
aren
)o
<<’)
’;po
p_pr
eced
ence
();
}11
60el
se{
asse
rt(l
evel
.fin
d(b.
op)
!=le
vel.
end(
));
bool
need
Pare
n=
true
;//
Pare
nthe
ses
alwa
ysne
eded
beca
use
’and
’an
d’o
r’ha
veth
esa
me//
prec
eden
cein
VHDL
if(n
eedP
aren
)vh
dlCo
de.i
mple
ment
atio
n<<
’(’;
proc
ess(
b.so
urce
1);
vhdl
Code
.imp
leme
ntat
ion
<<’
’<<
b.op
<<’
’;pr
oces
s(b.
sour
ce2)
;if
(nee
dPar
en)
vhdl
Code
.imp
leme
ntat
ion
<<’)
’;po
p_pr
eced
ence
();
1170
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Loa
dVar
iabl
eExp
ress
ion
&e)
{//
for
prin
ting
the
sw-m
odul
e,th
eor
igin
alCE
CEs
tere
lPri
nter
meth
odis
used
if(i
sSWM
odul
e){
asse
rt(e
.var
iabl
e);
o<<
e.va
riab
le->
name
;}
1180
else
{//
prin
ta
cons
tant
true
orfa
lse
asse
rt(e
.var
iabl
e);
if(e
.var
iabl
e->n
ame
=="true")
vhdl
Code
.imp
leme
ntat
ion
<<"1";
else
vhdl
Code
.imp
leme
ntat
ion
<<"0";
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Loa
dSig
nalE
xpre
ssio
n&e
){
1190
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{as
sert
(e.s
igna
l);
o<<
e.si
gnal
->na
me;
} else
{//
prin
ta
sign
alna
meto
the
comb
inat
oria
lfu
ncti
onas
sert
(e.s
igna
l);
if(e
.sig
nal-
>kin
d==
Sign
alSy
mbol
::In
puto
utpu
t){
1200
vhdl
Code
.imp
leme
ntat
ion
<<ge
tUni
queS
igNa
me(e
.sig
nal-
>nam
e+"_
tmp"
,use
dSym
bols
);}
else
{vh
dlCo
de.i
mple
ment
atio
n<<
e.si
gnal
->na
me;
} //if
sign
alis
bool
ean
then
s(0)
isth
est
ate
valu
eif
(e.s
igna
l->t
ype)
vhdl
Code
.imp
leme
ntat
ion
<<"(0
)";
} retu
rnSt
atus
();
}
1210
Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Loa
dSig
nalV
alue
Expr
essi
on&e
){
113
A. Kommentierter Programmcode
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{as
sert
(e.s
igna
l);
if(e
.sig
nal-
>kin
d==
Sign
alSy
mbol
::Tr
ap)
o<<
’?’;
o<<
’?’
<<e.
sign
al->
name
;} el
se{
//pr
int
asi
gnal
name
toth
eco
mbin
ator
ial
func
tion
asse
rt(e
.sig
nal)
;12
20if
(e.s
igna
l->k
ind
==Si
gnal
Symb
ol::
Inpu
tout
put)
{vh
dlCo
de.i
mple
ment
atio
n<<
getU
niqu
eSig
Name
(e.s
igna
l->n
ame
+"_
tmp"
,use
dSym
bols
);}
else
{vh
dlCo
de.i
mple
ment
atio
n<<
e.si
gnal
->na
me;
} //if
sign
alis
bool
ean
then
s(1)
isth
ebo
olea
nva
lue
vhdl
Code
.imp
leme
ntat
ion
<<"(1
)";
} retu
rnSt
atus
();
}12
30St
atus
CoDe
sign
HWSW
Prin
ter:
:vis
it(L
iter
al&l
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{as
sert
(l.t
ype)
;if
(l.t
ype-
>nam
e==
"str
ing")
{o
<<’\"’;
␣␣␣␣␣␣␣␣fo
r␣(str
ing::
itera
tor␣i␣=␣l.valu
e.begin
()␣;␣
i␣!=
␣l.valu
e.e
nd()
␣;␣
i++)␣
{␣␣␣␣␣␣␣␣␣␣if
␣(∗
i␣==␣’\
"’)
o<<
’\"’;
␣␣␣␣␣␣␣␣␣␣o␣<
<␣∗i;
1240
␣␣␣␣␣␣␣␣}
␣␣␣␣␣␣␣␣o␣<
<␣’\
"’;
} else
o<<
l.va
lue;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Fun
ctio
nCal
l&e
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
ed12
50//
func
tion
call
sno
tsu
ppor
ted
byKE
Pif
(isS
WMod
ule)
{as
sert
(e.c
alle
e);
o<<
e.ca
llee
->na
me;
o<<
’(’;
vect
or<E
xpre
ssio
n *>:
:con
st_i
tera
tor
i=
e.ar
gume
nts.
begi
n();
whil
e(i
!=e.
argu
ment
s.en
d())
{ex
pres
sion
( *i)
;i+
+;if
(i
!=e.
argu
ment
s.en
d())
o<<
",␣
";12
60} o
<<’)
’;
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Del
ay&e
){
//fo
rpr
inti
ngth
esw
-mod
ule,
the
orig
inal
CEC
Este
relP
rint
erme
thod
isus
edif
(isS
WMod
ule)
{if
(e.i
s_im
medi
ate)
{12
70as
sert
(e.c
ount
==NU
LL);
o<<
"im
mediate
␣";
}el
se{
expr
essi
on(e
.cou
nt);
o<<
’’;
} //o
<<’[
’;si
gexp
ress
ion(
e.pr
edic
ate)
;//
o<<
’]’;
}12
80el
se{
sige
xpre
ssio
n(e.
pred
icat
e);
} retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(Che
ckCo
unte
r&e
){
asse
rt(e
.cou
nter
);o
<<"ch
eck
(";
expr
essi
on(e
.pre
dica
te);
1290
o<<
’)’;
retu
rnSt
atus
();
} Stat
usCo
Desi
gnHW
SWPr
inte
r::v
isit
(IfT
henE
lse
&s)
{o
<<"if
␣("
;ex
pres
sion
(s.p
redi
cate
);o
<<")"
;if
(s.t
hen_
part
){
o<<
"␣{";
1300
stat
emen
t(s.
then
_par
t);
o<<
"}";
} if(s
.els
e_pa
rt)
{o
<<"␣else␣{";
stat
emen
t(s.
else
_par
t);
o<<
"}";
} retu
rnSt
atus
();
}13
10}
114
A.2. Wiederherstellung von Signalabhängigkeiten im CKAG
A.2. Wiederherstellung von Signalabhängigkeiten imCKAG
Durch die Ersetzung von Ausdrücken durch Hilfssignale während der HW/SW Co-Synthese gehen Abhängigkeiten zwischen Readern und Writern eines Signals verloren(vgl. Abschnitt 3.5.1). Während der Partitionierung wird daher eine Datei erstellt,die eine Sicherung dieser Abhängigkeiten enthält. Auf Basis dieser Datei kann derEsterel2KASM Compiler die fehlenden Signalabhängigkeiten wieder rekonstruieren.
Um dies zu erreichen wurde die Klasse DependencyHandler des Esterel2KASMCompilers geeignet erweitert. Die Klasse ExtDependencyHandler liest die Datei mitden gesicherten Abhängigkeiten ein und fügt diese zum CKAG hinzu.
Um fehlende Signalabhängigkeiten wieder herzustellen, muss das Programm cec-astkep aus der Esterel2KASM Compiler Toolkette mit der zusätzlichen Option -cdepfilename gestartet werden, wobei depfilename der Name der Datei mit dengesicherten Abhängigkeiten ist. Normalerweise geschieht dies automatisch über dasMakefile, indem man das Target *.cosyn.kep.kasm oder *.opt.cosyn.kep.kasmangibt.
115
A. Kommentierter Programmcode
A.2
.1.
Ext
Dep
ende
ncyH
andl
er.c
pp
/ *Th
ecl
ass
ExtD
epen
denc
yHan
dler
exte
nds
the
orig
inal
KEP
clas
sDe
pend
ency
Hand
ler.
*No
rmal
ly,
the
Este
rel2
KASM
comp
iler
cann
otre
cons
truc
tfr
omwh
ich
sign
als
the
*au
xili
ary
sign
als,
that
subs
titu
teco
mple
xex
pres
sion
s,de
pend
on.
This
in-
*fo
rmat
ion
was
stor
edin
afi
ledu
ring
the
part
itio
ning
proc
ess.
Inca
seof
*co
-syn
thes
isth
iscl
ass
has
tobe
used
that
rest
ores
the
sign
alde
pend
enci
es
*in
the
CKAG
*/ clas
sEx
tDep
ende
ncyH
andl
er:
publ
icKE
P::D
epen
denc
yHan
dler
{10
prot
ecte
d:st
d::s
trin
gex
t_de
ps_f
ile;
publ
ic:
ExtD
epen
denc
yHan
dler
(KEP
::De
bug
*d=n
ewKE
P::D
ebug
(),s
td::
stri
ngfi
lena
me="")
:KE
P::D
epen
denc
yHan
dler
(d),
ext_
deps
_fil
e(fi
lena
me)
{}pr
otec
ted:
void
add_
depe
nden
cies
(boo
l=fa
lse)
;};
20vo
idEx
tDep
ende
ncyH
andl
er::
add_
depe
nden
cies
(boo
lal
l){
debu
g->p
rint
("sta
rt␣KepDependencies::
add_dependencies:"
);de
bug-
>ind
ent(
);
visi
t_no
des(
);st
d::m
ap<K
EP::
Sign
alSy
mbol
*,Si
gnal
Node
s>::
iter
ator
m,n;
std:
:set
<KEP
::Ke
pNod
e *>:
:con
st_i
tera
tor
w,r;
std:
:ifs
trea
mif
s(ex
t_de
ps_f
ile.
c_st
r())
;st
d::s
trin
gli
ne,
read
er_s
igna
l,wr
iter
_sig
nal;
30st
d::g
etli
ne(i
fs,l
ine,
’\n’
);
whil
e(!i
fs.e
of()
){
std:
:ist
ring
stre
amli
neSt
r(li
ne);
line
Str
>>re
ader
_sig
nal;
line
Str
>>wr
iter
_sig
nal;
//Th
ede
pend
enci
esob
ject
stor
esfo
rea
chsi
gnal
all
read
eran
dwr
iter
node
s//
inth
eCK
AG.
40//
Iter
ate
over
all
depe
nden
cies
for
(m=t
his-
>dep
ende
ncie
s.be
gin(
);m!
=thi
s->d
epen
denc
ies.
end(
);m+
+){
KEP:
:Sig
nalS
ymbo
l*s
ymbo
l=
m->f
irst
;as
sert
(sym
bol)
;//
ifel
emen
tfo
rth
ede
pend
enci
esof
anau
xili
ary
sign
al(r
eade
r_si
gnal
)//
isfo
und
...
if(r
eade
r_si
gnal
==sy
mbol
->ge
tNam
e())
{//
...
find
all
writ
ers
of(w
rite
r_si
gnal
),th
atis
asi
gnal
the
auxi
liar
y
//si
gnal
depe
nds
onn
...
for
(n=t
his-
>dep
ende
ncie
s.be
gin(
);n!
=thi
s->d
epen
denc
ies.
end(
);n+
+){
50KE
P::S
igna
lSym
bol
*sym
bol
=n-
>fir
st;
cons
tSi
gnal
Node
s&s
n=
n->s
econ
d;as
sert
(sym
bol)
;if
(wri
ter_
sign
al==
symb
ol->
getN
ame(
)){
if(!
n->s
econ
d.wr
iter
s.em
pty(
)){
for
(w=s
n.wr
iter
s.be
gin(
);w!
=sn.
writ
ers.
end(
);w+
+){
//..
.an
dad
dth
emto
the
data
stru
ctur
em-
>sec
ond.
writ
ers.
inse
rt( *
w);
}}
60}
}}
} std:
:get
line
(ifs
,lin
e,’\
n’);
} ifs.
clos
e();
for
(m=t
his-
>dep
ende
ncie
s.be
gin(
);m!
=thi
s->d
epen
denc
ies.
end(
);m+
+){
70co
nst
Sign
alNo
des
&sn
=( *
m).s
econ
d;
if(!
sn.w
rite
rs.e
mpty
()&&
!sn.
read
ers.
empt
y())
{fo
r(w
=sn.
writ
ers.
begi
n();
w!=s
n.wr
iter
s.en
d();
w++)
{as
sert
( *w)
;Ke
pThr
eadI
d*i
d_w
=( *w)
->ge
tThr
eadI
d();
asse
rt(i
d_w)
;
for
(r=s
n.re
ader
s.be
gin(
);r!
=sn.
read
ers.
end(
);r+
+){
asse
rt( *
r);
80Ke
pThr
eadI
d*i
d_r
=( *
r)->
getT
hrea
dId(
);as
sert
(id_
r);
if(!
all
&&id
_w->
conc
urre
nt(i
d_r)
){
( *w)
->ad
dRea
der(*r
,m->
firs
t);
}}
}}
}90
debu
g->u
nind
ent(
);de
bug-
>pri
nt("en
d␣KepDependencies::
add_dependencies."
);}
116
A.3. Interfacemodul des KEP
A.3. Interfacemodul des KEP
Als Ausführungsplattform für das Co-Design dient der KEP mit dem dazugehörigenKEP-Compiler in der Version 4.16. Die unter Microsoft Windows ausführbare Dateikepcmpv4.16.exe enthält sowohl einen Compiler von KASM in KEP Operations-code, als auch einen VHDL Codegenerator. Mit Hilfe des Codegenerators kann eineVHDL Beschreibung des KEP in einer individuell angepassten Konfiguration erzeugtwerden. Eine spezielle Option erlaubt es, die VHDL Beschreibung des Logikblocks zuimportieren und automatisch in den Code des Interfacemoduls zu integrieren. Dernachfolgende Code zeigt die Implementierung des Generators für den Logikblock.Der Programmcode innerhalb von if (CoDesignFlag==true) { } Blöcken ist rele-vant für die Integration des Logikblocks in das Interfacemodul.
117
A. Kommentierter Programmcode
A.3
.1.
blki
nter
face
.cpp
int
gene
rate
_blk
inte
rfac
e()
{in
ti,
tmpd
at1,
tmpd
at2,
tmpd
at3;
char
tmpc
har1
[2];
char
tmpc
har2
[8];
char
tmpc
hars
[Max
Char
s]="";
stri
ngtm
pstr
1,tm
pstr
2,tm
pstr
3,tm
pstr
4,tm
pstr
5;st
ring
tmpE
ntit
yNam
e;
10st
ring
tmps
tr[M
axSt
atem
ents
];st
ring
tmpS
igna
lNam
e[Ma
xSta
teme
nts]
[2];
//tm
pSig
nalN
ame[
x][0
]:na
me//
tmpS
igna
lNam
e[x]
[1]:
dir
and
type
(IN
|IN
V|
OUT
|OUT
V)
int
tmpf
lag1
;
ofst
ream
outf
ile1
("blk
inte
rface.v
hd",
ios_
base
::ou
t);
20if
(!ou
tfil
e1){
retu
rn-1
;}ou
tfil
e1<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"−−␣Genera
ted␣by␣"<
<ver
sion
<<"\n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"−−␣Xin␣Li\
n";
outf
ile1
<<"−−␣Realtim
e␣an
d␣Embed
ded
␣Sys
tem␣Gro
ups\
n";
outf
ile1
<<"−−␣Univ
ers
ity␣of␣
Kiel,␣
German
y\n";
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−␣\n";
outf
ile1
<<"−−␣Design␣N
ame:␣
Kie
l␣Est
ere
l␣Pro
cess
or␣
4\n";
outf
ile1
<<"−−␣Componen
t␣Nam
e:␣
blk
inte
rface\n";
30ou
tfil
e1<<"−−␣Desc
ription:\
n";
outf
ile1
<<"−−␣␣␣Addre
ss␣W
idth
␣=␣"<
<Add
ress
Widt
h<<"\n";
outf
ile1
<<"−−␣␣␣I/O␣Sig
nals␣=
␣"<
<Sig
nalN
um<<"\n";
//ou
tfil
e1<<"−−␣␣␣Valued␣I/O␣Sig
nals␣=
␣"<
<Val
uedN
um<<"\n";
outf
ile1
<<"−−␣␣␣Data
path
␣W
idth
␣(bit
)␣=␣"<
<Dat
aWid
th<<"\n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
tmpd
at1=
1;
//Re
ads
the
hard
ware
desc
ript
ion
ofth
elo
gic
bloc
kfr
omfi
le//
and
adds
ente
rsit
into
the
code
for
the
inte
rfac
ebl
ock.
40//
Furt
her
the
enti
tyna
meis
stor
edin
’tmp
Enti
tyNa
me’
and
the
inte
rfac
e//
decl
arat
ion
iswr
itte
nto
the
stri
ng’t
mpst
r’if
(CoD
esig
nFla
g==t
rue)
{//
cite
hw_v
hdl.
vhd
ifst
ream
inFi
le(H
WKEP
File
Name
.c_s
tr()
);tm
pfla
g1=1
;
tmpd
at1=
0;if
(!i
nFil
e)
{50
retu
rn-1
;}
whil
e(i
nFil
e.ge
tlin
e(tm
pcha
rs,M
axCh
ars)
){
outf
ile1
<<tm
pcha
rs<<"\n";
tmps
tr1=
tmpc
hars
;is
trin
gstr
eam
sbuf
2(tm
pstr
1);
sbuf
2>>t
mpst
r2>>
tmps
tr3>
>tmp
str4
;
60if
((up
per_
stri
ng(t
mpst
r2)=
="E
NTITY")
&&(u
pper
_str
ing(
tmps
tr4)
=="IS
"))
{tm
pEnt
ityN
ame=
tmps
tr3;
tmps
tr5=
tmpE
ntit
yNam
e;tm
pstr
5+=";"
;tm
pfla
g1=2
;}
if((
(upp
er_s
trin
g(tm
pstr
2)=="E
ND")
&&(u
pper
_str
ing(
tmps
tr3)
==up
per_
stri
ng(
tmpE
ntit
yNam
e)))
||((
uppe
r_st
ring
(tmp
str2
)=="E
ND")
&&(u
pper
_str
ing(
tmps
tr3)
==up
per_
stri
ng(t
mpst
r5))
)){
70tm
pfla
g1=1
;}
if((
tmpf
lag1
==0)
&&(t
mpst
r1.s
ize(
)>0)
){tm
pstr
[tmp
dat1
++]=
tmpc
hars
;}
if(t
mpfl
ag1=
=2){
tmpf
lag1
=0;}
}}
80ou
tfil
e1<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"libra
ry␣ie
ee;\
nuse
␣IE
EE.S
TD_LO
GIC_11
64.A
LL;\
nuse
␣IE
EE.
STD_LO
GIC_ARITH.A
LL;\
nuse
␣IE
EE.STD_LO
GIC_UNSIGNED
.ALL
;\n";
outf
ile1
<<"libra
ry␣UNISIM
;\nuse
␣UNISIM
.Vco
mponen
ts.A
LL;\
n";
outf
ile1
<<"entity
␣SDatReg
␣is
␣\n";
outf
ile1
<<"port
(␣clk
␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣clk
2␣␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣en
␣␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣en
2␣␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣we␣
␣:␣
in␣st
d_lo
gic
;␣\n";
90ou
tfil
e1<<"␣␣␣␣␣␣we2
␣␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣Addr:␣
in␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣Addr2
:␣in
␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣di␣
␣:␣
in␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
118
A.3. Interfacemodul des KEP
outf
ile1
<<"␣␣␣␣␣␣di2
␣␣:␣
in␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣do␣␣:␣
out␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣do2␣␣:␣
out␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0));\
n";
outf
ile1
<<"en
d␣SDatReg
;␣\n";
outf
ile1
<<"arc
hitectu
re␣Behavio
ral␣
of␣
SDatReg
␣is
␣\n";
outf
ile1
<<"co
mponen
t␣RAMB16_S3
6_S3
6\n";
100
outf
ile1
<<"port
(␣␣A
DDRA␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(8
␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣A
DDRB␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(8
␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣C
LKA␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣C
LKB␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣DIA
␣␣␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(3
1␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣DIB
␣␣␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(3
1␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣DIPA␣␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(3
␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣DIPB␣␣:␣
in␣␣␣␣st
d_lo
gic_vecto
r␣(3
␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣E
NA␣␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣E
NB␣␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
110
outf
ile1
<<"␣␣␣␣␣␣␣S
SRA␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣S
SRB␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣W
EA␣␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣W
EB␣␣␣:␣
in␣␣␣␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣D
OA␣␣␣:␣
out␣
␣␣st
d_lo
gic_vecto
r␣(3
1␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣D
OB␣␣␣:␣
out␣
␣␣st
d_lo
gic_vecto
r␣(3
1␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣D
OPA␣␣:␣
out␣
␣␣st
d_lo
gic_vecto
r␣(3
␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣D
OPB␣␣:␣
out␣
␣␣st
d_lo
gic_vecto
r␣(3
␣downto
␣0));\
n";
outf
ile1
<<"en
d␣co
mponen
t;\
n";
outf
ile1
<<"sig
nal␣
addra
:␣st
d_lo
gic_vecto
r(8
␣downto
␣0);␣
\n";
120
outf
ile1
<<"sig
nal␣
addrb
:␣st
d_lo
gic_vecto
r(8
␣downto
␣0);␣
\n";
outf
ile1
<<"sig
nal␣DOPA:␣
std_lo
gic_vecto
r(3
␣downto
␣0);␣
\n";
outf
ile1
<<"sig
nal␣DOPB:␣
std_lo
gic_vecto
r(3
␣downto
␣0);␣
\n";
outf
ile1
<<"begin
␣\n";
outf
ile1
<<"addra<=conv_std_logic_vecto
r(conv_inte
ger(Addr)
,9);␣
\n";
outf
ile1
<<"addrb
<=conv_std_logic_vecto
r(conv_inte
ger(Addr2
),9
);␣
\n";
outf
ile1
<<"SDatReg
:␣RAMB16_S3
6_S3
6␣port
␣map
␣(␣
addra
,␣addrb
,␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣clk
,␣clk2,␣
di,␣
di2
,␣\"0
000\
",␣
\"0
000\",␣
en,␣
en2,␣
’0’,
␣’0
’,␣we,␣
we2
,␣do
,␣do2,␣DOPA,D
OPB);␣
\n\n"
;13
0ou
tfil
e1<<"en
d␣Behavio
ral;\n\n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n\n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"libra
ry␣ie
ee;\
nuse
␣IE
EE.S
TD_LO
GIC_11
64.A
LL;\
nuse
␣IE
EE.
STD_LO
GIC_ARITH.A
LL;\
nuse
␣IE
EE.STD_LO
GIC_UNSIGNED
.ALL
;\n";
outf
ile1
<<"libra
ry␣UNISIM
;\nuse
␣UNISIM
.Vco
mponen
ts.A
LL;\
n";
outf
ile1
<<"entity
␣blk
inte
rface␣is
\n";
outf
ile1
<<"␣␣port
(␣␣cclk
␣:␣
in␣st
d_lo
gic
;\n";
if(S
imDe
bugM
etho
d==1
)14
0{
outf
ile1
<<"␣␣␣␣␣␣␣␣␣blk
inte
rfaceDebug:␣
out␣
std_lo
gic_vecto
r(3
1␣downto
␣0);\
n";
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣re
set␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣tick␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣wre
mit:in
␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣wrp
reemption:in
␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣wrp
reemptionty
pe:in
␣st
d_lo
gic_vecto
r(1
␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣Sin
out␣
:␣in
out␣st
d_lo
gic_vecto
r("
<<Si
gnal
Num-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣SDir␣:␣
in␣st
d_lo
gic
;␣␣␣␣−−␣’0
’:␣Sinout,␣
SDatReg
,␣etc
.,␣
Control␣
by␣environment\
n";
150
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣−−␣’1
’:␣Sinout,␣
SDatReg
,␣etc
.,␣
Control␣
by␣K
EP\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣SDatC
lk␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣SDat
␣:␣
inout␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣SDatID
␣:␣
in␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣S
DatWR␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣rd
pre
sent:␣
out␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣re
gDatin␣:␣
out␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣re
gDato
ut␣
:␣in
␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣in
nero
p:in
␣st
d_lo
gic_vecto
r(4
␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣in
nera
ddr␣
:␣in
␣st
d_lo
gic_vecto
r(8
␣downto
␣0);\
n";
160
outf
ile1
<<"␣␣␣␣␣␣␣␣␣innerm
ark
␣:␣
in␣st
d_lo
gic_vecto
r(5
␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣in
nerd
ata
␣:␣
in␣st
d_lo
gic_vecto
r(1
5␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣in
strc
lk:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣CurA
ddr:␣
in␣st
d_lo
gic_vecto
r("
<<Ad
dres
sWid
th-1
<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣W
atc
herS
ignal:
␣out␣
std_lo
gic_vecto
r("
<<Wa
tche
rMax
Num-
1<<
"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣LW
atc
herS
ignalC
ode:␣
in␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h-1
<<"␣downto
␣0);␣
␣−−no␣P
RE\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣LW
atc
herS
ignal:
␣out␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣TW
atc
herS
ignalC
ode:␣
in␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);␣
␣␣␣−−PRE␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣TW
atc
herS
ignal:␣out␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣Block
sCE:␣
in␣st
d_lo
gic
);\
n";
170
outf
ile1
<<"en
d␣blk
inte
rface;\
n";
outf
ile1
<<"␣␣␣␣arc
hitectu
re␣Behavio
ral␣
of␣
blk
inte
rface␣is
\n";
outf
ile1
<<"␣␣␣␣att
ribute
␣clo
ck_signal␣
:␣str
ing;\
n";
outf
ile1
<<"␣␣␣␣att
ribute
␣clo
ck_signal␣
of␣
cclk
:␣sig
nal␣
is␣\"y
es\";␣
\n";
outf
ile1
<<"␣␣␣␣const
ant␣
EMITR:␣
std_lo
gic_vecto
r(4
␣downto
␣0):=\"1
0010
\";␣
␣−−EMITR␣&
␣SUST
AIN
R\n";
outf
ile1
<<"␣␣␣␣const
ant␣
EMIT
:␣st
d_lo
gic_vecto
r(4
␣downto
␣0):=\"0
1000
\";␣
␣␣
−−EMIT␣&
␣SUSTAIN
␣&␣C
ANCEL\
n";
outf
ile1
<<"co
mponen
t␣SDatReg
␣is
␣\n";
outf
ile1
<<"port
(␣clk
␣:␣
in␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣␣␣clk
2:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣en
␣␣:␣
in␣st
d_lo
gic
;␣\n";
180
outf
ile1
<<"␣␣␣␣␣␣en
2␣␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣we␣
␣:␣
in␣st
d_lo
gic
;␣\n";
119
A. Kommentierter Programmcode
outf
ile1
<<"␣␣␣␣␣␣we2
␣:␣
in␣st
d_lo
gic
;␣\n";
outf
ile1
<<"␣␣␣␣␣␣Addr:␣
in␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣Addr2
:␣in
␣st
d_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣di␣
␣:␣
in␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣di2
␣:␣
in␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣do␣␣:␣
out␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣do2␣:␣
out␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0));\
n";
outf
ile1
<<"en
d␣co
mponen
t;␣
\n";
190
//De
clar
esth
elo
gic
bloc
kas
comp
onen
tof
the
inte
rfac
ebl
ock
if(C
oDes
ignF
lag=
=tru
e){
outf
ile1
<<"co
mponen
t␣"<
<tmp
Enti
tyNa
me<<"␣is
␣\n";
tmpd
at1=
0;wh
ile(
tmps
tr[t
mpda
t1].
size
()>0
){ou
tfil
e1<<"␣␣␣␣"<
<tmp
str[
tmpd
at1+
+]<<"\n";
200
}ou
tfil
e1<<"en
d␣co
mponen
t;\
n";
}
outf
ile1
<<"␣␣␣␣const
ant␣
ABORT:st
d_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0010
\";␣
␣␣
␣−−ABORT\n";
outf
ile1
<<"␣␣␣␣const
ant␣
ABORTI:
std_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0011
\";␣
␣␣−−ABORTI\n";
outf
ile1
<<"␣␣␣␣const
ant␣
WABORT
:st
d_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0100
\";␣
␣␣−−WABORT
\n";
outf
ile1
<<"␣␣␣␣const
ant␣
WABORTI:st
d_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0101
\";␣
␣−−WABORTI\n";
outf
ile1
<<"␣␣␣␣const
ant␣
SUSP
END:st
d_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0110
\";␣
␣−−SU
SPEN
D\n";
outf
ile1
<<"␣␣␣␣const
ant␣
SUSPENDI:
std_lo
gic_vecto
r(4
␣downto
␣0):=\"0
0111
\";
␣␣−−SUSPENDI\n";
210
outf
ile1
<<"␣␣␣␣sig
nal␣
tic
kflag:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
instrc
lkflag:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
wre
mitflag:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣−−sig
nal␣
wrp
reemptionflag:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
Sin
outB
uff
:␣st
d_lo
gic_vecto
r("
<<Si
gnal
Num-
1<<"␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
Sin
outreg:␣
std_lo
gic_vecto
r("
<<Si
gnal
Num<
<"␣downto
␣0)
;␣\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
pre
Sin
outreg:␣
std_lo
gic_vecto
r("
<<Si
gnal
Num<
<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
initSin
out:␣
std_lo
gic_vecto
r("
<<Si
gnal
Num<
<"␣downto
␣0);␣
\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
innerS
inoutF
lag:␣
std_lo
gic_vecto
r("
<<Si
gnal
Num<
<"␣
downto
␣0);\
n";
220
outf
ile1
<<"␣␣␣␣ty
pe␣W
atc
herS
ignalC
ode_ty
pe␣is
␣array␣("
<<Wa
tche
rMax
Num-
1<<"␣
downto
␣0)␣
of␣
std_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
Watc
herS
ignalC
ode:␣
Watc
herS
ignalC
ode_ty
pe;\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
ClkMux:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
ClkKEP:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegWRKEP:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
IDKEP:␣
std_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DIK
EP:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegDOKEP:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
230
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
ClkKEP2:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegWRKEP2:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
IDKEP2:␣
std_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DIK
EP2:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegDOKEP2:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatR
egClk
:␣st
d_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegWR:␣
std_lo
gic
;\n";
240
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
EN:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
ID:␣
std_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DI:
␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DO:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatR
egClk2:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
EN2:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatRegWR2:␣
std_lo
gic
;\n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
ID2:␣
std_lo
gic_vecto
r("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DI2
:␣st
d_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
250
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatReg
DO2:␣
std_lo
gic_vecto
r("
<<Da
taWi
dth-
1<<"␣downto
␣0);\
n";
if(C
oDes
ignF
lag=
=tru
e){
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatB
oolean:␣
std_lo
gic_vecto
r("
<<Si
gnal
Num<
<"␣
downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣sig
nal␣
SDatB
ooleanLogic
:␣st
d_lo
gic_vecto
r("
<<Si
gnal
Num<
<"
␣downto
␣0);\
n";
}
//(m
odif
ied
bysg
a)if
(CoD
esig
nFla
g==t
rue)
260
{tm
pdat
1=0;
tmpd
at2=
0;wh
ile(
tmps
tr[t
mpda
t1].
size
()>0
){
repl
ace(
tmps
tr[t
mpda
t1].
begi
n(),
tmps
tr[t
mpda
t1].
end(
),’(
’,’
’);
repl
ace(
tmps
tr[t
mpda
t1].
begi
n(),
tmps
tr[t
mpda
t1].
end(
),’)
’,’
’);
120
A.3. Interfacemodul des KEP
repl
ace(
tmps
tr[t
mpda
t1].
begi
n(),
tmps
tr[t
mpda
t1].
end(
),’:
’,’
’);
tmps
tr[t
mpda
t1]=
uppe
r_st
ring
(tmp
str[
tmpd
at1]
);tm
pdat
1++;
270
}
tmpd
at1=
0;
//st
ore
the
name
sof
all
inte
rfac
esi
gnal
sof
the
logi
cbl
ock
and
thei
r//
dire
ctio
nin
’tmp
Sign
alNa
me’.
Anad
diti
onal
ly’V
’in
dica
tes
that
the
sign
al//
isbo
olea
nwh
ile(
tmps
tr[t
mpda
t1].
size
()>0
){is
trin
gstr
eam
sbuf
2(tm
pstr
[tmp
dat1
]);
280
tmps
tr1="␣";
whil
e(tm
pstr
1.si
ze()
>0)
{tm
pstr
2=tm
pstr
1;sb
uf2>
>tmp
str1
;if
((tm
pstr
1=="IN
")||
(tmp
str1
=="O
UT")
){st
ring
type
;sb
uf2
>>ty
pe;
tmpS
igna
lNam
e[tm
pdat
2][0
]=tm
pstr
2;29
0tm
pSig
nalN
ame[
tmpd
at2]
[1]=
tmps
tr1;
if((
type
!="S
TD_LO
GIC")
&&(t
ype
!="S
TD_LO
GIC
;"))
tmpS
igna
lNam
e[tm
pdat
2][1
]+=
"V";
tmpd
at2+
+;}
}tm
pdat
1++;
}
tmpd
at1=
0;30
0//
decl
are
loca
lsi
gnal
swi
thth
ena
mean
dty
peof
the
inte
rfac
esi
gnal
sof
the
logi
cbl
ock
whil
e(tm
pSig
nalN
ame[
tmpd
at1]
[0].
size
()>0
){ou
tfil
e1<<
"␣␣␣␣sig
nal␣
"<<
tmpS
igna
lNam
e[tm
pdat
1][0
];//
test
ifsi
gnal
isbo
olea
nif
((tm
pSig
nalN
ame[
tmpd
at1]
[1]=
="IN
")||
(tmp
Sign
alNa
me[t
mpda
t1][
1]=="O
UT")
)ou
tfil
e1<<
":␣
std_lo
gic
;␣␣\n";
else ou
tfil
e1<<
":␣
std_lo
gic_vecto
r(1
␣downto
␣0);␣
␣\n";
310
//ou
tfil
e1<<"\n";
tmpd
at1+
+;}
}
outf
ile1
<<"begin
\n\n";
outf
ile1
<<"SDat_Reg
:␣SDatReg
␣port
␣map
␣(SDatReg
Clk
,␣SDatReg
Clk2,␣
SDatReg
EN,␣
SDatReg
EN2,␣
SDatRegWR,␣
SDatRegWR,␣
SDatReg
ID,␣
SDatReg
ID2
,␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
DI,␣
SDatReg
DI2
,␣SDatReg
DO
,␣SDatReg
DO2);␣
\n";
320
//in
stan
tiat
eth
elo
gic
bloc
kif
(CoD
esig
nFla
g==t
rue)
{ou
tfil
e1<<
tmpE
ntit
yNam
e<<"_in
stant:␣
"<<t
mpEn
tity
Name
<<"␣port
␣map
␣(␣
\n";
tmpd
at1=
0;wh
ile(
tmpS
igna
lNam
e[tm
pdat
1][0
].si
ze()
>0)
{if
(tmp
dat1
>0)
330
{ou
tfil
e1<<",\
n";
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣"<
<tmp
Sign
alNa
me[t
mpda
t1][
0];
tmpd
at1+
+;}
outf
ile1
<<");\
n";
}ou
tfil
e1<<"pro
cess
(cclk
,re
set)\
n";
340
outf
ile1
<<"begin
\n";
outf
ile1
<<"if
␣fa
llin
g_edge(cclk
)␣th
en\n";
outf
ile1
<<"−−if
␣Block
sCE=’1
’␣th
en\n";
outf
ile1
<<"␣␣␣␣if
␣re
set=’1
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣Sin
outreg<=(o
thers
=>’0’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣pre
Sin
outreg<=(o
thers
=>’0’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣in
itSin
out<=(o
thers
=>’1’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣tickflag<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣in
str
clk
flag<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣wre
mitflag<=’0
’;\n";
350
outf
ile1
<<"␣␣␣␣␣␣␣␣−−wrp
reemptionflag<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣S
DatRegWRKEP<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣fo
r␣i␣
in␣0␣to
␣"<
<Wat
cher
MaxN
um-1
<<"␣loop\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣W
atc
herS
ignalC
ode(i)<=(o
thers
=>’0’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣en
d␣loop;\
n";
outf
ile1
<<"␣␣␣␣else\n";
//Pr
oduc
esVH
DLco
deto
wire
the
Logi
cBl
ock
with
the
inte
rfac
ebl
ock
//’t
mpSi
gnal
Name
’co
ntai
nsth
ein
terf
ace
sign
als
ofth
elo
gic
bloc
k//
’Sig
nalT
able
’ma
psth
esi
gnal
name
used
inth
eEs
tere
lpr
ogra
mto
360
//th
ead
dres
sin
the
SDat
Reg
//(c
ode
modi
fied
bysg
a)if
(CoD
esig
nFla
g==t
rue)
{tm
pdat
1=0;
whil
e(tm
pSig
nalN
ame[
tmpd
at1]
[0].
size
()>0
){tm
pdat
2=0;
whil
e(Si
gnal
Tabl
e[tm
pdat
2][0
].si
ze()
>0)
{37
0if
(Sig
nalT
able
[tmp
dat2
][0]
==tm
pSig
nalN
ame[
tmpd
at1]
[0])
{is
trin
gstr
eam
sbuf
2(Si
gnal
Tabl
e[tm
pdat
2][2
]);
121
A. Kommentierter Programmcode
sbuf
2>>t
mpda
t3;
//wr
ite
addr
ess
ofth
esi
gnal
inth
eSD
atRe
gto
tmpd
at3
//no
teth
atSD
atRe
gha
stw
ice
the
size
ofSi
nout
Reg
//or
SDat
Bool
ean
tost
ore
the
pre
valu
esif
((tm
pSig
nalN
ame[
tmpd
at1]
[1]=
="IN
")||
(tmp
Sign
alNa
me[t
mpda
t1][
1]=="IN
V")
){
outf
ile1
<<"␣␣␣␣␣␣␣␣"<
<tmp
Sign
alNa
me[t
mpda
t1][
0];
if(t
mpSi
gnal
Name
[tmp
dat1
][1]
=="IN
"){
380
outf
ile1
<<"<
=in
nerS
inoutF
lag("
<<tm
pdat
3/2<
<");\
n";
} else
{ou
tfil
e1<<"(0
)<=in
nerS
inoutF
lag("
<<tm
pdat
3/2<
<");\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣"<
<tmp
Sign
alNa
me[t
mpda
t1][
0]<<"(1
)<=
SDatB
oolean("
<<tm
pdat
3/2<
<");\
n";
}}
else {
outf
ile1
<<"␣␣␣␣␣␣␣␣SinoutR
eg("
<<tm
pdat
3/2<
<")<
=";
390
if(t
mpSi
gnal
Name
[tmp
dat1
][1]
=="O
UT")
outf
ile1
<<tm
pSig
nalN
ame[
tmpd
at1
][0]
<<";\
n";
else
{ou
tfil
e1<<
tmpS
igna
lNam
e[tm
pdat
1][0
]<<"(0
);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣SDatB
oolean("
<<tm
pdat
3/2<
<")<
="<
<tm
pSig
nalN
ame[
tmpd
at1]
[0]<
<"(1
);\
n";
}}
}tm
pdat
2++;
}tm
pdat
1++;
400
}}
outf
ile1
<<"␣␣␣␣␣␣␣␣tickflag<=tick;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣in
str
clk
flag<=in
strc
lk;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣wre
mitflag<=wre
mit;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣−−wrp
reemptionflag<=wrp
reemption;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣S
DatRegWRKEP<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣S
DatRegWRKEP2<=’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣SDatReg
IDKEP<=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)␣
&␣
’0’;\n";
410
outf
ile1
<<"␣␣␣␣␣␣␣␣SDatReg
IDKEP2<
=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)␣
&␣
’1’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣if
␣wre
mit=’1
’␣an
d␣wre
mitflag=’0
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣if
␣innerm
ark
(5␣downto
␣4)=
\"11
\"␣th
en␣␣␣␣−−CANCEL␣
(SIG
NAL␣IN
)\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣Sin
outreg(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’0’;\n";
if(p
resu
ppor
t==t
rue)
{ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣pre
Sin
outreg(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’0’;\n";
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣els
if␣in
nero
p=EMIT␣th
en␣␣␣␣␣␣−−EMIT
,␣SUSTAIN
,␣SE
TV\n";
420
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣innerm
ark
(5␣downto
␣4)/
=\"
10\"␣th
en␣␣␣␣−−
EMIT␣or␣
SUSTAIN
␣(not␣
SETV)␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣Sin
outreg(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’1’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣0)>
"<<
Gen_
Init
_Str
(Sig
nalW
idth
+1,1
)<<"␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣in
itSin
out(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’0’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
IDKEP<=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣
downto
␣1)␣
&␣’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
DIK
EP<="<
<Gen
_Ini
t_St
r(Da
taWi
dth-
16,0
)<<"␣
&␣in
nerd
ata
(15␣downto
␣0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣S
DatRegWRKEP<=’1
’;\n";
if(p
resu
ppor
t==t
rue)
430
{ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣innerm
ark
(5␣downto
␣4)/
=\"
10\"␣th
en␣
␣␣␣−−EMIT␣or␣
SUSTAIN
␣(not␣
SETV)␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣in
itSin
out(conv_inte
ger(
innera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))=’1
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
IDKEP2<
=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)␣
&␣’1
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
DIK
EP2<
=SDatRegDOKEP;\
n"; outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣S
DatRegWRKEP2<=’1
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
440
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣else␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣−−EMITR,␣
SUST
AIN
R\n
";ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣innerm
ark
(5␣downto
␣4)/
=\"
10\"␣th
en␣␣␣␣−−
EMITR␣or␣
SUST
AIN
R␣(not␣
SETV)␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣Sin
outreg(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’1’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣0)>
"<<
Gen_
Init
_Str
(Sig
nalW
idth
+1,1
)<<"␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣in
itSin
out(conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))<=’0’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
IDKEP<=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣
downto
␣1)␣
&␣’0
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
DIK
EP<=re
gDato
ut;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣S
DatRegWRKEP<=’1
’;\n";
if(p
resu
ppor
t==t
rue)
450
{ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣innerm
ark
(5␣downto
␣4)/
=\"
10\"␣th
en␣
␣␣␣−−EMITR␣or␣
SUST
AIN
R␣(not␣
SETVR)␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣if
␣in
itSin
out(conv_inte
ger(
innera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))=’1
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
IDKEP2<
=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)␣
&␣’1
’;\n";
122
A.3. Interfacemodul des KEP
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣SDatReg
DIK
EP2<
=SDatRegDOKEP;\
n"; outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣S
DatRegWRKEP2<=’1
’;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
460
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣if
␣(in
nero
p=ABORT␣or␣
innero
p=ABORTI␣
or␣
innero
p=
WABORT
␣or␣
innero
p=WABORTI␣or␣
innero
p=SU
SPEN
D␣or␣
innero
p=SUSPENDI)␣
and␣in
strc
lk=’1
’␣an
d␣in
strc
lkflag=’0
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣W
atc
herS
ignalC
ode(conv_inte
ger(innerm
ark
(4␣
downto
␣0)))<
=in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣0);\
n";
/ *ou
tfil
e1<<"␣␣␣␣␣␣␣␣else␣␣−−␣R
EAD␣(LOAD,␣ADD,␣
...␣)␣
\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣if
␣in
nera
ddr(0
)=’1
’␣an
d␣in
itSin
out(conv_inte
ger
(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1)))=’0
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣re
gDatIn<=SDatRegDOKEP2;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣else\n";
470
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣re
gDatIn<=SDatRegDOKEP;\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
*/ outf
ile1
<<"␣␣␣␣␣␣␣␣en
d␣if
;\n";
//ou
tfil
e1<<"␣␣␣␣␣␣␣␣if
␣tic
kflag=’1
’␣an
d␣tick=’0
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣if
␣tic
kflag=’0
’␣an
d␣tick=’0
’␣th
en\n";
if(p
resu
ppor
t==t
rue)
{ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣pre
Sin
outreg<=(S
inoutB
uff␣&
␣’1
’)␣or␣
Sin
outreg
;\n";
480
}ou
tfil
e1<<"␣␣␣␣␣␣␣␣␣␣␣␣SinoutR
eg<=(o
thers
=>’0’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣in
itSin
out<=(o
thers
=>’1’);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"−−en
d␣if
;\n";
outf
ile1
<<"en
d␣if
;\n";
outf
ile1
<<"en
d␣pro
cess
;\n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"−−in
nerS
inoutF
lag<=(S
inoutB
uff␣&
␣’1
’)␣or␣
SinoutR
eg;\
n";
490
outf
ile1
<<"in
nerS
inoutF
lag<=(S
inout␣
&␣’1
’)␣or␣
SinoutR
eg;\
n";
outf
ile1
<<"−−SinoutB
uff<=Sin
out␣
whe
n␣SDir=’1
’␣else␣(oth
ers
=>’0’);\
n";
outf
ile1
<<"Sinout<
=SinoutR
eg("
<<Si
gnal
Num<
<"␣downto
␣1)␣
when
␣SDir=’0
’␣else␣(
oth
ers
=>’Z
’);\
n";
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"W
atc
herS
ignalG
en:␣
\n";
outf
ile1
<<"fo
r␣i␣
in␣0␣to
␣"<
<Wat
cher
MaxN
um-1
<<"␣genera
te␣\n";
if(p
resu
ppor
t==t
rue)
{
outf
ile1
<<"W
atc
herS
ignal(
i)<=in
nerS
inoutf
lag(conv_inte
ger(
Watc
herS
ignalC
ode(i)
("<<
Sign
alWi
dth<
<"␣downto
␣1)))␣
when
␣W
atc
herS
ignalC
ode(i)
(0)=’0
’␣else\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣pre
Sin
outreg(conv_inte
ger(
Watc
herS
ignalC
ode(i)
("<<
Sign
alWi
dth<
<"␣downto
␣1)));\
n";
500
}el
se {ou
tfil
e1<<"W
atc
herS
ignal(
i)<=in
nerS
inoutf
lag(conv_inte
ger(
Watc
herS
ignalC
ode(i)
("<<
Sign
alWi
dth<
<"␣downto
␣1)));\
n";
}ou
tfil
e1<<"en
d␣genera
te;␣
\n";
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n
";ou
tfil
e1<<"LW
atc
herS
ignal<
=in
nerS
inoutf
lag(conv_inte
ger(
LW
atc
herS
ignalC
ode));\
n";
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n
";if
(pre
supp
ort=
=tru
e)51
0{ou
tfil
e1<<"TW
atc
herS
ignal<=in
nerS
inoutf
lag(conv_inte
ger(
TW
atc
herS
ignalC
ode("
<<Si
gnal
Widt
h<<"␣downto
␣1)))␣
when
␣TW
atc
herS
ignalC
ode(0
)=’0
’␣else\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣␣pre
Sin
outreg(conv_inte
ger(
TW
atc
herS
ignalC
ode("
<<Si
gnal
Widt
h<<"␣downto
␣1)));\
n";
}el
se {ou
tfil
e1<<"TW
atc
herS
ignal<=in
nerS
inoutf
lag(conv_inte
ger(
TW
atc
herS
ignalC
ode("
<<Si
gnal
Widt
h<<"␣downto
␣1)));\
n";
}
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n
";52
0if
(pre
supp
ort=
=tru
e){ou
tfil
e1<<"rd
pre
sent<
=in
nerS
inoutf
lag((
conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1))))␣
when
␣in
nera
ddr(0
)=’0
’␣else\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣pre
Sin
outreg((
conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1))));\
n";
}el
se {ou
tfil
e1<<"rd
pre
sent<
=in
nerS
inoutf
lag((
conv_inte
ger(in
nera
ddr("
<<Si
gnal
Widt
h<<"␣downto
␣1))));\
n";
}ou
tfil
e1<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
530
outf
ile1
<<"SDatReg
Clk<=cclk
␣when
␣tick=’1
’␣else␣SDatC
lk;\
n";
outf
ile1
<<"SDatRegWR<
=SD
atRegWRKEP␣when
␣tick=’1
’␣else␣S
DatWR;\
n";
outf
ile1
<<"SDatReg
ID<=SDatReg
IDKEP␣when
␣tick=’1
’␣else␣SDatID
;\n";
outf
ile1
<<"SDat<=SDatReg
DO␣when
␣SDatWR=’0
’␣an
d␣tick=’0
’␣else␣(oth
ers
=>’
Z’)
;\n";
outf
ile1
<<"SDatReg
DI<=SDat
␣when
␣SDatWR=’1
’␣an
d␣tick=’0
’␣else␣
SDatReg
DIK
EP;\
n";
outf
ile1
<<"SDatReg
EN<=’1
’;\n";
outf
ile1
<<"−−SDatReg
EN2<
=Block
sCE;\
n";
outf
ile1
<<"SDatReg
EN2<=’1
’;\n";
123
A. Kommentierter Programmcode
//ge
nera
tes
the
SDat
Bool
ean
regi
ster
that
stor
esth
eva
lues
540
//co
nnec
ted
toth
ein
put
with
the
fall
ing
edge
ofSD
atRe
gClk
//(c
ode
modi
fied
bysg
a)if
(CoD
esig
nFla
g==t
rue)
{ou
tfil
e1<<"pro
cess
␣(SDatReg
Clk
,re
set)\
n";
outf
ile1
<<"begin
\n";
outf
ile1
<<"␣␣␣if
␣fa
llin
g_edge(SDatR
egClk)␣
then\n";
outf
ile1
<<"␣␣␣␣␣␣if
␣re
set=’1
’␣th
en\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣SDatB
oolean␣<
=␣(oth
ers
␣=>␣’0
’);\
n";
outf
ile1
<<"␣␣␣␣␣␣else\n";
550
outf
ile1
<<"␣␣␣␣␣␣␣␣␣if
␣SDatRegWR=’1
’␣th
en␣\n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣␣␣␣SDatB
oolean(conv_inte
ger(SDatReg
ID))␣<=␣
SDatReg
DI(
0);\
n";
outf
ile1
<<"␣␣␣␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣␣␣␣en
d␣if
;\n";
outf
ile1
<<"␣␣␣en
d␣if
;\n";
outf
ile1
<<"en
d␣pro
cess
;\n";
}
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n
";ou
tfil
e1<<"SDatReg
Clk2<
=cclk
␣an
d␣tick;\
n";
560
outf
ile1
<<"SDatReg
ID2<
=SDatReg
IDKEP2;\
n";
outf
ile1
<<"SDatRegWR2<
=SDatRegWRKEP2;\
n";
outf
ile1
<<"SDatReg
DI2<=SDatReg
DIK
EP2;\
n";
outf
ile1
<<"SDatRegDOKEP2<
=SDatReg
DO2;\
n";
outf
ile1
<<"SDatRegDOKEP<
=SDatReg
DO;\
n";
outf
ile1
<<"−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\n
";if
(pre
supp
ort=
=tru
e){
outf
ile1
<<"re
gDatIn<=SDatRegDOKEP2␣when
␣in
nera
ddr(0
)=’1
’␣an
d␣
initSin
out(conv_inte
ger(in
nera
ddr(6
␣downto
␣1)))=’0
’␣else␣
SDatRegDOKEP;\
n";
}57
0el
se {if
(CoD
esig
nFla
g==t
rue)
{ou
tfil
e1<<"re
gDatIn<=SDatRegDOKEP("
<<Da
taWi
dth-
1<<"␣downto
␣1)␣
&␣
SDatB
oolean(conv_inte
ger(SDatReg
ID));\
n";
}el
se {ou
tfil
e1<<"re
gDatIn<=SDatRegDOKEP;\
n";
}58
0}
outf
ile1
<<"
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−\
n";
outf
ile1
<<"en
d␣Behavio
ral;\n";
outf
ile1
.clo
se()
;re
turn
0;}
124
top related