Functional hardware description in Lava

Functional hardware description in Lava
Alexander Sulfrian (2009)
Einleitung:
Dieses Dokument befasst sich mit der Möglichkeit logische Schaltkreise in Haskell zu
beschreiben. Es existieren verschiedene andere Varianten um Hardware am PC zu
beschreiben. Die verbreitetsten sind VHDL in Europa und Verilog in den USA. Diese
formalen Sprachen dienen dazu über eine gewisses Abstraktionsebene Schaltkreise zu
beschreiben. Dabei sind diese Sprache aber sehr kompliziert und mit erst mit viel
Einarbeitung zu verstehen. Dazu kommt, dass für eine einfache Schaltung schon diese
Sprache schon sehr umfangreich werden können.
Wir verwenden zur Beschreibung von Hardware das Modul Lava2000. Dieses kann im
Gegensatz zu den anderen Sprachen mit einfachen Haskellfunktionen aus
grundlegenden logischen Gattern ganze Schaltungen beschreiben und simulieren.
Dabei dient es bei der Verifikation oder auch bei der realen Fertigung nur als Frontend
für andere Anwendung und kann die Schaltungen dann auch in VHDL (das vorwiegend
zur Konfiguration von programmierbaren integrierten Schaltkreisen dient) exportieren.
Zu Beginn werde ich kurz auf die Installation von Lava200 und den benötigten
Anwendungen eingehen. Danach werde ich versuchen an Hand von anschaulichen
Beispielen die Idee hinter Lava zu zeigen. Dabei werde ich von Grundlagen, über
einfache logische Gatter, bis hin zu komplexen logischen Schaltnetzen und
Schaltwerken die Methoden von Lava erläutern.
Installation
Lava2000 ist ein Haskellmodul. Es sollte klar sein, dass für den Betrieb von diesem
eine Haskellcompiler (zum Beispiel der ghc) vorhanden sein muss. Da allerdings viele
gezeigten Anwendungen interaktiv sein können, wäre es vorteilhaft wenn auch der
zugehörige Interpreter (ghci) installiert wäre. Damit Lava installiert werden kann sind
darüber hinaus noch darcs (das Versionsverwaltungssystem von den meisten
Haskellprojekten) sowie cabal (das Haskellpaketverwaltungssystem) von Vorteil.
Zur Zeit existieren mindestens 2 Versionen von Lava. Lava2000 (auch Chalmers-Lava)
soll vor allem als Interface für formale Verifikationstools dienen. Parallel dazu wurde
von Xilinx Inc. eine weitere Version von Lava entwickelt, die im Gegensatz dazu vor
allem zum Erstellen von Konfigurationen für die FPGAs von Xilinx geeignet ist. Im
folgenden liegt der Schwerpunkt hier auf dem Chalmers-Lava Modul. 1
Zur Installation von Lava2000 ist die zunächst einfach wie folgt herunterzuladen:
darcs get http://www.cs.chalmers.se/~emax/darcs/chalmers-lava2000/
Danach ist eine Besonderheit von Lava zu beachten: Für verschiedene Aufgaben
werden externe Tools benutzt. Daher benötigt Lava den Pfad der Installation um
benutzerdefinierte Scripte zu laden. Dieser Pfad muss in der Datei
Lava2000/LavaDir.hs im heruntergeladenem Sourcecode anzupassen. Danach kann
Lava genau wie jedes andere cabal-Projekt mit den folgenden 3 Schritten installiert
werden: (hier am Beispiel für den ghc)
runghc Setup configure
runghc Setup build
runghc Setup install
1: http://www.cs.chalmers.se/~koen/Lava/
Seite 1/7

Um Schaltungen zu Verifizieren benötigt man nun noch eine externe Anwendung. Hier
wird die nötige Konfiguration am Beispiel von NuSMV 2 erläutert: Nach der Installation
von NuSMV muss man noch eine passende Scriptdatei für die Anbindung an Lava
erstellen. Die smv.wrapper die bei Lava dabei ist, ist leider für eine ältere Version und
nicht mit NuSMV kompatibel. Daher habe ich diese modifiziert. Die veränderte Version
kann jetzt unter http://download.animux.de/smv.wrapper heruntergeladen werden.
Diese Datei muss an den Pfad der in Lava2000/LavaDir.hs angegeben wurde in Scripts/
abgelegt werden.
Wenn dies geschafft ist, ist Lava endlich einsatzbereit und man kann anfangen
Schaltungen damit zu beschreiben, zu simulieren und zu verifizieren.
Schaltnetze
Schaltnetze sind eine der grundlegende Strukturen von logischen Schaltungen. Dies
sind logische Formeln aus der Mathematik in Hardware als ein Netz aus logischen
Gattern. Dabei findet man in Schaltnetzen keine Gatter die ihren Zustand speichern
und deshalb haben Schaltnetze keinen inneren Zustand. Bei einer Belegung der
Eingänge kann man unabhängig von der vorherigen Belegung immer die selben Werte
an den Ausgängen messen.
• Die einfachste Struktur ist ein Halbaddierer:
Dieses Schaltnetz realisiert die Addition der beiden Eingänge. Dabei liefert es
zum einen die Summe und an einem anderen Ausgang den Übertrag, der bei
der Addition von 2 Bit entstehen kann. Die Umsetzung von dieser Struktur in
Lava sieht wie folgt aus:
import Lava2000
halfAdd :: (Signal Bool, Signal Bool) -> (Signal Bool, Signal Bool)
halfAdd(a,b) = (sum,carry)
where
sum = xor2(a,b)
carry = and2(a,b)
Wie man erkennen kann, kann der Schaltplan direkt 1-zu-1 nach Lava
übersetzt werden und mit den logischen Gattern die Lava bereit stellt
nachgebaut werden.
• Allerdings reicht meißt ein Halbaddierer nicht aus. Mit diesem kann man wie der
Name schon sagt Bits nur zur Hälfte addieren. Um mehrere Bits addieren zu
können benötigt man einen Volladdierer:
2: NuSMV - a new symbolic model checker: http://nusmv.irst.itc.it/
Seite 2/7

Der Volladdierer erhält als Eingang ähnlich wie der Halbaddierer auch zwei
Werte die er addiert. Er hat allerdings zusätzlich einen Eingang um einen
Überlauf von einer vorherigen Addition aufzunehmen. Das Ergebnis dieser 3
Bit gibt er genauso wie der Halbaddierer als Summe und Überlauf aus.
Wie man erkennen kann ist der Volladdierer aus 2 Halbaddierern aufgebaut.
Da Lava die Schaltungen als Funktionen darstellt, ist die Wiederverwendung
besonders einfach:
fullAdd :: (Signal Bool, (Signal Bool, Signal Bool)) ->
(Signal Bool, Signal Bool)
fullAdd(carryIn, (a,b)) = (sum,carryOut)
where
(sum1, carryOut1) = halfAdd(a,b)
(sum, carryOut2) = halfAdd(carryIn,sum1)
carryOut = xor2(carryOut1,carryOut2)
Auch hier wird wieder die 1-zu-1 Übersetzung des Schaltbildes in Lava
sichbar.
• Nachdem wir nun die Voraussetzung für die Addition von mehreren Bits mit dem
Volladdierer geschaffen haben, können wir nun eine Schaltung beschreiben, die
ein Bit zu einer ganzen Liste von Bits addiert und die resultierende Liste und
einen eventuellen Überlauf zurückgibt. Die Liste könnte hierbei als Binärzahl
gesehen werden, wobei anders als bei der üblichen Schreibweise das
niederwertigste Bit am Anfang steht:
bitAdder :: (Signal Bool, [Signal Bool]) ->
([Signal Bool], Signal Bool)
bitAdder(carryIn, []) = ([], carryIn)
bitAdder(carryIn, a:as) = (sum : sums, carryOut)
where
(sum, carry) = halfAdd(carryIn, a)
(sums, carryOut) = bitAdder(carry, as)
Das besondere bei dieser Lavafunktion ist, dass dies keine Beschreibung für
eine Schaltung ist, sondern eine Beschreibung für eine ganze Gruppe
Schaltungen. Durch die Rekursion in der Funktion über die Liste vom Eingang
wird erst durch die Belegung des Parameters entschieden wie groß die
Schaltung sein wird. Dabei wird die Rekursion verwendet um ein Muster zu
beschreiben. Dadurch entsteht eine Rekursion über Raum bzw. über die
Struktur der Schaltung.
• Mit diesem Vorwissen können wir jetzt relativ einfach einen kompletten
Addierer erstellen. Dieser erhält als Eingabe 2 gleichlange Listen mit binär
Zahlen (wie oben erwähnt in umgekehrter Reihenfolge) und einen evtl. Überlauf
von einer früheren Addition. Die beiden Zahlen werden mit Hilfe des ripple-carry
Schemas addiert. Dadruch entsteht zwar der Nachteil, dass die Zahlen
gleichlang sein müssen. Dies ist aber öftmals beim Hardwaredesign gegeben
(zum Beispiel bei einem PC sind die Zahlen meißt 32bit oder 64bit lang) oder
die folgende Implementierung ließe sich relativ einfach erweitern:
adder :: (Signal Bool, ([Signal Bool],[Signal Bool])) ->
([Signal Bool], Signal Bool)
adder(carryIn, ([], [])) = ([], carryIn)
adder(carryIn, (a:as, b:bs)) = (sum : sums, carryOut)
where
Seite 3/7

(sum, carry) = fullAdd(carryIn, (a, b))
(sums, carryOut) = adder(carry, (as, bs))
Ähnlich wie dieser Addierer könnte mit diesem Rekursionsschema auch eine
Struktur zur Subtraktion oder Multiplikation erstellt werden.
Gerade in den letzten beiden Beispielen wurde deutlich, dass viele Schaltungen
ähnliche Strukturen verwenden. Um diese zusammen zufassen liefert Lava
polymorphe (also für alle Typen definierte) Verbindungsfunktionen. Die einfachsten
Verbindungen sind parallele und serielle Schaltungen. Diese könnte man zwar auch
ohne die Funktionen die Lava bietet realisieren, allerdings ist es möglich, dass
Hardwarehersteller (wie Xilinx Inc.) diese Funktionen so auf ihre Produkte anpassen,
dass präferenzen über die Platzierung von den Schaltungsteilen eingehalten werden.
Damit kann beispielsweise die Effizienz von den Schlatungen verbessert werden.
Bei der seriellen Verbindung werden 2 einzelne Schaltungen so verbunden, dass der
Ausgang der ersten an den Eingang der zweiten Schaltung geleitet werden. Dies
funktioniert mit dieser Funktion für alle Schaltungen die in dieser Form
zusammenpassen (also der Ausgang der ersten das gleiche Format wie der Eingang
der zweiten hat):
(->-) :: (a -> b) -> (b -> c) -> (a -> c)
(f ->- g) a = c
where
b = f a
c = g b
Die parallele Verbindung verknüpft die Schaltungen so, dass aus 2 Schaltungen eine
Schaltung wird, die gleichzeitig die Eingäng der ersten und der zweiten aufnimmt und
die Ausgänge beider Schaltungen zusammen zurückgibt.
(-|-) :: (a -> c) -> (b -> d) -> ((a, b) -> (c, d))
(f -|- g) (a, b) = (c, d)
where
c = f a
d = g b
Weiterführend zu diesen einfachen Verbindungen kann man eine Verbindung
definieren, die eine Schaltung mehrfach hintereinander hängt, die Eingänge und die
Ausgängen zusammenfasst und einen speziellen Ausgang immer an einen speziellen
Eingang von der nächsten Schaltung weiterreicht. Diese "Zeile" (analog wäre auch
eine Spalte möglich) könnte wiefolgt aussehen:
row :: ((c, a) -> (b, c)) -> (c, [a]) -> ([b], c)
row f (carryIn, []) = ([], carryIn)
row f (carryIn, a:as) = (b:bs, carryOut)
where
(b, carry) = f (carryIn, a)
(bs, carryOut) = row f (carry, as)
Diese Struktur ermöglicht es jetzt die Definition von BitAddierer oder Addierer stark zu
vereinfachen 3 :
bitAdder = row halfAdd
adder' = row fullAdd
3: Die Signatur von adder' ist nicht exakt identisch mit der von adder: Es wird kein
Tupel von 2 Listen übergeben sondern einen Liste mit Tupeln von je 2 Werten.
Seite 4/7

Schaltwerke
Schaltwerke sind ähnlich wie Schaltnetze boolsche Formeln. Allerdings enthalten sie
elektronische Bauelemente die ihren Zustand speichern können. Diese Verzögerungen
(oder auch Register) sorgen dafür, dass der Zustand an den Ausgängen nicht mehr nur
von den Eingängen abhängt sondern auch noch von dem Verlauf der Eingänge.
Diese Verzögerung heißt in Lava delay und gibt beim ersten Aufruf den Wert des
ersten Parameters zurück und in allen folgenden immer den Wert den der zweite
Parameter beim vorherigen Aufruf hatte.
Eine einfache Anwendung einer solchen Verzögerung ist ein Wechseler. Sobald der
eine Eingang ein High-Signal erhält, wechselt wer den Zustand von seinem Ausgang:
toggle :: Signal Bool -> Signal Bool
toggle change = out
where
out' = delay low out
out = xor2(change, out')
Das besondere an dieser Definition ist, dass beide Werte in dem where-Statement
voneinander abhängen. Dies ist normalerweise in einer Lava-Schaltung nicht möglich.
Allerdings ist dies bei der Verwendung von delay essentiell und wird dafür mittels
observable sharing realisiert.
Die delay Funktion, die von Lava bereit gestellt wird, ist universell überladen und kann
Bits, Tupel von Bits, Listen von Bits und andere Kombinationen speichern. Deshalb ist
es damit auch möglich einen Zähler zu realisieren:
counter :: Int -> () -> [Signal Bool]
counter n () = number
where
number' = delay (zeroList n) number
(number, _) = bitAdder (high, number')
Dieser Zählerbaustein (ohne Eingang) addiert bei jedem Aufruf auf einen internen
Zähler eins und gibt dann den Wert zurück. Der Parameter n gibt dabei nur an wie
viele Bits für den Zähler verwendet werden sollen.
Simulation
Lavaschaltungen können ganz einfach simuliert werden. Dazu kann man einfach
simulate verwenden. Diesem übergibt man einfach die Lava-Schaltung und die
entsprechenden Werte für die Eingänge:
> simulate halfAdd (high, high)
(low,high)
Möchte man mehrer Eingangsbelegungen gleichzeitig überprüfen (ist für Schaltwerke
zwingend erforderlich) verwendet man einfach simulateSeq dem man eine Lava-
Schaltung und eine Liste von entsprechenden Werten für die Eingänge übergibt:
> simulateSeq toggle [low, high, low, low, high, high, low]
[low,high,high,high,low,high,high]
Seite 5/7

Verifikation
Da man nun aber nicht für jede Schaltung alle Eingangsbelegungen (bei Schaltwerken
sogar alle Folgen von Belegungen) durchprobieren möchte um zu überprüfen ob eine
Aussage wahr oder falsch ist, bietet Lava an die Schaltung an ein externes
Verifikationstool zu übergeben. Dazu muss man zuerst eine Funktion schreiben, die die
Eigenschaft der Schaltung beschreibt, die man überprüfen möchte:
prop_HalfAddOutputNeverBothHigh :: (Signal Bool, Signal Bool) -> Signal Bool
prop_HalfAddOutputNeverBothHigh (a,b) = ok
where
(sum, carryOut) = halfAdd(a,b)
ok
= nand2(sum, carryOut)
Diese Beschreibung sieht selbst aus wie eine Schaltung und gibt High zurück wenn die
zu überprüfende Eigenschaft zutrifft. (Hier wird beispielsweise überprüft ob bei einem
Halbaddierer die beiden Ausgänge niemals zusammen High sein können.)
Wenn man jetzt dem Aufruf des Verifikationstools diese Eigenschaftsdefinition
übergibt kann dieses überprüfen ob diese Eigenschaft immer erfüllt ist:
> smv prop_HalfAddOutputNeverBothHigh
Smv:...Valid.
Dabei ist wichtig, dass die Verifikation nicht daraus besteht alle Varianten durch zu
probieren. Sondern die Schaltung wird in einen mathematischen Ausdruck
umgewandelt und dann von dem externen Tool überprüft. So kann sowohl die
Wahrheit als auch der Gegenbeweis relativ schnell festgestellt werden. Versucht man
den oberen Beweis, statt mit dem Halbaddierer mit dem Volladdierer durchzuführen,
ergibt dies folgendes:
> smv prop_FullAddOutputNeverBothHigh
Smv:...Falsifiable.
Einen Spezialfall bei der Verifikation stellen die Lavadefinitionen dar, die als Parameter
eine Liste erwarten. Bei diesen Definitionen wird erst durch die konkrete Belegung der
Eingänge entscheiden was für eine Schaltung entsteht. Daher ist eine einfach
Definition der Eigenschaft wie folgt nicht ausreichend:
prop_AdderCommutative :: ([Signal Bool], [Signal Bool]) ->
Signal Bool
prop_AdderCommutative (a,b) = ok
where
out1 = adder(a,b)
out2 = adder(b,a)
ok = out1 out2
Bei dieser Definition ist noch völlig offen wie groß die Eingabewerte sind und welche
Schaltung entsteht. Damit man diese Schaltung aber zumindest für eine bestimmte
Größe testen kann, kann man eine Hilfsfunktion definieren:
prop_AdderCommutative_ForSize :: Int -> Property
prop_AdderCommutative_ForSize n =
forAll (list n) $ \as ->
forAll (list n) $ \bs ->
prop_AdderCommutative (as, bs)
Seite 6/7

Mit dieser Funktion ist es möglich für eine Eingabelänge n die oben definierte
Eigenschaft zu überprüfen:
> smv (prop_AdderCommutative_ForSize 32)
Smv:...Valid.
Fazit
Mit Lava ist es einfach und schnell möglich Hardware zu designen. Durch die einfach
Möglichkeit die Schaltungen danach zu Simulieren und zu verifizieren bietet sich Lava
als das optimale Tool zur Entwicklung von Schaltungen an. Leider ist es in letzter Zeit
um die Entwicklung von Lava relativ ruhig gewurden. Das mag daran liegen, dass die
Installation von Haskell und den erforderlichen Tools für die meißten
Hardwaredesigner nicht ohne weiteres erschlossen werden kann und diese lieber zu
komerziellen Lösungen in VHDL und Verilog greifen.
Ich finde Lava bietet eine gute Möglichkeit mit relativ wenig Erfahrung einfach
Schaltungen Schritt für Schritt aufzubauen und würde es begrüßen wenn die
Entwicklung von Lava nicht ganz untergeht damit man auch in Zukunft Lava noch für
das Design von Hardware einsetzen kann.
Seite 7/7