changes

diff --git a/Robust/src/Benchmarks/SingleTM/Genome/ByteString.java b/Robust/src/Benchmarks/SingleTM/Genome/ByteString.java
index 20f6c468534e7a46f3573fbe408b395ad50fee6f..a3c3dd7caef88a0793c230c2aac2a3a06c6c2a50 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/Genome/ByteString.java
+++ b/Robust/src/Benchmarks/SingleTM/Genome/ByteString.java
@@ -146,14 +146,20 @@ public class ByteString {
   public byte byteAt(int i) {
     return value[i+offset];
   }
+
   public int hashCode() {
-    if (cachedHashcode!=0)
-      return cachedHashcode;
-    int hashcode=0;
-    for(int i=0; i<count; i++)
-      hashcode=hashcode*31+value[i+offset];
-    cachedHashcode=hashcode;
-    return hashcode;
+    if (cachedHashCode!=0)
+      return cachedHashCode;
+    int hash=0;
+    int off=offset;
+    for(int index = 0; index < str.length(); index++) {
+      byte c = str.value[index+off];
+      hash = c + (hash << 6) + (hash << 16) - hash;
+    }
+    if(hash < 0) hash = -hash;
+    
+    cachedHashCode=hash;
+    return hash;
   }
 
   public boolean equals(Object o) {

diff --git a/Robust/src/Benchmarks/SingleTM/Genome/Gene.java b/Robust/src/Benchmarks/SingleTM/Genome/Gene.java
index b44de8ba550a16a03127be855d1c4b7ee3723cf5..28ebb79faac89624bb72d08f2471bd083e67c0e8 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/Genome/Gene.java
+++ b/Robust/src/Benchmarks/SingleTM/Genome/Gene.java
@@ -5,7 +5,6 @@ public class Gene {
   
   Gene(int myLength) {
     length = myLength;
-    contents = "";
     startBitmapPtr = new Bitmap(length);
   }
 
@@ -15,21 +14,17 @@ public class Gene {
  * -- Populate contents with random gene
  * =============================================================================
  */
-  void create (Random randomObj) {
+  void create(Random randomObj) {
     int i;
     byte[] nucleotides = new byte[4];
     byte[] arrayContents = new byte[length];
-    nucleotides[0] = 'a';
-    nucleotides[1] = 'c';
-    nucleotides[2] = 'g';
-    nucleotides[3] = 't';
+    nucleotides[0] = (byte) 'a';
+    nucleotides[1] = (byte) 'c';
+    nucleotides[2] = (byte) 'g';
+    nucleotides[3] = (byte) 't';
 
     for (i = 0; i < length; i++) {
-      int legitimateNumber = (int)randomObj.random_generate(); 
-      if(legitimateNumber < 0) {
-        legitimateNumber *= -1;
-      }
-      arrayContents[i] = nucleotides[legitimateNumber % 4];
+      arrayContents[i] = nucleotides[(int)(randomObj.random_generate() % 4)];
     }
     
     contents = new ByteString(arrayContents);

diff --git a/Robust/src/Benchmarks/SingleTM/Genome/Hashtable.java b/Robust/src/Benchmarks/SingleTM/Genome/Hashtable.java
index 468aab444ae146b2f5a6978ab2429150be5449b9..65087e0b8ffddf169f4dc0f19009c0226d5eacec 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/Genome/Hashtable.java
+++ b/Robust/src/Benchmarks/SingleTM/Genome/Hashtable.java
@@ -14,7 +14,7 @@ public class Hashtable {
     }
     
     public boolean TMhashtable_insert (ByteString keyPtr, ByteString dataPtr) {
-      int i = hashSegment(keyPtr) % numBucket;
+      int i = keyPtr.hashCode() % numBucket;
 
       Pair findPair = new Pair();
       findPair.firstPtr = keyPtr;

diff --git a/Robust/src/Benchmarks/SingleTM/Genome/Sequencer.java b/Robust/src/Benchmarks/SingleTM/Genome/Sequencer.java
index bad30de80bcc33ad0de9991f2d5fae91e5a5d3b0..741467cc9f6b2068dc260629780a0af6c1ef6d3a 100644 (file)
--- a/Robust/src/Benchmarks/SingleTM/Genome/Sequencer.java
+++ b/Robust/src/Benchmarks/SingleTM/Genome/Sequencer.java
@@ -192,7 +192,7 @@ public class Sequencer {
          * and compute all of them here.
          */
         /* constructEntryPtr is local now */
-        constructEntryPtr.endHash = hashString(segment.substring(1)); // USE BYTE SUBSTRING FUNCTION
+        constructEntryPtr.endHash = segment.substring(1).hashCode(); // USE BYTE SUBSTRING FUNCTION
 
         startHash = 0;
         for (newj = 1; newj < segmentLength; newj++) {
@@ -312,15 +312,15 @@ public class Sequencer {
           endInfoEntries[0].jumpToNext = i;
           if (endInfoEntries[0].isEnd) {
             ByteString segment = constructEntries[0].segment;
-            constructEntries[0].endHash = hashString(segment.subString((int)index)); // USE BYTE SUBSTRING FUNCTION
+            constructEntries[0].endHash = segment.subString(index).hashCode(); // USE BYTE SUBSTRING FUNCTION
           }
           /* Continue scanning (do not reset i) */
           for (j = 0; i < numUniqueSegment; i+=endInfoEntries[i].jumpToNext) {
 
             if (endInfoEntries[i].isEnd) {
               ByteString segment = constructEntries[i].segment;
-              constructEntries[i].endHash = hashString(segment.substring((int)index)); // USE BYTE SUBSTRING FUNCTION
-              endInfoEntries[j].jumpToNext = Math.imax((int)1, (int)(i - j));
+              constructEntries[i].endHash = segment.substring(index).hashCode(); // USE BYTE SUBSTRING FUNCTION
+              endInfoEntries[j].jumpToNext = Math.imax(1, i - j);
               j = i;
             }
           }
@@ -363,7 +363,7 @@ public class Sequencer {
             if(sequencerPtr.sequence == null) {
               sequencerPtr.sequence = copyPtr;
             } else {
-              sequencerPtr.sequence = sequencerPtr.sequence.concat(copyPtr.substring((int)(prevOverlap)));
+              sequencerPtr.sequence = sequencerPtr.sequence.concat(copyPtr.substring(prevOverlap));
             }
             prevOverlap = constructEntryPtr.overlap;
             constructEntryPtr = constructEntryPtr.nextPtr;
@@ -377,41 +377,20 @@ public class Sequencer {
   static void trans2(ByteString startSegment, ByteString endSegment, constructEntry startConstructEntryPtr, constructEntry endConstructEntryPtr, int segmentLength, int substringLength, endInfoEntry endInfoEntries[], int entryIndex) {
     if(startConstructEntryPtr.isStart &&
        (endConstructEntryPtr.startPtr != startConstructEntryPtr) &&
-       (startSegment.substring(0, (int)substringLength).compareTo(endSegment.substring((int)(segmentLength-substringLength))) == 0))
-      {
-       startConstructEntryPtr.isStart = false;
+       (startSegment.substring(0, substringLength.compareTo(endSegment.substring(segmentLength-substringLength))) == 0)) {
+      startConstructEntryPtr.isStart = false;
        
-       /* Update endInfo (appended something so no inter end) */
-       endInfoEntries[entryIndex].isEnd = false;
-       /* Update segment chain construct info */
-       constructEntry startConstructEntry_endPtr = startConstructEntryPtr.endPtr;
-       constructEntry endConstructEntry_startPtr = endConstructEntryPtr.startPtr;
-       startConstructEntry_endPtr.startPtr = endConstructEntry_startPtr;
-       endConstructEntryPtr.nextPtr = startConstructEntryPtr;
-       endConstructEntry_startPtr.endPtr = startConstructEntry_endPtr;
-       endConstructEntryPtr.overlap = substringLength;
-       int newLength = endConstructEntry_startPtr.length + startConstructEntryPtr.length - substringLength;
-       endConstructEntry_startPtr.length = newLength;
-      }
-  }
-
-  /* =============================================================================
-   * hashString
-   * -- uses sdbm hash function
-   * =============================================================================
-   */
-  static int hashString (ByteString str) {
-    int hash = 0;
-
-    int index = 0;
-    // Note: Do not change this hashing scheme 
-    for(index = 0; index < str.length(); index++) {
-      byte c = str.byteAt(index);
-      hash = c + (hash << 6) + (hash << 16) - hash;
+      /* Update endInfo (appended something so no inter end) */
+      endInfoEntries[entryIndex].isEnd = false;
+      /* Update segment chain construct info */
+      constructEntry startConstructEntry_endPtr = startConstructEntryPtr.endPtr;
+      constructEntry endConstructEntry_startPtr = endConstructEntryPtr.startPtr;
+      startConstructEntry_endPtr.startPtr = endConstructEntry_startPtr;
+      endConstructEntryPtr.nextPtr = startConstructEntryPtr;
+      endConstructEntry_startPtr.endPtr = startConstructEntry_endPtr;
+      endConstructEntryPtr.overlap = substringLength;
+      int newLength = endConstructEntry_startPtr.length + startConstructEntryPtr.length - substringLength;
+      endConstructEntry_startPtr.length = newLength;
     }
-
-    if(hash < 0) hash *= -1;
-
-    return hash;
   }
 }