Lava

Xilinx Lava is a library for FPGA circuit design with a focus on circuit layout.

Lava Combinators

Serial composition combinators

(->-) :: (a -> Out b) -> (b -> Out c) -> a -> Out c

Serial composition with no layout

(>->) :: (a -> Out b) -> (b -> Out c) -> a -> Out c

Serial composition with horizontal left to right layout

(>=>) :: (a -> Out b) -> (b -> Out c) -> a -> Out c

Serial composition with mid-horizontal left to right layout

(>|>) :: (a -> Out b) -> (b -> Out c) -> a -> Out c

Serial composition with overly layout

Conditional shift for obstacle avoidance

condShift :: (Int -> Bool, Int -> Int) -> (Int -> Bool, Int -> Int) -> Out ()

Parallel composition combinators

hRepN :: Int -> (a -> Out a) -> a -> Out a

Repeated serial composition (left to right)

par2 :: (a -> Out c) -> (b -> Out d) -> (a, b) -> Out (c, d)

Vertical parallel composition of two circuits

maP :: (a -> Out b) -> [a] -> Out [b]

Vertical map of a circuit

mapPair :: ((a, a) -> Out a) -> [a] -> Out [a]

mapPair maps a circuit over adajcent pairs of elements in a list

hpar2 :: (a -> Out c) -> (b -> Out d) -> (a, b) -> Out (c, d)

Horizontal parallel composition of two circuits

hmaP :: (a -> Out b) -> [a] -> Out [b]

Horizontal map of a circuit

par2Overlay :: (a -> Out c) -> (b -> Out d) -> (a, b) -> Out (c, d)

Parallel composition of two circuit which have overlaid layout

par3Overlay :: (a -> Out ao) -> (b -> Out bo) -> (c -> Out co) -> (a, b, c) -> Out (ao, bo, co)

Parallel composition of three circuit which have overlaid layout

hpar :: [a -> Out b] -> [a] -> Out [b]

Horizontal parallel composition of a list of circuits

hparN :: Int -> (a -> Out b) -> [a] -> Out [b]

Horizontal repeated parallel composition of a circuit

Wiring combinators

fork2 :: a -> Out (a, a)

Splits a wire into two

listToPair :: [a] -> Out (a, a)

Converts a two element list into a pair

pairToList :: (a, a) -> Out [a]

Converts a par into a list containing two elements

ziP :: ([a], [b]) -> Out [(a, b)]

Takes a pair of lists and returns a zipped list of pairs

unziP :: [(a, b)] -> Out ([a], [b])

Takes a list of pairs and unzips it into a pair of lists

zipList :: [[a]] -> Out [[a]]

Takes a list containing two elements and returns a list of lists where each element is a two element list

unzipList :: [[a]] -> Out [[a]]

Undo the zipList operation

fstListPair :: [a] -> a

sndListPair :: [a] -> a

pair :: [a] -> Out [[a]]

This makes pairs out of consequetive members of an even length list.

unpair :: [[a]] -> Out [a]

Takes a list of pairs and returns a flattend list

halveListToPair :: [a] -> ([a], [a])

halveListToPair will take a list and return a pair containing the two halves.

halve :: [a] -> Out ([a], [a])

Tales a list and returns a pair containing the two halves of the list

unhalve :: ([a], [a]) -> Out [a]

Take a pair containing two list halves and undoes the halve

halveList :: [a] -> Out [[a]]

Halves the input list into a list containign the two halves

unhalveList :: [[a]] -> Out [a]

Undoes halveList

chop :: Int -> [a] -> Out [[a]]

Chops a list into chunks

chopPair :: [a] -> Out [(a, a)]

Chops a list into chunks formed as pairs

concaT :: [[a]] -> Out [a]

Takes a list of lists and returns their concatenation

fstList :: ([a] -> Out [a]) -> [a] -> Out [a]

Applies a circuit to the first halve of a list

sndList :: ([a] -> Out [a]) -> [a] -> Out [a]

Applies a circuit to the second halve of a list

fsT :: (a -> Out b) -> (a, c) -> Out (b, c)

Applies a circuit to the first element of a pair

snD :: (b -> Out c) -> (a, b) -> Out (a, c)

Applies a circuit to the second element of a pair

projectFst :: (a, b) -> Out a

projectSnd :: (a, b) -> Out b

reversE :: [a] -> Out [a]

Circuit input/output ports

inputPort :: String -> NetType -> Out Bit

inputPort creates a single bit input port

inputBitVec :: String -> NetType -> Out [Bit]

inputBitVec creates a bit-vector input port

inputBitVecLocal :: String -> NetType -> Out [Bit]

inputBitVecLocal creates a local bit-vector input port

outputPort :: String -> NetType -> Bit -> Out ()

outputPort creates a single bit output port

outputBitVec :: String -> NetType -> [Bit] -> Out ()

outputBitVec creates a bit-vector output port

outputBitVecLocal :: String -> NetType -> [Bit] -> Out ()

outputBitVecKept creates a bit-vector local singal with a KEEP attribute set

data Dir

Constructors

To

Downto

Instances

Eq Dir

Show Dir

data NetType

Constructors

BitType

BitVec Int Dir Int

Instances

Eq NetType

Show NetType

data Netlist

type Out a = State Netlist a

type Bit = Int

data XilinxArchitecture

Constructors

Virtex2

Virtex4

Virtex5

Virtex6

Instances

Eq XilinxArchitecture

Show XilinxArchitecture

col

Arguments

:: ((a, b) -> Out (c, a))

type of element circuit r

-> (a, [b])

input to the col

-> Out ([c], a)

output of the col

Place four sided tile comoponents in a colum

Generating a Lava netlist

computeNetlist :: String -> XilinxArchitecture -> Out () -> Netlist

preLayoutNetlist :: String -> XilinxArchitecture -> Out () -> Netlist

putXilinxVHDL :: Netlist -> IO ()

overlayTile :: Out a -> Out a

overlayTile takes a circuit instantiation block and overlays all the the instantions.

middle :: (a -> Out c) -> ((c, d) -> Out e) -> (b -> Out d) -> (a, b) -> Out e

Place components in a horizontal middle arrangement

Adding new primitive gates to the Lava system

primitiveGate

Arguments

:: String

The name of the component

-> [(String, Bit)]

name of input ports with argument nets

-> [String]

name of output ports

-> Maybe (Int, Int)

optional size information for layout

-> Out [Bit]

a list of output nets from this component

primitiveGate adds a primitive gate

instantiate :: String -> Out () -> [(String, Bit)] -> [String] -> Out [Bit]

putXilinxEDIF :: Netlist -> IO ()

Functions for defining new LUT-based gates

lut1gate :: (Bool -> Bool) -> String -> Bit -> Out Bit

Implements a user-defined 1 input combinational gate

lut2gate :: (Bool -> Bool -> Bool) -> String -> (Bit, Bit) -> Out Bit

Implements a user defined two input combinational gate

lut2gate_l :: (Bool -> Bool -> Bool) -> String -> (Bit, Bit) -> Out Bit

Implements a local user defined two input combinational gate

lut3gate :: (Bool -> Bool -> Bool -> Bool) -> String -> (Bit, Bit, Bit) -> Out Bit

Implements a user defined three input combinational gate

lut4gate :: (Bool -> Bool -> Bool -> Bool -> Bool) -> String -> (Bit, Bit, Bit, Bit) -> Out Bit

Implements a user defined four input combinational gate

lut5gate :: (Bool -> Bool -> Bool -> Bool -> Bool -> Bool) -> String -> (Bit, Bit, Bit, Bit, Bit) -> Out Bit

Implements a user defined five input combinational gate

lut6gate :: (Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> Bool) -> String -> (Bit, Bit, Bit, Bit, Bit, Bit) -> Out Bit

Implements a user defined six input combinational gate

Getting the Lava version number

lavaVersion :: (Int, Int, Int, Int)

This function defines the version of Lava which should correspond to the Cabal version.

one :: Bit

zero :: Bit