fix ILC tests, take advantage of new command line flags, update which tests pass

diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
index 6b7ae86..cc2d2b9 100644 (file)
--- a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
@@ -14,6 +14,7 @@ import com.sun.async.test.JtagSubchainTesterModel;
 import com.sun.async.test.JtagTester;
 import com.sun.async.test.ManualPowerChannel;
 import com.sun.async.test.NanosimModel;
+import com.sun.async.test.VerilogModel;
 import com.sun.async.test.Netscan4;
 import com.sun.async.test.PowerChannel;
 import com.sun.async.test.Pst3202Channel;
@@ -218,7 +219,7 @@ public class MarinaTest {
                 fatal(true, "unrecognized CmdArgs.Mode");
                 return;
         }
-        model = new NanosimModel();
+        model = cmdArgs.useVerilog ? new VerilogModel() : new NanosimModel();
         
         //tester = ((SimulationModel)model).createJtagTester("TCK", "TMS", "TRSTb", "TDI", "TDO");
         ChainControls ccs = new ChainControls();
@@ -228,7 +229,7 @@ public class MarinaTest {
         testerC = ((SimulationModel)model).createJtagSubchainTester("sic[1:9]", null); 
         testerD.printInfo = testerR.printInfo = testerC.printInfo = false;
 
-        int khz = 1000000;
+        int khz   = model instanceof VerilogModel ?  100000 : 1000000;
         
         ChainControl ccD, ccR, ccC;
         ccD = new ChainControl(SCAN_CHAIN_XML, testerD, 1.8f, khz);
@@ -243,18 +244,41 @@ public class MarinaTest {
         ctR = new ChainTest(ccR, pc);
         ctC = new ChainTest(ccC, pc);
         
-        ((SimulationModel)model).start("nanosim -c cfg", netListName, 0, !cmdArgs.jtagShift);
-        
-        /*
-          ctD.testAllChains("marina", Infrastructure.SEVERITY_WARNING);
-          ctR.testAllChains("marina", Infrastructure.SEVERITY_WARNING);
-          ctC.testAllChains("marina", Infrastructure.SEVERITY_WARNING);
-        */
+        if (model instanceof VerilogModel) {
+            VerilogModel vm = (VerilogModel)model;
+            vm.start("verilog", "marina.v", VerilogModel.DUMPVARS);
+            vm.setNodeState("sid[9]", 1);
+            vm.setNodeState("sic[9]", 1);
+            vm.setNodeState("sir[9]", 1);
+            model.waitNS(1000);
+            vm.setNodeState("sid[9]", 0);
+            vm.setNodeState("sic[9]", 0);
+            vm.setNodeState("sir[9]", 0);
+            model.waitNS(1000);
+        } else {
+            ((SimulationModel)model).start("nanosim -c cfg", netListName, 0, !cmdArgs.jtagShift);
+            System.out.println("**** vdd="+((NanosimModel)model).getVdd());
+        }
+
+        if (cmdArgs.testChains) {
+            ctC.testOneChain(Marina.CONTROL_CHAIN, Infrastructure.SEVERITY_WARNING);
+        }
+        ccC.resetInBits();
+        ccC.shift(Marina.CONTROL_CHAIN, false, true);
+        if (cmdArgs.testChains) {            
+            ctD.testOneChain(Marina.DATA_CHAIN, Infrastructure.SEVERITY_WARNING);
+            //ccD.resetInBits();
+            //ccD.shift(Marina.DATA_CHAIN, false, true);
+            
+            ctR.testOneChain(Marina.REPORT_CHAIN, Infrastructure.SEVERITY_WARNING);
+            //ccR.resetInBits();
+            //ccR.shift(Marina.REPORT_CHAIN, false, true);
+        }
 
         ccs.addChain(Marina.DATA_CHAIN, ccD);
         ccs.addChain(Marina.REPORT_CHAIN, ccR);
         ccs.addChain(Marina.CONTROL_CHAIN, ccC);
-                
+
         marina = new Marina(ccs, model, !cmdArgs.jtagShift, indenter);
 
         //System.out.println("launching");
@@ -436,6 +460,7 @@ public class MarinaTest {
         adjustIndent(2);
 
         for(ProperStopper ps : new ProperStopper[] { marina.data, marina.instrIn }) {
+
             prln("testing " + (ps == marina.data ? "data" : "instruction") + " stopper");
             adjustIndent(2);
 
@@ -468,7 +493,8 @@ public class MarinaTest {
             count = count.add(one);
         }
 
-        marina.instrIn.fillMany(din);
+        for(BitVector d : din)
+            marina.instrIn.fill(new MarinaPacket(d, false, MarinaPacket.null_path));
 
         adjustIndent(-2);
         prln("End sendInstructions");
@@ -689,7 +715,6 @@ public class MarinaTest {
         Ilc ilc = marina.getILC();
         prln("ILC.done=="+ilc.getDone()+
              " ILC.infinity=="+ilc.getInfinity()+
-             " ILC.zero=="+ilc.getZero()+
              " ILC.count=="+ilc.getCount());
         
         boolean a = marina.getFlagA();
@@ -704,13 +729,14 @@ public class MarinaTest {
     private void walkOneOLC(Marina marina) {
         prln("Begin walkOneOLC");
         adjustIndent(2);
-        for (int i=0; i<7; i++) {
+        for (int i=6; i>=0; i--) {
             int inOlc = 0x20 >> i;
             prln("Set inOlc="+inOlc);
             marina.instrIn.fill(new 
                                 Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc));
             int outOlc = marina.getOLC();
             fatal(outOlc!=inOlc, "walkOneOLC: got="+outOlc+" expected="+inOlc);
+            prln("walkOneOLC: "+inOlc+" checks out");
         }
         adjustIndent(-2);
         prln("End walkOneOLC");
@@ -718,9 +744,9 @@ public class MarinaTest {
     private void walkOneILC(Marina marina) {
         prln("Begin walkOneILC");
         adjustIndent(2);
-        for (int i=0; i<7; i++) {
+        for (int i=0; i<6; i++) {
             // Mask off the "zero" bit position
-            int inIlc = 0x20 >> i;
+            int inIlc = 1 << i;
             prln("inIlc="+inIlc);
 
             marina.instrIn.fill(new 
@@ -729,10 +755,7 @@ public class MarinaTest {
             Ilc ilc = marina.getILC();
             int outIlc = ilc.getCount();
             fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+outIlc);
-                
-            boolean inZero = inIlc==0;
-            boolean outZero = ilc.getZero();
-            fatal(outZero!=inZero, "bad ILC zero: "+outZero);
+
             fatal(ilc.getInfinity(), "bad Infinity bit: true");
         }
         prln("Now test the infinity bit");
@@ -758,7 +781,7 @@ public class MarinaTest {
         prln("execute a move instruction that does nothing except decrement the ILC to zero");
         marina.instrIn.fill(
                             new Instruction.Move(dock,
-                                                 Predicate.IgnoreFlagD,   /* predicate   */
+                                                 Predicate.IgnoreFlagD, /* predicate   */
                                                  false,                 /* torpedoable */
                                                  null,                  /* path        */
                                                  false,                 /* tokenIn     */
@@ -1192,6 +1215,7 @@ public class MarinaTest {
 
         // clear the flags to a known state, then check both 0->1 and 1->0 transitions
         for(boolean b : new boolean[] { false, true, false }) {
+            prln("state: a="+marina.getFlagA()+", b="+marina.getFlagB());
             prln((b?"Setting":"Clearing")+" flags");
 
             marina.instrIn.fill(new 
@@ -1585,6 +1609,7 @@ public class MarinaTest {
         MarinaPath path = new MarinaPath((MarinaFleet)dock.getShip().getFleet(), bv);
 
         prln("send data with path="+bv);
+        marina.instrIn.fill(new Instruction.Set(dock,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
         marina.instrIn.fill(new Instruction.Move(dock,
                                                  Predicate.IgnoreFlagD, /* predicate   */
                                                  false,                 /* torpedoable */
@@ -1890,7 +1915,6 @@ public class MarinaTest {
             int ilcCount = ilc.getCount();
             fatal(ilcCount!=notZero, "bad ILC count: "+ilcCount+" expected: "+notZero);
         
-            fatal(ilc.getZero(), "bad ILC zero bit: true");
             fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
                         
             prln("Set ILC="+notZero);
@@ -1906,7 +1930,6 @@ public class MarinaTest {
             ilcCount = ilc.getCount();
             fatal(ilcCount!=0, "bad ILC count: "+ilcCount+" expected: 0");
         
-            fatal(!ilc.getZero(), "bad ILC zero bit: false");
             fatal(ilc.getInfinity(), "bad ILC Infinity bit: true");
         }
 
@@ -1965,7 +1988,7 @@ public class MarinaTest {
         adjustIndent(-2);
         prln("End flipOlcBit");
     }
-    private void testSouthRecirculate (Marina marina) {
+    private void testSouthRecirculate(Marina marina) {
         prln("Begin testSouthRecirculate");
         adjustIndent(2);
 
@@ -1978,9 +2001,11 @@ public class MarinaTest {
         adjustIndent(2);
         for (int i=0; i<AMOUNT; i++) {
             prln("inserting item " + (i+1) + " / " + AMOUNT);
-            BitVector instr = new BitVector(36, "Instr"+i);
-            instr.setFromLong(i+1);
-            marina.instrIn.fill(instr);
+            BitVector path = new BitVector(MarinaPacket.PATH_WIDTH, "path");
+            BitVector data = new BitVector(MarinaPacket.WORD_WIDTH, "path");
+            path.set(0, MarinaPacket.PATH_WIDTH, false);
+            data.setFromLong(i+1);
+            marina.instrIn.fill(new MarinaPacket(data, false, path));
         }
         adjustIndent(-2);
 
@@ -1992,7 +2017,7 @@ public class MarinaTest {
             prln("extracting item " + (i+1) + " / " + AMOUNT);
             //int expect = (i+Marina.SOUTH_RING_CAPACITY-1) % Marina.SOUTH_RING_CAPACITY;
             int expect = i+1;
-            long got = out.get(i).toLong();
+            long got = new MarinaPacket(out.get(i)).data.toLong();
             if (got!=expect) {
                 bad = true;
                 prln("  bad instruction: "+got+" expected: "+expect);
@@ -2009,21 +2034,38 @@ public class MarinaTest {
         prln("End testSouthRecirculate");
     }
     private void doOneTest(int testNum) {
+        prln("");
+        prln("============================================================");
         prln("MarinaTest: performing test: "+testNum);
+
         marina.masterClear();
-        
         marina.enableInstructionSend(true);
         
         switch (testNum) {
-            case 1:    testProperStoppers(marina);             break; // passes, 24-Mar
-            case 2:    sendInstructions(marina);               break; // passes, 24-Mar
-            case 3:    sendToken(marina);                      break; // passes, 24-Mar
+            case 0: {
+
+                // these tests run fairly quickly
+                doOneTest(1);
+                doOneTest(2);
+                doOneTest(3000);
+                doOneTest(3001);
+                doOneTest(3006);
+                doOneTest(3018);
+                //doOneTest(1000);
+
+                // these tests take a while and usually pass
+                doOneTest(1006);
+
+                break;
+            }
+            case 1:    testProperStoppers(marina);             break; // passes, 24-Mar (+verilog)
+            case 2:    sendInstructions(marina);               break; // passes, 24-Mar (+verilog)
 
             case 4:    getCtrsFlags(marina);                   break;
             case 5:    walkOneOLC(marina);                     break;
                 
                 // Russell's tests begin with 1000
-            case 1000: walkOneILC(marina);                     break;
+            case 1000: walkOneILC(marina);                     break; //         20-Apr (+verilog)
             case 1001: countIlc(marina);                       break;
             case 1002: countOlc(marina);                       break;
 
@@ -2032,16 +2074,16 @@ public class MarinaTest {
             case 1004: flipIlcBit(marina);                     break;
             case 1005: flipOlcBit(marina);                     break;
 
-            case 1006: testSouthRecirculate(marina);           break; // passes, 24-Mar
+            case 1006: testSouthRecirculate(marina);           break; // passes, 24-Mar (+verilog)
                 
                 // Adam's tests begin with 3000
-            case 3000: sendToken(marina);                      break; // passes, 24-Mar
-            case 3001: testFlagAB(marina);                     break; // passes, 08-Apr
+            case 3000: sendToken(marina);                      break; // passes, 24-Mar (+verilog)
+            case 3001: testFlagAB(marina);                     break; // passes, 08-Apr (+verilog)
             case 3002: testRequeueStage0(marina);              break;
             case 3003: testRequeueStage0to1(marina);           break;
             case 3004: testFlagZ(marina);                      break;
             case 3005: testPredicationOnAB(marina);            break;
-            case 3006: sendData(marina);                       break; // passes, 24-Mar
+            case 3006: sendData(marina);                       break; // passes, 24-Mar (+verilog)
             case 3007: testRequeueStage0to1to3to0(marina);     break;
             case 3008: testWaitForTail(marina);                break;
             case 3009: testRequeueStageDrop(marina);           break;         
@@ -2053,7 +2095,7 @@ public class MarinaTest {
             case 3015: testSendAndRecvToken(marina);           break;
             case 3016: sendDataIlcInfinite(marina);            break;
             case 3017: testFlagTruthTable(marina);             break;
-            case 3018: sendDataWithPath(marina);               break; // passes, 13-Apr
+            case 3018: sendDataWithPath(marina);               break; // passes, 13-Apr (+verilog)
             case 3019: setOlcFromDataLatch(marina);            break;
             case 3020: setIlcFromDataLatch(marina);            break;
             case 3021: recvPath(marina);                       break;
@@ -2069,7 +2111,7 @@ public class MarinaTest {
         // If we get here then test passed
         prln("Test Result: Passed");
         printTestTime();
-        Infrastructure.exit(0);
+        //Infrastructure.exit(0);
     }