Robust/src/Benchmarks/Prefetch/SOR/dsm/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 extends Thread {
  23
  24   int id,num_iterations;
  25   double G[][],omega;
  26   int nthreads;
  27
  28   public SORRunner(int id, double omega, double G[][], int num_iterations, int nthreads) {
  29     this.id = id;
  30     this.omega=omega;
  31     this.G=G;
  32     this.num_iterations=num_iterations;
  33     this.nthreads = nthreads;
  34   }
  35
  36   public void run() {
  37     int tmpid, M, N, numthreads;
  38     double omega_over_four, one_minus_omega;
  39     int numiterations;
  40     Barrier barr;
  41     barr = new Barrier("128.195.175.79");
  42     int ilow, iupper, slice, tslice, ttslice, Mm1, Nm1;
  43
  44     atomic {
  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       G[0]=global new double[N];
  62       for(int i=ilow;i<iupper;i++) {
  63         G[i]=global new double[N];
  64       }
  65     }
  66
  67     Barrier.enterBarrier(barr);
  68     atomic {
  69       Random rand=new Random();
  70       double[] R = G[0];
  71       for(int j=0;j<M;j++)
  72         R[j]=rand.nextDouble() * 1e-6;
  73       for(int i=ilow;i<iupper;i++) {
  74         R=G[i];
  75         for(int j=0;j<M;j++)
  76           R[j]=rand.nextDouble() * 1e-6;
  77       }
  78     }
  79     Barrier.enterBarrier(barr);
  80
  81     // update interior points
  82     //
  83
  84
  85     for (int p=0; p<2*numiterations; p++) {
  86       atomic {
  87         for (int i=ilow+(p%2); i<iupper; i=i+2) {
  88
  89           double [] Gi = G[i];
  90           double [] Gim1 = G[i-1];
  91
  92           if(i == 1) {
  93             double [] Gip1 = G[i+1];
  94
  95             for (int j=1; j<Nm1; j=j+2){
  96               Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
  97                   + Gi[j+1]) + one_minus_omega * Gi[j];
  98
  99             }
 100           } else if (i == Mm1) {
 101
 102           } else {
 103
 104             double [] Gip1 = G[i+1];
 105
 106             for (int j=1; j<Nm1; j=j+2){
 107               Gi[j] = omega_over_four * (Gim1[j] + Gip1[j] + Gi[j-1]
 108                   + Gi[j+1]) + one_minus_omega * Gi[j];
 109
 110             }
 111           }
 112         }
 113       } //close atomic
 114
 115       Barrier.enterBarrier(barr);
 116       atomic {
 117         for (int i=ilow+(p%2); i<iupper; i=i+2) {
 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             for (int j=1; j<Nm1; j=j+2){
 128               if((j+1) != Nm1) {
 129                 Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
 130                     + Gim1[j+2]) + one_minus_omega * Gim1[j+1];
 131               }
 132             }
 133
 134           } else {
 135
 136             double [] Gim2 = G[i-2];
 137
 138             for (int j=1; j<Nm1; j=j+2){
 139               if((j+1) != Nm1) {
 140                 Gim1[j+1]=omega_over_four * (Gim2[j+1] + Gi[j+1] + Gim1[j]
 141                     + Gim1[j+2]) + one_minus_omega * Gim1[j+1];
 142               }
 143             }
 144           }
 145         }
 146       } //close atomic
 147
 148       Barrier.enterBarrier(barr);
 149     }//end of for
 150   } //end of run()
 151 }