Robust/src/Benchmarks/oooJava/sor/SORRunner.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  *      adapted from SciMark 2.0, author Roldan Pozo (pozo@cam.nist.gov)   *
  16  *                                                                         *
  17  *      This version copyright (c) The University of Edinburgh, 2001.      *
  18  *                         All rights reserved.                            *
  19  *                                                                         *
  20  **************************************************************************/
  21
  22 class SORRunner  {
  23
  24   int id, num_iterations;
  25   double G[][],omega;
  26   int nthreads;
  27   long RANDOM_SEED;
  28
  29   public SORRunner(int id, double omega, double G[][], int num_iterations, int nthreads, long RANDOM_SEED) {
  30     this.id = id;
  31     this.omega=omega;
  32     this.G=G;
  33     this.num_iterations=num_iterations;
  34     this.nthreads = nthreads;
  35     this.RANDOM_SEED =  RANDOM_SEED;
  36   }
  37
  38   public void run() {
  39     int tmpid, M, N, numthreads;
  40     double omega_over_four, one_minus_omega;
  41     int numiterations;
  42     int ilow, iupper, slice, tslice, ttslice, Mm1, Nm1;
  43
  44
  45     N = M = G.length;
  46
  47     omega_over_four = omega * 0.25;
  48     one_minus_omega = 1.0 - omega;
  49     numthreads = nthreads;
  50     tmpid = id;
  51     numiterations = num_iterations;
  52     Mm1 = M-1;
  53     Nm1 = N-1;
  54     tslice = (Mm1) / 2;
  55     ttslice = (tslice + numthreads-1)/numthreads;
  56     slice = ttslice*2;
  57     ilow=tmpid*slice+1;
  58     iupper = ((tmpid+1)*slice)+1;
  59     if (iupper > Mm1) iupper =  Mm1+1;
  60     if (tmpid == (numthreads-1)) iupper = Mm1+1;
  61
  62     //barrier
  63
  64     Random rand=new Random(RANDOM_SEED);
  65     double[] R = G[0];
  66     for(int j=0;j<M;j++)
  67       R[j]=rand.nextDouble() * 1e-6;
  68     for(int i=ilow;i<iupper;i++) {
  69       R=G[i];
  70       for(int j=0;j<M;j++)
  71         R[j]=rand.nextDouble() * 1e-6;
  72     }
  73
  74     System.out.println("Starting computation!");
  75
  76     // update interior points
  77     //
  78
  79     //barrier
  80
  81     for (int p=0; p<2*numiterations; p++) {
  82       for (int q=0;q<=2;q+=2) {//new line
  83
  84         for (int i=ilow+(p%2)+q; i<iupper; i=i+4) {//changed 2->4 and added q
  85
  86         double [] Gi = G[i];
  87         double [] Gim1 = G[i-1];
  88
  89         if(i == 1) {
  90           double [] Gip1 = G[i+1];
  91
  92           sese first {
  93           for (int j=1; j<Nm1; j=j+2){
  94             Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
  95                 + Gi[j+1]) + one_minus_omega * Gi[j];
  96
  97           }
  98           }
  99         } else if (i == Mm1) {
 100
 101         } else {
 102
 103           double [] Gip1 = G[i+1];
 104           sese second {
 105           for (int j=1; j<Nm1; j=j+2){
 106             Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
 107                 + Gi[j+1]) + one_minus_omega * Gi[j];
 108
 109           }
 110           }
 111         }
 112       }
 113       } //new line
 114
 115       //barrier
 116       for (int q=0;q<=2;q+=2) {//new line
 117         for (int i=ilow+(p%2)+q; i<iupper; i=i+4) { //added q, changed 2->4
 118
 119         double [] Gi = G[i];
 120         double [] Gim1 = G[i-1];
 121
 122         if(i == 1) {
 123         } else if (i == Mm1) {
 124
 125           double [] Gim2 = G[i-2];
 126
 127           sese three {
 128           for (int j=1; j<Nm1; j=j+2){
 129             if((j+1) != Nm1) {
 130               Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
 131                   + Gim1[j+2]) + one_minus_omega * Gim1[j+1];
 132             }
 133           }
 134           }
 135
 136         } else {
 137
 138           double [] Gim2 = G[i-2];
 139
 140           sese four {
 141           for (int j=1; j<Nm1; j=j+2){
 142             if((j+1) != Nm1) {
 143               Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
 144                   + Gim1[j+2]) + one_minus_omega * Gim1[j+1];
 145             }
 146           }
 147           }
 148         }
 149       }
 150       }
 151       //barrier
 152     }//end of for
 153
 154   } //end of run()
 155 }