src/com/sun/vlsi/chips/marina/test/BitVectorGenerators.java

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