src/edu/berkeley/fleet/marina/BitVectorGenerators.java

   1 package edu.berkeley.fleet.marina;
   2 import com.sun.electric.tool.simulation.test.*;
   3
   4 import java.util.List;
   5 import java.util.Random;
   6 import java.util.ArrayList;
   7
   8 /**
   9  *  Miscellaneous routines to generate BitVectors as test inputs.
  10  *  Currently not used.
  11  */
  12 public class BitVectorGenerators {
  13
  14     private static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
  15
  16     public static BitVector generateBits(int start, boolean alternate, int n) {
  17         int temp = start;
  18         String bits = Integer.toString(start);
  19         if (alternate){
  20             for (int i = 2; i<= n; i++) {
  21                 temp = (temp+1)%2;
  22                 bits += Integer.toString (temp);
  23             }
  24         }
  25         else {
  26             for (int i = 2; i <= n; i++){
  27                 bits += Integer.toString(start);
  28             }
  29         }
  30         BitVector bv = new BitVector (n, bits);
  31         bv.put(0,bits);
  32         return bv;
  33     }
  34
  35
  36     public static String generateTokenContent(int i) {
  37         BitVector data0 = generateBits(0, true, 37);     // 37 bits, alternating
  38         BitVector  tag0 =  generateBits(1, false, 1);
  39         BitVector addr0 = generateBits(0, true, 14);    // 14 bits, alternating
  40         //BitVector addr0 = new BitVector ("00000001111111", "addr0");    // 14 bits, alternating
  41         BitVector data1 = generateBits(1, true, 37);     // 37 bits, alternating
  42         BitVector  tag1 =  generateBits(1, false, 1);
  43         //BitVector addr1 = generateBits(1, true, 14);    // 14 bits, alternating
  44         BitVector addr1 = new BitVector ("00101010101011", "addr1");    // 14 bits, alternating
  45         if (i==0){
  46             return generateBits(0, false, 37).getState()+"1"+addr0.getState();
  47         }
  48         else if (i%4 == 1){
  49             return data1.getState()+tag1.getState()+addr1.getState();// the addr data MAY enable cross: bit 0 (cross active high for Ring 1) and 13 (cross active low for Ring 2)
  50             //return data1.getState()+tag1.getState()+addr0.getState();//
  51         }
  52         else if (i%4 == 2){
  53             return data0.getState()+tag1.getState()+addr0.getState();
  54         }
  55         else if (i%4 == 3){
  56             return data1.getState()+tag0.getState()+addr1.getState();
  57             //return data1.getState()+tag0.getState()+addr0.getState();
  58         }
  59         else {
  60             return data0.getState()+tag0.getState()+addr0.getState();
  61         }
  62     }
  63     public static boolean compareTags(BitVector inputContent, BitVector exitContent){
  64         return inputContent.get(37) == exitContent.get(37);         //bit 37 is the tag bit
  65     }
  66
  67     public static boolean compareData(BitVector inputContent, BitVector exitContent){
  68         return inputContent.get(0, 37).getState().equals(exitContent.get(0, 37).getState()); //bits 0:36 are the data bits
  69     }
  70
  71     public static boolean compareAddress(BitVector inputContent, BitVector exitContent){
  72         return inputContent.get(38, 14).getState().equals(exitContent.get(38, 14).getState()); //bits 38:38+14 are the data bits
  73     }
  74
  75     public static boolean insertedVsRemoved(BitVector [] insertedTokenContent, BitVector [] removedTokenContent, int numTokens){
  76         for (int i = 0; i < numTokens; i++) {
  77             if (insertedTokenContent[i].get(37)){ //tag = 1 meaning data is valid
  78
  79                 if (!insertedTokenContent[i].getState().equals(removedTokenContent[i].getState())){
  80                     System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " does NOT match!");
  81                     return false;
  82                 }
  83                 System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " matches!");
  84             }
  85             else {//if tag=0, just need to make sure tag bit is still the same as inserted but data and address are no longer important
  86                 if (!compareTags(insertedTokenContent[i], removedTokenContent[i])){
  87                     System.out.println ("Inserted vs removed tag @ stage " + i + " does NOT match!");
  88                     return false;
  89                 }
  90                 System.out.println ("Inserted vs removed tag @ stage " + i + " matches!");
  91             }
  92         }
  93         System.out.println("Inserted tokens match removed tokens...All is well!");
  94         return true;
  95
  96     }
  97     public static void checkRingData(String ringNm, List<BitVector> dIn,
  98                                      List<BitVector> dOut) {
  99         int sz = dIn.size();
 100
 101         fatal(dOut.size()!=sz,  ringNm+
 102               " wrong number of items. Expected:"+sz+", got:"+dOut.size());
 103
 104         // find offset
 105         BitVector first = dIn.get(0);
 106         int offset=0;
 107         for (; offset<sz; offset++) {
 108             if (dOut.get(offset).equals(first)) break;
 109         }
 110         fatal(offset==sz, "first input item not found in output: "+first.getState());
 111         //prln("Output item offset: "+offset);
 112         System.out.println("Output item offset: "+offset);
 113
 114         // compare all items
 115         for (int i=0; i<sz; i++) {
 116             int outNdx = (i + offset + sz) % sz;
 117             BitVector out = dOut.get(outNdx);
 118             BitVector in = dIn.get(i);
 119
 120             fatal(!in.equals(out), i+"th input item:"+in.getState()+"\n"+
 121                   "doesn't match "+outNdx+"th output item: "+out.getState());
 122         }
 123     }
 124     /** Generate List of BitVectors where Token=true, high 25 data bits
 125      * are alternating ones and zeros, low 12 data bits increment from
 126      * zero, and address is given by random number generator. */
 127     public static List<BitVector> makeIncrDataRandAdr(int num, Random rand) {
 128         List<BitVector> ans = new ArrayList<BitVector>();
 129         BitVector dHi = new BitVector(25, "dataHi");
 130         BitVector dLo = new BitVector(12, "dataLo");
 131         BitVector t = new BitVector("1", "token");
 132         BitVector a = new BitVector(14, "addr");
 133         dHi.setFromLong(0x00aaaaa);
 134         for (int i=0; i<num; i++) {
 135             dLo.setFromLong(i);
 136             a.setFromLong((long)rand.nextInt());
 137             ans.add(dHi.cat(dLo).cat(t).cat(a));
 138             dHi = dHi.not();
 139         }
 140         return ans;
 141     }
 142
 143     /** Generate List of BitVectors where Token=true, high 25 data bits
 144      * are alternating ones and zeros, low 12 data bits increment from
 145      * zero, and address is given by addr. */
 146
 147     public static List<BitVector> makeIncrDataConstAdr(int num, int addr) {
 148         List<BitVector> ans = new ArrayList<BitVector>();
 149         BitVector dHi = new BitVector(25, "dataHi");
 150         BitVector dLo = new BitVector(12, "dataLo");
 151         BitVector t = new BitVector("1", "token");
 152         BitVector a = new BitVector(14, "addr");
 153         dHi.setFromLong(0x00aaaaa);
 154         a.setFromLong(addr);
 155         for (int i=0; i<num; i++) {
 156             dLo.setFromLong(i);
 157             ans.add(dHi.cat(dLo).cat(t).cat(a));
 158             dHi = dHi.not();
 159         }
 160         return ans;
 161     }
 162     public static List<BitVector> makeIncrDataConstAdr(int num, String addr) {
 163         List<BitVector> ans = new ArrayList<BitVector>();
 164         BitVector dHi = new BitVector(25, "dataHi");
 165         BitVector dLo = new BitVector(12, "dataLo");
 166         BitVector t = new BitVector("1", "token");
 167         BitVector a = new BitVector(addr, "addr");
 168         dHi.setFromLong(0x00aaaaa);
 169         //a.setFromLong(addr);
 170         for (int i=0; i<num; i++) {
 171             dLo.setFromLong(i);
 172             ans.add(dHi.cat(dLo).cat(t).cat(a));
 173             dHi = dHi.not();
 174         }
 175         return ans;
 176     }
 177     public static List<BitVector> makeConstDataConstAdr(int num, boolean dataValue, String addr) {
 178         List<BitVector> ans = new ArrayList<BitVector>();
 179         BitVector d = new BitVector(37, "dataHi");
 180         BitVector t = new BitVector("1", "token");
 181         BitVector a = new BitVector(addr, "addr");
 182         Long dat = dataValue ? -1L : 0L;
 183         d.setFromLong(dat);
 184         for (int i=0; i<num; i++) {
 185             ans.add(d.cat(t).cat(a));
 186         }
 187         return ans;
 188     }
 189     public static List<BitVector> make0TokenAdd(int num, int addrMsb, int addrLsb) {
 190         List<BitVector> ans = new ArrayList<BitVector>();
 191         BitVector d = new BitVector(37, "data");
 192         BitVector t = new BitVector("0", "token");
 193         BitVector aHi = new BitVector(1, "addrHi");
 194         BitVector aLo = new BitVector(1, "addrLo");
 195         BitVector aMid = new BitVector(12, "addrMid");
 196         d.setFromLong(0x0000000000L);
 197         aHi.setFromLong(addrMsb);
 198         aLo.setFromLong(addrLsb);
 199         aMid.setFromLong(0x000);
 200         for (int i=0; i<num; i++) {
 201             ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
 202         }
 203         return ans;
 204     }
 205
 206     /** Generate List of BitVectors where Token=true, the address MSB
 207      * is given by addrMsb, the address LSB is set by addrLSB,
 208      * data bits alternate between 0xaaaa and 0x5555.
 209      * 12 insignificant address bits to crosser alternate between 0xaaa and 0x555 */
 210
 211     public static List<BitVector> makeAltDataAdd(int num, Long longValue, int addrMsb, int addrLsb, boolean crosser) {
 212         List<BitVector> ans = new ArrayList<BitVector>();
 213         BitVector d = new BitVector(37, "data");
 214         BitVector t = new BitVector("1", "token");
 215         BitVector aHi = new BitVector(1, "addrHi");
 216         BitVector aLo = new BitVector(1, "addrLo");
 217         BitVector aMid = new BitVector(12, "addrMid");
 218         BitVector aRing = new BitVector(14, "addrRing");    //address bits for ring, bit 0 and 13 do not need to be anything specific b/c there isn't a cross element in the ring
 219         //d.setFromLong(0xaaaaaaaaaaL);
 220         d.setFromLong(longValue);
 221         aHi.setFromLong(addrMsb);
 222         aLo.setFromLong(addrLsb);
 223         aMid.setFromLong(0xaaa);
 224         aRing.setFromLong(0xaaaa);
 225         for (int i=0; i<num; i++) {
 226             if (crosser){
 227                 ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
 228             } else {
 229                 ans.add(d.cat(t).cat(aRing));
 230             }
 231             d = d.not();
 232             aMid = aMid.not();
 233             aRing = aRing.not();
 234         }
 235         return ans;
 236     }
 237     public static void compareJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
 238         fatal(din.size()!=dout.size(),
 239               "in count="+din.size()+" out count="+dout.size());
 240         for (int i=0; i<din.size(); i++) {
 241             BitVector dI = din.get(i);
 242             BitVector dO = dout.get(i);
 243             //prln("Count = " + i + ", dI = " + dI + ", dO = " + dO);
 244             fatal(!dI.get(0,37).equals(dO.get(0,37)),
 245                   "data mismatch! in data + tag:"+dI.get(0,37).getState()+" out data + tag:"+dO.get(0,37).getState());
 246         }
 247     }
 248
 249     public static void checkUnorderedData(List<BitVector> din, List<BitVector> dout) {
 250         int sz = din.size();
 251         fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
 252         for (BitVector in : din) {
 253             boolean found = false;
 254             for (BitVector out : dout) {
 255                 if (in.equals(out)) {
 256                     found = true;
 257                     break;
 258                 }
 259             }
 260             fatal(!found, "Can't find vector in output: "+in.getState());
 261         }
 262     }
 263     public static void checkUnorderedJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
 264         int sz = din.size();
 265         fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
 266         for (BitVector in : din) {
 267             boolean found = false;
 268             for (BitVector out : dout) {
 269                 if (in.get(0,37).equals(out.get(0,37))) {
 270                     found = true;
 271                     break;
 272                 }
 273             }
 274             fatal(!found, "Can't find vector in output: "+in.getState());
 275         }
 276     }
 277
 278     public static void checkToken0Add(List<BitVector> din, List<BitVector> dout) {
 279         int sz = din.size();
 280         fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
 281         for (BitVector in : din) {
 282             boolean found = false;
 283             for (BitVector out : dout) {
 284                 if (in.get(38,14).equals(out.get(38,14))) {
 285                     found = true;
 286                     break;
 287                 }
 288             }
 289             fatal(!found, "Can't find vector in output: "+in.getState());
 290         }
 291     }
 292
 293     public static int findBitVectorIndex(List<BitVector> din, BitVector findThis) {
 294         int sz = din.size();
 295         boolean found=false;
 296         int i=0;
 297         for (BitVector in : din) {
 298             if (in.equals(findThis)) {
 299                 found = true;
 300                 break;
 301             } else {i++;}
 302         }
 303         fatal(!found, "Can't find vector in output: "+findThis.getState());
 304         return i;
 305
 306     }
 307
 308 }