1 package com.sun.vlsi.chips.marina.test;
2 /* -*- tab-width: 4 -*- */
3 import java.util.ArrayList;
6 import com.sun.async.test.BitVector;
7 import com.sun.async.test.ChainControl;
8 import com.sun.async.test.ChainG;
9 import com.sun.async.test.ChainTest;
10 import com.sun.async.test.ChipModel;
11 import com.sun.async.test.HP34401A;
12 import com.sun.async.test.Infrastructure;
13 import com.sun.async.test.JtagSubchainTesterModel;
14 import com.sun.async.test.JtagTester;
15 import com.sun.async.test.ManualPowerChannel;
16 import com.sun.async.test.NanosimModel;
17 import com.sun.async.test.HsimModel;
18 import com.sun.async.test.VerilogModel;
19 import com.sun.async.test.Netscan4;
20 import com.sun.async.test.PowerChannel;
21 import com.sun.async.test.Pst3202Channel;
22 import com.sun.async.test.SiliconChip;
23 import com.sun.async.test.SimulationModel;
24 import com.sun.async.test.VoltageReadable;
25 import com.sun.vlsi.chips.marina.test.Marina.Ilc;
26 import com.sun.vlsi.chips.marina.test.CmdArgs;
27 import com.sun.vlsi.chips.marina.test.CmdArgs.Mode;
29 import edu.berkeley.fleet.api.Dock;
30 import edu.berkeley.fleet.api.Instruction;
31 import edu.berkeley.fleet.api.Predicate;
32 import edu.berkeley.fleet.api.Instruction.Set.SetDest;
33 import edu.berkeley.fleet.api.Instruction.Set.SetSource;
34 import edu.berkeley.fleet.marina.MarinaFleet;
35 import edu.berkeley.fleet.marina.MarinaPath;
40 public class MarinaTest {
41 public static final MarinaFleet marinaFleet = new MarinaFleet();
42 public static final Dock dock = marinaFleet.getOnlyInputDock();
44 //-------------------------- constants -----------------------------------
45 private static final String SCAN_CHAIN_XML = "marina.xml";
46 private static final String NET_LIST = "marina.spi";
48 public static final int INSTR_SZ = 36;
51 public static final Instruction.Set.FlagFunction CLEAR_FLAG
52 = Instruction.Set.FlagFunction.ZERO;
53 public static final Instruction.Set.FlagFunction SET_FLAG
54 = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA)
55 .add(Predicate.NotFlagA);
56 public static final Instruction.Set.FlagFunction A_FLAG
57 = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA);
59 public static final Instruction.Set.FlagFunction B_FLAG
60 = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB);
62 // COLUMN_LATENCY is a delay that is larger than the latency through an Infinity column
63 private static final int COLUMN_LATENCY = 10; // nanoseconds
66 // Officially, this should be the number of requeueing no-ops that
67 // can be inserted into an idle dock whose OLC is nonzero.
69 // Less formally, this is roughly the number of stages of
70 // buffering between the instruction insertion point and the
71 // instruction ring, plus the capacity of the instruction ring.
72 private static final int INSTRUCTION_IN_SATURATION_AMOUNT = 19;
74 // This is some number which is significantly greater than
75 // INSTRUCTION_IN_SATURATION_AMOUNT. Increasing it may slow the tests down, but
76 // will never cause them to operate incorrectly.
77 private static final int MORE_THAN_INSTRUCTION_IN_SATURATION_AMOUNT = 25;
79 // This is the number of items which can be in the instruction
80 // fifo ring WITHOUT causing it to stop circulating.
81 private static final int INSTRUCTION_RING_CAPACITY = 13;
83 // Officially, this should be the number of data items which can
84 // be sent from the dock while the "data" proper stopper is in
85 // the "stopped" state
87 // Less formally, this is roughly the number of stages of
88 // buffering between the dock's data successor and the "data"
91 FIXME: what is the correct value here?
92 private static final int DATA_OUT_SATURATION_AMOUNT = XXX;
95 // This is some number which is greater than
96 // DATA_OUT_SATURATION_AMOUNT, but less than the capacity of the
98 private static final int MORE_THAN_DATA_OUT_SATURATION_AMOUNT = 10;
100 // Nominal cycle time assuming 4 GHz throughput
101 public static double CYCLE_TIME_NS;
103 //-------------------------------- types ---------------------------------
105 //-------------------------- private data --------------------------------
106 private static long startTime;
108 public static Indenter indenter = new Indenter();
109 private Marina marina;
110 private ChipModel model;
111 //private ChainControl cc;
112 //private JtagTester tester;
113 private CmdArgs cmdArgs;
114 private PowerChannel corePowerSupply, padsPowerSupply;
115 private VoltageReadable coreVoltmeter, voltmeterForCurrent;
117 private ChainTest ctD, ctR, ctC;
118 private ChainControl ccD, ccR, ccC;
120 //-------------------------- private methods -----------------------------
121 /** @return true if simulation. Return false if we're testing silicon. */
122 private boolean sim() {return model instanceof SimulationModel;}
124 private void prln(String msg) {indenter.prln(msg);}
125 private void pr(String msg) {indenter.pr(msg);}
126 private void adjustIndent(int n) {indenter.adjustIndent(n);}
128 public static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
130 public static void fatalIfBitVectorsDoNotMatch(BitVector bv1, BitVector bv2) {
131 // FIXME: better error reporting needed here
133 fatal(bv1.getNumBits()!=bv2.getNumBits(), "lengths do not match");
135 boolean mismatch = false;
137 for(int i=0; i<bv1.getNumBits(); i++) {
138 if (bv1.get(i) != bv2.get(i)) {
143 fatal(mismatch, "bit vectors do not match on bits " + err + "\n "+bv1+"\n "+bv2);
146 private static void printTestTime() {
147 long endTime = System.currentTimeMillis();
148 System.out.println("Test took: "+(endTime-startTime)/1000.0+" sec");
151 // Tell user what we're about to do
152 private static void reportTask(CmdArgs args) {
153 System.out.println("Begin testing Marina");
155 case WHOLE_CHIP_SCHEMATIC_PARASITICS:
156 System.out.println(" Simulate whole chip, schematic parasitics");
158 case WHOLE_CHIP_LAYOUT_PARASITICS:
159 System.out.println(" Simulate whole chip, layout parasitics");
162 System.out.println(" Test silicon");
165 fatal(true, "unrecognized CmdArgs.Mode");
169 private void setUpSuppliesAndMeters(Station station) {
170 // set up power supplies and meters
172 prln("Testing station: "+station);
173 Infrastructure.gpibControllers = new int[] {0};
174 switch (cmdArgs.station) {
176 corePowerSupply = new Pst3202Channel("ch1", "HPST3202", 1);
177 padsPowerSupply = new Pst3202Channel("ch2", "HPST3202", 2);
180 corePowerSupply = new Pst3202Channel("ch1", "HPST3202B", 1);
181 padsPowerSupply = new Pst3202Channel("ch2", "HPST3202B", 2);
184 fatal(true, "Unrecognized station: "+cmdArgs.station);
186 corePowerSupply.setCurrent((float)1.7);
187 corePowerSupply.setVoltageWait((float)1.0);
189 padsPowerSupply.setCurrent((float)0.100);
190 padsPowerSupply.setVoltageWait((float)1.8);
192 coreVoltmeter = new HP34401A(station.coreVoltmeter);
193 voltmeterForCurrent = new HP34401A(station.currentVoltmenter);
197 private MarinaTest(String[] args) {
198 cmdArgs = new CmdArgs(args);
200 if (cmdArgs.mode==Mode.TEST_SILICON) doSilicon(); else doSim();
203 private void doSim() {
205 switch (cmdArgs.mode) {
206 case WHOLE_CHIP_SCHEMATIC_PARASITICS:
207 netListName = NET_LIST;
209 case WHOLE_CHIP_LAYOUT_PARASITICS:
210 netListName = "marina_pads_guts.spi";
213 fatal(true, "unrecognized CmdArgs.Mode");
216 model = cmdArgs.useVerilog
220 : new NanosimModel();
222 ((SimulationModel)model).setOptimizedDirectReadsWrites(true);
224 CYCLE_TIME_NS = cmdArgs.useVerilog ? (100*20) : 0.250;
226 //tester = ((SimulationModel)model).createJtagTester("TCK", "TMS", "TRSTb", "TDI", "TDO");
227 ChainControls ccs = new ChainControls();
228 JtagTester testerD, testerR, testerC;
229 testerD = ((SimulationModel)model).createJtagSubchainTester("sid[1:9]", null);
230 testerR = ((SimulationModel)model).createJtagSubchainTester("sir[1:9]", null);
231 testerC = ((SimulationModel)model).createJtagSubchainTester("sic[1:9]", null);
232 testerD.printInfo = testerR.printInfo = testerC.printInfo = false;
234 int khz = model instanceof VerilogModel ? 100000 : 1000000;
236 ccD = new ChainControl(SCAN_CHAIN_XML, testerD, 1.8f, khz);
237 ccR = new ChainControl(SCAN_CHAIN_XML, testerR, 1.8f, khz);
238 ccC = new ChainControl(SCAN_CHAIN_XML, testerC, 1.8f, khz);
239 ccD.noTestSeverity = ccR.noTestSeverity = ccC.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
241 PowerChannel pc = new ManualPowerChannel("pc", false);
243 ctD = new ChainTest(ccD, pc);
244 ctR = new ChainTest(ccR, pc);
245 ctC = new ChainTest(ccC, pc);
247 ccs.addChain(Marina.DATA_CHAIN, ccD);
248 ccs.addChain(Marina.REPORT_CHAIN, ccR);
249 ccs.addChain(Marina.CONTROL_CHAIN, ccC);
251 marina = new Marina(ccs, model, !cmdArgs.jtagShift, indenter);
253 if (model instanceof VerilogModel)
254 ((SimulationModel)model).start("verilog", "marina.v", VerilogModel.DUMPVARS, !cmdArgs.jtagShift);
255 else if (model instanceof HsimModel)
256 ((SimulationModel)model).start("hsim64", netListName, 0, !cmdArgs.jtagShift);
258 ((SimulationModel)model).start("nanosim -c cfg", netListName, 0, !cmdArgs.jtagShift);
261 ccC.shift(Marina.CONTROL_CHAIN, false, true);
263 doOneTest(cmdArgs.testNum);
265 ((SimulationModel)model).finish();
267 private void doSilicon() {
268 model = new SiliconChip();
269 String ip = cmdArgs.station.ipAddr;
270 JtagTester tester = new Netscan4(ip, cmdArgs.station.jtagChannel);
271 tester.printInfo = false;
273 ChainControl cc = new ChainControl("???", tester, 1.8f, khz);
274 cc.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
275 ChainControls ccs = new ChainControls();
276 ccs.addChain(Marina.DATA_CHAIN, cc);
277 ccs.addChain(Marina.REPORT_CHAIN, cc);
278 ccs.addChain(Marina.CONTROL_CHAIN, cc);
279 marina = new Marina(ccs, model, false, indenter);
280 PowerChannel pc = new ManualPowerChannel("pc", false);
281 ChainTest ct = new ChainTest(cc, pc);
282 ct.testAllChains("marina", Infrastructure.SEVERITY_WARNING);
283 doOneTest(cmdArgs.testNum);
284 setUpSuppliesAndMeters(cmdArgs.station);
287 /** In the absence of looping, the longest path through Infinity is 4 column delays */
288 private void waitUntilQuiescent() {
289 model.waitNS(4*COLUMN_LATENCY);
292 private double readCurrent() {
293 return voltmeterForCurrent.readVoltage() / cmdArgs.station.ammeterShuntResistance;
296 /** Generate List of BitVectors where Token=true, high 25 data bits
297 * are alternating ones and zeros, low 12 data bits increment from
298 * zero, and address is given by addr. */
299 private List<BitVector> makeIncrDataConstAdr(int num, int addr) {
300 List<BitVector> ans = new ArrayList<BitVector>();
301 BitVector dHi = new BitVector(25, "dataHi");
302 BitVector dLo = new BitVector(12, "dataLo");
303 BitVector t = new BitVector("1", "token");
304 BitVector a = new BitVector(14, "addr");
305 dHi.setFromLong(0x00aaaaa);
307 for (int i=0; i<num; i++) {
309 ans.add(dHi.cat(dLo).cat(t).cat(a));
314 private void stopToStop(ProperStopper s1, ProperStopper s2,
316 List<BitVector> din) {
317 prln("Begin stopToStop");
322 long ctrStart = ctr==null ? 0 : ctr.getCount();
325 waitUntilQuiescent();
327 List<BitVector> dout = s2.drainMany();
329 MarinaUtils.compareItemsOrdered(din, dout);
332 long ctrEnd = ctr.getCount();
333 long delta = ctrEnd - ctrStart;
334 long expect = din.size();
336 "counter delta wrong: expected delta: "+expect+
337 " counter before:"+ctrStart+" counter after:"+ctrEnd);
341 prln("End stopToStop");
343 /** Burst data from src to dst. gate is stopped while loading src. gate
344 * is then run to allow the burst to flow. */
345 private void stopToStopBurst(ProperStopper src, ProperStopper gate,
348 List<BitVector> din) {
349 prln("Begin stopToStopBurst test");
355 long ctrStart = ctr==null ? 0 : ctr.getCount();
358 waitUntilQuiescent();
360 // open the gate to start the burst
362 waitUntilQuiescent();
364 List<BitVector> dout = dst.drainMany();
366 MarinaUtils.compareItemsOrdered(din, dout);
369 long ctrEnd = ctr.getCount();
370 long delta = ctrEnd - ctrStart;
372 long expectA = din.size();
373 fatal(delta!=expectA,
374 "counter delta wrong: expected delta: "+expectA+
375 " counter before:"+ctrStart+" counter after:"+ctrEnd);
379 prln("End stopToStopBurst test");
382 private void stopToStopOne(ProperStopper s1, ProperStopper s2,
383 Counter ctr, int adr) {
384 prln("Begin stopToStopOne");
387 List<BitVector> din = makeIncrDataConstAdr(1, adr);
388 stopToStop(s1, s2, ctr, din);
391 prln("End stopToStopOne");
394 private void stopToStopThree(ProperStopper s1, ProperStopper s2,
395 Counter ctr, int adr) {
396 prln("Begin stopToStopOne");
399 List<BitVector> din = makeIncrDataConstAdr(3, adr);
400 stopToStop(s1, s2, ctr, din);
403 prln("End stopToStopOne");
406 private int indexOf(BitVector o, List<BitVector> dIn) {
407 for (int i=0; i<dIn.size(); i++) {
408 if (o.equals(dIn.get(i))) return i;
412 private String ringDump(List<BitVector> dIn, List<BitVector> dOut) {
413 StringBuffer sb = new StringBuffer();
414 sb.append(" ring dump: ");
415 for (BitVector o : dOut) {
416 sb.append(indexOf(o, dIn)+" ");
418 return sb.toString();
421 private int[][] makeIntArray2D(int a, int b) {
422 int[][] ans = new int[a][];
423 for (int i=0; i<a; i++) ans[i] = new int[b];
427 //=========================================================================
428 // Put top level tests here
430 private void testChains(Marina marina) {
431 prln("Testing control chain...");
432 ctC.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
434 ccC.shift(Marina.CONTROL_CHAIN, false, true);
436 prln("Testing data chain...");
437 ctD.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
439 //ccD.shift(Marina.DATA_CHAIN, false, true);
441 prln("Testing report chain...");
442 ctR.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
444 //ccR.shift(Marina.REPORT_CHAIN, false, true);
447 private void testProperStoppers(Marina marina) {
448 prln("Begin testProperStoppers");
451 for(ProperStopper ps : new ProperStopper[] { marina.data, marina.instrIn }) {
453 prln("testing " + (ps == marina.data ? "data" : "instruction") + " stopper");
456 prln("un-stopping stopper");
458 fatal( ps.getStopped(), "stopper should not have been stopped, but was");
460 prln("stopping stopper");
462 fatal( !ps.getStopped(), "stopper should have been stopped, but was not");
470 private void sendInstructions(Marina marina) {
471 prln("Begin sendInstructions");
474 List<BitVector> din = new ArrayList<BitVector>();
476 BitVector count = new BitVector(MarinaPacket.WORD_WIDTH,"count");
477 BitVector one = new BitVector(MarinaPacket.WORD_WIDTH, "one");
478 count.setFromLong(0);
480 for (int i=0; i<3; i++) {
482 count = count.add(one);
485 for(BitVector d : din)
486 marina.instrIn.fill(new MarinaPacket(d, false, MarinaPacket.null_path));
489 prln("End sendInstructions");
492 private void sendToken(Marina marina) {
493 prln("Begin sendToken");
496 //getCtrsFlags(marina);
498 int nbToks = marina.getNumTokens();
499 fatal(nbToks!=0, "Expected no tokens on initialization but got: "+nbToks+" tokens");
501 marina.instrIn.fill(setIlc(1));
502 marina.instrIn.fill(SEND_TOKEN);
503 nbToks = marina.getNumTokens();
504 fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
507 prln("End sendToken");
510 private void sendData(Marina marina) {
511 prln("Begin sendData");
514 edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
515 for(int i=0; i<bv.length(); i+=2) bv.set(i, false);
516 MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
518 marina.instrIn.fill(setIlc(1));
519 marina.instrIn.fill(SEND_DATA);
521 List<BitVector> dataItems = marina.data.drainMany();
522 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
524 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
525 fatal(mp.tokenhood, "Expected tokenhood=data, but got tokenhood=token");
528 prln("End sendData");
531 private void sendDataIlcInfinite(Marina marina) {
532 prln("Begin sendDataIlcInfinite");
535 marina.fillSouthProperStopper(new Instruction[] {
536 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
542 List<BitVector> dataItems = marina.data.drainMany(howmany);
543 fatal(dataItems.size()!=howmany,
544 "Expected an unending supply of data items to emerge but only got got: "+dataItems.size());
547 prln("End sendDataIlcInfinite");
550 private Instruction setOlc(int olc) {
551 return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, olc);
553 private Instruction setOlcIfZero(int olc) {
554 return new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter, olc);
556 private Instruction setIlc(int ilc) {
557 return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, ilc);
560 private void testFlagD(Marina marina) {
561 prln("Begin testFlagD");
564 List<BitVector> toks;
566 Predicate only_if_olc_zero = Predicate.FlagD;
567 Predicate only_if_olc_nonzero = Predicate.Default;
569 marina.instrIn.fill(setIlc(1));
571 for(int olc : new int[] { 1, 0 }) {
572 for(boolean predicate_olc_nonzero : new boolean[] { true, false }) {
573 prln("Attempting send data item with "+
575 "predicate olc"+(predicate_olc_nonzero?"!=0":"==0"));
578 marina.fillSouthProperStopper(new Instruction[] {
580 new Instruction.Move(dock,
581 predicate_olc_nonzero // predicate
582 ? only_if_olc_nonzero
585 false, // torpedoable
595 expectNorthFifoExactly((predicate_olc_nonzero == (olc!=0)) ? 1 : 0);
597 for(int i=0; i<olc; i++)
598 marina.instrIn.fill(DEC);
604 prln("End testFlagD");
607 private void testPredicationOnAB(Marina marina) {
608 prln("Begin testPredicationOnAB");
611 List<BitVector> dItems;
613 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 1));
614 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
616 for(boolean flag_a : new boolean[] { false, true }) {
617 for(boolean flag_b : new boolean[] { false, true }) {
618 prln("Setting flags, a="+flag_a+" b="+flag_b);
619 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
621 ? Instruction.Set.FlagFunction.ONE
622 : Instruction.Set.FlagFunction.ZERO,
624 ? Instruction.Set.FlagFunction.ONE
625 : Instruction.Set.FlagFunction.ZERO
627 getCtrsFlags(marina);
630 for(Predicate predicate : new Predicate[] {
638 prln("Attempting send data with a="+flag_a+", b="+flag_b+", predicate="+predicate);
640 marina.instrIn.fill(new Instruction.Move(dock,
641 predicate, // predicate
642 false, // torpedoable
652 dItems = marina.data.drainMany();
653 int expected = predicate.evaluate(flag_a, flag_b, false, false) ? 1 : 0;
654 fatal(dItems.size()!=expected, "Expected "+expected+" data items to emerge but got: "+
655 dItems.size()+" items(s)");
661 prln("End testPredicationOnAB");
666 private void getCtrsFlags(Marina marina) {
667 prln("begin getCtrsFlags");
670 int olc = marina.getOLC();
673 Ilc ilc = marina.getILC();
674 prln("ILC.done=="+ilc.getDone()+
675 " ILC.infinity=="+ilc.getInfinity()+
676 " ILC.count=="+ilc.getCount());
677 prln("flagA=="+marina.getFlagA());
678 prln("flagB=="+marina.getFlagB());
680 prln("end getCtrsFlags");
683 private void walkOneOLC(Marina marina) {
684 prln("Begin walkOneOLC");
686 for (int i=-1; i<=5; i++) {
688 if (marina.kesselsCounter) {
689 // master clear on each iteration; otherwise we'd need to "run down" the olc
690 marina.masterClear();
691 marina.enableInstructionSend(true);
694 int inOlc = i==-1 ? 0 : (1<<i);
695 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc));
697 model.waitNS(128 * CYCLE_TIME_NS);
699 int outOlc = marina.getOLC();
701 fatal(outOlc!=inOlc, "walkOneOLC: got="+outOlc+" expected="+inOlc);
702 prln("walkOneOLC: "+inOlc+" checks out");
705 prln("End walkOneOLC");
707 private void walkOneILC(Marina marina) {
708 prln("Begin walkOneILC");
710 for (int i=0; i<6; i++) {
711 // Mask off the "zero" bit position
713 prln("inIlc="+inIlc);
714 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, inIlc));
715 Ilc ilc = marina.getILC();
716 int outIlc = ilc.getCount();
717 fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+inIlc);
718 fatal(ilc.getInfinity(), "bad Infinity bit: true");
720 prln("Now test the infinity bit");
721 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
722 Ilc ilc = marina.getILC();
723 fatal(!ilc.getInfinity(), "bad Infinity bit: false");
725 prln("End walkOneILC");
727 private void countIlc(Marina marina) {
728 final int maxIlc = 63;
729 prln("Begin countIlc");
732 marina.instrIn.fill(new
733 Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, maxIlc));
735 int ilc = marina.getILC().getCount();
736 fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc);
738 prln("execute a move instruction that does nothing except decrement the ILC to zero");
740 new Instruction.Move(dock,
741 Predicate.IgnoreFlagD, // predicate
742 false, // torpedoable
752 // wait for ILC to count from 63 to 0
753 model.waitNS(128 * CYCLE_TIME_NS);
754 //model.waitNS(10000);
756 prln("Check that ILC==0");
757 ilc = marina.getILC().getCount();
758 fatal(ilc!=0, "bad ILC count: "+ilc+" expected: "+0);
761 prln("End countIlc");
763 // Note: countOlc takes 44 minutes to run on nanosim
764 private void countOlc(Marina marina) {
766 prln("Begin countOlc");
769 marina.instrIn.fill(setOlc(maxOlc));
771 for (int i=maxOlc; i>=0; i--) {
772 model.waitNS(128 * CYCLE_TIME_NS);
773 prln("OLC should be: "+i);
774 int olc = marina.getOLC();
775 fatal(olc!=i, "bad OLC: "+olc+" expected: "+i);
776 marina.instrIn.fill(new
777 Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, SetSource.Decrement));
781 prln("End countOlc");
784 private void saturateInstructionFifo(Marina marina, Instruction instruction, int quantity, boolean expect_it_to_jam_up) {
785 prln("Inserting "+quantity+" copies of \"" + instruction + "\"");
788 for(i=0; i<quantity; i++) {
789 prln("Inserting instruction " + (i+1) +"/"+ quantity);
790 marina.instrIn.fill(instruction);
791 boolean jammed = (marina.instrIn.getFillStateWire()==MarinaUtils.StateWireState.FULL);
792 if (jammed && expect_it_to_jam_up) {
793 prln("Stopper remained full after inserting instruction; this was expected; we are happy.");
797 fatal(jammed, "Instruction stopper did not drain after inserting " + (i+1) + " instructions; not good!");
799 fatal(expect_it_to_jam_up, "Expected instruction stopper to jam up, but it did not");
801 prln("Successfully inserted " + i + " instructions");
804 private static MarinaPath null_path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(),
805 MarinaUtils.sunToBerk(MarinaPacket.null_path));
807 private static final Instruction DEC =
808 new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter, SetSource.Decrement);
810 private static final Instruction FLAG_NOP =
811 new Instruction.Set(dock, Predicate.IgnoreFlagD,
812 CLEAR_FLAG.add(Predicate.FlagA),
813 CLEAR_FLAG.add(Predicate.FlagB));
815 private static final Instruction NOP =
816 new Instruction.Move(dock,
817 Predicate.IgnoreFlagD, /* predicate */
818 false, /* torpedoable */
822 false, /* latchData */
823 false, /* latchPath */
828 private static final Instruction SEND_DATA =
829 new Instruction.Move(dock,
830 Predicate.IgnoreFlagD, /* predicate */
831 false, /* torpedoable */
832 null_path, /* path */
835 false, /* latchData */
836 false, /* latchPath */
841 private static final Instruction SEND_DATA_IF_D_NOT_SET =
842 new Instruction.Move(dock,
843 Predicate.Default, /* predicate */
844 false, /* torpedoable */
845 null_path, /* path */
848 false, /* latchData */
849 false, /* latchPath */
854 private static final Instruction TORPEDOABLE_RECV_DATA =
855 new Instruction.Move(dock,
856 Predicate.IgnoreFlagD, /* predicate */
857 true, /* torpedoable */
861 true, /* latchData */
862 false, /* latchPath */
867 private static final Instruction RECV_DATA =
868 new Instruction.Move(dock,
869 Predicate.IgnoreFlagD, /* predicate */
870 false, /* torpedoable */
874 true, /* latchData */
875 false, /* latchPath */
880 private static final Instruction SEND_TOKEN =
881 new Instruction.Move(dock,
882 Predicate.IgnoreFlagD, /* predicate */
883 false, /* torpedoable */
884 null_path, /* path */
887 false, /* latchData */
888 false, /* latchPath */
893 private static final Instruction RECV_TOKEN =
894 new Instruction.Move(dock,
895 Predicate.IgnoreFlagD, /* predicate */
896 false, /* torpedoable */
900 false, /* latchData */
901 false, /* latchPath */
907 private void expectNorthFifoNoMoreThan(int num) {
908 model.waitNS(128 * CYCLE_TIME_NS);
909 List<BitVector> dataItems = marina.data.drainMany(num+1);
910 fatal(dataItems.size()>num,
911 "Expected no more than "+num+
912 " data items to emerge but got at least: "+dataItems.size());
914 private void expectNorthFifoExactly(int num) {
915 model.waitNS(128 * CYCLE_TIME_NS);
916 List<BitVector> dataItems = marina.data.drainMany(num+1);
917 fatal(dataItems.size()!=num,
918 "Expected exactly "+num+
919 " data items to emerge but got at least: "+dataItems.size());
921 private void expectTokensNoMoreThan(int num) {
922 int x = marina.getNumTokens();
923 List<BitVector> dataItems = marina.data.drainMany(num+1);
925 "Expected no more than "+num+
926 " data items to emerge but got at least: "+x);
928 private void expectTokensExactly(int num) {
929 int x = marina.getNumTokens();
931 "Expected exactly "+num+
932 " data items to emerge but got at least: "+x);
935 private void testFlagDRecomputationTime(Marina marina) {
936 marina.instrIn.fill(setIlc(1));
937 marina.fillSouthProperStopper(new Instruction[] {
939 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
940 SEND_DATA_IF_D_NOT_SET
942 marina.fillNorthProperStopper();
943 expectNorthFifoNoMoreThan(0);
945 marina.fillSouthProperStopper(new Instruction[] {
947 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
948 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
949 SEND_DATA_IF_D_NOT_SET
951 marina.fillNorthProperStopper();
952 expectNorthFifoNoMoreThan(0);
954 marina.fillSouthProperStopper(new Instruction[] {
956 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
957 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
958 SEND_DATA_IF_D_NOT_SET
960 marina.fillNorthProperStopper();
961 expectNorthFifoExactly(1);
962 marina.instrIn.fill(DEC);
964 marina.fillSouthProperStopper(new Instruction[] {
966 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
967 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
968 SEND_DATA_IF_D_NOT_SET
970 marina.fillNorthProperStopper();
971 expectNorthFifoExactly(1);
974 private void testTailWaitsForHead(Marina marina) {
975 marina.instrIn.fill(setIlc(1));
976 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
978 marina.enableInstructionSend(false);
979 marina.enableInstructionRecirculate(true);
981 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
982 marina.instrIn.fill(new Instruction.Head(dock));
983 marina.instrIn.fill(SEND_DATA);
984 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
985 marina.instrIn.fill(SEND_TOKEN);
986 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
987 marina.instrIn.fill(new Instruction.Tail(dock));
988 marina.instrIn.fillTorpedo();
990 marina.enableInstructionRecirculate(false);
991 marina.enableInstructionSend(true);
992 marina.instrIn.run();
994 expectNorthFifoNoMoreThan(0);
995 prln("inserting into north proper stopper");
996 marina.fillNorthProperStopper();
997 expectNorthFifoExactly(1);
998 int nbToks = marina.getNumTokens();
999 fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
1003 marina.instrIn.fill(setIlc(1));
1004 marina.instrIn.fill(setOlc(1));
1006 // this makes the head wait for the torpedo
1007 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
1009 // the head should wait for the tail
1010 marina.instrIn.fill(new Instruction.Head(dock));
1011 marina.instrIn.fill(NOP);
1012 marina.instrIn.fill(SEND_DATA);
1013 marina.instrIn.fill(RECV_DATA);
1015 expectNorthFifoNoMoreThan(0);
1017 marina.instrIn.fillTorpedo();
1018 expectNorthFifoNoMoreThan(0);
1020 marina.instrIn.fill(new Instruction.Tail(dock));
1021 expectNorthFifoExactly(1);
1024 private void testTailWithoutHead(Marina marina) {
1025 marina.instrIn.fill(setIlc(1));
1026 marina.fillSouthProperStopper(new Instruction[] {
1027 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1028 new Instruction.Tail(dock),
1031 List<BitVector> dataItems = marina.data.drainMany(1);
1032 fatal(dataItems.size()!=0, "Expected exactly no data items to emerge but got at least: "+dataItems.size());
1035 private void testHeadWaitsForTail(Marina marina) {
1036 List<BitVector> dataItems;
1038 prln("Begin testHeadWaitsForTail");
1041 marina.instrIn.fill(setIlc(1));
1042 marina.fillSouthProperStopper(new Instruction[] {
1043 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1044 new Instruction.Head(dock),
1045 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1048 dataItems = marina.data.drainMany(1);
1049 fatal(dataItems.size()!=0, "Expected exactly no data items to emerge but got at least: "+dataItems.size());
1050 marina.instrIn.fill(new Instruction.Tail(dock));
1052 BitVector bv = marina.data.drain();
1053 fatal(bv==null, "Expected at least one data item to emerge but got none");
1056 prln("End testHeadWaitsForTail");
1059 private void testNonTorpedoableMoveDoesNotResetDFlag(Marina marina) {
1060 marina.instrIn.fill(setIlc(1));
1061 marina.fillSouthProperStopper(new Instruction[] {
1062 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,63),
1063 new Instruction.Move(dock,
1064 Predicate.IgnoreFlagD, // predicate
1065 true, // torpedoable
1074 new Instruction.Move(dock,
1075 Predicate.FlagD, // predicate
1076 false, // torpedoable
1086 marina.instrIn.fillTorpedo();
1087 expectNorthFifoExactly(1);
1088 marina.fillSouthProperStopper(new Instruction[] {
1089 new Instruction.Move(dock,
1090 Predicate.Default, // predicate
1091 false, // torpedoable
1101 expectNorthFifoNoMoreThan(0);
1104 private void testAbort(Marina marina) {
1106 marina.instrIn.fill(setIlc(1));
1107 marina.fillSouthProperStopper(new Instruction[] {
1108 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,1),
1109 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
1110 SEND_DATA_IF_D_NOT_SET,
1111 new Instruction.Head(dock),
1112 SEND_DATA_IF_D_NOT_SET,
1113 new Instruction.Set(dock,Predicate.Default,SetDest.DataLatch,2),
1114 new Instruction.Abort(dock, Predicate.FlagD),
1115 new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter,SetSource.Decrement),
1116 new Instruction.Tail(dock),
1119 for(int i=0; i<4; i++) {
1122 model.waitNS(128 * CYCLE_TIME_NS);
1123 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1124 fatal(bv==null, "no data item found");
1125 prln("got " + bv.toLong());
1126 fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1128 model.waitNS(128 * CYCLE_TIME_NS);
1129 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1130 fatal(bv==null, "no data item found");
1131 prln("got " + bv.toLong());
1132 fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1134 model.waitNS(128 * CYCLE_TIME_NS);
1135 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1136 fatal(bv==null, "no data item found");
1137 prln("got " + bv.toLong());
1138 fatal(bv.toLong()!=2, "expected 2, got " + bv.toLong());
1143 private void testAbortOutsideOfLoop(Marina marina) {
1144 marina.instrIn.fill(setIlc(1));
1145 marina.fillSouthProperStopper(new Instruction[] {
1146 // ensure that an abort doesn't cause problems if no loop is in progress
1147 new Instruction.Abort(dock, Predicate.IgnoreFlagD),
1150 expectNorthFifoExactly(1);
1153 private void testFlagAB(Marina marina) {
1154 prln("Begin testFlagAB");
1157 Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1158 Instruction.Set.FlagFunction one = zero;
1161 // we should be able to use any pair of FlagX+NotFlagX,
1162 // but we toss them all in to maximize the chances of the
1163 // test passing (later we will try the individual
1164 // combinations to maximize the chances of failure).
1165 one = one.add(Predicate.FlagA);
1166 one = one.add(Predicate.NotFlagA);
1167 one = one.add(Predicate.FlagB);
1168 one = one.add(Predicate.NotFlagB);
1169 one = one.add(Predicate.FlagC);
1170 one = one.add(Predicate.NotFlagC);
1172 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
1173 for(boolean fast : new boolean[] { true, false }) {
1174 // clear the flags to a known state, then check both 0->1 and 1->0 transitions
1175 for(boolean b : new boolean[] { false, true, false }) {
1176 prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
1177 prln((b?"Setting":"Clearing")+" flags");
1179 Instruction inst = new Instruction.Set(dock,Predicate.IgnoreFlagD,
1184 marina.fillSouthProperStopper(new Instruction[] {
1189 model.waitNS(64 * CYCLE_TIME_NS);
1190 marina.fillNorthProperStopper();
1192 marina.instrIn.fill(inst);
1195 fatal(marina.getFlagA()!=b,
1196 "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set"));
1197 fatal(marina.getFlagB()!=b,
1198 "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set"));
1203 prln("End testFlagAB");
1207 * WARNING: this is a very, very, very long test case -- it goes
1208 * through 216 iterations.
1210 private void testFlagTruthTable(Marina marina) {
1211 prln("Begin testFlagTruthTable");
1214 marina.instrIn.fill(setIlc(1));
1215 Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1216 Instruction.Set.FlagFunction one = zero.add(Predicate.FlagA).add(Predicate.NotFlagA);
1218 for(Predicate a_input : new Predicate[] { null, Predicate.FlagA, Predicate.NotFlagA })
1219 for(Predicate b_input : new Predicate[] { null, Predicate.FlagB, Predicate.NotFlagB })
1220 for(Predicate c_input : new Predicate[] { null, Predicate.FlagC, Predicate.NotFlagC })
1221 for(boolean a_state : new boolean[] { false, true })
1222 for(boolean b_state : new boolean[] { false, true })
1223 for(boolean c_state : new boolean[] { false, true }) {
1224 for(boolean which : new boolean[] { false, true }) {
1226 prln("before instruction: a="+a_state+", b="+b_state+", c="+c_state);
1227 // set A,B flags to a_state and b_state
1228 marina.instrIn.fill(new
1229 Instruction.Set(dock,Predicate.IgnoreFlagD,
1230 a_state ? one : zero,
1231 b_state ? one : zero
1234 // set C flag to c_state
1235 BitVector data = new BitVector(37, "empty");
1236 BitVector addr = new BitVector(14, "empty");
1237 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1238 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1239 addr.set(Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE, c_state);
1240 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1241 marina.instrIn.fill(RECV_DATA);
1243 Instruction.Set.FlagFunction func = zero;
1244 if (a_input!=null) func = func.add(a_input);
1245 if (b_input!=null) func = func.add(b_input);
1246 if (c_input!=null) func = func.add(c_input);
1248 Instruction inst = new
1249 Instruction.Set(dock,Predicate.IgnoreFlagD,
1250 !which ? func : zero.add(Predicate.FlagA),
1251 which ? func : zero.add(Predicate.FlagB)
1254 marina.instrIn.fill(inst);
1256 boolean expected_a = !which ? func.evaluate(a_state, b_state, c_state, false) : a_state;
1257 boolean expected_b = which ? func.evaluate(a_state, b_state, c_state, false) : b_state;
1258 fatal(expected_a != marina.getFlagA(),
1259 "expected A="+expected_a+", but got "+marina.getFlagA());
1260 fatal(expected_b != marina.getFlagB(),
1261 "expected B="+expected_b+", but got "+marina.getFlagB());
1265 prln("End testFlagTruthTable");
1268 private void recvData(Marina marina) {
1269 prln("Begin recvData");
1272 marina.instrIn.fill(setIlc(1));
1273 marina.fillSouthProperStopper(new Instruction[] {
1274 new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1275 new Instruction.Move(dock,
1276 Predicate.IgnoreFlagD, // predicate
1277 false, // torpedoable
1286 new Instruction.Set(dock,Predicate.IgnoreFlagD, SET_FLAG, SET_FLAG),
1288 model.waitNS(64 * CYCLE_TIME_NS);
1290 prln("checking to confirm that A flag is cleared");
1291 fatal(marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1293 prln("inserting data item in north fifo ring");
1294 BitVector data = new BitVector(37, "empty");
1295 BitVector addr = new BitVector(14, "empty");
1296 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1297 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1298 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1299 model.waitNS(64 * CYCLE_TIME_NS);
1301 prln("checking to see if A flag got set");
1302 fatal(!marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1305 prln("End recvData");
1309 private void testRecvAndSendWalkingOne(Marina marina) {
1310 prln("Begin testRecvAndSendWalkingOne");
1313 marina.instrIn.fill(setIlc(1));
1315 List<BitVector> dataItems;
1316 for(int bit=0; bit<37; bit++) {
1318 BitVector data = new BitVector(37, "empty");
1319 BitVector addr = new BitVector(14, "empty");
1320 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1321 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1322 data.set(bit, true);
1323 prln("testing with bit pattern " + data);
1325 prln("inserting data item into north fifo ring");
1326 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1328 prln("stopping the north proper stopper");
1331 dataItems = marina.data.drainMany(1);
1332 fatal(dataItems.size()!=0,
1333 "found a data item waiting in the north proper stopper, but should not have");
1335 marina.instrIn.fill(new Instruction.Move(dock,
1336 Predicate.IgnoreFlagD, // predicate
1337 false, // torpedoable
1347 dataItems = marina.data.drainMany(2);
1348 fatal(dataItems.size()!=1,
1349 "found "+dataItems.size()+" data items in north fifo; expected one");
1350 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1351 fatalIfBitVectorsDoNotMatch(mp.data, data);
1355 prln("End testRecvAndSendWalkingOne");
1360 private void setOlcFromDataLatch(Marina marina) {
1361 prln("Begin setOlcFromDataLatch");
1364 marina.instrIn.fill(setIlc(1));
1366 // walk a bit from 0 to 5
1367 for(int bit=0; bit<6; bit++) {
1368 prln("inserting data item in north fifo ring");
1369 BitVector data = new BitVector(37, "empty");
1370 BitVector addr = new BitVector(14, "empty");
1371 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1372 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1373 data.set(bit, true);
1374 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1376 marina.fillSouthProperStopper(new Instruction[] {
1378 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.DataLatch),
1379 // FIXME: try a load literal right here to be evil
1382 model.waitNS(CYCLE_TIME_NS * 64);
1384 int olc = marina.getOLC();
1385 fatal(olc != (1<<bit), "expected olc to be " + (1<<bit) + ", but got " + olc);
1387 if (marina.kesselsCounter) {
1388 // master clear on each iteration; otherwise we'd need to "run down" the olc
1389 marina.masterClear();
1390 marina.enableInstructionSend(true);
1395 prln("End setOlcFromDataLatch");
1398 private void setIlcFromDataLatch(Marina marina) {
1399 prln("Begin setIlcFromDataLatch");
1402 marina.instrIn.fill(setIlc(1));
1404 // walk a bit from 0 to 5
1405 for(int bit=5; bit>=0; bit--) {
1406 prln("inserting data item in north fifo ring");
1407 BitVector data = new BitVector(37, "empty");
1408 BitVector addr = new BitVector(14, "empty");
1409 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1410 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1411 data.set(bit, true);
1412 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1414 marina.fillSouthProperStopper(new Instruction[] {
1415 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1417 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.DataLatch),
1419 model.waitNS(CYCLE_TIME_NS * 64);
1421 int ilc = marina.getILC().getCount();
1422 fatal(ilc != (1<<bit), "expected ilc to be " + (1<<bit) + ", but got " + ilc);
1426 prln("End setIlcFromDataLatch");
1429 private void testSendAndRecvToken(Marina marina) {
1430 prln("Begin testSendAndRecvToken");
1433 marina.instrIn.fill(setIlc(1));
1434 marina.fillSouthProperStopper(new Instruction[] {
1439 expectNorthFifoExactly(1);
1442 prln("End testSendAndRecvToken");
1445 private void testSignExtendedLiteral(Marina marina) {
1446 prln("Begin testSignExtendedLiteral");
1449 marina.instrIn.fill(setIlc(1));
1450 for(long val : new long[] { (-1L << 14), -1, 0, 1 }) {
1452 marina.fillSouthProperStopper(new Instruction[] {
1453 new Instruction.Set(dock,Predicate.IgnoreFlagD,
1454 Instruction.Set.SetDest.DataLatch,
1458 model.waitNS(CYCLE_TIME_NS * 64);
1460 List<BitVector> dataItems = marina.data.drainMany(3);
1461 fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1463 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1464 BitVector bv = mp.data;
1465 prln("got back " + mp);
1467 boolean mismatch = false;
1469 for(int i=0; i<37; i++) {
1470 if (bv.get(i) != ( (val & (1L << i)) != 0 )) {
1475 fatal(mismatch, "data read back did not match inserted literal; mismatch on bits " + err);
1479 prln("End testSignExtendedLiteral");
1482 private void testShiftedLiteral(Marina marina) {
1483 prln("Begin testShiftedLiteral");
1486 marina.instrIn.fill(setIlc(1));
1487 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
1488 Instruction.Set.SetDest.DataLatch,
1491 BitVector dreg = new BitVector(37, "what we think is in the d-register");
1492 for(int i=0; i<37; i++) dreg.set(i, false);
1494 for(long val : new long[] { -1, 0, 1, (-1L << 18) }) {
1496 edu.berkeley.fleet.api.BitVector immediate =
1497 new edu.berkeley.fleet.api.BitVector(19);
1498 for(int i=0; i<immediate.length(); i++)
1499 immediate.set(i, (val & (1L << i)) != 0);
1501 // shift over 19 LSB's towards MSB
1502 for(int i=0; i<19; i++)
1503 if (i+19 <= 36) dreg.set(i+19, dreg.get(i));
1504 for(int i=0; i<19; i++)
1505 dreg.set(i, immediate.get(i));
1507 marina.fillSouthProperStopper(new Instruction[] {
1508 new Instruction.Shift(dock,Predicate.IgnoreFlagD,immediate),
1512 model.waitNS(CYCLE_TIME_NS * 64);
1513 List<BitVector> dataItems = marina.data.drainMany(3);
1514 fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1516 BitVector bv = new MarinaPacket(dataItems.get(0)).data;
1517 fatal(!bv.equals(dreg), "data read back did not match inserted literal.\n" +
1518 "got: "+bv.bitReverse().getState()+"\n"+
1519 "expected:"+dreg.bitReverse().getState());
1523 prln("End testShiftedLiteral");
1526 private void testFlagC(Marina marina) {
1527 prln("Begin testFlagC");
1535 // Dc=1 => sigS is copied into C-flag
1536 // Dc=0 => sigA is copied into C-flag
1538 marina.instrIn.fill(setIlc(1));
1539 for(boolean dc : new boolean[] { false, true }) {
1540 for(boolean c_flag : new boolean[] { true, false, true }) {
1543 prln("****** checking case where dc="+dc+", cflag="+c_flag);
1544 BitVector data = new BitVector(37, "empty");
1545 BitVector addr = new BitVector(14, "empty");
1546 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1547 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1550 ? Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE
1551 : Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO;
1552 prln("setting addr["+whichbit+"] to "+(c_flag?"1":"0"));
1553 addr.set(whichbit, c_flag);
1555 prln("... and filling north fifo proper stopper");
1556 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1558 prln("clearing flags");
1559 prln("executing recv data with Dc="+dc);
1560 prln("copying c-flag to a-flag");
1561 marina.fillSouthProperStopper(new Instruction[] {
1562 new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1563 new Instruction.Move(dock,
1564 Predicate.IgnoreFlagD, /* predicate */
1565 true, /* torpedoable */
1567 false, /* tokenIn */
1570 false, /* latchPath */
1571 false, /* dataOut */
1572 false /* tokenOut */
1575 new Instruction.Set(dock,Predicate.IgnoreFlagD,
1576 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagC),
1581 model.waitNS(CYCLE_TIME_NS * 64);
1583 prln("checking to confirm that A flag is " + c_flag);
1584 fatal(marina.getFlagA()!=c_flag, "bad A flag: "+marina.getFlagA());
1588 prln("End testFlagC");
1591 private void sendDataWithPath(Marina marina) {
1592 prln("Begin sendDataWithPath");
1595 edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
1596 marina.instrIn.fill(setIlc(1));
1598 // alternating ones and zeroes
1599 for(int i=0; i<bv.length(); i+=2)
1601 // and then ones in the lower four bits so it's not symmetric
1602 for(int i=0; i<4; i++)
1605 MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
1607 marina.fillSouthProperStopper(new Instruction[] {
1608 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1609 new Instruction.Move(dock,
1610 Predicate.IgnoreFlagD, /* predicate */
1611 false, /* torpedoable */
1613 false, /* tokenIn */
1615 false, /* latchData */
1616 false, /* latchPath */
1618 false /* tokenOut */
1622 List<BitVector> dataItems;
1625 dataItems = marina.data.drainMany();
1626 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1627 mp = new MarinaPacket(dataItems.get(0));
1629 // the 14th bit of the outbound address cannot be set by the
1630 // ship, so we don't care about it
1631 fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1633 prln("send data with no change to path");
1634 marina.instrIn.fill(new Instruction.Move(dock,
1635 Predicate.IgnoreFlagD, /* predicate */
1636 false, /* torpedoable */
1638 false, /* tokenIn */
1640 false, /* latchData */
1641 false, /* latchPath */
1643 false /* tokenOut */
1646 dataItems = marina.data.drainMany();
1647 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1648 mp = new MarinaPacket(dataItems.get(0));
1650 // the 14th bit of the outbound address cannot be set by the
1651 // ship, so we don't care about it
1652 fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1655 prln("End sendDataWithPath");
1658 private void recvPath(Marina marina) {
1659 prln("Begin recvPath");
1662 marina.instrIn.fill(setIlc(1));
1663 for(int bit=0; bit<11; bit++) {
1664 BitVector packet_data = new BitVector(37, "inbound data item");
1665 for(int i=0; i<37; i++) packet_data.set(i, false);
1666 packet_data.set(27+bit, true);
1667 BitVector packet_path = new BitVector(14, "inbound data item");
1668 for(int i=0; i<14; i++) packet_path.set(i, false);
1670 marina.fillNorthProperStopper(new MarinaPacket(packet_data, false, packet_path));
1672 prln("recv path, send data (using recv'd path)");
1673 marina.instrIn.fill(new Instruction.Move(dock,
1674 Predicate.IgnoreFlagD, /* predicate */
1675 false, /* torpedoable */
1677 false, /* tokenIn */
1679 true, /* latchData */
1680 true, /* latchPath */
1682 false /* tokenOut */
1685 List<BitVector> dataItems = marina.data.drainMany();
1686 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1687 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1689 fatalIfBitVectorsDoNotMatch(packet_data.get(25,11), mp.path.get(0,11));
1690 fatalIfBitVectorsDoNotMatch(packet_data, mp.data);
1694 prln("End recvPath");
1697 private void testILC(Marina marina) {
1698 prln("Begin testILC");
1701 for(int bit=0; bit<6; bit++) {
1702 int ilc = bit<0 ? 0 : (1<<bit);
1703 marina.fillSouthProperStopper(new Instruction[] {
1704 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,ilc),
1707 List<BitVector> dataItems = marina.data.drainMany();
1708 fatal(dataItems.size()!=ilc, "Expected "+ilc+" data item(s) to emerge but got: "+dataItems.size()+" data items");
1712 prln("End testILC");
1715 private void testILCZero(Marina marina) {
1717 marina.fillSouthProperStopper(new Instruction[] {
1718 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,0),
1722 expectNorthFifoNoMoreThan(0);
1723 expectTokensExactly(1);
1727 private void sendTorpedo(Marina marina) {
1728 prln("Begin sendTorpedo");
1730 marina.instrIn.fill(setIlc(1));
1731 marina.instrIn.fill(setOlc(63));
1734 model.waitNS(128 * CYCLE_TIME_NS);
1735 olc = marina.getOLC();
1736 fatal(olc!=63, "bad OLC: "+olc+" expected: 63");
1738 marina.instrIn.fill(new
1739 Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
1740 fatal(marina.getFlagA(), "bad A flag: true");
1741 fatal(marina.getFlagB(), "bad B flag: true");
1743 prln("execute a move instruction that does nothing but loops until torpedo arrives");
1744 prln("A=1, B=B This instruction should not execute because D-flag is set");
1745 prln("Set A=A, B=1 This instruction should execute because D-flag is set");
1747 model.waitNS(128 * CYCLE_TIME_NS);
1748 prln("infoz: olc="+marina.getOLC());
1750 marina.fillSouthProperStopper(new Instruction[] {
1751 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity),
1752 new Instruction.Move(dock,
1753 Predicate.IgnoreFlagD, // predicate
1754 true, // torpedoable
1763 new Instruction.Set(dock,Predicate.Default,
1765 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB)
1767 new Instruction.Set(dock, Predicate.FlagD,
1768 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA),
1773 model.waitNS(128 * CYCLE_TIME_NS);
1774 prln("infoz: olc="+marina.getOLC());
1776 prln("send torpedo. This should clear the OLC");
1777 marina.instrIn.fillTorpedo();
1778 model.waitNS(128 * CYCLE_TIME_NS);
1780 model.waitNS(128 * CYCLE_TIME_NS);
1781 prln("infoz: olc="+marina.getOLC());
1783 prln("A should remain false, B should be true");
1784 fatal(marina.getFlagA(), "bad A flag: true");
1785 fatal(!marina.getFlagB(), "bad B flag: false");
1787 model.waitNS(128 * CYCLE_TIME_NS);
1788 prln("infoz: olc="+marina.getOLC());
1790 prln("Reload OLC after torpedo, clears D-flag");
1791 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
1793 // FIXME: find another way to test this
1794 model.waitNS(128 * CYCLE_TIME_NS);
1795 olc = marina.getOLC();
1796 fatal(olc!=63, "bad OLC: "+olc+" expected: 63");
1798 prln("Set A=1, B=1 This instruction should execute because OLC!=0");
1799 marina.instrIn.fill(new
1800 Instruction.Set(dock,Predicate.Default, SET_FLAG, SET_FLAG));
1802 prln("A and B should be true");
1803 fatal(!marina.getFlagA(), "bad A flag: false");
1804 fatal(!marina.getFlagB(), "bad B flag: false");
1807 prln("End sendTorpedo");
1810 private void testTorpedoOnAnInfinite(Marina marina) {
1811 prln("Begin testTorpedoOnAnInfinite");
1814 List<BitVector> dataItems;
1816 marina.instrIn.fill(setIlc(1));
1817 for(boolean torpedoable : new boolean[] { true, false }) {
1819 marina.fillSouthProperStopper(new Instruction[] {
1820 new Instruction.Move(dock,
1821 Predicate.IgnoreFlagD, // predicate
1822 false, // torpedoable
1831 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
1832 new Instruction.Move(dock,
1833 Predicate.IgnoreFlagD, // predicate
1834 torpedoable, // torpedoable
1843 // FIXME: this probably should be removed, unless Ivan doesn't want to change the behavior
1844 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1849 // expect nothing to come out, because the NOP is executing
1850 dataItems = marina.data.drainMany(2);
1851 fatal(dataItems.size()!=0, "Expected no data item(s) to emerge but got at least: "+dataItems.size()+" data items");
1853 marina.instrIn.fillTorpedo();
1855 int expected = torpedoable?1:0;
1856 dataItems = marina.data.drainMany(2);
1857 fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
1859 fatal(!marina.getILC().getDone(), "Expected ilc=done, but got "+marina.getILC());
1863 prln("End testTorpedoOnAnInfinite");
1866 private void testOlcDecrementAtHighSpeed(Marina marina) {
1867 prln("Begin testOlcDecrementAtHighSpeed");
1870 List<BitVector> dataItems;
1872 // Each element of the following pair of arrays is one "test".
1873 // The OLC will be loaded with olcs[i] and then decremented
1874 // decr_amounts[i] times; after that has happened the zeroness
1875 // of the OLC will be checked by executing a MOVE with
1876 // [olc!=0] as the predicate.
1878 int[] olcs = new int[] { 3, 3, 3, 10, 41 };
1879 int[] decr_amounts = new int[] { 2, 3, 4, 9, 9 };
1881 for(int which=0; which<olcs.length; which++) {
1882 int olc = olcs[which];
1883 int decr_amount = decr_amounts[which];
1885 prln("inserting set olc="+olc);
1886 prln("inserting set ilc=1");
1887 marina.fillSouthProperStopper(new Instruction[] {
1888 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1889 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,olc),
1892 // commenting the following four lines causes this test to pass
1894 prln("inserting: "+decr_amount+" olc-- instructions");
1895 prln("inserting: [!d] send data");
1896 Instruction[] instructions = new Instruction[decr_amount+1];
1897 for(int i=0; i<decr_amount; i++)
1899 new Instruction.Set(dock,
1901 SetDest.OuterLoopCounter,
1902 SetSource.Decrement);
1903 instructions[instructions.length-1] =
1904 new Instruction.Move(dock,
1905 Predicate.Default, // predicate
1906 false, // torpedoable
1915 marina.fillSouthProperStopper(instructions);
1916 model.waitNS(64 * CYCLE_TIME_NS);
1918 int expected = decr_amount>=olc ? 0 : 1;
1919 dataItems = marina.data.drainMany(2);
1920 fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
1922 if (marina.kesselsCounter) {
1923 // master clear on each iteration; otherwise we'd need to "run down" the olc
1924 marina.masterClear();
1925 marina.enableInstructionSend(true);
1930 prln("End testOlcDecrementAtHighSpeed");
1933 private void flipIlcBit(Marina marina) {
1934 prln("Begin flipIlcBit");
1936 prln("Using the set ILC instruction, toggle a single bit between zero and one. \n" +
1937 "Check correct setting of the ILC zero bit");
1939 for (int i=0; i<6; i++) {
1942 prln("Then immediately set ILC="+notZero);
1943 marina.fillSouthProperStopper(new Instruction[] {
1944 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
1945 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
1948 model.waitNS(64 * CYCLE_TIME_NS);
1950 prln("Verify ILC using scan chain");
1951 Ilc ilc = marina.getILC();
1952 int ilcCount = ilc.getCount();
1953 fatal(ilcCount!=notZero, "bad ILC count: "+ilcCount+" expected: "+notZero);
1954 fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
1956 marina.fillSouthProperStopper(new Instruction[] {
1957 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
1958 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
1961 model.waitNS(64 * CYCLE_TIME_NS);
1963 prln("Verify ILC using scan chain");
1964 ilc = marina.getILC();
1965 ilcCount = ilc.getCount();
1966 fatal(ilcCount!=0, "bad ILC count: "+ilcCount+" expected: 0");
1967 fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
1971 prln("End flipIlcBit");
1973 private void flipOlcBit(Marina marina) {
1974 prln("Begin flipOlcBit");
1976 prln("Using the set OLC instruction, toggle a single bit between zero and one. \n" +
1977 "Check correct setting of the OLC zero bit");
1979 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
1981 for (int i=0; i<6; i++) {
1982 int notZero = 32 >> i;
1984 if (marina.kesselsCounter) {
1985 // master clear on each iteration; otherwise we'd need to "run down" the olc
1986 marina.masterClear();
1987 marina.enableInstructionSend(true);
1992 prln("Then immediately set OLC="+notZero);
1993 marina.fillSouthProperStopper(new Instruction[] {
1994 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
1995 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
1998 model.waitNS(64 * CYCLE_TIME_NS);
1999 prln("Verify OLC count using scan chain");
2000 outOlc = marina.getOLC();
2001 fatal(outOlc!=notZero, "bad OLC count: "+outOlc+" expected: "+notZero);
2003 if (!marina.kesselsCounter) {
2004 prln("Set OLC="+notZero);
2005 prln("Then immediately set OLC=0");
2006 marina.fillSouthProperStopper(new Instruction[] {
2007 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
2008 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
2011 model.waitNS(64 * CYCLE_TIME_NS);
2012 prln("Verify OLC count using scan chain");
2013 outOlc = marina.getOLC();
2014 fatal(outOlc!=0, "bad OLC count: "+outOlc+" expected: 0");
2019 prln("End flipOlcBit");
2021 private void testSouthRecirculate(Marina marina, int AMOUNT) {
2022 prln("Begin testSouthRecirculate("+AMOUNT+")");
2025 marina.enableInstructionSend(false);
2026 marina.enableInstructionRecirculate(true);
2028 prln("Completely fill south ring");
2030 for (int i=0; i<AMOUNT; i++) {
2031 prln("inserting item " + (i+1) + " / " + AMOUNT);
2032 BitVector path = new BitVector(MarinaPacket.PATH_WIDTH, "path");
2033 BitVector data = new BitVector(MarinaPacket.WORD_WIDTH, "path");
2034 path.set(0, MarinaPacket.PATH_WIDTH, false);
2035 data.setFromLong(i+9);
2036 marina.instrIn.fill(new MarinaPacket(data, false, path));
2040 prln("Drain south ring and check contents");
2042 List<BitVector> out = marina.instrIn.drainMany();
2043 boolean bad = false;
2044 for (int i=0; i<AMOUNT; i++) {
2045 prln("extracting item " + (i+1) + " / " + AMOUNT);
2046 //int expect = (i+Marina.SOUTH_RING_CAPACITY-1) % Marina.SOUTH_RING_CAPACITY;
2048 long got = new MarinaPacket(out.get(i)).data.toLong();
2051 prln(" bad instruction: "+got+" expected: "+expect);
2053 prln(" good instruction.");
2056 fatal(bad, "data inserted does not match data retrieved");
2059 for (int i=0; i<5; i++) {}
2062 prln("End testSouthRecirculate("+AMOUNT+")");
2064 private void doOneTest(int testNum) {
2066 prln("============================================================");
2067 prln("MarinaTest: performing test: "+testNum);
2069 marina.masterClear();
2070 marina.enableInstructionSend(true);
2077 // these tests run fairly quickly
2079 doOneTest(1); // passes extracted parasitics
2080 doOneTest(2); // passes extracted parasitics
2081 doOneTest(3); // passes extracted parasitics
2082 doOneTest(4); // passes extracted parasitics
2083 doOneTest(5); // passes extracted parasitics
2084 doOneTest(6); // passes extracted parasitics
2085 doOneTest(1000); // passes extracted parasitics
2086 doOneTest(1001); // passes extracted parasitics
2087 doOneTest(1003); // passes extracted parasitics
2088 doOneTest(3000); // passes extracted parasitics
2089 doOneTest(3001); // passes extracted parasitics
2090 doOneTest(3003); // passes extracted parasitics
2091 doOneTest(3004); // passes extracted parasitics
2092 doOneTest(3005); // passes extracted parasitics
2093 doOneTest(3006); // passes extracted parasitics
2094 doOneTest(3007); // passes extracted parasitics
2095 doOneTest(3008); // passes extracted parasitics
2096 doOneTest(3009); // passes extracted parasitics
2097 doOneTest(3010); // passes extracted parasitics
2098 doOneTest(3011); // passes extracted parasitics
2099 doOneTest(3012); // passes extracted parasitics
2100 doOneTest(3013); // passes extracted parasitics
2101 doOneTest(3014); // passes extracted parasitics
2102 doOneTest(3015); // passes extracted parasitics
2103 doOneTest(3019); // passes extracted parasitics
2104 doOneTest(3020); // passes extracted parasitics
2105 doOneTest(3022); // passes extracted parasitics
2106 doOneTest(3023); // passes extracted parasitics
2107 doOneTest(3026); // passes extracted parasitics
2108 doOneTest(3027); // passes extracted parasitics
2109 doOneTest(3028); // passes extracted parasitics
2111 // these tests take a while and usually pass
2122 // this takes an insanely long time
2126 case 1: testChains(marina); break; // passes, 24-Mar (+verilog)
2127 case 2: testProperStoppers(marina); break; // passes, 24-Mar (+verilog)
2128 case 3: testSouthRecirculate(marina, 1); break; // passes, 24-Mar (+verilog)
2129 case 4: getCtrsFlags(marina); break; // 20-Apr (+verilog)
2130 case 5: sendInstructions(marina); break; // passes, 24-Mar (+verilog)
2131 case 6: walkOneOLC(marina); break; // 21-Apr (+verilog)
2133 // Russell's tests begin with 1000
2134 case 1000: walkOneILC(marina); break; // 20-Apr (+verilog)
2135 case 1001: countIlc(marina); break; // 20-Apr (+verilog)
2136 case 1002: countOlc(marina); break; // 23-Apr (+verilog)
2138 case 1003: sendTorpedo(marina); break; // 23-Apr (+verilog) [with wor-hack]
2140 case 1004: flipIlcBit(marina); break; // 20-Apr (+verilog)
2141 case 1005: flipOlcBit(marina); break; // 21-Apr (+verilog)
2143 case 1006: testSouthRecirculate(marina, Marina.SOUTH_RING_CAPACITY-1); break; // passes, 24-Mar (+verilog)
2145 // Adam's tests begin with 3000
2146 case 3000: sendToken(marina); break; // passes, 24-Mar (+verilog)
2147 case 3001: testFlagAB(marina); break; // passes, 08-Apr (+verilog)
2148 case 3002: testPredicationOnAB(marina); break; // 22-Apr (+verilog)
2149 case 3003: testFlagC(marina); break; // 23-Apr (+verilog)
2150 case 3004: testFlagD(marina); break; // 23-Apr (+verilog)
2151 case 3005: testFlagDRecomputationTime(marina); break;
2153 case 3006: testTailWaitsForHead(marina); break;
2154 case 3007: testTailWithoutHead(marina); break;
2155 case 3008: testHeadWaitsForTail(marina); break; // 22-Apr (+verilog)
2156 case 3009: testAbort(marina); break; // 22-Apr (+verilog)
2158 case 3010: sendData(marina); break; // passes, 24-Mar (+verilog)
2159 case 3011: recvData(marina); break; // 21-Apr (+verilog)
2160 case 3012: sendDataWithPath(marina); break; // passes, 13-Apr (+verilog)
2162 case 3013: testSignExtendedLiteral(marina); break; // 20-Apr (+verilog)
2163 case 3014: testShiftedLiteral(marina); break; // 20-Apr (+verilog)
2164 case 3015: testSendAndRecvToken(marina); break; // 21-Apr (+verilog)
2166 case 3016: sendDataIlcInfinite(marina); break; // 22-Apr (+verilog)
2167 case 3017: testFlagTruthTable(marina); break; // 23-Apr (+verilog)
2169 case 3019: setOlcFromDataLatch(marina); break; // 23-Apr (+verilog)
2170 case 3020: setIlcFromDataLatch(marina); break; // 23-Apr (+verilog)
2171 case 3021: recvPath(marina); break; // 22-Apr (+verilog)
2172 case 3022: testILC(marina); break; // 23-Apr (+verilog)
2173 case 3023: testTorpedoOnAnInfinite(marina); break; // 23-Apr (+verilog)
2174 case 3024: testRecvAndSendWalkingOne(marina); break; // 21-Apr (+verilog)
2175 case 3025: testOlcDecrementAtHighSpeed(marina); break; // 23-Apr (+verilog)
2177 case 3026: testNonTorpedoableMoveDoesNotResetDFlag(marina); break; // 23-Apr (+verilog)
2178 case 3027: testILCZero(marina); break;
2179 case 3028: testAbortOutsideOfLoop(marina); break;
2182 fatal(true, "Test number: "+testNum+" doesn't exist.");
2185 // If we get here then test passed
2186 prln("Test Result: Passed");
2188 //Infrastructure.exit(0);
2189 } catch (MarinaUtils.FailureException fe) {
2190 System.out.println("******************************************************************************");
2191 System.out.println("******************************************************************************");
2192 System.out.println("******************************************************************************");
2193 System.out.println("******************************************************************************");
2194 fe.printStackTrace();
2199 //============================ for public use =============================
2202 * 0: test detected success
2203 * 2: test detected failure
2206 public static void main(String[] args) {
2207 startTime = System.currentTimeMillis();
2208 new MarinaTest(args);