Robust/src/Benchmarks/Prefetch/SOR/dsm/JGFSORBench.java

   1 /**************************************************************************
   2  *                                                                         *
   3  *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
   4  *                                                                         *
   5  *                            produced by                                  *
   6  *                                                                         *
   7  *                  Java Grande Benchmarking Project                       *
   8  *                                                                         *
   9  *                                at                                       *
  10  *                                                                         *
  11  *                Edinburgh Parallel Computing Centre                      *
  12  *                                                                         *
  13  *                email: epcc-javagrande@epcc.ed.ac.uk                     *
  14  *                                                                         *
  15  *                                                                         *
  16  *      This version copyright (c) The University of Edinburgh, 2001.      *
  17  *                         All rights reserved.                            *
  18  *                                                                         *
  19  **************************************************************************/
  20 public class JGFSORBench {
  21
  22   int size;
  23   int[] datasizes;
  24   int JACOBI_NUM_ITER;
  25   long RANDOM_SEED;
  26   public int nthreads;
  27   public double Gtotal;
  28
  29   public JGFSORBench(int nthreads){
  30     this.nthreads = nthreads;
  31     datasizes = global new int[4];
  32     datasizes[0] = 1000;
  33     datasizes[1] = 1500;
  34     datasizes[2] = 2000;
  35     datasizes[3] = 8000;
  36     JACOBI_NUM_ITER = 100;
  37     RANDOM_SEED = 10101010;
  38     Gtotal = 0.0;
  39   }
  40
  41   public void JGFsetsize(int size){
  42     this.size = size;
  43   }
  44
  45   public static void JGFkernel(JGFSORBench sor) {
  46     int numthreads, datasize;
  47     BarrierServer mybarr;
  48
  49     int[] mid = new int[8];
  50     mid[0] = (128<<24)|(195<<16)|(175<<8)|84;//dw-10
  51     mid[1] = (128<<24)|(195<<16)|(175<<8)|85;//dw-11
  52     mid[2] = (128<<24)|(195<<16)|(175<<8)|86;//dw-12
  53     mid[3] = (128<<24)|(195<<16)|(175<<8)|87;//dw-13
  54     mid[4] = (128<<24)|(195<<16)|(175<<8)|88;//dw-14
  55     mid[5] = (128<<24)|(195<<16)|(175<<8)|89;//dw-15
  56     mid[6] = (128<<24)|(195<<16)|(175<<8)|90;//dw-16
  57     mid[7] = (128<<24)|(195<<16)|(175<<8)|91;//dw-17
  58
  59     double[][] G;
  60     int num_iterations;
  61
  62     atomic {
  63       numthreads = sor.nthreads;
  64       datasize = sor.datasizes[sor.size];
  65       mybarr = global new BarrierServer(numthreads);
  66       G =  global new double[datasize][];
  67       num_iterations = sor.JACOBI_NUM_ITER;
  68     }
  69     mybarr.start(mid[0]);
  70
  71     double omega = 1.25;
  72     double omega_over_four = omega * 0.25;
  73     double one_minus_omega = 1.0 - omega;
  74
  75     // update interior points
  76     //
  77     //spawn threads
  78
  79     SORWrap[] thobjects = new SORWrap[numthreads];
  80
  81     atomic {
  82         for(int i=0;i<numthreads;i++) {
  83             thobjects[i] =  new SORWrap(global new SORRunner(i,omega,G,num_iterations,numthreads));
  84         }
  85     }
  86
  87     boolean waitfordone=true;
  88     while(waitfordone) {
  89       atomic {
  90         if (mybarr.done)
  91           waitfordone=false;
  92       }
  93     }
  94
  95     for(int i=0;i<numthreads;i++) {
  96         thobjects[i].sor.start(mid[i]);
  97     }
  98
  99     for(int i=0;i<numthreads;i++) {
 100       thobjects[i].sor.join();
 101     }
 102
 103     //JGFInstrumentor.stopTimer("Section2:SOR:Kernel", instr.timers);
 104     atomic {
 105         for (int i=1; i<G.length-1; i++) {
 106             for (int j=1; j<G.length-1; j++) {
 107                 sor.Gtotal += G[i][j];
 108             }
 109         }
 110     }
 111   }
 112
 113   public int JGFvalidate(){
 114
 115     double refval[];
 116     refval = new double[4];
 117     refval[0] = 0.498574406322512;
 118     refval[1] = 1.1234778980135105;
 119     refval[2] = 1.9954895063582696;
 120     refval[3] = 2.654895063582696;
 121     double dev = Math.fabs(Gtotal - refval[size]);
 122     long l = (long) refval[size] * 1000000;
 123     long r = (long) Gtotal * 1000000;
 124     if (l != r ){
 125       return 1;
 126     } else {
 127       return 0;
 128     }
 129   }
 130 }