src/edu/berkeley/fleet/marina/MarinaTest.java

   1 package edu.berkeley.fleet.marina;
   2 import java.util.*;
   3 import com.sun.electric.tool.simulation.test.*;
   4 import edu.berkeley.fleet.marina.CmdArgs;
   5 import edu.berkeley.fleet.marina.CmdArgs.Mode;
   6 import edu.berkeley.fleet.api.Dock;
   7 import edu.berkeley.fleet.api.Instruction;
   8 import edu.berkeley.fleet.api.Predicate;
   9 import edu.berkeley.fleet.api.Instruction.Set.SetDest;
  10 import edu.berkeley.fleet.api.Instruction.Set.SetSource;
  11 import java.io.*;
  12
  13 /**
  14  * Tests for Marina
  15  */
  16 public class MarinaTest {
  17
  18     private static Marina marina;
  19     private MarinaTest(Marina marina) throws Exception {
  20         this.marina = marina;
  21         go("marina.spi");
  22     }
  23
  24     private void go(String netListName) throws Exception {
  25         if (model instanceof NanosimModel) {
  26             NanosimLogicSettable mc = (NanosimLogicSettable)
  27                 ((SimulationModel)model).createLogicSettable(Marina.MASTER_CLEAR);
  28             mc.setInitState(true);
  29         }
  30
  31         prln("starting model");
  32         if (model instanceof VerilogModel)
  33             ((SimulationModel)model).start("verilog", "marina.v", VerilogModel.DUMPVARS, !cmdArgs.jtagShift);
  34         else if (model instanceof HsimModel)
  35             ((SimulationModel)model).start("hsim64", netListName, 0, !cmdArgs.jtagShift);
  36         else if (model instanceof NanosimModel)
  37             ((SimulationModel)model).start("nanosim -c cfg", netListName, 0, !cmdArgs.jtagShift);
  38         else
  39             {}
  40         prln("model started");
  41
  42         model.waitNS(1000);
  43         prln("deasserting master clear");
  44         if (model instanceof SimulationModel)
  45             ((SimulationModel)model).setNodeState(Marina.MASTER_CLEAR, 0);
  46         else
  47             marina.masterClear();
  48         model.waitNS(1000);
  49
  50         if (cmdArgs.testNum!=0 && cmdArgs.testNum!=1) {
  51             cc.resetInBits();
  52             cc.shift(Marina.CONTROL_CHAIN, false, true);
  53         }
  54
  55         doOneTest(cmdArgs.testNum);
  56
  57         if (model instanceof SimulationModel)
  58             ((SimulationModel)model).finish();
  59     }
  60
  61     public static float vdd = 1.0f;
  62
  63     //--------------------------  constants -----------------------------------
  64     private static final String SCAN_CHAIN_XML = "marina.xml";
  65
  66     public static final int INSTR_SZ = 36;
  67
  68
  69     public final Instruction.Set.FlagFunction CLEAR_FLAG
  70         = Instruction.Set.FlagFunction.ZERO;
  71     public final Instruction.Set.FlagFunction SET_FLAG
  72         = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA)
  73         .add(Predicate.NotFlagA);
  74     public final Instruction.Set.FlagFunction A_FLAG
  75         = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA);
  76
  77     public final Instruction.Set.FlagFunction B_FLAG
  78         = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB);
  79
  80     // COLUMN_LATENCY is a delay that is larger than the latency through an Infinity column
  81     private static final int COLUMN_LATENCY = 10; // nanoseconds
  82
  83
  84     // Officially, this should be the number of requeueing no-ops that
  85     // can be inserted into an idle dock whose OLC is nonzero.
  86     //
  87     // Less formally, this is roughly the number of stages of
  88     // buffering between the instruction insertion point and the
  89     // instruction ring, plus the capacity of the instruction ring.
  90     private static final int INSTRUCTION_IN_SATURATION_AMOUNT = 19;
  91
  92     // This is some number which is significantly greater than
  93     // INSTRUCTION_IN_SATURATION_AMOUNT.  Increasing it may slow the tests down, but
  94     // will never cause them to operate incorrectly.
  95     private static final int MORE_THAN_INSTRUCTION_IN_SATURATION_AMOUNT = 25;
  96
  97     // This is the number of items which can be in the instruction
  98     // fifo ring WITHOUT causing it to stop circulating.
  99     private static final int INSTRUCTION_RING_CAPACITY = 13;
 100
 101     // Officially, this should be the number of data items which can
 102     // be sent from the dock while the "data" proper stopper is in
 103     // the "stopped" state
 104     //
 105     // Less formally, this is roughly the number of stages of
 106     // buffering between the dock's data successor and the "data"
 107     // proper stopper
 108     /*
 109       FIXME: what is the correct value here?
 110       private static final int DATA_OUT_SATURATION_AMOUNT = XXX;
 111     */
 112
 113     // This is some number which is greater than
 114     // DATA_OUT_SATURATION_AMOUNT, but less than the capacity of the
 115     // instruction fifo.
 116     private static final int MORE_THAN_DATA_OUT_SATURATION_AMOUNT = 10;
 117
 118     // Nominal cycle time assuming 4 GHz throughput
 119     public static double CYCLE_TIME_NS;
 120
 121     //--------------------------------  types ---------------------------------
 122
 123     //--------------------------  private data --------------------------------
 124     private static long startTime;
 125
 126     public static Indenter indenter = new Indenter();
 127     private static ChipModel model;
 128     //private ChainControl cc;
 129     //private JtagTester tester;
 130     private static CmdArgs cmdArgs;
 131     private PowerChannel corePowerSupply, padsPowerSupply;
 132     private VoltageReadable coreVoltmeter, voltmeterForCurrent;
 133
 134
 135
 136     private static ChainTest ctD, ctR, ctC, ct;
 137     private static ChainControl ccD, ccR, ccC, cc;
 138
 139     //--------------------------  private methods -----------------------------
 140     /** @return true if simulation. Return false if we're testing silicon. */
 141     private boolean sim() {return model instanceof SimulationModel;}
 142
 143     private void prln(String msg) {indenter.prln(msg);}
 144     private void pr(String msg) {indenter.pr(msg);}
 145     private void adjustIndent(int n) {indenter.adjustIndent(n);}
 146
 147     public static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
 148
 149     public static void fatalIfBitVectorsDoNotMatch(BitVector bv1, BitVector bv2) {
 150         // FIXME: better error reporting needed here
 151
 152         fatal(bv1.getNumBits()!=bv2.getNumBits(), "lengths do not match");
 153
 154         boolean mismatch = false;
 155         String err = "";
 156         for(int i=0; i<bv1.getNumBits(); i++) {
 157             if (bv1.get(i) != bv2.get(i)) {
 158                 mismatch = true;
 159                 err += ""+i+", ";
 160             }
 161         }
 162         fatal(mismatch, "bit vectors do not match on bits " + err + "\n  "+bv1+"\n  "+bv2);
 163     }
 164
 165     private static void printTestTime() {
 166         long endTime = System.currentTimeMillis();
 167         System.out.println("Test took: "+(endTime-startTime)/1000.0+"  sec");
 168     }
 169
 170     // Tell user what we're about to do
 171     private static void reportTask(CmdArgs args) {
 172         System.out.println("Begin testing Marina");
 173         switch (args.mode) {
 174             case WHOLE_CHIP_SCHEMATIC_PARASITICS:
 175                 System.out.println("  Simulate whole chip, schematic parasitics");
 176                 break;
 177             case WHOLE_CHIP_LAYOUT_PARASITICS:
 178                 System.out.println("  Simulate whole chip, layout parasitics");
 179                 break;
 180             case TEST_SILICON:
 181                 System.out.println("  Test silicon");
 182                 break;
 183             default:
 184                 fatal(true, "unrecognized CmdArgs.Mode");
 185                 return;
 186         }
 187     }
 188
 189
 190     static PowerChannel vdd18;
 191     static PowerChannel vdd10;
 192     static PowerChannel vdds;
 193
 194     private static void setVdd10(float v) {
 195         if (vdd10==null) return;
 196         vdd10.setVoltageWait(v);
 197     }
 198
 199
 200     /** In the absence of looping, the longest path through Infinity is 4 column delays */
 201     private void waitUntilQuiescent() {
 202         model.waitNS(4*COLUMN_LATENCY);
 203     }
 204
 205
 206     /** Generate List of BitVectors where Token=true, high 25 data bits
 207      * are alternating ones and zeros, low 12 data bits increment from
 208      * zero, and address is given by addr. */
 209     private List<BitVector> makeIncrDataConstAdr(int num, int addr) {
 210         List<BitVector> ans = new ArrayList<BitVector>();
 211         BitVector dHi = new BitVector(25, "dataHi");
 212         BitVector dLo = new BitVector(12, "dataLo");
 213         BitVector t = new BitVector("1", "token");
 214         BitVector a = new BitVector(14, "addr");
 215         dHi.setFromLong(0x00aaaaa);
 216         a.setFromLong(addr);
 217         for (int i=0; i<num; i++) {
 218             dLo.setFromLong(i);
 219             ans.add(dHi.cat(dLo).cat(t).cat(a));
 220             dHi = dHi.not();
 221         }
 222         return ans;
 223     }
 224     private void stopToStop(ProperStopper s1, ProperStopper s2,
 225                             List<BitVector> din) {
 226         prln("Begin stopToStop");
 227         adjustIndent(2);
 228
 229         s1.stop();
 230
 231         long ctrStart = 0;
 232
 233         s1.fillMany(din);
 234         waitUntilQuiescent();
 235
 236         List<BitVector> dout = s2.drainMany();
 237
 238         MarinaUtils.compareItemsOrdered(din, dout);
 239
 240         adjustIndent(-2);
 241         prln("End stopToStop");
 242     }
 243     /** Burst data from src to dst. gate is stopped while loading src. gate
 244      * is then run to allow the burst to flow. */
 245     private void stopToStopBurst(ProperStopper src, ProperStopper gate,
 246                                  ProperStopper dst,
 247                                  List<BitVector> din) {
 248         prln("Begin stopToStopBurst test");
 249         adjustIndent(2);
 250
 251         src.stop();
 252         gate.stop();
 253
 254         long ctrStart = 0;
 255
 256         src.fillMany(din);
 257         waitUntilQuiescent();
 258
 259         // open the gate to start the burst
 260         gate.run();
 261         waitUntilQuiescent();
 262
 263         List<BitVector> dout = dst.drainMany();
 264
 265         MarinaUtils.compareItemsOrdered(din, dout);
 266
 267         adjustIndent(-2);
 268         prln("End stopToStopBurst test");
 269     }
 270
 271     private void stopToStopOne(ProperStopper s1, ProperStopper s2,
 272                                int adr) {
 273         prln("Begin stopToStopOne");
 274         adjustIndent(2);
 275
 276         List<BitVector> din = makeIncrDataConstAdr(1, adr);
 277         stopToStop(s1, s2, din);
 278
 279         adjustIndent(-2);
 280         prln("End stopToStopOne");
 281     }
 282
 283     private void stopToStopThree(ProperStopper s1, ProperStopper s2,
 284                                  int adr) {
 285         prln("Begin stopToStopOne");
 286         adjustIndent(2);
 287
 288         List<BitVector> din = makeIncrDataConstAdr(3, adr);
 289         stopToStop(s1, s2, din);
 290
 291         adjustIndent(-2);
 292         prln("End stopToStopOne");
 293     }
 294
 295     private int indexOf(BitVector o, List<BitVector> dIn) {
 296         for (int i=0; i<dIn.size(); i++) {
 297             if (o.equals(dIn.get(i)))  return i;
 298         }
 299         return -1;
 300     }
 301     private String ringDump(List<BitVector> dIn, List<BitVector> dOut) {
 302         StringBuffer sb = new StringBuffer();
 303         sb.append("  ring dump: ");
 304         for (BitVector o : dOut) {
 305             sb.append(indexOf(o, dIn)+" ");
 306         }
 307         return sb.toString();
 308     }
 309
 310     private int[][] makeIntArray2D(int a, int b) {
 311         int[][] ans = new int[a][];
 312         for (int i=0; i<a; i++) ans[i] = new int[b];
 313         return ans;
 314     }
 315
 316     //=========================================================================
 317     // Put top level tests here
 318
 319     private void testChains(Marina marina) {
 320         if (ctC!=null) {
 321             prln("Testing control chain...");
 322             ctC.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
 323             ccC.resetInBits();
 324             ccC.shift(Marina.CONTROL_CHAIN, false, true);
 325         }
 326
 327         if (ctD!=null) {
 328             prln("Testing data chain...");
 329             ctD.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
 330             //ccD.resetInBits();
 331             //ccD.shift(Marina.DATA_CHAIN, false, true);
 332         }
 333
 334         if (ctR!=null) {
 335             prln("Testing report chain...");
 336             ctR.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
 337             //ccR.resetInBits();
 338             //ccR.shift(Marina.REPORT_CHAIN, false, true);
 339         }
 340
 341         if (ct!=null) {
 342             prln("Testing control chain...");
 343             ct.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
 344             cc.resetInBits();
 345             cc.shift(Marina.CONTROL_CHAIN, false, true);
 346             prln("Testing data chain...");
 347             ct.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
 348             prln("Testing report chain...");
 349             ct.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
 350         }
 351     }
 352
 353     private void testProperStoppers(Marina marina) {
 354         prln("Begin testProperStoppers");
 355         adjustIndent(2);
 356
 357         for(ProperStopper ps : new ProperStopper[] { marina.northRing, marina.southRing }) {
 358
 359             prln("testing " + (ps == marina.northRing ? "data" : "instruction") + " stopper");
 360             adjustIndent(2);
 361
 362             prln("un-stopping stopper");
 363             ps.run();
 364             fatal( ps.getStopped(), "stopper should not have been stopped, but was");
 365
 366             prln("stopping stopper");
 367             ps.stop();
 368             fatal( !ps.getStopped(), "stopper should have been stopped, but was not");
 369
 370             adjustIndent(-2);
 371         }
 372
 373         adjustIndent(-2);
 374     }
 375
 376     private void sendInstructions(Marina marina) {
 377         prln("Begin sendInstructions");
 378         adjustIndent(2);
 379
 380         List<BitVector> din = new ArrayList<BitVector>();
 381
 382         BitVector count = new BitVector(MarinaPacket.WORD_WIDTH,"count");
 383         BitVector one = new BitVector(MarinaPacket.WORD_WIDTH, "one");
 384         count.setFromLong(0);
 385         one.setFromLong(1);
 386         for (int i=0; i<3; i++) {
 387             din.add(count);
 388             count = count.add(one);
 389         }
 390
 391         for(BitVector d : din)
 392             marina.southRing.fill(new MarinaPacket(d, false, MarinaPacket.null_path));
 393
 394         adjustIndent(-2);
 395         prln("End sendInstructions");
 396     }
 397
 398     private void sendToken(Marina marina) {
 399         prln("Begin sendToken");
 400         adjustIndent(2);
 401
 402         //getCtrsFlags(marina);
 403
 404         int nbToks = marina.getNumTokens();
 405         fatal(nbToks!=0, "Expected no tokens on initialization but got: "+nbToks+" tokens");
 406
 407         marina.southRing.fill(setIlc(1));
 408         marina.southRing.fill(SEND_TOKEN);
 409         nbToks = marina.getNumTokens();
 410         fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
 411
 412         adjustIndent(-2);
 413         prln("End sendToken");
 414     }
 415
 416     private void sendData(Marina marina) {
 417         prln("Begin sendData");
 418         adjustIndent(2);
 419
 420         edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
 421         for(int i=0; i<bv.length(); i+=2) bv.set(i, false);
 422         MarinaPath path = new MarinaPath(marina, bv);
 423
 424         marina.southRing.fill(setIlc(1));
 425         marina.southRing.fill(SEND_DATA);
 426
 427         List<BitVector> dataItems = marina.northRing.drainMany();
 428         fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
 429
 430         MarinaPacket mp = new MarinaPacket(dataItems.get(0));
 431         fatal(mp.tokenhood, "Expected tokenhood=data, but got tokenhood=token");
 432
 433         adjustIndent(-2);
 434         prln("End sendData");
 435     }
 436
 437     private void sendDataIlcInfinite(Marina marina) {
 438         prln("Begin sendDataIlcInfinite");
 439         adjustIndent(2);
 440
 441         marina.southRing.fill(new Instruction[] {
 442                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
 443                 SEND_DATA,
 444             });
 445
 446         // more than MAX_ILC
 447         int howmany = 70;
 448         List<BitVector> dataItems = marina.northRing.drainMany(howmany);
 449         fatal(dataItems.size()!=howmany,
 450               "Expected an unending supply of data items to emerge but only got got: "+dataItems.size());
 451
 452         adjustIndent(-2);
 453         prln("End sendDataIlcInfinite");
 454     }
 455
 456     private Instruction setOlc(int olc) {
 457         return new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, olc);
 458     }
 459     private Instruction setOlcIfZero(int olc) {
 460         return new Instruction.Set(marina.getOnlyDock(),Predicate.Default,SetDest.OuterLoopCounter, olc);
 461     }
 462     private Instruction setIlc(int ilc) {
 463         return new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, ilc);
 464     }
 465
 466     private void testFlagD(Marina marina) {
 467         prln("Begin testFlagD");
 468         adjustIndent(2);
 469
 470         List<BitVector> toks;
 471
 472         Predicate only_if_olc_zero    = Predicate.FlagD;
 473         Predicate only_if_olc_nonzero = Predicate.Default;
 474
 475         marina.southRing.fill(setIlc(1));
 476
 477         for(int olc : new int[] { 1, 0 }) {
 478             for(boolean predicate_olc_nonzero : new boolean[] { true, false }) {
 479                 prln("Attempting send data item with "+
 480                      "olc=="+olc+" and "+
 481                      "predicate olc"+(predicate_olc_nonzero?"!=0":"==0"));
 482                 adjustIndent(2);
 483
 484                 marina.southRing.fill(new Instruction[] {
 485                         setOlc(olc),
 486                         new Instruction.Move(marina.getOnlyDock(),
 487                                              predicate_olc_nonzero  // predicate
 488                                              ? only_if_olc_nonzero
 489                                              : only_if_olc_zero
 490                                              ,
 491                                              false,                 // torpedoable
 492                                              null,                  // path
 493                                              false,                 // tokenIn
 494                                              false,                 // dataIn
 495                                              false,                 // latchData
 496                                              false,                 // latchPath
 497                                              true,                  // dataOut
 498                                              false                  // tokenOut
 499                                              ),
 500                     });
 501                 expectNorthFifoExactly((predicate_olc_nonzero == (olc!=0)) ? 1 : 0);
 502
 503                 for(int i=0; i<olc; i++)
 504                     marina.southRing.fill(DEC);
 505
 506                 adjustIndent(-2);
 507             }
 508         }
 509         adjustIndent(-2);
 510         prln("End testFlagD");
 511     }
 512
 513     private void testPredicationOnAB(Marina marina) {
 514         prln("Begin testPredicationOnAB");
 515         adjustIndent(2);
 516
 517         List<BitVector> dItems;
 518
 519         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 1));
 520         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
 521
 522         for(boolean flag_a : new boolean[] { false, true }) {
 523             for(boolean flag_b : new boolean[] { false, true }) {
 524                 prln("Setting flags, a="+flag_a+" b="+flag_b);
 525                 marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
 526                                                         flag_a
 527                                                         ? Instruction.Set.FlagFunction.ONE
 528                                                         : Instruction.Set.FlagFunction.ZERO,
 529                                                         flag_b
 530                                                         ? Instruction.Set.FlagFunction.ONE
 531                                                         : Instruction.Set.FlagFunction.ZERO
 532                                                         ));
 533                 getCtrsFlags(marina);
 534
 535                 adjustIndent(2);
 536                 for(Predicate predicate : new Predicate[] {
 537                         Predicate.Default,
 538                         Predicate.FlagA,
 539                         Predicate.FlagB,
 540                         Predicate.NotFlagA,
 541                         Predicate.NotFlagB,
 542                     }) {
 543
 544                     prln("Attempting send data with a="+flag_a+", b="+flag_b+", predicate="+predicate);
 545                     adjustIndent(2);
 546                     marina.southRing.fill(new Instruction.Move(marina.getOnlyDock(),
 547                                                              predicate,  // predicate
 548                                                              false,      // torpedoable
 549                                                              null,       // path
 550                                                              false,      // tokenIn
 551                                                              false,      // dataIn
 552                                                              false,      // latchData
 553                                                              false,      // latchPath
 554                                                              true,       // dataOut
 555                                                              false       // tokenOut
 556                                                              ));
 557                     adjustIndent(-2);
 558                     dItems = marina.northRing.drainMany();
 559                     int expected = predicate.evaluate(flag_a, flag_b, false, false) ? 1 : 0;
 560                     fatal(dItems.size()!=expected, "Expected "+expected+" data items to emerge but got: "+
 561                           dItems.size()+" items(s)");
 562                 }
 563                 adjustIndent(-2);
 564             }
 565         }
 566         adjustIndent(-2);
 567         prln("End testPredicationOnAB");
 568     }
 569
 570
 571     private void showOlc() {
 572         prln("OLC=="+marina.getOLC());
 573     }
 574     private void expectOlc(int x) {
 575         int olc = marina.getOLC();
 576         fatal(x!=olc, "expected OLC=="+x+", but scanned out OLC=="+olc);
 577     }
 578
 579     private void getCtrsFlags(Marina marina) {
 580         prln("begin getCtrsFlags");
 581         adjustIndent(2);
 582
 583         showOlc();
 584         prln("ILC.done=="+marina.getILCDone()+
 585              " ILC.infinity=="+marina.getILCInfinity()+
 586              " ILC.count=="+marina.getILC());
 587         prln("flagA=="+marina.getFlagA());
 588         prln("flagB=="+marina.getFlagB());
 589         adjustIndent(-2);
 590         prln("end getCtrsFlags");
 591     }
 592
 593     private void walkOneOLC(Marina marina) {
 594         prln("Begin walkOneOLC");
 595         /*
 596         adjustIndent(2);
 597         //for (int i=-1; i<6; i++) {
 598         marina.southRing.fill(new Instruction[] {
 599
 600         new Instruction.Head(marina.getOnlyDock()),
 601
 602         //                new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, SetDest.OuterLoopCounter, 1),
 603         FLAG_NOP,
 604         FLAG_NOP,
 605         FLAG_NOP,
 606         TORPEDOABLE_RECV_DATA,
 607         FLAG_NOP,
 608         FLAG_NOP,
 609         FLAG_NOP,
 610
 611
 612         //new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, SetSource.Decrement),
 613
 614         new Instruction.Tail(marina.getOnlyDock()),
 615         });
 616         marina.southRing.fill(new Instruction[] {
 617         null,
 618         },
 619         true);
 620         while(true) {
 621         BitVector bits = null;
 622         marina.shiftReport(true, false);
 623         for(int i=0; i<4; i++) {
 624         BitVector x = marina.cc.getOutBits(marina.REPORT_CHAIN+"."+marina.OLC_PATH_KESSEL+i);
 625         //System.out.println("bits are: " + x);
 626         bits = bits==null ? x : bits.cat(x);
 627         }
 628         System.out.println("dec="+bits.get(0));
 629         if (bits.get(1)) throw new RuntimeException();
 630         }
 631         */
 632         /*        for (int i=0; i<64; i++) {
 633
 634                   if (marina.kesselsCounter) {
 635                   System.out.println("master-clearing...");
 636                   // master clear on each iteration; otherwise we'd need to "run down" the olc
 637                   marina.masterClear();
 638                   marina.southRing.enableInstructionSend(true);
 639                   }
 640
 641                   expectTokensExactly(0);
 642                   marina.getOLC();
 643
 644                   int inOlc = i==-1 ? 0 : (1<<i);
 645                   inOlc = i;
 646                   marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc));
 647                   marina.southRing.fill(SEND_DATA_IF_D_SET);
 648                   marina.southRing.fill(SEND_DATA_IF_D_NOT_SET);
 649                   marina.southRing.fill(SEND_DATA);
 650
 651                   model.waitNS(128 * CYCLE_TIME_NS);
 652
 653                   expectOlc(inOlc);
 654                   prln("walkOneOLC: "+inOlc+" checks out");
 655                   expectNorthFifoExactly(0);
 656                   }
 657                   adjustIndent(-2);
 658                   prln("End walkOneOLC");
 659         */
 660     }
 661     private void walkOneILC(Marina marina) {
 662         prln("Begin walkOneILC");
 663         adjustIndent(2);
 664         for (int i=0; i<6; i++) {
 665             // Mask off the "zero" bit position
 666             int inIlc = 1 << i;
 667             prln("inIlc="+inIlc);
 668             marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, inIlc));
 669             int outIlc = marina.getILC();
 670             fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+inIlc);
 671             fatal(marina.getILCInfinity(), "bad Infinity bit: true");
 672         }
 673         prln("Now test the infinity bit");
 674         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
 675         fatal(!marina.getILCInfinity(), "bad Infinity bit: false");
 676         adjustIndent(-2);
 677         prln("End walkOneILC");
 678     }
 679     private void countIlc(Marina marina) {
 680         final int maxIlc = 63;
 681         prln("Begin countIlc");
 682         adjustIndent(2);
 683
 684         marina.southRing.fill(new
 685                             Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, maxIlc));
 686
 687         int ilc = marina.getILC();
 688         fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc);
 689
 690         prln("execute a move instruction that does nothing except decrement the ILC to zero");
 691         marina.southRing.fill(
 692                             new Instruction.Move(marina.getOnlyDock(),
 693                                                  Predicate.IgnoreFlagD, // predicate
 694                                                  false,                 // torpedoable
 695                                                  null,                  // path
 696                                                  false,                 // tokenIn
 697                                                  false,                 // dataIn
 698                                                  false,                 // latchData
 699                                                  false,                 // latchPath
 700                                                  false,                 // dataOut
 701                                                  false                  // tokenOut
 702                                                  ));
 703
 704         // wait for ILC to count from 63 to 0
 705         model.waitNS(128 * CYCLE_TIME_NS);
 706         //model.waitNS(10000);
 707
 708         prln("Check that ILC==0");
 709         ilc = marina.getILC();
 710         fatal(ilc!=0, "bad ILC count: "+ilc+" expected: "+0);
 711
 712         adjustIndent(-2);
 713         prln("End countIlc");
 714     }
 715     // Note: countOlc takes 44 minutes to run on nanosim
 716     private void countOlc(Marina marina) {
 717         int maxOlc = 63;
 718         prln("Begin countOlc");
 719         adjustIndent(2);
 720
 721         marina.southRing.fill(setOlc(maxOlc));
 722
 723         for (int i=maxOlc; i>=0; i--) {
 724             model.waitNS(128 * CYCLE_TIME_NS);
 725             prln("OLC should be: "+i);
 726             expectOlc(i);
 727             marina.southRing.fill(new
 728                                 Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, SetSource.Decrement));
 729         }
 730
 731         adjustIndent(-2);
 732         prln("End countOlc");
 733     }
 734     private void loadEveryValueOLC(Marina marina) {
 735         adjustIndent(2);
 736         //while(true)
 737         for (int i=0; i<(1<<6); i++) {
 738
 739             if (marina.kesselsCounter) {
 740                 System.out.println("master-clearing...");
 741                 // master clear on each iteration; otherwise we'd need to "run down" the olc
 742                 marina.masterClear();
 743                 marina.southRing.enableInstructionSend(true);
 744             }
 745
 746             int inOlc = i;
 747             marina.southRing.fill(new Instruction[] {
 748
 749                     setIlc(1),
 750
 751                     // to ensure that instruction is bubble-limited
 752                     RECV_DATA,
 753
 754                     // the Set-OLC instruction
 755                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc),
 756
 757                     // put a Set-ILC instruction right behind it with inverted bits to be sure we're
 758                     // not capturing the instruction-latch value too late in the cycle
 759                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, (inOlc ^ (~(-1<<6)))),
 760
 761                 });
 762
 763             model.waitNS(128 * CYCLE_TIME_NS);
 764             marina.northRing.fill();
 765             model.waitNS(128 * CYCLE_TIME_NS);
 766
 767             expectOlc(inOlc);
 768             prln("loadEveryValueOLC: "+inOlc+" checks out");
 769         }
 770         adjustIndent(-2);
 771     }
 772
 773     private void saturateInstructionFifo(Marina marina, Instruction instruction, int quantity, boolean expect_it_to_jam_up) {
 774         prln("Inserting "+quantity+" copies of \"" + instruction + "\"");
 775         adjustIndent(2);
 776         int i=0;
 777         for(i=0; i<quantity; i++) {
 778             prln("Inserting instruction " + (i+1) +"/"+ quantity);
 779             marina.southRing.fill(instruction);
 780             boolean jammed = (marina.southRing.getFillStateWire()==MarinaUtils.StateWireState.FULL);
 781             if (jammed && expect_it_to_jam_up) {
 782                 prln("Stopper remained full after inserting instruction; this was expected; we are happy.");
 783                 adjustIndent(-2);
 784                 return;
 785             }
 786             fatal(jammed, "Instruction stopper did not drain after inserting " + (i+1) + " instructions; not good!");
 787         }
 788         fatal(expect_it_to_jam_up, "Expected instruction stopper to jam up, but it did not");
 789         adjustIndent(-2);
 790         prln("Successfully inserted " + i + " instructions");
 791     }
 792
 793     private MarinaPath null_path = new MarinaPath(marina, MarinaUtils.sunToBerk(MarinaPacket.null_path));
 794
 795     private final Instruction DEC =
 796         new Instruction.Set(marina.getOnlyDock(),Predicate.Default,SetDest.OuterLoopCounter, SetSource.Decrement);
 797
 798     private final Instruction FLAG_NOP =
 799         new Instruction.Set(marina.getOnlyDock(), Predicate.IgnoreFlagD,
 800                             CLEAR_FLAG.add(Predicate.FlagA),
 801                             CLEAR_FLAG.add(Predicate.FlagB));
 802
 803     private final Instruction FLAG_NOP_IF_FLAG_A =
 804         new Instruction.Set(marina.getOnlyDock(), Predicate.FlagA,
 805                             CLEAR_FLAG.add(Predicate.FlagA),
 806                             CLEAR_FLAG.add(Predicate.FlagB));
 807
 808     private final Instruction NOP =
 809         new Instruction.Move(marina.getOnlyDock(),
 810                              Predicate.IgnoreFlagD, /* predicate   */
 811                              false,                 /* torpedoable */
 812                              null,                  /* path        */
 813                              false,                 /* tokenIn     */
 814                              false,                 /* dataIn      */
 815                              false,                 /* latchData   */
 816                              false,                 /* latchPath   */
 817                              false,                 /* dataOut     */
 818                              false                  /* tokenOut    */
 819                              );
 820
 821     private final Instruction SEND_DATA =
 822         new Instruction.Move(marina.getOnlyDock(),
 823                              Predicate.IgnoreFlagD,   /* predicate   */
 824                              false,                 /* torpedoable */
 825                              null_path,                  /* path        */
 826                              false,                 /* tokenIn     */
 827                              false,                 /* dataIn      */
 828                              false,                 /* latchData   */
 829                              false,                 /* latchPath   */
 830                              true,                  /* dataOut     */
 831                              false                  /* tokenOut    */
 832                              );
 833
 834     private final Instruction SEND_DATA_IF_D_NOT_SET =
 835         new Instruction.Move(marina.getOnlyDock(),
 836                              Predicate.Default,     /* predicate   */
 837                              false,                 /* torpedoable */
 838                              null_path,             /* path        */
 839                              false,                 /* tokenIn     */
 840                              false,                 /* dataIn      */
 841                              false,                 /* latchData   */
 842                              false,                 /* latchPath   */
 843                              true,                  /* dataOut     */
 844                              false                  /* tokenOut    */
 845                              );
 846
 847     private final Instruction SEND_DATA_IF_A_SET_AND_D_NOT_SET =
 848         new Instruction.Move(marina.getOnlyDock(),
 849                              Predicate.FlagA,       /* predicate   */
 850                              false,                 /* torpedoable */
 851                              null_path,             /* path        */
 852                              false,                 /* tokenIn     */
 853                              false,                 /* dataIn      */
 854                              false,                 /* latchData   */
 855                              false,                 /* latchPath   */
 856                              true,                  /* dataOut     */
 857                              false                  /* tokenOut    */
 858                              );
 859
 860     private final Instruction SEND_DATA_IF_D_SET =
 861         new Instruction.Move(marina.getOnlyDock(),
 862                              Predicate.FlagD,       /* predicate   */
 863                              false,                 /* torpedoable */
 864                              null_path,             /* path        */
 865                              false,                 /* tokenIn     */
 866                              false,                 /* dataIn      */
 867                              false,                 /* latchData   */
 868                              false,                 /* latchPath   */
 869                              true,                  /* dataOut     */
 870                              false                  /* tokenOut    */
 871                              );
 872
 873     private final Instruction SEND_TOKEN_IF_D_SET =
 874         new Instruction.Move(marina.getOnlyDock(),
 875                              Predicate.FlagD,       /* predicate   */
 876                              false,                 /* torpedoable */
 877                              null_path,             /* path        */
 878                              false,                 /* tokenIn     */
 879                              false,                 /* dataIn      */
 880                              false,                 /* latchData   */
 881                              false,                 /* latchPath   */
 882                              false,                 /* dataOut     */
 883                              true                   /* tokenOut    */
 884                              );
 885
 886     private final Instruction SEND_TOKEN_IF_D_NOT_SET =
 887         new Instruction.Move(marina.getOnlyDock(),
 888                              Predicate.Default,     /* predicate   */
 889                              false,                 /* torpedoable */
 890                              null_path,             /* path        */
 891                              false,                 /* tokenIn     */
 892                              false,                 /* dataIn      */
 893                              false,                 /* latchData   */
 894                              false,                 /* latchPath   */
 895                              false,                 /* dataOut     */
 896                              true                   /* tokenOut    */
 897                              );
 898
 899     private final Instruction TORPEDOABLE_RECV_DATA =
 900         new Instruction.Move(marina.getOnlyDock(),
 901                              Predicate.IgnoreFlagD, /* predicate   */
 902                              true,                  /* torpedoable */
 903                              null,                  /* path        */
 904                              false,                 /* tokenIn     */
 905                              true,                  /* dataIn      */
 906                              true,                  /* latchData   */
 907                              false,                 /* latchPath   */
 908                              false,                 /* dataOut     */
 909                              false                  /* tokenOut    */
 910                              );
 911
 912     private final Instruction RECV_DATA =
 913         new Instruction.Move(marina.getOnlyDock(),
 914                              Predicate.IgnoreFlagD,   /* predicate   */
 915                              false,                 /* torpedoable */
 916                              null,                  /* path        */
 917                              false,                 /* tokenIn     */
 918                              true,                  /* dataIn      */
 919                              true,                  /* latchData   */
 920                              false,                 /* latchPath   */
 921                              false,                 /* dataOut     */
 922                              false                  /* tokenOut    */
 923                              );
 924
 925     private final Instruction SEND_TOKEN =
 926         new Instruction.Move(marina.getOnlyDock(),
 927                              Predicate.IgnoreFlagD,   /* predicate   */
 928                              false,                 /* torpedoable */
 929                              null_path,                  /* path        */
 930                              false,                 /* tokenIn     */
 931                              false,                 /* dataIn      */
 932                              false,                 /* latchData   */
 933                              false,                 /* latchPath   */
 934                              false,                 /* dataOut     */
 935                              true                   /* tokenOut    */
 936                              );
 937
 938     private final Instruction RECV_TOKEN =
 939         new Instruction.Move(marina.getOnlyDock(),
 940                              Predicate.IgnoreFlagD,   /* predicate   */
 941                              false,                 /* torpedoable */
 942                              null,                  /* path        */
 943                              true,                  /* tokenIn     */
 944                              false,                 /* dataIn      */
 945                              false,                 /* latchData   */
 946                              false,                 /* latchPath   */
 947                              false,                 /* dataOut     */
 948                              false                  /* tokenOut    */
 949                              );
 950
 951
 952     private void expectNorthFifoNoMoreThan(int num) {
 953         model.waitNS(128 * CYCLE_TIME_NS);
 954         List<BitVector> dataItems = marina.northRing.drainMany(num+1);
 955         fatal(dataItems.size()>num,
 956               "Expected no more than "+num+
 957               " data items to emerge but got at least: "+dataItems.size());
 958     }
 959     private void expectNorthFifoExactly(int num) {
 960         model.waitNS(128 * CYCLE_TIME_NS);
 961         List<BitVector> dataItems = marina.northRing.drainMany(num+1);
 962         fatal(dataItems.size()!=num,
 963               "Expected exactly "+num+
 964               " data items to emerge but got at least: "+dataItems.size());
 965     }
 966     private void expectNorthFifoAtLeast(int num) {
 967         model.waitNS(128 * CYCLE_TIME_NS);
 968         List<BitVector> dataItems = marina.northRing.drainMany(num);
 969         fatal(dataItems.size()<num,
 970               "Expected at least "+num+
 971               " data items to emerge but got only: "+dataItems.size());
 972     }
 973     private void expectTokensNoMoreThan(int num) {
 974         int x = marina.getNumTokens();
 975         List<BitVector> dataItems = marina.northRing.drainMany(num+1);
 976         fatal(x>num,
 977               "Expected no more than "+num+
 978               " tokens to emerge but got at least: "+x);
 979     }
 980     private void expectTokensExactly(int num) {
 981         int x = marina.getNumTokens();
 982         fatal(x!=num,
 983               "Expected exactly "+num+
 984               " tokens but got at least: "+x);
 985     }
 986
 987     private void testFlagDRecomputationTime(Marina marina) {
 988         marina.southRing.fill(setIlc(1));
 989         marina.southRing.fill(new Instruction[] {
 990                 RECV_DATA,
 991                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
 992                 SEND_DATA_IF_D_NOT_SET
 993             });
 994         marina.northRing.fill();
 995         expectNorthFifoNoMoreThan(0);
 996
 997         marina.southRing.fill(new Instruction[] {
 998                 RECV_DATA,
 999                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
1000                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
1001                 SEND_DATA_IF_D_NOT_SET
1002             });
1003         marina.northRing.fill();
1004         expectNorthFifoNoMoreThan(0);
1005
1006         marina.southRing.fill(new Instruction[] {
1007                 RECV_DATA,
1008                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
1009                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement),
1010                 SEND_DATA_IF_D_NOT_SET
1011             });
1012         marina.northRing.fill();
1013         expectNorthFifoExactly(1);
1014         marina.southRing.fill(DEC);
1015
1016         marina.southRing.fill(new Instruction[] {
1017                 RECV_DATA,
1018                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,0),
1019                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,1),
1020                 SEND_DATA_IF_D_NOT_SET
1021             });
1022         marina.northRing.fill();
1023         expectNorthFifoExactly(1);
1024     }
1025
1026     private void testTailWaitsForHead(Marina marina) {
1027         marina.southRing.fill(setIlc(1));
1028         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
1029
1030         marina.southRing.enableInstructionSend(false);
1031         marina.southRing.enableInstructionRecirculate(true);
1032
1033         marina.southRing.fill(TORPEDOABLE_RECV_DATA);
1034         marina.southRing.fill(new Instruction.Head(marina.getOnlyDock()));
1035         marina.southRing.fill(SEND_DATA);
1036         marina.southRing.fill(TORPEDOABLE_RECV_DATA);
1037         marina.southRing.fill(SEND_TOKEN);
1038         marina.southRing.fill(TORPEDOABLE_RECV_DATA);
1039         marina.southRing.fill(new Instruction.Tail(marina.getOnlyDock()));
1040         marina.southRing.fillTorpedo();
1041
1042         marina.southRing.enableInstructionRecirculate(false);
1043         marina.southRing.enableInstructionSend(true);
1044         marina.southRing.run();
1045
1046         expectNorthFifoNoMoreThan(0);
1047         prln("inserting into north proper stopper");
1048         marina.northRing.fill();
1049         expectNorthFifoExactly(1);
1050         int nbToks = marina.getNumTokens();
1051         fatal(nbToks!=1, "Expected one token to emerge but got: "+nbToks+" tokens");
1052     }
1053
1054     /*
1055       marina.southRing.fill(setIlc(1));
1056       marina.southRing.fill(setOlc(1));
1057
1058       // this makes the head wait for the torpedo
1059       marina.southRing.fill(TORPEDOABLE_RECV_DATA);
1060
1061       // the head should wait for the tail
1062       marina.southRing.fill(new Instruction.Head(marina.getOnlyDock()));
1063       marina.southRing.fill(NOP);
1064       marina.southRing.fill(SEND_DATA);
1065       marina.southRing.fill(RECV_DATA);
1066
1067       expectNorthFifoNoMoreThan(0);
1068
1069       marina.southRing.fillTorpedo();
1070       expectNorthFifoNoMoreThan(0);
1071
1072       marina.southRing.fill(new Instruction.Tail(marina.getOnlyDock()));
1073       expectNorthFifoExactly(1);
1074     */
1075
1076     private void testTailWithoutHead(Marina marina) {
1077         marina.southRing.fill(setIlc(1));
1078         marina.southRing.fill(new Instruction[] {
1079                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1080                 new Instruction.Tail(marina.getOnlyDock()),
1081                 SEND_DATA,
1082             });
1083         List<BitVector> dataItems = marina.northRing.drainMany(1);
1084         fatal(dataItems.size()!=0, "Expected exactly no data items to emerge but got at least: "+dataItems.size());
1085     }
1086
1087     private void testHeadWaitsForTail(Marina marina) {
1088         List<BitVector> dataItems;
1089
1090         prln("Begin testHeadWaitsForTail");
1091         adjustIndent(2);
1092
1093         marina.southRing.fill(setIlc(1));
1094         marina.southRing.fill(new Instruction[] {
1095                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63),
1096                 new Instruction.Head(marina.getOnlyDock()),
1097                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1098                 SEND_DATA,
1099             });
1100
1101         expectNorthFifoExactly(0);
1102         marina.southRing.fill(new Instruction.Tail(marina.getOnlyDock()));
1103         expectNorthFifoAtLeast(1);
1104
1105         adjustIndent(-2);
1106         prln("End testHeadWaitsForTail");
1107     }
1108
1109     private void testNonTorpedoableMoveDoesNotResetDFlag(Marina marina) {
1110         marina.southRing.fill(setIlc(1));
1111         marina.southRing.fill(new Instruction[] {
1112                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,63),
1113                 new Instruction.Move(marina.getOnlyDock(),
1114                                      Predicate.IgnoreFlagD, // predicate
1115                                      true,                  // torpedoable
1116                                      null,                  // path
1117                                      true,                  // tokenIn
1118                                      false,                 // dataIn
1119                                      false,                 // latchData
1120                                      false,                 // latchPath
1121                                      false,                 // dataOut
1122                                      false                  // tokenOut
1123                                      ),
1124                 new Instruction.Move(marina.getOnlyDock(),
1125                                      Predicate.FlagD,       // predicate
1126                                      false,                 // torpedoable
1127                                      null,                  // path
1128                                      false,                 // tokenIn
1129                                      false,                 // dataIn
1130                                      false,                 // latchData
1131                                      false,                 // latchPath
1132                                      true,                  // dataOut
1133                                      false                  // tokenOut
1134                                      ),
1135             });
1136         marina.southRing.fillTorpedo();
1137         expectNorthFifoExactly(1);
1138         marina.southRing.fill(new Instruction[] {
1139                 new Instruction.Move(marina.getOnlyDock(),
1140                                      Predicate.Default,     // predicate
1141                                      false,                 // torpedoable
1142                                      null,                  // path
1143                                      false,                 // tokenIn
1144                                      false,                 // dataIn
1145                                      false,                 // latchData
1146                                      false,                 // latchPath
1147                                      true,                  // dataOut
1148                                      false                  // tokenOut
1149                                      ),
1150             });
1151         expectNorthFifoNoMoreThan(0);
1152     }
1153
1154     private void testAbort(Marina marina) {
1155
1156         marina.southRing.fill(setIlc(1));
1157         marina.southRing.fill(new Instruction[] {
1158                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.DataLatch,1),
1159                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,2),
1160                 SEND_DATA_IF_D_NOT_SET,
1161                 new Instruction.Head(marina.getOnlyDock()),
1162                 SEND_DATA_IF_D_NOT_SET,
1163                 new Instruction.Set(marina.getOnlyDock(),Predicate.Default,SetDest.DataLatch,2),
1164                 new Instruction.Abort(marina.getOnlyDock(), Predicate.FlagD),
1165                 new Instruction.Set(marina.getOnlyDock(),Predicate.Default,SetDest.OuterLoopCounter,SetSource.Decrement),
1166                 new Instruction.Tail(marina.getOnlyDock()),
1167             }, true);
1168
1169         for(int i=0; i<4; i++) {
1170             BitVector bv;
1171
1172             model.waitNS(128 * CYCLE_TIME_NS);
1173             bv = new MarinaPacket(marina.northRing.drain()).data.bitReverse();
1174             fatal(bv==null, "no data item found");
1175             prln("got " + bv.toLong());
1176             fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1177
1178             model.waitNS(128 * CYCLE_TIME_NS);
1179             bv = new MarinaPacket(marina.northRing.drain()).data.bitReverse();
1180             fatal(bv==null, "no data item found");
1181             prln("got " + bv.toLong());
1182             fatal(bv.toLong()!=1, "expected 1, got " + bv.toLong());
1183
1184             model.waitNS(128 * CYCLE_TIME_NS);
1185             bv = new MarinaPacket(marina.northRing.drain()).data.bitReverse();
1186             fatal(bv==null, "no data item found");
1187             prln("got " + bv.toLong());
1188             fatal(bv.toLong()!=2, "expected 2, got " + bv.toLong());
1189
1190         }
1191     }
1192
1193     private void testAbortOutsideOfLoop(Marina marina) {
1194         marina.southRing.fill(setIlc(1));
1195         marina.southRing.fill(new Instruction[] {
1196                 // ensure that an abort doesn't cause problems if no loop is in progress
1197                 new Instruction.Abort(marina.getOnlyDock(), Predicate.IgnoreFlagD),
1198                 SEND_DATA,
1199             });
1200         expectNorthFifoExactly(1);
1201     }
1202
1203     private void testFlagAB(Marina marina) {
1204         prln("Begin testFlagAB");
1205         adjustIndent(2);
1206
1207         Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1208         Instruction.Set.FlagFunction one  = zero;
1209
1210
1211         // we should be able to use any pair of FlagX+NotFlagX,
1212         // but we toss them all in to maximize the chances of the
1213         // test passing (later we will try the individual
1214         // combinations to maximize the chances of failure).
1215         one = one.add(Predicate.FlagA);
1216         one = one.add(Predicate.NotFlagA);
1217         one = one.add(Predicate.FlagB);
1218         one = one.add(Predicate.NotFlagB);
1219         one = one.add(Predicate.FlagC);
1220         one = one.add(Predicate.NotFlagC);
1221
1222         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
1223         for(boolean fast : new boolean[] { true, false }) {
1224             // clear the flags to a known state, then check both 0->1 and 1->0 transitions
1225             for(boolean b : new boolean[] { false, true, false }) {
1226                 prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
1227                 prln((b?"Setting":"Clearing")+" flags");
1228
1229                 Instruction inst = new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1230                                                        b ? one : zero,
1231                                                        b ? one : zero
1232                                                        );
1233                 if (fast) {
1234                     marina.southRing.fill(new Instruction[] {
1235                             RECV_DATA,
1236                             inst,
1237                             NOP,
1238                         });
1239                     model.waitNS(64 * CYCLE_TIME_NS);
1240                     marina.northRing.fill();
1241                 } else {
1242                     marina.southRing.fill(inst);
1243                 }
1244
1245                 fatal(marina.getFlagA()!=b,
1246                       "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set"));
1247                 fatal(marina.getFlagB()!=b,
1248                       "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set"));
1249             }
1250         }
1251
1252         adjustIndent(-2);
1253         prln("End testFlagAB");
1254     }
1255
1256     /**
1257      *  WARNING: this is a very, very, very long test case -- it goes
1258      *  through 216 iterations.
1259      */
1260     private void testFlagTruthTable(Marina marina) {
1261         prln("Begin testFlagTruthTable");
1262         adjustIndent(2);
1263
1264         marina.southRing.fill(setIlc(1));
1265         Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO;
1266         Instruction.Set.FlagFunction one  = zero.add(Predicate.FlagA).add(Predicate.NotFlagA);
1267
1268         for(Predicate a_input : new Predicate[] { null, Predicate.FlagA, Predicate.NotFlagA })
1269             for(Predicate b_input : new Predicate[] { null, Predicate.FlagB, Predicate.NotFlagB })
1270                 for(Predicate c_input : new Predicate[] { null, Predicate.FlagC, Predicate.NotFlagC })
1271                     for(boolean a_state : new boolean[] { false, true })
1272                         for(boolean b_state : new boolean[] { false, true })
1273                             for(boolean c_state : new boolean[] { false, true }) {
1274                                 for(boolean which : new boolean[] { false, true }) {
1275
1276                                     prln("before instruction: a="+a_state+", b="+b_state+", c="+c_state);
1277                                     // set A,B flags to a_state and b_state
1278                                     marina.southRing.fill(new
1279                                                         Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1280                                                                         a_state ? one : zero,
1281                                                                         b_state ? one : zero
1282                                                                         ));
1283
1284                                     // set C flag to c_state
1285                                     BitVector data = new BitVector(37, "empty");
1286                                     BitVector addr = new BitVector(14, "empty");
1287                                     for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1288                                     for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1289                                     addr.set(Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE, c_state);
1290                                     marina.northRing.fill(new MarinaPacket(data, false, addr));
1291                                     marina.southRing.fill(RECV_DATA);
1292
1293                                     Instruction.Set.FlagFunction func = zero;
1294                                     if (a_input!=null) func = func.add(a_input);
1295                                     if (b_input!=null) func = func.add(b_input);
1296                                     if (c_input!=null) func = func.add(c_input);
1297
1298                                     Instruction inst = new
1299                                         Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1300                                                         !which ? func : zero.add(Predicate.FlagA),
1301                                                         which  ? func : zero.add(Predicate.FlagB)
1302                                                         );
1303
1304                                     marina.southRing.fill(inst);
1305
1306                                     boolean expected_a = !which ? func.evaluate(a_state, b_state, c_state, false) : a_state;
1307                                     boolean expected_b =  which ? func.evaluate(a_state, b_state, c_state, false) : b_state;
1308                                     fatal(expected_a != marina.getFlagA(),
1309                                           "expected A="+expected_a+", but got "+marina.getFlagA());
1310                                     fatal(expected_b != marina.getFlagB(),
1311                                           "expected B="+expected_b+", but got "+marina.getFlagB());
1312                                 }
1313                             }
1314         adjustIndent(-2);
1315         prln("End testFlagTruthTable");
1316     }
1317
1318     private void recvData(Marina marina) {
1319         prln("Begin recvData");
1320         adjustIndent(2);
1321
1322         marina.southRing.fill(setIlc(1));
1323         marina.southRing.fill(new Instruction[] {
1324                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1325                 new Instruction.Move(marina.getOnlyDock(),
1326                                      Predicate.IgnoreFlagD, // predicate
1327                                      false,                 // torpedoable
1328                                      null,                  // path
1329                                      false,                 // tokenIn
1330                                      true,                  // dataIn
1331                                      false,                 // latchData
1332                                      false,                 // latchPath
1333                                      false,                 // dataOut
1334                                      false                  // tokenOut
1335                                      ),
1336                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, SET_FLAG, SET_FLAG),
1337             });
1338         model.waitNS(64 * CYCLE_TIME_NS);
1339
1340         prln("checking to confirm that A flag is cleared");
1341         fatal(marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1342
1343         prln("inserting data item in north fifo ring");
1344         BitVector data = new BitVector(37, "empty");
1345         BitVector addr = new BitVector(14, "empty");
1346         for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1347         for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1348         marina.northRing.fill(new MarinaPacket(data, false, addr));
1349         model.waitNS(64 * CYCLE_TIME_NS);
1350
1351         prln("checking to see if A flag got set");
1352         fatal(!marina.getFlagA(), "bad A flag: "+marina.getFlagA());
1353
1354         adjustIndent(-2);
1355         prln("End recvData");
1356     }
1357
1358
1359     private void testRecvAndSendWalkingOne(Marina marina) {
1360         prln("Begin testRecvAndSendWalkingOne");
1361         adjustIndent(2);
1362
1363         marina.southRing.fill(setIlc(1));
1364
1365         List<BitVector> dataItems;
1366         for(int bit=0; bit<37; bit++) {
1367
1368             BitVector data = new BitVector(37, "empty");
1369             BitVector addr = new BitVector(14, "empty");
1370             for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1371             for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1372             data.set(bit, true);
1373             prln("testing with bit pattern " + data);
1374
1375             prln("inserting data item into north fifo ring");
1376             marina.northRing.fill(new MarinaPacket(data, false, addr));
1377
1378             prln("stopping the north proper stopper");
1379             marina.northRing.stop();
1380
1381             dataItems = marina.northRing.drainMany(1);
1382             fatal(dataItems.size()!=0,
1383                   "found a data item waiting in the north proper stopper, but should not have");
1384
1385             marina.southRing.fill(new Instruction.Move(marina.getOnlyDock(),
1386                                                      Predicate.IgnoreFlagD,  // predicate
1387                                                      false,                  // torpedoable
1388                                                      null_path,              // path
1389                                                      false,                  // tokenIn
1390                                                      true,                   // dataIn
1391                                                      true,                   // latchData
1392                                                      false,                  // latchPath
1393                                                      true,                   // dataOut
1394                                                      false                   // tokenOut
1395                                                      ));
1396
1397             dataItems = marina.northRing.drainMany(2);
1398             fatal(dataItems.size()!=1,
1399                   "found "+dataItems.size()+" data items in north fifo; expected one");
1400             MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1401             fatalIfBitVectorsDoNotMatch(mp.data, data);
1402         }
1403
1404         adjustIndent(-2);
1405         prln("End testRecvAndSendWalkingOne");
1406     }
1407
1408
1409
1410     private void setOlcFromDataLatch(Marina marina) {
1411         prln("Begin setOlcFromDataLatch");
1412         adjustIndent(2);
1413
1414         marina.southRing.fill(setIlc(1));
1415
1416         // walk a bit from 0 to 5
1417         for(int bit=0; bit<6; bit++) {
1418             prln("inserting data item in north fifo ring");
1419             BitVector data = new BitVector(37, "empty");
1420             BitVector addr = new BitVector(14, "empty");
1421             for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1422             for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1423             data.set(bit, true);
1424             marina.northRing.fill(new MarinaPacket(data, false, addr));
1425
1426             marina.southRing.fill(new Instruction[] {
1427                     RECV_DATA,
1428                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.DataLatch),
1429                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.DataLatch,-1),
1430                 });
1431
1432             model.waitNS(CYCLE_TIME_NS * 64);
1433
1434             expectOlc(1<<bit);
1435
1436             if (marina.kesselsCounter) {
1437                 // master clear on each iteration; otherwise we'd need to "run down" the olc
1438                 marina.masterClear();
1439                 marina.southRing.enableInstructionSend(true);
1440             }
1441         }
1442
1443         adjustIndent(-2);
1444         prln("End setOlcFromDataLatch");
1445     }
1446
1447     private void setIlcFromDataLatch(Marina marina) {
1448         prln("Begin setIlcFromDataLatch");
1449         adjustIndent(2);
1450
1451         marina.southRing.fill(setIlc(1));
1452
1453         // walk a bit from 0 to 5
1454         for(int bit=5; bit>=0; bit--) {
1455             prln("inserting data item in north fifo ring");
1456             BitVector data = new BitVector(37, "empty");
1457             BitVector addr = new BitVector(14, "empty");
1458             for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1459             for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1460             data.set(bit, true);
1461             marina.northRing.fill(new MarinaPacket(data, false, addr));
1462
1463             marina.southRing.fill(new Instruction[] {
1464                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1465                     RECV_DATA,
1466                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.DataLatch),
1467                 });
1468             model.waitNS(CYCLE_TIME_NS * 64);
1469
1470             int ilc = marina.getILC();
1471             fatal(ilc != (1<<bit), "expected ilc to be " + (1<<bit) + ", but got " + ilc);
1472         }
1473
1474         adjustIndent(-2);
1475         prln("End setIlcFromDataLatch");
1476     }
1477
1478     private void testSendAndRecvToken(Marina marina) {
1479         prln("Begin testSendAndRecvToken");
1480         adjustIndent(2);
1481
1482         marina.southRing.fill(setIlc(1));
1483         marina.southRing.fill(new Instruction[] {
1484                 SEND_TOKEN,
1485                 RECV_TOKEN,
1486                 SEND_DATA,
1487             });
1488         expectNorthFifoExactly(1);
1489
1490         adjustIndent(-2);
1491         prln("End testSendAndRecvToken");
1492     }
1493
1494     private void testSignExtendedLiteral(Marina marina) {
1495         prln("Begin testSignExtendedLiteral");
1496         adjustIndent(2);
1497
1498         marina.southRing.fill(setIlc(1));
1499         for(long val : new long[] { (-1L << 14), -1, 0, 1 }) {
1500
1501             marina.southRing.fill(new Instruction[] {
1502                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1503                                         Instruction.Set.SetDest.DataLatch,
1504                                         val),
1505                     SEND_DATA,
1506                 });
1507             model.waitNS(CYCLE_TIME_NS * 64);
1508
1509             List<BitVector> dataItems = marina.northRing.drainMany(3);
1510             fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1511
1512             MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1513             BitVector bv = mp.data;
1514             prln("got back " + mp);
1515
1516             boolean mismatch = false;
1517             String err = "";
1518             for(int i=0; i<37; i++) {
1519                 if (bv.get(i) != ( (val & (1L << i)) != 0 )) {
1520                     mismatch = true;
1521                     err += ""+i+", ";
1522                 }
1523             }
1524             fatal(mismatch, "data read back did not match inserted literal; mismatch on bits " + err);
1525         }
1526
1527         adjustIndent(-2);
1528         prln("End testSignExtendedLiteral");
1529     }
1530
1531     private void testShiftedLiteral(Marina marina) {
1532         prln("Begin testShiftedLiteral");
1533         adjustIndent(2);
1534
1535         marina.southRing.fill(setIlc(1));
1536         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1537                                                 Instruction.Set.SetDest.DataLatch,
1538                                                 0));
1539
1540         BitVector dreg = new BitVector(37, "what we think is in the d-register");
1541         for(int i=0; i<37; i++) dreg.set(i, false);
1542
1543         for(long val : new long[] { -1, 0, 1, (-1L << 18) }) {
1544
1545             edu.berkeley.fleet.api.BitVector immediate =
1546                 new edu.berkeley.fleet.api.BitVector(19);
1547             for(int i=0; i<immediate.length(); i++)
1548                 immediate.set(i, (val & (1L << i)) != 0);
1549
1550             // shift over 19 LSB's towards MSB
1551             for(int i=0; i<19; i++)
1552                 if (i+19 <= 36)  dreg.set(i+19, dreg.get(i));
1553             for(int i=0; i<19; i++)
1554                 dreg.set(i, immediate.get(i));
1555
1556             marina.southRing.fill(new Instruction[] {
1557                     new Instruction.Shift(marina.getOnlyDock(),Predicate.IgnoreFlagD,immediate),
1558                     SEND_DATA,
1559                 });
1560
1561             model.waitNS(CYCLE_TIME_NS * 64);
1562             List<BitVector> dataItems = marina.northRing.drainMany(3);
1563             fatal(dataItems.size()!=1, "expected exactly one data item, got " + dataItems.size());
1564
1565             BitVector bv = new MarinaPacket(dataItems.get(0)).data;
1566             fatal(!bv.equals(dreg), "data read back did not match inserted literal.\n" +
1567                   "got:     "+bv.bitReverse().getState()+"\n"+
1568                   "expected:"+dreg.bitReverse().getState());
1569         }
1570
1571         adjustIndent(-2);
1572         prln("End testShiftedLiteral");
1573     }
1574
1575     private void testFlagC(Marina marina) {
1576         prln("Begin testFlagC");
1577         adjustIndent(2);
1578
1579         // Russell says:
1580         // addr[14] == sigS
1581         // addr[1]  == sigA
1582         //
1583         // Adam says:
1584         // Dc=1 => sigS is copied into C-flag
1585         // Dc=0 => sigA is copied into C-flag
1586
1587         marina.southRing.fill(setIlc(1));
1588         for(boolean dc : new boolean[] { false, true }) {
1589             for(boolean c_flag : new boolean[] { true, false, true }) {
1590
1591                 prln("");
1592                 prln("****** checking case where dc="+dc+", cflag="+c_flag);
1593                 BitVector data = new BitVector(37, "empty");
1594                 BitVector addr = new BitVector(14, "empty");
1595                 for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
1596                 for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
1597
1598                 int whichbit = dc
1599                     ? Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE
1600                     : Marina.INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO;
1601                 prln("setting addr["+whichbit+"] to "+(c_flag?"1":"0"));
1602                 addr.set(whichbit, c_flag);
1603
1604                 prln("... and filling north fifo proper stopper");
1605                 marina.northRing.fill(new MarinaPacket(data, false, addr));
1606
1607                 prln("clearing flags");
1608                 prln("executing recv data with Dc="+dc);
1609                 prln("copying c-flag to a-flag");
1610                 marina.southRing.fill(new Instruction[] {
1611                         new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG),
1612                         new Instruction.Move(marina.getOnlyDock(),
1613                                              Predicate.IgnoreFlagD,   /* predicate   */
1614                                              true,                  /* torpedoable */
1615                                              null,                  /* path        */
1616                                              false,                 /* tokenIn     */
1617                                              true,                  /* dataIn      */
1618                                              dc,                    /* latchData   */
1619                                              false,                 /* latchPath   */
1620                                              false,                 /* dataOut     */
1621                                              false                  /* tokenOut    */
1622                                              ),
1623                         FLAG_NOP,
1624                         new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
1625                                             Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagC),
1626                                             CLEAR_FLAG
1627                                             ),
1628                     });
1629
1630                 model.waitNS(CYCLE_TIME_NS * 64);
1631
1632                 prln("checking to confirm that A flag is " + c_flag);
1633                 fatal(marina.getFlagA()!=c_flag, "bad A flag: "+marina.getFlagA());
1634             }
1635         }
1636         adjustIndent(-2);
1637         prln("End testFlagC");
1638     }
1639
1640     private void sendDataWithPath(Marina marina) {
1641         prln("Begin sendDataWithPath");
1642         adjustIndent(2);
1643
1644         edu.berkeley.fleet.api.BitVector bv = new edu.berkeley.fleet.api.BitVector(13);
1645         marina.southRing.fill(setIlc(1));
1646
1647         // alternating ones and zeroes
1648         for(int i=0; i<bv.length(); i+=2)
1649             bv.set(i, true);
1650         // and then ones in the lower four bits so it's not symmetric
1651         for(int i=0; i<4; i++)
1652             bv.set(i, true);
1653
1654         MarinaPath path = new MarinaPath(marina, bv);
1655
1656         marina.southRing.fill(new Instruction[] {
1657                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1658                 new Instruction.Move(marina.getOnlyDock(),
1659                                      Predicate.IgnoreFlagD, /* predicate   */
1660                                      false,                 /* torpedoable */
1661                                      path,                  /* path        */
1662                                      false,                 /* tokenIn     */
1663                                      false,                 /* dataIn      */
1664                                      false,                 /* latchData   */
1665                                      false,                 /* latchPath   */
1666                                      true,                  /* dataOut     */
1667                                      false                  /* tokenOut    */
1668                                      ),
1669             });
1670
1671         List<BitVector> dataItems;
1672         MarinaPacket mp;
1673
1674         dataItems = marina.northRing.drainMany();
1675         fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1676         mp = new MarinaPacket(dataItems.get(0));
1677
1678         // the 14th bit of the outbound address cannot be set by the
1679         // ship, so we don't care about it
1680         fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1681
1682         prln("send data with no change to path");
1683         marina.southRing.fill(new Instruction.Move(marina.getOnlyDock(),
1684                                                  Predicate.IgnoreFlagD, /* predicate   */
1685                                                  false,                 /* torpedoable */
1686                                                  null,                  /* path        */
1687                                                  false,                 /* tokenIn     */
1688                                                  false,                 /* dataIn      */
1689                                                  false,                 /* latchData   */
1690                                                  false,                 /* latchPath   */
1691                                                  true,                  /* dataOut     */
1692                                                  false                  /* tokenOut    */
1693                                                  ));
1694
1695         dataItems = marina.northRing.drainMany();
1696         fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1697         mp = new MarinaPacket(dataItems.get(0));
1698
1699         // the 14th bit of the outbound address cannot be set by the
1700         // ship, so we don't care about it
1701         fatalIfBitVectorsDoNotMatch(MarinaUtils.berkToSun(bv), mp.path.get(0,13));
1702
1703         adjustIndent(-2);
1704         prln("End sendDataWithPath");
1705     }
1706
1707     private void recvPath(Marina marina) {
1708         prln("Begin recvPath");
1709         adjustIndent(2);
1710
1711         marina.southRing.fill(setIlc(1));
1712         for(int bit=0; bit<11; bit++) {
1713             BitVector packet_data = new BitVector(37, "inbound data item");
1714             for(int i=0; i<37; i++) packet_data.set(i, false);
1715             packet_data.set(27+bit, true);
1716             BitVector packet_path = new BitVector(14, "inbound data item");
1717             for(int i=0; i<14; i++) packet_path.set(i, false);
1718
1719             marina.northRing.fill(new MarinaPacket(packet_data, false, packet_path));
1720
1721             prln("recv path, send data (using recv'd path)");
1722             marina.southRing.fill(new Instruction.Move(marina.getOnlyDock(),
1723                                                      Predicate.IgnoreFlagD,   /* predicate   */
1724                                                      false,                 /* torpedoable */
1725                                                      null,                  /* path        */
1726                                                      false,                 /* tokenIn     */
1727                                                      true,                  /* dataIn      */
1728                                                      true,                  /* latchData   */
1729                                                      true,                  /* latchPath   */
1730                                                      true,                  /* dataOut     */
1731                                                      false                  /* tokenOut    */
1732                                                      ));
1733
1734             List<BitVector> dataItems = marina.northRing.drainMany();
1735             fatal(dataItems.size()!=1, "Expected one data item to emerge but got: "+dataItems.size()+" data items");
1736             MarinaPacket mp = new MarinaPacket(dataItems.get(0));
1737
1738             fatalIfBitVectorsDoNotMatch(packet_data.get(25,11), mp.path.get(0,11));
1739             fatalIfBitVectorsDoNotMatch(packet_data, mp.data);
1740         }
1741
1742         adjustIndent(-2);
1743         prln("End recvPath");
1744     }
1745
1746     private void testILC(Marina marina) {
1747         prln("Begin testILC");
1748         adjustIndent(2);
1749
1750         for(int bit=0; bit<6; bit++) {
1751             int ilc = bit<0 ? 0 : (1<<bit);
1752             marina.southRing.fill(new Instruction[] {
1753                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,ilc),
1754                     SEND_DATA,
1755                 });
1756             List<BitVector> dataItems = marina.northRing.drainMany();
1757             fatal(dataItems.size()!=ilc, "Expected "+ilc+" data item(s) to emerge but got: "+dataItems.size()+" data items");
1758         }
1759
1760         adjustIndent(-2);
1761         prln("End testILC");
1762     }
1763
1764     private void testILCZero(Marina marina) {
1765         adjustIndent(2);
1766         marina.southRing.fill(new Instruction[] {
1767                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,0),
1768                 SEND_DATA,
1769                 SEND_TOKEN,
1770             });
1771         expectNorthFifoNoMoreThan(0);
1772         expectTokensExactly(1);
1773         adjustIndent(-2);
1774     }
1775
1776     private void sendTorpedo(Marina marina) {
1777         prln("Begin sendTorpedo");
1778         adjustIndent(2);
1779         marina.southRing.fill(setIlc(1));
1780         marina.southRing.fill(setOlc(63));
1781
1782         model.waitNS(128 * CYCLE_TIME_NS);
1783         expectOlc(63);
1784
1785         marina.southRing.fill(new
1786                             Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
1787         fatal(marina.getFlagA(), "bad A flag: true");
1788         fatal(marina.getFlagB(), "bad B flag: true");
1789
1790         prln("execute a move instruction that does nothing but loops until torpedo arrives");
1791         prln("A=1, B=B This instruction should not execute because D-flag is set");
1792         prln("Set A=A, B=1 This instruction should execute because D-flag is set");
1793
1794         model.waitNS(128 * CYCLE_TIME_NS);
1795
1796         marina.southRing.fill(new Instruction[] {
1797                 new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity),
1798                 new Instruction.Move(marina.getOnlyDock(),
1799                                      Predicate.IgnoreFlagD, // predicate
1800                                      true,                  // torpedoable
1801                                      null,                  // path
1802                                      false,                 // tokenIn
1803                                      true,                  // dataIn
1804                                      false,                 // latchData
1805                                      false,                 // latchPath
1806                                      false,                 // dataOut
1807                                      false                  // tokenOut
1808                                      ),
1809                 new Instruction.Set(marina.getOnlyDock(),Predicate.Default,
1810                                     SET_FLAG,
1811                                     Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB)
1812                                     ),
1813                 new Instruction.Set(marina.getOnlyDock(), Predicate.FlagD,
1814                                     Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA),
1815                                     SET_FLAG
1816                                     ),
1817             });
1818
1819         model.waitNS(128 * CYCLE_TIME_NS);
1820
1821         prln("send torpedo. This should clear the OLC");
1822         marina.southRing.fillTorpedo();
1823         model.waitNS(128 * CYCLE_TIME_NS);
1824
1825         model.waitNS(128 * CYCLE_TIME_NS);
1826
1827         prln("A should remain false, B should be true");
1828         fatal(marina.getFlagA(), "bad A flag: true");
1829         fatal(!marina.getFlagB(), "bad B flag: false");
1830
1831         model.waitNS(128 * CYCLE_TIME_NS);
1832
1833         prln("Reload OLC after torpedo, clears D-flag");
1834         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
1835
1836         // FIXME: find another way to test this
1837         model.waitNS(128 * CYCLE_TIME_NS);
1838         expectOlc(63);
1839
1840         prln("Set A=1, B=1 This instruction should execute because OLC!=0");
1841         marina.southRing.fill(new
1842                             Instruction.Set(marina.getOnlyDock(),Predicate.Default, SET_FLAG, SET_FLAG));
1843
1844         prln("A and B should be true");
1845         fatal(!marina.getFlagA(), "bad A flag: false");
1846         fatal(!marina.getFlagB(), "bad B flag: false");
1847
1848         adjustIndent(-2);
1849         prln("End sendTorpedo");
1850     }
1851
1852     private void testTorpedoOnAnInfinite(Marina marina) {
1853         prln("Begin testTorpedoOnAnInfinite");
1854         adjustIndent(2);
1855
1856         List<BitVector> dataItems;
1857
1858         marina.southRing.fill(setIlc(1));
1859         for(boolean torpedoable : new boolean[] { true, false }) {
1860
1861             marina.southRing.fill(new Instruction[] {
1862                     new Instruction.Move(marina.getOnlyDock(),
1863                                          Predicate.IgnoreFlagD, // predicate
1864                                          false,                 // torpedoable
1865                                          null,                  // path
1866                                          false,                 // tokenIn
1867                                          false,                 // dataIn
1868                                          false,                 // latchData
1869                                          false,                 // latchPath
1870                                          false,                 // dataOut
1871                                          true                   // tokenOut
1872                                          ),
1873                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity),
1874                     new Instruction.Move(marina.getOnlyDock(),
1875                                          Predicate.IgnoreFlagD, // predicate
1876                                          torpedoable,           // torpedoable
1877                                          null,                  // path
1878                                          true,                  // tokenIn
1879                                          false,                 // dataIn
1880                                          false,                 // latchData
1881                                          false,                 // latchPath
1882                                          false,                 // dataOut
1883                                          true                   // tokenOut
1884                                          ),
1885                     // FIXME: this probably should be removed, unless Ivan doesn't want to change the behavior
1886                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1887
1888                     SEND_DATA,
1889                 });
1890
1891             // expect nothing to come out, because the NOP is executing
1892             dataItems = marina.northRing.drainMany(2);
1893             fatal(dataItems.size()!=0, "Expected no data item(s) to emerge but got at least: "+dataItems.size()+" data items");
1894
1895             marina.southRing.fillTorpedo();
1896
1897             int expected = torpedoable?1:0;
1898             dataItems = marina.northRing.drainMany(2);
1899             fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
1900
1901             fatal(!marina.getILCDone(), "Expected ilc=done, but got "+marina.getILC());
1902         }
1903
1904         adjustIndent(-2);
1905         prln("End testTorpedoOnAnInfinite");
1906     }
1907
1908     private void testDFlagWhenTorpedoLyingInWait(Marina marina) {
1909         marina.southRing.fill(new Instruction[] {
1910                 setOlc(1),
1911                 RECV_DATA,
1912                 TORPEDOABLE_RECV_DATA,
1913                 FLAG_NOP,
1914                 FLAG_NOP,
1915                 FLAG_NOP,
1916                 SEND_TOKEN_IF_D_SET,
1917             });
1918
1919         expectTokensExactly(0);
1920
1921         // changing the order of these lines should work, but it does not
1922         marina.northRing.fill();
1923         marina.southRing.fillTorpedo();
1924
1925         expectTokensExactly(1);
1926     }
1927
1928     private void testSetOlcFollowedByDPredicated(Marina marina) {
1929         for(boolean d_set : new boolean[] { false, true }) {
1930             prln("");
1931             marina.southRing.fill(new Instruction[] {
1932                     setOlc(0),
1933                     marina.kesselsCounter ? null : FLAG_NOP,
1934                     d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
1935                 });
1936             expectNorthFifoExactly(d_set ? 1 : 0);
1937
1938             prln("");
1939             marina.southRing.fill(new Instruction[] {
1940                     setOlc(32),
1941                     marina.kesselsCounter ? null : FLAG_NOP,
1942                     d_set ? SEND_DATA_IF_D_SET : SEND_DATA_IF_D_NOT_SET,
1943                 });
1944             expectNorthFifoExactly(d_set ? 0 : 1);
1945
1946             if (marina.kesselsCounter) {
1947                 marina.masterClear();
1948                 marina.southRing.enableInstructionSend(true);
1949             }
1950         }
1951     }
1952
1953     private void testOlcDecrementAtHighSpeed(Marina marina) {
1954         prln("Begin testOlcDecrementAtHighSpeed");
1955         adjustIndent(2);
1956
1957         List<BitVector> dataItems;
1958
1959         // Each element of the following pair of arrays is one "test".
1960         // The OLC will be loaded with olcs[i] and then decremented
1961         // decr_amounts[i] times; after that has happened the zeroness
1962         // of the OLC will be checked by executing a MOVE with
1963         // [olc!=0] as the predicate.
1964
1965         int[] olcs         = new int[] { 3, 3, 3, 10, 41 };
1966         int[] decr_amounts = new int[] { 2, 3, 4, 9,  9  };
1967
1968         for(int which=0; which<olcs.length; which++) {
1969             int olc = olcs[which];
1970             int decr_amount = decr_amounts[which];
1971
1972             prln("inserting set olc="+olc);
1973             prln("inserting set ilc=1");
1974             marina.southRing.fill(new Instruction[] {
1975                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1),
1976                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,olc),
1977                 });
1978
1979             // commenting the following four lines causes this test to pass
1980
1981             prln("inserting: "+decr_amount+" olc-- instructions");
1982             prln("inserting: [!d] send data");
1983             Instruction[] instructions = new Instruction[decr_amount+1];
1984             for(int i=0; i<decr_amount; i++)
1985                 instructions[i] =
1986                     new Instruction.Set(marina.getOnlyDock(),
1987                                         Predicate.Default,
1988                                         SetDest.OuterLoopCounter,
1989                                         SetSource.Decrement);
1990             instructions[instructions.length-1] =
1991                 new Instruction.Move(marina.getOnlyDock(),
1992                                      Predicate.Default,     // predicate
1993                                      false,                 // torpedoable
1994                                      null,                  // path
1995                                      false,                 // tokenIn
1996                                      false,                 // dataIn
1997                                      false,                 // latchData
1998                                      false,                 // latchPath
1999                                      true,                  // dataOut
2000                                      false                  // tokenOut
2001                                      );
2002
2003             marina.southRing.fill(instructions);
2004             model.waitNS(64 * CYCLE_TIME_NS);
2005
2006             int expected = decr_amount>=olc ? 0 : 1;
2007             dataItems = marina.northRing.drainMany(2);
2008             fatal(dataItems.size()!=expected, "Expected "+expected+" item to emerge but got: "+dataItems.size()+" data items");
2009             expectOlc(Math.max(0,olc-decr_amount));
2010
2011             if (marina.kesselsCounter) {
2012                 // master clear on each iteration; otherwise we'd need to "run down" the olc
2013                 marina.masterClear();
2014                 marina.southRing.enableInstructionSend(true);
2015             }
2016         }
2017
2018         adjustIndent(-2);
2019         prln("End testOlcDecrementAtHighSpeed");
2020     }
2021
2022     private void flipIlcBit(Marina marina) {
2023         prln("Begin flipIlcBit");
2024         adjustIndent(2);
2025         prln("Using the set ILC instruction, toggle a single bit between zero and one. \n" +
2026              "Check correct setting of the ILC zero bit");
2027
2028         for (int i=0; i<6; i++) {
2029             int notZero = 1<<i;
2030
2031             prln("Then immediately set ILC="+notZero);
2032             marina.southRing.fill(new Instruction[] {
2033                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
2034                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
2035                 });
2036
2037             model.waitNS(64 * CYCLE_TIME_NS);
2038
2039             prln("Verify ILC using scan chain");
2040             int ilcCount = marina.getILC();
2041             fatal(ilcCount!=notZero, "bad ILC count: "+ilcCount+" expected: "+notZero);
2042             fatal(marina.getILCInfinity(), "bad ILC Infinity bit: true");
2043
2044             marina.southRing.fill(new Instruction[] {
2045                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero),
2046                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0),
2047                 });
2048
2049             model.waitNS(64 * CYCLE_TIME_NS);
2050
2051             prln("Verify ILC using scan chain");
2052             ilcCount = marina.getILC();
2053             fatal(ilcCount!=0, "bad ILC count: "+ilcCount+" expected: 0");
2054             fatal(marina.getILCInfinity(), "bad ILC Infinity bit: true");
2055         }
2056
2057         adjustIndent(-2);
2058         prln("End flipIlcBit");
2059     }
2060     private void flipOlcBit(Marina marina) {
2061         prln("Begin flipOlcBit");
2062         adjustIndent(2);
2063         prln("Using the set OLC instruction, toggle a single bit between zero and one. \n" +
2064              "Check correct setting of the OLC zero bit");
2065
2066         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
2067
2068         for (int i=0; i<6; i++) {
2069             int notZero = 32 >> i;
2070
2071             if (marina.kesselsCounter) {
2072                 // master clear on each iteration; otherwise we'd need to "run down" the olc
2073                 marina.masterClear();
2074                 marina.southRing.enableInstructionSend(true);
2075             }
2076
2077             int outOlc;
2078             prln("Set OLC=0");
2079             prln("Then immediately set OLC="+notZero);
2080             marina.southRing.fill(new Instruction[] {
2081                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
2082                     new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
2083                 });
2084
2085             model.waitNS(64 * CYCLE_TIME_NS);
2086             prln("Verify OLC count using scan chain");
2087             expectOlc(notZero);
2088
2089             if (!marina.kesselsCounter) {
2090                 prln("Set OLC="+notZero);
2091                 prln("Then immediately set OLC=0");
2092                 marina.southRing.fill(new Instruction[] {
2093                         new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero),
2094                         new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0),
2095                     });
2096
2097                 model.waitNS(64 * CYCLE_TIME_NS);
2098                 prln("Verify OLC count using scan chain");
2099                 expectOlc(0);
2100             }
2101         }
2102
2103         adjustIndent(-2);
2104         prln("End flipOlcBit");
2105     }
2106     private void testSouthRecirculate(Marina marina, int AMOUNT) {
2107         prln("Begin testSouthRecirculate("+AMOUNT+")");
2108         adjustIndent(2);
2109
2110         marina.southRing.enableInstructionSend(false);
2111         marina.southRing.enableInstructionRecirculate(true);
2112
2113         prln("Completely fill south ring");
2114         adjustIndent(2);
2115         for (int i=0; i<AMOUNT; i++) {
2116             prln("inserting item " + (i+1) + " / " + AMOUNT);
2117             BitVector path = new BitVector(MarinaPacket.PATH_WIDTH, "path");
2118             BitVector data = new BitVector(MarinaPacket.WORD_WIDTH, "path");
2119             path.set(0, MarinaPacket.PATH_WIDTH, false);
2120             data.setFromLong(i+9);
2121             marina.southRing.fill(new MarinaPacket(data, false, path));
2122         }
2123         adjustIndent(-2);
2124
2125         prln("Drain south ring and check contents");
2126         adjustIndent(2);
2127         List<BitVector> out = marina.southRing.drainMany();
2128         boolean bad = false;
2129         for (int i=0; i<AMOUNT; i++) {
2130             prln("extracting item " + (i+1) + " / " + AMOUNT);
2131             //int expect = (i+Marina.SOUTH_RING_CAPACITY-1) % Marina.SOUTH_RING_CAPACITY;
2132             int expect = i+9;
2133             long got = new MarinaPacket(out.get(i)).data.toLong();
2134             if (got!=expect) {
2135                 bad = true;
2136                 prln("  bad instruction: "+got+" expected: "+expect);
2137             } else {
2138                 prln("  good instruction.");
2139             }
2140         }
2141         fatal(bad, "data inserted does not match data retrieved");
2142         adjustIndent(-2);
2143
2144         for (int i=0; i<5; i++) {}
2145
2146         adjustIndent(-2);
2147         prln("End testSouthRecirculate("+AMOUNT+")");
2148     }
2149
2150
2151     private void testOverfillTokens(Marina marina) {
2152         prln("Begin testOverfillTokens");
2153         adjustIndent(2);
2154
2155         for(int i=0; i<marina.TOKEN_FIFO_CAPACITY + 3; i++)
2156             marina.southRing.fill(SEND_TOKEN);
2157         marina.southRing.fill(SEND_DATA);
2158         expectNorthFifoExactly(0);
2159
2160         adjustIndent(-2);
2161         prln("End testSouthRecirculate");
2162     }
2163
2164
2165
2166     private void doOneTest(int testNum) throws Exception {
2167         try {
2168             doOneTest_(testNum);
2169         } catch (MarinaUtils.FailureException fe) {
2170             System.out.println("******************************************************************************");
2171             System.out.println("******************************************************************************");
2172             System.out.println("******************************************************************************");
2173             System.out.println("******************************************************************************");
2174             fe.printStackTrace();
2175             System.exit(-1);
2176         }
2177     }
2178
2179     private void doOneTest_(int testNum) throws Exception {
2180         prln("");
2181         prln("============================================================");
2182         prln("MarinaTest: performing test: "+testNum);
2183
2184         if (testNum==999) {
2185             //vdd = 0.5f;
2186             vdd = 1.0f;
2187             int[] tests = new int[] { 1002, 1003, 1005, 3002, 3004, 3005, 3006, 3008, 3009, 3025, 3026, 3029 };
2188             try {
2189                 PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("test.out")));
2190                 while(vdd <= 1.3f) {
2191                     vdd10.setVoltageWait(vdd);
2192                     System.out.println("vdd10 = " + vdd10.readVoltage());
2193                     Thread.sleep(1000);
2194                     for(int i=0; i<tests.length; i++) {
2195                         try {
2196                             doOneTest_(tests[i]);
2197                             pw.println(vdd + " " + i + " " + "1");
2198                         } catch (MarinaUtils.FailureException fe) {
2199                             pw.println(vdd + " " + i + " " + "0");
2200                         }
2201                         pw.flush();
2202                     }
2203                     vdd -= 0.01f;
2204                 }
2205             } catch (Exception e) { throw new RuntimeException(e); }
2206         }
2207
2208         if (testNum!=0) {
2209             marina.masterClear();
2210             marina.southRing.enableInstructionSend(true);
2211         }
2212
2213         MarinaUtils.testnum = testNum;
2214
2215         switch (testNum) {
2216             case 0: {
2217
2218                 doOneTest(1);       // passes extracted parasitics
2219                 doOneTest(2);       // passes extracted parasitics
2220                 doOneTest(3);       // passes extracted parasitics
2221                 doOneTest(4);       // passes extracted parasitics
2222                 doOneTest(5);       // passes extracted parasitics
2223                 doOneTest(6);
2224
2225                 doOneTest(1000);    // passes extracted parasitics
2226                 doOneTest(1001);    // passes extracted parasitics
2227                 doOneTest(1003);    // passes extracted parasitics
2228                 doOneTest(1005);
2229                 doOneTest(3000);    // passes extracted parasitics
2230                 doOneTest(3001);    // passes extracted parasitics
2231                 doOneTest(3003);    // passes extracted parasitics
2232                 doOneTest(3004);    // passes extracted parasitics
2233                 doOneTest(3005);    // passes extracted parasitics
2234                 doOneTest(3006);    // passes extracted parasitics
2235                 doOneTest(3007);    // passes extracted parasitics
2236                 doOneTest(3008);    // passes extracted parasitics
2237                 doOneTest(3009);    // passes extracted parasitics
2238                 doOneTest(3010);    // passes extracted parasitics
2239                 doOneTest(3011);    // passes extracted parasitics
2240                 doOneTest(3012);    // passes extracted parasitics
2241                 doOneTest(3013);    // passes extracted parasitics
2242                 doOneTest(3014);    // passes extracted parasitics
2243                 doOneTest(3015);    // passes extracted parasitics
2244                 doOneTest(3019);    // passes extracted parasitics
2245                 doOneTest(3020);    // passes extracted parasitics
2246                 doOneTest(3022);    // passes extracted parasitics
2247                 doOneTest(3023);    // passes extracted parasitics
2248                 doOneTest(3025);    // passes extracted parasitics
2249                 doOneTest(3026);    // passes extracted parasitics
2250                 doOneTest(3027);    // passes extracted parasitics
2251                 doOneTest(3028);    // passes extracted parasitics
2252                 doOneTest(3029);    // passes extracted parasitics
2253                 //doOneTest(3030);    // passes extracted parasitics (questionable)
2254                 //doOneTest(3031);    // passes extracted parasitics should not pass!
2255
2256                 // these tests take a while and usually pass
2257                 doOneTest(1002);
2258                 doOneTest(1004);
2259                 doOneTest(1005);
2260                 doOneTest(1006);
2261                 doOneTest(3002);
2262                 doOneTest(3016);
2263                 doOneTest(3021);
2264                 doOneTest(3024);
2265                 doOneTest(3025);
2266                 doOneTest(3040);
2267
2268                 // this takes an insanely long time
2269                 doOneTest(3017);
2270                 break;
2271             }
2272             case 1:    testChains(marina);                     break; // passes, 24-Mar (+verilog)
2273             case 2:    testProperStoppers(marina);             break; // passes, 24-Mar (+verilog)
2274             case 3:    testSouthRecirculate(marina, 1);        break; // passes, 24-Mar (+verilog)
2275             case 4:    getCtrsFlags(marina);                   break; //         20-Apr (+verilog)
2276             case 5:    sendInstructions(marina);               break; // passes, 24-Mar (+verilog)
2277             case 6:    walkOneOLC(marina);                     break; //         21-Apr (+verilog)
2278
2279                 // Russell's tests begin with 1000
2280             case 1000: walkOneILC(marina);                     break; //         20-Apr (+verilog)
2281             case 1001: countIlc(marina);                       break; //         20-Apr (+verilog)
2282             case 1002: countOlc(marina);                       break; //         23-Apr (+verilog)
2283
2284             case 1003: sendTorpedo(marina);                    break; //         23-Apr (+verilog)  [with wor-hack]
2285
2286             case 1004: flipIlcBit(marina);                     break; //         20-Apr (+verilog)
2287             case 1005: flipOlcBit(marina);                     break; //         21-Apr (+verilog)
2288
2289             case 1006: testSouthRecirculate(marina, Marina.SOUTH_RING_CAPACITY-1);        break; // passes, 24-Mar (+verilog)
2290
2291                 // Adam's tests begin with 3000
2292             case 3000: sendToken(marina);                      break; // passes, 24-Mar (+verilog)
2293             case 3001: testFlagAB(marina);                     break; // passes, 08-Apr (+verilog)
2294             case 3002: testPredicationOnAB(marina);            break; //         22-Apr (+verilog)
2295             case 3003: testFlagC(marina);                      break; //         23-Apr (+verilog)
2296             case 3004: testFlagD(marina);                      break; //         23-Apr (+verilog)
2297             case 3005: testFlagDRecomputationTime(marina);     break;
2298
2299             case 3006: testTailWaitsForHead(marina);           break;
2300             case 3007: testTailWithoutHead(marina);            break;
2301             case 3008: testHeadWaitsForTail(marina);           break; //         22-Apr (+verilog)
2302             case 3009: testAbort(marina);                      break; //         22-Apr (+verilog)
2303
2304             case 3010: sendData(marina);                       break; // passes, 24-Mar (+verilog)
2305             case 3011: recvData(marina);                       break; //         21-Apr (+verilog)
2306             case 3012: sendDataWithPath(marina);               break; // passes, 13-Apr (+verilog)
2307
2308             case 3013: testSignExtendedLiteral(marina);        break; //         20-Apr (+verilog)
2309             case 3014: testShiftedLiteral(marina);             break; //         20-Apr (+verilog)
2310             case 3015: testSendAndRecvToken(marina);           break; //         21-Apr (+verilog)
2311
2312             case 3016: sendDataIlcInfinite(marina);            break; //         22-Apr (+verilog)
2313             case 3017: testFlagTruthTable(marina);             break; //         23-Apr (+verilog)
2314
2315             case 3019: setOlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
2316             case 3020: setIlcFromDataLatch(marina);            break; //         23-Apr (+verilog)
2317             case 3021: recvPath(marina);                       break; //         22-Apr (+verilog)
2318             case 3022: testILC(marina);                        break; //         23-Apr (+verilog)
2319             case 3023: testTorpedoOnAnInfinite(marina);        break; //         23-Apr (+verilog)
2320             case 3024: testRecvAndSendWalkingOne(marina);      break; //         21-Apr (+verilog)
2321             case 3025: testOlcDecrementAtHighSpeed(marina);    break; //         23-Apr (+verilog)
2322
2323             case 3026: testNonTorpedoableMoveDoesNotResetDFlag(marina);        break; //         23-Apr (+verilog)
2324             case 3027: testILCZero(marina);                    break;
2325             case 3028: testAbortOutsideOfLoop(marina); break;
2326             case 3029: testDFlagWhenTorpedoLyingInWait(marina); break;
2327             case 3030: testSetOlcFollowedByDPredicated(marina); break;
2328             case 3031: testOverfillTokens(marina); break;
2329
2330             case 3040: loadEveryValueOLC(marina); break;
2331             case 6666: {
2332                 SubchainNode chainNode =
2333                     (SubchainNode)marina.dukeChain
2334                     .findNode("marina.duke.marinaGu@0.dukeAll@1.dukePart@0.ring37sW@1.scanner@0.scanFx1@1.scanCell@3");
2335                 int bitIndex = chainNode.getBitIndex();
2336                 ChainNode root = chainNode.getParentChain();
2337
2338                 for(int i=0; i<13; i++) {
2339                     System.out.println("i="+i);
2340                     for(int j=0; j<12; j++)
2341                         root.getInBits().set(bitIndex+j, false);
2342                     root.getInBits().set(bitIndex+i, true);
2343                     marina.dukeChain.shift(Marina.DUKE_CHAIN, false, true);
2344                     System.in.read();
2345                 }
2346                 break;
2347             }
2348
2349             case 7777: {
2350
2351                 int wait = 300;
2352
2353                 PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("out.dat")));
2354
2355                 vdd = 0.9f;
2356                 vdd18.setVoltageWait((float)Math.max(1.8,vdd));
2357                 //vdd10.setVoltageWait(vdd);
2358
2359                 if (!Marina.kesselsCounter) throw new RuntimeException();
2360                 if (!Marina.omegaCounter) throw new RuntimeException();
2361
2362                 for(int xx=1; xx<65; xx++) {
2363                 marina.masterClear();
2364                 marina.northRing.sink();
2365                 marina.stopAndResetCounters();
2366
2367                 marina.southRing.enableInstructionSend(true);
2368                 marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
2369                                                                   Instruction.Set.FlagFunction.ZERO
2370                                                                   .add(Predicate.FlagA).add(Predicate.NotFlagA),
2371                                                                   Instruction.Set.FlagFunction.ZERO));
2372                 //int xx = 63;      // 1.802ms
2373                 //int xx = 1;         // 0.207ms  =>  24.3ns for 62 counts => 390ps cycle time => 2.5Ghz
2374                 marina.southRing.fill(new Instruction[] {
2375                         new Instruction.Head(marina.getOnlyDock()),
2376                         setOlc(xx),
2377                         FLAG_NOP,
2378                         FLAG_NOP,
2379                         TORPEDOABLE_RECV_DATA,
2380                         FLAG_NOP,
2381                         FLAG_NOP,
2382                         SEND_DATA,
2383                         new Instruction.Tail(marina.getOnlyDock()),
2384                     }, false, false);
2385
2386                 marina.southRing.fill(new Instruction[] {
2387                         /*
2388                           new Instruction.Set(marina.getOnlyDock(),Predicate.FlagD,
2389                           Instruction.Set.FlagFunction.ZERO.add(Predicate.NotFlagA),
2390                           Instruction.Set.FlagFunction.ZERO),
2391                           setOlcIfZero(32),
2392                           setIlc(63),
2393                           SEND_DATA_IF_A_SET_AND_D_NOT_SET,
2394                           setIlc(63),
2395                           SEND_DATA_IF_A_SET_AND_D_NOT_SET,
2396                           DEC,
2397                           setIlc(63),
2398                           SEND_DATA_IF_A_SET_AND_D_NOT_SET,
2399                           setIlc(63),
2400                           SEND_DATA,
2401                         */
2402                         null,
2403                         null,
2404                         null,
2405                         null,
2406                         null,
2407                         null,
2408                         null,
2409                         null,
2410                     }, true, true);
2411
2412                 //marina.startCounters(false, false);
2413
2414                 marina.southRing.run();
2415
2416                 vdd10.setVoltageWait(vdd);
2417                 marina.startCounters(false, true);
2418
2419                 try { Thread.sleep(wait); } catch (Exception e) { }
2420                 //marina.southRing.stop();
2421
2422                 marina.stopAndResetCounters();
2423                 int countNorth = marina.getNorthCount();
2424                 int countSouth = marina.getSouthCount();
2425                 pw.println(xx + " " + countNorth + " " + vdd + " " + vdd10.readCurrent());
2426                 pw.flush();
2427                 System.out.println(xx + " " + countNorth + " " + vdd + " " + vdd10.readCurrent());
2428                 }
2429                 pw.close();
2430                 break;
2431             }
2432             case 8888: {
2433
2434                 //int wait = 1000;
2435                 int wait = 200;
2436                 //int toks = 1;
2437
2438                 PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("out.dat")));
2439                 for(double myvdd = 1.00; myvdd<1.01; myvdd += 0.05) {
2440                     vdd = (float)myvdd;
2441                     vdd18.setVoltageWait((float)Math.max(1.8,vdd));
2442                     vdd10.setVoltageWait(vdd);
2443                     Thread.sleep(1000);
2444
2445                     for(int toks = 0; toks < 13; toks++) {
2446                         int MAX_ITER = 10;
2447                         double total = 0;
2448                         for(int iter = 0; iter < MAX_ITER; iter++) {
2449
2450                             marina.masterClear();
2451                             marina.northRing.sink();
2452                             marina.stopAndResetCounters();
2453
2454                             marina.southRing.enableInstructionSend(true);
2455                             marina.southRing.fill(setOlc(1));
2456                             marina.southRing.fill(new Instruction.Head(marina.getOnlyDock()));
2457                             for(int i=0; i<toks; i++)
2458                                 marina.southRing.fill(/*SEND_DATA*/NOP);
2459                             marina.southRing.fill(new Instruction[] {
2460                                     new Instruction.Tail(marina.getOnlyDock()),
2461                                 }, false, true);
2462
2463                             marina.southRing.run();
2464
2465                             // have to set the voltage while drawing current
2466                             vdd10.setVoltageWait(vdd);
2467
2468                             marina.startCounters();
2469                             try { Thread.sleep(wait); } catch (Exception e) { }
2470                             marina.stopAndResetCounters();
2471                             //marina.southRing.stop();
2472
2473                             int countNorth = marina.getNorthCount();
2474                             int countSouth = marina.getSouthCount();
2475                             System.out.println();
2476                             System.out.println();
2477                             if (countSouth > (2<<29))
2478                                 System.out.println("warning: count was greater than 2^29...");
2479                             double gst = ((((double)countSouth*2)) / (1000000. * wait /* * toks*/));
2480                             System.out.println("south counter is: " + countSouth + ", which is " + gst + "Ginst/sec with toks="+toks + " @vdd="+vdd);
2481                             total += gst;
2482
2483                             System.out.println();
2484                             System.out.println();
2485                             /*
2486                               System.out.println("counters are " + count + " and " + countNorth + "; ratio is "+
2487                               (((double)countNorth)/((double)(count*2))) + " " +
2488                               (((double)countNorth)/((double)(count*2+1))) + " " +
2489                               "");
2490                             */
2491                         }
2492                         float vdd10v = vdd10.readVoltage();
2493                         float vdd18v = vdd18.readVoltage();
2494                         float vddsv  = vdds.readCurrent();
2495                         float vdd10c = vdd10.readCurrent();
2496                         float vdd18c = vdd18.readCurrent();
2497                         pw.println(vdd + " " +
2498                                    toks + " " +
2499                                    (((double)total) / MAX_ITER) + " " +
2500                                    //vddsv  + " " +
2501                                    vdd10c + " " +
2502                                    vdd18v + " " +
2503                                    vdd18c + " " +
2504                                    "");
2505                         pw.flush();
2506                     }
2507                 }
2508                 break;
2509             }
2510             case 8889: {
2511
2512                 int wait = 1000;
2513                 //int wait = 200;
2514                 //int toks = 1;
2515
2516                 PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("out.dat")));
2517                 for(int toks = 0; toks < 13; toks++) {
2518                     int MAX_ITER = 10;
2519                     double total = 0;
2520                     for(int iter = 0; iter < MAX_ITER; iter++) {
2521
2522                         marina.masterClear();
2523                         marina.northRing.sink();
2524                         marina.stopAndResetCounters();
2525
2526                         marina.southRing.enableInstructionSend(true);
2527                         marina.southRing.fill(setOlc(1));
2528                         marina.southRing.fill(new Instruction.Set(marina.getOnlyDock(),Predicate.IgnoreFlagD,
2529                                                                           Instruction.Set.FlagFunction.ZERO,
2530                                                                           Instruction.Set.FlagFunction.ZERO));
2531                         marina.southRing.fill(new Instruction.Head(marina.getOnlyDock()));
2532                         //marina.southRing.fill(setIlc(31));
2533                         marina.southRing.fill(SEND_DATA);
2534                         for(int i=0; i<toks+1; i++) {
2535                             //marina.southRing.fill(FLAG_NOP_IF_FLAG_A);
2536                             marina.southRing.fill(FLAG_NOP);
2537                         }
2538                         marina.southRing.fill(new Instruction[] {
2539                                 new Instruction.Tail(marina.getOnlyDock()),
2540                             }, false, true);
2541                         marina.startCounters();
2542
2543                         marina.southRing.run();
2544                         try { Thread.sleep(wait); } catch (Exception e) { }
2545
2546                         marina.stopAndResetCounters();
2547                         int countNorth = marina.getNorthCount();
2548                         int count      = marina.getSouthCount();
2549                         System.out.println();
2550                         System.out.println();
2551                         if (count > (2<<29))
2552                             System.out.println("warning: count was greater than 2^29...");
2553                         double gst = ((((double)count*2)) / (1000000. * wait /* * toks*/));
2554                         System.out.println("south counter is: " + count + ", which is " + gst + "Ginst/sec with toks="+toks + " @vdd="+vdd);
2555                         total += gst;
2556
2557                         System.out.println();
2558                         System.out.println();
2559                     }
2560                     pw.println(vdd + " " + toks + " " + (((double)total) / MAX_ITER));
2561                     pw.flush();
2562                 }
2563                 break;
2564             }
2565             case 9999:
2566                 loadEveryValueOLC(marina);
2567                 countOlc(marina);
2568                 break;
2569
2570             default:
2571                 fatal(true, "Test number: "+testNum+" doesn't exist.");
2572                 break;
2573         }
2574         prln("Test Result: Passed");
2575         printTestTime();
2576     }
2577
2578     public static void main(String[] args) throws Exception {
2579         startTime = System.currentTimeMillis();
2580         cmdArgs = new CmdArgs(args);
2581         reportTask(cmdArgs);
2582         Infrastructure.gpibControllers = new int[]{1};
2583         vdds  = new Pst3202Channel("ch1", "tiPST3202", 1);
2584         vdd18 = new Pst3202Channel("ch3", "tiPST3202", 3);
2585         vdd10 = new PowerChannelResistorVoltageReadable(new Pst3202Channel("ch2", "tiPST3202", 2),
2586                                                         1000,
2587                                                         new HP34401A("HP34970"),
2588                                                         true);
2589         if (vdd10!=null) setVdd10(vdd);
2590         if (vdd18!=null) vdd18.setVoltageNoWait(1.8f);
2591
2592         model = cmdArgs.useVerilog
2593             ? new VerilogModel()
2594             : cmdArgs.useHsim
2595             ? new HsimModel()
2596             : cmdArgs.silicon
2597             ? new SiliconChip()
2598             : new NanosimModel();
2599
2600         if (model instanceof SimulationModel)
2601             ((SimulationModel)model).setOptimizedDirectReadsWrites(true);
2602
2603         CYCLE_TIME_NS = cmdArgs.useVerilog ? (100*20) : 0.250;
2604         int khz   =
2605             model instanceof VerilogModel
2606             ? 100000
2607             : cmdArgs.jtagShift
2608             ? 20000
2609             : model instanceof ChipModel
2610             ? 1000
2611             : 1000000;
2612
2613         System.err.println("constructing jtag controller");
2614         JtagTester tester =
2615             model instanceof SimulationModel
2616             ? ((SimulationModel)model).createJtagTester("TCK", "TMS", "TRSTb", "TDI", "TDO")
2617             : new Netscan("jtag2");
2618         //: new Netscan("10.0.0.200");
2619         //: new Signalyzer();
2620         //: new Netscan("jtag2");
2621         JtagLogicLevel mc0=null;
2622         JtagLogicLevel mc1=null;
2623         if (tester instanceof NetscanGeneric) {
2624             ((NetscanGeneric)tester).reset();
2625             // master clear
2626             // not sure if "GPIO1" means "index 0" or not
2627             mc0 = new JtagLogicLevel(tester, 0);
2628             mc1 = new JtagLogicLevel(tester, 1);
2629             mc1 = mc0;
2630             mc0.setLogicState(true);
2631             mc1.setLogicState(true);
2632         }
2633         tester.printInfo = false;
2634         PowerChannel pc = new ManualPowerChannel("pc", false);
2635         cc = new ChainControl(SCAN_CHAIN_XML, tester, 1.8f, khz);
2636         cc.noTestSeverity = Infrastructure.SEVERITY_NOMESSAGE;
2637         ct = new ChainTest(cc, pc);
2638         marina = new Marina(cc, cc, cc, cc, model, !cmdArgs.jtagShift, indenter);
2639         marina.mc0=mc0;
2640         marina.mc1=mc1;
2641         new MarinaTest(marina);
2642     }
2643
2644 }