From 76ff0c5890dbbdc055ff685fb4e5a7ce6fe9c53a Mon Sep 17 00:00:00 2001 From: afedward Date: Wed, 10 Jun 2009 01:56:47 +0000 Subject: [PATCH] Added ByteArray implementation. --- .../SingleTM/genome/java/ByteArray.java | 75 ++++++++++ .../Benchmarks/SingleTM/genome/java/Gene.java | 22 +-- .../SingleTM/genome/java/Genome.java | 6 +- .../SingleTM/genome/java/Hashtable.java | 8 +- .../Benchmarks/SingleTM/genome/java/List.java | 4 +- .../Benchmarks/SingleTM/genome/java/Pair.java | 6 +- .../SingleTM/genome/java/Segments.java | 21 +-- .../SingleTM/genome/java/Sequencer.java | 128 ++++++++---------- .../SingleTM/genome/java/constructEntry.java | 4 +- .../Benchmarks/SingleTM/genome/java/makefile | 2 +- 10 files changed, 169 insertions(+), 107 deletions(-) create mode 100644 Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java diff --git a/Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java b/Robust/src/Benchmarks/SingleTM/genome/java/ByteArray.java new file mode 100644 index 00000000..67db2cce --- /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 8c5dacae..c29b5a36 100644 --- 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 f4e864be..09f0c820 100644 --- 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 baab7dff..2bdb9c27 100644 --- 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 90660456..7840dbe5 100644 --- 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 3c96d9d6..c946dd94 100644 --- 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 fd4eb949..508d5424 100644 --- 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 b9888543..d7bcf07c 100644 --- 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 64057d51..499faf8d 100644 --- 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 0f2148e6..aa28caca 100644 --- 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} -- 2.34.1