mild overhaul of Interpreter; now capable of performing MergeSort

[fleet.git] / src / edu / berkeley / fleet / interpreter / InterpreterDock.java

diff --git a/src/edu/berkeley/fleet/interpreter/InterpreterDock.java b/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
index a08531c..5c7e9ec 100644 (file)
--- a/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
+++ b/src/edu/berkeley/fleet/interpreter/InterpreterDock.java
@@ -18,15 +18,13 @@ class InterpreterDock extends FleetTwoDock {
     final BitVector dataLatch = new BitVector(getShip().getFleet().getWordWidth());
     InterpreterPath pathLatch = null;
     boolean         requeueStageInCirculatingState = false;
-    boolean         requeueStageHasTailInstruction = false;
-    boolean         torpedoWaiting = false;
     boolean         flushing = false;
 
     LinkedList<Instruction> instructions = new LinkedList<Instruction>();
     LinkedList<Packet> dataPackets = new LinkedList<Packet>();
 
     // HACK
-    private LinkedList<Instruction> instructionsBackedUpIntoSwitchFabric = new LinkedList<Instruction>();
+    private LinkedList<Packet> instructionsBackedUpIntoSwitchFabric = new LinkedList<Packet>();
 
     boolean dataReadyForShip = false;
     boolean readyForDataFromShip = true;
@@ -45,13 +43,11 @@ class InterpreterDock extends FleetTwoDock {
         dataLatch.set(0);
         pathLatch = null;
         requeueStageInCirculatingState = false;
-        requeueStageHasTailInstruction = false;
         instructions.clear();
         dataPackets.clear();
         instructionsBackedUpIntoSwitchFabric.clear();
         dataReadyForShip = false;
         readyForDataFromShip = true;
-        torpedoWaiting = false;
         flushing = false;
     }
 
@@ -60,20 +56,7 @@ class InterpreterDock extends FleetTwoDock {
     /** includes the epilogue fifo */
     public InterpreterDestination instructionDestination = new InterpreterDestination(this) {
             public String toString() { return getDock()+":i"; }
-            public void addDataFromFabric(Packet p) {
-                if (p.isToken()) {
-                    if (instructionsBackedUpIntoSwitchFabric.size()!=0)
-                        throw new RuntimeException("torpedo arrived while instructions were backed up into switch fabric");
-                    if (torpedoWaiting) throw new RuntimeException("two torpedoes collided!");
-                    torpedoWaiting = true;
-                    return;
-                }
-
-                Instruction inst =
-                    getInterpreter().decodeInstruction(p.getValue(),
-                                                       InterpreterDock.this /* this is wrong, but harmless */);
-                addInstruction(inst);
-            }
+            public void addDataFromFabric(Packet p) { addInstruction(p); }
         };
     public InterpreterDestination dataDestination = new InterpreterDestination(this) {
             public String toString() { return getDock()+""; }
@@ -93,19 +76,22 @@ class InterpreterDock extends FleetTwoDock {
 
     boolean trace = false;
 
-    private void addInstruction(Instruction inst) {
-        if (requeueStageInCirculatingState || requeueStageHasTailInstruction) {
-            // GROSS HACK
-            instructionsBackedUpIntoSwitchFabric.add(inst);
-            return;
+    private void addInstruction(Packet p) {
+        if (p.isToken() ||
+            instructionsBackedUpIntoSwitchFabric.size()!=0 ||
+            requeueStageInCirculatingState ||
+            (p2i(p) instanceof Instruction.Tail)) {
+            instructionsBackedUpIntoSwitchFabric.add(p);
+        } else {
+            instructions.add(p2i(p));
         }
-        if (inst instanceof Instruction.Tail) {
-            requeueStageHasTailInstruction = true;
-            return;
-        }
-        instructions.add(inst);
     }
     
+    private Instruction p2i(Packet p) {
+        if (p.isToken()) throw new RuntimeException();
+        return getInterpreter().decodeInstruction(p.getValue(), InterpreterDock.this /* this is wrong, but harmless */);
+    }
+
     protected final void service() {
 
         if (dataReadyForShip || flushing) return;
@@ -113,10 +99,12 @@ class InterpreterDock extends FleetTwoDock {
 
         if (instructions.peek() instanceof Instruction.Head) {
             if (requeueStageInCirculatingState) { instructions.remove(); return; }
-            if (!requeueStageHasTailInstruction) return;
-            requeueStageHasTailInstruction = false;
-            requeueStageInCirculatingState = true;
-            instructions.remove();
+            Packet p = instructionsBackedUpIntoSwitchFabric.peek();
+            if (p!=null && !p.isToken() && p2i(p) instanceof Instruction.Tail) {
+                instructionsBackedUpIntoSwitchFabric.remove();
+                requeueStageInCirculatingState = true;
+                instructions.remove();
+            }
             return;
         }
 
@@ -132,11 +120,14 @@ class InterpreterDock extends FleetTwoDock {
 
                 if (ilc==0) { ilc = 1; break; }
 
-                if (move.interruptible && torpedoWaiting) {
-                    torpedoWaiting = false;
-                    ilc = 1;
-                    flag_d = true;
-                    break;
+                if (move.interruptible) {
+                    Packet p = instructionsBackedUpIntoSwitchFabric.peek();
+                    if (p!=null && p.isToken()) {
+                        instructionsBackedUpIntoSwitchFabric.remove();
+                        ilc = 1;
+                        flag_d = true;
+                        break;
+                    }
                 }
 
                 if (move.dataIn  && !isInputDock() && readyForDataFromShip)  return;
@@ -177,12 +168,11 @@ class InterpreterDock extends FleetTwoDock {
 
             } else if (instructions.peek() instanceof Instruction.Abort) {
                 requeueStageInCirculatingState = false;
-                // HACK
-                while (instructionsBackedUpIntoSwitchFabric.size()!=0) {
-                    Instruction i = instructionsBackedUpIntoSwitchFabric.remove();
-                    addInstruction(i);
-                    instructionsBackedUpIntoSwitchFabric.clear();
-                }
+                LinkedList<Packet> temp = new LinkedList<Packet>();
+                while (instructionsBackedUpIntoSwitchFabric.size()!=0)
+                    temp.add(instructionsBackedUpIntoSwitchFabric.remove());
+                while (temp.size()!=0)
+                    addInstruction(temp.remove());
                 break;
 
             } else if (instructions.peek() instanceof Instruction.Flush) {
@@ -284,9 +274,7 @@ class InterpreterDock extends FleetTwoDock {
         if (instructions.size()==0 &&
             dataPackets.size()==0 &&
             instructionsBackedUpIntoSwitchFabric.size()==0 &&
-            !requeueStageHasTailInstruction &&
             !requeueStageInCirculatingState &&
-            !torpedoWaiting &&
             !flushing &&
             !dataReadyForShip &&
             readyForDataFromShip)
@@ -299,8 +287,6 @@ class InterpreterDock extends FleetTwoDock {
                            (flag_c?"[c] ":"")+
                            (flag_d?"[d] ":"")+
                            (requeueStageInCirculatingState?"[recirculating] ":"")+
-                           (requeueStageHasTailInstruction?"[tail waiting] ":"")+
-                           (torpedoWaiting?"[torpedo waiting] ":"")+
                            (flushing?"[flushing] ":"")
                            );
         if (!readyForDataFromShip)
@@ -309,7 +295,7 @@ class InterpreterDock extends FleetTwoDock {
             System.out.println(ANSI.cyan("  waiting for ship to accept: " + dataLatch.toLong()));
         for(Instruction i : instructions)
             System.out.println(ANSI.red("  "+i));
-        for(Instruction i : instructionsBackedUpIntoSwitchFabric)
+        for(Packet i : instructionsBackedUpIntoSwitchFabric)
             System.out.println(ANSI.red(ANSI.bold("  "+i+" BACKED UP")));
         for(Packet p : dataPackets)
             System.out.println(ANSI.cyan("  "+p));