diff options
33 files changed, 1274 insertions, 15 deletions
diff --git a/BenchmarkFramework/Readme.txt b/BenchmarkFramework/Readme.txt index 2692db0..c8e4d70 100644 --- a/BenchmarkFramework/Readme.txt +++ b/BenchmarkFramework/Readme.txt @@ -5,7 +5,7 @@ This file includes a little info about "benchmarkframework" application. 1) The main target of the application is to run different benchmark tests integrated inside the app and written on (JAVA/C/C++) -2) There are 33 tests integrated for now: +2) There are 46 tests integrated for now: - "MemSpeed" // This benchmark is integrated as *so library and will be remove if not needed. Source code: http://www.roylongbottom.org.uk/android%20benchmarks.htm#anchor17 @@ -52,20 +52,45 @@ This file includes a little info about "benchmarkframework" application. - "TeapotES(GPU)" //Source code: https://openbenchmarking.org/ -- "Tiotester" (Tiotester (Threaded I/O Tester) benchmarks the hard disk drive / file-system performance.) -- "Himeno" (The Himeno benchmark is a linear solver of pressure Poisson using a point-Jacobi method). (Processor Test) -- "Stream" Stream:(This benchmark tests the system memory (RAM) performance.) -- "FS-Mark" (FS_Mark is designed to test a system's file-system performance.) -- "Bork" (Bork is a small, cross-platform file encryption utility. It is written in Java and designed to be included along with the files it encrypts for long-term +- "Tiotester" (Disk) (Tiotester (Threaded I/O Tester) benchmarks the hard disk drive / file-system performance.) +- "Himeno" (Processor) (The Himeno benchmark is a linear solver of pressure Poisson using a point-Jacobi method). (Processor Test) +- "Stream" (Memory) Stream:(This benchmark tests the system memory (RAM) performance.) +- "FS-Mark" (Disk) (FS_Mark is designed to test a system's file-system performance.) +- "Bork" (Processor) (Bork is a small, cross-platform file encryption utility. It is written in Java and designed to be included along with the files it encrypts for long-term storage. This test measures the amount of time it takes to encrypt a sample file.) -- "SciMark" (This test runs the Java version of SciMark 2.0, which is a benchmark for scientific and numerical computing developed by programmers at the +- "SciMark" (Processor) (This test runs the Java version of SciMark 2.0, which is a benchmark for scientific and numerical computing developed by programmers at the National Institute of Standards and Technology. This benchmark is made up of Fast Foruier Transform, Jacobi Successive Over-relaxation, Monte Carlo, Sparse Matrix Multiply, and dense LU matrix factorization benchmarks.) -- "Smallpt" (Smallpt is a C++ global illumination renderer written in less than 100 lines of code. Global illumination is done via unbiased Monte Carlo path tracing +- "Smallpt" (Processor) (Smallpt is a C++ global illumination renderer written in less than 100 lines of code. Global illumination is done via unbiased Monte Carlo path tracing and there is multi-threading support via the OpenMP library.) -- "Tscp" (This is a performance test of TSCP, Tom Kerrigan's Simple Chess Program, which has a built-in performance benchmark.) +- "Tscp" (Processor) (This is a performance test of TSCP, Tom Kerrigan's Simple Chess Program, which has a built-in performance benchmark.) +- "Hint" (System) (Hierarchical INTegration: This test runs the U.S. Department of Energy's Ames Laboratory Hierarchical INTegration (HINT) benchmark.) +- "Fhourstones" (Processor) (This integer benchmark solves positions in the game of connect-4, as played on a vertical 7x6 board. By default, it uses a 64Mb transposition table with + the twobig replacement strategy. Positions are represented as 64-bit bitboards, and the hash function is computed using a single 64-bit modulo operation, + giving 64-bit machines a slight edge. The alpha-beta searcher sorts moves dynamically based on the history heuristic.) +- "Monte-Carlo" (CPU) Function for running Monte Carlo on the CPU +- "Bonds" (CPU) Contains main function for running manual CUDA and CPU bonds application +- "Repo" (CPU) Engine for running the repo (repurchase agreement) on the CPU +- "N-Queens" (Processor)(This is a test of the OpenMP version of a test that solves the N-queens problem. The board problem size is 17.) + + +- "Sysbench" (CPU, file IO, MySQL) //Source code: https://android-git.linaro.org/gitweb/platform/external/sysbench.git/tree/refs/heads/linaro_android + +- "BinaryTrees" //Source code: https://android-git.linaro.org/gitweb/platform/external/gperftools.git/blob/HEAD:/benchmark +- "MallocBench" //Source code: https://android-git.linaro.org/gitweb/platform/external/gperftools.git/blob/HEAD:/benchmark + +- "StressBench" //Source code: https://android-git.linaro.org/gitweb/platform/external/stressapptest.git + +- "TuXBencH" ("TuXRuleZ' OC benchmark": It's useful for testing the improvement when OC'ing ) //Source code: https://sourceforge.net/projects/tuxbench/?source=directory + +- "Later" (memory latency benchmark(Portable benchmarking tool to measure so called idle main memory access latency. IOW this tiny thing tests how long it takes for your processor + (CPU) to get the data not being cached in CPU\'s caches.) + //Source code: https://sourceforge.net/projects/later/?source=directory + +- "LinPack" (The LINPACK benchmark is a test problem used to rate the performance of a computer on a simple linear algebra problem.) + //Source code: https://people.sc.fsu.edu/~jburkardt/cpp_src/linpack_bench/linpack_bench.html 3)Functionality: diff --git a/BenchmarkFramework/app/src/main/assets/TuXBencH b/BenchmarkFramework/app/src/main/assets/TuXBencH Binary files differnew file mode 100755 index 0000000..681ef01 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/TuXBencH diff --git a/BenchmarkFramework/app/src/main/assets/bonds b/BenchmarkFramework/app/src/main/assets/bonds Binary files differnew file mode 100755 index 0000000..097e039 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/bonds diff --git a/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_binarytrees b/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_binarytrees Binary files differnew file mode 100755 index 0000000..e45f9d8 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_binarytrees diff --git a/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_malloc b/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_malloc Binary files differnew file mode 100755 index 0000000..8c867c7 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/gperftools_benchmark_malloc diff --git a/BenchmarkFramework/app/src/main/assets/hint b/BenchmarkFramework/app/src/main/assets/hint Binary files differnew file mode 100755 index 0000000..54d650b --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/hint diff --git a/BenchmarkFramework/app/src/main/assets/later b/BenchmarkFramework/app/src/main/assets/later Binary files differnew file mode 100755 index 0000000..e776565 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/later diff --git a/BenchmarkFramework/app/src/main/assets/linpack_bench_d b/BenchmarkFramework/app/src/main/assets/linpack_bench_d Binary files differnew file mode 100755 index 0000000..f4cb49d --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/linpack_bench_d diff --git a/BenchmarkFramework/app/src/main/assets/montecarlocpu b/BenchmarkFramework/app/src/main/assets/montecarlocpu Binary files differnew file mode 100755 index 0000000..ada49ee --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/montecarlocpu diff --git a/BenchmarkFramework/app/src/main/assets/qn24b_base b/BenchmarkFramework/app/src/main/assets/qn24b_base Binary files differnew file mode 100755 index 0000000..d922098 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/qn24b_base diff --git a/BenchmarkFramework/app/src/main/assets/repoo b/BenchmarkFramework/app/src/main/assets/repoo Binary files differnew file mode 100755 index 0000000..0c7d301 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/repoo diff --git a/BenchmarkFramework/app/src/main/assets/stressapptest b/BenchmarkFramework/app/src/main/assets/stressapptest Binary files differnew file mode 100755 index 0000000..33b1211 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/stressapptest diff --git a/BenchmarkFramework/app/src/main/assets/sysbench b/BenchmarkFramework/app/src/main/assets/sysbench Binary files differnew file mode 100755 index 0000000..1bbfae2 --- /dev/null +++ b/BenchmarkFramework/app/src/main/assets/sysbench diff --git a/BenchmarkFramework/app/src/main/java/fhourstones/Game.java b/BenchmarkFramework/app/src/main/java/fhourstones/Game.java new file mode 100644 index 0000000..79c7106 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/fhourstones/Game.java @@ -0,0 +1,142 @@ +// Fhourstones 3.1 Board Logic +// (http://www.cwi.nl/~tromp/c4/fhour.html) +// +// implementation of the well-known game +// usually played on a vertical board of 7 columns by 6 rows, +// where 2 players take turns in dropping counters in a column. +// the first player to get four of his counters +// in a horizontal, vertical or diagonal row, wins the game. +// if neither player has won after 42 moves, then the game is drawn. +// +// This software is copyright (c) 1996-2005 by +// John Tromp +// Insulindeweg 908 +// 1095 DX Amsterdam +// Netherlands +// E-mail: tromp@cwi.nl +// +// This notice must not be removed. +// This software must not be sold for profit. +// You may redistribute if your distributees have the +// same rights and restrictions. + +package fhourstones; + +public class Game { + static long color[]; // black and white bitboard + public static final int WIDTH = 7; + public static final int HEIGHT = 6; +// bitmask corresponds to board as follows in 7x6 case: +// . . . . . . . TOP +// 5 12 19 26 33 40 47 +// 4 11 18 25 32 39 46 +// 3 10 17 24 31 38 45 +// 2 9 16 23 30 37 44 +// 1 8 15 22 29 36 43 +// 0 7 14 21 28 35 42 BOTTOM + static final int H1 = HEIGHT+1; + static final int H2 = HEIGHT+2; + static final int SIZE = HEIGHT*WIDTH; + static final int SIZE1 = H1*WIDTH; + static final long ALL1 = (1L<<SIZE1)-1L; // assumes SIZE1 < 63 + static final int COL1 = (1<<H1)-1; + static final long BOTTOM = ALL1 / COL1; // has bits i*H1 set + static final long TOP = BOTTOM << HEIGHT; + + public int moves[],nplies; + byte height[]; // holds bit index of lowest free square + + public Game() + { + color = new long[2]; + height = new byte[WIDTH]; + moves = new int[SIZE]; + reset(); + } + + public void reset() + { + nplies = 0; + color[0] = color[1] = 0L; + for (int i=0; i<WIDTH; i++) + height[i] = (byte)(H1*i); + } + + public long positioncode() + { + return color[nplies&1] + color[0] + color[1] + BOTTOM; +// color[0] + color[1] + BOTTOM forms bitmap of heights +// so that positioncode() is a complete board encoding + } + + public String toString() + { + StringBuffer buf = new StringBuffer(); + + for (int i=0; i<nplies; i++) + buf.append(1+moves[i]); + if (true) return buf.toString(); // remove to get board + info printed + buf.append("\n"); + for (int w=0; w<WIDTH; w++) + buf.append(" "+(w+1)); + buf.append("\n"); + for (int h=HEIGHT-1; h>=0; h--) { + for (int w=h; w<SIZE1; w+=H1) { + long mask = 1L<<w; + buf.append((color[0]&mask)!= 0 ? " @" : + (color[1]&mask)!= 0 ? " 0" : " ."); + } + buf.append("\n"); + } + if (haswon(color[0])) + buf.append("@ won\n"); + if (haswon(color[1])) + buf.append("O won\n"); + return buf.toString(); + } + + // return whether columns col has room + final boolean isplayable(int col) + { + return islegal(color[nplies&1] | (1L << height[col])); + } + + // return whether newboard lacks overflowing column + final boolean islegal(long newboard) + { + return (newboard & TOP) == 0; + } + + // return whether newboard is legal and includes a win + final boolean islegalhaswon(long newboard) + { + return islegal(newboard) && haswon(newboard); + } + + // return whether newboard includes a win + final boolean haswon(long newboard) + { + long diag1 = newboard & (newboard>>HEIGHT); // check diagonal \ + long hori = newboard & (newboard>>H1); // check horizontal - + long diag2 = newboard & (newboard>>H2); // check diagonal / + long vert = newboard & (newboard>>1); // check vertical | + return ((diag1 & (diag1 >> 2*HEIGHT)) | + (hori & (hori >> 2*H1)) | + (diag2 & (diag2 >> 2*H2)) | + (vert & (vert >> 2))) != 0; + } + + void backmove() + { + int n; + + n = moves[--nplies]; + color[nplies&1] ^= 1L<<--height[n]; + } + + public void makemove(int n) + { + color[nplies&1] ^= 1L<<height[n]++; + moves[nplies++] = n; + } +} diff --git a/BenchmarkFramework/app/src/main/java/fhourstones/SearchGame.java b/BenchmarkFramework/app/src/main/java/fhourstones/SearchGame.java new file mode 100644 index 0000000..03d6ebf --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/fhourstones/SearchGame.java @@ -0,0 +1,186 @@ +// This software is copyright (c) 1996-2005 by +// John Tromp +// Insulindeweg 908 +// 1095 DX Amsterdam +// Netherlands +// E-mail: tromp@cwi.nl +// +// This notice must not be removed. +// This software must not be sold for profit. +// You may redistribute if your distributees have the +// same rights and restrictions. + +package fhourstones; + +import java.io.*; +import java.text.DecimalFormat; + +public class SearchGame extends TransGame { + static final int BOOKPLY = 0; // full-width search up to this depth + static final int REPORTPLY = 2; + static int reportply = 2; + int history[][] = new int[2][SIZE1]; + public long nodes, msecs; + + void inithistory() + { + for (int side=0; side<2; side++) + for (int i=0; i<(WIDTH+1)/2; i++) + for (int h=0; h<H1/2; h++) + history[side][H1*i+h] = history[side][H1*(WIDTH-1-i)+HEIGHT-1-h] = + history[side][H1*i+HEIGHT-1-h] = history[side][H1*(WIDTH-1-i)+h] = + 4+Math.min(3,i) + Math.max(-1,Math.min(3,h)-Math.max(3-i,0)) + + Math.min(3,Math.min(i,h)) + Math.min(3,h); + } + + int ab(int alpha, int beta) + { + nodes++; + if (nplies == SIZE-1) // one move left + return DRAW; // by assumption, player to move can't win + int side, otherside; + otherside = (side = nplies & 1) ^ 1; + long other = color[otherside]; + int i,nav,av[] = new int[WIDTH]; + long newbrd; + boolean winontop; + for (i = nav = 0; i < WIDTH; i++) { + newbrd = other | (1L << height[i]); // check opponent move + if (!islegal(newbrd)) + continue; + winontop = islegalhaswon(other | (2L << height[i])); + if (haswon(newbrd)) { // immediate threat + if (winontop) // can't stop double threat + return LOSS; + nav = 0; // forced move + av[nav++] = i; + while (++i < WIDTH) + if (islegalhaswon(other | (1L << height[i]))) + return LOSS; + break; + } + if (!winontop) + av[nav++] = i; + } + if (nav == 0) + return LOSS; + if (nplies == SIZE-2) // two moves left + return DRAW; // opponent has no win either + int score; + if (nav == 1) { + makemove(av[0]); + score = LOSSWIN-ab(LOSSWIN-beta,LOSSWIN-alpha); + backmove(); + return score; + } + int ttscore = transpose(); + if (ttscore != UNKNOWN) { + if (ttscore == DRAWLOSS) { + if ((beta = DRAW) <= alpha) + return ttscore; + } else if (ttscore == DRAWWIN) { + if ((alpha = DRAW) >= beta) + return ttscore; + } else return ttscore; // exact score + } + int hashindx = htindex; + int hashlock = lock; + long poscnt = posed; + int besti=0,j,l,sc; + int v,val; + score = LOSS; + for (i = 0; i < nav; i++) { + val = history[side][height[av[l = i]]]; + for (j = i+1; j < nav; j++) { + v = history[side][height[av[j]]]; + if (v > val) { + val = v; l = j; + } + } + for (j = av[l]; l>i; l--) + av[l] = av[l-1]; + makemove(av[i] = j); + sc = LOSSWIN-ab(LOSSWIN-beta,LOSSWIN-alpha); + backmove(); + if (sc > score) { + besti = i; + if ((score=sc) > alpha && nplies >= BOOKPLY && (alpha=sc) >= beta) { + if (score == DRAW && i < nav-1) + score = DRAWWIN; + if (besti > 0) { + for (i = 0; i < besti; i++) + history[side][height[av[i]]]--; // punish worse + history[side][height[av[besti]]] += besti; + } + break; + } + } + } + if (score == LOSSWIN-ttscore) // combine < and > + score = DRAW; + poscnt = posed - poscnt; + int work; + for (work=0; (poscnt>>=1) != 0; work++) ; // work=log #positions stored + transtore(hashindx, hashlock, score, work); + if (nplies <= reportply) { + System.out.println(toString() + "#-<=>+".charAt(score) + work); + } + return score; + } + + public int solve() + { + int i, side = nplies & 1, otherside = side ^ 1; + reportply = nplies + REPORTPLY; + nodes = 0L; + msecs = 1L; + if (haswon(color[otherside])) + return LOSS; + for (i = 0; i < WIDTH; i++) + if (islegalhaswon(color[side] | (1L << height[i]))) + return WIN; + inithistory(); + msecs = System.currentTimeMillis(); + int score = ab(LOSS, WIN); + msecs = System.currentTimeMillis() + 1 - msecs; // prevent division by 0 + return score; + } + + public static void main(String argv[]) + { + System.out.println("Fhourstones 3.1 (Java)"); + System.out.println("Boardsize = " + WIDTH + "x" + HEIGHT); + System.out.println("Using " + TRANSIZE + " transposition table entries."); + SearchGame c4 = new SearchGame(); + BufferedReader dis = new BufferedReader(new InputStreamReader(System.in)); + DecimalFormat df = new DecimalFormat("######.###"); + + for (;;) { + String line=null; + try { + line = dis.readLine(); + } catch (IOException e) { + System.out.println(e); + System.exit(0); + } + if (line == null) + break; + c4.reset(); + for (int i=0; i < line.length(); i++) + c4.makemove(line.charAt(i) - '1'); + System.out.println("\nSolving " + c4.nplies + "-ply position after " + + c4.toString() + " . . ."); + + c4.emptyTT(); + int result = c4.solve(); + long poscnt = c4.posed; + int work; + for (work=0; (poscnt>>=1) != 0; work++) ; //work = log #transpositions + System.out.println("score = " + result + " (" + + "#-<=>+".charAt(result) + ") work = " + work); + System.out.println("" + c4.nodes + " pos / " + c4.msecs + + " msec = " + df.format((double)c4.nodes/c4.msecs) + " Kpos/sec"); + System.out.println(c4.htstat()); + } + } +} diff --git a/BenchmarkFramework/app/src/main/java/fhourstones/TransGame.java b/BenchmarkFramework/app/src/main/java/fhourstones/TransGame.java new file mode 100644 index 0000000..43ed062 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/fhourstones/TransGame.java @@ -0,0 +1,126 @@ +// This software is copyright (c) 1996-2005 by +// John Tromp +// Insulindeweg 908 +// 1095 DX Amsterdam +// Netherlands +// E-mail: tromp@cwi.nl +// +// This notice must not be removed. +// This software must not be sold for profit. +// You may redistribute if your distributees have the +// same rights and restrictions. + + +package fhourstones; + +import java.text.DecimalFormat; + +public class TransGame extends Game { + static final int LOCKSIZE = 26; + static final int SCORELOCKSIZE = 3+LOCKSIZE; + public static final int TRANSIZE = 8306069; + // should be a prime no less than about 2^{SIZE1-LOCKSIZE} + static final int SYMMREC = 10; // symmetry normalize first SYMMREC moves + static final int UNKNOWN = 0; + static final int LOSS = 1; + static final int DRAWLOSS = 2; + static final int DRAW = 3; + static final int DRAWWIN = 4; + static final int WIN = 5; + static final int LOSSWIN = LOSS+WIN; + + static final int SCORELOCKMASK = (1<<SCORELOCKSIZE)-1; + static final int LOCKMASK = (1<<LOCKSIZE)-1; + protected int ht[]; // hash entries + protected int htindex, lock; + + public long posed; // counts transtore calls + + public TransGame() + { + super(); + ht = new int[2*TRANSIZE]; + } + + public void emptyTT() + { + int i, h, work; + + for (i=0; i<2*TRANSIZE; i++) + ht[i] = 0; + posed = 0L; + } + + void hash() + { + long htemp = positioncode(); + if (nplies < SYMMREC) { // try symmetry recognition by reversing columns + long htemp2 = 0L; + for (long htmp=htemp; htmp!=0; htmp>>=H1) + htemp2 = htemp2<<H1 | (htmp & COL1); + if (htemp2 < htemp) + htemp = htemp2; + } + lock = (int)(htemp >> (SIZE1-26)); + htindex = 2*(int)(htemp % TRANSIZE); + } + + int transpose() + { + hash(); + int he0 = ht[htindex]; + int he1 = ht[htindex+1]; + if ((he0 & LOCKMASK) == lock) // biglock + return he1 >>> SCORELOCKSIZE; // bigscore + if ((he1 & LOCKMASK) == lock) // newlock + return (he1 >> LOCKSIZE) & 7; // newscore + return UNKNOWN; + } + + void transtore(int x, int lock, int score, int work) + { + posed++; + int he0 = ht[x]; + int he1 = ht[x+1]; + int biglock = he0 & LOCKMASK; + if (biglock == lock || work >= (he0 >>> LOCKSIZE)) { + ht[x] = (work << LOCKSIZE) | lock; + ht[x+1] = (score << SCORELOCKSIZE) | (he1 & SCORELOCKMASK); + } else { + ht[x+1] = ((he1 >>> SCORELOCKSIZE) << 3 | score) << LOCKSIZE | lock; + } + } + + public String htstat() /* some statistics on hash table performance */ + { + int total, i; + StringBuffer buf = new StringBuffer(); + int typecnt[]; // bound type stats + DecimalFormat df = new DecimalFormat("######.###"); + + typecnt = new int[8]; + for (i=0; i<8; i++) + typecnt[i] = 0; + for (i=0; i<2*TRANSIZE; i+=2) { + int he0 = ht[i]; + int he1 = ht[i+1]; + int biglock = he0 & LOCKMASK; + int bigscore = he1 >>> SCORELOCKSIZE; + int newlock = he1 & LOCKMASK; + int newscore = (he1 >> LOCKSIZE) & 7; + if (biglock != 0) + typecnt[bigscore]++; + if (newlock != 0) + typecnt[newscore]++; + } + for (total=0,i=LOSS; i<=WIN; i++) + total += typecnt[i]; + if (total > 0) + buf.append("- "+df.format(typecnt[LOSS]/(double)total) + + " < "+df.format(typecnt[DRAWLOSS]/(double)total) + + " = "+df.format(typecnt[DRAW]/(double)total) + + " > " + df.format(typecnt[DRAWWIN]/(double)total) + + " + " + df.format(typecnt[WIN]/(double)total)); + return buf.toString(); + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/BaseBenchmark.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/BaseBenchmark.java index d51b618..01bc436 100644 --- a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/BaseBenchmark.java +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/BaseBenchmark.java @@ -59,9 +59,12 @@ public class BaseBenchmark { "iozone -E -C 70 -L -S -W", "bonnie -d temp -s 400 -r 200 -u "+ MainActivity.APP_UID, "himenobmtxpa L", - "fs_mark -d temp -s 51200 -n 4096" + "fs_mark -d temp -s 51200 -n 4096", // "smallpt 24" - + "qn24b_base 17", //max N=29 + "sysbench --test=cpu --cpu-max-prime=5000 run", + "stressapptest -s 20 -M 256 -m 8 -C 8 -W", + "later 4" //usage: later <blocksize in KB> [<speedup factor> [<minimal stride>]] ); diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Chart.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Chart.java index 0ab9ab5..66ad311 100644 --- a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Chart.java +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Chart.java @@ -68,7 +68,20 @@ public class Chart extends AppCompatActivity { "Bork", "SciMark", "Smallpt", - "Tscp"}; + "Tscp", + "Hint", + "Fhourstones", + "Monte-Carlo", + "Bonds", + "Repo", + "N-queens", + "SysBench", + "BinaryTrees", + "MallocBench", + "StressBench", + "TuXBencH", + "Later", + "LinPack"}; @Override diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java index 1c3bc9d..6164513 100644 --- a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/MainActivity.java @@ -174,7 +174,20 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe "Test30", "Test31", "Test32", - "Test33"}; + "Test33", + "Test34", + "Test35", + "Test36", + "Test37", + "Test38", + "Test39", + "Test40", + "Test41", + "Test42", + "Test43", + "Test44", + "Test45", + "Test46"}; //********************************************************************************************** @Override @@ -295,7 +308,20 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe "Bork", "SciMark", "Smallpt", - "Tscp"}; + "Tscp", + "Hint", + "Fhourstones", + "Monte-Carlo", + "Bonds", + "Repo", + "N-queens", + "SysBench", + "BinaryTrees", + "MallocBench", + "StressBench", + "TuXBencH", + "Later", + "LinPack"}; //*******************GridView******************* @@ -1423,7 +1449,7 @@ public class MainActivity extends AppCompatActivity implements View.OnClickListe String testNumber = selectedClassTest.replace("Test", ""); - if(!(Integer.parseInt(testNumber) >=16 && Integer.parseInt(testNumber) <=25)) { + if(!(Integer.parseInt(testNumber) >=16 && Integer.parseInt(testNumber) <=25)) { //Dont show progress dialog for test with own PD progressDialog.show(); } diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test34.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test34.java new file mode 100644 index 0000000..f853da1 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test34.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test34 extends BaseBenchmark{ + + private String TAG = "Hint"; + + public String startBenchmark(int count) + { + version = " Hint"; + benchmarkName = "Test34"; + executable_name = "hint"; + integrationType = "EX"; + chartName = "Hint"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test35.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test35.java new file mode 100644 index 0000000..e7f7d06 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test35.java @@ -0,0 +1,134 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.PrintStream; +import java.nio.charset.StandardCharsets; +import java.text.DecimalFormat; + + +import fhourstones.Game; +import fhourstones.SearchGame; +import fhourstones.TransGame; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test35 extends BaseBenchmark{ + + private String TAG = "Fhourstones"; + static boolean isJavaCanceled = false; + + public String startBenchmark(int count) { + + isJavaCanceled = false; + + version = " Fhourstones "; + benchmarkName = "Test35"; + integrationType = "SL"; + chartName = "Fhourstones"; + + long before; + long after; + + + clear(); + + //****Redirect System.out and Syste.err**** + PrintStream stdOut = System.out; + PrintStream stdErrt = System.err; + + PrintStream interceptor_stdout = new Interceptor(stdOut); + PrintStream interceptor_err = new Interceptor(stdErrt); + System.setOut(interceptor_stdout);// just add the interceptor + System.setErr(interceptor_err);// just add the interceptor + //****Redirect System.out and Syste.err**** + + startTest = System.currentTimeMillis(); + + + if(isJavaCanceled) return ""; + //***********SearchGame************* + + before = System.currentTimeMillis(); + + + System.out.println("Fhourstones 3.1 (Java)"); + System.out.println("Boardsize = " + Game.WIDTH + "x" + Game.HEIGHT); + System.out.println("Using " + TransGame.TRANSIZE + " transposition table entries."); + SearchGame c4 = new SearchGame(); + + + String inputs = "45461667\n" + + "35333571\n" + + "13333111"; + + InputStream istream = new ByteArrayInputStream(inputs.getBytes()); + + + BufferedReader dis = new BufferedReader(new InputStreamReader(istream/*System.in*/)); + DecimalFormat df = new DecimalFormat("######.###"); + + for (;;) { + String line=null; + try { + line = dis.readLine(); + } catch (IOException e) { + System.out.println(e); + //System.exit(0); + } + if (line == null) + break; + c4.reset(); + for (int i=0; i < line.length(); i++) + c4.makemove(line.charAt(i) - '1'); + System.out.println("\nSolving " + c4.nplies + "-ply position after " + + c4.toString() + " . . ."); + + c4.emptyTT(); + int result = c4.solve(); + long poscnt = c4.posed; + int work; + for (work=0; (poscnt>>=1) != 0; work++) ; //work = log #transpositions + System.out.println("score = " + result + " (" + + "#-<=>+".charAt(result) + ") work = " + work); + System.out.println("" + c4.nodes + " pos / " + c4.msecs + + " msec = " + df.format((double)c4.nodes/c4.msecs) + " Kpos/sec"); + System.out.println(c4.htstat()); + } + + + after = System.currentTimeMillis(); + + System.out.println("fhourstones/SearchGame: " + (after - before)); + //***********AccessNBody************* + + + + + + xout[2] = Interceptor.outputTxt; + Interceptor.clear(); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + isJavaCanceled = true; + Log.i(TAG, "stopBenchmark: isJNICanceled"); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test36.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test36.java new file mode 100644 index 0000000..f98c1c0 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test36.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test36 extends BaseBenchmark{ + + private String TAG = "Monte-Carlo"; + + public String startBenchmark(int count) + { + version = " Monte-Carlo"; + benchmarkName = "Test36"; + executable_name = "montecarlocpu"; + integrationType = "EX"; + chartName = "Monte-Carlo"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test37.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test37.java new file mode 100644 index 0000000..ecd1942 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test37.java @@ -0,0 +1,49 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test37 extends BaseBenchmark{ + + private String TAG = "Bonds"; + + public String startBenchmark(int count) + { + version = " Bonds"; + benchmarkName = "Test37"; + executable_name = "bonds"; + integrationType = "EX"; + chartName = "Bonds"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} + diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test38.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test38.java new file mode 100644 index 0000000..fb9fca3 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test38.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test38 extends BaseBenchmark{ + + private String TAG = "Repo"; + + public String startBenchmark(int count) + { + version = " Repo"; + benchmarkName = "Test38"; + executable_name = "repoo"; + integrationType = "EX"; + chartName = "Repo"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test39.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test39.java new file mode 100644 index 0000000..20a6b32 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test39.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/24/16. + */ +public class Test39 extends BaseBenchmark{ + + private String TAG = "N-queens"; + + public String startBenchmark(int count) + { + version = " N-queens"; + benchmarkName = "Test39"; + executable_name = "qn24b_base"; + integrationType = "EX"; + chartName = "N-queens"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test40.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test40.java new file mode 100644 index 0000000..732ea9b --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test40.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/25/16. + */ +public class Test40 extends BaseBenchmark{ + + private String TAG = "SysBench"; + + public String startBenchmark(int count) + { + version = " SysBench"; + benchmarkName = "Test40"; + executable_name = "sysbench"; + integrationType = "EX"; + chartName = "SysBench"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test41.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test41.java new file mode 100644 index 0000000..2bac3a0 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test41.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/25/16. + */ +public class Test41 extends BaseBenchmark{ + + private String TAG = "BinaryTrees"; + + public String startBenchmark(int count) + { + version = " BinaryTrees"; + benchmarkName = "Test41"; + executable_name = "gperftools_benchmark_binarytrees"; + integrationType = "EX"; + chartName = "BinaryTrees"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test42.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test42.java new file mode 100644 index 0000000..c8118b2 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test42.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/25/16. + */ +public class Test42 extends BaseBenchmark{ + + private String TAG = "MallocBench"; + + public String startBenchmark(int count) + { + version = " MallocBench"; + benchmarkName = "Test42"; + executable_name = "gperftools_benchmark_malloc"; + integrationType = "EX"; + chartName = "MallocBench"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test43.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test43.java new file mode 100644 index 0000000..26a3e3f --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test43.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/25/16. + */ +public class Test43 extends BaseBenchmark{ + + private String TAG = "StressBench"; + + public String startBenchmark(int count) + { + version = " StressBench"; + benchmarkName = "Test43"; + executable_name = "stressapptest"; + integrationType = "EX"; + chartName = "StressBench"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test44.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test44.java new file mode 100644 index 0000000..b60a4a3 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test44.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/26/16. + */ +public class Test44 extends BaseBenchmark{ + + private String TAG = "TuXBencH"; + + public String startBenchmark(int count) + { + version = " TuXBencH"; + benchmarkName = "Test44"; + executable_name = "TuXBencH"; + integrationType = "EX"; + chartName = "TuXBencH"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test45.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test45.java new file mode 100644 index 0000000..18a3081 --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test45.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/27/16. + */ +public class Test45 extends BaseBenchmark{ + + private String TAG = "Later"; + + public String startBenchmark(int count) + { + version = " Later"; + benchmarkName = "Test45"; + executable_name = "later"; + integrationType = "EX"; + chartName = "Later"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test46.java b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test46.java new file mode 100644 index 0000000..d3ce3af --- /dev/null +++ b/BenchmarkFramework/app/src/main/java/org/linaro/iasenov/benchmarkframework/Test46.java @@ -0,0 +1,48 @@ +package org.linaro.iasenov.benchmarkframework; + +import android.util.Log; + +/** + * Created by iasenov on 10/27/16. + */ +public class Test46 extends BaseBenchmark{ + + private String TAG = "LinPack"; + + public String startBenchmark(int count) + { + version = " LinPack"; + benchmarkName = "Test46"; + executable_name = "linpack_bench_d"; + integrationType = "EX"; + chartName = "LinPack"; + + + + clear(); + + startTest = System.currentTimeMillis(); + + String param = ""; + + TESTCOMMANDS = getCommands(executable_name, benchmarkName); + + xout[2] = copyAssetsExecFileAndRun(executable_name, TESTCOMMANDS); + + endTest = System.currentTimeMillis(); + + sendElapsedTimeToChart(); + + submitElapsedTime(endTest-startTest); + + + + return benchmarkName + ":" + getBenchmarkResult(5, integrationType); + } + + public boolean stopBenchmark(){ + process_exec.destroy(); + Log.i(TAG, "Destroy Process:" + process_exec.toString()); + return true; + } +} diff --git a/BenchmarkFramework/shellscript/runTestsFromShell.sh b/BenchmarkFramework/shellscript/runTestsFromShell.sh index 1c3b45a..0e64a41 100755 --- a/BenchmarkFramework/shellscript/runTestsFromShell.sh +++ b/BenchmarkFramework/shellscript/runTestsFromShell.sh @@ -37,6 +37,20 @@ # Test31 = "SciMark" # Test32 = "Smallpt" # Test33 = "Tscp" +# Test34 = "Hint" +# Test35 = "Fhourstones" +# Test36 = "Monte-Carlo" +# Test37 = "Bonds" +# Test38 = "Repo" +# Test39 = "N-queens" +# Test40 = "Sysbench" +# Test41 = "BinaryTrees" +# Test42 = "MallocBench" +# Test43 = "StressBench" +# Test44 = "TuXBencH" +# Test45 = "Later" +# Test46 = "LinPack" + adb devices @@ -170,6 +184,19 @@ echo "Test30 = Bork" echo "Test31 = SciMark" echo "Test32 = Smallpt" echo "Test33 = Tscp" +echo "Test34 = Hint" +echo "Test35 = Fhourstones" +echo "Test36 = Monte-Carlo" +echo "Test37 = Bonds" +echo "Test38 = Repo" +echo "Test39 = N-queens" +echo "Test40 = Sysbench" +echo "Test41 = BinaryTrees" +echo "Test42 = MallocBench" +echo "Test43 = StressBench" +echo "Test44 = TuXBencH" +echo "Test45 = Later" +echo "Test46 = LinPack" echo "" |