src/com/sun/vlsi/chips/marina/test/Marina.java

   1 package com.sun.vlsi.chips.marina.test;
   2 /* -*- tab-width: 4 -*- */
   3 import com.sun.electric.tool.simulation.test.*;
   4
   5 import edu.berkeley.fleet.api.Instruction;
   6 import edu.berkeley.fleet.marina.MarinaPath;
   7
   8 /** The Marina object will eventually represent the Marina test chip.
   9  * Right now, it doesn't do much of anything. It just helps me exercise
  10  * my test infrastructure. */
  11 public class Marina {
  12
  13     public static final int INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE  = 5;
  14     public static final int INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO = MarinaPath.SIGNAL_BIT_INDEX;
  15
  16
  17     public static int TOKEN_FIFO_CAPACITY = 3;
  18
  19     //public static boolean kesselsCounter = true;
  20     public static boolean kesselsCounter = false;
  21     public static boolean omegaCounter = false;
  22
  23     public static final String DATA_CHAIN =    kesselsCounter ? "marina.marina_data" : "marina.ivan_data";
  24     public static final String CONTROL_CHAIN = kesselsCounter ? "marina.marina_control" : "marina.ivan_control";
  25     public static final String REPORT_CHAIN =  kesselsCounter ? "marina.marina_report" : "marina.ivan_report";
  26
  27     public static String prefix = "marinaGu@0.outDockW@"+(kesselsCounter?"3":"0")+".marinaOu@"+(kesselsCounter?"1":"0")+".";
  28     public static String MASTER_CLEAR = "mc";
  29
  30
  31     /*
  32     private static String prefix = "outDockW@"+(kesselsCounter?"3":"0")+".marinaOu@1.";
  33     private static String MASTER_CLEAR = "EXTmasterClear";
  34     */
  35
  36     private static final String OLC_PATH_EVEN =
  37         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.scanEx3h@1"; // bits 2,4,6
  38     private static final String OLC_PATH_ODD =
  39         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.scanEx3h@2"; // bits 1,3,5
  40     public static final String OLC_PATH_KESSEL =
  41         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.counte@0.adamScan@1.scanEx6h@";
  42     private static final String ILC_PATH_ODD =
  43         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx4h@0"; // bits 1,3,5,7
  44     private static final String ILC_PATH_EVEN =
  45         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx4h@1"; // bits 2,4,6,8
  46     private static final String FLAGS_PATH =
  47         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.scanEx3h@0";
  48
  49     private static final String INSTR_RING_CONTROL_PATH =
  50         prefix+"southFif@1.tapPropS@1.tapStage@2";
  51     private static final String TOK_FIFO_PATH =
  52         prefix+"tokenFIF@1";
  53     private static final String INSTRUCTION_COUNTER_PATH =
  54         prefix+"southFif@1.tapPropS@1.instruct@0";
  55     private static final String DATA_COUNTER_PATH =
  56         prefix+"northFif@1.fillDrai@1.instruct@0";
  57     private static final String TOK_PRED_PATH =
  58         prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.scanEx2h@0.scanCell@10";
  59
  60     private static final int COUNTER_LENGTH = 34;
  61     private static final int INSTRUCTION_SEND_NDX = 1;
  62     private static final int INSTRUCTION_RECIRCULATE_NDX = 0;
  63
  64     public static final int INSTRUCTION_LENGTH = 36;
  65
  66     private static final int A_FLAG_NDX = 0;
  67     private static final int B_FLAG_NDX = 1;
  68
  69     public static final int SOUTH_RING_CAPACITY = 11;
  70
  71     // ILC appears in scan chain as "count[1:6], zLo, i, dLo"
  72     public class Ilc {
  73         // value is bit reversed and complemented
  74         private int value;
  75         private Ilc() {
  76             shiftReport(true, false);
  77             BitVector odd  = cc.getOutBits(REPORT_CHAIN+"."+ILC_PATH_ODD).bitReverse().not();
  78             BitVector even = cc.getOutBits(REPORT_CHAIN+"."+ILC_PATH_EVEN).bitReverse().not();
  79             BitVector ret  = new BitVector(8, "olc");
  80             for(int i=0; i<4; i++) {
  81                 ret.set(i*2+1, odd.get(i));
  82                 ret.set(i*2,   even.get(i));
  83             }
  84             value = (int)ret.toLong();
  85         }
  86         /** Get the inner loop counter done bit. */
  87         public boolean getDone() {
  88             return (value & 0x40) != 0;
  89         }
  90         /** Get the inner loop counter infinity bit */
  91         public boolean getInfinity() {
  92             return (value & 0x80) != 0;
  93         }
  94         /** Get the 6 bits of count of the inner loop counter */
  95         public int getCount() {
  96             return value & 0x3f;
  97         }
  98         public String toString() {
  99             return "[ilc, count="+getCount()+", infinity="+getInfinity()+", done="+getDone()+"]";
 100         }
 101     }
 102
 103     private final Indenter indenter;
 104
 105     // The name of the scan chain
 106     // The instance path, from the top cell of the netlist, of the instance of infinityWithCover
 107     public final ChainControls cc;           // specifies the scan chain
 108     private final ChipModel model;
 109     public final ProperStopper data;
 110     public final InstructionStopper instrIn;
 111
 112     private void prln(String msg) {indenter.prln(msg);}
 113     private void pr(String msg) {indenter.pr(msg);}
 114
 115     /** Shift the report scan chain */
 116     public void shiftReport(boolean readEnable, boolean writeEnable) {
 117         cc.shift(REPORT_CHAIN, readEnable, writeEnable);
 118     }
 119
 120     /** Shift the report scan chain */
 121     private void shiftControl(boolean readEnable, boolean writeEnable) {
 122         cc.shift(CONTROL_CHAIN, readEnable, writeEnable);
 123     }
 124
 125     /** Shift the data scan chain */
 126     private void shiftData(boolean readEnable, boolean writeEnable) {
 127         cc.shift(DATA_CHAIN, readEnable, writeEnable);
 128     }
 129
 130     public Marina(ChainControls cc, ChipModel model, boolean clockHack, Indenter indenter) {
 131         this.cc = cc;
 132         this.model = model;
 133         this.indenter = indenter;
 134         data = new ProperStopper("north fifo",
 135                                  prefix+"northFif@1.fillDrai@1.properSt@1",
 136                                  CONTROL_CHAIN,
 137                                  DATA_CHAIN,
 138                                  REPORT_CHAIN,
 139                                  cc, model, clockHack, indenter,
 140                                  prefix+"northFif@1.fillDrai@1.instruct@0.cntScnTh@1.cntScnOn@1");
 141         instrIn = new InstructionStopper("south fifo",
 142                                          prefix+"southFif@1.tapPropS@1.properSt@1",
 143                                          CONTROL_CHAIN,
 144                                          DATA_CHAIN,
 145                                          REPORT_CHAIN,
 146                                          cc, model, clockHack, indenter,
 147                                          prefix+"southFif@1.tapPropS@1.instruct@0.cntScnTh@1.cntScnOn@1");
 148     }
 149
 150     int northCount = 0;
 151     int southCount = 0;
 152
 153     public void stopAndResetCounters() {
 154         instrIn.setCounterEnable(false);
 155         data.setCounterEnable(false);
 156         cc.shift(DATA_CHAIN, true, false);
 157         northCount = data.getCounterValue();
 158         southCount = instrIn.getCounterValue();
 159         data.setCounterValue(0);
 160         instrIn.setCounterValue(0);
 161     }
 162     public void startCounters() {
 163         instrIn.setCounterEnable(true);
 164         data.setCounterEnable(true);
 165     }
 166     public int getNorthCount() { return northCount; }
 167     public int getSouthCount() { return southCount; }
 168
 169
 170     public void masterClear() {
 171         final double WIDTH = 10; // ns
 172         // Put a high going pulse on the internal chip master clear signal
 173         if (model instanceof VerilogModel) {
 174
 175             data.clear();
 176             instrIn.clear();
 177
 178             VerilogModel vm = (VerilogModel)model;
 179             //
 180             // In real life the flags come up with some undefined
 181             // value.  In verilog we need to prevent the X'es from
 182             // propagating, so we force the flags to a known value
 183             //
 184             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__set_", 0);
 185             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__clr_", 1);
 186             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__set_", 0);
 187             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__clr_", 1);
 188
 189             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__set_", 1);
 190             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__clr_", 0);
 191
 192             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@0.net_50", 0);       // A
 193             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@1.net_50", 0);       // B
 194             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.litDandP@0.latch2in@0.hi2inLat@0.latchKee@0.out_B_", 0); // C
 195
 196             // possible C-flag inputs
 197             vm.setNodeState(prefix+"northFif@1.upDown8w@2.weakStag@22.ain["+(INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE+1)+"]", 0);
 198             vm.setNodeState(prefix+"northFif@1.upDown8w@2.weakStag@22.ain["+(INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO+1)+"]", 0);
 199
 200             // force the OLC to zero
 201             if (!kesselsCounter)
 202                 for(int i=1; i<=6; i++)
 203                     vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.inLO["+i+"]", (i==1)?0:1);
 204
 205             // set the ILC input to 1
 206             for(int i=1; i<=8; i++) {
 207                 if (i!=7)
 208                     vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.\\inLO["+i+"]", (i==1)?0:1);
 209             }
 210
 211             vm.setNodeState(prefix+"northFif@1.upDown8w@2.weakStag@22.addr1in2@0.fire", 1);
 212             model.waitNS(1000);
 213             vm.setNodeState(prefix+"northFif@1.upDown8w@2.weakStag@22.addr1in2@0.fire", 0);
 214             model.waitNS(1000);
 215
 216             vm.setNodeState(MASTER_CLEAR, 1);
 217             model.waitNS(1000);
 218             vm.setNodeState(MASTER_CLEAR, 0);
 219             model.waitNS(1000);
 220
 221             // pulse ilc[load] and olc[load]
 222             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_load_", 1);
 223             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_decLO_", 1);
 224             vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_torpLO_", 1);
 225             if (!kesselsCounter)
 226                 vm.setNodeState(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.olc_load_", 1);
 227             model.waitNS(100);
 228             model.waitNS(1);
 229             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_load_");
 230             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_decLO_");
 231             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.ilc_torpLO_");
 232             if (!kesselsCounter)
 233                 vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.olc_load_");
 234
 235             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__set_");
 236             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_A__clr_");
 237             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__set_");
 238             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_B__clr_");
 239
 240             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__set_");
 241             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flag_D__clr_");
 242
 243             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@0.net_50");
 244             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.flags@0.aFlag@1.net_50");
 245
 246             // Every move instruction, even those with Ti=0,Di=0,
 247             // loads the C-flag.  It will get loaded with an "X",
 248             // which will then leak into the flags and from there the
 249             // predicate.
 250             vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.litDandP@0.latch2in@0.hi2inLat@0.latchKee@0.out_B_");
 251             vm.releaseNode(prefix+"northFif@1.upDown8w@2.weakStag@22.ain["+(INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ONE+1)+"]");
 252             vm.releaseNode(prefix+"northFif@1.upDown8w@2.weakStag@22.ain["+(INDEX_OF_ADDRESS_BIT_COPIED_TO_C_FLAG_WHEN_DC_EQUALS_ZERO+1)+"]");
 253             vm.releaseNode(prefix+"northFif@1.upDown8w@2.weakStag@22.addr1in2@0.fire");
 254
 255             for(int i=1; i<=8; i++) {
 256                 if (i!=7)
 257                     vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.ilcMoveO@0.ilc@0.\\inLO["+i+"] ");
 258             }
 259             model.waitNS(1000);
 260
 261             if (!kesselsCounter)
 262                 for(int i=1; i<=6; i++)
 263                     vm.releaseNode(prefix+"outputDo@0.outM1Pre@0.outDockP@0.outDockC@0.olcWcont@0.olc@0.inLO["+i+"]");
 264
 265             // the proper stopper states come up in an undefined ("X")
 266             // state, so under Verilog we need to force them to a
 267             // known state
 268
 269             data.idle();
 270             instrIn.idle();
 271
 272         } else if (model instanceof NanosimModel) {
 273             NanosimModel nModel = (NanosimModel) model;
 274             /*
 275             nModel.setNodeVoltage(prefix+"sid[9]",1.0);
 276             nModel.setNodeVoltage(prefix+"sic[9]",1.0);
 277             nModel.setNodeVoltage(prefix+"sir[9]",1.0);
 278             nModel.waitNS(WIDTH);
 279             nModel.setNodeVoltage(prefix+"sid[9]",0.0);
 280             nModel.setNodeVoltage(prefix+"sic[9]",0.0);
 281             nModel.setNodeVoltage(prefix+"sir[9]",0.0);
 282             nModel.waitNS(1);
 283             */
 284             nModel.setNodeVoltage(MASTER_CLEAR,1.0);
 285             nModel.waitNS(WIDTH);
 286             nModel.setNodeVoltage(MASTER_CLEAR,0.0);
 287             nModel.waitNS(1);
 288         } else {
 289
 290             mc0.setLogicState(true);
 291             mc1.setLogicState(true);
 292             model.waitNS(1000);
 293             mc0.setLogicState(false);
 294             mc1.setLogicState(false);
 295             model.waitNS(1000);
 296
 297         }
 298         resetAfterMasterClear();
 299     }
 300
 301     JtagLogicLevel mc0;
 302     JtagLogicLevel mc1;
 303
 304     private void resetAfterMasterClear() {
 305         // The following call to ChainControl.resetInBits() is vital!
 306         // If you forget, then the inBits member initializes
 307         // with random data. Then when you do your first write,
 308         // some bits are written randomly.
 309         cc.resetInBits();
 310
 311         // For reset, I want to clear all the stoppers simultaneously
 312         data.clear();
 313         //tokOut.clear();
 314         instrIn.clear();
 315
 316         data.stop();
 317         //tokOut.stop();
 318         instrIn.stop();
 319
 320         data.resetAfterMasterClear();
 321         //tokOut.resetAfterMasterClear();
 322         instrIn.resetAfterMasterClear();
 323     }
 324
 325
 326     /** Get the 6 bit outer loop counter. */
 327     public int getOLC() {
 328         shiftReport(true, false);
 329         if (omegaCounter) {
 330             BitVector bits = null;
 331             for(int i=0; i<4; i++) {
 332                 BitVector x = cc.getOutBits(REPORT_CHAIN+"."+OLC_PATH_KESSEL+i);
 333                 //System.out.println("bits are: " + x);
 334                 bits = bits==null ? x : bits.cat(x);
 335             }
 336             System.out.print("  kesselsCounter = ");
 337             int ret = 0;
 338             boolean done = true;
 339             boolean bad = false;
 340             for(int bit=5; bit>=0; bit--) {
 341                 boolean zeroOrTwo  = bits.get(4+bit*3);
 342                 boolean zeroOrDone = bits.get(4+bit*3+1);
 343                 if      ( zeroOrTwo && !zeroOrDone) {
 344                     ret += (2<<bit);
 345                     System.out.print("2");
 346                     done = false;
 347                 } else if (!zeroOrTwo && !zeroOrDone) {
 348                     ret += (1<<bit);
 349                     System.out.print("1");
 350                     done = false;
 351                 } else if ( zeroOrTwo &&  zeroOrDone) {
 352                     System.out.print("0");
 353                     bad = true;
 354                     done = false;
 355                 } else if (!zeroOrTwo &&  zeroOrDone) {
 356                     System.out.print("_");
 357                     if (!done) bad = true;
 358                 }
 359                 // FIXME: check for unreduced counter and warn about it
 360             }
 361             if (bad) System.out.print("  WARNING: UNREDUCED COUNTER VALUE!!!!!!");
 362             System.out.println();
 363             return ret;
 364         } else if (kesselsCounter) {
 365             BitVector bits = null;
 366             for(int i=0; i<4; i++) {
 367                 BitVector x = cc.getOutBits(REPORT_CHAIN+"."+OLC_PATH_KESSEL+i);
 368                 //System.out.println("bits are: " + x);
 369                 bits = bits==null ? x : bits.cat(x);
 370             }
 371             //System.out.println("kesselsCounter = " + bits);
 372             int first = 0;
 373             int second = 0;
 374             String hi="";
 375             String lo="";
 376             String latched="";
 377             String res="";
 378             for(int i=0; i<6; i++) {
 379                 first  |= bits.get(4+i*3)   ? (1<<i) : 0;
 380                 second |= bits.get(4+i*3+2) ? (1<<i) : 0;
 381                 hi = (bits.get(4+i*3)   ? "1" : "0") + hi;
 382                 lo = (bits.get(4+i*3+2)   ? "1" : "0") + lo;
 383                 res =
 384                     (   bits.get(4+i*3) && !bits.get(4+i*3+2) ? "X"
 385                      : !bits.get(4+i*3) && !bits.get(4+i*3+2) ? "0"
 386                      : !bits.get(4+i*3) &&  bits.get(4+i*3+2) ? "1"
 387                      : "2")
 388                     +res;
 389                 latched = (bits.get(4+i*3+1)   ? "0" : "1") + latched;
 390             }
 391             System.out.println("kesselsCounter: "+
 392                                "s[1]="+hi+
 393                                " s[3]="+lo+
 394                                " latched="+latched +
 395                                " res="+res+
 396                                " do[ins]="+(bits.get(0) ? "1" : "0")+
 397                                " dec="+(bits.get(1) ? "1" : "0")+
 398                                " flag[D][set]="+(bits.get(2) ? "1" : "0")+
 399                                " resetting="+(bits.get(3) ? "1" : "0")+
 400                                ""
 401                                );
 402             return (first+second);
 403         } else {
 404             BitVector odd = cc.getOutBits(REPORT_CHAIN+"."+OLC_PATH_ODD).bitReverse();
 405             BitVector even = cc.getOutBits(REPORT_CHAIN+"."+OLC_PATH_EVEN).bitReverse();
 406             odd = odd.not();
 407             even = even.not();
 408             BitVector bv = new BitVector(6, "olc");
 409             for(int i=0; i<3; i++) {
 410                 bv.set(i*2,   odd.get(i));
 411                 bv.set(i*2+1, even.get(i));
 412             }
 413             return (int)bv.toLong();
 414         }
 415     }
 416     /** Get the 7 bit inner loop counter. The MSB is the zero bit.
 417      * The low order 6 bits are the count */
 418     public Ilc getILC() {
 419         return new Ilc();
 420     }
 421     /** Get the A flag */
 422     public boolean getFlagA() {
 423         shiftReport(true, false);
 424         return cc.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(A_FLAG_NDX);
 425     }
 426     /** Get the B flag */
 427     public boolean getFlagB() {
 428         shiftReport(true, false);
 429         return cc.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(B_FLAG_NDX);
 430     }
 431     /** return value of instruction counter. Instruction counter counts
 432      * the instructions flowing through 1/2 of alternating FIFO.
 433      * Caution: instruction counter is written by all scans,
 434      * regardless of readEnable or writeEnable! */
 435     public long getInstructionCounter() {
 436         shiftData(true, false);
 437         BitVector count = cc.getOutBits(DATA_CHAIN+"."+INSTRUCTION_COUNTER_PATH);
 438         int sz = count.getNumBits();
 439         MarinaTest.fatal(sz!=COUNTER_LENGTH, "wrong number of counter bits: "+sz+
 440                          " expected: "+COUNTER_LENGTH);
 441         return count.bitReverse().toLong();
 442     }
 443     /** return value of data counter. Data counter counts items flowing
 444      * through drain stage of data proper stopper.
 445      * Caution: data counter is written by all scans,
 446      * regardless of readEnable or writeEnable! */
 447     public long getDataCounter() {
 448         shiftData(true, false);
 449         BitVector count = cc.getOutBits(DATA_CHAIN+"."+DATA_COUNTER_PATH);
 450         int sz = count.getNumBits();
 451         MarinaTest.fatal(sz!=COUNTER_LENGTH, "wrong number of counter bits: "+sz+
 452                          " expected: "+COUNTER_LENGTH);
 453         return count.bitReverse().toLong();
 454     }
 455     /** Fill the "North" Fifo ring */
 456     public void fillNorthProperStopper() {
 457         BitVector data = new BitVector(37, "empty");
 458         BitVector addr = new BitVector(14, "empty");
 459         for(int i=0; i<data.getNumBits(); i++) data.set(i, false);
 460         for(int i=0; i<addr.getNumBits(); i++) addr.set(i, false);
 461         fillNorthProperStopper(new MarinaPacket(data, false, addr));
 462     }
 463     /** Fill the "North" Fifo ring */
 464     public void fillNorthProperStopper(MarinaPacket mp) {
 465         prln("inserting into north: " + mp);
 466         this.data.fill(mp.toSingleBitVector());
 467     }
 468     /** Enable the transmission of instructions from the instruction
 469      * ring test structure to the EPI FIFO. */
 470     public void enableInstructionSend(boolean b) {
 471         BitVector bv = cc.getInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH);
 472         bv.set(INSTRUCTION_SEND_NDX, b);
 473         cc.setInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH, bv);
 474         shiftControl(false, true);
 475     }
 476     /** Enable the recirculation of instructions within the South FIFO */
 477     public void enableInstructionRecirculate(boolean b) {
 478         BitVector bv = cc.getInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH);
 479         bv.set(INSTRUCTION_RECIRCULATE_NDX, b);
 480         cc.setInBits(CONTROL_CHAIN+"."+INSTR_RING_CONTROL_PATH, bv);
 481         shiftControl(false, true);
 482     }
 483     /** get the number of tokens in the token FIFO.
 484      * This includes the Token successor wire, the token FIFO wires,
 485      * and Token predecessor wire.
 486      * Master clear clears the token FIFO. */
 487     public int getNumTokens() {
 488         shiftReport(true, false);
 489         // get the token successor and token FIFO wires
 490         BitVector bv = cc.getOutBits(REPORT_CHAIN+"."+TOK_FIFO_PATH);
 491         int sz = bv.getNumBits();
 492         MarinaTest.fatal(sz!=3, "wrong token FIFO size: "+sz+" expected: 3");
 493
 494         // get the token predecessor wire
 495         BitVector pred = cc.getOutBits(REPORT_CHAIN+"."+TOK_PRED_PATH);
 496         sz = pred.getNumBits();
 497         MarinaTest.fatal(sz!=1, "wrong token predecessor size: "+sz+" expected: 1");
 498
 499         // concatenate them
 500         bv = bv.cat(pred);
 501         sz = bv.getNumBits();
 502         prln("Token state wires: "+bv.getState());
 503
 504         int nbTok = 0;
 505         for (int i=0; i<sz; i++) if (bv.get(i)) nbTok++;
 506         return nbTok;
 507     }
 508     /** Configure the test probe so it measures the throughput of
 509      * the north data FIFO. The test probe frequency is 8192
 510      * times slower than the FIFO throughput. This control has
 511      * highest priority. */
 512     public void probeDataCounter(Boolean b) {
 513         data.setGeneralPurposeOutput(b);
 514     }
 515     /** Configure the test probe so it measures the throughput of
 516      * the alternating instruction FIFO. The test probe frequency is
 517      * 1/16384 of the FIFO throughput. This control has second
 518      * highest priority. Thus the following two calls probe the
 519      * instruction counter:
 520      *      probeDataCounter(false);
 521      *      probeInstructionCounter(true)
 522      */
 523     public void enableInstructionCounter(Boolean b) {
 524         instrIn.setGeneralPurposeOutput(b);
 525     }
 526
 527     public void fillSouthProperStopper(Instruction i) {
 528         instrIn.fill(i);
 529     }
 530     public void fillSouthProperStopper(Instruction[] instructions) { fillSouthProperStopper(instructions, false); }
 531     public void fillSouthProperStopper(Instruction[] instructions, boolean repeat) { fillSouthProperStopper(instructions, repeat, false); }
 532     public void fillSouthProperStopper(Instruction[] instructions, boolean repeat, boolean leaveStopped) {
 533         enableInstructionSend(false);
 534         enableInstructionRecirculate(true);
 535         for(Instruction i : instructions)
 536             if (i!=null) {
 537                 instrIn.fill(i);
 538             } else {
 539                 instrIn.fillTorpedo();
 540             }
 541         enableInstructionRecirculate(repeat);
 542         enableInstructionSend(true);
 543         if (!leaveStopped) instrIn.run();
 544     }
 545
 546
 547 }