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;
dataLatch.set(0);
pathLatch = null;
requeueStageInCirculatingState = false;
- requeueStageHasTailInstruction = false;
instructions.clear();
dataPackets.clear();
instructionsBackedUpIntoSwitchFabric.clear();
dataReadyForShip = false;
readyForDataFromShip = true;
- torpedoWaiting = false;
flushing = false;
}
/** 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 at dock "+this);
- 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()+""; }
boolean trace = false;
- private void addInstruction(Instruction inst) {
- if (requeueStageInCirculatingState || requeueStageHasTailInstruction) {
- // GROSS HACK
- instructionsBackedUpIntoSwitchFabric.add(inst);
- return;
- }
- if (inst instanceof Instruction.Tail) {
- requeueStageHasTailInstruction = true;
- 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));
}
- 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;
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;
}
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;
} else if (instructions.peek() instanceof Instruction.Abort) {
requeueStageInCirculatingState = false;
+ LinkedList<Packet> temp = new LinkedList<Packet>();
while (instructionsBackedUpIntoSwitchFabric.size()!=0)
- addInstruction(instructionsBackedUpIntoSwitchFabric.remove());
+ temp.add(instructionsBackedUpIntoSwitchFabric.remove());
+ while (temp.size()!=0)
+ addInstruction(temp.remove());
break;
} else if (instructions.peek() instanceof Instruction.Flush) {
if (instructions.size()==0 &&
dataPackets.size()==0 &&
instructionsBackedUpIntoSwitchFabric.size()==0 &&
- !requeueStageHasTailInstruction &&
!requeueStageInCirculatingState &&
- !torpedoWaiting &&
!flushing &&
!dataReadyForShip &&
readyForDataFromShip)
(flag_c?"[c] ":"")+
(flag_d?"[d] ":"")+
(requeueStageInCirculatingState?"[recirculating] ":"")+
- (requeueStageHasTailInstruction?"[tail waiting] ":"")+
- (torpedoWaiting?"[torpedo waiting] ":"")+
(flushing?"[flushing] ":"")
);
if (!readyForDataFromShip)
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));