diplomarbeit -...

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

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,

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


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


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.


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


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.


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


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

• 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


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


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


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


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


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


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


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


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

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


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


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


[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


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


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

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


[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


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

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


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


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


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


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


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


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


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

http://www.i3s.unice.fr/~andre/CA Publis/SYNCCHARTS/SyncCharts.pdf

http://www.i3s.unice.fr/~andre/CA Publis/SYNCCHARTS/SyncCharts.pdf


[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

http://www1.cs.columbia.edu/~sedwards/software/estbench-1.0.tar.gz

http://www1.cs.columbia.edu/~sedwards/software/estbench-1.0.tar.gz

http://www1.cs.columbia.edu/~sedwards/cec/

http://www1.cs.columbia.edu/~sedwards/cec/

http://www.esterel-technologies.com/products/esterel-studio/overview.html

http://www.esterel-technologies.com/products/esterel-studio/overview.html

http://www-sop.inria.fr/esterel.org/Html/History/History.htm

http://www-sop.inria.fr/esterel.org/Html/History/History.htm


[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

http://e-diss.uni-kiel.de/tech-fak.html

http://e-diss.uni-kiel.de/tech-fak.html

http://www.cs.uic.edu/~jlillis/courses/cs594/spring05/blif.pdf

http://www.informatik.uni-kiel.de/rtsys/kep/

http://www.informatik.uni-kiel.de/rtsys/kep/

http://www.xilinx.com/cgi-bin/power_tool/power_Virtex2p

http://www.xilinx.com/cgi-bin/power_tool/power_Virtex2p


[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


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

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

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


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

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

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

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

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

}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

.7.

CoD

esig

nEst

erel

Print

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

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

.8.

CoD

esig

nEst

erel

Print

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

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(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(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

if(u

nary

leve

l[dy

nami

c_ca

st(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(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

));

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

(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

//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

} / *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(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

//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(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

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

}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

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

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

} 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

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

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

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


}

90


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

.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

#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

}} / *

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

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

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

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

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

.14.

CoD

esig

nHW

SW

Print

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

#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

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

.15.

CoD

esig

nHW

SW

Print

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

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

||(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

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

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

} 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

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

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

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

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

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(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

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

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

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


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

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


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

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


ant␣

ABORT:st

d_lo

gic_vecto

r(4

␣downto

␣0):=\"0

0010

\";␣

␣␣

␣−−ABORT\n";

outf

ile1


ant␣

ABORTI:

std_lo

gic_vecto

r(4

␣downto

␣0):=\"0

0011

\";␣

␣␣−−ABORTI\n";

outf

ile1


ant␣

WABORT

:st

d_lo

gic_vecto

r(4

␣downto

␣0):=\"0

0100

\";␣

␣␣−−WABORT

\n";

outf

ile1


ant␣

WABORTI:st

d_lo

gic_vecto

r(4

␣downto

␣0):=\"0

0101

\";␣

␣−−WABORTI\n";

outf

ile1


ant␣

SUSP

END:st

d_lo

gic_vecto

r(4

␣downto

␣0):=\"0

0110

\";␣

␣−−SU

SPEN

D\n";

outf

ile1


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

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

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

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

//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

diplomarbeit -...

Documents