package edu.berkeley.fleet.marina;
-/* -*- tab-width: 4 -*- */
+import edu.berkeley.fleet.api.*;
import com.sun.electric.tool.simulation.test.*;
+import com.sun.electric.tool.simulation.test.BitVector;
-import edu.berkeley.fleet.api.Instruction;
-import edu.berkeley.fleet.marina.MarinaPath;
-
-/** The Marina object will eventually represent the Marina test chip.
- * Right now, it doesn't do much of anything. It just helps me exercise
- * my test infrastructure. */
public class Marina {
+ JtagLogicLevel mc0;
+ JtagLogicLevel mc1;
+ private final Indenter indenter;
+ public final ChainControl controlChain;
+ public final ChainControl dataChain;
+ public final ChainControl dukeChain;
+ public final ChainControl reportChain;
+ private final ChipModel model;
+ public final ProperStopper data;
+ public final InstructionStopper instrIn;
+ public final ProperStopper northRing;
+ public final InstructionStopper southRing;
+ int northCount = 0;
+ int southCount = 0;
+
+ public Marina(ChainControl controlChain,
+ ChainControl dataChain,
+ ChainControl dukeChain,
+ ChainControl reportChain,
+ ChipModel model,
+ boolean clockHack,
+ Indenter indenter) {
+ this.controlChain = controlChain;
+ this.dataChain = dataChain;
+ this.dukeChain = dukeChain;
+ this.reportChain = reportChain;
+ this.model = model;
+ this.indenter = indenter;
+ northRing = data = new ProperStopper(prefix+"northFif@1.fillDrai@1",
+ controlChain,
+ dataChain,
+ reportChain,
+ model,
+ clockHack,
+ indenter,
+ prefix+"northFif@1.fillDrai@1.instruct@0.cntScnTh@1.cntScnOn@1");
+ southRing = instrIn = new InstructionStopper(prefix+"southFif@1.tapPropS@1",
+ controlChain,
+ dataChain,
+ reportChain,
+ model,
+ clockHack,
+ indenter,
+ prefix+"southFif@1.tapPropS@1.instruct@0.cntScnTh@1.cntScnOn@1");
+ }
+
public static final int INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE = 5;
public static final int INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO = MarinaPath.SIGNAL_BIT_INDEX;
-
- public static int TOKEN_FIFO_CAPACITY = 3;
-
- //public static final boolean kesselsCounter = true;
+ private static final int COUNTER_LENGTH = 34;
+ public static final int INSTRUCTION_LENGTH = 36;
+ public static final int SOUTH_RING_CAPACITY = 11;
+ public static final int TOKEN_FIFO_CAPACITY = 3;
public static final boolean kesselsCounter = false;
public static final boolean omegaCounter = false;
-
public static final String DATA_CHAIN = kesselsCounter ? "marina.marina_data" : "marina.ivan_data";
public static final String CONTROL_CHAIN = kesselsCounter ? "marina.marina_control" : "marina.ivan_control";
public static final String REPORT_CHAIN = kesselsCounter ? "marina.marina_report" : "marina.ivan_report";
public static String prefix = "marinaGu@0.outDockW@"+(kesselsCounter?"3":"0")+".marinaOu@"+(kesselsCounter?"1":"0")+".";
public static String MASTER_CLEAR = "mc";
-
- /*
- private static String prefix = "outDockW@"+(kesselsCounter?"3":"0")+".marinaOu@1.";
- private static String MASTER_CLEAR = "EXTmasterClear";
- */
-
- private static final String OLC_PATH_EVEN =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.scanEx3h@1"; // bits 2,4,6
- private static final String OLC_PATH_ODD =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.scanEx3h@2"; // bits 1,3,5
- public static final String OLC_PATH_KESSEL =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.counte@0.adamScan@1.scanEx6h@";
- private static final String ILC_PATH_ODD =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx4h@0"; // bits 1,3,5,7
- private static final String ILC_PATH_EVEN =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx4h@1"; // bits 2,4,6,8
- private static final String FLAGS_PATH =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.scanEx3h@0";
-
- private static final String INSTR_RING_CONTROL_PATH =
- prefix+"southFif@1.tapPropS@1.tapStage@2";
- private static final String TOK_FIFO_PATH =
- prefix+"tokenFIF@1";
- private static final String INSTRUCTION_COUNTER_PATH =
- prefix+"southFif@1.tapPropS@1.instruct@0";
- private static final String DATA_COUNTER_PATH =
- prefix+"northFif@1.fillDrai@1.instruct@0";
- private static final String TOK_PRED_PATH =
- prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx2h@0.scanCell@10";
-
- private static final int COUNTER_LENGTH = 34;
- private static final int INSTRUCTION_SEND_NDX = 1;
- private static final int INSTRUCTION_RECIRCULATE_NDX = 0;
-
- public static final int INSTRUCTION_LENGTH = 36;
-
- private static final int A_FLAG_NDX = 0;
- private static final int B_FLAG_NDX = 1;
-
- public static final int SOUTH_RING_CAPACITY = 11;
+ private static final String CENTER_PATH = prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0";
+ private static final String OLC_PATH_EVEN = CENTER_PATH+".olcWcont@0.scanEx3h@1"; // bits 2,4,6
+ private static final String OLC_PATH_ODD = CENTER_PATH+".olcWcont@0.scanEx3h@2"; // bits 1,3,5
+ private static final String OLC_PATH_KESSEL = CENTER_PATH+".counte@0.adamScan@1.scanEx6h@";
+ private static final String ILC_PATH_ODD = CENTER_PATH+".ilcMoveO@0.scanEx4h@0"; // bits 1,3,5,7
+ private static final String ILC_PATH_EVEN = CENTER_PATH+".ilcMoveO@0.scanEx4h@1"; // bits 2,4,6,8
+ private static final String FLAGS_PATH = CENTER_PATH+".flags@0.scanEx3h@0";
+ private static final String TOK_FIFO_PATH = prefix+"tokenFIF@1";
+ private static final String INSTRUCTION_COUNTER_PATH = prefix+"southFif@1.tapPropS@1.instruct@0";
+ private static final String DATA_COUNTER_PATH =prefix+"northFif@1.fillDrai@1.instruct@0";
+ private static final String TOK_PRED_PATH = CENTER_PATH+".ilcMoveO@0.scanEx2h@0.scanCell@10";
// ILC appears in scan chain as "count[1:6], zLo, i, dLo"
- public class Ilc {
+ private class Ilc {
// value is bit reversed and complemented
private int value;
private Ilc() {
}
}
- private final Indenter indenter;
-
- // The name of the scan chain
- // The instance path, from the top cell of the netlist, of the instance of infinityWithCover
- public final ChainControl controlChain;
- public final ChainControl dataChain;
- public final ChainControl dukeChain;
- public final ChainControl reportChain;
-
- private final ChipModel model;
- public final ProperStopper data;
- public final InstructionStopper instrIn;
-
- private void prln(String msg) {indenter.prln(msg);}
- private void pr(String msg) {indenter.pr(msg);}
-
/** Shift the report scan chain */
public void shiftReport(boolean readEnable, boolean writeEnable) {
reportChain.shift(REPORT_CHAIN, readEnable, writeEnable);
dukeChain.shift(DUKE_CHAIN, readEnable, writeEnable);
}
- public Marina(ChainControl controlChain,
- ChainControl dataChain,
- ChainControl dukeChain,
- ChainControl reportChain,
- ChipModel model, boolean clockHack, Indenter indenter) {
- this.controlChain = controlChain;
- this.dataChain = dataChain;
- this.dukeChain = dukeChain;
- this.reportChain = reportChain;
- this.model = model;
- this.indenter = indenter;
- data = new ProperStopper("north fifo",
- prefix+"northFif@1.fillDrai@1.properSt@1",
- controlChain,
- dataChain,
- reportChain,
- model, clockHack, indenter,
- prefix+"northFif@1.fillDrai@1.instruct@0.cntScnTh@1.cntScnOn@1");
- instrIn = new InstructionStopper("south fifo",
- prefix+"southFif@1.tapPropS@1.properSt@1",
- controlChain,
- dataChain,
- reportChain,
- model, clockHack, indenter,
- prefix+"southFif@1.tapPropS@1.instruct@0.cntScnTh@1.cntScnOn@1");
- }
-
- int northCount = 0;
- int southCount = 0;
-
public void stopAndResetCounters() {
instrIn.setCounterEnable(false);
data.setCounterEnable(false);
public int getNorthCount() { return northCount; }
public int getSouthCount() { return southCount; }
-
public void masterClear() {
final double WIDTH = 10; // ns
// Put a high going pulse on the internal chip master clear signal
// value. In verilog we need to prevent the X'es from
// propagating, so we force the flags to a known value
//
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__set_", 0);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__clr_", 1);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__set_", 0);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__clr_", 1);
+ vm.setNodeState(CENTER_PATH+".flag_A__set_", 0);
+ vm.setNodeState(CENTER_PATH+".flag_A__clr_", 1);
+ vm.setNodeState(CENTER_PATH+".flag_B__set_", 0);
+ vm.setNodeState(CENTER_PATH+".flag_B__clr_", 1);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__set_", 1);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__clr_", 0);
+ vm.setNodeState(CENTER_PATH+".flag_D__set_", 1);
+ vm.setNodeState(CENTER_PATH+".flag_D__clr_", 0);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@0.net_50", 0); // A
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@1.net_50", 0); // B
+ vm.setNodeState(CENTER_PATH+".flags@0.aFlag@0.net_50", 0); // A
+ vm.setNodeState(CENTER_PATH+".flags@0.aFlag@1.net_50", 0); // B
vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.litDandP@0.latch2in@0.hi2inLat@0.latchKee@0.out_B_", 0); // C
// possible C-flag inputs
// force the OLC to zero
if (!kesselsCounter)
for(int i=1; i<=6; i++)
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.inLO["+i+"]", (i==1)?0:1);
+ vm.setNodeState(CENTER_PATH+".olcWcont@0.olc@0.inLO["+i+"]", (i==1)?0:1);
// set the ILC input to 1
for(int i=1; i<=8; i++) {
if (i!=7)
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.\\inLO["+i+"]", (i==1)?0:1);
+ vm.setNodeState(CENTER_PATH+".ilcMoveO@0.ilc@0.\\inLO["+i+"]", (i==1)?0:1);
}
vm.setNodeState(prefix+"northFif@1.upDown8w@2.weakStag@22.addr1in2@0.fire", 1);
model.waitNS(1000);
// pulse ilc[load] and olc[load]
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_load_", 1);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_decLO_", 1);
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_torpLO_", 1);
+ vm.setNodeState(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_load_", 1);
+ vm.setNodeState(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_decLO_", 1);
+ vm.setNodeState(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_torpLO_", 1);
if (!kesselsCounter)
- vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.olc_load_", 1);
+ vm.setNodeState(CENTER_PATH+".olcWcont@0.olc@0.olc_load_", 1);
model.waitNS(100);
model.waitNS(1);
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_load_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_decLO_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_torpLO_");
+ vm.releaseNode(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_load_");
+ vm.releaseNode(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_decLO_");
+ vm.releaseNode(CENTER_PATH+".ilcMoveO@0.ilc@0.ilc_torpLO_");
if (!kesselsCounter)
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.olc_load_");
+ vm.releaseNode(CENTER_PATH+".olcWcont@0.olc@0.olc_load_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__set_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__clr_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__set_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__clr_");
+ vm.releaseNode(CENTER_PATH+".flag_A__set_");
+ vm.releaseNode(CENTER_PATH+".flag_A__clr_");
+ vm.releaseNode(CENTER_PATH+".flag_B__set_");
+ vm.releaseNode(CENTER_PATH+".flag_B__clr_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__set_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__clr_");
+ vm.releaseNode(CENTER_PATH+".flag_D__set_");
+ vm.releaseNode(CENTER_PATH+".flag_D__clr_");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@0.net_50");
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@1.net_50");
+ vm.releaseNode(CENTER_PATH+".flags@0.aFlag@0.net_50");
+ vm.releaseNode(CENTER_PATH+".flags@0.aFlag@1.net_50");
// Every move instruction, even those with Ti=0,Di=0,
// loads the C-flag. It will get loaded with an "X",
for(int i=1; i<=8; i++) {
if (i!=7)
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.\\inLO["+i+"] ");
+ vm.releaseNode(CENTER_PATH+".ilcMoveO@0.ilc@0.\\inLO["+i+"] ");
}
model.waitNS(1000);
if (!kesselsCounter)
for(int i=1; i<=6; i++)
- vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.inLO["+i+"]");
+ vm.releaseNode(CENTER_PATH+".olcWcont@0.olc@0.inLO["+i+"]");
// the proper stopper states come up in an undefined ("X")
// state, so under Verilog we need to force them to a
resetAfterMasterClear();
}
- JtagLogicLevel mc0;
- JtagLogicLevel mc1;
-
private void resetAfterMasterClear() {
// The following call to ChainControl.resetInBits() is vital!
// If you forget, then the inBits member initializes
return (int)bv.toLong();
}
}
- /** Get the 7 bit inner loop counter. The MSB is the zero bit.
- * The low order 6 bits are the count */
- public Ilc getILC() {
- return new Ilc();
- }
- /** Get the A flag */
+ public boolean getILCInfinity() { return new Ilc().getInfinity(); }
+ public boolean getILCDone() { return new Ilc().getDone(); }
+ public int getILC() { return new Ilc().getCount(); }
public boolean getFlagA() {
shiftReport(true, false);
- return reportChain.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(A_FLAG_NDX);
+ return reportChain.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(0);
}
- /** Get the B flag */
public boolean getFlagB() {
shiftReport(true, false);
- return reportChain.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(B_FLAG_NDX);
- }
- /** return value of instruction counter. Instruction counter counts
- * the instructions flowing through 1/2 of alternating FIFO.
- * Caution: instruction counter is written by all scans,
- * regardless of readEnable or writeEnable! */
- public long getInstructionCounter() {
- shiftData(true, false);
- BitVector count = dataChain.getOutBits(DATA_CHAIN+"."+INSTRUCTION_COUNTER_PATH);
- int sz = count.getNumBits();
- MarinaTest.fatal(sz!=COUNTER_LENGTH, "wrong number of counter bits: "+sz+
- " expected: "+COUNTER_LENGTH);
- return count.bitReverse().toLong();
- }
- /** return value of data counter. Data counter counts items flowing
- * through drain stage of data proper stopper.
- * Caution: data counter is written by all scans,
- * regardless of readEnable or writeEnable! */
- public long getDataCounter() {
- shiftData(true, false);
- BitVector count = dataChain.getOutBits(DATA_CHAIN+"."+DATA_COUNTER_PATH);
- int sz = count.getNumBits();
- MarinaTest.fatal(sz!=COUNTER_LENGTH, "wrong number of counter bits: "+sz+
- " expected: "+COUNTER_LENGTH);
- return count.bitReverse().toLong();
- }
- /** Fill the "North" Fifo ring */
- public void fillNorthProperStopper() {
- BitVector data = new BitVector(37, "empty");
- BitVector addr = new BitVector(14, "empty");
- for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
- for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
- fillNorthProperStopper(new MarinaPacket(data, false, addr));
- }
- /** Fill the "North" Fifo ring */
- public void fillNorthProperStopper(MarinaPacket mp) {
- prln("inserting into north: " + mp);
- this.data.fill(mp.toSingleBitVector());
- }
- /** Enable the transmission of instructions from the instruction
- * ring test structure to the EPI FIFO. */
- public void enableInstructionSend(boolean b) {
- BitVector bv = controlChain.getInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH);
- bv.set(INSTRUCTION_SEND_NDX, b);
- controlChain.setInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH, bv);
- shiftControl(false, true);
- }
- /** Enable the recirculation of instructions within the South FIFO */
- public void enableInstructionRecirculate(boolean b) {
- BitVector bv = controlChain.getInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH);
- bv.set(INSTRUCTION_RECIRCULATE_NDX, b);
- controlChain.setInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH, bv);
- shiftControl(false, true);
+ return reportChain.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(1);
}
/** get the number of tokens in the token FIFO.
* This includes the Token successor wire, the token FIFO wires,
// concatenate them
bv = bv.cat(pred);
sz = bv.getNumBits();
- prln("Token state wires: "+bv.getState());
int nbTok = 0;
for (int i=0; i<sz; i++) if (bv.get(i)) nbTok++;
return nbTok;
}
- /** Configure the test probe so it measures the throughput of
- * the north data FIFO. The test probe frequency is 8192
- * times slower than the FIFO throughput. This control has
- * highest priority. */
- public void probeDataCounter(Boolean b) {
- data.setGeneralPurposeOutput(b);
- }
- /** Configure the test probe so it measures the throughput of
- * the alternating instruction FIFO. The test probe frequency is
- * 1/16384 of the FIFO throughput. This control has second
- * highest priority. Thus the following two calls probe the
- * instruction counter:
- * probeDataCounter(false);
- * probeInstructionCounter(true)
- */
- public void enableInstructionCounter(Boolean b) {
- instrIn.setGeneralPurposeOutput(b);
- }
-
- public void fillSouthProperStopper(Instruction i) {
- instrIn.fill(i);
- }
- public void fillSouthProperStopper(Instruction[] instructions) { fillSouthProperStopper(instructions, false); }
- public void fillSouthProperStopper(Instruction[] instructions, boolean repeat) { fillSouthProperStopper(instructions, repeat, false); }
- public void fillSouthProperStopper(Instruction[] instructions, boolean repeat, boolean leaveStopped) {
- enableInstructionSend(false);
- enableInstructionRecirculate(true);
- for(Instruction i : instructions)
- if (i!=null) {
- instrIn.fill(i);
- } else {
- instrIn.fillTorpedo();
- }
- enableInstructionRecirculate(repeat);
- enableInstructionSend(true);
- if (!leaveStopped) instrIn.run();
- }
-
-
}
import java.util.List;
import com.sun.electric.tool.simulation.test.*;
-import edu.berkeley.fleet.marina.Marina.Ilc;
import edu.berkeley.fleet.marina.CmdArgs;
import edu.berkeley.fleet.marina.CmdArgs.Mode;
prln("Begin sendDataIlcInfinite");
adjustIndent(2);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
SEND_DATA,
});
"predicate olc"+(predicate_olc_nonzero?"!=0":"==0"));
adjustIndent(2);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
setOlc(olc),
new Instruction.Move(dock,
predicate_olc_nonzero // predicate
adjustIndent(2);
showOlc();
- Ilc ilc = marina.getILC();
- prln("ILC.done=="+ilc.getDone()+
- " ILC.infinity=="+ilc.getInfinity()+
- " ILC.count=="+ilc.getCount());
+ prln("ILC.done=="+marina.getILCDone()+
+ " ILC.infinity=="+marina.getILCInfinity()+
+ " ILC.count=="+marina.getILC());
prln("flagA=="+marina.getFlagA());
prln("flagB=="+marina.getFlagB());
adjustIndent(-2);
private void walkOneOLC(Marina marina) {
prln("Begin walkOneOLC");
- adjustIndent(2);
/*
+ adjustIndent(2);
//for (int i=-1; i<6; i++) {
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Head(dock),
new Instruction.Tail(dock),
});
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
null,
},
true);
System.out.println("master-clearing...");
// master clear on each iteration; otherwise we'd need to "run down" the olc
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
expectTokensExactly(0);
int inIlc = 1 << i;
prln("inIlc="+inIlc);
marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, inIlc));
- Ilc ilc = marina.getILC();
- int outIlc = ilc.getCount();
+ int outIlc = marina.getILC();
fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+inIlc);
- fatal(ilc.getInfinity(), "bad Infinity bit: true");
+ fatal(marina.getILCInfinity(), "bad Infinity bit: true");
}
prln("Now test the infinity bit");
marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
- Ilc ilc = marina.getILC();
- fatal(!ilc.getInfinity(), "bad Infinity bit: false");
+ fatal(!marina.getILCInfinity(), "bad Infinity bit: false");
adjustIndent(-2);
prln("End walkOneILC");
}
marina.instrIn.fill(new
Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, maxIlc));
- int ilc = marina.getILC().getCount();
+ int ilc = marina.getILC();
fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc);
prln("execute a move instruction that does nothing except decrement the ILC to zero");
//model.waitNS(10000);
prln("Check that ILC==0");
- ilc = marina.getILC().getCount();
+ ilc = marina.getILC();
fatal(ilc!=0, "bad ILC count: "+ilc+" expected: "+0);
adjustIndent(-2);
System.out.println("master-clearing...");
// master clear on each iteration; otherwise we'd need to "run down" the olc
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
int inOlc = i;
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
setIlc(1),
});
model.waitNS(128 * CYCLE_TIME_NS);
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
model.waitNS(128 * CYCLE_TIME_NS);
expectOlc(inOlc);
private void testFlagDRecomputationTime(Marina marina) {
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
SEND_DATA_IF_D_NOT_SET
});
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
expectNorthFifoNoMoreThan(0);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
SEND_DATA_IF_D_NOT_SET
});
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
expectNorthFifoNoMoreThan(0);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
SEND_DATA_IF_D_NOT_SET
});
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
expectNorthFifoExactly(1);
marina.instrIn.fill(DEC);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
SEND_DATA_IF_D_NOT_SET
});
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
expectNorthFifoExactly(1);
}
marina.instrIn.fill(setIlc(1));
marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
- marina.enableInstructionSend(false);
- marina.enableInstructionRecirculate(true);
+ marina.southRing.enableInstructionSend(false);
+ marina.southRing.enableInstructionRecirculate(true);
marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
marina.instrIn.fill(new Instruction.Head(dock));
marina.instrIn.fill(new Instruction.Tail(dock));
marina.instrIn.fillTorpedo();
- marina.enableInstructionRecirculate(false);
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionRecirculate(false);
+ marina.southRing.enableInstructionSend(true);
marina.instrIn.run();
expectNorthFifoNoMoreThan(0);
prln("inserting into north proper stopper");
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
expectNorthFifoExactly(1);
int nbToks = marina.getNumTokens();
fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
private void testTailWithoutHead(Marina marina) {
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
new Instruction.Tail(dock),
SEND_DATA,
adjustIndent(2);
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
new Instruction.Head(dock),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
private void testNonTorpedoableMoveDoesNotResetDFlag(Marina marina) {
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,63),
new Instruction.Move(dock,
Predicate.IgnoreFlagD, // predicate
});
marina.instrIn.fillTorpedo();
expectNorthFifoExactly(1);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Move(dock,
Predicate.Default, // predicate
false, // torpedoable
private void testAbort(Marina marina) {
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,1),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
SEND_DATA_IF_D_NOT_SET,
private void testAbortOutsideOfLoop(Marina marina) {
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
// ensure that an abort doesn't cause problems if no loop is in progress
new Instruction.Abort(dock, Predicate.IgnoreFlagD),
SEND_DATA,
b ? one : zero
);
if (fast) {
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
inst,
NOP,
});
model.waitNS(64 * CYCLE_TIME_NS);
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
} else {
marina.instrIn.fill(inst);
}
for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
addr.set(Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE, c_state);
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
marina.instrIn.fill(RECV_DATA);
Instruction.Set.FlagFunction func = zero;
adjustIndent(2);
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
new Instruction.Move(dock,
Predicate.IgnoreFlagD, // predicate
BitVector addr = new BitVector(14, "empty");
for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
model.waitNS(64 * CYCLE_TIME_NS);
prln("checking to see if A flag got set");
prln("testing with bit pattern " + data);
prln("inserting data item into north fifo ring");
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
prln("stopping the north proper stopper");
marina.data.stop();
for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
data.set(bit, true);
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.DataLatch),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,-1),
if (marina.kesselsCounter) {
// master clear on each iteration; otherwise we'd need to "run down" the olc
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
}
for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
data.set(bit, true);
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
RECV_DATA,
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.DataLatch),
});
model.waitNS(CYCLE_TIME_NS * 64);
- int ilc = marina.getILC().getCount();
+ int ilc = marina.getILC();
fatal(ilc != (1<<bit), "expected ilc to be " + (1<<bit) + ", but got " + ilc);
}
adjustIndent(2);
marina.instrIn.fill(setIlc(1));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
SEND_TOKEN,
RECV_TOKEN,
SEND_DATA,
marina.instrIn.fill(setIlc(1));
for(long val : new long[] { (-1L << 14), -1, 0, 1 }) {
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,
Instruction.Set.SetDest.DataLatch,
val),
for(int i=0; i<19; i++)
dreg.set(i, immediate.get(i));
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Shift(dock,Predicate.IgnoreFlagD,immediate),
SEND_DATA,
});
addr.set(whichbit, c_flag);
prln("... and filling north fifo proper stopper");
- marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
+ marina.northRing.fill(new MarinaPacket(data, false, addr));
prln("clearing flags");
prln("executing recv data with Dc="+dc);
prln("copying c-flag to a-flag");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
new Instruction.Move(dock,
Predicate.IgnoreFlagD, /* predicate */
MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
new Instruction.Move(dock,
Predicate.IgnoreFlagD, /* predicate */
BitVector packet_path = new BitVector(14, "inbound data item");
for(int i=0; i<14; i++) packet_path.set(i, false);
- marina.fillNorthProperStopper(new MarinaPacket(packet_data, false, packet_path));
+ marina.northRing.fill(new MarinaPacket(packet_data, false, packet_path));
prln("recv path, send data (using recv'd path)");
marina.instrIn.fill(new Instruction.Move(dock,
for(int bit=0; bit<6; bit++) {
int ilc = bit<0 ? 0 : (1<<bit);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,ilc),
SEND_DATA,
});
private void testILCZero(Marina marina) {
adjustIndent(2);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,0),
SEND_DATA,
SEND_TOKEN,
model.waitNS(128 * CYCLE_TIME_NS);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity),
new Instruction.Move(dock,
Predicate.IgnoreFlagD, // predicate
marina.instrIn.fill(setIlc(1));
for(boolean torpedoable : new boolean[] { true, false }) {
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Move(dock,
Predicate.IgnoreFlagD, // predicate
false, // torpedoable
dataItems = marina.data.drainMany(2);
fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
- fatal(!marina.getILC().getDone(), "Expected ilc=done, but got "+marina.getILC());
+ fatal(!marina.getILCDone(), "Expected ilc=done, but got "+marina.getILC());
}
adjustIndent(-2);
}
private void testDFlagWhenTorpedoLyingInWait(Marina marina) {
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
setOlc(1),
RECV_DATA,
TORPEDOABLE_RECV_DATA,
expectTokensExactly(0);
// changing the order of these lines should work, but it does not
- marina.fillNorthProperStopper();
+ marina.northRing.fill();
marina.instrIn.fillTorpedo();
expectTokensExactly(1);
private void testSetOlcFollowedByDPredicated(Marina marina) {
for(boolean d_set : new boolean[] { false, true }) {
prln("");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
setOlc(0),
marina.kesselsCounter ? null : FLAG_NOP,
d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
expectNorthFifoExactly(d_set ? 1 : 0);
prln("");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
setOlc(32),
marina.kesselsCounter ? null : FLAG_NOP,
d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
if (marina.kesselsCounter) {
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
}
}
prln("inserting set olc="+olc);
prln("inserting set ilc=1");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,olc),
});
false // tokenOut
);
- marina.fillSouthProperStopper(instructions);
+ marina.southRing.fill(instructions);
model.waitNS(64 * CYCLE_TIME_NS);
int expected = decr_amount>=olc ? 0 : 1;
if (marina.kesselsCounter) {
// master clear on each iteration; otherwise we'd need to "run down" the olc
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
}
int notZero = 1<<i;
prln("Then immediately set ILC="+notZero);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
});
model.waitNS(64 * CYCLE_TIME_NS);
prln("Verify ILC using scan chain");
- Ilc ilc = marina.getILC();
- int ilcCount = ilc.getCount();
+ int ilcCount = marina.getILC();
fatal(ilcCount!=notZero, "bad ILC count: "+ilcCount+" expected: "+notZero);
- fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
+ fatal(marina.getILCInfinity(), "bad ILC Infinity bit: true");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
});
model.waitNS(64 * CYCLE_TIME_NS);
prln("Verify ILC using scan chain");
- ilc = marina.getILC();
- ilcCount = ilc.getCount();
+ ilcCount = marina.getILC();
fatal(ilcCount!=0, "bad ILC count: "+ilcCount+" expected: 0");
- fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
+ fatal(marina.getILCInfinity(), "bad ILC Infinity bit: true");
}
adjustIndent(-2);
if (marina.kesselsCounter) {
// master clear on each iteration; otherwise we'd need to "run down" the olc
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
int outOlc;
prln("Set OLC=0");
prln("Then immediately set OLC="+notZero);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
});
if (!marina.kesselsCounter) {
prln("Set OLC="+notZero);
prln("Then immediately set OLC=0");
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
});
prln("Begin testSouthRecirculate("+AMOUNT+")");
adjustIndent(2);
- marina.enableInstructionSend(false);
- marina.enableInstructionRecirculate(true);
+ marina.southRing.enableInstructionSend(false);
+ marina.southRing.enableInstructionRecirculate(true);
prln("Completely fill south ring");
adjustIndent(2);
System.out.println("******************************************************************************");
System.out.println("******************************************************************************");
fe.printStackTrace();
+ System.exit(-1);
}
}
if (testNum!=0) {
marina.masterClear();
- marina.enableInstructionSend(true);
+ marina.southRing.enableInstructionSend(true);
}
MarinaUtils.testnum = testNum;
marina.data.sink();
marina.stopAndResetCounters();
- marina.enableInstructionSend(true);
- marina.fillSouthProperStopper(new Instruction.Set(dock,Predicate.IgnoreFlagD,
+ marina.southRing.enableInstructionSend(true);
+ marina.southRing.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
Instruction.Set.FlagFunction.ZERO
.add(Predicate.FlagA).add(Predicate.NotFlagA),
Instruction.Set.FlagFunction.ZERO));
//int xx = 63; // 1.802ms
//int xx = 1; // 0.207ms => 24.3ns for 62 counts => 390ps cycle time => 2.5Ghz
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Head(dock),
setOlc(xx),
FLAG_NOP,
new Instruction.Tail(dock),
}, false, false);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
/*
new Instruction.Set(dock,Predicate.FlagD,
Instruction.Set.FlagFunction.ZERO.add(Predicate.NotFlagA),
marina.data.sink();
marina.stopAndResetCounters();
- marina.enableInstructionSend(true);
- marina.fillSouthProperStopper(setOlc(1));
- marina.fillSouthProperStopper(new Instruction.Head(dock));
+ marina.southRing.enableInstructionSend(true);
+ marina.southRing.fill(setOlc(1));
+ marina.southRing.fill(new Instruction.Head(dock));
for(int i=0; i<toks; i++)
- marina.fillSouthProperStopper(/*SEND_DATA*/NOP);
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(/*SEND_DATA*/NOP);
+ marina.southRing.fill(new Instruction[] {
new Instruction.Tail(dock),
}, false, true);
marina.data.sink();
marina.stopAndResetCounters();
- marina.enableInstructionSend(true);
- marina.fillSouthProperStopper(setOlc(1));
- marina.fillSouthProperStopper(new Instruction.Set(dock,Predicate.IgnoreFlagD,
+ marina.southRing.enableInstructionSend(true);
+ marina.southRing.fill(setOlc(1));
+ marina.southRing.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
Instruction.Set.FlagFunction.ZERO,
Instruction.Set.FlagFunction.ZERO));
- marina.fillSouthProperStopper(new Instruction.Head(dock));
- //marina.fillSouthProperStopper(setIlc(31));
- marina.fillSouthProperStopper(SEND_DATA);
+ marina.southRing.fill(new Instruction.Head(dock));
+ //marina.southRing.fill(setIlc(31));
+ marina.southRing.fill(SEND_DATA);
for(int i=0; i<toks+1; i++) {
- //marina.fillSouthProperStopper(FLAG_NOP_IF_FLAG_A);
- marina.fillSouthProperStopper(FLAG_NOP);
+ //marina.southRing.fill(FLAG_NOP_IF_FLAG_A);
+ marina.southRing.fill(FLAG_NOP);
}
- marina.fillSouthProperStopper(new Instruction[] {
+ marina.southRing.fill(new Instruction[] {
new Instruction.Tail(dock),
}, false, true);
marina.startCounters();
projects / fleet.git / commitdiff