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   Random R;
  28   public double Gtotal;
  29
  30   public JGFSORBench(int nthreads){
  31     this.nthreads = nthreads;
  32     datasizes = global new int[3];
  33     datasizes[0] = 1000;
  34     datasizes[1] = 1500;
  35     datasizes[2] = 2000;
  36     JACOBI_NUM_ITER = 100;
  37     RANDOM_SEED = 10101010;
  38     R = global new Random(RANDOM_SEED);
  39     Gtotal = 0.0;
  40   }
  41
  42   public void JGFsetsize(int size){
  43     this.size = size;
  44   }
  45
  46   public static void JGFkernel(JGFSORBench sor) {
  47     int numthreads, datasize;
  48     BarrierServer mybarr;
  49     Random rand;
  50
  51     int[] mid = new int[4];
  52     mid[0] = (128<<24)|(195<<16)|(175<<8)|79;
  53     mid[1] = (128<<24)|(195<<16)|(175<<8)|73;
  54     mid[2] = (128<<24)|(195<<16)|(175<<8)|78;
  55     mid[3] = (128<<24)|(195<<16)|(175<<8)|69;
  56
  57     atomic {
  58       numthreads = sor.nthreads;
  59       rand = sor.R;
  60       datasize = sor.datasizes[sor.size];
  61       mybarr = global new BarrierServer(numthreads);
  62     }
  63     mybarr.start(mid[0]);
  64
  65     double[][] G;
  66     int M, N;
  67     atomic {
  68       G = sor.RandomMatrix(datasize, datasize, rand);
  69       M = G.length;
  70       N = G[0].length;
  71     }
  72     double omega = 1.25;
  73     int num_iterations;
  74     atomic {
  75       num_iterations = sor.JACOBI_NUM_ITER;
  76     }
  77
  78     double omega_over_four = omega * 0.25;
  79     double one_minus_omega = 1.0 - omega;
  80
  81     // update interior points
  82     //
  83     int Mm1 = M-1;
  84     int Nm1 = N-1;
  85
  86     //spawn threads
  87     SORRunner[] thobjects;
  88     atomic {
  89       thobjects = global new SORRunner[numthreads];
  90     }
  91
  92     //JGFInstrumentor.startTimer("Section2:SOR:Kernel", instr.timers);
  93
  94     boolean waitfordone=true;
  95     while(waitfordone) {
  96       atomic {
  97         if (mybarr.done)
  98           waitfordone=false;
  99       }
 100     }
 101
 102     SORRunner tmp;
 103     for(int i=1;i<numthreads;i++) {
 104       atomic {
 105         thobjects[i] =  global new SORRunner(i,omega,G,num_iterations,numthreads);
 106         tmp = thobjects[i];
 107       }
 108       tmp.start(mid[i]);
 109     }
 110     atomic {
 111       thobjects[0] =  global new SORRunner(0,omega,G,num_iterations,numthreads);
 112       tmp = thobjects[0];
 113     }
 114     tmp.start(mid[0]);
 115     tmp.join();
 116
 117     for(int i=1;i<numthreads;i++) {
 118       atomic {
 119         tmp = thobjects[i];
 120       }
 121       tmp.join();
 122     }
 123
 124     //JGFInstrumentor.stopTimer("Section2:SOR:Kernel", instr.timers);
 125     atomic {
 126       for (int i=1; i<Nm1; i++) {
 127         for (int j=1; j<Nm1; j++) {
 128           sor.Gtotal += G[i][j];
 129         }
 130       }
 131     }
 132   }
 133
 134   public double[][] RandomMatrix(int M, int N, Random R)
 135   {
 136     double A[][] = global new double[M][N];
 137
 138     for (int i=0; i<N; i++)
 139       for (int j=0; j<N; j++)
 140       {
 141         A[i][j] = R.nextDouble() * 1e-6;
 142       }
 143     return A;
 144   }
 145
 146   public int JGFvalidate(){
 147
 148     double refval[];
 149     refval = new double[3];
 150     refval[0] = 0.498574406322512;
 151     refval[1] = 1.1234778980135105;
 152     refval[2] = 1.9954895063582696;
 153     double dev = Math.fabs(Gtotal - refval[size]);
 154     long l = (long) refval[size] * 1000000;
 155     long r = (long) Gtotal * 1000000;
 156     if (l != r ){
 157       //System.printString("Validation failed");
 158       //System.printString("Gtotal = " + (long) Gtotal * 1000000 + "  " +(long) dev * 1000000 + "  " + size);
 159       return 1;
 160     } else {
 161       return 0;
 162     }
 163   }
 164 }