projects / fleet.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 696463d)
update MarinaTest to work with new encoder
authorAdam Megacz <adam.megacz@sun.com>
Tue, 3 Mar 2009 20:38:35 +0000 (20:38 +0000)
committerAdam Megacz <adam.megacz@sun.com>
Tue, 3 Mar 2009 20:38:35 +0000 (20:38 +0000)
testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java patch | blob | history

diff --git a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
index 84c08ee..3264b27 100644 (file)
--- a/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
+++ b/testCode/com/sun/vlsi/chips/marina/test/MarinaTest.java
@@ -452,7 +452,7 @@ public class MarinaTest {
         marina.instrIn.fill(
             new Instruction.Move(DOCK,
                                  false,                 /* requeueing  */
-                                 Predicate.IgnoreOLC,   /* predicate   */
+                                 Predicate.IgnoreFlagD,   /* predicate   */
                                  false,                 /* torpedoable */
                                  null,                  /* path        */
                                  false,                 /* tokenIn     */
@@ -478,7 +478,7 @@ public class MarinaTest {
        
        prln("ILC=1");
        marina.instrIn.fill(
-               new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1));
+               new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
 
        getCtrsFlags(marina);
        
@@ -486,7 +486,7 @@ public class MarinaTest {
         marina.instrIn.fill(
             new Instruction.Move(DOCK,
                                  false,                 /* requeueing  */
-                                 Predicate.IgnoreOLC,   /* predicate   */
+                                 Predicate.IgnoreFlagD,   /* predicate   */
                                  false,                 /* torpedoable */
                                  null,                  /* path        */
                                  false,                 /* tokenIn     */
@@ -514,7 +514,7 @@ public class MarinaTest {
        
        prln("ILC=\\infty");
        marina.instrIn.fill(
-               new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,SetSource.Infinity));
+               new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity));
 
        getCtrsFlags(marina);
        
@@ -536,7 +536,7 @@ public class MarinaTest {
     private void setOLC(Marina marina, int olc) {
         // ugly hack, to be removed when we fix the zero-detect circuit
         for(int i=0; i<2; i++) {
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, olc));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, olc));
         }
     }
 
@@ -546,7 +546,7 @@ public class MarinaTest {
        
         List<BitVector> toks;
 
-        Predicate only_if_olc_zero    = Predicate.OLCZero;
+        Predicate only_if_olc_zero    = Predicate.FlagD;
         Predicate only_if_olc_nonzero = Predicate.Default;
 
         for(int olc : new int[] { 1, 0 }) {
@@ -597,7 +597,7 @@ public class MarinaTest {
         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);
-                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                         flag_a
                                                         ? Instruction.Set.FlagFunction.ONE
                                                         : Instruction.Set.FlagFunction.ZERO,
@@ -618,7 +618,7 @@ public class MarinaTest {
 
                     prln("Attempting send data with a="+flag_a+", b="+flag_b+", predicate="+predicate.getClass().getName());
                     adjustIndent(2);
-                    marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1));
+                    marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
                     marina.instrIn.fill(new Instruction.Move(DOCK,
                                                              false,                 /* requeueing  */
                                                              predicate,             /* predicate   */
@@ -675,7 +675,7 @@ public class MarinaTest {
                int inOlc = 0x20 >> i;
                prln("Set inOlc="+inOlc);
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, inOlc));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, inOlc));
                int outOlc = marina.getOLC();
                fatal(outOlc!=inOlc, "walkOneOLC: got="+outOlc+" expected="+inOlc);
        }
@@ -691,7 +691,7 @@ public class MarinaTest {
                        prln("inIlc="+inIlc);
 
                        marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, inIlc));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, inIlc));
 
                        Ilc ilc = marina.getILC();
                int outIlc = ilc.getCount();
@@ -704,7 +704,7 @@ public class MarinaTest {
        }
        prln("Now test the infinity bit");
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, SetSource.Infinity));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
                Ilc ilc = marina.getILC();
                fatal(!ilc.getInfinity(), "bad Infinity bit: false");
        adjustIndent(-2);
@@ -717,7 +717,7 @@ public class MarinaTest {
        
        prln("Set ILC=63");
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, maxIlc));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, maxIlc));
 
                int ilc = marina.getILC().getCount();
                fatal(ilc!=maxIlc, "bad ILC count: "+ilc+" expected: "+maxIlc);
@@ -726,7 +726,7 @@ public class MarinaTest {
         marina.instrIn.fill(
             new Instruction.Move(DOCK,
                                  false,                                /* requeueing */
-                                 Predicate.IgnoreOLC,   /* predicate   */
+                                 Predicate.IgnoreFlagD,   /* predicate   */
                                  false,                 /* torpedoable */
                                  null,                  /* path        */
                                  false,                 /* tokenIn     */
@@ -754,13 +754,13 @@ public class MarinaTest {
        adjustIndent(2);
        
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, maxOlc));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, maxOlc));
                for (int i=maxOlc; i>=0; i--) {
                        prln("OLC should be: "+i);
                        int olc = marina.getOLC();
                        fatal(olc!=i, "bad OLC: "+olc+" expected: "+i);
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, SetSource.Decrement));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, SetSource.Decrement));
                }
 
        adjustIndent(-2);
@@ -790,7 +790,7 @@ public class MarinaTest {
     private static final Instruction NOP =
         new Instruction.Move(DOCK,
                              false,                  /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -804,7 +804,7 @@ public class MarinaTest {
     private static final Instruction REQUEUEING_NOP =
         new Instruction.Move(DOCK,
                              true,                  /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -818,7 +818,7 @@ public class MarinaTest {
     private static final Instruction SEND_DATA =
         new Instruction.Move(DOCK,
                              false,                 /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -832,7 +832,7 @@ public class MarinaTest {
     private static final Instruction RECV_DATA =
         new Instruction.Move(DOCK,
                              false,                 /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -846,7 +846,7 @@ public class MarinaTest {
     private static final Instruction SEND_TOKEN =
         new Instruction.Move(DOCK,
                              false,                 /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -860,7 +860,7 @@ public class MarinaTest {
     private static final Instruction RECV_TOKEN =
         new Instruction.Move(DOCK,
                              false,                 /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              true,                  /* tokenIn     */
@@ -874,7 +874,7 @@ public class MarinaTest {
     private static final Instruction REQUEUEING_SEND_DATA =
         new Instruction.Move(DOCK,
                              true,                  /* requeueing  */
-                             Predicate.IgnoreOLC,   /* predicate   */
+                             Predicate.IgnoreFlagD,   /* predicate   */
                              false,                 /* torpedoable */
                              null,                  /* path        */
                              false,                 /* tokenIn     */
@@ -932,7 +932,7 @@ public class MarinaTest {
         prln("Executing Set OLC="+olc_value);
         setOLC(marina, olc_value);
        prln("Executing Set ILC=1");
-       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
 
         // verify state0 "EPI->ring" and 0->1 transition
        prln("Executing Send Data (requeueable); this will cause 0->1 transition and be discarded");
@@ -942,13 +942,13 @@ public class MarinaTest {
 
         // verify state1 "EPI->ring"
        prln("Executing Set ILC=1; this will be recirculated");
-       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
 
        prln("Executing Send Data; this will be recirculated");
         marina.instrIn.fill(REQUEUEING_SEND_DATA);
 
        prln("Executing Set OLC--; this will be recirculated");
-        marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,SetSource.Decrement));
+        marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement));
 
         // verify state1 "OD waits"
         dataItems = marina.data.drainMany(2);
@@ -1008,7 +1008,7 @@ public class MarinaTest {
         setOLC(marina, olc_value);
 
        prln("Executing Set ILC=1");
-       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 1));
 
         // insert many non-requeueing "send data item" instructions;
         // this will let us single-step the execution point by
@@ -1027,7 +1027,7 @@ public class MarinaTest {
         marina.instrIn.fill(REQUEUEING_SEND_DATA);
 
        prln("Inserting [Rq] Set OLC--; this will be recirculated");
-        marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,SetSource.Decrement));
+        marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.Decrement));
 
         // insert the tail, which will cause the 0->2 transition
        prln("Inserting Tail");
@@ -1092,7 +1092,7 @@ public class MarinaTest {
         }
 
        prln("inserting instruction: [Rq] Set ILC=1");
-       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
 
        prln("inserting instruction: [Rq] Send Data");
         marina.instrIn.fill(REQUEUEING_SEND_DATA);
@@ -1122,7 +1122,7 @@ public class MarinaTest {
         setOLC(marina, 63);
 
        prln("inserting instruction: Set ILC=1");
-       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
 
         // if you uncomment this, then the NOP will be dropped and the test will pass
        //prln("inserting instruction: [Rq] Nop; this will cause 0->1 transition and possibly be discarded");
@@ -1132,7 +1132,7 @@ public class MarinaTest {
         marina.instrIn.fill(REQUEUEING_SEND_DATA);
 
        prln("inserting instruction: [Rq] Set ILC=1");
-       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,1));
+       marina.instrIn.fill(new Instruction.Set(DOCK,true,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
 
        prln("inserting instruction: Tail");
        marina.instrIn.fill(new Instruction.Tail(DOCK));
@@ -1170,7 +1170,7 @@ public class MarinaTest {
             prln((b?"Setting":"Clearing")+" flags");
 
             marina.instrIn.fill(new 
-                                Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                                Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                 b ? one : zero,
                                                 b ? one : zero
                                                 ));
@@ -1205,7 +1205,7 @@ public class MarinaTest {
 
                                     // set A,B flags to a_state and b_state
                                     marina.instrIn.fill(new 
-                                                        Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                                                        Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                                         a_state ? one : zero,
                                                                         b_state ? one : zero
                                                                         ));
@@ -1225,7 +1225,7 @@ public class MarinaTest {
                                     if (c_input!=null) func = func.add(c_input);
 
                                     Instruction inst = new 
-                                        Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                                        Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                         !which ? func : zero.add(Predicate.FlagA),
                                                         which  ? func : zero.add(Predicate.FlagB)
                                                         );
@@ -1249,10 +1249,10 @@ public class MarinaTest {
        prln("Begin recvData");
        adjustIndent(2);
 
-        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, CLEAR_FLAG, CLEAR_FLAG));
+        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
         marina.instrIn.fill(new Instruction.Move(DOCK,
                                                  false,                /* requeueing  */
-                                                 Predicate.IgnoreOLC,   /* predicate   */
+                                                 Predicate.IgnoreFlagD,   /* predicate   */
                                                  true,                  /* torpedoable */
                                                  null,                  /* path        */
                                                  false,                 /* tokenIn     */
@@ -1262,7 +1262,7 @@ public class MarinaTest {
                                                  false,                 /* dataOut     */
                                                  false                  /* tokenOut    */
                                                  ));
-        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, SET_FLAG, SET_FLAG));
+        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD, SET_FLAG, SET_FLAG));
 
         prln("checking to confirm that A flag is cleared");
         fatal(marina.getFlagA(), "bad A flag: "+marina.getFlagA());
@@ -1308,7 +1308,7 @@ public class MarinaTest {
 
             marina.instrIn.fill(new Instruction.Move(DOCK,
                                                      false,                // requeueing  
-                                                     Predicate.IgnoreOLC,   // predicate   
+                                                     Predicate.IgnoreFlagD,   // predicate   
                                                      true,                  // torpedoable 
                                                      null,                  // path        
                                                      false,                 // tokenIn     
@@ -1347,7 +1347,7 @@ public class MarinaTest {
             marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
 
             marina.instrIn.fill(RECV_DATA);
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,SetSource.DataLatch));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,SetSource.DataLatch));
 
             int olc = marina.getOLC();
             fatal(olc != (1<<bit), "expected olc to be " + (1<<bit) + ", but got " + olc); 
@@ -1371,9 +1371,9 @@ public class MarinaTest {
             data.set(bit, true);
             marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
 
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,1));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
             marina.instrIn.fill(RECV_DATA);
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,SetSource.DataLatch));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.DataLatch));
 
             int ilc = marina.getILC().getCount();
             fatal(ilc != (1<<bit), "expected ilc to be " + (1<<bit) + ", but got " + ilc); 
@@ -1411,7 +1411,7 @@ public class MarinaTest {
 
         for(long val : new long[] { -1, 0, 1, (-1L << 14) }) {
             prln("inserting Set Data Latch (sign-extended) 37'b" + Long.toString(val, 1));
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                     Instruction.Set.SetDest.DataLatch,
                                                     val));
 
@@ -1444,7 +1444,7 @@ public class MarinaTest {
        adjustIndent(2);
 
         prln("clearing the D register");
-        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+        marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                 Instruction.Set.SetDest.DataLatch,
                                                 0));
 
@@ -1458,7 +1458,7 @@ public class MarinaTest {
                 new edu.berkeley.fleet.api.BitVector(19);
             for(int i=0; i<immediate.length(); i++)
                 immediate.set(i, (val & (1L << i)) != 0);
-            marina.instrIn.fill(new Instruction.Shift(DOCK,false,Predicate.IgnoreOLC,immediate));
+            marina.instrIn.fill(new Instruction.Shift(DOCK,false,Predicate.IgnoreFlagD,immediate));
 
             // shift over 19 LSB's towards MSB
             for(int i=0; i<19; i++)
@@ -1514,12 +1514,12 @@ public class MarinaTest {
                 marina.fillNorthProperStopper(new MarinaPacket(data, false, addr));
                 
                 prln("clearing flags");
-                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC, CLEAR_FLAG, CLEAR_FLAG));
+                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
                 
                 prln("executing recv data with Dc="+dc);
                 marina.instrIn.fill(new Instruction.Move(DOCK,
                                                          false,                        /* requeueing  */
-                                                         Predicate.IgnoreOLC,   /* predicate   */
+                                                         Predicate.IgnoreFlagD,   /* predicate   */
                                                          true,                  /* torpedoable */
                                                          null,                  /* path        */
                                                          false,                 /* tokenIn     */
@@ -1531,7 +1531,7 @@ public class MarinaTest {
                                                          ));
                 
                 prln("copying c-flag to a-flag");
-                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                         Instruction.Set.FlagFunction.ZERO.add(Predicate.FlagC),
                                                         CLEAR_FLAG
                                                         ));
@@ -1564,7 +1564,7 @@ public class MarinaTest {
         prln("send data with path="+bv);
         marina.instrIn.fill(new Instruction.Move(DOCK,
                                                  false,                 /* requeueing  */
-                                                 Predicate.IgnoreOLC,   /* predicate   */
+                                                 Predicate.IgnoreFlagD,   /* predicate   */
                                                  false,                 /* torpedoable */
                                                  path,                  /* path        */
                                                  false,                 /* tokenIn     */
@@ -1588,7 +1588,7 @@ public class MarinaTest {
         prln("send data with no change to path");
         marina.instrIn.fill(new Instruction.Move(DOCK,
                                                  false,                 /* requeueing  */
-                                                 Predicate.IgnoreOLC,   /* predicate   */
+                                                 Predicate.IgnoreFlagD,   /* predicate   */
                                                  false,                 /* torpedoable */
                                                  null,                  /* path        */
                                                  false,                 /* tokenIn     */
@@ -1627,7 +1627,7 @@ public class MarinaTest {
             prln("recv path, send data (using recv'd path)");
             marina.instrIn.fill(new Instruction.Move(DOCK,
                                                      false,                 /* requeueing  */
-                                                     Predicate.IgnoreOLC,   /* predicate   */
+                                                     Predicate.IgnoreFlagD,   /* predicate   */
                                                      false,                 /* torpedoable */
                                                      null,                  /* path        */
                                                      false,                 /* tokenIn     */
@@ -1657,7 +1657,7 @@ public class MarinaTest {
             int ilc = bit<0 ? 0 : (1<<bit);
 
             prln("set ilc="+ilc);
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,ilc));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,ilc));
 
             prln("send data");
             marina.instrIn.fill(SEND_DATA);
@@ -1676,27 +1676,27 @@ public class MarinaTest {
        
        prln("Set OLC = 1");
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 1));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 1));
 
                int olc = marina.getOLC();
                fatal(olc!=1, "bad OLC: "+olc+" expected: 1");
 
                prln("Set A=0, B=0");
                marina.instrIn.fill(new 
-            Instruction.Set(DOCK,false,Predicate.IgnoreOLC, CLEAR_FLAG, CLEAR_FLAG));
+            Instruction.Set(DOCK,false,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
 
                fatal(marina.getFlagA(), "bad A flag: true");
                fatal(marina.getFlagB(), "bad B flag: true");
                
                prln("Set ILC = Infinity");
                marina.instrIn.fill(new 
-               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, SetSource.Infinity));
+               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, SetSource.Infinity));
                
                prln("execute a move instruction that does nothing but loops until torpedo arrives"); 
         marina.instrIn.fill(
             new Instruction.Move(DOCK,
                                     false,                             /* requeueing */
-                                 Predicate.IgnoreOLC,   /* predicate   */
+                                 Predicate.IgnoreFlagD,   /* predicate   */
                                  true,                 /* torpedoable */
                                  null,                  /* path        */
                                  false,                 /* tokenIn     */
@@ -1725,7 +1725,7 @@ public class MarinaTest {
        
        prln("OLC = 63. Reload OLC after torpedo");
                marina.instrIn.fill(new 
-                       Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 63));
+                       Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 63));
 
                olc = marina.getOLC();
                fatal(olc!=63, "bad OLC: "+olc+" expected: 63");
@@ -1750,12 +1750,12 @@ public class MarinaTest {
 
         for(boolean torpedoable : new boolean[] { true, false }) {
             prln("set ilc=\\infty");
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,SetSource.Infinity));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,SetSource.Infinity));
             
             prln("nop");
             marina.instrIn.fill(new Instruction.Move(DOCK,
                                                      false,                 /* requeueing  */
-                                                     Predicate.IgnoreOLC,   /* predicate   */
+                                                     Predicate.IgnoreFlagD,   /* predicate   */
                                                      torpedoable,           /* torpedoable */
                                                      null,                  /* path        */
                                                      false,                 /* tokenIn     */
@@ -1804,9 +1804,9 @@ public class MarinaTest {
             int decr_amount = decr_amounts[which];
 
             prln("inserting set olc="+olc);
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter,olc));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter,olc));
             prln("inserting set ilc=1");
-            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter,1));
+            marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter,1));
 
             // commenting the following four lines causes this test to pass
             prln("disabling instruction send");
@@ -1816,7 +1816,7 @@ public class MarinaTest {
 
             prln("inserting "+decr_amount+" olc-- instructions");
             for(int i=0; i<decr_amount; i++)
-                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreOLC,
+                marina.instrIn.fill(new Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,
                                                         SetDest.OuterLoopCounter,SetSource.Decrement));
 
             prln("inserting [olc!=0] send data");
@@ -1862,11 +1862,11 @@ public class MarinaTest {
                int notZero = 32 >> i;
                        prln("Set ILC=0");
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 0));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0));
                
                        prln("Then immediately set ILC="+notZero);
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, notZero));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero));
                
                        prln("Verify ILC using scan chain");
                        Ilc ilc = marina.getILC();
@@ -1878,11 +1878,11 @@ public class MarinaTest {
                        
                        prln("Set ILC="+notZero);
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, notZero));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, notZero));
                
                        prln("Then immediately set ILC=0");
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.InnerLoopCounter, 0));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.InnerLoopCounter, 0));
                        
                        prln("Verify ILC using scan chain");
                        ilc = marina.getILC();
@@ -1904,17 +1904,17 @@ public class MarinaTest {
 
        prln("Set A=0, B=0");
                marina.instrIn.fill(new 
-            Instruction.Set(DOCK,false,Predicate.IgnoreOLC, CLEAR_FLAG, CLEAR_FLAG));
+            Instruction.Set(DOCK,false,Predicate.IgnoreFlagD, CLEAR_FLAG, CLEAR_FLAG));
 
        for (int i=0; i<6; i++) {
                int notZero = 32 >> i;
                        prln("Set OLC=0");
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 0));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0));
        
                        prln("Then immediately set OLC="+notZero);
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, notZero));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero));
        
                        prln("Verify OLC count using scan chain");
                        int outOlc = marina.getOLC();
@@ -1923,16 +1923,16 @@ public class MarinaTest {
                        prln("Verify OLC zero bit using predication");
                        prln("if (OLC==0) {A=1; B=1;} // should not get executed");
                        marina.instrIn.fill(new 
-                           Instruction.Set(DOCK,false,Predicate.OLCZero, SET_FLAG, SET_FLAG));
+                           Instruction.Set(DOCK,false,Predicate.FlagD, SET_FLAG, SET_FLAG));
                        fatal(marina.getFlagA(), "bad A flag. expected: false");
        
                        prln("Set OLC="+notZero);
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, notZero));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, notZero));
        
                        prln("Then immediately set OLC=0");
                        marina.instrIn.fill(new 
-                               Instruction.Set(DOCK,false,Predicate.IgnoreOLC,SetDest.OuterLoopCounter, 0));
+                               Instruction.Set(DOCK,false,Predicate.IgnoreFlagD,SetDest.OuterLoopCounter, 0));
                        
                        prln("Verify OLC count using scan chain");
                        outOlc = marina.getOLC();
The FleetCode -- http://fleet.cs.berkeley.edu/