From f8651379b96d78a481c87c9da9587074f6b38453 Mon Sep 17 00:00:00 2001 From: rkao Date: Fri, 7 Nov 2008 21:30:01 +0000 Subject: [PATCH] sendToken runs --- .../vlsi/chips/marina/test/InstructionStopper.java | 11 ++- .../com/sun/vlsi/chips/marina/test/MarinaTest.java | 86 +++++++++++++++++++- 2 files changed, 95 insertions(+), 2 deletions(-) diff --git a/testCode/com/sun/vlsi/chips/marina/test/InstructionStopper.java b/testCode/com/sun/vlsi/chips/marina/test/InstructionStopper.java index c17b773..8e747ed 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/InstructionStopper.java +++ b/testCode/com/sun/vlsi/chips/marina/test/InstructionStopper.java @@ -14,10 +14,17 @@ import edu.berkeley.fleet.marina.MarinaFleet; /** InstructionStopper is a scaffold that lets us create a 36 bit propperStopper * by using a 52 bit propperStopper and throwing away the unused bits. */ public class InstructionStopper extends ProperStopper { + public static final BitVector TORPEDO; public static final int INSTR_SZ = 36; public static final MarinaFleet MARINA = new MarinaFleet(); public static final Dock DOCK = MARINA.getOnlyInputDock(); + static { + BitVector d = new BitVector(37, "token"); d.setFromLong(0); + BitVector t = new BitVector(1, "token"); t.setFromLong(0); + BitVector a = new BitVector(14, "addr"); a.setFromLong(0); + TORPEDO = d.cat(t).cat(a); + } // Convert a Berkeley BitVector into a Sun BitVector private BitVector berkToSun(edu.berkeley.fleet.api.BitVector berkBits) { BitVector sunBits = new BitVector(INSTR_SZ, "instr"); @@ -42,10 +49,12 @@ public class InstructionStopper extends ProperStopper { ChainControl cc, ChipModel model, Indenter indenter) { super(propInst, controlChain, dataChain, reportChain, cc, model, indenter); - } @Override public void fill(BitVector instr) { + // allow user to pass in complete item: data + token + addr + if (instr.getNumBits()==(37+1+14)) {super.fill(instr); return;} + int n = instr.getNumBits(); fatal(n!=INSTR_SZ, "InstructionStopper.fill: wrong num bits: "+n+", expect: "+INSTR_SZ); fatal(INSTR_SZ>37, "Instructions can't be more than 37 bits"); diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java index 4efe298..3aa18ab 100644 --- a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java +++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java @@ -36,7 +36,17 @@ public class MarinaTest { public static final int INSTR_SZ = 36; public static final Dock DOCK = InstructionStopper.DOCK; - + public static final Instruction.Set.FlagFunction CLEAR_FLAG + = Instruction.Set.FlagFunction.ZERO; + public static final Instruction.Set.FlagFunction SET_FLAG + = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA) + .add(Predicate.NotFlagA); + public static final Instruction.Set.FlagFunction A_FLAG + = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagA); + + public static final Instruction.Set.FlagFunction B_FLAG + = Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagB); + // COLUMN_LATENCY is a delay that is larger than the latency through an Infinity column private static final int COLUMN_LATENCY = 10; // nanoseconds @@ -502,6 +512,7 @@ public class MarinaTest { Instruction.Set.FlagFunction zero = Instruction.Set.FlagFunction.ZERO; Instruction.Set.FlagFunction one = zero; + // we should be able to use any pair of FlagX+NotFlagX, // but we toss them all in to maximize the chances of the @@ -530,6 +541,78 @@ public class MarinaTest { adjustIndent(-2); prln("End testFlagAB"); } + private void sendTorpedo(IsolatedInDock inDock) { + prln("Begin sendTorpedo"); + adjustIndent(2); + + prln("OLC = 63"); + inDock.instrIn.fill(new + Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); + + int olc = inDock.getOLC(); + fatal(olc!=63, "bad OLC: "+olc+" expected: 63"); + + prln("A=0, B=0"); + inDock.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"); + + prln("ILC = Infinity"); + inDock.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( + new Instruction.Move(DOCK, + false, /* requeueing */ + Predicate.IgnoreOLC, /* predicate */ + true, /* torpedoable */ + null, /* path */ + false, /* tokenIn */ + false, /* dataIn */ + false, /* latchData */ + false, /* latchPath */ + false, /* dataOut */ + false /* tokenOut */ + )); + + prln("NOP This instruction can't predicate on OLC because of a hardware bug"); + inDock.instrIn.fill(new + Instruction.Set(DOCK,false,Predicate.Default, CLEAR_FLAG, CLEAR_FLAG)); + + prln("A=1, B=1 This instruction should get torpedoed along with the Move"); + inDock.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); + + getCtrsFlags(inDock); + + prln("A and B should remain false"); + fatal(inDock.getFlagA(), "bad A flag: true"); + fatal(inDock.getFlagB(), "bad B flag: true"); + + prln("OLC = 63. Reload OLC after torpedo"); + inDock.instrIn.fill(new + Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63)); + + olc = inDock.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 + 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"); + + adjustIndent(-2); + prln("End sendTorpedo"); + } private void doOneTest(int testNum) { prln("MarinaTest: performing test: "+testNum); design.masterClear(tester); @@ -546,6 +629,7 @@ public class MarinaTest { case 1000: walkOneILC((IsolatedInDock)design); break; case 1001: countIlc((IsolatedInDock)design); break; case 1002: countOlc((IsolatedInDock)design); break; + case 1003: sendTorpedo((IsolatedInDock)design); break; // Bill's tests begin with 2000 case 2000: break; -- 1.7.10.4