--- /dev/null
+package com.sun.vlsi.chips.marina.test;
+import com.sun.async.test.BitVector;
+import com.sun.async.test.Infrastructure;
+
+import java.util.List;
+import java.util.Random;
+import java.util.ArrayList;
+
+/**
+ * Miscellaneous routines to generate BitVectors as test inputs.
+ * Currently not used.
+ */
+public class BitVectorGenerators {
+
+ private static void fatal(boolean pred, String msg) { MarinaUtils.fatal(pred, msg); }
+
+ public static BitVector generateBits(int start, boolean alternate, int n) {
+ int temp = start;
+ String bits = Integer.toString(start);
+ if (alternate){
+ for (int i = 2; i<= n; i++) {
+ temp = (temp+1)%2;
+ bits += Integer.toString (temp);
+ }
+ }
+ else {
+ for (int i = 2; i <= n; i++){
+ bits += Integer.toString(start);
+ }
+ }
+ BitVector bv = new BitVector (n, bits);
+ bv.put(0,bits);
+ return bv;
+ }
+
+
+ public static String generateTokenContent(int i) {
+ BitVector data0 = generateBits(0, true, 37); // 37 bits, alternating
+ BitVector tag0 = generateBits(1, false, 1);
+ BitVector addr0 = generateBits(0, true, 14); // 14 bits, alternating
+ //BitVector addr0 = new BitVector ("00000001111111", "addr0"); // 14 bits, alternating
+ BitVector data1 = generateBits(1, true, 37); // 37 bits, alternating
+ BitVector tag1 = generateBits(1, false, 1);
+ //BitVector addr1 = generateBits(1, true, 14); // 14 bits, alternating
+ BitVector addr1 = new BitVector ("00101010101011", "addr1"); // 14 bits, alternating
+ if (i==0){
+ return generateBits(0, false, 37).getState()+"1"+addr0.getState();
+ }
+ else if (i%4 == 1){
+ 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)
+ //return data1.getState()+tag1.getState()+addr0.getState();//
+ }
+ else if (i%4 == 2){
+ return data0.getState()+tag1.getState()+addr0.getState();
+ }
+ else if (i%4 == 3){
+ return data1.getState()+tag0.getState()+addr1.getState();
+ //return data1.getState()+tag0.getState()+addr0.getState();
+ }
+ else {
+ return data0.getState()+tag0.getState()+addr0.getState();
+ }
+ }
+ public static boolean compareTags(BitVector inputContent, BitVector exitContent){
+ return inputContent.get(37) == exitContent.get(37); //bit 37 is the tag bit
+ }
+
+ public static boolean compareData(BitVector inputContent, BitVector exitContent){
+ return inputContent.get(0, 37).getState().equals(exitContent.get(0, 37).getState()); //bits 0:36 are the data bits
+ }
+
+ public static boolean compareAddress(BitVector inputContent, BitVector exitContent){
+ return inputContent.get(38, 14).getState().equals(exitContent.get(38, 14).getState()); //bits 38:38+14 are the data bits
+ }
+
+ public static boolean insertedVsRemoved(BitVector [] insertedTokenContent, BitVector [] removedTokenContent, int numTokens){
+ for (int i = 0; i < numTokens; i++) {
+ if (insertedTokenContent[i].get(37)){ //tag = 1 meaning data is valid
+
+ if (!insertedTokenContent[i].getState().equals(removedTokenContent[i].getState())){
+ System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " does NOT match!");
+ return false;
+ }
+ System.out.println ("Inserted vs removed data, tag and address @ stage " + i + " matches!");
+ }
+ 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
+ if (!compareTags(insertedTokenContent[i], removedTokenContent[i])){
+ System.out.println ("Inserted vs removed tag @ stage " + i + " does NOT match!");
+ return false;
+ }
+ System.out.println ("Inserted vs removed tag @ stage " + i + " matches!");
+ }
+ }
+ System.out.println("Inserted tokens match removed tokens...All is well!");
+ return true;
+
+ }
+ public static void checkRingData(String ringNm, List<BitVector> dIn,
+ List<BitVector> dOut) {
+ int sz = dIn.size();
+
+ fatal(dOut.size()!=sz, ringNm+
+ " wrong number of items. Expected:"+sz+", got:"+dOut.size());
+
+ // find offset
+ BitVector first = dIn.get(0);
+ int offset=0;
+ for (; offset<sz; offset++) {
+ if (dOut.get(offset).equals(first)) break;
+ }
+ fatal(offset==sz, "first input item not found in output: "+first.getState());
+ //prln("Output item offset: "+offset);
+ System.out.println("Output item offset: "+offset);
+
+ // compare all items
+ for (int i=0; i<sz; i++) {
+ int outNdx = (i + offset + sz) % sz;
+ BitVector out = dOut.get(outNdx);
+ BitVector in = dIn.get(i);
+
+ fatal(!in.equals(out), i+"th input item:"+in.getState()+"\n"+
+ "doesn't match "+outNdx+"th output item: "+out.getState());
+ }
+ }
+ /** Generate List of BitVectors where Token=true, high 25 data bits
+ * are alternating ones and zeros, low 12 data bits increment from
+ * zero, and address is given by random number generator. */
+ public static List<BitVector> makeIncrDataRandAdr(int num, Random rand) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector dHi = new BitVector(25, "dataHi");
+ BitVector dLo = new BitVector(12, "dataLo");
+ BitVector t = new BitVector("1", "token");
+ BitVector a = new BitVector(14, "addr");
+ dHi.setFromLong(0x00aaaaa);
+ for (int i=0; i<num; i++) {
+ dLo.setFromLong(i);
+ a.setFromLong((long)rand.nextInt());
+ ans.add(dHi.cat(dLo).cat(t).cat(a));
+ dHi = dHi.not();
+ }
+ return ans;
+ }
+
+ /** Generate List of BitVectors where Token=true, high 25 data bits
+ * are alternating ones and zeros, low 12 data bits increment from
+ * zero, and address is given by addr. */
+
+ public static List<BitVector> makeIncrDataConstAdr(int num, int addr) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector dHi = new BitVector(25, "dataHi");
+ BitVector dLo = new BitVector(12, "dataLo");
+ BitVector t = new BitVector("1", "token");
+ BitVector a = new BitVector(14, "addr");
+ dHi.setFromLong(0x00aaaaa);
+ a.setFromLong(addr);
+ for (int i=0; i<num; i++) {
+ dLo.setFromLong(i);
+ ans.add(dHi.cat(dLo).cat(t).cat(a));
+ dHi = dHi.not();
+ }
+ return ans;
+ }
+ public static List<BitVector> makeIncrDataConstAdr(int num, String addr) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector dHi = new BitVector(25, "dataHi");
+ BitVector dLo = new BitVector(12, "dataLo");
+ BitVector t = new BitVector("1", "token");
+ BitVector a = new BitVector(addr, "addr");
+ dHi.setFromLong(0x00aaaaa);
+ //a.setFromLong(addr);
+ for (int i=0; i<num; i++) {
+ dLo.setFromLong(i);
+ ans.add(dHi.cat(dLo).cat(t).cat(a));
+ dHi = dHi.not();
+ }
+ return ans;
+ }
+ public static List<BitVector> makeConstDataConstAdr(int num, boolean dataValue, String addr) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector d = new BitVector(37, "dataHi");
+ BitVector t = new BitVector("1", "token");
+ BitVector a = new BitVector(addr, "addr");
+ Long dat = dataValue ? -1L : 0L;
+ d.setFromLong(dat);
+ for (int i=0; i<num; i++) {
+ ans.add(d.cat(t).cat(a));
+ }
+ return ans;
+ }
+ public static List<BitVector> make0TokenAdd(int num, int addrMsb, int addrLsb) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector d = new BitVector(37, "data");
+ BitVector t = new BitVector("0", "token");
+ BitVector aHi = new BitVector(1, "addrHi");
+ BitVector aLo = new BitVector(1, "addrLo");
+ BitVector aMid = new BitVector(12, "addrMid");
+ d.setFromLong(0x0000000000L);
+ aHi.setFromLong(addrMsb);
+ aLo.setFromLong(addrLsb);
+ aMid.setFromLong(0x000);
+ for (int i=0; i<num; i++) {
+ ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
+ }
+ return ans;
+ }
+
+ /** Generate List of BitVectors where Token=true, the address MSB
+ * is given by addrMsb, the address LSB is set by addrLSB,
+ * data bits alternate between 0xaaaa and 0x5555.
+ * 12 insignificant address bits to crosser alternate between 0xaaa and 0x555 */
+
+ public static List<BitVector> makeAltDataAdd(int num, Long longValue, int addrMsb, int addrLsb, boolean crosser) {
+ List<BitVector> ans = new ArrayList<BitVector>();
+ BitVector d = new BitVector(37, "data");
+ BitVector t = new BitVector("1", "token");
+ BitVector aHi = new BitVector(1, "addrHi");
+ BitVector aLo = new BitVector(1, "addrLo");
+ BitVector aMid = new BitVector(12, "addrMid");
+ 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
+ //d.setFromLong(0xaaaaaaaaaaL);
+ d.setFromLong(longValue);
+ aHi.setFromLong(addrMsb);
+ aLo.setFromLong(addrLsb);
+ aMid.setFromLong(0xaaa);
+ aRing.setFromLong(0xaaaa);
+ for (int i=0; i<num; i++) {
+ if (crosser){
+ ans.add(d.cat(t).cat(aHi).cat(aMid).cat(aLo));
+ } else {
+ ans.add(d.cat(t).cat(aRing));
+ }
+ d = d.not();
+ aMid = aMid.not();
+ aRing = aRing.not();
+ }
+ return ans;
+ }
+ public static void compareJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
+ fatal(din.size()!=dout.size(),
+ "in count="+din.size()+" out count="+dout.size());
+ for (int i=0; i<din.size(); i++) {
+ BitVector dI = din.get(i);
+ BitVector dO = dout.get(i);
+ //prln("Count = " + i + ", dI = " + dI + ", dO = " + dO);
+ fatal(!dI.get(0,37).equals(dO.get(0,37)),
+ "data mismatch! in data + tag:"+dI.get(0,37).getState()+" out data + tag:"+dO.get(0,37).getState());
+ }
+ }
+
+ public static void checkUnorderedData(List<BitVector> din, List<BitVector> dout) {
+ int sz = din.size();
+ fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+ for (BitVector in : din) {
+ boolean found = false;
+ for (BitVector out : dout) {
+ if (in.equals(out)) {
+ found = true;
+ break;
+ }
+ }
+ fatal(!found, "Can't find vector in output: "+in.getState());
+ }
+ }
+ public static void checkUnorderedJUSTDataTag(List<BitVector> din, List<BitVector> dout) {
+ int sz = din.size();
+ fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+ for (BitVector in : din) {
+ boolean found = false;
+ for (BitVector out : dout) {
+ if (in.get(0,37).equals(out.get(0,37))) {
+ found = true;
+ break;
+ }
+ }
+ fatal(!found, "Can't find vector in output: "+in.getState());
+ }
+ }
+
+ public static void checkToken0Add(List<BitVector> din, List<BitVector> dout) {
+ int sz = din.size();
+ fatal(dout.size()!=sz, "found "+dout.size()+" items, Expected: "+sz);
+ for (BitVector in : din) {
+ boolean found = false;
+ for (BitVector out : dout) {
+ if (in.get(38,14).equals(out.get(38,14))) {
+ found = true;
+ break;
+ }
+ }
+ fatal(!found, "Can't find vector in output: "+in.getState());
+ }
+ }
+
+ public static int findBitVectorIndex(List<BitVector> din, BitVector findThis) {
+ int sz = din.size();
+ boolean found=false;
+ int i=0;
+ for (BitVector in : din) {
+ if (in.equals(findThis)) {
+ found = true;
+ break;
+ } else {i++;}
+ }
+ fatal(!found, "Can't find vector in output: "+findThis.getState());
+ return i;
+
+ }
+
+}
\ No newline at end of file
projects / fleet.git / blobdiff