Added another piece on state

[matthijs/master-project/dsd-paper.git] / cλash.lhs

diff --git a/cλash.lhs b/cλash.lhs
index 58caa4bb9c3b75b0eab808ce1c27e296fa66fced..16608ab610ef2455d2a8172cb8f0889b4b8e09d4 100644 (file)
--- a/cλash.lhs
+++ b/cλash.lhs
@@ -343,22 +343,39 @@
 
 % Macro for certain acronyms in small caps. Doesn't work with the
 % default font, though (it contains no smallcaps it seems).
 
 % Macro for certain acronyms in small caps. Doesn't work with the
 % default font, though (it contains no smallcaps it seems).

-\def\VHDL{{\small{VHDL}}}
-\def\GHC{{\small{GHC}}}
-\def\CLaSH{\textsc{C$\lambda$aSH}}
+\def\acro#1{{\small{#1}}}
+\def\VHDL{\acro{VHDL}}
+\def\GHC{\acro{GHC}}
+\def\CLaSH{{\small{C}}$\lambda$a{\small{SH}}}

 
 % Macro for pretty printing haskell snippets. Just monospaced for now, perhaps
 % we'll get something more complex later on.
 \def\hs#1{\texttt{#1}}
 \def\quote#1{``{#1}"}
 
 
 % Macro for pretty printing haskell snippets. Just monospaced for now, perhaps
 % we'll get something more complex later on.
 \def\hs#1{\texttt{#1}}
 \def\quote#1{``{#1}"}
 

+\newenvironment{xlist}[1][\rule{0em}{0em}]{%
+  \begin{list}{}{%
+    \settowidth{\labelwidth}{#1:}
+    \setlength{\labelsep}{0.5cm}
+    \setlength{\leftmargin}{\labelwidth}
+    \addtolength{\leftmargin}{\labelsep}
+    \setlength{\rightmargin}{0pt}
+    \setlength{\parsep}{0.5ex plus 0.2ex minus 0.1ex}
+    \setlength{\itemsep}{0 ex plus 0.2ex}
+    \renewcommand{\makelabel}[1]{##1:\hfil}
+    }
+  }
+{\end{list}}
+
+\usepackage{paralist}
+

 %include polycode.fmt
 
 \begin{document}
 %
 % paper title
 % can use linebreaks \\ within to get better formatting as desired
 %include polycode.fmt
 
 \begin{document}
 %
 % paper title
 % can use linebreaks \\ within to get better formatting as desired

-\title{\CLaSH: Structural Descriptions \\ of Synchronous Hardware using Haskell}
+\title{C$\lambda$aSH: Structural Descriptions \\ of Synchronous Hardware using Haskell}

 
 
 % author names and affiliations
 
 
 % author names and affiliations


@@ -367,7 +384,7 @@
 \author{\IEEEauthorblockN{Christiaan P.R. Baaij, Matthijs Kooijman, Jan Kuper, Marco E.T. Gerards, Bert Molenkamp, Sabih H. Gerez}
 \IEEEauthorblockA{University of Twente, Department of EEMCS\\
 P.O. Box 217, 7500 AE, Enschede, The Netherlands\\
 \author{\IEEEauthorblockN{Christiaan P.R. Baaij, Matthijs Kooijman, Jan Kuper, Marco E.T. Gerards, Bert Molenkamp, Sabih H. Gerez}
 \IEEEauthorblockA{University of Twente, Department of EEMCS\\
 P.O. Box 217, 7500 AE, Enschede, The Netherlands\\

-c.p.r.baaij@utwente.nl, matthijs@stdin.nl}}
+c.p.r.baaij@@utwente.nl, matthijs@@stdin.nl}}

 % \and
 % \IEEEauthorblockN{Homer Simpson}
 % \IEEEauthorblockA{Twentieth Century Fox\\
 % \and
 % \IEEEauthorblockN{Homer Simpson}
 % \IEEEauthorblockA{Twentieth Century Fox\\


@@ -573,7 +590,7 @@ sumif _ _ _ = 0
     others are defined by the \CLaSH\ package, so they are user-defined types
     from Haskell's point of view).
 
     others are defined by the \CLaSH\ package, so they are user-defined types
     from Haskell's point of view).
 

-    \begin{description}
+    \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
       \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


@@ -595,9 +612,9 @@ sumif _ _ _ = 0
         length type, so you can define an unsigned word of 32 bits wide as
         ollows:
 
         length type, so you can define an unsigned word of 32 bits wide as
         ollows:
 

-        \begin{verbatim}
-          type Word32 = SizedWord D32
-        \end{verbatim}
+\begin{verbatim}
+  type Word32 = SizedWord D32
+\end{verbatim}

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


@@ -617,9 +634,9 @@ sumif _ _ _ = 0
         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:
 
         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{verbatim}
+type RegisterState = Vector D8 Word32
+\end{verbatim}

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


@@ -639,9 +656,9 @@ sumif _ _ _ = 0
 
         To define an index for the 8 element vector above, we would do:
 
 
         To define an index for the 8 element vector above, we would do:
 

-        \begin{verbatim}
-        type RegisterIndex = RangedWord D7
-        \end{verbatim}
+\begin{verbatim}
+type RegisterIndex = RangedWord D7
+\end{verbatim}

 
         Here, a type synonym \hs{RegisterIndex} is defined that is equal to
         the \hs{RangedWord} type constructor applied to the type \hs{D7}. In
 
         Here, a type synonym \hs{RegisterIndex} is defined that is equal to
         the \hs{RangedWord} type constructor applied to the type \hs{D7}. In


@@ -650,7 +667,7 @@ sumif _ _ _ = 0
         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{description}
+    \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}
   \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}


@@ -671,9 +688,8 @@ sumif _ _ _ = 0
 
     For algebraic types, we can make the following distinction: 
 
 
     For algebraic types, we can make the following distinction: 
 

-    \begin{description}
-
-      \item[Product types]
+    \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
         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


@@ -689,7 +705,7 @@ sumif _ _ _ = 0
         constructor algebraic data-types, including those with just one
         field (which are technically not a product, but generate a VHDL
         record for implementation simplicity).
         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[Enumerated types]
+      \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.
         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.


@@ -700,7 +716,7 @@ sumif _ _ _ = 0
         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.
         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[Sum types]
+      \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
         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


@@ -715,9 +731,9 @@ sumif _ _ _ = 0
         no obvious \VHDL\ alternative. They can easily be emulated, however, as
         we will see from an example:
 
         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}
+\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
 
         An obvious way to translate this would be to create an enumeration to
         distinguish the constructors and then create a big record that


@@ -725,10 +741,10 @@ sumif _ _ _ = 0
         translation that would result from the following enumeration and
         product type (using a tuple for clarity):
 
         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}
+\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
 
         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


@@ -746,24 +762,63 @@ sumif _ _ _ = 0
         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.
         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{description}
-
-
+      \end{xlist}
+
+  \subsection{State}
+    A very important concept in hardware it the concept of state. In a 
+    stateful design, the outputs depend on the history of the inputs, or the 
+    state. State is usually stored in registers, which retain their value 
+    during a clock cycle. As we want to describe more than simple 
+    combinatorial designs, \CLaSH\ needs an abstraction mechanism for state.
+
+    An important property in Haskell, and in most other functional languages, 
+    is \emph{purity}. A function is said to be \emph{pure} if it satisfies two
+    conditions:
+    \begin{inparaenum}
+      \item given the same arguments twice, it should return the same value in 
+      both cases, and
+      \item when the function is called, it should not have observable 
+      side-effects.
+    \end{inparaenum}
+    This purity property is important for functional languages, since it 
+    enables all kinds of mathematical reasoning that could not be guaranteed 
+    correct for impure functions. Pure functions are as such a perfect match 
+    for a combinatorial circuit, where the output solely depends on the 
+    inputs. When a circuit has state however, it can no longer be simply
+    described by a pure function. Simply removing the purity property is not a 
+    valid option, as the language would then lose many of it mathematical 
+    properties. In an effort to include the concept of state in pure 
+    functions, the current value of the state is made an argument of the  
+    function; the updated state becomes part of the result.
+    
+    A simple example is the description of an accumulator circuit:
+    \begin{code}
+    acc :: Word -> State Word -> (State Word, Word)
+    acc inp (State s) = (State s', outp)
+      where
+        outp  = s + inp
+        s'    = outp
+    \end{code}
+    This approach makes the state of a function very explicit: which variables 
+    are part of the state is completely determined by the type signature. This 
+    approach to state is well suited to be used in combination with the 
+    existing code and language features, such as all the choice elements, as 
+    state values are just normal values.

 \section{\CLaSH\ prototype}
 
 foo\par bar
 
 \section{Related work}
 Many functional hardware description languages have been developed over the 
 \section{\CLaSH\ prototype}
 
 foo\par bar
 
 \section{Related work}
 Many functional hardware description languages have been developed over the 

-years. Early work includes such languages as \textsc{$\mu$fp}~\cite{muFP}, an 
-extension of Backus' \textsc{fp} language to synchronous streams, designed 
+years. Early work includes such languages as $\mu$\acro{FP}~\cite{muFP}, an 
+extension of Backus' \acro{FP} language to synchronous streams, designed 

 particularly for describing and reasoning about regular circuits. The 
 Ruby~\cite{Ruby} language uses relations, instead of functions, to describe 
 particularly for describing and reasoning about regular circuits. The 
 Ruby~\cite{Ruby} language uses relations, instead of functions, to describe 

-circuits, and has a particular focus on layout. \textsc{hml}~\cite{HML2} is a 
+circuits, and has a particular focus on layout. \acro{HML}~\cite{HML2} is a 

 hardware modeling language based on the strict functional language 
 hardware modeling language based on the strict functional language 

-\textsc{ml}, and has support for polymorphic types and higher-order functions. 
+\acro{ML}, and has support for polymorphic types and higher-order functions. 

 Published work suggests that there is no direct simulation support for 
 Published work suggests that there is no direct simulation support for 

-\textsc{hml}, and that the translation to \VHDL\ is only partial.
+\acro{HML}, and that the translation to \VHDL\ is only partial.

 
 Like this work, many functional hardware description languages have some sort 
 of foundation in the functional programming language Haskell. 
 
 Like this work, many functional hardware description languages have some sort 
 of foundation in the functional programming language Haskell. 


@@ -802,7 +857,7 @@ Wired~\cite{Wired},, T-Ruby~\cite{T-Ruby}, Hydra~\cite{Hydra}.
 
 A functional language designed specifically for hardware design is 
 $re{\mathit{FL}}^{ect}$~\cite{reFLect}, which draws experience from earlier 
 
 A functional language designed specifically for hardware design is 
 $re{\mathit{FL}}^{ect}$~\cite{reFLect}, which draws experience from earlier 

-language called \textsc{fl}~\cite{FL} to la
+language called \acro{FL}~\cite{FL} to la

 
 % An example of a floating figure using the graphicx package.
 % Note that \label must occur AFTER (or within) \caption.
 
 % An example of a floating figure using the graphicx package.
 % Note that \label must occur AFTER (or within) \caption.