From b00c7ee7cad99b2fe7d8f0fc892a943033997083 Mon Sep 17 00:00:00 2001 From: bdemsky Date: Wed, 21 Oct 2009 04:29:07 +0000 Subject: [PATCH] try to work on memory usage...have large test case running now --- .../src/Benchmarks/SingleTM/Bayes/Adtree.java | 199 +++++----------- .../Benchmarks/SingleTM/Bayes/AdtreeNode.java | 26 +-- .../Benchmarks/SingleTM/Bayes/AdtreeVary.java | 23 +- .../src/Benchmarks/SingleTM/Bayes/Bayes.java | 54 ++--- .../src/Benchmarks/SingleTM/Bayes/Data.java | 67 ++---- .../Benchmarks/SingleTM/Bayes/Learner.java | 132 ++++------- Robust/src/Benchmarks/SingleTM/Bayes/Net.java | 51 +---- .../Benchmarks/SingleTM/Bayes/QuickSort.java | 16 +- .../src/Benchmarks/SingleTM/Bayes/Random.java | 74 +++--- .../src/Benchmarks/SingleTM/Bayes/Sort.java | 214 +++++++++--------- .../Benchmarks/SingleTM/Bayes/Vector_t.java | 141 ++++++++++++ Robust/src/Benchmarks/SingleTM/Bayes/makefile | 9 +- 12 files changed, 455 insertions(+), 551 deletions(-) create mode 100644 Robust/src/Benchmarks/SingleTM/Bayes/Vector_t.java diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Adtree.java b/Robust/src/Benchmarks/SingleTM/Bayes/Adtree.java index c124d593..f70fca10 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/Adtree.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Adtree.java @@ -83,155 +83,69 @@ public class Adtree { int numRecord; AdtreeNode rootNodePtr; - public Adtree() { - - } - - /* ============================================================================= - * freeNode - * ============================================================================= - */ - public void - freeNode (AdtreeNode nodePtr) - { - nodePtr.varyVectorPtr.vector_free(); - nodePtr = null; - } - - - - /* ============================================================================= - * freeVary - * ============================================================================= - */ - public void - freeVary (AdtreeVary varyPtr) - { - varyPtr = null; - } - - /* ============================================================================= * adtree_alloc * ============================================================================= */ - public static Adtree adtree_alloc () - { - Adtree adtreePtr = new Adtree(); - if (adtreePtr != null) { - adtreePtr.numVar = -1; - adtreePtr.numRecord = -1; - adtreePtr.rootNodePtr = null; - } - - return adtreePtr; - } - - - /* ============================================================================= - * freeNodes - * ============================================================================= - */ - public void - freeNodes (AdtreeNode nodePtr) - { - if (nodePtr != null) { - Vector_t varyVectorPtr = nodePtr.varyVectorPtr; - int numVary = varyVectorPtr.vector_getSize(); - for (int v = 0; v < numVary; v++) { - AdtreeVary varyPtr = (AdtreeVary)(varyVectorPtr.vector_at(v)); - freeNodes(varyPtr.zeroNodePtr); - freeNodes(varyPtr.oneNodePtr); - freeVary(varyPtr); - } - freeNode(nodePtr); - } - } - + public Adtree() { + numVar = -1; + numRecord = -1; + rootNodePtr = null; + } - /* ============================================================================= - * adtree_free - * ============================================================================= - */ - public void - adtree_free () - { - freeNodes(rootNodePtr); - } /* ============================================================================= * makeVary * ============================================================================= */ - public AdtreeVary - makeVary (int parentIndex, - int index, - int start, - int numRecord, - Data dataPtr) - { - AdtreeVary varyPtr = AdtreeVary.allocVary(index); - - if ((parentIndex + 1 != index) && (numRecord > 1)) { - dataPtr.data_sort(start, numRecord, index); - } - - int num0 = dataPtr.data_findSplit(start, numRecord, index); - int num1 = numRecord - num0; - - int mostCommonValue = ((num0 >= num1) ? 0 : 1); - varyPtr.mostCommonValue = mostCommonValue; - - if (num0 == 0 || mostCommonValue == 0) { - varyPtr.zeroNodePtr = null; - } else { - varyPtr.zeroNodePtr = - makeNode(index, index, start, num0, dataPtr); - varyPtr.zeroNodePtr.value = 0; - } - - if (num1 == 0 || mostCommonValue == 1) { - varyPtr.oneNodePtr = null; - } else { - varyPtr.oneNodePtr = - makeNode(index, index, (start + num0), num1, dataPtr); - varyPtr.oneNodePtr.value = 1; - } + public AdtreeVary makeVary (int parentIndex, int index, int start, int numRecord, Data dataPtr) { + AdtreeVary varyPtr = new AdtreeVary(index); - return varyPtr; + if ((parentIndex + 1 != index) && (numRecord > 1)) { + dataPtr.data_sort(start, numRecord, index); } + + int num0 = dataPtr.data_findSplit(start, numRecord, index); + int num1 = numRecord - num0; + + int mostCommonValue = ((num0 >= num1) ? 0 : 1); + varyPtr.mostCommonValue = mostCommonValue; + + if (num0 == 0 || mostCommonValue == 0) { + } else { + varyPtr.zeroNodePtr = makeNode(index, index, start, num0, dataPtr); + varyPtr.zeroNodePtr.value = 0; + } + + if (num1 == 0 || mostCommonValue == 1) { + } else { + varyPtr.oneNodePtr = makeNode(index, index, (start + num0), num1, dataPtr); + varyPtr.oneNodePtr.value = 1; + } + + return varyPtr; + } /* ============================================================================= * makeNode * ============================================================================= */ - public AdtreeNode - makeNode (int parentIndex, - int index, - int start, - int numRecord, - Data dataPtr) - { - AdtreeNode nodePtr = AdtreeNode.allocNode(index); - - nodePtr.count = numRecord; - - Vector_t varyVectorPtr = nodePtr.varyVectorPtr; - - int numVar = dataPtr.numVar; - for (int v = (index + 1); v < numVar; v++) { - AdtreeVary varyPtr = - makeVary(parentIndex, v, start, numRecord, dataPtr); - boolean status; - if((status = varyVectorPtr.vector_pushBack(varyPtr)) != true) { - System.out.println("Assert failed: varyVectorPtr.vector_pushBack != true"); - System.exit(0); - } - } - - return nodePtr; + public AdtreeNode makeNode (int parentIndex, int index, int start, int numRecord, Data dataPtr) { + int numVar = dataPtr.numVar; + AdtreeNode nodePtr = new AdtreeNode(index, numVar-index-1); + nodePtr.count = numRecord; + + AdtreeVary varyVectorPtr[] = nodePtr.varyVectorPtr; + int i=0; + + for (int v = (index + 1); v < numVar; v++) { + AdtreeVary varyPtr = makeVary(parentIndex, v, start, numRecord, dataPtr); + varyVectorPtr[i++]=varyPtr; } + + return nodePtr; + } /* ============================================================================= @@ -239,14 +153,12 @@ public class Adtree { * -- Records in dataPtr will get rearranged * ============================================================================= */ - public void - adtree_make (Data dataPtr) - { - numVar = dataPtr.numVar; - numRecord = dataPtr.numRecord; - dataPtr.data_sort(0, numRecord, 0); - rootNodePtr = makeNode(-1, -1, 0, numRecord, dataPtr); - } + public void adtree_make (Data dataPtr) { + numVar = dataPtr.numVar; + numRecord = dataPtr.numRecord; + dataPtr.data_sort(0, numRecord, 0); + rootNodePtr = makeNode(-1, -1, 0, numRecord, dataPtr); + } /* ============================================================================= @@ -282,8 +194,7 @@ public class Adtree { System.exit(0); } - Vector_t varyVectorPtr = nodePtr.varyVectorPtr; - AdtreeVary varyPtr = (AdtreeVary)(varyVectorPtr.vector_at((queryIndex - nodeIndex - 1))); + AdtreeVary varyPtr = nodePtr.varyVectorPtr[queryIndex - nodeIndex - 1]; int queryValue = queryPtr.value; @@ -296,18 +207,16 @@ public class Adtree { * query with the current toggled (invertCount). */ int numQuery = queryVectorPtr.vector_getSize(); - Vector_t superQueryVectorPtr = Vector_t.vector_alloc(numQuery - 1); + Vector_t superQueryVectorPtr = new Vector_t(numQuery - 1); for (int qq = 0; qq < numQuery; qq++) { if (qq != q) { - boolean status = superQueryVectorPtr.vector_pushBack( - queryVectorPtr.vector_at(qq)); + boolean status = superQueryVectorPtr.vector_pushBack(queryVectorPtr.vector_at(qq)); } } int superCount = adtree_getCount(superQueryVectorPtr); - - superQueryVectorPtr.vector_free(); + superQueryVectorPtr.clear(); int invertCount; if (queryValue == 0) { diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeNode.java b/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeNode.java index e3322077..e84dedfc 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeNode.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeNode.java @@ -9,7 +9,7 @@ public class AdtreeNode { int index; int value; int count; - Vector_t varyVectorPtr; + AdtreeVary varyVectorPtr[]; public AdtreeNode() { @@ -19,22 +19,10 @@ public class AdtreeNode { * allocNode * ============================================================================= */ - public static AdtreeNode - allocNode (int index) - { - AdtreeNode nodePtr = new AdtreeNode(); - - if (nodePtr != null) { - nodePtr.varyVectorPtr = Vector_t.vector_alloc(1); - if (nodePtr.varyVectorPtr == null) { - nodePtr = null; - return null; - } - nodePtr.index = index; - nodePtr.value = -1; - nodePtr.count = -1; - } - - return nodePtr; - } + public AdtreeNode(int index, int vecsize) { + this.varyVectorPtr = new AdtreeVary[vecsize]; + this.index = index; + this.value = -1; + this.count = -1; + } } diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeVary.java b/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeVary.java index e7c24925..1edd4354 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeVary.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/AdtreeVary.java @@ -13,26 +13,19 @@ public class AdtreeVary { AdtreeNode oneNodePtr; public AdtreeVary() { - } /* ============================================================================= * allocVary * ============================================================================= */ - public AdtreeVary - allocVary (int index) - { - AdtreeVary varyPtr= new AdtreeVary(); - - if (varyPtr != null) { - varyPtr.index = index; - varyPtr.mostCommonValue = -1; - varyPtr.zeroNodePtr = null; - varyPtr.oneNodePtr = null; - } - - return varyPtr; - } + public AdtreeVary(int index) { + this.index = index; + mostCommonValue = -1; + } + public void free_vary() { + zeroNodePtr=null; + oneNodePtr=null; + } } diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Bayes.java b/Robust/src/Benchmarks/SingleTM/Bayes/Bayes.java index 89663d3f..08597cae 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/Bayes.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Bayes.java @@ -199,28 +199,27 @@ public class Bayes extends Thread { * score * ============================================================================= */ - public float - score (Net netPtr, Adtree adtreePtr) - { - /* - * Create dummy data structures to conform to learner_score assumptions - */ - - Data dataPtr = Data.data_alloc(1, 1, null); - - Learner learnerPtr = Learner.learner_alloc(dataPtr, adtreePtr, 1, global_insertPenalty, global_maxNumEdgeLearned, global_operationQualityFactor); - - Net tmpNetPtr = learnerPtr.netPtr; - learnerPtr.netPtr = netPtr; + public float score (Net netPtr, Adtree adtreePtr) { + /* + * Create dummy data structures to conform to learner_score assumptions + */ + + Data dataPtr = new Data(1, 1, null); + + Learner learnerPtr = new Learner(dataPtr, adtreePtr, 1, global_insertPenalty, global_maxNumEdgeLearned, global_operationQualityFactor); + + Net tmpNetPtr = learnerPtr.netPtr; + learnerPtr.netPtr = netPtr; + + float score = learnerPtr.learner_score(); + learnerPtr.netPtr = tmpNetPtr; + learnerPtr.learner_free(); + dataPtr.data_free(); - float score = learnerPtr.learner_score(); - learnerPtr.netPtr = tmpNetPtr; - learnerPtr.learner_free(); - dataPtr.data_free(); - return score; - } + return score; + } /** @@ -282,7 +281,7 @@ public class Bayes extends Thread { randomPtr.random_alloc(); randomPtr.random_seed(randomSeed); - Data dataPtr = Data.data_alloc(numVar, numRecord, randomPtr); + Data dataPtr = new Data(numVar, numRecord, randomPtr); Net netPtr = dataPtr.data_generate(-1, maxNumParent, percentParent); System.out.println("done."); @@ -291,11 +290,12 @@ public class Bayes extends Thread { * Generate adtree */ - Adtree adtreePtr = Adtree.adtree_alloc(); + Adtree adtreePtr = new Adtree(); System.out.print("Generating adtree... "); adtreePtr.adtree_make(dataPtr); + dataPtr.data_free(); System.out.println("done."); @@ -310,9 +310,7 @@ public class Bayes extends Thread { * Learn structure of Bayesian network */ - Learner learnerPtr = Learner.learner_alloc(dataPtr, adtreePtr, numThread, b.global_insertPenalty, b.global_maxNumEdgeLearned, b.global_operationQualityFactor); - - dataPtr.data_free(); /* save memory */ + Learner learnerPtr = new Learner(dataPtr, adtreePtr, numThread, b.global_insertPenalty, b.global_maxNumEdgeLearned, b.global_operationQualityFactor); System.out.print("Learning structure..."); @@ -359,14 +357,6 @@ public class Bayes extends Thread { /* * Clean up */ - -#ifndef SIMULATOR - adtreePtr.adtree_free(); -# if 0 - learnerPtr.learner_free(); -# endif -#endif - } } /* ============================================================================= diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Data.java b/Robust/src/Benchmarks/SingleTM/Bayes/Data.java index 7a9b3a97..a376db25 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/Data.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Data.java @@ -60,42 +60,29 @@ public class Data { int numRecord; byte[] records; /* coordination of all records */ Random randomPtr; - - public Data() { - } + Sort sort; /* ============================================================================= * data_alloc * ============================================================================= */ - public static Data data_alloc (int numVar, int numRecord, Random randomPtr) + public Data(int numVar, int numRecord, Random randomPtr) { - Data dataPtr = new Data(); - - if (dataPtr != null) { - int numDatum = numVar * numRecord; - dataPtr.records = new byte[numDatum]; - for(int i = 0; i 0; i++, j++, n--) swap(i, j, a); @@ -138,7 +138,7 @@ public class QuickSort { * -- For vector_sort * =========================================== */ - public boolean less(Object x, Object y) { + public static boolean less(Object x, Object y) { Query aQueryPtr = (Query) x; Query bQueryPtr = (Query) y; if(aQueryPtr.index < bQueryPtr.index) @@ -146,7 +146,7 @@ public class QuickSort { return false; } - public int diff(Object x, Object y) { + public static int diff(Object x, Object y) { Query aQueryPtr = (Query) x; Query bQueryPtr = (Query) y; return (aQueryPtr.index - bQueryPtr.index); diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Random.java b/Robust/src/Benchmarks/SingleTM/Bayes/Random.java index 2c601f48..1862c3b4 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/Random.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Random.java @@ -1,23 +1,13 @@ public class Random { long[] mt; int mti; - long RANDOM_DEFAULT_SEED; + int RANDOM_DEFAULT_SEED; /* period parameter */ - int N; - int M; - long MATRIX_A; - long UPPER_MASK; - long LOWER_MASK; + public Random() { - RANDOM_DEFAULT_SEED = 0L; - N = 624; - M = 397; - mt = new long[N]; - mti = N; - MATRIX_A = 0x9908b0dfL; /* constant vector a */ - UPPER_MASK = 0x80000000L; /* most significant w-r bits */ - LOWER_MASK = 0x7fffffffL; /* least significant r bits */ + RANDOM_DEFAULT_SEED = 0; + mt = new long[624]; } public void random_alloc() { @@ -25,11 +15,10 @@ public class Random { } /* initializes mt[N] with a seed */ - public void init_genrand(long s) { - int mti; - mt[0]= s & 0xFFFFFFFFL; - for (mti=1; mti> 30)) + mti); + public void init_genrand(int s) { + mt[0]= ((long)s) & 0xFFFFFFFFL; + for (int mti=1; mti<624; mti++) { + mt[mti] = (1812433253L * (mt[mti-1] ^ (mt[mti-1] >> 30)) + ((long)mti)); /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */ /* In the previous versions, MSBs of the seed affect */ /* only MSBs of the array mt[]. */ @@ -37,43 +26,48 @@ public class Random { mt[mti] &= 0xFFFFFFFFL; /* for >32 bit machines */ } - this.mti=mti; + this.mti=624; } - public void random_seed(long seed) { + public void random_seed(int seed) { init_genrand(seed); } public long random_generate() { - return genrand_int32(); + long x= genrand_int32()&0xFFFFFFFFL; + return x; + } + + public long posrandom_generate() { + long r=genrand_int32(); + if (r>0) + return r; + else + return -r; } - //public static long genrand_int32(long[] mt, long mtiPtr) { public long genrand_int32() { long y; - long[] mag01= new long[2]; - mag01[0] = 0x0L; - mag01[1] = MATRIX_A; int mti = this.mti; + long[] mt = this.mt; - /* mag01[x] = x * MATRIX_A for x=0,1 */ - - if (mti >= N) { /* generate N words at one time */ + if (mti >= 624) { /* generate N words at one time */ int kk; - if (mti == N+1) /* if init_genrand() has not been called, */ - init_genrand(5489L); /* a default initial seed is used */ - - for (kk=0;kk> 1) ^ mag01[(int)(y & 0x1L)]; + if (mti == 624+1) { /* if init_genrand() has not been called, */ + init_genrand(5489); /* a default initial seed is used */ + mti=this.mti; + } + for (kk=0;kk<(624-397);kk++) { + y = (mt[kk]&0x80000000L)|(mt[kk+1]&0x7fffffffL); + mt[kk] = mt[kk+397] ^ (y >> 1) ^ ((y & 0x1)==0 ? 0L:0x9908b0dfL); } - for (;kk> 1) ^ mag01[(int)(y & 0x1L)]; + for (;kk<(624-1);kk++) { + y = (mt[kk]&0x80000000L)|(mt[kk+1]&0x7fffffffL); + mt[kk] = mt[kk+(397-624)] ^ (y >> 1) ^ ((y & 0x1)==0 ? 0L:0x9908b0dfL); } - y = (mt[N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK); - mt[N-1] = mt[M-1] ^ (y >> 1) ^ mag01[(int)(y & 0x1L)]; + y = (mt[624-1]&0x80000000L)|(mt[0]&0x7fffffffL); + mt[624-1] = mt[397-1] ^ (y >> 1) ^ ((y & 0x1)==0 ? 0L:0x9908b0dfL); mti = 0; } diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Sort.java b/Robust/src/Benchmarks/SingleTM/Bayes/Sort.java index 572859de..6708a0e8 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/Sort.java +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Sort.java @@ -84,26 +84,28 @@ #define CUTOFF 8 public class Sort { + int[] lostk; + int[] histk; - public Sort() { + public Sort() { + lostk= new int[30]; + histk= new int[30]; } /* ============================================================================= * swap * ============================================================================= */ - public static void - swap (byte[] base, int a, int b, int width) - { - if (a != b ) { - while (width--) { - byte tmp = base[a]; - base[a++] = base[b]; - base[b++] = tmp; - } + public static void swap (byte[] base, int a, int b, int width) { + if (a != b ) { + while(width--) { + byte tmp = base[a]; + base[a++] = base[b]; + base[b++] = tmp; } } + } /* ============================================================================= @@ -134,106 +136,104 @@ public class Sort { * sort * ============================================================================= */ - public static void - sort (byte[] base, - int start, - int num, - int width, - int n, - int offset) - { - if (num < 2 || width == 0) { - return; - } - - /** - * Pointers that keep track of - * where to start looking in - * the base array - **/ - int[] lostk= new int[30]; - int[] histk= new int[30]; - - int stkptr = 0; - - int lo = start; - int hi = start + (width * (num - 1)); - - int size = 0; - - int pvlo = lo; - int pvhi = hi; - int pvwidth = width; - int pvn = n; - int pvmid; - int pvloguy; - int pvhiguy; - int typeflag; - - while(true) { - - size = (pvhi - pvlo) / pvwidth + 1; - - if (size <= CUTOFF) { - - shortsort(base, pvlo, pvhi, pvwidth, pvn, offset); - - } else { - - pvmid = pvlo + (size / 2) * pvwidth; - swap(base, pvmid, pvlo, pvwidth); - - pvloguy = pvlo; - pvhiguy = pvhi + pvwidth; - - while(true) { - do { - pvloguy += pvwidth; - } while (pvloguy <= pvhi && cmp(base, pvloguy, pvlo, pvn, offset) <= 0); - do { - pvhiguy -= pvwidth; - } while (pvhiguy > pvlo && cmp(base, pvhiguy, pvlo, pvn, offset) >= 0); - if (pvhiguy < pvloguy) { - break; - } - swap(base, pvloguy, pvhiguy, pvwidth); - } - - swap(base, pvlo, pvhiguy, pvwidth); - - if ((pvhiguy - 1 - pvlo) >= (pvhi - pvloguy)) { - if (pvlo + pvwidth < pvhiguy) { - lostk[stkptr] = pvlo; - histk[stkptr] = pvhiguy - pvwidth; - ++stkptr; - } - - if (pvloguy < pvhi) { - pvlo = pvloguy; - continue; - } - } else { - if (pvloguy < pvhi) { - lostk[stkptr] = pvloguy; - histk[stkptr] = pvhi; - ++stkptr; - } - if (pvlo + pvwidth < pvhiguy) { - pvhi = pvhiguy - pvwidth; - continue; + public void sort (byte[] base, + int start, + int num, + int width, + int n, + int offset) { + if (num < 2 || width == 0) { + return; + } + + /** + * Pointers that keep track of + * where to start looking in + * the base array + **/ + int[] lostk=this.lostk; + int[] histk=this.histk; + + int stkptr = 0; + + int lo = start; + int hi = start + (width * (num - 1)); + + int size = 0; + + int pvlo = lo; + int pvhi = hi; + int pvwidth = width; + int pvn = n; + int pvmid; + int pvloguy; + int pvhiguy; + int typeflag; + + while(true) { + + size = (pvhi - pvlo) / pvwidth + 1; + + if (size <= CUTOFF) { + + shortsort(base, pvlo, pvhi, pvwidth, pvn, offset); + + } else { + + pvmid = pvlo + (size / 2) * pvwidth; + swap(base, pvmid, pvlo, pvwidth); + + pvloguy = pvlo; + pvhiguy = pvhi + pvwidth; + + while(true) { + do { + pvloguy += pvwidth; + } while (pvloguy <= pvhi && cmp(base, pvloguy, pvlo, pvn, offset) <= 0); + do { + pvhiguy -= pvwidth; + } while (pvhiguy > pvlo && cmp(base, pvhiguy, pvlo, pvn, offset) >= 0); + if (pvhiguy < pvloguy) { + break; + } + swap(base, pvloguy, pvhiguy, pvwidth); + } + + swap(base, pvlo, pvhiguy, pvwidth); + + if ((pvhiguy - 1 - pvlo) >= (pvhi - pvloguy)) { + if (pvlo + pvwidth < pvhiguy) { + lostk[stkptr] = pvlo; + histk[stkptr] = pvhiguy - pvwidth; + ++stkptr; + } + + if (pvloguy < pvhi) { + pvlo = pvloguy; + continue; + } + } else { + if (pvloguy < pvhi) { + lostk[stkptr] = pvloguy; + histk[stkptr] = pvhi; + ++stkptr; + } + if (pvlo + pvwidth < pvhiguy) { + pvhi = pvhiguy - pvwidth; + continue; } - } - } - - --stkptr; - if (stkptr >= 0) { - pvlo = lostk[stkptr]; - pvhi = histk[stkptr]; - continue; - } - break; + } } + + --stkptr; + if (stkptr >= 0) { + pvlo = lostk[stkptr]; + pvhi = histk[stkptr]; + continue; + } + break; } + } /* ============================================================================= * compareRecord diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/Vector_t.java b/Robust/src/Benchmarks/SingleTM/Bayes/Vector_t.java new file mode 100644 index 00000000..b134600f --- /dev/null +++ b/Robust/src/Benchmarks/SingleTM/Bayes/Vector_t.java @@ -0,0 +1,141 @@ +public class Vector_t { + int size; + int capacity; + Object[] elements; + + public Vector_t() { + } + + /* ============================================================================= + * Vector_alloc + * -- Returns null if failed + * ============================================================================= + */ + public Vector_t(int initCapacity) { + int capacity = Math.imax(initCapacity, 1); + this.size = 0; + this.capacity = capacity; + this.elements = new Object[capacity]; + } + + /* ============================================================================= + * Vector_free + * ============================================================================= + */ + public void clear() { + elements = null; + } + + /* ============================================================================= + * Vector_at + * -- Returns null if failed + * ============================================================================= + */ + public Object vector_at (int i) { + if ((i < 0) || (i >= size)) { + System.out.println("Illegal Vector.element\n"); + return null; + } + return (elements[i]); + } + + + /* ============================================================================= + * Vector_pushBack + * -- Returns false if fail, else true + * ============================================================================= + */ + public boolean vector_pushBack (Object dataPtr) { + if (size == capacity) { + int newCapacity = capacity * 2; + Object[] newElements = new Object[newCapacity]; + + if (newElements == null) { + return false; + } + capacity = newCapacity; + for (int i = 0; i < size; i++) { + newElements[i] = elements[i]; + } + elements = null; + elements = newElements; + } + + elements[size++] = dataPtr; + + return true; + } + + /* ============================================================================= + * Vector_popBack + * -- Returns null if fail, else returns last element + * ============================================================================= + */ + public Object vector_popBack () { + if (size < 1) { + return null; + } + Object o=elements[--(size)]; + elements[size]=null; + return o; + } + + /* ============================================================================= + * Vector_getSize + * ============================================================================= + */ + public int + vector_getSize () + { + return (size); + } + + /* ============================================================================= + * Vector_clear + * ============================================================================= + */ + public void vector_clear () { + while(size>0) + elements[--size]=null; + } + + /* ============================================================================= + * Vector_sort + * ============================================================================= + */ + public void + vector_sort () + { + QuickSort.sort(elements, 0, size); + } + + /* ============================================================================= + * Vector_copy + * ============================================================================= + */ + public static boolean + vector_copy (Vector_t dstVectorPtr, Vector_t srcVectorPtr) + { + int dstCapacity = dstVectorPtr.capacity; + int srcSize = srcVectorPtr.size; + if (dstCapacity < srcSize) { + int srcCapacity = srcVectorPtr.capacity; + Object[] elements = new Object[srcCapacity]; + + if (elements == null) { + return false; + } + dstVectorPtr.elements = null; + dstVectorPtr.elements = elements; + dstVectorPtr.capacity = srcCapacity; + } + + for(int i = 0; i< srcSize; i++) { + dstVectorPtr.elements[i] = srcVectorPtr.elements[i]; + } + + dstVectorPtr.size = srcSize; + + return true; + } +} diff --git a/Robust/src/Benchmarks/SingleTM/Bayes/makefile b/Robust/src/Benchmarks/SingleTM/Bayes/makefile index 18b57d0d..e8b9d50d 100644 --- a/Robust/src/Benchmarks/SingleTM/Bayes/makefile +++ b/Robust/src/Benchmarks/SingleTM/Bayes/makefile @@ -16,7 +16,7 @@ SRC=tmp${MAINCLASS}.java \ IntListNode.java \ tmpQueue.java \ Random.java \ - ../common/Vector_t.java \ + Vector_t.java \ ListNode.java \ tmpList.java \ QuickSort.java \ @@ -24,9 +24,11 @@ SRC=tmp${MAINCLASS}.java \ ../../../ClassLibrary/JavaSTM/Barrier.java \ ../common/LocalStartStop.java -FLAGS=-mainclass ${MAINCLASS} -singleTM -optimize -debug -dcopts -stmstats -fastmemcpy -transstats -abcclose +include ../common/Makefile.flags -default: +include ../common/Makefile.builds + +prep: cpp Bayes.java > tmp1Bayes.java cpp Data.java > tmp1Data.java cpp Net.java > tmp1Net.java @@ -37,7 +39,6 @@ default: cpp -DLIST_NO_DUPLICATES IntList.java > tmp1IntList.java cpp -DLIST_NO_DUPLICATES List.java > tmp1List.java ./extractLines - ../../../buildscript ${FLAGS} -o ${MAINCLASS} ${SRC} clean: rm tmp1Bayes.java -- 2.34.1