ships/Alu.ship

   1 ship: Alu
   2
   3 == Ports ===========================================================
   4 data  in:   in1
   5 data  in:   in2
   6 data  in:   inOp
   7   constant IN1: 0
   8   constant IN2: 1
   9   constant ADD: 2
  10   constant SUB: 3
  11   constant MAX: 4
  12   constant MIN: 5
  13   constant CMP: 6
  14   constant DROP1: 7
  15   constant DROP2: 8
  16   constant MAXMERGE: 9
  17
  18 data  out:  out
  19
  20
  21 == TeX ==============================================================
  22
  23 {\tt Alu} is a ``two-input'' arithmetic logic unit.  It includes
  24 logic for performing arithmetic operations on a pair of arguments.
  25 Currently this includes
  26 addition ({\sc add}),
  27 subtraction ({\sc sub}),
  28 maximum ({\sc max}), and
  29 minimum ({\sc min}).
  30
  31 \subsection*{Semantics}
  32
  33 When a value is present at each of {\tt in1}, {\tt in2} and {\tt
  34 inOp}, these three values are consumed.  Based on the value consumed
  35 at {\tt inOp}, the requested operation is performed on the values
  36 consumed from {\tt in1} and {\tt in2}.  The result of this operation
  37 is then made available at {\tt out}.
  38
  39 \subsection*{C-Flag}
  40
  41 \begin{verbatim}
  42 IN1      - undefined; drain in1 only
  43 IN2      - undefined; drain in2 only
  44 ADD      - carry-out
  45 SUB      - undefined
  46 MAX      - if in1>in2 cflag=0 and drain in1, else cflag=1 and drain in2
  47 MIN      - if in1>in2 cflag=1 and drain in2, else cflag=0 and drain in1
  48 CMP      - if in1==in2 cflag=1, else cflag=0
  49 DROP1    - consume in1, produce no output
  50 DROP2    - consume in2, produce no output
  51 MAXMERGE - if (in1<0 && in2<0) consume both, emit either, cflag=undef else act as MAX
  52 \end{verbatim}
  53
  54 \subsection*{To Do}
  55
  56 The {\it link bit} and other features of \cite{ies31} are not yet
  57 implemented.
  58
  59 The carry-in, carry-out, zero-test, negative-test, and overflow-test
  60 flags typically present in a conventional processor ALU are also not
  61 yet implemented.
  62
  63 == Fleeterpreter ====================================================
  64 public void service() {
  65   if (box_inOp.dataReadyForShip() &&
  66       box_in1.dataReadyForShip() &&
  67       box_in2.dataReadyForShip() &&
  68       box_out.readyForDataFromShip()) {
  69       long a;
  70       long b;
  71       long op     = box_inOp.removeDataForShip();
  72       switch((int)op) {
  73           case 0:
  74               a = box_in1.removeDataForShip();
  75               box_out.addDataFromShip(a); // IN1
  76               break;
  77           case 1:
  78               b = box_in2.removeDataForShip();
  79               box_out.addDataFromShip(b); // IN2
  80               break;
  81           case 2:
  82               a = box_in1.removeDataForShip();
  83               b = box_in2.removeDataForShip();
  84               box_out.addDataFromShip(a+b); // ADD
  85               break;
  86           case 3:
  87               a = box_in1.removeDataForShip();
  88               b = box_in2.removeDataForShip();
  89               box_out.addDataFromShip(a-b); // SUB
  90               break;
  91           case 9:
  92               if (box_in1.peekDataForShip()<0 && box_in2.peekDataForShip()<0) {
  93                 a = box_in1.removeDataForShip();
  94                 b = box_in2.removeDataForShip();
  95                 box_out.addDataFromShip(a, false);
  96                 break;
  97               }
  98               // fall through
  99           case 4:
 100               a = box_in1.peekDataForShip();
 101               b = box_in2.peekDataForShip();
 102               box_out.addDataFromShip(Math.max(a,b), !(a>b)); // MAX
 103               if (a<b) box_in1.removeDataForShip(); else box_in2.removeDataForShip();
 104               break;
 105           case 5:
 106               a = box_in1.peekDataForShip();
 107               b = box_in2.peekDataForShip();
 108               box_out.addDataFromShip(Math.min(a,b), a>b); // MIN
 109               if (a>b) box_in1.removeDataForShip(); else box_in2.removeDataForShip();
 110               break;
 111           case 6:
 112               a = box_in1.removeDataForShip();
 113               b = box_in2.removeDataForShip();
 114               box_out.addDataFromShip(0, a==b); // CMP
 115               break;
 116 /*
 117           case 7:
 118               box_in1.removeDataForShip();      // DROP1
 119               break;
 120           case 8:
 121               box_in2.removeDataForShip();      // DROP2
 122               break;
 123 */
 124           default:
 125               throw new RuntimeException("invalid opcode: " + op);
 126       }
 127   }
 128 }
 129
 130 == FleetSim ==============================================================
 131
 132 == FPGA ==============================================================
 133
 134   wire [`WORDWIDTH:0]     sum;
 135   wire                    cin;
 136   wire [(`WORDWIDTH-1):0] in2_inverted;
 137
 138   wire [(`WORDWIDTH-1):0] res;
 139   wire                    isplus;
 140   wire                    eq;
 141   wire                    cout;
 142
 143   wire [3:0]              inOp_d_trunc;
 144   assign                  inOp_d_trunc = inOp_d[3:0];
 145
 146   assign isplus        = inOp_d_trunc[2:0]==2;
 147   assign cin           = isplus ? 0 : 1;
 148   assign in2_inverted  = isplus ? in2_d : ~in2_d;
 149   assign sum           = {in1_d,cin} + {in2_inverted,cin};
 150   assign res           = sum[`WORDWIDTH:1];
 151   assign greater       = !res[`WORDWIDTH-1];
 152   assign both_negative = in1_d[`WORDWIDTH-1] && in2_d[`WORDWIDTH-1];
 153   assign eq            = in1_d == in2_d;
 154   assign cout          = sum[`WORDWIDTH];
 155
 156   reg out_draining;
 157
 158   assign out_d_[`WORDWIDTH] =
 159           (inOp_d_trunc==0) ? 1'b0 :
 160           (inOp_d_trunc==1) ? 1'b0 :
 161           (inOp_d_trunc==2) ? cout :
 162           (inOp_d_trunc==3) ? cout :
 163           (inOp_d_trunc==4) ? ~greater :
 164           (inOp_d_trunc==5) ?  greater :
 165           (inOp_d_trunc==6) ?  eq :
 166           (inOp_d_trunc==9) ? ~greater :
 167           0;
 168
 169   assign out_d_[(`WORDWIDTH-1):0] =
 170           (inOp_d_trunc==0) ? (in1_d)  :
 171           (inOp_d_trunc==1) ? (in2_d)  :
 172           (inOp_d_trunc==2) ? (res)  :
 173           (inOp_d_trunc==3) ? (res)  :
 174           (inOp_d_trunc==4) ? (greater ? in1_d : in2_d)  :
 175           (inOp_d_trunc==5) ? (greater ? in2_d : in1_d)  :
 176           (inOp_d_trunc==6) ? {{ (`WORDWIDTH-1) {1'b0 }}, eq  } :
 177           (inOp_d_trunc==9) ? (both_negative ? in1_d : (greater ? in1_d : in2_d)) :
 178           0;
 179
 180   always @(posedge clk) begin
 181     if (!rst) begin
 182       `reset
 183       out_draining <= 0;
 184     end else begin
 185       `flush
 186       `cleanup
 187       if (out_draining && `out_empty) begin
 188         `drain_inOp
 189         out_draining <= 0;
 190         if      (inOp_d_trunc==0) `drain_in1
 191         else if (inOp_d_trunc==1) `drain_in2
 192         else if (inOp_d_trunc==9 &&  both_negative) begin `drain_in1 `drain_in2 end
 193         else if (inOp_d_trunc==4 &&  greater) `drain_in1
 194         else if (inOp_d_trunc==5 &&  greater) `drain_in2
 195         else if (inOp_d_trunc==9 &&  greater) `drain_in1
 196         else if (inOp_d_trunc==4 && !greater) `drain_in2
 197         else if (inOp_d_trunc==5 && !greater) `drain_in1
 198         else if (inOp_d_trunc==9 && !greater) `drain_in2
 199         else begin
 200           `drain_in1
 201           `drain_in2
 202         end
 203       end
 204       if (!out_draining && `out_empty && `in1_full && `in2_full && `inOp_full) begin
 205         `fill_out
 206         out_draining <= 1;
 207       end
 208     end
 209   end
 210
 211 == Test ==============================================================================
 212
 213 // FIXME: need test for ADD carry-out c-flag
 214
 215 #ship debug : Debug
 216 #ship alu   : Alu
 217
 218 #expect 17
 219 #expect 1
 220 #expect 9
 221 #expect 8
 222 #expect 8
 223 #expect 1
 224 #expect 9
 225 #expect 0
 226 #expect 0
 227 #expect 1
 228
 229 debug.in:   set ilc=*;  recv, deliver;
 230 alu.in1:
 231   set word= 9;
 232   set ilc=5;
 233   deliver;
 234   set word= 9;
 235   deliver;
 236
 237 alu.in2:
 238   set word= 8;
 239   set ilc=5;
 240   deliver;
 241   set word= 9;
 242   deliver;
 243
 244 alu.out:
 245   set ilc=4;
 246   collect, send to debug.in;
 247 alu.inOp:
 248  set word= Alu.inOp[ADD]; deliver;
 249  set word= Alu.inOp[SUB]; deliver;
 250  set word= Alu.inOp[IN1]; deliver;
 251  set word= Alu.inOp[IN2]; deliver;
 252  set word= Alu.inOp[MIN]; deliver;
 253  set word= Alu.inOp[MAX]; deliver;
 254  set word= Alu.inOp[CMP]; deliver;
 255  set word= Alu.inOp[CMP]; deliver;
 256
 257 alu.out:
 258   collect, send to debug.in;        // MIN
 259   set flags a=c, b=b;
 260   [a]  set word= 1;
 261   [!a] set word= 0;
 262   send to debug.in;
 263
 264   collect, send to debug.in;        // MAX
 265   set flags a=c, b=b;
 266   [a]  set word= 1;
 267   [!a] set word= 0;
 268   send to debug.in;
 269
 270   collect;        // CMP
 271   set flags a=c, b=b;
 272   [a]  set word= 1;
 273   [!a] set word= 0;
 274   send to debug.in;
 275
 276   collect;        // CMP
 277   set flags a=c, b=b;
 278   [a]  set word= 1;
 279   [!a] set word= 0;
 280   send to debug.in;
 281
 282 == Contributors =========================================================
 283 Adam Megacz <megacz@cs.berkeley.edu>