Added ByteArray implementation.

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java b/Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java
new file mode 100644 (file)
index 0000000..67db2cc
--- /dev/null
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java
@@ -0,0 +1,75 @@
+public class ByteArray {
+    public byte[] array;
+    public int offset;
+    
+    public ByteArray() {
+    }
+    
+    public ByteArray(byte[] ptr) {
+           array=ptr;
+    }
+    
+    
+    public void print() {
+      String myStr = new String(array);
+      System.out.print("offset: " + offset);
+      System.out.println(myStr);
+    }
+
+    //Create copy
+    public ByteArray newIndex(int newindex) {
+       ByteArray ba=new ByteArray(array);
+           ba.offset=offset+newindex;
+       return ba;
+    }
+    
+    public ByteArray substring(int begindex, int endindex) {
+      int newlength = endindex-begindex;
+      byte barray[] = new byte[newlength];
+      int i = 0;
+      for(i = 0; i < (newlength); i++) {
+        barray[i] = array[offset+begindex+i];
+      }
+      ByteArray ba = new ByteArray(barray);
+      return ba;
+      
+    }
+    
+    //Modify current
+    public void changeIndex(int newindex) {   // USEFUL FOR IN MEMORY SUBSTRINGS, JUST CALL CHANGE INDEX TWICE TO RESET OFFSET BACK TO UNEDITED
+           offset = newindex;
+    }
+    
+    public int compareTo(ByteArray targetArray) {
+    
+      if((array.length-offset) < (targetArray.array.length-targetArray.offset)) {
+        return -1;
+      } else if ((array.length-offset) > (targetArray.array.length-targetArray.offset)) {
+        return 1;
+      }
+    
+      int i = 0;
+      for(i = 0; i < array.length; i++) {
+        if(array[offset+i] < targetArray.array[targetArray.offset+i]) {
+          return -1;
+        } else if (array[offset+i] > targetArray.array[targetArray.offset+i]) {
+          return 1;
+        }
+      }
+      return 0;
+    }
+    
+    public void concat(ByteArray targetArray) {
+      byte newarray[] = new byte[(array.length-offset) + (targetArray.array.length-targetArray.offset)];
+      int i = 0;
+      for(i = 0; i < (array.length - offset); i++) {
+        newarray[i] = array[offset+i];
+      }
+      int j = 0;
+      for(j = 0; j < (targetArray.array.length - targetArray.offset); j++) {
+        newarray[i+j] = targetArray.array[targetArray.offset+j];
+      }
+      array = newarray;
+      offset = 0;
+    }
+}

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java
index 8c5dacae27c60edcb9bfca76f1b5aa7780be733b..c29b5a36c153ffb6c800a4b73a45f811f8b04adb 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Gene.java
@@ -1,11 +1,12 @@
 public class Gene {
   public long length;
-  public String contents;
+  public ByteArray contents;
   public Bitmap startBitmapPtr; /* used for creating segments */
   
   Gene(long myLength) {
     length = myLength;
-    contents = "";
+    byte array[] = new byte[length];
+    contents = new ByteArray(array);
     startBitmapPtr = new Bitmap(length);
   }
 
@@ -17,12 +18,12 @@ public class Gene {
  */
   void create (Random randomObj) {
     int i;
-    char[] nucleotides = new char[4];
-    char[] arrayContents = new char[length];
-    nucleotides[0] = 'a';
-    nucleotides[1] = 'c';
-    nucleotides[2] = 'g';
-    nucleotides[3] = 't';
+    byte[] nucleotides = new byte[4];
+    byte[] arrayContents = new byte[length];
+    nucleotides[0] = (byte)'a';
+    nucleotides[1] = (byte)'c';
+    nucleotides[2] = (byte)'g';
+    nucleotides[3] = (byte)'t';
 
 //    System.out.println("length: " + length);
 
@@ -33,10 +34,9 @@ public class Gene {
       }
 //      System.out.println("legitNum: " + legitimateNumber + ":" + (legitimateNumber % 4));
       arrayContents[i] = nucleotides[legitimateNumber % 4];
-//      System.out.println("arrayContents[" + i + "]: " + arrayContents[i]);
+//      System.out.println("arrayContents[" + i + "]: " + (char)arrayContents[i]);
     }
     
-    contents = new String(arrayContents);
-//    System.out.println("contents: " + contents);
+    contents = new ByteArray(arrayContents);
   }  
 }

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java
index f4e864be0280a5ed01662c0e24128b127fb553f8..09f0c8200d7e7b15f645a84168a52a0de8417c38 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Genome.java
@@ -124,7 +124,7 @@ public class Genome extends Thread {
 
 /* Create and Start Threads */
 
-    String gene = g.genePtr.contents;
+    ByteArray gene = g.genePtr.contents;
 
     Genome[] gn = new Genome[g.numThread];
 
@@ -175,8 +175,8 @@ public class Genome extends Thread {
 
     /* Check result */
     {
-        String sequence = g.sequencerPtr.sequence;
-//        System.out.println("sequence: " + sequence);
+        ByteArray sequence = g.sequencerPtr.sequence;
+//        System.out.print("sequence: ");sequence.print();
         boolean result = (gene.compareTo(sequence) == 0) ? true:false;
         System.out.println("Sequence matches gene: " + (result ? "yes" : "no"));
         if (result) {

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Hashtable.java b/Robust/src/Benchmarks/SingleTM/genome/java/Hashtable.java
index baab7dff567c6fed1316751f71084a472c8eb50f..2bdb9c2781467bb88ce7ca3a3cf339d08b17e863 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Hashtable.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Hashtable.java
@@ -18,7 +18,7 @@ public class Hashtable {
       growthFactor = ((growthFactor < 0) ? 3 : growthFactor);
     }
     
-    boolean TMhashtable_insert (String keyPtr, String dataPtr) {
+    boolean TMhashtable_insert (ByteArray keyPtr, ByteArray dataPtr) {
       long i = hashSegment(keyPtr) % numBucket;
 
       Pair findPair = new Pair();
@@ -51,13 +51,13 @@ public class Hashtable {
       }
     }
     
-    long hashSegment (String str) {
+    long hashSegment (ByteArray str) {
       long hash = 0;
 
       int index = 0;
       /* Note: Do not change this hashing scheme */
-      for(index = 0; index < str.length(); index++) {
-        char c = str.charAt(index);
+      for(index = 0; index < str.array.length; index++) {
+        char c = (char)(str.array[str.offset+index]);
         hash = c + (hash << 6) + (hash << 16) - hash;
       }
   

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/List.java b/Robust/src/Benchmarks/SingleTM/genome/java/List.java
index 9066045645606d3b91079fa918a07c0357f895a5..7840dbe52961a46967947d1c7d2828f5c163b376 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/List.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/List.java
@@ -76,8 +76,8 @@ public class List {
     }
 */
     long compareSegment (Pair a, Pair b) { // RE WRITE THIS FOR BYTE ARRAYS
-      String aString = (String)a.firstPtr;
-      String bString = (String)b.firstPtr;
+      ByteArray aString = (ByteArray)a.firstPtr;
+      ByteArray bString = (ByteArray)b.firstPtr;
       return aString.compareTo(bString);
     }
  

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Pair.java b/Robust/src/Benchmarks/SingleTM/genome/java/Pair.java
index 3c96d9d67ac4af1176c6211d4164ad10e933e07d..c946dd945f12ca240e4c89b0f3a4e6858ef3f28d 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Pair.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Pair.java
@@ -1,13 +1,13 @@
 public class Pair {
-    String firstPtr;
-    String secondPtr;
+    ByteArray firstPtr;
+    ByteArray secondPtr;
     
     public Pair() {
       firstPtr = null;
       secondPtr = null;
     }
     
-    Pair (String myFirstPtr, String mySecondPtr) { // WILL LIKELY NEED TO RE-WRITE THIS
+    Pair (ByteArray myFirstPtr, ByteArray mySecondPtr) { // WILL LIKELY NEED TO RE-WRITE THIS
         firstPtr = myFirstPtr;
         secondPtr = mySecondPtr;
     }

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java
index fd4eb9497d895aae53a62f425ff72f8d3adc81af..508d5424e35d4371dc79ce3a9c263d4a7dc2694e 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Segments.java
@@ -3,13 +3,12 @@ public class Segments {
     public long minNum;
     Vector contentsPtr;
 /* private: */
-    String strings[];
+    ByteArray strings[];
     
     Segments (long myLength, long myMinNum) {
       minNum = myMinNum;
       length = myLength;
-      
-      strings = new String[(int)minNum];
+      strings = new ByteArray[minNum];
       contentsPtr = new Vector((int)minNum);
     }
 
@@ -20,7 +19,7 @@ public class Segments {
      * =============================================================================
      */
     void create (Gene genePtr, Random randomPtr) {
-        String geneString;
+        ByteArray geneString;
         long geneLength;
         Bitmap startBitmapPtr;
         long numStart;
@@ -31,23 +30,27 @@ public class Segments {
         geneLength = genePtr.length;
         startBitmapPtr = genePtr.startBitmapPtr;
         numStart = geneLength - length + 1;
-        
+//        String str = new String(geneString.array);
+//        System.out.println("str: " + str);
 //        System.out.println("minNum: " + minNum);
         /* Pick some random segments to start */
+//        System.out.println("minNum: " + minNum);
         for (i = 0; i < minNum; i++) {
             int j = (int)(randomPtr.random_generate(randomPtr) % numStart);
             boolean status = startBitmapPtr.set(j);
             strings[i] = geneString.substring((int)j, (int)(j+length)); // WRITE SUBSTRING FUNCTION
+//            System.out.print("seg: ");
+//            strings[i].print();
             contentsPtr.addElement(strings[i]);
         }
         
-
+///        System.out.println("post random segments selection");
         
         /* Make sure segment covers start */
         i = 0;
         if (!startBitmapPtr.isSet(i)) {
-            String string;
-            string = geneString.subString((int)i, (int)(i+length)); // USE BYTE SUBSTRING FUNCTION
+            ByteArray string;
+            string = geneString.substring((int)i, (int)(i+length)); // USE BYTE SUBSTRING FUNCTION
             contentsPtr.addElement(string);
             startBitmapPtr.set(i);
         }
@@ -64,7 +67,7 @@ public class Segments {
             if (i == i_stop) {
                 /* Found big enough hole */
                 i = i - 1;
-                String string = geneString.subString((int)i, (int)(i+length)); // USE BYTE SUBSTRING FUNCTION
+                ByteArray string = geneString.substring((int)i, (int)(i+length)); // USE BYTE SUBSTRING FUNCTION
                 contentsPtr.addElement(string);
                 startBitmapPtr.set(i);
             }

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java
index b98885435b6863a3efe6ad995aa24aac219536f1..d7bcf07c9fe950ef33872fc714536cf0c8634950 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/Sequencer.java
@@ -1,6 +1,6 @@
 public class Sequencer {
 
-      public String sequence;
+      public ByteArray sequence;
 
       public Segments segmentsPtr;
 
@@ -118,7 +118,7 @@ public class Sequencer {
             long ii;
             long ii_stop = Math.imin((int)i_stop, (int)(i+CHUNK_STEP1));
             for (ii = i; ii < ii_stop; ii++) {
-                String segment = (String)segmentsContentsPtr.elementAt((int)ii);
+                ByteArray segment = (ByteArray)segmentsContentsPtr.elementAt((int)ii);
 //                TMHASHTABLE_INSERT(uniqueSegmentsPtr, segment, segment);
 //                System.out.print("Placing: " + segment + " into uniqueSegmentsPtr...");
                 if(uniqueSegmentsPtr.TMhashtable_insert(segment, segment)) {
@@ -136,8 +136,22 @@ public class Sequencer {
     
     
     System.out.println("Past removing duplicate segments");
+/*    System.out.println("Uniq segs: ");
     
-    /*
+    int jer = 0;
+    for(jer = 0; jer < uniqueSegmentsPtr.numBucket; jer++) {
+      List jerPtr = uniqueSegmentsPtr.buckets[jer];
+      ListNode jerit = jerPtr.head;
+      while(jerit.nextPtr != null) {
+        jerit = jerit.nextPtr;
+        ByteArray jerba = jerit.dataPtr.firstPtr;
+        String jerstr = new String(jerba.array);
+        System.out.println(jerstr);
+      }
+    }
+    
+    System.out.println("End of uniqsegs");
+*/    /*
      * Step 2a: Iterate over unique segments and compute hashes.
      *
      * For the gene "atcg", the hashes for the end would be:
@@ -214,7 +228,8 @@ public class Sequencer {
 //      System.out.println("past null it check");
 
         it = it.nextPtr;    
-        String segment = it.dataPtr.firstPtr;
+        ByteArray segment = it.dataPtr.firstPtr;
+
 //        System.out.println("Segment: " + segment);
 //      System.out.println("segment[" + i + "]: " + segment);
     //        list_iter_t it;
@@ -258,11 +273,21 @@ public class Sequencer {
          * and compute all of them here.
          */
         /* constructEntryPtr is local now */
-        constructEntryPtr.endHash = hashString(segment.substring(1)); // USE BYTE SUBSTRING FUNCTION
+        
+        
+//        segment.print();
+//        segment.changeIndex(1);
+//        segment.print();
+        constructEntryPtr.endHash = hashString(segment.newIndex(1));   // CAN BE SWAPPED OUT WITH CHANGE INDEX, FOR SOME REASON SLOWS IT DOWN INSTEAD OF SPEEDING IT UP. DOESNT MAKE SENSE TO US.
+//        segment.changeIndex(0);
+
 
+//        System.out.println("first endHash: " + constructEntryPtr.endHash);
         startHash = 0;
         for (newj = 1; newj < segmentLength; newj++) {
-            startHash = segment.charAt((int)newj-1) + (startHash << 6) + (startHash << 16) - startHash;
+            startHash = (char)(segment.array[segment.offset + (int)newj-1]) + (startHash << 6) + (startHash << 16) - startHash;
+            String myStr = new String(segment.array);
+//            System.out.println("hash for segment-" + myStr + ": " + startHash);
             atomic {
   //                TM_BEGIN();
   //                status = TMTABLE_INSERT(startHashToConstructEntryTables[j], (ulong_t)startHash, (void*)constructEntryPtr );
@@ -277,7 +302,7 @@ public class Sequencer {
         /*
          * For looking up construct entries quickly
          */
-        startHash = segment.charAt((int)newj-1) + (startHash << 6) + (startHash << 16) - startHash;
+        startHash = (char)(segment.array[segment.offset + (int)newj-1]) + (startHash << 6) + (startHash << 16) - startHash;
           atomic {
   //            TM_BEGIN();
   //            status = TMTABLE_INSERT(hashToConstructEntryTable, (ulong_t)startHash, (void*)constructEntryPtr);
@@ -322,14 +347,6 @@ public class Sequencer {
                 index_stop = index_start + partitionSize;
             }
         }
-//#else /* !(HTM || STM) */
-//        index_start = 0;
-//        index_stop = numUniqueSegment;
-//#endif /* !(HTM || STM) */
-
-
-//        System.out.println("index_start: " + index_start);
-//        System.out.println("index_stop: " + index_stop);
 
         /* Iterating over disjoint itervals in the range [0, numUniqueSegment) */
         for (entryIndex = index_start;
@@ -341,81 +358,46 @@ public class Sequencer {
             }
 
             /*  ConstructEntries[entryIndex] is local data */
+//            System.out.println("entryIndex: " + entryIndex);
             constructEntry endConstructEntryPtr = constructEntries[(int)entryIndex];
-            String endSegment = endConstructEntryPtr.segment;
+            ByteArray endSegment = endConstructEntryPtr.segment;
             long endHash = endConstructEntryPtr.endHash;
-
+//            System.out.println("endHash: " + endHash);
             LinkedList chainPtr = buckets[(int)(endHash % numBucket)]; /* buckets: constant data */
             LinkedListIterator it = (LinkedListIterator)chainPtr.iterator();
             while (it.hasNext()) {
                 constructEntry startConstructEntryPtr = (constructEntry)it.next();
-                String startSegment = startConstructEntryPtr.segment;
-//                System.out.println("startSegment: " + startSegment);
+                ByteArray startSegment = startConstructEntryPtr.segment;
                 long newLength = 0;
 
                 /* endConstructEntryPtr is local except for properties startPtr/endPtr/length */
                 atomic {
 //                TM_BEGIN();
-
-                /* Check if matches */
-//                if (TM_SHARED_READ(startConstructEntryPtr->isStart) &&
-//                    (TM_SHARED_READ_P(endConstructEntryPtr->startPtr) != startConstructEntryPtr) &&
-//                    (strncmp(startSegment,
-//                             &endSegment[segmentLength - substringLength],
-//                             substringLength) == 0))
-//                  System.out.println("end = " + endSegment);
-//                  System.out.println("strt= " + startSegment);
-//                  System.out.println("at " + (segmentLength-substringLength) + " size " + substringLength);
-
-//                  System.out.println(startSegment.substring(0, (int)substringLength) + ".compareTo(" + endSegment.substring((int)(segmentLength-substringLength)) + ") == 0: " + (startSegment.substring(0, (int)substringLength).compareTo(endSegment.substring((int)(segmentLength-substringLength))) == 0));
-                  
-//                  System.out.println("startConstructEntryPtr.isStart: " + startConstructEntryPtr.isStart);
-//                  System.out.println("endConstructEntryPtr.startPtr != startConstructEntryPtr: " + (endConstructEntryPtr.startPtr != startConstructEntryPtr));
+//                  System.out.print("Comparing: ");endSegment.print();
+//                  System.out.print("and      : ");startSegment.print();
+//                  System.out.println("size: " + substringLength);
                   
                   if(startConstructEntryPtr.isStart &&
                       (endConstructEntryPtr.startPtr != startConstructEntryPtr) &&
-                      (startSegment.substring(0, (int)substringLength).compareTo(endSegment.substring((int)(segmentLength-substringLength))) == 0))
+                      (startSegment.substring(0, (int)substringLength).compareTo(endSegment.newIndex((int)(segmentLength-substringLength))) == 0))
                   {
+
 //                    System.out.println("Match!");
-//                    TM_SHARED_WRITE(startConstructEntryPtr->isStart, FALSE);
                     startConstructEntryPtr.isStart = false;
-//                    System.out.println("A");
                     constructEntry startConstructEntry_endPtr;
                     constructEntry endConstructEntry_startPtr;
 
                     /* Update endInfo (appended something so no longer end) */
-//                    TM_LOCAL_WRITE(endInfoEntries[entryIndex].isEnd, FALSE);
                     endInfoEntries[(int)entryIndex].isEnd = false;
-//                    System.out.println("B");
                     /* Update segment chain construct info */
-//                    startConstructEntry_endPtr = (constructEntry_t*)TM_SHARED_READ_P(startConstructEntryPtr->endPtr);
                     startConstructEntry_endPtr = startConstructEntryPtr.endPtr;
-//                    System.out.println("C");
-//                    endConstructEntry_startPtr = (constructEntry_t*)TM_SHARED_READ_P(endConstructEntryPtr->startPtr);
                     endConstructEntry_startPtr = endConstructEntryPtr.startPtr;
-//                    System.out.println("D");                    
-//                    assert(startConstructEntry_endPtr);
-//                    assert(endConstructEntry_startPtr);
-
-
-//                    TM_SHARED_WRITE_P(startConstructEntry_endPtr->startPtr, endConstructEntry_startPtr);
-//                    if(startConstructEntry_endPtr == null) System.out.println("pwnted");
                     startConstructEntry_endPtr.startPtr = endConstructEntry_startPtr;
-//                    System.out.println("E");
-//                    TM_LOCAL_WRITE_P(endConstructEntryPtr->nextPtr, startConstructEntryPtr);
                     endConstructEntryPtr.nextPtr = startConstructEntryPtr;
-//                    System.out.println("F");                    
-//                    TM_SHARED_WRITE_P(endConstructEntry_startPtr->endPtr, startConstructEntry_endPtr);
                     endConstructEntry_startPtr.endPtr = startConstructEntry_endPtr;
-//                    System.out.println("G");                    
-//                    TM_SHARED_WRITE(endConstructEntryPtr->overlap, substringLength);
                     endConstructEntryPtr.overlap = substringLength;
-//                    System.out.println("H");                    
                     newLength = endConstructEntry_startPtr.length + startConstructEntryPtr.length - substringLength;
-//                    TM_SHARED_WRITE(endConstructEntry_startPtr->length, newLength);
-//                    System.out.println("I");
                     endConstructEntry_startPtr.length = newLength;
-//                    System.out.println("J");
                   } else {/* if (matched) */
 //                    System.out.println("Non match.");
                   }
@@ -429,8 +411,6 @@ public class Sequencer {
             } /* iterate over chain */
 
         } /* for (endIndex < numUniqueSegment) */
-        
-//        System.out.println("out of for2");
 
 //        thread_barrier_wait();
         Barrier.enterBarrier();
@@ -466,9 +446,9 @@ public class Sequencer {
                 /* entry 0 is handled seperately from the loop below */
                 endInfoEntries[0].jumpToNext = i;
                 if (endInfoEntries[0].isEnd) {
-                    String segment = constructEntries[0].segment;
+                    ByteArray segment = constructEntries[0].segment;
 //                    segment.changeOffset((int)index);
-                    constructEntries[0].endHash = hashString(segment.subString((int)index)); // USE BYTE SUBSTRING FUNCTION
+                    constructEntries[0].endHash = hashString(segment.newIndex((int)index)); // USE BYTE SUBSTRING FUNCTION
                 }
                 //System.out.println("post inner if");                
                 /* Continue scanning (do not reset i) */
@@ -478,9 +458,9 @@ public class Sequencer {
                     
                     if (endInfoEntries[(int)i].isEnd) {
                     //System.out.println("isEnd");
-                        String segment = constructEntries[(int)i].segment;
+                        ByteArray segment = constructEntries[(int)i].segment;
                         //System.out.println("segment[" + i + "]: " + segment);
-                        constructEntries[(int)i].endHash = hashString(segment.substring((int)index)); // USE BYTE SUBSTRING FUNCTION
+                        constructEntries[(int)i].endHash = hashString(segment.newIndex((int)index)); // USE BYTE SUBSTRING FUNCTION
                         endInfoEntries[(int)j].jumpToNext = Math.imax((int)1, (int)(i - j));
                         j = i;
                     }
@@ -518,9 +498,9 @@ public class Sequencer {
 
         //System.out.println("totalLength: " + totalLength);
 
-        String sequence = sequencerPtr.sequence;
+        ByteArray sequence = sequencerPtr.sequence;
 
-        String copyPtr = sequence;
+        ByteArray copyPtr = sequence;
         long sequenceLength = 0;
 
         for (i = 0; i < numUniqueSegment; i++) {
@@ -541,6 +521,7 @@ public class Sequencer {
 //                        break;
 //                    }
                     copyPtr = constructEntryPtr.segment;
+//                    System.out.print("building: ");copyPtr.print();
 //                    System.out.println("copyPtr:  " + constructEntryPtr.segment);
 //                    System.out.println("overlap: " + prevOverlap);  // OVERLAP MAKESS NOOOO SEEEENNSEEEE
 //                    System.out.println("length:  " + constructEntryPtr.length);
@@ -550,7 +531,7 @@ public class Sequencer {
                       sequencerPtr.sequence = copyPtr;
                     } else {
 //                      System.out.println("not null, concat");
-                      sequencerPtr.sequence = sequencerPtr.sequence.concat(copyPtr.substring((int)(prevOverlap)));
+                      sequencerPtr.sequence.concat(copyPtr.newIndex((int)(prevOverlap)));
                     }
 //                    System.out.println("sequence: " + sequencerPtr.sequence);
                     prevOverlap = constructEntryPtr.overlap;
@@ -590,19 +571,22 @@ public class Sequencer {
       return hash;
   }
 */
-  static long hashString (String str)
+  static long hashString (ByteArray str)
   {
+      //String myStr = new String(str.array);
+//      System.out.println("comping hash for string: " + myStr + " offset: " + str.offset);  
+  
       long hash = 0;
 
       int index = 0;
       // Note: Do not change this hashing scheme 
-      for(index = 0; index < str.length(); index++) {
-        char c = str.charAt(index);
+      for(index = str.offset; index < str.array.length; index++) {
+        char c = (char)(str.array[index]);
         hash = c + (hash << 6) + (hash << 16) - hash;
       }
   
       if(hash < 0) hash *= -1;
-
+      //System.out.println("hash: " + hash);
       return hash;
   }
 

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/constructEntry.java b/Robust/src/Benchmarks/SingleTM/genome/java/constructEntry.java
index 64057d51459b5aed4fb66831cef612fdd0ddc2fc..499faf8d2dfdece31e05980aeaf8637ee2c3e7a7 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/constructEntry.java
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/constructEntry.java
@@ -1,6 +1,6 @@
 public class constructEntry {
     boolean isStart;
-    String segment;
+    ByteArray segment;
     long endHash;
     constructEntry startPtr;
     constructEntry nextPtr;
@@ -8,7 +8,7 @@ public class constructEntry {
     long overlap;
     long length;
       
-    constructEntry(String mySegment, boolean myStart, long myEndHash, constructEntry myStartPtr, constructEntry myNextPtr, constructEntry myEndPtr, long myOverlap, long myLength) {
+    constructEntry(ByteArray mySegment, boolean myStart, long myEndHash, constructEntry myStartPtr, constructEntry myNextPtr, constructEntry myEndPtr, long myOverlap, long myLength) {
       segment = mySegment;
       isStart = myStart;
       endHash = myEndHash;

diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/makefile b/Robust/src/Benchmarks/SingleTM/genome/java/makefile
index 0f2148e6f6e618e4285f09edbaf00a17e9606176..aa28cacae60e5ba16cf064e9f888780cd7715b8d 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/genome/java/makefile
+++ b/Robust/src/Benchmarks/SingleTM/genome/java/makefile
@@ -9,7 +9,7 @@ SRC=${MAINCLASS}.java \
   ../../../../ClassLibrary/JavaSTM/Barrier.java \
   Sequencer.java \
   Table.java
-FLAGS=-mainclass ${MAINCLASS} -thread -nooptimize -debug -dcopts -joptimize -profile -abcclose
+FLAGS=-mainclass ${MAINCLASS} -thread -nooptimize -debug
 
 default:
        ../../../../buildscript ${FLAGS} -o ${MAINCLASS} ${SRC}