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, ct;
118 private ChainControl ccD, ccR, ccC, cc;
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;
225 int khz = model instanceof VerilogModel ? 100000 : cmdArgs.jtagShift ? 20000 : 1000000;
227 prln("constructing jtag controller");
228 JtagTester tester = ((SimulationModel)model).createJtagTester("TCK", "TMS", "TRSTb", "TDI", "TDO");
229 tester.printInfo = false;
231 ChainControls ccs = new ChainControls();
232 PowerChannel pc = new ManualPowerChannel("pc", false);
234 JtagTester testerD, testerR, testerC;
235 testerD = ((SimulationModel)model).createJtagSubchainTester("sid[1:9]", null);
236 testerR = ((SimulationModel)model).createJtagSubchainTester("sir[1:9]", null);
237 testerC = ((SimulationModel)model).createJtagSubchainTester("sic[1:9]", null);
238 testerD.printInfo = testerR.printInfo = testerC.printInfo = false;
240 ccD = new ChainControl(SCAN_CHAIN_XML, testerD, 1.8f, khz);
241 ccR = new ChainControl(SCAN_CHAIN_XML, testerR, 1.8f, khz);
242 ccC = new ChainControl(SCAN_CHAIN_XML, testerC, 1.8f, khz);
243 ccD.noTestSeverity = ccR.noTestSeverity = ccC.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
246 ctD = new ChainTest(ccD, pc);
247 ctR = new ChainTest(ccR, pc);
248 ctC = new ChainTest(ccC, pc);
251 ccs.addChain(Marina.DATA_CHAIN, ccD);
252 ccs.addChain(Marina.REPORT_CHAIN, ccR);
253 ccs.addChain(Marina.CONTROL_CHAIN, ccC);
256 cc = new ChainControl(SCAN_CHAIN_XML, tester, 1.8f, khz);
257 cc.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
258 ct = new ChainTest(cc, pc);
259 ccs.addChain(Marina.DATA_CHAIN, cc);
260 ccs.addChain(Marina.REPORT_CHAIN, cc);
261 ccs.addChain(Marina.CONTROL_CHAIN, cc);
263 marina = new Marina(ccs, model, !cmdArgs.jtagShift, indenter);
265 if (model instanceof VerilogModel)
266 ((SimulationModel)model).start("verilog", "marina.v", VerilogModel.DUMPVARS, !cmdArgs.jtagShift);
267 else if (model instanceof HsimModel)
268 ((SimulationModel)model).start("hsim64", netListName, 0, !cmdArgs.jtagShift);
270 ((SimulationModel)model).start("nanosim -c cfg", netListName, 0, !cmdArgs.jtagShift);
274 ccC.shift(Marina.CONTROL_CHAIN, false, true);
278 cc.shift(Marina.CONTROL_CHAIN, false, true);
280 doOneTest(cmdArgs.testNum);
282 ((SimulationModel)model).finish();
284 private void doSilicon() {
285 model = new SiliconChip();
286 String ip = cmdArgs.station.ipAddr;
287 JtagTester tester = new Netscan4(ip, cmdArgs.station.jtagChannel);
288 tester.printInfo = false;
290 ChainControl cc = new ChainControl("???", tester, 1.8f, khz);
291 cc.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
292 ChainControls ccs = new ChainControls();
293 ccs.addChain(Marina.DATA_CHAIN, cc);
294 ccs.addChain(Marina.REPORT_CHAIN, cc);
295 ccs.addChain(Marina.CONTROL_CHAIN, cc);
296 marina = new Marina(ccs, model, false, indenter);
297 PowerChannel pc = new ManualPowerChannel("pc", false);
298 ChainTest ct = new ChainTest(cc, pc);
299 ct.testAllChains("marina", Infrastructure.SEVERITY_WARNING);
300 doOneTest(cmdArgs.testNum);
301 setUpSuppliesAndMeters(cmdArgs.station);
304 /** In the absence of looping, the longest path through Infinity is 4 column delays */
305 private void waitUntilQuiescent() {
306 model.waitNS(4*COLUMN_LATENCY);
309 private double readCurrent() {
310 return voltmeterForCurrent.readVoltage() / cmdArgs.station.ammeterShuntResistance;
313 /** Generate List of BitVectors where Token=true, high 25 data bits
314 * are alternating ones and zeros, low 12 data bits increment from
315 * zero, and address is given by addr. */
316 private List<BitVector> makeIncrDataConstAdr(int num, int addr) {
317 List<BitVector> ans = new ArrayList<BitVector>();
318 BitVector dHi = new BitVector(25, "dataHi");
319 BitVector dLo = new BitVector(12, "dataLo");
320 BitVector t = new BitVector("1", "token");
321 BitVector a = new BitVector(14, "addr");
322 dHi.setFromLong(0x00aaaaa);
324 for (int i=0; i<num; i++) {
326 ans.add(dHi.cat(dLo).cat(t).cat(a));
331 private void stopToStop(ProperStopper s1, ProperStopper s2,
333 List<BitVector> din) {
334 prln("Begin stopToStop");
339 long ctrStart = ctr==null ? 0 : ctr.getCount();
342 waitUntilQuiescent();
344 List<BitVector> dout = s2.drainMany();
346 MarinaUtils.compareItemsOrdered(din, dout);
349 long ctrEnd = ctr.getCount();
350 long delta = ctrEnd - ctrStart;
351 long expect = din.size();
353 "counter delta wrong: expected delta: "+expect+
354 " counter before:"+ctrStart+" counter after:"+ctrEnd);
358 prln("End stopToStop");
360 /** Burst data from src to dst. gate is stopped while loading src. gate
361 * is then run to allow the burst to flow. */
362 private void stopToStopBurst(ProperStopper src, ProperStopper gate,
365 List<BitVector> din) {
366 prln("Begin stopToStopBurst test");
372 long ctrStart = ctr==null ? 0 : ctr.getCount();
375 waitUntilQuiescent();
377 // open the gate to start the burst
379 waitUntilQuiescent();
381 List<BitVector> dout = dst.drainMany();
383 MarinaUtils.compareItemsOrdered(din, dout);
386 long ctrEnd = ctr.getCount();
387 long delta = ctrEnd - ctrStart;
389 long expectA = din.size();
390 fatal(delta!=expectA,
391 "counter delta wrong: expected delta: "+expectA+
392 " counter before:"+ctrStart+" counter after:"+ctrEnd);
396 prln("End stopToStopBurst test");
399 private void stopToStopOne(ProperStopper s1, ProperStopper s2,
400 Counter ctr, int adr) {
401 prln("Begin stopToStopOne");
404 List<BitVector> din = makeIncrDataConstAdr(1, adr);
405 stopToStop(s1, s2, ctr, din);
408 prln("End stopToStopOne");
411 private void stopToStopThree(ProperStopper s1, ProperStopper s2,
412 Counter ctr, int adr) {
413 prln("Begin stopToStopOne");
416 List<BitVector> din = makeIncrDataConstAdr(3, adr);
417 stopToStop(s1, s2, ctr, din);
420 prln("End stopToStopOne");
423 private int indexOf(BitVector o, List<BitVector> dIn) {
424 for (int i=0; i<dIn.size(); i++) {
425 if (o.equals(dIn.get(i))) return i;
429 private String ringDump(List<BitVector> dIn, List<BitVector> dOut) {
430 StringBuffer sb = new StringBuffer();
431 sb.append(" ring dump: ");
432 for (BitVector o : dOut) {
433 sb.append(indexOf(o, dIn)+" ");
435 return sb.toString();
438 private int[][] makeIntArray2D(int a, int b) {
439 int[][] ans = new int[a][];
440 for (int i=0; i<a; i++) ans[i] = new int[b];
444 //=========================================================================
445 // Put top level tests here
447 private void testChains(Marina marina) {
449 prln("Testing control chain...");
450 ctC.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
452 ccC.shift(Marina.CONTROL_CHAIN, false, true);
456 prln("Testing data chain...");
457 ctD.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
459 //ccD.shift(Marina.DATA_CHAIN, false, true);
463 prln("Testing report chain...");
464 ctR.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
466 //ccR.shift(Marina.REPORT_CHAIN, false, true);
470 prln("Testing control chain...");
471 ct.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
473 cc.shift(Marina.CONTROL_CHAIN, false, true);
474 prln("Testing data chain...");
475 ct.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
476 prln("Testing report chain...");
477 ct.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
481 private void testProperStoppers(Marina marina) {
482 prln("Begin testProperStoppers");
485 for(ProperStopper ps : new ProperStopper[] { marina.data, marina.instrIn }) {
487 prln("testing " + (ps == marina.data ? "data" : "instruction") + " stopper");
490 prln("un-stopping stopper");
492 fatal( ps.getStopped(), "stopper should not have been stopped, but was");
494 prln("stopping stopper");
496 fatal( !ps.getStopped(), "stopper should have been stopped, but was not");
504 private void sendInstructions(Marina marina) {
505 prln("Begin sendInstructions");
508 List<BitVector> din = new ArrayList<BitVector>();
510 BitVector count = new BitVector(MarinaPacket.WORD_WIDTH,"count");
511 BitVector one = new BitVector(MarinaPacket.WORD_WIDTH, "one");
512 count.setFromLong(0);
514 for (int i=0; i<3; i++) {
516 count = count.add(one);
519 for(BitVector d : din)
520 marina.instrIn.fill(new MarinaPacket(d, false, MarinaPacket.null_path));
523 prln("End sendInstructions");
526 private void sendToken(Marina marina) {
527 prln("Begin sendToken");
530 //getCtrsFlags(marina);
532 int nbToks = marina.getNumTokens();
533 fatal(nbToks!=0, "Expected no tokens on initialization but got: "+nbToks+" tokens");
535 marina.instrIn.fill(setIlc(1));
536 marina.instrIn.fill(SEND_TOKEN);
537 nbToks = marina.getNumTokens();
538 fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
541 prln("End sendToken");
544 private void sendData(Marina marina) {
545 prln("Begin sendData");
548 edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
549 for(int i=0; i<bv.length(); i+=2) bv.set(i, false);
550 MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
552 marina.instrIn.fill(setIlc(1));
553 marina.instrIn.fill(SEND_DATA);
555 List<BitVector> dataItems = marina.data.drainMany();
556 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
558 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
559 fatal(mp.tokenhood, "Expected tokenhood=data, but got tokenhood=token");
562 prln("End sendData");
565 private void sendDataIlcInfinite(Marina marina) {
566 prln("Begin sendDataIlcInfinite");
569 marina.fillSouthProperStopper(new Instruction[] {
570 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
576 List<BitVector> dataItems = marina.data.drainMany(howmany);
577 fatal(dataItems.size()!=howmany,
578 "Expected an unending supply of data items to emerge but only got got: "+dataItems.size());
581 prln("End sendDataIlcInfinite");
584 private Instruction setOlc(int olc) {
585 return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, olc);
587 private Instruction setOlcIfZero(int olc) {
588 return new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter, olc);
590 private Instruction setIlc(int ilc) {
591 return new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, ilc);
594 private void testFlagD(Marina marina) {
595 prln("Begin testFlagD");
598 List<BitVector> toks;
600 Predicate only_if_olc_zero = Predicate.FlagD;
601 Predicate only_if_olc_nonzero = Predicate.Default;
603 marina.instrIn.fill(setIlc(1));
605 for(int olc : new int[] { 1, 0 }) {
606 for(boolean predicate_olc_nonzero : new boolean[] { true, false }) {
607 prln("Attempting send data item with "+
609 "predicate olc"+(predicate_olc_nonzero?"!=0":"==0"));
612 marina.fillSouthProperStopper(new Instruction[] {
614 new Instruction.Move(dock,
615 predicate_olc_nonzero // predicate
616 ? only_if_olc_nonzero
619 false, // torpedoable
629 expectNorthFifoExactly((predicate_olc_nonzero == (olc!=0)) ? 1 : 0);
631 for(int i=0; i<olc; i++)
632 marina.instrIn.fill(DEC);
638 prln("End testFlagD");
641 private void testPredicationOnAB(Marina marina) {
642 prln("Begin testPredicationOnAB");
645 List<BitVector> dItems;
647 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 1));
648 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
650 for(boolean flag_a : new boolean[] { false, true }) {
651 for(boolean flag_b : new boolean[] { false, true }) {
652 prln("Setting flags, a="+flag_a+" b="+flag_b);
653 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
655 ? Instruction.Set.FlagFunction.ONE
656 : Instruction.Set.FlagFunction.ZERO,
658 ? Instruction.Set.FlagFunction.ONE
659 : Instruction.Set.FlagFunction.ZERO
661 getCtrsFlags(marina);
664 for(Predicate predicate : new Predicate[] {
672 prln("Attempting send data with a="+flag_a+", b="+flag_b+", predicate="+predicate);
674 marina.instrIn.fill(new Instruction.Move(dock,
675 predicate, // predicate
676 false, // torpedoable
686 dItems = marina.data.drainMany();
687 int expected = predicate.evaluate(flag_a, flag_b, false, false) ? 1 : 0;
688 fatal(dItems.size()!=expected, "Expected "+expected+" data items to emerge but got: "+
689 dItems.size()+" items(s)");
695 prln("End testPredicationOnAB");
699 private void showOlc() {
700 prln("OLC=="+marina.getOLC());
702 private void expectOlc(int x) {
703 int olc = marina.getOLC();
704 fatal(x!=olc, "expected OLC=="+x+", but scanned out OLC=="+olc);
707 private void getCtrsFlags(Marina marina) {
708 prln("begin getCtrsFlags");
712 Ilc ilc = marina.getILC();
713 prln("ILC.done=="+ilc.getDone()+
714 " ILC.infinity=="+ilc.getInfinity()+
715 " ILC.count=="+ilc.getCount());
716 prln("flagA=="+marina.getFlagA());
717 prln("flagB=="+marina.getFlagB());
719 prln("end getCtrsFlags");
722 private void walkOneOLC(Marina marina) {
723 prln("Begin walkOneOLC");
725 for (int i=0; i<6; i++) {
727 if (marina.kesselsCounter) {
728 System.out.println("master-clearing...");
729 // master clear on each iteration; otherwise we'd need to "run down" the olc
730 marina.masterClear();
731 marina.enableInstructionSend(true);
734 int inOlc = i==-1 ? 0 : (1<<i);
735 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc));
737 model.waitNS(128 * CYCLE_TIME_NS);
740 prln("walkOneOLC: "+inOlc+" checks out");
743 prln("End walkOneOLC");
745 private void walkOneILC(Marina marina) {
746 prln("Begin walkOneILC");
748 for (int i=0; i<6; i++) {
749 // Mask off the "zero" bit position
751 prln("inIlc="+inIlc);
752 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, inIlc));
753 Ilc ilc = marina.getILC();
754 int outIlc = ilc.getCount();
755 fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+inIlc);
756 fatal(ilc.getInfinity(), "bad Infinity bit: true");
758 prln("Now test the infinity bit");
759 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
760 Ilc ilc = marina.getILC();
761 fatal(!ilc.getInfinity(), "bad Infinity bit: false");
763 prln("End walkOneILC");
765 private void countIlc(Marina marina) {
766 final int maxIlc = 63;
767 prln("Begin countIlc");
770 marina.instrIn.fill(new
771 Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, maxIlc));
773 int ilc = marina.getILC().getCount();
774 fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc);
776 prln("execute a move instruction that does nothing except decrement the ILC to zero");
778 new Instruction.Move(dock,
779 Predicate.IgnoreFlagD, // predicate
780 false, // torpedoable
790 // wait for ILC to count from 63 to 0
791 model.waitNS(128 * CYCLE_TIME_NS);
792 //model.waitNS(10000);
794 prln("Check that ILC==0");
795 ilc = marina.getILC().getCount();
796 fatal(ilc!=0, "bad ILC count: "+ilc+" expected: "+0);
799 prln("End countIlc");
801 // Note: countOlc takes 44 minutes to run on nanosim
802 private void countOlc(Marina marina) {
804 prln("Begin countOlc");
807 marina.instrIn.fill(setOlc(maxOlc));
809 for (int i=maxOlc; i>=0; i--) {
810 model.waitNS(128 * CYCLE_TIME_NS);
811 prln("OLC should be: "+i);
813 marina.instrIn.fill(new
814 Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, SetSource.Decrement));
818 prln("End countOlc");
820 private void loadEveryValueOLC(Marina marina) {
822 for (int i=0; i<(1<<6); i++) {
824 if (marina.kesselsCounter) {
825 System.out.println("master-clearing...");
826 // master clear on each iteration; otherwise we'd need to "run down" the olc
827 marina.masterClear();
828 marina.enableInstructionSend(true);
832 marina.fillSouthProperStopper(new Instruction[] {
836 // to ensure that instruction is bubble-limited
839 // the Set-OLC instruction
840 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc),
842 // put a Set-ILC instruction right behind it with inverted bits to be sure we're
843 // not capturing the instruction-latch value too late in the cycle
844 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, (inOlc ^ (~(-1<<6)))),
848 model.waitNS(128 * CYCLE_TIME_NS);
849 marina.fillNorthProperStopper();
850 model.waitNS(128 * CYCLE_TIME_NS);
853 prln("loadEveryValueOLC: "+inOlc+" checks out");
858 private void saturateInstructionFifo(Marina marina, Instruction instruction, int quantity, boolean expect_it_to_jam_up) {
859 prln("Inserting "+quantity+" copies of \"" + instruction + "\"");
862 for(i=0; i<quantity; i++) {
863 prln("Inserting instruction " + (i+1) +"/"+ quantity);
864 marina.instrIn.fill(instruction);
865 boolean jammed = (marina.instrIn.getFillStateWire()==MarinaUtils.StateWireState.FULL);
866 if (jammed && expect_it_to_jam_up) {
867 prln("Stopper remained full after inserting instruction; this was expected; we are happy.");
871 fatal(jammed, "Instruction stopper did not drain after inserting " + (i+1) + " instructions; not good!");
873 fatal(expect_it_to_jam_up, "Expected instruction stopper to jam up, but it did not");
875 prln("Successfully inserted " + i + " instructions");
878 private static MarinaPath null_path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(),
879 MarinaUtils.sunToBerk(MarinaPacket.null_path));
881 private static final Instruction DEC =
882 new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter, SetSource.Decrement);
884 private static final Instruction FLAG_NOP =
885 new Instruction.Set(dock, Predicate.IgnoreFlagD,
886 CLEAR_FLAG.add(Predicate.FlagA),
887 CLEAR_FLAG.add(Predicate.FlagB));
889 private static final Instruction NOP =
890 new Instruction.Move(dock,
891 Predicate.IgnoreFlagD, /* predicate */
892 false, /* torpedoable */
896 false, /* latchData */
897 false, /* latchPath */
902 private static final Instruction SEND_DATA =
903 new Instruction.Move(dock,
904 Predicate.IgnoreFlagD, /* predicate */
905 false, /* torpedoable */
906 null_path, /* path */
909 false, /* latchData */
910 false, /* latchPath */
915 private static final Instruction SEND_DATA_IF_D_NOT_SET =
916 new Instruction.Move(dock,
917 Predicate.Default, /* predicate */
918 false, /* torpedoable */
919 null_path, /* path */
922 false, /* latchData */
923 false, /* latchPath */
928 private static final Instruction SEND_DATA_IF_D_SET =
929 new Instruction.Move(dock,
930 Predicate.FlagD, /* predicate */
931 false, /* torpedoable */
932 null_path, /* path */
935 false, /* latchData */
936 false, /* latchPath */
941 private static final Instruction TORPEDOABLE_RECV_DATA =
942 new Instruction.Move(dock,
943 Predicate.IgnoreFlagD, /* predicate */
944 true, /* torpedoable */
948 true, /* latchData */
949 false, /* latchPath */
954 private static final Instruction RECV_DATA =
955 new Instruction.Move(dock,
956 Predicate.IgnoreFlagD, /* predicate */
957 false, /* torpedoable */
961 true, /* latchData */
962 false, /* latchPath */
967 private static final Instruction SEND_TOKEN =
968 new Instruction.Move(dock,
969 Predicate.IgnoreFlagD, /* predicate */
970 false, /* torpedoable */
971 null_path, /* path */
974 false, /* latchData */
975 false, /* latchPath */
980 private static final Instruction RECV_TOKEN =
981 new Instruction.Move(dock,
982 Predicate.IgnoreFlagD, /* predicate */
983 false, /* torpedoable */
987 false, /* latchData */
988 false, /* latchPath */
994 private void expectNorthFifoNoMoreThan(int num) {
995 model.waitNS(128 * CYCLE_TIME_NS);
996 List<BitVector> dataItems = marina.data.drainMany(num+1);
997 fatal(dataItems.size()>num,
998 "Expected no more than "+num+
999 " data items to emerge but got at least: "+dataItems.size());
1001 private void expectNorthFifoExactly(int num) {
1002 model.waitNS(128 * CYCLE_TIME_NS);
1003 List<BitVector> dataItems = marina.data.drainMany(num+1);
1004 fatal(dataItems.size()!=num,
1005 "Expected exactly "+num+
1006 " data items to emerge but got at least: "+dataItems.size());
1008 private void expectNorthFifoAtLeast(int num) {
1009 model.waitNS(128 * CYCLE_TIME_NS);
1010 List<BitVector> dataItems = marina.data.drainMany(num);
1011 fatal(dataItems.size()<num,
1012 "Expected at least "+num+
1013 " data items to emerge but got only: "+dataItems.size());
1015 private void expectTokensNoMoreThan(int num) {
1016 int x = marina.getNumTokens();
1017 List<BitVector> dataItems = marina.data.drainMany(num+1);
1019 "Expected no more than "+num+
1020 " tokens to emerge but got at least: "+x);
1022 private void expectTokensExactly(int num) {
1023 int x = marina.getNumTokens();
1025 "Expected exactly "+num+
1026 " tokens but got at least: "+x);
1029 private void testFlagDRecomputationTime(Marina marina) {
1030 marina.instrIn.fill(setIlc(1));
1031 marina.fillSouthProperStopper(new Instruction[] {
1033 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
1034 SEND_DATA_IF_D_NOT_SET
1036 marina.fillNorthProperStopper();
1037 expectNorthFifoNoMoreThan(0);
1039 marina.fillSouthProperStopper(new Instruction[] {
1041 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
1042 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
1043 SEND_DATA_IF_D_NOT_SET
1045 marina.fillNorthProperStopper();
1046 expectNorthFifoNoMoreThan(0);
1048 marina.fillSouthProperStopper(new Instruction[] {
1050 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
1051 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
1052 SEND_DATA_IF_D_NOT_SET
1054 marina.fillNorthProperStopper();
1055 expectNorthFifoExactly(1);
1056 marina.instrIn.fill(DEC);
1058 marina.fillSouthProperStopper(new Instruction[] {
1060 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
1061 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
1062 SEND_DATA_IF_D_NOT_SET
1064 marina.fillNorthProperStopper();
1065 expectNorthFifoExactly(1);
1068 private void testTailWaitsForHead(Marina marina) {
1069 marina.instrIn.fill(setIlc(1));
1070 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
1072 marina.enableInstructionSend(false);
1073 marina.enableInstructionRecirculate(true);
1075 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
1076 marina.instrIn.fill(new Instruction.Head(dock));
1077 marina.instrIn.fill(SEND_DATA);
1078 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
1079 marina.instrIn.fill(SEND_TOKEN);
1080 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
1081 marina.instrIn.fill(new Instruction.Tail(dock));
1082 marina.instrIn.fillTorpedo();
1084 marina.enableInstructionRecirculate(false);
1085 marina.enableInstructionSend(true);
1086 marina.instrIn.run();
1088 expectNorthFifoNoMoreThan(0);
1089 prln("inserting into north proper stopper");
1090 marina.fillNorthProperStopper();
1091 expectNorthFifoExactly(1);
1092 int nbToks = marina.getNumTokens();
1093 fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
1097 marina.instrIn.fill(setIlc(1));
1098 marina.instrIn.fill(setOlc(1));
1100 // this makes the head wait for the torpedo
1101 marina.instrIn.fill(TORPEDOABLE_RECV_DATA);
1103 // the head should wait for the tail
1104 marina.instrIn.fill(new Instruction.Head(dock));
1105 marina.instrIn.fill(NOP);
1106 marina.instrIn.fill(SEND_DATA);
1107 marina.instrIn.fill(RECV_DATA);
1109 expectNorthFifoNoMoreThan(0);
1111 marina.instrIn.fillTorpedo();
1112 expectNorthFifoNoMoreThan(0);
1114 marina.instrIn.fill(new Instruction.Tail(dock));
1115 expectNorthFifoExactly(1);
1118 private void testTailWithoutHead(Marina marina) {
1119 marina.instrIn.fill(setIlc(1));
1120 marina.fillSouthProperStopper(new Instruction[] {
1121 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1122 new Instruction.Tail(dock),
1125 List<BitVector> dataItems = marina.data.drainMany(1);
1126 fatal(dataItems.size()!=0, "Expected exactly no data items to emerge but got at least: "+dataItems.size());
1129 private void testHeadWaitsForTail(Marina marina) {
1130 List<BitVector> dataItems;
1132 prln("Begin testHeadWaitsForTail");
1135 marina.instrIn.fill(setIlc(1));
1136 marina.fillSouthProperStopper(new Instruction[] {
1137 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1138 new Instruction.Head(dock),
1139 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1143 expectNorthFifoExactly(0);
1144 marina.instrIn.fill(new Instruction.Tail(dock));
1145 expectNorthFifoAtLeast(1);
1148 prln("End testHeadWaitsForTail");
1151 private void testNonTorpedoableMoveDoesNotResetDFlag(Marina marina) {
1152 marina.instrIn.fill(setIlc(1));
1153 marina.fillSouthProperStopper(new Instruction[] {
1154 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,63),
1155 new Instruction.Move(dock,
1156 Predicate.IgnoreFlagD, // predicate
1157 true, // torpedoable
1166 new Instruction.Move(dock,
1167 Predicate.FlagD, // predicate
1168 false, // torpedoable
1178 marina.instrIn.fillTorpedo();
1179 expectNorthFifoExactly(1);
1180 marina.fillSouthProperStopper(new Instruction[] {
1181 new Instruction.Move(dock,
1182 Predicate.Default, // predicate
1183 false, // torpedoable
1193 expectNorthFifoNoMoreThan(0);
1196 private void testAbort(Marina marina) {
1198 marina.instrIn.fill(setIlc(1));
1199 marina.fillSouthProperStopper(new Instruction[] {
1200 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,1),
1201 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
1202 SEND_DATA_IF_D_NOT_SET,
1203 new Instruction.Head(dock),
1204 SEND_DATA_IF_D_NOT_SET,
1205 new Instruction.Set(dock,Predicate.Default,SetDest.DataLatch,2),
1206 new Instruction.Abort(dock, Predicate.FlagD),
1207 new Instruction.Set(dock,Predicate.Default,SetDest.OuterLoopCounter,SetSource.Decrement),
1208 new Instruction.Tail(dock),
1211 for(int i=0; i<4; i++) {
1214 model.waitNS(128 * CYCLE_TIME_NS);
1215 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1216 fatal(bv==null, "no data item found");
1217 prln("got " + bv.toLong());
1218 fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1220 model.waitNS(128 * CYCLE_TIME_NS);
1221 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1222 fatal(bv==null, "no data item found");
1223 prln("got " + bv.toLong());
1224 fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1226 model.waitNS(128 * CYCLE_TIME_NS);
1227 bv = new MarinaPacket(marina.data.drain()).data.bitReverse();
1228 fatal(bv==null, "no data item found");
1229 prln("got " + bv.toLong());
1230 fatal(bv.toLong()!=2, "expected 2, got " + bv.toLong());
1235 private void testAbortOutsideOfLoop(Marina marina) {
1236 marina.instrIn.fill(setIlc(1));
1237 marina.fillSouthProperStopper(new Instruction[] {
1238 // ensure that an abort doesn't cause problems if no loop is in progress
1239 new Instruction.Abort(dock, Predicate.IgnoreFlagD),
1242 expectNorthFifoExactly(1);
1245 private void testFlagAB(Marina marina) {
1246 prln("Begin testFlagAB");
1249 Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1250 Instruction.Set.FlagFunction one = zero;
1253 // we should be able to use any pair of FlagX+NotFlagX,
1254 // but we toss them all in to maximize the chances of the
1255 // test passing (later we will try the individual
1256 // combinations to maximize the chances of failure).
1257 one = one.add(Predicate.FlagA);
1258 one = one.add(Predicate.NotFlagA);
1259 one = one.add(Predicate.FlagB);
1260 one = one.add(Predicate.NotFlagB);
1261 one = one.add(Predicate.FlagC);
1262 one = one.add(Predicate.NotFlagC);
1264 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
1265 for(boolean fast : new boolean[] { true, false }) {
1266 // clear the flags to a known state, then check both 0->1 and 1->0 transitions
1267 for(boolean b : new boolean[] { false, true, false }) {
1268 prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
1269 prln((b?"Setting":"Clearing")+" flags");
1271 Instruction inst = new Instruction.Set(dock,Predicate.IgnoreFlagD,
1276 marina.fillSouthProperStopper(new Instruction[] {
1281 model.waitNS(64 * CYCLE_TIME_NS);
1282 marina.fillNorthProperStopper();
1284 marina.instrIn.fill(inst);
1287 fatal(marina.getFlagA()!=b,
1288 "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set"));
1289 fatal(marina.getFlagB()!=b,
1290 "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set"));
1295 prln("End testFlagAB");
1299 * WARNING: this is a very, very, very long test case -- it goes
1300 * through 216 iterations.
1302 private void testFlagTruthTable(Marina marina) {
1303 prln("Begin testFlagTruthTable");
1306 marina.instrIn.fill(setIlc(1));
1307 Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1308 Instruction.Set.FlagFunction one = zero.add(Predicate.FlagA).add(Predicate.NotFlagA);
1310 for(Predicate a_input : new Predicate[] { null, Predicate.FlagA, Predicate.NotFlagA })
1311 for(Predicate b_input : new Predicate[] { null, Predicate.FlagB, Predicate.NotFlagB })
1312 for(Predicate c_input : new Predicate[] { null, Predicate.FlagC, Predicate.NotFlagC })
1313 for(boolean a_state : new boolean[] { false, true })
1314 for(boolean b_state : new boolean[] { false, true })
1315 for(boolean c_state : new boolean[] { false, true }) {
1316 for(boolean which : new boolean[] { false, true }) {
1318 prln("before instruction: a="+a_state+", b="+b_state+", c="+c_state);
1319 // set A,B flags to a_state and b_state
1320 marina.instrIn.fill(new
1321 Instruction.Set(dock,Predicate.IgnoreFlagD,
1322 a_state ? one : zero,
1323 b_state ? one : zero
1326 // set C flag to c_state
1327 BitVector data = new BitVector(37, "empty");
1328 BitVector addr = new BitVector(14, "empty");
1329 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1330 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1331 addr.set(Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE, c_state);
1332 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1333 marina.instrIn.fill(RECV_DATA);
1335 Instruction.Set.FlagFunction func = zero;
1336 if (a_input!=null) func = func.add(a_input);
1337 if (b_input!=null) func = func.add(b_input);
1338 if (c_input!=null) func = func.add(c_input);
1340 Instruction inst = new
1341 Instruction.Set(dock,Predicate.IgnoreFlagD,
1342 !which ? func : zero.add(Predicate.FlagA),
1343 which ? func : zero.add(Predicate.FlagB)
1346 marina.instrIn.fill(inst);
1348 boolean expected_a = !which ? func.evaluate(a_state, b_state, c_state, false) : a_state;
1349 boolean expected_b = which ? func.evaluate(a_state, b_state, c_state, false) : b_state;
1350 fatal(expected_a != marina.getFlagA(),
1351 "expected A="+expected_a+", but got "+marina.getFlagA());
1352 fatal(expected_b != marina.getFlagB(),
1353 "expected B="+expected_b+", but got "+marina.getFlagB());
1357 prln("End testFlagTruthTable");
1360 private void recvData(Marina marina) {
1361 prln("Begin recvData");
1364 marina.instrIn.fill(setIlc(1));
1365 marina.fillSouthProperStopper(new Instruction[] {
1366 new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1367 new Instruction.Move(dock,
1368 Predicate.IgnoreFlagD, // predicate
1369 false, // torpedoable
1378 new Instruction.Set(dock,Predicate.IgnoreFlagD, SET_FLAG, SET_FLAG),
1380 model.waitNS(64 * CYCLE_TIME_NS);
1382 prln("checking to confirm that A flag is cleared");
1383 fatal(marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1385 prln("inserting data item in north fifo ring");
1386 BitVector data = new BitVector(37, "empty");
1387 BitVector addr = new BitVector(14, "empty");
1388 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1389 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1390 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1391 model.waitNS(64 * CYCLE_TIME_NS);
1393 prln("checking to see if A flag got set");
1394 fatal(!marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1397 prln("End recvData");
1401 private void testRecvAndSendWalkingOne(Marina marina) {
1402 prln("Begin testRecvAndSendWalkingOne");
1405 marina.instrIn.fill(setIlc(1));
1407 List<BitVector> dataItems;
1408 for(int bit=0; bit<37; bit++) {
1410 BitVector data = new BitVector(37, "empty");
1411 BitVector addr = new BitVector(14, "empty");
1412 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1413 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1414 data.set(bit, true);
1415 prln("testing with bit pattern " + data);
1417 prln("inserting data item into north fifo ring");
1418 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1420 prln("stopping the north proper stopper");
1423 dataItems = marina.data.drainMany(1);
1424 fatal(dataItems.size()!=0,
1425 "found a data item waiting in the north proper stopper, but should not have");
1427 marina.instrIn.fill(new Instruction.Move(dock,
1428 Predicate.IgnoreFlagD, // predicate
1429 false, // torpedoable
1439 dataItems = marina.data.drainMany(2);
1440 fatal(dataItems.size()!=1,
1441 "found "+dataItems.size()+" data items in north fifo; expected one");
1442 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1443 fatalIfBitVectorsDoNotMatch(mp.data, data);
1447 prln("End testRecvAndSendWalkingOne");
1452 private void setOlcFromDataLatch(Marina marina) {
1453 prln("Begin setOlcFromDataLatch");
1456 marina.instrIn.fill(setIlc(1));
1458 // walk a bit from 0 to 5
1459 for(int bit=0; bit<6; bit++) {
1460 prln("inserting data item in north fifo ring");
1461 BitVector data = new BitVector(37, "empty");
1462 BitVector addr = new BitVector(14, "empty");
1463 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1464 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1465 data.set(bit, true);
1466 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1468 marina.fillSouthProperStopper(new Instruction[] {
1470 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.DataLatch),
1471 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.DataLatch,-1),
1474 model.waitNS(CYCLE_TIME_NS * 64);
1478 if (marina.kesselsCounter) {
1479 // master clear on each iteration; otherwise we'd need to "run down" the olc
1480 marina.masterClear();
1481 marina.enableInstructionSend(true);
1486 prln("End setOlcFromDataLatch");
1489 private void setIlcFromDataLatch(Marina marina) {
1490 prln("Begin setIlcFromDataLatch");
1493 marina.instrIn.fill(setIlc(1));
1495 // walk a bit from 0 to 5
1496 for(int bit=5; bit>=0; bit--) {
1497 prln("inserting data item in north fifo ring");
1498 BitVector data = new BitVector(37, "empty");
1499 BitVector addr = new BitVector(14, "empty");
1500 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1501 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1502 data.set(bit, true);
1503 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1505 marina.fillSouthProperStopper(new Instruction[] {
1506 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1508 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.DataLatch),
1510 model.waitNS(CYCLE_TIME_NS * 64);
1512 int ilc = marina.getILC().getCount();
1513 fatal(ilc != (1<<bit), "expected ilc to be " + (1<<bit) + ", but got " + ilc);
1517 prln("End setIlcFromDataLatch");
1520 private void testSendAndRecvToken(Marina marina) {
1521 prln("Begin testSendAndRecvToken");
1524 marina.instrIn.fill(setIlc(1));
1525 marina.fillSouthProperStopper(new Instruction[] {
1530 expectNorthFifoExactly(1);
1533 prln("End testSendAndRecvToken");
1536 private void testSignExtendedLiteral(Marina marina) {
1537 prln("Begin testSignExtendedLiteral");
1540 marina.instrIn.fill(setIlc(1));
1541 for(long val : new long[] { (-1L << 14), -1, 0, 1 }) {
1543 marina.fillSouthProperStopper(new Instruction[] {
1544 new Instruction.Set(dock,Predicate.IgnoreFlagD,
1545 Instruction.Set.SetDest.DataLatch,
1549 model.waitNS(CYCLE_TIME_NS * 64);
1551 List<BitVector> dataItems = marina.data.drainMany(3);
1552 fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1554 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1555 BitVector bv = mp.data;
1556 prln("got back " + mp);
1558 boolean mismatch = false;
1560 for(int i=0; i<37; i++) {
1561 if (bv.get(i) != ( (val & (1L << i)) != 0 )) {
1566 fatal(mismatch, "data read back did not match inserted literal; mismatch on bits " + err);
1570 prln("End testSignExtendedLiteral");
1573 private void testShiftedLiteral(Marina marina) {
1574 prln("Begin testShiftedLiteral");
1577 marina.instrIn.fill(setIlc(1));
1578 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,
1579 Instruction.Set.SetDest.DataLatch,
1582 BitVector dreg = new BitVector(37, "what we think is in the d-register");
1583 for(int i=0; i<37; i++) dreg.set(i, false);
1585 for(long val : new long[] { -1, 0, 1, (-1L << 18) }) {
1587 edu.berkeley.fleet.api.BitVector immediate =
1588 new edu.berkeley.fleet.api.BitVector(19);
1589 for(int i=0; i<immediate.length(); i++)
1590 immediate.set(i, (val & (1L << i)) != 0);
1592 // shift over 19 LSB's towards MSB
1593 for(int i=0; i<19; i++)
1594 if (i+19 <= 36) dreg.set(i+19, dreg.get(i));
1595 for(int i=0; i<19; i++)
1596 dreg.set(i, immediate.get(i));
1598 marina.fillSouthProperStopper(new Instruction[] {
1599 new Instruction.Shift(dock,Predicate.IgnoreFlagD,immediate),
1603 model.waitNS(CYCLE_TIME_NS * 64);
1604 List<BitVector> dataItems = marina.data.drainMany(3);
1605 fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1607 BitVector bv = new MarinaPacket(dataItems.get(0)).data;
1608 fatal(!bv.equals(dreg), "data read back did not match inserted literal.\n" +
1609 "got: "+bv.bitReverse().getState()+"\n"+
1610 "expected:"+dreg.bitReverse().getState());
1614 prln("End testShiftedLiteral");
1617 private void testFlagC(Marina marina) {
1618 prln("Begin testFlagC");
1626 // Dc=1 => sigS is copied into C-flag
1627 // Dc=0 => sigA is copied into C-flag
1629 marina.instrIn.fill(setIlc(1));
1630 for(boolean dc : new boolean[] { false, true }) {
1631 for(boolean c_flag : new boolean[] { true, false, true }) {
1634 prln("****** checking case where dc="+dc+", cflag="+c_flag);
1635 BitVector data = new BitVector(37, "empty");
1636 BitVector addr = new BitVector(14, "empty");
1637 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1638 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1641 ? Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE
1642 : Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO;
1643 prln("setting addr["+whichbit+"] to "+(c_flag?"1":"0"));
1644 addr.set(whichbit, c_flag);
1646 prln("... and filling north fifo proper stopper");
1647 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
1649 prln("clearing flags");
1650 prln("executing recv data with Dc="+dc);
1651 prln("copying c-flag to a-flag");
1652 marina.fillSouthProperStopper(new Instruction[] {
1653 new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1654 new Instruction.Move(dock,
1655 Predicate.IgnoreFlagD, /* predicate */
1656 true, /* torpedoable */
1658 false, /* tokenIn */
1661 false, /* latchPath */
1662 false, /* dataOut */
1663 false /* tokenOut */
1666 new Instruction.Set(dock,Predicate.IgnoreFlagD,
1667 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagC),
1672 model.waitNS(CYCLE_TIME_NS * 64);
1674 prln("checking to confirm that A flag is " + c_flag);
1675 fatal(marina.getFlagA()!=c_flag, "bad A flag: "+marina.getFlagA());
1679 prln("End testFlagC");
1682 private void sendDataWithPath(Marina marina) {
1683 prln("Begin sendDataWithPath");
1686 edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
1687 marina.instrIn.fill(setIlc(1));
1689 // alternating ones and zeroes
1690 for(int i=0; i<bv.length(); i+=2)
1692 // and then ones in the lower four bits so it's not symmetric
1693 for(int i=0; i<4; i++)
1696 MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
1698 marina.fillSouthProperStopper(new Instruction[] {
1699 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1700 new Instruction.Move(dock,
1701 Predicate.IgnoreFlagD, /* predicate */
1702 false, /* torpedoable */
1704 false, /* tokenIn */
1706 false, /* latchData */
1707 false, /* latchPath */
1709 false /* tokenOut */
1713 List<BitVector> dataItems;
1716 dataItems = marina.data.drainMany();
1717 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1718 mp = new MarinaPacket(dataItems.get(0));
1720 // the 14th bit of the outbound address cannot be set by the
1721 // ship, so we don't care about it
1722 fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1724 prln("send data with no change to path");
1725 marina.instrIn.fill(new Instruction.Move(dock,
1726 Predicate.IgnoreFlagD, /* predicate */
1727 false, /* torpedoable */
1729 false, /* tokenIn */
1731 false, /* latchData */
1732 false, /* latchPath */
1734 false /* tokenOut */
1737 dataItems = marina.data.drainMany();
1738 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1739 mp = new MarinaPacket(dataItems.get(0));
1741 // the 14th bit of the outbound address cannot be set by the
1742 // ship, so we don't care about it
1743 fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1746 prln("End sendDataWithPath");
1749 private void recvPath(Marina marina) {
1750 prln("Begin recvPath");
1753 marina.instrIn.fill(setIlc(1));
1754 for(int bit=0; bit<11; bit++) {
1755 BitVector packet_data = new BitVector(37, "inbound data item");
1756 for(int i=0; i<37; i++) packet_data.set(i, false);
1757 packet_data.set(27+bit, true);
1758 BitVector packet_path = new BitVector(14, "inbound data item");
1759 for(int i=0; i<14; i++) packet_path.set(i, false);
1761 marina.fillNorthProperStopper(new MarinaPacket(packet_data, false, packet_path));
1763 prln("recv path, send data (using recv'd path)");
1764 marina.instrIn.fill(new Instruction.Move(dock,
1765 Predicate.IgnoreFlagD, /* predicate */
1766 false, /* torpedoable */
1768 false, /* tokenIn */
1770 true, /* latchData */
1771 true, /* latchPath */
1773 false /* tokenOut */
1776 List<BitVector> dataItems = marina.data.drainMany();
1777 fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1778 MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1780 fatalIfBitVectorsDoNotMatch(packet_data.get(25,11), mp.path.get(0,11));
1781 fatalIfBitVectorsDoNotMatch(packet_data, mp.data);
1785 prln("End recvPath");
1788 private void testILC(Marina marina) {
1789 prln("Begin testILC");
1792 for(int bit=0; bit<6; bit++) {
1793 int ilc = bit<0 ? 0 : (1<<bit);
1794 marina.fillSouthProperStopper(new Instruction[] {
1795 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,ilc),
1798 List<BitVector> dataItems = marina.data.drainMany();
1799 fatal(dataItems.size()!=ilc, "Expected "+ilc+" data item(s) to emerge but got: "+dataItems.size()+" data items");
1803 prln("End testILC");
1806 private void testILCZero(Marina marina) {
1808 marina.fillSouthProperStopper(new Instruction[] {
1809 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,0),
1813 expectNorthFifoNoMoreThan(0);
1814 expectTokensExactly(1);
1818 private void sendTorpedo(Marina marina) {
1819 prln("Begin sendTorpedo");
1821 marina.instrIn.fill(setIlc(1));
1822 marina.instrIn.fill(setOlc(63));
1824 model.waitNS(128 * CYCLE_TIME_NS);
1827 marina.instrIn.fill(new
1828 Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
1829 fatal(marina.getFlagA(), "bad A flag: true");
1830 fatal(marina.getFlagB(), "bad B flag: true");
1832 prln("execute a move instruction that does nothing but loops until torpedo arrives");
1833 prln("A=1, B=B This instruction should not execute because D-flag is set");
1834 prln("Set A=A, B=1 This instruction should execute because D-flag is set");
1836 model.waitNS(128 * CYCLE_TIME_NS);
1838 marina.fillSouthProperStopper(new Instruction[] {
1839 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity),
1840 new Instruction.Move(dock,
1841 Predicate.IgnoreFlagD, // predicate
1842 true, // torpedoable
1851 new Instruction.Set(dock,Predicate.Default,
1853 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB)
1855 new Instruction.Set(dock, Predicate.FlagD,
1856 Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA),
1861 model.waitNS(128 * CYCLE_TIME_NS);
1863 prln("send torpedo. This should clear the OLC");
1864 marina.instrIn.fillTorpedo();
1865 model.waitNS(128 * CYCLE_TIME_NS);
1867 model.waitNS(128 * CYCLE_TIME_NS);
1869 prln("A should remain false, B should be true");
1870 fatal(marina.getFlagA(), "bad A flag: true");
1871 fatal(!marina.getFlagB(), "bad B flag: false");
1873 model.waitNS(128 * CYCLE_TIME_NS);
1875 prln("Reload OLC after torpedo, clears D-flag");
1876 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
1878 // FIXME: find another way to test this
1879 model.waitNS(128 * CYCLE_TIME_NS);
1882 prln("Set A=1, B=1 This instruction should execute because OLC!=0");
1883 marina.instrIn.fill(new
1884 Instruction.Set(dock,Predicate.Default, SET_FLAG, SET_FLAG));
1886 prln("A and B should be true");
1887 fatal(!marina.getFlagA(), "bad A flag: false");
1888 fatal(!marina.getFlagB(), "bad B flag: false");
1891 prln("End sendTorpedo");
1894 private void testTorpedoOnAnInfinite(Marina marina) {
1895 prln("Begin testTorpedoOnAnInfinite");
1898 List<BitVector> dataItems;
1900 marina.instrIn.fill(setIlc(1));
1901 for(boolean torpedoable : new boolean[] { true, false }) {
1903 marina.fillSouthProperStopper(new Instruction[] {
1904 new Instruction.Move(dock,
1905 Predicate.IgnoreFlagD, // predicate
1906 false, // torpedoable
1915 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
1916 new Instruction.Move(dock,
1917 Predicate.IgnoreFlagD, // predicate
1918 torpedoable, // torpedoable
1927 // FIXME: this probably should be removed, unless Ivan doesn't want to change the behavior
1928 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1933 // expect nothing to come out, because the NOP is executing
1934 dataItems = marina.data.drainMany(2);
1935 fatal(dataItems.size()!=0, "Expected no data item(s) to emerge but got at least: "+dataItems.size()+" data items");
1937 marina.instrIn.fillTorpedo();
1939 int expected = torpedoable?1:0;
1940 dataItems = marina.data.drainMany(2);
1941 fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
1943 fatal(!marina.getILC().getDone(), "Expected ilc=done, but got "+marina.getILC());
1947 prln("End testTorpedoOnAnInfinite");
1950 private void testDFlagWhenTorpedoLyingInWait(Marina marina) {
1951 marina.fillSouthProperStopper(new Instruction[] {
1953 TORPEDOABLE_RECV_DATA,
1954 marina.kesselsCounter ? null : FLAG_NOP,
1957 marina.instrIn.fillTorpedo();
1958 model.waitNS(64 * CYCLE_TIME_NS);
1959 marina.fillNorthProperStopper();
1960 model.waitNS(64 * CYCLE_TIME_NS);
1961 expectNorthFifoExactly(1);
1964 private void testSetOlcFollowedByDPredicated(Marina marina) {
1965 for(boolean d_set : new boolean[] { false, true }) {
1967 marina.fillSouthProperStopper(new Instruction[] {
1969 marina.kesselsCounter ? null : FLAG_NOP,
1970 d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
1972 expectNorthFifoExactly(d_set ? 1 : 0);
1975 marina.fillSouthProperStopper(new Instruction[] {
1977 marina.kesselsCounter ? null : FLAG_NOP,
1978 d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
1980 expectNorthFifoExactly(d_set ? 0 : 1);
1982 if (marina.kesselsCounter) {
1983 marina.masterClear();
1984 marina.enableInstructionSend(true);
1989 private void testOlcDecrementAtHighSpeed(Marina marina) {
1990 prln("Begin testOlcDecrementAtHighSpeed");
1993 List<BitVector> dataItems;
1995 // Each element of the following pair of arrays is one "test".
1996 // The OLC will be loaded with olcs[i] and then decremented
1997 // decr_amounts[i] times; after that has happened the zeroness
1998 // of the OLC will be checked by executing a MOVE with
1999 // [olc!=0] as the predicate.
2001 int[] olcs = new int[] { 3, 3, 3, 10, 41 };
2002 int[] decr_amounts = new int[] { 2, 3, 4, 9, 9 };
2004 for(int which=0; which<olcs.length; which++) {
2005 int olc = olcs[which];
2006 int decr_amount = decr_amounts[which];
2008 prln("inserting set olc="+olc);
2009 prln("inserting set ilc=1");
2010 marina.fillSouthProperStopper(new Instruction[] {
2011 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
2012 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,olc),
2015 // commenting the following four lines causes this test to pass
2017 prln("inserting: "+decr_amount+" olc-- instructions");
2018 prln("inserting: [!d] send data");
2019 Instruction[] instructions = new Instruction[decr_amount+1];
2020 for(int i=0; i<decr_amount; i++)
2022 new Instruction.Set(dock,
2024 SetDest.OuterLoopCounter,
2025 SetSource.Decrement);
2026 instructions[instructions.length-1] =
2027 new Instruction.Move(dock,
2028 Predicate.Default, // predicate
2029 false, // torpedoable
2039 marina.fillSouthProperStopper(instructions);
2040 model.waitNS(64 * CYCLE_TIME_NS);
2042 int expected = decr_amount>=olc ? 0 : 1;
2043 dataItems = marina.data.drainMany(2);
2044 fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
2046 if (marina.kesselsCounter) {
2047 // master clear on each iteration; otherwise we'd need to "run down" the olc
2048 marina.masterClear();
2049 marina.enableInstructionSend(true);
2054 prln("End testOlcDecrementAtHighSpeed");
2057 private void flipIlcBit(Marina marina) {
2058 prln("Begin flipIlcBit");
2060 prln("Using the set ILC instruction, toggle a single bit between zero and one. \n" +
2061 "Check correct setting of the ILC zero bit");
2063 for (int i=0; i<6; i++) {
2066 prln("Then immediately set ILC="+notZero);
2067 marina.fillSouthProperStopper(new Instruction[] {
2068 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
2069 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
2072 model.waitNS(64 * CYCLE_TIME_NS);
2074 prln("Verify ILC using scan chain");
2075 Ilc ilc = marina.getILC();
2076 int ilcCount = ilc.getCount();
2077 fatal(ilcCount!=notZero, "bad ILC count: "+ilcCount+" expected: "+notZero);
2078 fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
2080 marina.fillSouthProperStopper(new Instruction[] {
2081 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
2082 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
2085 model.waitNS(64 * CYCLE_TIME_NS);
2087 prln("Verify ILC using scan chain");
2088 ilc = marina.getILC();
2089 ilcCount = ilc.getCount();
2090 fatal(ilcCount!=0, "bad ILC count: "+ilcCount+" expected: 0");
2091 fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
2095 prln("End flipIlcBit");
2097 private void flipOlcBit(Marina marina) {
2098 prln("Begin flipOlcBit");
2100 prln("Using the set OLC instruction, toggle a single bit between zero and one. \n" +
2101 "Check correct setting of the OLC zero bit");
2103 marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
2105 for (int i=0; i<6; i++) {
2106 int notZero = 32 >> i;
2108 if (marina.kesselsCounter) {
2109 // master clear on each iteration; otherwise we'd need to "run down" the olc
2110 marina.masterClear();
2111 marina.enableInstructionSend(true);
2116 prln("Then immediately set OLC="+notZero);
2117 marina.fillSouthProperStopper(new Instruction[] {
2118 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
2119 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
2122 model.waitNS(64 * CYCLE_TIME_NS);
2123 prln("Verify OLC count using scan chain");
2126 if (!marina.kesselsCounter) {
2127 prln("Set OLC="+notZero);
2128 prln("Then immediately set OLC=0");
2129 marina.fillSouthProperStopper(new Instruction[] {
2130 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
2131 new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
2134 model.waitNS(64 * CYCLE_TIME_NS);
2135 prln("Verify OLC count using scan chain");
2141 prln("End flipOlcBit");
2143 private void testSouthRecirculate(Marina marina, int AMOUNT) {
2144 prln("Begin testSouthRecirculate("+AMOUNT+")");
2147 marina.enableInstructionSend(false);
2148 marina.enableInstructionRecirculate(true);
2150 prln("Completely fill south ring");
2152 for (int i=0; i<AMOUNT; i++) {
2153 prln("inserting item " + (i+1) + " / " + AMOUNT);
2154 BitVector path = new BitVector(MarinaPacket.PATH_WIDTH, "path");
2155 BitVector data = new BitVector(MarinaPacket.WORD_WIDTH, "path");
2156 path.set(0, MarinaPacket.PATH_WIDTH, false);
2157 data.setFromLong(i+9);
2158 marina.instrIn.fill(new MarinaPacket(data, false, path));
2162 prln("Drain south ring and check contents");
2164 List<BitVector> out = marina.instrIn.drainMany();
2165 boolean bad = false;
2166 for (int i=0; i<AMOUNT; i++) {
2167 prln("extracting item " + (i+1) + " / " + AMOUNT);
2168 //int expect = (i+Marina.SOUTH_RING_CAPACITY-1) % Marina.SOUTH_RING_CAPACITY;
2170 long got = new MarinaPacket(out.get(i)).data.toLong();
2173 prln(" bad instruction: "+got+" expected: "+expect);
2175 prln(" good instruction.");
2178 fatal(bad, "data inserted does not match data retrieved");
2181 for (int i=0; i<5; i++) {}
2184 prln("End testSouthRecirculate("+AMOUNT+")");
2188 private void testOverfillTokens(Marina marina) {
2189 prln("Begin testOverfillTokens");
2192 for(int i=0; i<marina.TOKEN_FIFO_CAPACITY + 3; i++)
2193 marina.instrIn.fill(SEND_TOKEN);
2194 marina.instrIn.fill(SEND_DATA);
2195 expectNorthFifoExactly(0);
2198 prln("End testSouthRecirculate");
2203 private void doOneTest(int testNum) {
2205 prln("============================================================");
2206 prln("MarinaTest: performing test: "+testNum);
2209 marina.masterClear();
2210 marina.enableInstructionSend(true);
2217 doOneTest(1); // passes extracted parasitics
2218 doOneTest(2); // passes extracted parasitics
2219 doOneTest(3); // passes extracted parasitics
2220 doOneTest(4); // passes extracted parasitics
2221 doOneTest(5); // passes extracted parasitics
2224 doOneTest(1000); // passes extracted parasitics
2225 doOneTest(1001); // passes extracted parasitics
2226 doOneTest(1003); // passes extracted parasitics
2228 doOneTest(3000); // passes extracted parasitics
2229 doOneTest(3001); // passes extracted parasitics
2230 doOneTest(3003); // passes extracted parasitics
2231 doOneTest(3004); // passes extracted parasitics
2232 doOneTest(3005); // passes extracted parasitics
2233 doOneTest(3006); // passes extracted parasitics
2234 doOneTest(3007); // passes extracted parasitics
2235 doOneTest(3008); // passes extracted parasitics
2236 doOneTest(3009); // passes extracted parasitics
2237 doOneTest(3010); // passes extracted parasitics
2238 doOneTest(3011); // passes extracted parasitics
2239 doOneTest(3012); // passes extracted parasitics
2240 doOneTest(3013); // passes extracted parasitics
2241 doOneTest(3014); // passes extracted parasitics
2242 doOneTest(3015); // passes extracted parasitics
2243 doOneTest(3019); // passes extracted parasitics
2244 doOneTest(3020); // passes extracted parasitics
2245 doOneTest(3022); // passes extracted parasitics
2246 doOneTest(3023); // passes extracted parasitics
2247 doOneTest(3025); // passes extracted parasitics
2248 doOneTest(3026); // passes extracted parasitics
2249 doOneTest(3027); // passes extracted parasitics
2250 doOneTest(3028); // passes extracted parasitics
2251 doOneTest(3029); // passes extracted parasitics
2252 doOneTest(3030); // passes extracted parasitics
2253 doOneTest(3031); // passes extracted parasitics
2255 // these tests take a while and usually pass
2267 // this takes an insanely long time
2271 case 1: testChains(marina); break; // passes, 24-Mar (+verilog)
2272 case 2: testProperStoppers(marina); break; // passes, 24-Mar (+verilog)
2273 case 3: testSouthRecirculate(marina, 1); break; // passes, 24-Mar (+verilog)
2274 case 4: getCtrsFlags(marina); break; // 20-Apr (+verilog)
2275 case 5: sendInstructions(marina); break; // passes, 24-Mar (+verilog)
2276 case 6: walkOneOLC(marina); break; // 21-Apr (+verilog)
2278 // Russell's tests begin with 1000
2279 case 1000: walkOneILC(marina); break; // 20-Apr (+verilog)
2280 case 1001: countIlc(marina); break; // 20-Apr (+verilog)
2281 case 1002: countOlc(marina); break; // 23-Apr (+verilog)
2283 case 1003: sendTorpedo(marina); break; // 23-Apr (+verilog) [with wor-hack]
2285 case 1004: flipIlcBit(marina); break; // 20-Apr (+verilog)
2286 case 1005: flipOlcBit(marina); break; // 21-Apr (+verilog)
2288 case 1006: testSouthRecirculate(marina, Marina.SOUTH_RING_CAPACITY-1); break; // passes, 24-Mar (+verilog)
2290 // Adam's tests begin with 3000
2291 case 3000: sendToken(marina); break; // passes, 24-Mar (+verilog)
2292 case 3001: testFlagAB(marina); break; // passes, 08-Apr (+verilog)
2293 case 3002: testPredicationOnAB(marina); break; // 22-Apr (+verilog)
2294 case 3003: testFlagC(marina); break; // 23-Apr (+verilog)
2295 case 3004: testFlagD(marina); break; // 23-Apr (+verilog)
2296 case 3005: testFlagDRecomputationTime(marina); break;
2298 case 3006: testTailWaitsForHead(marina); break;
2299 case 3007: testTailWithoutHead(marina); break;
2300 case 3008: testHeadWaitsForTail(marina); break; // 22-Apr (+verilog)
2301 case 3009: testAbort(marina); break; // 22-Apr (+verilog)
2303 case 3010: sendData(marina); break; // passes, 24-Mar (+verilog)
2304 case 3011: recvData(marina); break; // 21-Apr (+verilog)
2305 case 3012: sendDataWithPath(marina); break; // passes, 13-Apr (+verilog)
2307 case 3013: testSignExtendedLiteral(marina); break; // 20-Apr (+verilog)
2308 case 3014: testShiftedLiteral(marina); break; // 20-Apr (+verilog)
2309 case 3015: testSendAndRecvToken(marina); break; // 21-Apr (+verilog)
2311 case 3016: sendDataIlcInfinite(marina); break; // 22-Apr (+verilog)
2312 case 3017: testFlagTruthTable(marina); break; // 23-Apr (+verilog)
2314 case 3019: setOlcFromDataLatch(marina); break; // 23-Apr (+verilog)
2315 case 3020: setIlcFromDataLatch(marina); break; // 23-Apr (+verilog)
2316 case 3021: recvPath(marina); break; // 22-Apr (+verilog)
2317 case 3022: testILC(marina); break; // 23-Apr (+verilog)
2318 case 3023: testTorpedoOnAnInfinite(marina); break; // 23-Apr (+verilog)
2319 case 3024: testRecvAndSendWalkingOne(marina); break; // 21-Apr (+verilog)
2320 case 3025: testOlcDecrementAtHighSpeed(marina); break; // 23-Apr (+verilog)
2322 case 3026: testNonTorpedoableMoveDoesNotResetDFlag(marina); break; // 23-Apr (+verilog)
2323 case 3027: testILCZero(marina); break;
2324 case 3028: testAbortOutsideOfLoop(marina); break;
2325 case 3029: testDFlagWhenTorpedoLyingInWait(marina); break;
2326 case 3030: testSetOlcFollowedByDPredicated(marina); break;
2327 case 3031: testOverfillTokens(marina); break;
2329 case 3040: loadEveryValueOLC(marina); break;
2332 fatal(true, "Test number: "+testNum+" doesn't exist.");
2335 // If we get here then test passed
2336 prln("Test Result: Passed");
2338 //Infrastructure.exit(0);
2339 } catch (MarinaUtils.FailureException fe) {
2340 System.out.println("******************************************************************************");
2341 System.out.println("******************************************************************************");
2342 System.out.println("******************************************************************************");
2343 System.out.println("******************************************************************************");
2344 fe.printStackTrace();
2349 //============================ for public use =============================
2352 * 0: test detected success
2353 * 2: test detected failure
2356 public static void main(String[] args) {
2357 startTime = System.currentTimeMillis();
2358 new MarinaTest(args);