From 94692e15bd1af5144b843c3a1b083c822cc1d471 Mon Sep 17 00:00:00 2001 From: rkao Date: Mon, 17 Nov 2008 15:07:12 +0000 Subject: [PATCH] Regressions run based upon 11 Nov 2008 design. --- .../com/sun/vlsi/chips/marina/test/Marina.java | 182 +- .../com/sun/vlsi/chips/marina/test/MarinaTest.java | 242 +- .../sun/vlsi/chips/marina/test/MarinaUtils.java | 24 +- .../sun/vlsi/chips/marina/test/ProperStopper.java | 49 +- testCode/hardwareBugs.txt | 11 + testCode/marina.bsh | 11 +- testCode/marina.spi |12271 ++++++++++++++++++++ testCode/marina.xml | 833 +- 8 files changed, 13212 insertions(+), 411 deletions(-) create mode 100644 testCode/marina.spi diff --git a/testCode/com/sun/vlsi/chips/marina/test/Marina.java b/testCode/com/sun/vlsi/chips/marina/test/Marina.java index f701e4d..44e391a 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/Marina.java +++ b/testCode/com/sun/vlsi/chips/marina/test/Marina.java @@ -1,94 +1,142 @@ package com.sun.vlsi.chips.marina.test; /* -*- tab-width: 4 -*- */ +import com.sun.async.test.BitVector; import com.sun.async.test.ChainControl; import com.sun.async.test.ChipModel; -import com.sun.async.test.JtagLogicLevel; import com.sun.async.test.JtagTester; import com.sun.async.test.NanosimModel; /** The Marina object will eventually represent the Marina test chip. * Right now, it doesn't do much of anything. It just helps me exercise * my test infrastructure. */ -public class Marina implements Design { - private static final String DATA_CHAIN = "marina.jtag_dockTest_data"; - private static final String CONTROL_CHAIN = "marina.jtag_dockTest_control"; - private static final String REPORT_CHAIN = "marina.jtag_dockTest_report"; +public class Marina { + private static final String DATA_CHAIN = "marina.marina_data"; + private static final String CONTROL_CHAIN = "marina.marina_control"; + private static final String REPORT_CHAIN = "marina.marina_report"; + + private static final String OLC_PATH = "ringSkip@0.skipCoun@0.scanKx6@0"; + private static final String ILC_PATH = "ringSkip@0.skipCoun@0.scanKx7@0"; + private static final String FLAGS_PATH = "ringSkip@0.skipCoun@0.scanKx3@0"; + private static final String SEND_INSTR_PATH = "instrIn.tapPropS@0.tapStage@1"; + + private final Indenter indenter; // The name of the scan chain // The instance path, from the top cell of the netlist, of the instance of infinityWithCover private final ChainControl cc; // specifies the scan chain private final ChipModel model; - public final ProperStopper stopper1, stopper2; - public final Counter counter; + public final ProperStopper data, tokOut; + public final InstructionStopper instrIn; + + private void prln(String msg) {indenter.prln(msg);} + private void pr(String msg) {indenter.pr(msg);} + + /** Shift the report scan chain */ + private void shiftReport(boolean readEnable, boolean writeEnable) { + cc.shift(REPORT_CHAIN, readEnable, writeEnable); + } + + /** Shift the report scan chain */ + private void shiftControl(boolean readEnable, boolean writeEnable) { + cc.shift(CONTROL_CHAIN, readEnable, writeEnable); + } - public Marina(ChainControl cc, ChipModel model, boolean wholeChipNetlist, Indenter indenter) { + public Marina(ChainControl cc, ChipModel model, Indenter indenter) { this.cc = cc; this.model = model; - stopper1 = new ProperStopper("ps1", - CONTROL_CHAIN, - DATA_CHAIN, - REPORT_CHAIN, - cc, model, indenter); - stopper2 = new ProperStopper("ps2", - CONTROL_CHAIN, - DATA_CHAIN, - REPORT_CHAIN, - cc, model, indenter); - counter = new Counter("??", DATA_CHAIN, cc); + this.indenter = indenter; + data = new ProperStopper("data.fillDrai@0.properSt@0", + CONTROL_CHAIN, + DATA_CHAIN, + REPORT_CHAIN, + cc, model, indenter); + tokOut = new ProperStopper("tokOut", + CONTROL_CHAIN, + DATA_CHAIN, + REPORT_CHAIN, + cc, model, indenter); + instrIn = new InstructionStopper("instrIn.tapPropS@0.properSt@0", + CONTROL_CHAIN, + DATA_CHAIN, + REPORT_CHAIN, + cc, model, indenter); } public void masterClear(JtagTester tester) { - final double WIDTH = 10; - if (model instanceof NanosimModel) { - NanosimModel nModel = (NanosimModel) model; - System.out.println("master clear"); - // Put a low going pulse on the chip's master clear pin. This clears - // the master clear register. The master clear register's output is - // inverted. This inverse drivers the chip's internal master clear - // signal. - nModel.setNodeVoltage("mc",0.0); - nModel.waitNS(WIDTH); - nModel.setNodeVoltage("mc",1.0); - } else { - JtagLogicLevel jll = new JtagLogicLevel(tester, 0); - jll.setLogicState(false); - model.wait(0.100f); - jll.setLogicState(true); - - // Set the master clear register. This resets the chip's internal - // master clear. - cc.setInBits("Infinity.jtag_mc", "1"); - cc.shift("Infinity.jtag_mc", false, true); - } - resetAfterMasterClear(); + final double WIDTH = 10; // ns + NanosimModel nModel = (NanosimModel) model; + // Put a high going pulse on the internal chip master clear signal + nModel.setNodeVoltage("scanInD[9]",1.0); + nModel.setNodeVoltage("scanInC[9]",1.0); + nModel.setNodeVoltage("scanInR[9]",1.0); + nModel.waitNS(WIDTH); + nModel.setNodeVoltage("scanInD[9]",0.0); + nModel.setNodeVoltage("scanInC[9]",0.0); + nModel.setNodeVoltage("scanInR[9]",0.0); + nModel.waitNS(1); + resetAfterMasterClear(); } - - private void resetAfterMasterClear() { - // For reset, I want to simultaneously clear all the stoppers - stopper1.clear(); - stopper2.clear(); + // The following call to ChainControl.resetInBits() is vital! + // If you forget, then the inBits member initializes + // with random data. Then when you do your first write, + // some bits are written randomly. + cc.resetInBits(); + + // For reset, I want to clear all the stoppers simultaneously + data.clear(); + tokOut.clear(); + instrIn.clear(); - stopper1.stop(); - stopper2.stop(); + data.stop(); + tokOut.stop(); + instrIn.stop(); - stopper1.resetAfterMasterClear(); - stopper2.resetAfterMasterClear(); + data.resetAfterMasterClear(); + tokOut.resetAfterMasterClear(); + instrIn.resetAfterMasterClear(); + } + /** Get the 6 bit outer loop counter. */ + public int getOLC() { + shiftReport(true, false); + return (int) cc.getOutBits(REPORT_CHAIN+"."+OLC_PATH).bitReverse().not().toLong(); + } + /** Get the 7 bit inner loop counter. The MSB is the zero bit. + * The low order 6 bits are the count */ + public int getILC() { + shiftReport(true, false); + return (int) cc.getOutBits(REPORT_CHAIN+"."+ILC_PATH).bitReverse().not().toLong(); + } + /** Get the inner loop counter zero bit. If the zero bit is true + * then the hardware considers the inner loop counter to be zero + * regardless of the state of the count bits */ + public boolean getIlcZero() { + return (getILC() & 0x40) != 0; + } + /** Get the 6 bits of count of the inner loop counter */ + public int getIlcCount() { + return getILC() & 0x3f; + } + /** Get the A flag */ + public boolean getFlagA() { + shiftReport(true, false); + return cc.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(2); + } + /** Get the B flag */ + public boolean getFlagB() { + shiftReport(true, false); + return cc.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(1); + } + /** Get the C flag */ + public boolean getFlagC() { + shiftReport(true, false); + return cc.getOutBits(REPORT_CHAIN+"."+FLAGS_PATH).get(0); } -// /** Shift the data scan chain. */ -// public void shiftData(boolean readEnable, boolean writeEnable) { -// // Get current data of all stoppers -// cc.shift(DATA_CHAIN, readEnable, writeEnable); -// } -// /** Shift the control scan chain */ -// public void shiftControl(boolean readEnable, boolean writeEnable) { -// cc.shift(CONTROL_CHAIN, readEnable, writeEnable); -// } -// /** Shift the report scan chain */ -// public void shiftReport(boolean readEnable, boolean writeEnable) { -// cc.shift(REPORT_CHAIN, readEnable, writeEnable); -// } - public void initCounterScanBits(boolean val) { - cc.setInBits(DATA_CHAIN+".infinity@1.infinity@0.cnt", val); - cc.setInBits(DATA_CHAIN+".infinity@1.infinity@5.cnt", val); + /** Enable the transmission of instructions from the instruction + * ring test structure to the EPI FIFO. */ + public void enableInstructionSend(boolean b) { + BitVector bv = new BitVector(1, "send flag"); + bv.setFromLong(b?1:0); + cc.setInBits(CONTROL_CHAIN+"."+SEND_INSTR_PATH, bv); + shiftControl(true, false); } } diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java index 6a3a8b1..890565d 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java +++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java @@ -65,7 +65,7 @@ public class MarinaTest { private static long startTime; private Indenter indenter = new Indenter(); - private Design design; + private Marina marina; private ChipModel model; private ChainControl cc; private JtagTester tester; @@ -97,12 +97,6 @@ public class MarinaTest { private static void reportTask(CmdArgs args) { System.out.println("Begin testing Marina"); switch (args.mode) { - case ISOLATED_IN_DOCK: - System.out.println(" Simulate isolated input dock"); - break; - case ISOLATED_OUT_DOCK: - System.out.println(" Simulate isolated output dock"); - break; case WHOLE_CHIP_SCHEMATIC_PARASITICS: System.out.println(" Simulate whole chip, schematic parasitics"); break; @@ -162,30 +156,20 @@ public class MarinaTest { String netListName; switch (cmdArgs.mode) { - case ISOLATED_IN_DOCK: - netListName = "isolatedInDock.spi"; - cc = new ChainControl("isolatedInDock.xml", tester, 1.8f, khz); - design = new IsolatedInDock(cc, model, indenter); - break; - case ISOLATED_OUT_DOCK: - netListName = "isolatedOutDock.spi"; - cc = new ChainControl("isolatedOutDock.xml", tester, 1.8f, khz); - design = null; - break; case WHOLE_CHIP_SCHEMATIC_PARASITICS: - netListName = "marina_pads_guts.spi"; - cc = new ChainControl("???", tester, 1.8f, khz); - design = null; + netListName = "marina.spi"; + cc = new ChainControl("marina.xml", tester, 1.8f, khz); + marina = new Marina(cc, model, indenter); break; case WHOLE_CHIP_LAYOUT_PARASITICS: netListName = "marina_pads_guts.spi"; cc = new ChainControl("???", tester, 1.8f, khz); - design = null; + marina = null; break; case TEST_SILICON: netListName = "marina_pads_guts.spi"; cc = new ChainControl("???", tester, 1.8f, khz); - design = null; + marina = null; break; default: fatal(true, "unrecognized CmdArgs.Mode"); @@ -348,13 +332,13 @@ public class MarinaTest { //========================================================================= // Put top level tests here - private void stopToStopOneItem(IsolatedInDock inDock) { - stopToStopOne(inDock.datIn, inDock.tokOut, null, -1); + private void stopToStopOneItem(Marina marina) { + stopToStopOne(marina.data, marina.tokOut, null, -1); } - private void stopToStopThreeItems(IsolatedInDock inDock) { - stopToStopThree(inDock.datIn, inDock.tokOut, null, -1); + private void stopToStopThreeItems(Marina marina) { + stopToStopThree(marina.data, marina.tokOut, null, -1); } - private void sendInstructions(IsolatedInDock inDock) { + private void sendInstructions(Marina marina) { prln("Begin sendInstructions"); adjustIndent(2); @@ -369,22 +353,24 @@ public class MarinaTest { count = count.add(one); } - inDock.instrIn.fillMany(din); + marina.instrIn.fillMany(din); adjustIndent(-2); prln("End sendInstructions"); } - private void sendToken(IsolatedInDock inDock) { + private void sendToken(Marina marina) { prln("Begin sendToken"); adjustIndent(2); - inDock.instrIn.fill( + prln("ILC=1"); + marina.instrIn.fill( new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1)); - getCtrsFlags(inDock); + getCtrsFlags(marina); - inDock.instrIn.fill( + prln("send token"); + marina.instrIn.fill( new Instruction.Move(DOCK, false, /* requeueing */ Predicate.IgnoreOLC, /* predicate */ @@ -398,9 +384,9 @@ public class MarinaTest { true /* tokenOut */ )); - getCtrsFlags(inDock); + getCtrsFlags(marina); - List toks = inDock.tokOut.drainMany(); + List toks = marina.tokOut.drainMany(); fatal(toks.size()!=1, "Expected one token to emerge but got: "+toks.size()+" tokens"); prln("Token="+MarinaUtils.formatDataTokAddr(toks.get(0))); @@ -409,7 +395,7 @@ public class MarinaTest { prln("End sendToken"); } - private void testFlagZ(IsolatedInDock inDock) { + private void testFlagZ(Marina marina) { prln("Begin testFlagZ"); adjustIndent(2); @@ -424,11 +410,11 @@ public class MarinaTest { "olc=="+olc+" and "+ "predicate olc"+(predicate_olc_nonzero?"!=0":"==0")); adjustIndent(2); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 1)); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 1)); if (olc==0) - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, SetDest.OuterLoopCounter, SetSource.Decrement)); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1)); - inDock.instrIn.fill(new Instruction.Move(DOCK, + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, SetDest.OuterLoopCounter, SetSource.Decrement)); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1)); + marina.instrIn.fill(new Instruction.Move(DOCK, false, /* requeueing */ predicate_olc_nonzero /* predicate */ ? only_if_olc_nonzero @@ -443,7 +429,7 @@ public class MarinaTest { false, /* dataOut */ true /* tokenOut */ )); - toks = inDock.tokOut.drainMany(); + toks = marina.tokOut.drainMany(); int expected = (predicate_olc_nonzero == (olc!=0)) ? 1 : 0; fatal(toks.size()!=expected, "Expected "+expected+" token to emerge but got: "+toks.size()+" token(s)"); adjustIndent(-2); @@ -453,23 +439,23 @@ public class MarinaTest { prln("End testFlagZ"); } - private void testPredicationOnAB(IsolatedInDock inDock) { + private void testPredicationOnAB(Marina marina) { prln("Begin testPredicationOnAB"); adjustIndent(2); List toks; prln("Setting OLC=63"); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); for(boolean flag_a : new boolean[] { false, true }) { for(boolean flag_b : new boolean[] { false, true }) { prln("Setting flags, a="+flag_a+" b="+flag_b); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, flag_a ? Instruction.Set.FlagFunction.ONE : Instruction.Set.FlagFunction.ZERO, flag_b ? Instruction.Set.FlagFunction.ONE : Instruction.Set.FlagFunction.ZERO )); - getCtrsFlags(inDock); + getCtrsFlags(marina); adjustIndent(2); for(Predicate predicate : new Predicate[] { @@ -482,8 +468,8 @@ public class MarinaTest { prln("Attempting send token with a="+flag_a+", b="+flag_b+", predicate="+predicate.getClass().getName()); adjustIndent(2); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1)); - inDock.instrIn.fill(new Instruction.Move(DOCK, + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1)); + marina.instrIn.fill(new Instruction.Move(DOCK, false, /* requeueing */ predicate, /* predicate */ false, /* torpedoable */ @@ -496,7 +482,7 @@ public class MarinaTest { true /* tokenOut */ )); adjustIndent(-2); - toks = inDock.tokOut.drainMany(); + toks = marina.tokOut.drainMany(); int expected = predicate.evaluate(flag_a, flag_b, false, false) ? 1 : 0; fatal(toks.size()!=expected, "Expected "+expected+" token to emerge but got: "+ toks.size()+" token(s)"); @@ -508,37 +494,43 @@ public class MarinaTest { prln("End testPredicationOnAB"); } - private void getCtrsFlags(IsolatedInDock inDock) { - int olc = inDock.getOLC(); - prln("OLC="+olc); + private void getCtrsFlags(Marina marina) { + prln("begin getCtrsFlags"); + adjustIndent(2); + + int olc = marina.getOLC(); + prln("OLC=="+olc); - prln("ILC.zero="+inDock.getIlcZero()+ - " ILC.count="+inDock.getIlcCount()); + prln("ILC.zero=="+marina.getIlcZero()+ + " ILC.count=="+marina.getIlcCount()); + + boolean a = marina.getFlagA(); + prln("flagA=="+a); - boolean a = inDock.getFlagA(); - prln("flagA="+a); + boolean b = marina.getFlagB(); + prln("flagB=="+b); - boolean b = inDock.getFlagB(); - prln("flagB="+b); + boolean c = marina.getFlagC(); + prln("flagC=="+c); - boolean c = inDock.getFlagC(); - prln("flagC="+c); + adjustIndent(-2); + prln("end getCtrsFlags"); } - private void walkOneOLC(IsolatedInDock inDock) { + private void walkOneOLC(Marina marina) { prln("Begin walkOneOLC"); adjustIndent(2); for (int i=0; i<7; i++) { int inOlc = 0x20 >> i; prln("inOlc="+inOlc); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, inOlc)); - int outOlc = inDock.getOLC(); + int outOlc = marina.getOLC(); fatal(outOlc!=inOlc, "walkOneOLC: got="+outOlc+" expected="+inOlc); } adjustIndent(-2); prln("End walkOneOLC"); } - private void walkOneILC(IsolatedInDock inDock) { + private void walkOneILC(Marina marina) { prln("Begin walkOneILC"); adjustIndent(2); for (int i=0; i<7; i++) { @@ -546,32 +538,32 @@ public class MarinaTest { int inIlc = 0x20 >> i; prln("inIlc="+inIlc); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, inIlc)); - int outIlc = inDock.getIlcCount(); + int outIlc = marina.getIlcCount(); fatal(outIlc!=inIlc, "bad ILC count: "+outIlc+" expected: "+outIlc); boolean inZero = inIlc==0; - boolean outZero = inDock.getIlcZero(); + boolean outZero = marina.getIlcZero(); fatal(outZero!=inZero, "bad ILC zero: "+outZero); } adjustIndent(-2); prln("End walkOneILC"); } - private void countIlc(IsolatedInDock inDock) { + private void countIlc(Marina marina) { final int maxIlc = 63; prln("Begin countIlc"); adjustIndent(2); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, maxIlc)); - int ilc = inDock.getIlcCount(); + int ilc = marina.getIlcCount(); fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc); // execute a move instruction that does nothing except decrement the ILC to zero - inDock.instrIn.fill( + marina.instrIn.fill( new Instruction.Move(DOCK, false, /* requeueing */ Predicate.IgnoreOLC, /* predicate */ @@ -588,25 +580,25 @@ public class MarinaTest { // wait for ILC to count from 63 to 0 model.waitNS(64 * CYCLE_TIME_NS); - ilc = inDock.getIlcCount(); + ilc = marina.getIlcCount(); fatal(ilc!=0, "bad ILC count: "+ilc+" expected: "+0); adjustIndent(-2); prln("End countIlc"); } // Note: countOlc takes 44 minutes to run on nanosim - private void countOlc(IsolatedInDock inDock) { + private void countOlc(Marina marina) { final int maxOlc = 63; prln("Begin countOlc"); adjustIndent(2); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, maxOlc)); for (int i=maxOlc; i>=0; i--) { prln("OLC should be: "+i); - int olc = inDock.getOLC(); + int olc = marina.getOLC(); fatal(olc!=i, "bad OLC: "+olc+" expected: "+i); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, SetSource.Decrement)); } @@ -614,12 +606,12 @@ public class MarinaTest { prln("End countOlc"); } - private void saturateInstructionFifo(IsolatedInDock inDock, Instruction instruction, boolean expect_it_to_jam_up) { + private void saturateInstructionFifo(Marina marina, Instruction instruction, boolean expect_it_to_jam_up) { prln("Inserting "+(UPPER_BOUND_ON_INSTRUCTION_FIFO_SIZE+1)+" copies of \"" + instruction + "\""); adjustIndent(2); int i=0; for(i=0; i<(UPPER_BOUND_ON_INSTRUCTION_FIFO_SIZE+1); i++) { - boolean jammed = (inDock.instrIn.getFillStateWire()==MarinaUtils.StateWireState.FULL); + boolean jammed = (marina.instrIn.getFillStateWire()==MarinaUtils.StateWireState.FULL); if (jammed && expect_it_to_jam_up) { prln("Stopper remained full after inserting instruction; this was expected; we are happy."); adjustIndent(-2); @@ -627,7 +619,7 @@ public class MarinaTest { } fatal(jammed, "Instruction stopper did not drain after inserting " + i + " instructions; not good!"); prln("Inserting instruction " + (i+1) +"/"+ (UPPER_BOUND_ON_INSTRUCTION_FIFO_SIZE+1)); - inDock.instrIn.fill(instruction); + marina.instrIn.fill(instruction); } fatal(expect_it_to_jam_up, "Expected instruction stopper to jam up, but it did not"); adjustIndent(-2); @@ -648,31 +640,31 @@ public class MarinaTest { false /* tokenOut */ ); - private void testRequeueStage0(IsolatedInDock inDock) { + private void testRequeueStage0(Marina marina) { prln("Begin testRequeueStage0"); adjustIndent(2); prln("Executing Set OLC=1"); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,1)); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,1)); prln("Executing Set OLC--"); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,SetSource.Decrement)); - saturateInstructionFifo(inDock, REQUEUEING_NOP, false); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,SetSource.Decrement)); + saturateInstructionFifo(marina, REQUEUEING_NOP, false); adjustIndent(-2); prln("End testRequeueStage0"); } - private void testRequeueStage0to1(IsolatedInDock inDock) { + private void testRequeueStage0to1(Marina marina) { prln("Begin testRequeueStage0to1"); adjustIndent(2); prln("Executing Set OLC=63"); - inDock.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,63)); - saturateInstructionFifo(inDock, REQUEUEING_NOP, true); + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,63)); + saturateInstructionFifo(marina, REQUEUEING_NOP, true); adjustIndent(-2); prln("End testRequeueStage0to1"); } - private void testFlagAB(IsolatedInDock inDock) { + private void testFlagAB(Marina marina) { prln("Begin testFlagAB"); adjustIndent(2); @@ -695,42 +687,42 @@ public class MarinaTest { for(boolean b : new boolean[] { false, true, false }) { prln((b?"Setting":"Clearing")+" flags"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, b ? one : zero, b ? one : zero )); - fatal(inDock.getFlagA()!=b, "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set")); - fatal(inDock.getFlagB()!=b, "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set")); + fatal(marina.getFlagA()!=b, "after "+(b?"setting":"clearing")+" FlagA, it was still "+(b?"clear":"set")); + fatal(marina.getFlagB()!=b, "after "+(b?"setting":"clearing")+" FlagB, it was still "+(b?"clear":"set")); } adjustIndent(-2); prln("End testFlagAB"); } - private void sendTorpedo(IsolatedInDock inDock) { + private void sendTorpedo(Marina marina) { prln("Begin sendTorpedo"); adjustIndent(2); prln("OLC = 63"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); - int olc = inDock.getOLC(); + int olc = marina.getOLC(); fatal(olc!=63, "bad OLC: "+olc+" expected: 63"); prln("A=0, B=0"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, CLEAR_FLAG, CLEAR_FLAG)); - fatal(inDock.getFlagA(), "bad A flag: true"); - fatal(inDock.getFlagB(), "bad B flag: true"); + fatal(marina.getFlagA(), "bad A flag: true"); + fatal(marina.getFlagB(), "bad B flag: true"); prln("ILC = Infinity"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, SetSource.Infinity)); prln("execute a move instruction that does nothing but loops until torpedo arrives"); - inDock.instrIn.fill( + marina.instrIn.fill( new Instruction.Move(DOCK, false, /* requeueing */ Predicate.IgnoreOLC, /* predicate */ @@ -745,73 +737,75 @@ public class MarinaTest { )); prln("NOP This instruction can't predicate on OLC because of a hardware bug"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.Default, A_FLAG, B_FLAG)); prln("A=1, B=1 This instruction should get torpedoed along with the Move"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.Default, SET_FLAG, SET_FLAG)); prln("send torpedo. This should clear the OLC"); - inDock.instrIn.fill(InstructionStopper.TORPEDO); + marina.instrIn.fill(InstructionStopper.TORPEDO); - getCtrsFlags(inDock); + getCtrsFlags(marina); prln("A and B should remain false"); - fatal(inDock.getFlagA(), "bad A flag: true"); - fatal(inDock.getFlagB(), "bad B flag: true"); + fatal(marina.getFlagA(), "bad A flag: true"); + fatal(marina.getFlagB(), "bad B flag: true"); prln("OLC = 63. Reload OLC after torpedo"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); - olc = inDock.getOLC(); + olc = marina.getOLC(); fatal(olc!=63, "bad OLC: "+olc+" expected: 63"); prln("A=1, B=1 This instruction should execute because OLC!=0"); - inDock.instrIn.fill(new + marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.Default, SET_FLAG, SET_FLAG)); prln("A and B should be true"); - fatal(!inDock.getFlagA(), "bad A flag: false"); - fatal(!inDock.getFlagB(), "bad B flag: false"); + fatal(!marina.getFlagA(), "bad A flag: false"); + fatal(!marina.getFlagB(), "bad B flag: false"); adjustIndent(-2); prln("End sendTorpedo"); } private void doOneTest(int testNum) { prln("MarinaTest: performing test: "+testNum); - design.masterClear(tester); + marina.masterClear(tester); + + marina.enableInstructionSend(true); switch (testNum) { - case 0: stopToStopOneItem((IsolatedInDock)design); break; - case 1: stopToStopThreeItems((IsolatedInDock)design); break; - case 2: sendInstructions((IsolatedInDock)design); break; - case 3: sendToken((IsolatedInDock)design); break; - case 4: getCtrsFlags((IsolatedInDock)design); break; - case 5: walkOneOLC((IsolatedInDock)design); break; + case 2: sendInstructions(marina); break; + case 3: sendToken(marina); break; + case 4: getCtrsFlags(marina); break; + case 5: walkOneOLC(marina); break; // Russell's tests begin with 1000 - case 1000: walkOneILC((IsolatedInDock)design); break; - case 1001: countIlc((IsolatedInDock)design); break; - case 1002: countOlc((IsolatedInDock)design); break; - case 1003: sendTorpedo((IsolatedInDock)design); break; + case 1000: walkOneILC(marina); break; + case 1001: countIlc(marina); break; + case 1002: countOlc(marina); break; + case 1003: sendTorpedo(marina); break; // Bill's tests begin with 2000 case 2000: break; // Adam's tests begin with 3000 - case 3000: sendToken((IsolatedInDock)design); break; - case 3001: testFlagAB((IsolatedInDock)design); break; - case 3002: testRequeueStage0((IsolatedInDock)design); break; - case 3003: testRequeueStage0to1((IsolatedInDock)design); break; - case 3004: testFlagZ((IsolatedInDock)design); break; - case 3005: testPredicationOnAB((IsolatedInDock)design); break; + case 3000: sendToken(marina); break; + case 3001: testFlagAB(marina); break; + case 3002: testRequeueStage0(marina); break; + case 3003: testRequeueStage0to1(marina); break; + case 3004: testFlagZ(marina); break; + case 3005: testPredicationOnAB(marina); break; default: fatal(true, "Test number: "+testNum+" doesn't exist."); break; } + // If we get here then test passed + prln("Passed"); } diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java index 41c0200..495086f 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java +++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaUtils.java @@ -23,21 +23,21 @@ public class MarinaUtils { STOPSOURCE ("01000"),//("10000"), SINK ("00110"),//("00011"), STOPSINK ("00010"); - private String scanBits; - RingIfc(String bits) {scanBits = bits;} - public String bits() {return scanBits;} + private BitVector scanBits; + RingIfc(String bits) {scanBits = new BitVector(bits,"RingIfc");} + public BitVector bits() {return scanBits;} } /** StateWireState hides whether the state wire being high means FULL * or whether high means EMPTY */ public static enum StateWireState {FULL, EMPTY}; public static class CmdArgs { - public enum Mode {ISOLATED_IN_DOCK, - ISOLATED_OUT_DOCK, + public enum Mode {//ISOLATED_IN_DOCK, + //ISOLATED_OUT_DOCK, WHOLE_CHIP_SCHEMATIC_PARASITICS, WHOLE_CHIP_LAYOUT_PARASITICS, TEST_SILICON}; - public Mode mode = Mode.ISOLATED_IN_DOCK; + public Mode mode = Mode.WHOLE_CHIP_SCHEMATIC_PARASITICS; public int testNum, ringNum, numTokensOther, chipNum=-1; public Station station=Station.ONE; public float vdd, temp; @@ -50,8 +50,8 @@ public class MarinaUtils { System.out.println("Options: -testNum select which test to run"); System.out.println(" -vdd "); System.out.println(" -temp "); - System.out.println(" -isoIn simulate netlist of isolated input dock only, parasitics from schematic"); - System.out.println(" -isoOut simulate netlist of isolated output dock only, parasitics from schematic"); +// System.out.println(" -isoIn simulate netlist of isolated input dock only, parasitics from schematic"); +// System.out.println(" -isoOut simulate netlist of isolated output dock only, parasitics from schematic"); System.out.println(" -chipSch simulate netlist of entire chip, parasitics from schematic"); System.out.println(" -chipLay simulate netlist of entire chip, parasitics from layout"); System.out.println(" -silicon test the silicon"); @@ -91,12 +91,10 @@ public class MarinaUtils { case 2: station = Station.TWO; break; default: System.out.println("Bad station: "+args[i]); usage(); } - } else if (args[i].equals("-exptSch")) { - mode = CmdArgs.Mode.ISOLATED_IN_DOCK; - } else if (args[i].equals("-exptLay")) { - mode = CmdArgs.Mode.ISOLATED_OUT_DOCK; - } else if (args[i].equals("-chipLay")) { + } else if (args[i].equals("-chipSch")) { mode = CmdArgs.Mode.WHOLE_CHIP_SCHEMATIC_PARASITICS; + } else if (args[i].equals("-chipLay")) { + mode = CmdArgs.Mode.WHOLE_CHIP_LAYOUT_PARASITICS; } else if (args[i].equals("-silicon")) { mode = CmdArgs.Mode.TEST_SILICON; } else { diff --git a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java index 6649abf..eb8d00e 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java +++ b/testCode/com/sun/vlsi/chips/marina/test/ProperStopper.java @@ -11,7 +11,7 @@ import com.sun.vlsi.chips.marina.test.MarinaUtils.StateWireState; public class ProperStopper { private final String name; - private final String captureClockRelPath = "aFillSta@0.all1in52@1.data1in3@0"; + private final String captureClockRelPath = "fillStag@0.all1in52@1.data1in3@0"; private final String captureClockName = "wrr"; private boolean traceFill = true; @@ -71,6 +71,23 @@ public class ProperStopper { private StateWireState boolToState(boolean b) { return b ? StateWireState.FULL : StateWireState.EMPTY; } + // The first 5 bits of the control chain control the fill and drain stages + private void setFillDrainControl(BitVector fdCtl) { + fatal(fdCtl.getNumBits()!=5, "expect 5 proper stopper control bits"); + BitVector val = cc.getInBits(controlPath); + for (int i=0; i - - - - - - - - - -'> - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -'> - - - - - - - - - - - - -'> - + + + + + + + + + + + + + + + + + + +'> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +'> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +'> + + + + +'> + &countersL_cntScnThree_sin; + &countersL_cntScnThree_sin; + &countersL_cntScnThree_sin; +'> + + + +'> + &countersL_cntScnFour_sin; + &countersL_cntScnFour_sin; + &countersL_cntScnFour_sin; +'> + + &countersL_cntScnTwelve_sin; + &countersL_cntScnTwelve_sin; + &countersL_cntScnNine_sin; +'> + &fifoL_ringFIFO_sin; + &dockPartOD_skipCount_sin; + &dockPartsK_moveLit_sin; +'> + &scanK_scanKx7_sin; + &scanK_scanKx6_sin; + &scanK_scanKx3_sin; +'> + &scanK_scanKhx5_sin; +'> + &dockPartsK_moveD_sin; +'> + &gaspL_anEpiStartS_sin; + &gaspL_aStageS_sin; +'> + &fifoL_epiFifoCont_sin; +'> + &fifoL_m1stageD_sin; +'> + &scanK_scanKhx2_sin; +'> + &scanK_scanKhx5_sin; +'> + &fifoL_odRQstageD_sin; + &fifoL_split10_sin; + &fifoL_m12stageD_sin; +'> + &fifoL_splitStart_sin; + &fifoL_splitStageDx4_sin_1_; + &fifoL_splitStageDx4_sin_1_; + &fifoL_splitStageDx4_sin_2_; + &fifoL_splitStageDx4_sin_2_; + &fifoL_splitEnd_sin; +'> + &gaspL_anAltEndS_sin; +'> + &scanK_scanKhx2_sin; +'> + &fifoL_splitStageDx2_sin; +'> + &fifoL_splitStageDx2_sin; +'> + &gaspL_anAltStartS_sin; +'> + &scanK_scanKhx1_sin; +'> + &scanK_scanKhx3_sin; +'> + &scanK_scanKhx2_sin; +'> + &scanK_scanKhx1_sin; +'> + &scanJ_scanFx3hor_sic_1_; + &scanJ_scanFx1vert_sic_1_; '> - &scanJ_scanEx2vert_sir_1_; '> - &scanJ_scanFx2vert_sic_1_; '> - &scanJ_scanEx2vert_sir_1_; '> - &scanJ_scanFx1vert_sic_1_; +'> + &scanJ_scanEx1vertA_sir_1_; '> + &scanK_scanEx1vertFdn_sor_8_; +'> + &scanK_scanEx1vertFup_sir_1_; +'> + +'> + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; '> ®istersJ_data1in38scan_sid_1_; @@ -169,8 +485,44 @@ - - + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; + &latchGroupsK_latchWscan_sin; '> @@ -179,6 +531,9 @@ '> + +'> @@ -188,64 +543,180 @@ '> - &stagesJ_plainStage_sir_1_; - &stagesJ_plainStage_sir_1_; - &stagesJ_plainStage_sir_1_; - &stagesJ_plainStage_sir_1_; + +'> + +'> + +'> + + +'> + + + +'> + + + + + +'> + + + +'> + + + + + + +'> + + + + + + + +'> + &stageGroupsL_properStopper_sic_1_; +'> + &stageGroupsL_properStopper_sid_1_; + &countersL_instructionCount_sid_1_; +'> + &stageGroupsL_properStopper_sir_1_; '> - &stagesJ_fillStage_sic_1_; - &stagesJ_drainStage_sic_1_; + &stageGroupsL_fillDrainCount_sic_1_; '> - &stagesJ_fillStage_sid_1_; + &stageGroupsL_fillDrainCount_sid_1_; '> - &stagesJ_fillStage_sir_1_; - &stagesJ_drainStage_sir_1_; + &stageGroupsL_upDown8weak_sir_1_; + &stageGroupsL_fillDrainCount_sir_1_; '> - &gaspJ_gaspDrain_sic_1_; + &stageGroupsL_upDown8weak_sor_8_; '> - &gaspJ_gaspDrain_sir_1_; + &stagesL_fillStage_sic_1_; + &stagesL_drainStage_sic_1_; '> - &gaspJ_gaspFill_sic_1_; + &stagesL_fillStage_sid_1_; '> - &stagesL_fillStage_sir_1_; + &stagesL_drainStage_sir_1_; +'> + &stageGroupsL_tapPropStop_sic_1_; +'> + &stageGroupsL_tapPropStop_sid_1_; +'> + &stageGroupsL_upDown8weak_sir_1_; + &stageGroupsL_tapPropStop_sir_1_; +'> + &stageGroupsL_upDown8weak_sor_8_; +'> + &stageGroupsL_properStopper_sic_1_; + &stagesL_tapStage_sic_1_; +'> + &stageGroupsL_properStopper_sid_1_; + &countersL_instructionCount_sid_1_; +'> + &stageGroupsL_properStopper_sir_1_; + &stagesL_tapStage_sir_1_; +'> + &stagesL_weakStageUp_sir_1_; + &stagesL_weakStageUp_sir_1_; + &stagesL_weakStageUp_sir_1_; + &stagesL_weakStageUp_sir_1_; +'> + &stagesL_weakStageDn_sor_8_; + &stagesL_weakStageDn_sor_8_; + &stagesL_weakStageDn_sor_8_; + &stagesL_weakStageDn_sor_8_; +'> + &gaspL_gaspDrain_sic_1_; +'> + &gaspL_gaspDrain_sir_1_; +'> + &gaspL_gaspFill_sic_1_; +'> + ®istersJ_all1in52scan_sid_1_; '> - &gaspJ_gaspFill_sir_1_; + &gaspL_gaspFill_sir_1_; +'> + &gaspL_gaspTap_sic_1_; +'> + &gaspL_gaspTap_sir_1_; +'> + &gaspL_gaspWeakDn_sor_8_; '> - &gaspJ_gaspPlain_sir_1_; + &gaspL_gaspWeakUp_sir_1_; '> ]> - - &stageGroupsJ_properStopper_sic_1_; - &stageGroupsJ_properStopper_sic_1_; + + &stageGroupsL_southFifo_sic_1_; + &stageGroupsL_properStopper_sic_1_; + &stageGroupsL_northFifo_sic_1_; - - &stageGroupsJ_properStopper_sid_1_; - &stageGroupsJ_properStopper_sid_1_; + + &stageGroupsL_southFifo_sid_1_; + &stageGroupsL_properStopper_sid_1_; + &stageGroupsL_northFifo_sid_1_; - - &stageGroupsJ_properStopper_sir_1_; - &stageGroupsJ_plainStageFour_rscanIn_1_; - &stageGroupsJ_properStopper_sir_1_; + + &stageGroupsL_southFifo_sir_1_; + &fifoL_epiFifo_sin; + &dockPartOD_ringSkipMoveLit_sin; + &stageGroupsL_properStopper_sir_1_; + &stageGroupsL_northFifo_sir_1_; + &stageGroupsL_northFifo_sor_8_; + &stageGroupsL_southFifo_sor_8_; - &marina_jtag_dockTest_control_dataNets; - &marina_jtag_dockTest_data_dataNets; - &marina_jtag_dockTest_report_dataNets; + &marina_marina_control_dataNets; + &marina_marina_data_dataNets; + &marina_marina_report_dataNets; -- 1.7.10.4