\setlength{\leftmargin}{\labelwidth}
\addtolength{\leftmargin}{\labelsep}
\setlength{\rightmargin}{0pt}
- \setlength{\parsep}{0.5ex plus 0.2ex minus 0.1ex}
+ \setlength{\listparindent}{\parindent}
\setlength{\itemsep}{0 ex plus 0.2ex}
\renewcommand{\makelabel}[1]{##1:\hfil}
}
{\end{list}}
\usepackage{paralist}
+\usepackage{xcolor}
+\def\comment#1{{\color[rgb]{1.0,0.0,0.0}{#1}}}
%include polycode.fmt
%include clash.fmt
The approach taken in this research is not to make another domain specific
language embedded in Haskell, but to use (a subset) of the Haskell language
-itself to be used as hardware description language.
+itself to be used as hardware description language. By taking this approach,
+we can capture certain language constructs, such as Haskell's choice elements
+(if-statement, case-statment, etc.), which are not available in the functional
+hardware description languages that are embedded in Haskell. As far as the
+authors know, such extensive support for choice-elements is new in the domain
+of functional hardware description language. As the hardware descriptions are
+plain Haskell functions, these descriptions can be compiled for simulation
+using using the optimizing Haskell compiler \GHC.
+
+Like the standard hardware description languages, descriptions made in a
+functional hardware description languages must eventually be converted into a
+netlist. This research also features an a prototype translater called \CLaSH\
+(pronounced: Clash), which converts the Haskell code to equivalently behaving synthesizable \VHDL\ code, ready to be converted to an actual netlist format by optimizing \VHDL\ synthesis tools.
\section{Hardware description in Haskell}
Example that defines the \texttt{mac} function by applying the
\texttt{add} and \texttt{mul} functions to calculate $a * b + c$:
-\begin{verbatim}
+\begin{code}
mac a b c = add (mul a b) c
-\end{verbatim}
+\end{code}
- TODO: Pretty picture
+\comment{TODO: Pretty picture}
\subsection{Choices}
Although describing components and connections allows describing a
expression, one using only case expressions and one using pattern
matching and guards.
-\begin{code}
-sumif pred a b =
- if pred == Eq && a == b || pred == Neq && a != b
- then a + b
- else 0
-
-sumif pred a b = case pred of
- Eq -> case a == b of
- True -> a + b
- False -> 0
- Neq -> case a != b of
- True -> a + b
- False -> 0
-
-sumif Eq a b | a == b = a + b
-sumif Neq a b | a != b = a + b
-sumif _ _ _ = 0
-\end{code}
+ \begin{code}
+ sumif pred a b = if pred == Eq && a == b ||
+ pred == Neq && a != b
+ then a + b
+ else 0
+
+ sumif pred a b = case pred of
+ Eq -> case a == b of
+ True -> a + b
+ False -> 0
+ Neq -> case a != b of
+ True -> a + b
+ False -> 0
+
+ sumif Eq a b | a == b = a + b
+ sumif Neq a b | a != b = a + b
+ sumif _ _ _ = 0
+ \end{code}
- TODO: Pretty picture
+ \comment{TODO: Pretty picture}
\subsection{Types}
Translation of two most basic functional concepts has been
polymorphism, the possible types that can be used in hardware
descriptions will be discussed.
- Some way is needed to translate every values used to its hardware
+ Some way is needed to translate every value used to its hardware
equivalents. In particular, this means a hardware equivalent for
- every \emph{type} used in a hardware description is needed
+ every \emph{type} used in a hardware description is needed.
- Since most functional languages have a lot of standard types that
- are hard to translate (integers without a fixed size, lists without
- a static length, etc.), a number of \quote{built-in} types will be
- defined first. These types are built-in in the sense that our
- compiler will have a fixed \VHDL\ type for these. User defined types,
- on the other hand, will have their hardware type derived directly
- from their Haskell declaration automatically, according to the rules
- sketched here.
+ The following types are \emph{built-in}, meaning that their hardware
+ translation is fixed into the \CLaSH compiler. A designer can also
+ define his own types, which will be translated into hardware types
+ using translation rules that are discussed later on.
\subsection{Built-in types}
- The language currently supports the following built-in types. Of these,
- only the \hs{Bool} type is supported by Haskell out of the box (the
- others are defined by the \CLaSH\ package, so they are user-defined types
- from Haskell's point of view).
-
\begin{xlist}
\item[\hs{Bit}]
- This is the most basic type available. It is mapped directly onto
- the \texttt{std\_logic} \VHDL\ type. Mapping this to the
- \texttt{bit} type might make more sense (since the Haskell version
- only has two values), but using \texttt{std\_logic} is more standard
- (and allowed for some experimentation with don't care values)
-
+ This is the most basic type available. It can have two values:
+ \hs{Low} and \hs{High}. It is mapped directly onto the
+ \texttt{std\_logic} \VHDL\ type.
\item[\hs{Bool}]
- This is the only built-in Haskell type supported and is translated
- exactly like the Bit type (where a value of \hs{True} corresponds to a
- value of \hs{High}). Supporting the Bool type is particularly
- useful to support \hs{if ... then ... else ...} expressions, which
- always have a \hs{Bool} value for the condition.
-
- A \hs{Bool} is translated to a \texttt{std\_logic}, just like \hs{Bit}.
+ This is a basic logic type. It can have two values: \hs{True}
+ and \hs{False}. It is translated to \texttt{std\_logic} exactly
+ like the \hs{Bit} type (where a value of \hs{True} corresponds
+ to a value of \hs{High}). Supporting the Bool type is
+ particularly useful to support \hs{if ... then ... else ...}
+ expressions, which always have a \hs{Bool} value for the
+ condition.
\item[\hs{SizedWord}, \hs{SizedInt}]
These are types to represent integers. A \hs{SizedWord} is unsigned,
while a \hs{SizedInt} is signed. These types are parametrized by a
length type, so you can define an unsigned word of 32 bits wide as
- ollows:
+ follows:
-\begin{verbatim}
- type Word32 = SizedWord D32
-\end{verbatim}
+ \begin{code}
+ type Word32 = SizedWord D32
+ \end{code}
Here, a type synonym \hs{Word32} is defined that is equal to the
\hs{SizedWord} type constructor applied to the type \hs{D32}. \hs{D32}
is the \emph{type level representation} of the decimal number 32,
- making the \hs{Word32} type a 32-bit unsigned word.
-
- These types are translated to the \VHDL\ \texttt{unsigned} and
- \texttt{signed} respectively.
+ making the \hs{Word32} type a 32-bit unsigned word. These types are
+ translated to the \VHDL\ \texttt{unsigned} and \texttt{signed}
+ respectively.
\item[\hs{Vector}]
This is a vector type, that can contain elements of any other type and
- has a fixed length. It has two type parameters: its
- length and the type of the elements contained in it. By putting the
- length parameter in the type, the length of a vector can be determined
- at compile time, instead of only at run-time for conventional lists.
+ has a fixed length. The \hs{Vector} type constructor takes two type
+ arguments: the length of the vector and the type of the elements
+ contained in it. The state type of an 8 element register bank would
+ then for example be:
- The \hs{Vector} type constructor takes two type arguments: the length
- of the vector and the type of the elements contained in it. The state
- type of an 8 element register bank would then for example be:
-
-\begin{verbatim}
-type RegisterState = Vector D8 Word32
-\end{verbatim}
+ \begin{code}
+ type RegisterState = Vector D8 Word32
+ \end{code}
Here, a type synonym \hs{RegisterState} is defined that is equal to
- the \hs{Vector} type constructor applied to the types \hs{D8} (The type
- level representation of the decimal number 8) and \hs{Word32} (The 32
- bit word type as defined above). In other words, the
- \hs{RegisterState} type is a vector of 8 32-bit words.
-
- A fixed size vector is translated to a \VHDL\ array type.
+ the \hs{Vector} type constructor applied to the types \hs{D8} (The
+ type level representation of the decimal number 8) and \hs{Word32}
+ (The 32 bit word type as defined above). In other words, the
+ \hs{RegisterState} type is a vector of 8 32-bit words. A fixed size
+ vector is translated to a \VHDL\ array type.
\item[\hs{RangedWord}]
This is another type to describe integers, but unlike the previous
two it has no specific bit-width, but an upper bound. This means that
its range is not limited to powers of two, but can be any number.
A \hs{RangedWord} only has an upper bound, its lower bound is
- implicitly zero. There is a lot of added implementation complexity
- when adding a lower bound and having just an upper bound was enough
- for the primary purpose of this type: type-safely indexing vectors.
+ implicitly zero. The main purpose of the \hs{RangedWord} type is to be
+ used as an index to a \hs{Vector}.
- To define an index for the 8 element vector above, we would do:
+ \comment{TODO: Perhaps remove this example?} To define an index for
+ the 8 element vector above, we would do:
-\begin{verbatim}
-type RegisterIndex = RangedWord D7
-\end{verbatim}
+ \begin{code}
+ type RegisterIndex = RangedWord D7
+ \end{code}
Here, a type synonym \hs{RegisterIndex} is defined that is equal to
the \hs{RangedWord} type constructor applied to the type \hs{D7}. In
other words, this defines an unsigned word with values from
0 to 7 (inclusive). This word can be be used to index the
- 8 element vector \hs{RegisterState} above.
-
- This type is translated to the \texttt{unsigned} \VHDL type.
+ 8 element vector \hs{RegisterState} above. This type is translated to
+ the \texttt{unsigned} \VHDL type.
\end{xlist}
+
\subsection{User-defined types}
There are three ways to define new types in Haskell: algebraic
data-types with the \hs{data} keyword, type synonyms with the \hs{type}
keyword and type renamings with the \hs{newtype} keyword. \GHC\
offers a few more advanced ways to introduce types (type families,
existential typing, {\small{GADT}}s, etc.) which are not standard
- Haskell. These will be left outside the scope of this research.
+ Haskell. These are not currently supported.
Only an algebraic datatype declaration actually introduces a
completely new type, for which we provide the \VHDL\ translation
For algebraic types, we can make the following distinction:
\begin{xlist}
- \item[\textbf{Product types}]
- A product type is an algebraic datatype with a single constructor with
- two or more fields, denoted in practice like (a,b), (a,b,c), etc. This
- is essentially a way to pack a few values together in a record-like
- structure. In fact, the built-in tuple types are just algebraic product
- types (and are thus supported in exactly the same way).
-
- The \quote{product} in its name refers to the collection of values
- belonging to this type. The collection for a product type is the
- Cartesian product of the collections for the types of its fields.
-
- These types are translated to \VHDL\ record types, with one field for
- every field in the constructor. This translation applies to all single
- constructor algebraic data-types, including those with just one
- field (which are technically not a product, but generate a VHDL
- record for implementation simplicity).
- \item[\textbf{Enumerated types}]
- An enumerated type is an algebraic datatype with multiple constructors, but
- none of them have fields. This is essentially a way to get an
- enumeration-like type containing alternatives.
-
- Note that Haskell's \hs{Bool} type is also defined as an
- enumeration type, but we have a fixed translation for that.
-
- These types are translated to \VHDL\ enumerations, with one value for
- each constructor. This allows references to these constructors to be
- translated to the corresponding enumeration value.
- \item[\textbf{Sum types}]
- A sum type is an algebraic datatype with multiple constructors, where
- the constructors have one or more fields. Technically, a type with
- more than one field per constructor is a sum of products type, but
- for our purposes this distinction does not really make a
- difference, so this distinction is note made.
-
- The \quote{sum} in its name refers again to the collection of values
- belonging to this type. The collection for a sum type is the
- union of the the collections for each of the constructors.
-
- Sum types are currently not supported by the prototype, since there is
- no obvious \VHDL\ alternative. They can easily be emulated, however, as
- we will see from an example:
-
-\begin{verbatim}
-data Sum = A Bit Word | B Word
-\end{verbatim}
-
- An obvious way to translate this would be to create an enumeration to
- distinguish the constructors and then create a big record that
- contains all the fields of all the constructors. This is the same
- translation that would result from the following enumeration and
- product type (using a tuple for clarity):
-
-\begin{verbatim}
-data SumC = A | B
-type Sum = (SumC, Bit, Word, Word)
-\end{verbatim}
-
- Here, the \hs{SumC} type effectively signals which of the latter three
- fields of the \hs{Sum} type are valid (the first two if \hs{A}, the
- last one if \hs{B}), all the other ones have no useful value.
-
- An obvious problem with this naive approach is the space usage: the
- example above generates a fairly big \VHDL\ type. Since we can be
- sure that the two \hs{Word}s in the \hs{Sum} type will never be valid
- at the same time, this is a waste of space.
-
- Obviously, duplication detection could be used to reuse a
- particular field for another constructor, but this would only
- partially solve the problem. If two fields would be, for
- example, an array of 8 bits and an 8 bit unsigned word, these are
- different types and could not be shared. However, in the final
- hardware, both of these types would simply be 8 bit connections,
- so we have a 100\% size increase by not sharing these.
- \end{xlist}
+ \item[\bf{Single constructor}]
+ Algebraic datatypes with a single constructor with one or more
+ fields, are essentially a way to pack a few values together in a
+ record-like structure. An example of such a type is the following pair
+ of integers:
+
+\begin{code}
+data IntPair = IntPair Int Int
+\end{code}
+
+ Haskell's builtin tuple types are also defined as single
+ constructor algebraic types and are translated according to this
+ rule by the \CLaSH compiler. These types are translated to \VHDL\
+ record types, with one field for every field in the constructor.
+ \item[\bf{No fields}]
+ Algebraic datatypes with multiple constructors, but without any
+ fields are essentially a way to get an enumeration-like type
+ containing alternatives. Note that Haskell's \hs{Bool} type is also
+ defined as an enumeration type, but we have a fixed translation for
+ that. These types are translated to \VHDL\ enumerations, with one
+ value for each constructor. This allows references to these
+ constructors to be translated to the corresponding enumeration value.
+ \item[\bf{Multiple constructors with fields}]
+ Algebraic datatypes with multiple constructors, where at least
+ one of these constructors has one or more fields are not
+ currently supported.
+ \end{xlist}
\subsection{State}
A very important concept in hardware it the concept of state. In a
generation. If a developer wants to insert a choice element inside an actual
circuit he will have to specify this explicitly as a component. In this
respect \CLaSH\ differs from Lava, in that all the choice elements, such as
-case-statements and patter matching, are synthesized to choice elements in the
+case-statements and pattern matching, are synthesized to choice elements in the
eventual circuit. As such, richer control structures can both be specified and
synthesized in \CLaSH\ compared to any of the languages mentioned in this
section.
The merits of polymorphic typing, combined with higher-order functions, are
now also recognized in the `main-stream' hardware description languages,
-exemplified by the new \VHDL\ 2008 standard~\cite{VHDL2008}. \VHDL-2008 has
+exemplified by the new \VHDL\-2008 standard~\cite{VHDL2008}. \VHDL-2008 has
support to specify types as generics, thus allowing a developer to describe
polymorphic components. Note that those types still require an explicit
generic map, whereas type-inference and type-specialization are implicit in
projects / matthijs / master-project / dsd-paper.git / blobdiff