ships/Alu2.ship

   1 ship: Alu2
   2
   3 == Ports ===========================================================
   4 data  in:   in1
   5 data  in:   in2
   6 data  in:   inOp
   7   constant ADD: 0
   8   constant SUB: 1
   9   constant MAX: 2
  10   constant MIN: 3
  11
  12 data  out:  out
  13
  14
  15 == TeX ==============================================================
  16
  17 {\tt Alu2} is a ``two-input'' arithmetic logic unit.  It includes
  18 logic for performing arithmetic operations on a pair of arguments.
  19 Currently this includes
  20 addition ({\sc add}),
  21 subtraction ({\sc sub}),
  22 maximum ({\sc max}), and
  23 minimum ({\sc min}).
  24
  25 \subsection*{Semantics}
  26
  27 When a value is present at each of {\tt in1}, {\tt in2} and {\tt
  28 inOp}, these three values are consumed.  Based on the value consumed
  29 at {\tt inOp}, the requested operation is performed on the values
  30 consumed from {\tt in1} and {\tt in2}.  The result of this operation
  31 is then made available at {\tt out}.
  32
  33 \subsection*{To Do}
  34
  35 The {\it link bit} and other features of \cite{ies31} are not yet
  36 implemented.
  37
  38 The carry-in, carry-out, zero-test, negative-test, and overflow-test
  39 flags typically present in a conventional processor ALU are also not
  40 yet implemented.
  41
  42 == Fleeterpreter ====================================================
  43 public long resolveLiteral(String literal) {
  44   if (literal.equals("ADD")) return 0;
  45   if (literal.equals("SUB")) return 1;
  46   if (literal.equals("MAX")) return 2;
  47   if (literal.equals("MIN")) return 3;
  48   return super.resolveLiteral(literal);
  49 }
  50 public void service() {
  51   if (box_in1.dataReadyForShip() &&
  52       box_in2.dataReadyForShip() &&
  53       box_inOp.dataReadyForShip() &&
  54       box_out.readyForDataFromShip()) {
  55       long a      = box_in1.removeDataForShip();
  56       long b      = box_in2.removeDataForShip();
  57       long op     = box_inOp.removeDataForShip();
  58       switch((int)op) {
  59           case 0: box_out.addDataFromShip(a+b); // ADD
  60               break;
  61           case 1: box_out.addDataFromShip(a-b); // SUB
  62               break;
  63           case 2: box_out.addDataFromShip(Math.max(a,b)); // MAX
  64               break;
  65           case 3: box_out.addDataFromShip(Math.min(a,b)); // MIN
  66               break;
  67           default: box_out.addDataFromShip(0);
  68               break;
  69       }
  70   }
  71 }
  72
  73 == FleetSim ==============================================================
  74
  75 == FPGA ==============================================================
  76
  77   reg                    have_a;
  78   reg [(`DATAWIDTH-1):0] reg_a;
  79   reg                    have_b;
  80   reg [(`DATAWIDTH-1):0] reg_b;
  81   reg                    have_op;
  82   reg [(`DATAWIDTH-1):0] reg_op;
  83
  84   always @(posedge clk) begin
  85     if (!have_a) begin
  86       `onread(in1_r, in1_a) have_a = 1; reg_a = in1_d; end
  87       end
  88     if (!have_b) begin
  89       `onread(in2_r, in2_a) have_b = 1; reg_b = in2_d; end
  90       end
  91     if (!have_op) begin
  92       `onread(inOp_r, inOp_a) have_op = 1; reg_op = inOp_d; end
  93       end
  94
  95     if (have_a && have_b && have_op) begin
  96       case (reg_op)
  97         0: out_d = reg_a + reg_b;
  98         1: out_d = reg_a - reg_b;
  99         2: out_d = reg_a > reg_b ? reg_a : reg_b;
 100         3: out_d = reg_a > reg_b ? reg_b : reg_a;
 101         default: out_d = 0;
 102       endcase
 103       `onwrite(out_r, out_a)
 104         have_a  = 0;
 105         have_b  = 0;
 106         have_op = 0;
 107       end
 108     end
 109   end
 110
 111 == Test ==============================================================================
 112 // expected output
 113 #ship debug : Debug
 114 #ship alu   : Alu2
 115
 116 #expect 17
 117 #expect 1
 118 #expect 8
 119 #expect 9
 120
 121 debug.in:   [*] take, deliver;
 122 alu.in1:
 123   literal 9; load repeat counter with 4; deliver;
 124
 125 alu.in2:
 126   literal 8; load repeat counter with 4; deliver;
 127
 128 alu.in1:    [*] take, deliver;
 129 alu.in2:    [*] take, deliver;
 130 alu.out:    [*] take, sendto debug.in;
 131
 132 alu.inOp:
 133  literal Alu2.inOp[ADD]; deliver;
 134  literal Alu2.inOp[SUB]; deliver;
 135  literal Alu2.inOp[MIN]; deliver;
 136  literal Alu2.inOp[MAX]; deliver;
 137
 138
 139
 140 == Contributors =========================================================
 141 Adam Megacz <megacz@cs.berkeley.edu>