PolyAlu.lhs

   1 %include talk.fmt
   2 %if style == newcode
   3 \begin{code}
   4 {-# LANGUAGE  TypeOperators, TypeFamilies, FlexibleContexts #-}
   5 module Main where
   6
   7 import qualified Prelude as P
   8 \end{code}
   9 %endif
  10
  11 \section{Polymorphic, Higher-Order CPU}
  12 \subsection{Introduction}
  13 \frame
  14 {
  15 \frametitle{Small Use Case}
  16 \begin{itemize}
  17   \item Small Polymorphic, Higher-Order CPU
  18   \item Each function is turned into a hardware component
  19   \item Use of state will be simple
  20 \end{itemize}
  21 }
  22
  23 \frame
  24 {
  25 \frametitle{Imports}
  26 Import all the built-in types, such as vectors and integers:
  27 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  28 \begin{code}
  29 import CLasH.HardwareTypes
  30 \end{code}
  31 \end{beamercolorbox}\pause
  32
  33 Import annotations, helps \clash{} to find top-level component:
  34 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  35 \begin{code}
  36 import CLasH.Translator.Annotations
  37 \end{code}
  38 \end{beamercolorbox}
  39 }
  40
  41 \subsection{Type Definitions}
  42 \frame
  43 {
  44 \frametitle{Type definitions}
  45 First we define some ALU types:
  46 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  47 \begin{code}
  48 type Op s a         =   a -> Vector s a -> a
  49 type Opcode         =   Bit
  50 \end{code}
  51 \end{beamercolorbox}\pause
  52
  53 And some Register types:
  54 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  55 \begin{code}
  56 type RegBank s a    =   Vector (s :+: D1) a
  57 type RegState s a   =   State (RegBank s a)
  58 \end{code}
  59 \end{beamercolorbox}\pause
  60
  61 And a simple Word type:
  62 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  63 \begin{code}
  64 type Word           =   SizedInt D12
  65 \end{code}
  66 \end{beamercolorbox}
  67 }
  68
  69 \subsection{Frameworks for Operations}
  70 \frame
  71 {
  72 \frametitle{Operations}
  73 We make a primitive operation:
  74 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  75 \begin{code}
  76 primOp :: {-"{\color<3>[rgb]{1,0,0}"-}(a -> a -> a){-"}"-} -> Op s a
  77 primOp f a b = a `f` a
  78 \end{code}
  79 \end{beamercolorbox}\pause
  80
  81 We make a vector operation:
  82 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  83 \begin{code}
  84 vectOp :: {-"{\color<3>[rgb]{1,0,0}"-}(a -> a -> a){-"}"-} -> Op s a
  85 vectOp f a b = {-"{\color<3>[rgb]{1,0,0}"-}foldl{-"}"-} f a b
  86 \end{code}
  87 \end{beamercolorbox}
  88 \begin{itemize}
  89 \uncover<3->{\item We support Higher-Order Functionality}
  90 \end{itemize}
  91 }
  92 \subsection{Polymorphic, Higher-Order ALU}
  93 \frame
  94 {
  95 \frametitle{Simple ALU}
  96 We define a polymorphic ALU:
  97 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
  98 \begin{code}
  99 alu ::
 100   Op s a ->
 101   Op s a ->
 102   Opcode -> a -> Vector s a -> a
 103 alu op1 op2 {-"{\color<2>[rgb]{1,0,0}"-}Low{-"}"-}    a b = op1 a b
 104 alu op1 op2 {-"{\color<2>[rgb]{1,0,0}"-}High{-"}"-}   a b = op2 a b
 105 \end{code}
 106 \end{beamercolorbox}
 107 \begin{itemize}
 108 \uncover<2->{\item We support Patter Matching}
 109 \end{itemize}
 110 }
 111 \subsection{Register bank}
 112 \frame
 113 {
 114 \frametitle{Register Bank}
 115 Make a simple register bank:
 116 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
 117 \begin{code}
 118 registerBank ::
 119   CXT((NaturalT s ,PositiveT (s :+: D1),((s :+: D1) :>: s) ~ True )) => (RegState s a) -> a -> RangedWord s ->
 120   RangedWord s -> Bit -> ((RegState s a), a )
 121
 122 registerBank (State mem) data_in rdaddr wraddr wrenable =
 123   ((State mem'), data_out)
 124   where
 125     data_out  =   mem!rdaddr
 126     mem'  {-"{\color<2>[rgb]{1,0,0}"-}| wrenable == Low{-"}"-}    = mem
 127           {-"{\color<2>[rgb]{1,0,0}"-}| otherwise{-"}"-}          = replace mem wraddr data_in
 128 \end{code}
 129 \end{beamercolorbox}
 130 \begin{itemize}
 131 \uncover<2->{\item We support Guards}
 132 \end{itemize}
 133 }
 134 \subsection{Simple CPU: ALU \& Register Bank}
 135 \frame
 136 {
 137 \frametitle{Simple CPU}
 138 Combining ALU and register bank:
 139 \begin{beamercolorbox}[sep=-2.5ex,rounded=true,shadow=true,vmode]{codebox}
 140 \begin{code}
 141 {-"{\color<2>[rgb]{1,0,0}"-}ANN(actual_cpu TopEntity){-"}"-}
 142 actual_cpu ::
 143   (Opcode, Word, Vector D4 Word, RangedWord D9,
 144   RangedWord D9, Bit) ->  RegState D9 Word ->
 145   (RegState D9 Word, Word)
 146
 147 actual_cpu (opc, a ,b, rdaddr, wraddr, wren) ram = (ram', alu_out)
 148   where
 149     alu_out = alu ({-"{\color<3>[rgb]{1,0,0}"-}primOp (+){-"}"-}) ({-"{\color<3>[rgb]{1,0,0}"-}vectOp (+){-"}"-}) opc ram_out b
 150     (ram',ram_out)  = registerBank ram a rdaddr wraddr wren
 151 \end{code}
 152 \end{beamercolorbox}
 153 \begin{itemize}
 154 \uncover<2->{\item Annotation is used to indicate top-level component}
 155 \end{itemize}
 156 }
 157
 158 %if style == newcode
 159 \begin{code}
 160 ANN(initstate InitState)
 161 initstate :: RegState D9 Word
 162 initstate = State (copy (0 :: Word))
 163
 164 ANN(program TestInput)
 165 program :: [(Opcode, Word, Vector D4 Word, RangedWord D9, RangedWord D9, Bit)]
 166 program =
 167   [ (Low, 4, copy (0::Word), 0, 0, High) -- Write 4 to Reg0, out = 0
 168   , (Low, 3, copy (0::Word), 0, 1, High) -- Write 3 to Reg1, out = Reg0 + Reg0 = 8
 169   , (High,0, copy (3::Word), 1, 0, Low)  -- No Write       , out = 15
 170   ]
 171
 172 run func state [] = []
 173 run func state (i:input) = o:out
 174   where
 175     (state', o) = func i state
 176     out         = run func state' input
 177
 178 main :: IO ()
 179 main = do
 180   let input = program
 181   let istate = initstate
 182   let output = run actual_cpu istate input
 183   mapM_ (\x -> putStr $ ("# (" P.++ (show x) P.++ ")\n")) output
 184   return ()
 185 \end{code}
 186 %endif