Functional hardware description in Lava

(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