src/edu/berkeley/fleet/interpreter/Outbox.java

   1 package edu.berkeley.fleet.interpreter;
   2 import edu.berkeley.sbp.util.ANSI;
   3 import edu.berkeley.fleet.api.*;
   4 import edu.berkeley.fleet.ies44.*;
   5 import edu.berkeley.sbp.util.*;
   6 import edu.berkeley.fleet.util.*;
   7 import static edu.berkeley.fleet.util.BitManipulations.*;
   8 import edu.berkeley.fleet.api.Instruction;
   9
  10 public class Outbox extends InstructionPump {
  11
  12     /** are we ready to accept another item from the ship? */
  13     private boolean readyForDataFromShip = false;
  14     private boolean haveDataFromShip     = false;
  15
  16     /** data which has been presented by the ship and is waiting to depart */
  17     private long    itemPresentedByShip;
  18
  19     /** number of tokens queued on the trigger input */
  20     private int     triggersReceived = 0;
  21
  22     /** the latched value */
  23     private long register;
  24
  25     public boolean isInbox() { return false; }
  26     public boolean isOutbox() { return true; }
  27     public Outbox(InterpreterShip ship, String name) { this(ship, name, new String[] { "" }); }
  28     public Outbox(InterpreterShip ship, String name, String[] ports) { super(ship, name, ports); }
  29
  30     protected void setDataLatch(long value) { register = value; }
  31     protected long peekDataLatch() { return register; }
  32
  33     protected final boolean service(Instruction.Executable instruction_) {
  34         if (clogged>0) return false;
  35         if (instruction_ instanceof Instruction.Clog) { clogged++; return true; }
  36         if (instruction_ instanceof Instruction.LocalLiteral) {
  37             Instruction.LocalLiteral ll = (Instruction.LocalLiteral)instruction_;
  38             register =
  39                 ll.high
  40                 ? setField(36, 19, ll.literal, register)
  41                 : setField(18,  0, ll.literal, register);
  42             return true;
  43         }
  44         Instruction.Move instruction = (Instruction.Move)instruction_;
  45
  46         // if no instruction waiting, do nothing
  47         if (instruction == null) return false;
  48
  49         // check firing conditions
  50         if (instruction.tokenIn && triggersReceived <= 0) return false;
  51         if (instruction.dataIn) {
  52             if (!haveDataFromShip) { readyForDataFromShip = true; return false; }
  53         }
  54
  55         // consume trigger
  56         if (instruction.tokenIn) triggersReceived--;
  57
  58         // consume item
  59         if (instruction.dataIn) {
  60             haveDataFromShip = false;
  61             if (instruction.latch)
  62                 register = itemPresentedByShip;
  63         }
  64
  65         if (instruction.dataOut) {
  66
  67             // if item to be transmitted, send it
  68             InterpreterDestination dest = (InterpreterDestination)instruction.dest;
  69             if (instruction.dataOutDest) {
  70                 // FIXME: still not supported
  71                 long bits = BitManipulations.getField(InstructionEncoder.OFFSET_PUMP_ADDR+InstructionEncoder.WIDTH_PUMP_ADDR-1,
  72                                                       InstructionEncoder.OFFSET_PUMP_ADDR,
  73                                                       register);
  74                 getInterpreter().dispatch(((Interpreter)getInterpreter()).iie.readInstruction(register), bits);
  75                 /*
  76                 dest = (InterpreterDestination)(((Interpreter)getInterpreter()).iie.getDestByAddr(bits));
  77                 if (dest == null) {
  78                     if (pump != null) {
  79
  80                 Pump pump = ((Interpreter)getInterpreter()).iie.getDestByInstAddr(bits);
  81                     }
  82                 }
  83                 */
  84                 //throw new RuntimeException();
  85             } else {
  86                 new Packet(getInterpreter(), this, register, dest).send();
  87             }
  88             if (instruction.tokenOut)
  89                 throw new RuntimeException("outboxes may not send acks!");
  90
  91         } else if (instruction.tokenOut) {
  92
  93             // if no item was sent, we might still send an ack
  94             new Packet(getInterpreter(), this, 0, (InterpreterDestination)instruction.dest).send();
  95         }
  96
  97         return true;
  98     }
  99
 100     public final boolean readyForDataFromShip() { return readyForDataFromShip; }
 101     public       void addDataFromShip(long data) { addItemFromShip(data); }
 102     public       void addDataFromFabric(Packet packet) { triggersReceived++; }
 103
 104     /** subclass invokes this to add an item from the ship */
 105     protected final void addItemFromShip(long data) {
 106         if (!readyForDataFromShip)
 107             throw new RuntimeException("tried to add an item to an outbox which was not ready!  you have a buggy ship!");
 108         readyForDataFromShip = false;
 109         haveDataFromShip = true;
 110         itemPresentedByShip = data;
 111     }
 112
 113     void shutdown() {
 114         if (haveDataFromShip)
 115             Log.println(ANSI.red(" WARNING: you left a value ("+itemPresentedByShip+") on outbox port " + this));
 116         if (triggersReceived > 0)
 117             Log.println(ANSI.red(" WARNING: you left a token on the trigger input to port " + this));
 118         super.shutdown(false);
 119     }
 120
 121 }