From: adash <adash>
Date: Fri, 18 Apr 2008 00:16:43 +0000 (+0000)
Subject: Add java version of Crypt benchmark
X-Git-Tag: preEdgeChange~144
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=a5558559291ef1fada78df87473775c5be5dae4c;p=IRC.git

Add java version of Crypt benchmark
---

diff --git a/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBench.java b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBench.java
new file mode 100644
index 00000000..f40598fd
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBench.java
@@ -0,0 +1,389 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+/**************************************************************************
+ *                       Ported for DSTM Benchmark                         *
+ **************************************************************************/
+import java.util.*;
+
+public class JGFCryptBench { 
+
+  private int size; 
+  private int datasizes[];
+  public int nthreads;
+  int array_rows; 
+
+  byte [] plain1;       // Buffer for plaintext data.
+  byte [] crypt1;       // Buffer for encrypted data.
+  byte [] plain2;       // Buffer for decrypted data.
+
+  short [] userkey;     // Key for encryption/decryption.
+  int [] Z;             // Encryption subkey (userkey derived).
+  int [] DK;            // Decryption subkey (userkey derived).
+
+
+  //
+  // buildTestData
+  //Builds the data used for the test -- each time the test is run.
+  void buildTestData()
+  {
+
+
+    // Create three byte arrays that will be used (and reused) for
+    // encryption/decryption operations.
+
+
+    plain1 = new byte [array_rows];
+    crypt1 = new byte [array_rows];
+    plain2 = new byte [array_rows];
+
+
+    Random rndnum = new Random(136506717L);  // Create random number generator.
+
+
+    // Allocate three arrays to hold keys: userkey is the 128-bit key.
+    // Z is the set of 16-bit encryption subkeys derived from userkey,
+    // while DK is the set of 16-bit decryption subkeys also derived
+    // from userkey. NOTE: The 16-bit values are stored here in
+    // 32-bit int arrays so that the values may be used in calculations
+    // as if they are unsigned. Each 64-bit block of plaintext goes
+    // through eight processing rounds involving six of the subkeys
+    // then a final output transform with four of the keys; (8 * 6)
+    // + 4 = 52 subkeys.
+
+    userkey = new short [8];  // User key has 8 16-bit shorts.
+    Z = new int [52];         // Encryption subkey (user key derived).
+    DK = new int [52];        // Decryption subkey (user key derived).
+
+    // Generate user key randomly; eight 16-bit values in an array.
+
+    for (int i = 0; i < 8; i++)
+    {
+      // Again, the random number function returns int. Converting
+      // to a short type preserves the bit pattern in the lower 16
+      // bits of the int and discards the rest.
+
+      userkey[i] = (short) rndnum.nextInt();
+    }
+
+    // Compute encryption and decryption subkeys.
+
+    calcEncryptKey();
+    calcDecryptKey();
+
+    // Fill plain1 with "text."
+    for (int i = 0; i < array_rows; i++)
+    {
+      plain1[i] = (byte) i; 
+
+      // Converting to a byte
+      // type preserves the bit pattern in the lower 8 bits of the
+      // int and discards the rest.
+    }
+  }
+
+
+  // calcEncryptKey
+
+  // Builds the 52 16-bit encryption subkeys Z[] from the user key and
+  //stores in 32-bit int array. The routing corrects an error in the
+  //source code in the Schnier book. Basically, the sense of the 7-
+  //and 9-bit shifts are reversed. It still works reversed, but would
+  //encrypted code would not decrypt with someone else's IDEA code.
+  //
+
+  private void calcEncryptKey()
+  {
+    int j;                       // Utility variable.
+
+    for (int i = 0; i < 52; i++) // Zero out the 52-int Z array.
+      Z[i] = 0;
+
+    for (int i = 0; i < 8; i++)  // First 8 subkeys are userkey itself.
+    {
+      Z[i] = userkey[i] & 0xffff;     // Convert "unsigned"
+      // short to int.
+    }
+
+    // Each set of 8 subkeys thereafter is derived from left rotating
+    // the whole 128-bit key 25 bits to left (once between each set of
+    // eight keys and then before the last four). Instead of actually
+    // rotating the whole key, this routine just grabs the 16 bits
+    // that are 25 bits to the right of the corresponding subkey
+    // eight positions below the current subkey. That 16-bit extent
+    // straddles two array members, so bits are shifted left in one
+    // member and right (with zero fill) in the other. For the last
+    // two subkeys in any group of eight, those 16 bits start to
+    // wrap around to the first two members of the previous eight.
+
+    for (int i = 8; i < 52; i++)
+    {
+      int flag1 = 0;
+      j = i % 8;
+      if (j < 6)
+      {
+        Z[i] = ((Z[i -7]>>>9) | (Z[i-6]<<7)) // Shift and combine.
+          & 0xFFFF;                    // Just 16 bits.
+        //continue;                            // Next iteration.
+        flag1 = 1;
+      }
+
+      if(flag1 == 0) {
+        int flag2 = 0;
+
+        if (j == 6)    // Wrap to beginning for second chunk.
+        {
+          Z[i] = ((Z[i -7]>>>9) | (Z[i-14]<<7))
+            & 0xFFFF;
+          //continue;
+          flag2 = 1;
+        }
+
+        if(flag2 == 0) {
+          // j == 7 so wrap to beginning for both chunks.
+          Z[i] = ((Z[i -15]>>>9) | (Z[i-14]<<7))
+            & 0xFFFF;
+        }
+      }
+    }
+  }
+
+  //
+  //calcDecryptKey
+  //
+  //Builds the 52 16-bit encryption subkeys DK[] from the encryption-
+  //subkeys Z[]. DK[] is a 32-bit int array holding 16-bit values as
+  //unsigned.
+  //
+
+  private void calcDecryptKey()
+  {
+    int j, k;                 // Index counters.
+    int t1, t2, t3;           // Temps to hold decrypt subkeys.
+
+    t1 = inv(Z[0]);           // Multiplicative inverse (mod x10001).
+    t2 = - Z[1] & 0xffff;     // Additive inverse, 2nd encrypt subkey.
+    t3 = - Z[2] & 0xffff;     // Additive inverse, 3rd encrypt subkey.
+
+    DK[51] = inv(Z[3]);       // Multiplicative inverse (mod x10001).
+    DK[50] = t3;
+    DK[49] = t2;
+    DK[48] = t1;
+
+    j = 47;                   // Indices into temp and encrypt arrays.
+    k = 4;
+    for (int i = 0; i < 7; i++)
+    {
+      t1 = Z[k++];
+      DK[j--] = Z[k++];
+      DK[j--] = t1;
+      t1 = inv(Z[k++]);
+      t2 = -Z[k++] & 0xffff;
+      t3 = -Z[k++] & 0xffff;
+      DK[j--] = inv(Z[k++]);
+      DK[j--] = t2;
+      DK[j--] = t3;
+      DK[j--] = t1;
+    }
+
+    t1 = Z[k++];
+    DK[j--] = Z[k++];
+    DK[j--] = t1;
+    t1 = inv(Z[k++]);
+    t2 = -Z[k++] & 0xffff;
+    t3 = -Z[k++] & 0xffff;
+    DK[j--] = inv(Z[k++]);
+    DK[j--] = t3;
+    DK[j--] = t2;
+    DK[j--] = t1;
+  }
+
+
+  //
+  //mul
+  //
+  // Performs multiplication, modulo (2**16)+1. This code is structured
+  // on the assumption that untaken branches are cheaper than taken
+  // branches, and that the compiler doesn't schedule branches.
+  // Java: Must work with 32-bit int and one 64-bit long to keep
+  // 16-bit values and their products "unsigned." The routine assumes
+  // that both a and b could fit in 16 bits even though they come in
+  // as 32-bit ints. Lots of "& 0xFFFF" masks here to keep things 16-bit.
+  // Also, because the routine stores mod (2**16)+1 results in a 2**16
+  // space, the result is truncated to zero whenever the result would
+  // zero, be 2**16. And if one of the multiplicands is 0, the result
+  // is not zero, but (2**16) + 1 minus the other multiplicand (sort
+  // of an additive inverse mod 0x10001).
+
+  // NOTE: The java conversion of this routine works correctly, but
+  // is half the speed of using Java's modulus division function (%)
+  // on the multiplication with a 16-bit masking of the result--running
+  // in the Symantec Caje IDE. So it's not called for now; the test
+  // uses Java % instead.
+  //
+
+  private int mul(int a, int b)
+  {
+    int ret;
+    long p;             // Large enough to catch 16-bit multiply
+    // without hitting sign bit.
+    if (a != 0)
+    {
+      if(b != 0)
+      {
+        p = (long) a * b;
+        b = (int) p & 0xFFFF;       // Lower 16 bits.
+        a = (int) p >>> 16;         // Upper 16 bits.
+        if (b < a)
+          return (b - a + 1) & 0xFFFF;
+        else
+          return (b - a) & 0xFFFF;
+      }
+      else
+        return ((1 - a) & 0xFFFF);  // If b = 0, then same as
+      // 0x10001 - a.
+    }
+    else                                // If a = 0, then return
+      return((1 - b) & 0xFFFF);       // same as 0x10001 - b.
+  }
+
+  //
+  // inv
+  //
+  // Compute multiplicative inverse of x, modulo (2**16)+1 using
+  // extended Euclid's GCD (greatest common divisor) algorithm.
+  // It is unrolled twice to avoid swapping the meaning of
+  // the registers. And some subtracts are changed to adds.
+  // Java: Though it uses signed 32-bit ints, the interpretation
+  // of the bits within is strictly unsigned 16-bit.
+  //
+
+  private int inv(int x)
+  {
+    int t0, t1;
+    int q, y;
+
+    if (x <= 1)             // Assumes positive x.
+      return(x);          // 0 and 1 are self-inverse.
+
+    t1 = 0x10001 / x;       // (2**16+1)/x; x is >= 2, so fits 16 bits.
+    y = 0x10001 % x;
+    if (y == 1)
+      return((1 - t1) & 0xFFFF);
+
+    t0 = 1;
+    do {
+      q = x / y;
+      x = x % y;
+      t0 += q * t1;
+      if (x == 1) return(t0);
+      q = y / x;
+      y = y % x;
+      t1 += q * t0;
+    } while (y != 1);
+
+    return((1 - t1) & 0xFFFF);
+  }
+
+  //
+  // freeTestData
+  //
+  // Nulls arrays and forces garbage collection to free up memory.
+  //
+
+  void freeTestData(int array_rows)
+  {
+    for(int i = 0; i<array_rows; i++) {
+      plain1[i] = (byte) 0;
+      crypt1[i] = (byte) 0;
+      plain2[i] = (byte) 0;
+    }
+
+    for(int i = 0; i<8; i++) {
+      userkey[i] = (short) 0;
+    }
+
+    for(int i = 0; i<52; i++) {
+      Z[i] = 0;
+      DK[i] = 0;
+    }
+
+    //System.gc();                // Force garbage collection.
+  }
+
+
+  public JGFCryptBench(int nthreads)
+  {
+    this.nthreads=nthreads;
+    datasizes = new int[3];
+    datasizes[0] = 3000000;
+    datasizes[1] = 20000000;
+    datasizes[2] = 50000000;
+  }
+
+
+  public void JGFsetsize(int size){
+    this.size = size;
+  }
+
+  public void JGFinitialise(){
+    array_rows = datasizes[size];
+    buildTestData();
+  }
+
+  /*
+  public void JGFkernel(){
+    Do(); 
+  }
+  */
+
+  public void JGFvalidate(){
+    boolean error;
+
+    error = false; 
+    for (int i = 0; i < array_rows; i++){
+      error = (plain1 [i] != plain2 [i]); 
+      if (error){
+        System.out.println("Validation failed");
+        System.out.println("Original Byte " + i + " = " + plain1[i]); 
+        System.out.println("Encrypted Byte " + i + " = " + crypt1[i]); 
+        System.out.println("Decrypted Byte " + i + " = " + plain2[i]); 
+        break;
+      }
+    }
+  }
+
+
+  public void JGFtidyup(){
+    freeTestData(array_rows); 
+  }  
+
+  /*
+  public void JGFrun(int size){
+    instr.addTimer("Section2:Crypt:Kernel", "Kbyte",size);
+    JGFsetsize(size); 
+    JGFinitialise(); 
+    JGFkernel(); 
+    JGFvalidate(); 
+    JGFtidyup(); 
+    instr.addOpsToTimer("Section2:Crypt:Kernel", (2*array_rows)/1000.); 
+    instr.printTimer("Section2:Crypt:Kernel"); 
+  }
+  */
+}
diff --git a/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBenchSizeA.java b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBenchSizeA.java
new file mode 100644
index 00000000..692f6b7b
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFCryptBenchSizeA.java
@@ -0,0 +1,248 @@
+public class JGFCryptBenchSizeA extends Thread{
+  JGFCryptBench cb;
+  int id,key[];
+  byte text1[],text2[];
+
+  public JGFCryptBenchSizeA(JGFCryptBench cb, int id, byte [] text1, byte [] text2, int [] key) {
+    this.cb = cb;
+    this.id = id;
+    this.text1=text1;
+    this.text2=text2;
+    this.key=key;
+  }
+
+  // run()
+  // 
+  // IDEA encryption/decryption algorithm. It processes plaintext in
+  // 64-bit blocks, one at a time, breaking the block into four 16-bit
+  // unsigned subblocks. It goes through eight rounds of processing
+  // using 6 new subkeys each time, plus four for last step. The source
+  // text is in array text1, the destination text goes into array text2
+  // The routine represents 16-bit subblocks and subkeys as type int so
+  // that they can be treated more easily as unsigned. Multiplication
+  // modulo 0x10001 interprets a zero sub-block as 0x10000; it must to
+  // fit in 16 bits.
+  //
+
+  public void run() {
+    int ilow, iupper, slice, tslice, ttslice;  
+
+    tslice = text1.length / 8;     
+    ttslice = (tslice + cb.nthreads-1) / cb.nthreads;
+    slice = ttslice*8;
+
+    ilow = id*slice;
+    iupper = (id+1)*slice;
+    if(iupper > text1.length) iupper = text1.length;
+
+    int i1 = ilow;                 // Index into first text array.
+    int i2 = ilow;                 // Index into second text array.
+    int ik;                     // Index into key array.
+    int x1, x2, x3, x4, t1, t2; // Four "16-bit" blocks, two temps.
+    int r;                      // Eight rounds of processing.
+
+    for (int i =ilow ; i <iupper ; i +=8)
+    {
+
+      ik = 0;                 // Restart key index.
+      r = 8;                  // Eight rounds of processing.
+
+      // Load eight plain1 bytes as four 16-bit "unsigned" integers.
+      // Masking with 0xff prevents sign extension with cast to int.
+
+      x1 = text1[i1++] & 0xff;          // Build 16-bit x1 from 2 bytes,
+      x1 |= (text1[i1++] & 0xff) << 8;  // assuming low-order byte first.
+      x2 = text1[i1++] & 0xff;
+      x2 |= (text1[i1++] & 0xff) << 8;
+      x3 = text1[i1++] & 0xff;
+      x3 |= (text1[i1++] & 0xff) << 8;
+      x4 = text1[i1++] & 0xff;
+      x4 |= (text1[i1++] & 0xff) << 8;
+
+      do {
+        // 1) Multiply (modulo 0x10001), 1st text sub-block
+        // with 1st key sub-block.
+
+        x1 = (int) ((long) x1 * key[ik++] % 0x10001L & 0xffff);
+        // 2) Add (modulo 0x10000), 2nd text sub-block
+        // with 2nd key sub-block.
+
+        x2 = x2 + key[ik++] & 0xffff;
+
+        // 3) Add (modulo 0x10000), 3rd text sub-block
+        // with 3rd key sub-block.
+
+        x3 = x3 + key[ik++] & 0xffff;
+
+        // 4) Multiply (modulo 0x10001), 4th text sub-block
+        // with 4th key sub-block.
+
+        x4 = (int) ((long) x4 * key[ik++] % 0x10001L & 0xffff);
+
+        // 5) XOR results from steps 1 and 3.
+
+        t2 = x1 ^ x3;
+
+        // 6) XOR results from steps 2 and 4.
+        // Included in step 8.
+
+        // 7) Multiply (modulo 0x10001), result of step 5
+        // with 5th key sub-block.
+
+        t2 = (int) ((long) t2 * key[ik++] % 0x10001L & 0xffff);
+
+        // 8) Add (modulo 0x10000), results of steps 6 and 7.
+
+        t1 = t2 + (x2 ^ x4) & 0xffff;
+
+        // 9) Multiply (modulo 0x10001), result of step 8
+        // with 6th key sub-block.
+
+        t1 = (int) ((long) t1 * key[ik++] % 0x10001L & 0xffff);
+
+        // 10) Add (modulo 0x10000), results of steps 7 and 9.
+
+        t2 = t1 + t2 & 0xffff;
+
+        // 11) XOR results from steps 1 and 9.
+
+        x1 ^= t1;
+
+        // 14) XOR results from steps 4 and 10. (Out of order).
+
+        x4 ^= t2;
+
+        // 13) XOR results from steps 2 and 10. (Out of order).
+
+        t2 ^= x2;
+
+        // 12) XOR results from steps 3 and 9. (Out of order).
+
+        x2 = x3 ^ t1;
+
+        x3 = t2;        // Results of x2 and x3 now swapped.
+
+      } while(--r != 0);  // Repeats seven more rounds.
+
+      // Final output transform (4 steps).
+
+      // 1) Multiply (modulo 0x10001), 1st text-block
+      // with 1st key sub-block.
+
+      x1 = (int) ((long) x1 * key[ik++] % 0x10001L & 0xffff);
+
+      // 2) Add (modulo 0x10000), 2nd text sub-block
+      // with 2nd key sub-block. It says x3, but that is to undo swap
+      // of subblocks 2 and 3 in 8th processing round.
+
+      x3 = x3 + key[ik++] & 0xffff;
+
+      // 3) Add (modulo 0x10000), 3rd text sub-block
+      // with 3rd key sub-block. It says x2, but that is to undo swap
+      // of subblocks 2 and 3 in 8th processing round.
+
+      x2 = x2 + key[ik++] & 0xffff;
+
+      // 4) Multiply (modulo 0x10001), 4th text-block
+      // with 4th key sub-block.
+
+      x4 = (int) ((long) x4 * key[ik++] % 0x10001L & 0xffff);
+
+      // Repackage from 16-bit sub-blocks to 8-bit byte array text2.
+
+      text2[i2++] = (byte) x1;
+      text2[i2++] = (byte) (x1 >>> 8);
+      text2[i2++] = (byte) x3;                // x3 and x2 are switched
+      text2[i2++] = (byte) (x3 >>> 8);        // only in name.
+      text2[i2++] = (byte) x2;
+      text2[i2++] = (byte) (x2 >>> 8);
+      text2[i2++] = (byte) x4;
+      text2[i2++] = (byte) (x4 >>> 8);
+
+    }   // End for loop.
+
+  }   // End routine.
+
+  public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.out.println("The no of threads has not been specified, defaulting to 1");
+      System.out.println("  ");
+      nthreads = 1;
+    }
+
+    /* Instruments output messages */
+    JGFInstrumentor instr = new JGFInstrumentor();
+    instr.printHeader(2,0,nthreads);
+
+    JGFCryptBench cb;
+    int size = 0;
+    instr.addTimer("Section2:Crypt:Kernel", "Kbyte",size);
+    cb = new JGFCryptBench(nthreads);
+    cb.JGFsetsize(size);
+    cb.JGFinitialise();
+
+    /* Start computation */
+    JGFCryptBenchSizeA[] th;
+    th = new JGFCryptBenchSizeA [nthreads];
+
+    // Start the stopwatch.       
+    instr.startTimer("Section2:Crypt:Kernel");        
+
+    // Encrypt plain1.
+    JGFCryptBenchSizeA tmp;
+    for(int i=1;i<nthreads;i++) {
+      th[i] = new JGFCryptBenchSizeA(cb, i, cb.plain1, cb.crypt1, cb.Z);
+      tmp = th[i];
+      tmp.start();
+    }
+
+    th[0] = new JGFCryptBenchSizeA(cb, 0, cb.plain1, cb.crypt1, cb.Z);
+    tmp = th[0];
+    tmp.start();
+
+
+    for(int i=1;i<nthreads;i++) {
+      tmp = th[i];
+      try {
+        tmp.join();
+      }  catch (InterruptedException e) {}
+    }
+
+    // Decrypt.
+    for(int i=1;i<nthreads;i++) {
+      th[i] = new JGFCryptBenchSizeA(cb, i, cb.crypt1, cb.plain2, cb.DK);
+      tmp = th[i];
+      tmp.start();
+    }
+
+    th[0] = new JGFCryptBenchSizeA(cb, 0, cb.crypt1, cb.plain2, cb.DK);
+    tmp = th[0];
+    tmp.start();
+
+
+    for(int i=1;i<nthreads;i++) {
+      tmp = th[i];
+      try {
+        tmp.join();
+      } catch (InterruptedException e) {}
+    }
+
+    // Stop the stopwatch.
+    instr.stopTimer("Section2:Crypt:Kernel");
+
+    cb.JGFvalidate();
+    cb.JGFtidyup();
+
+    int arows;
+    arows = cb.array_rows;
+
+    instr.addOpsToTimer("Section2:Crypt:Kernel", (2*arows)/1000.);
+    instr.printTimer("Section2:Crypt:Kernel");
+
+    System.out.println("Done\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFInstrumentor.java b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFInstrumentor.java
new file mode 100644
index 00000000..004ba8f9
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFInstrumentor.java
@@ -0,0 +1,206 @@
+/**************************************************************************
+*                                                                         *
+*         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+*                                                                         *
+*                            produced by                                  *
+*                                                                         *
+*                  Java Grande Benchmarking Project                       *
+*                                                                         *
+*                                at                                       *
+*                                                                         *
+*                Edinburgh Parallel Computing Centre                      *
+*                                                                         * 
+*                email: epcc-javagrande@epcc.ed.ac.uk                     *
+*                                                                         *
+*                                                                         *
+*      This version copyright (c) The University of Edinburgh, 1999.      *
+*                         All rights reserved.                            *
+*                                                                         *
+**************************************************************************/
+/**************************************************************************
+*                       Ported for DSTM Benchmark                         *
+**************************************************************************/
+import java.util.*;
+
+public class JGFInstrumentor{
+
+    private HashMap timers;
+    private HashMap data; 
+
+    public JGFInstrumentor()
+    {
+        timers = new HashMap();
+        data = new HashMap(); 
+    }
+
+    public void addTimer (String name){
+
+        if (timers.containsKey(name)) {
+            System.out.println("JGFInstrumentor.addTimer: warning -  timer " + name + 
+                    " already exists");
+        }
+        else {
+            timers.put(name, new JGFTimer(name));
+        }
+    }
+
+    public void addTimer (String name, String opname){
+
+        if (timers.containsKey(name)) {
+            System.out.println("JGFInstrumentor.addTimer: warning -  timer " + name + 
+                    " already exists");
+        }
+        else {
+            timers.put(name, new JGFTimer(name,opname));
+        }
+
+    }
+
+    public void addTimer (String name, String opname, int size){
+
+        if (timers.containsKey(name)) {
+            System.out.println("JGFInstrumentor.addTimer: warning -  timer " + name +
+                    " already exists");
+        }
+        else {
+            timers.put(name, new JGFTimer(name,opname,size));
+        }
+
+    }
+
+    public void startTimer(String name){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).start();
+        }
+        else {
+            System.out.println("JGFInstrumentor.startTimer: failed -  timer " + name + 
+                    " does not exist");
+        }
+
+    }
+
+    public void stopTimer(String name){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).stop();
+        }
+        else {
+            System.out.println("JGFInstrumentor.stopTimer: failed -  timer " + name + 
+                    " does not exist");
+        }
+    }
+
+    public void addOpsToTimer(String name, double count){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addops(count);
+        }
+        else {
+            System.out.println("JGFInstrumentor.addOpsToTimer: failed -  timer " + name + 
+                    " does not exist");
+        }
+    }  
+
+    public void addTimeToTimer(String name, double added_time){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).addtime(added_time);
+        }
+        else {
+            System.out.println("JGFInstrumentor.addTimeToTimer: failed -  timer " + name +
+                    " does not exist");
+        }
+
+
+
+    }
+
+    public double readTimer(String name){
+        double time; 
+        if (timers.containsKey(name)) {
+            time = ((JGFTimer) timers.get(name)).time;
+        }
+        else {
+            System.out.println("JGFInstrumentor.readTimer: failed -  timer " + name + 
+                    " does not exist");
+            time = 0.0; 
+        }
+        return time; 
+    }  
+
+    public void resetTimer(String name){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).reset();
+        }
+        else {
+            System.out.println("JGFInstrumentor.resetTimer: failed -  timer " + name +
+                    " does not exist");
+        }
+    }
+
+    public void printTimer(String name){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).print();
+        }
+        else {
+            System.out.println("JGFInstrumentor.printTimer: failed -  timer " + name +
+                    " does not exist");
+        }
+    }
+
+    public void printperfTimer(String name){
+        if (timers.containsKey(name)) {
+            ((JGFTimer) timers.get(name)).printperf();
+        }
+        else {
+            System.out.println("JGFInstrumentor.printTimer: failed -  timer " + name +
+                    " does not exist");
+        }
+    }
+
+    public void storeData(String name, Object obj){
+        data.put(name,obj); 
+    }
+
+    public void retrieveData(String name, Object obj){
+        obj = data.get(name); 
+    }
+
+    public void printHeader(int section, int size,int nthreads) {
+
+        String header, base; 
+
+        header = "";
+        base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section "; 
+
+        if (section == 1)
+        {
+            header = base + "1";
+        }
+        else if (section == 2)
+        {
+            if (size == 0)
+                header = base + "2 - Size A";
+            else if (size == 1)
+                header = base + "2 - Size B";
+            else if (size == 2)
+                header = base + "2 - Size C";
+        }
+        else if (section == 3)
+        {
+            if (size == 0)
+                header = base + "3 - Size A";
+            else if (size == 1)
+                header = base + "3 - Size B";
+        }
+
+        System.out.println(header); 
+
+        if (nthreads == 1) {
+            System.out.println("Executing on " + nthreads + " thread");
+        }
+        else {
+            System.out.println("Executing on " + nthreads + " threads");
+        }
+
+        System.out.println("");
+
+    } 
+}
diff --git a/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFTimer.java b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFTimer.java
new file mode 100644
index 00000000..b78b1b8c
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/Crypt/java/JGFTimer.java
@@ -0,0 +1,130 @@
+/**************************************************************************
+*                                                                         *
+*         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+*                                                                         *
+*                            produced by                                  *
+*                                                                         *
+*                  Java Grande Benchmarking Project                       *
+*                                                                         *
+*                                at                                       *
+*                                                                         *
+*                Edinburgh Parallel Computing Centre                      *
+*                                                                         * 
+*                email: epcc-javagrande@epcc.ed.ac.uk                     *
+*                                                                         *
+*                                                                         *
+*      This version copyright (c) The University of Edinburgh, 1999.      *
+*                         All rights reserved.                            *
+*                                                                         *
+**************************************************************************/
+/**************************************************************************
+*                       Ported for DSTM Benchmark                         *
+**************************************************************************/
+
+
+//package jgfutil;
+
+public class JGFTimer {
+
+  public String name; 
+  public String opname; 
+  public double time; 
+  public double opcount; 
+  public long calls; 
+  public int size;
+  
+  private long start_time;
+  private boolean on; 
+
+  public JGFTimer(String name, String opname){
+    this.name = name;
+    this.opname = opname;
+    this.size = -1;
+    reset(); 
+  }
+
+  public JGFTimer(String name, String opname, int size){
+    this.name = name;
+    this.opname = opname;
+    this.size = size;
+    reset();
+  }
+
+  public JGFTimer(String name){
+    this.name = name;
+    this.opname = "";
+    reset(); 
+  }
+
+
+
+  public void start(){
+    if (on) System.out.println("Warning timer " + name + " was already turned on");
+    on = true; 
+    start_time = System.currentTimeMillis();
+  }
+
+
+  public void stop(){
+    time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+    if (!on) System.out.println("Warning timer " + name + " wasn't turned on");
+    calls++;
+    on = false;  
+  }
+
+  public void addops(double count){
+    opcount += count;
+  } 
+
+  public void addtime(double added_time){
+    time += added_time;
+  }
+
+  public void reset(){
+    time = 0.0; 
+    calls = 0; 
+    opcount = 0; 
+    on = false;
+  }
+
+  public double perf(){
+    return opcount / time; 
+  }
+
+  public void longprint(){
+      System.out.println("Timer            Calls         Time(s)       Performance("+opname+"/s)");   
+     //System.out.println(name + "           " + calls +    "           "  +  time + "        " + this.perf());
+  }
+
+  public void print(){
+    if (opname.equals(""))
+    {
+      System.out.println(name + "   " + (long)time + " (s)");
+    }
+    else
+    {
+      if(size == 0) {
+	System.out.println(name + ":SizeA" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)");
+      } else if (size == 1) {
+	System.out.println(name + ":SizeB" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)");
+      } else if (size == 2) {
+	System.out.println(name + ":SizeC" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)");
+      } else{
+	System.out.println(name + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)");
+      }
+    }
+  }
+
+  public void printperf(){
+
+     String name;
+     name = this.name; 
+
+     // pad name to 40 characters
+     while ( name.length() < 40 ) name = name + " "; 
+     
+     System.out.println(name + "\t" + (long)this.perf() + "\t"
+			+ " ("+opname+"/s)");  
+  }
+
+}
diff --git a/Robust/src/Benchmarks/Prefetch/Crypt/java/makefile b/Robust/src/Benchmarks/Prefetch/Crypt/java/makefile
new file mode 100644
index 00000000..b89700d6
--- /dev/null
+++ b/Robust/src/Benchmarks/Prefetch/Crypt/java/makefile
@@ -0,0 +1,8 @@
+SRC = JGFCryptBenchSizeA
+default:
+	javac ${SRC}.java
+run:
+	java ${SRC}
+
+clean:
+	rm *.class