Robust/src/Benchmarks/Prefetch/Em3d/dsm/Em3dNold.java

   1 /**
   2  *
   3  *
   4  * Java implementation of the <tt>em3d</tt> Olden benchmark.  This Olden
   5  * benchmark models the propagation of electromagnetic waves through
   6  * objects in 3 dimensions. It is a simple computation on an irregular
   7  * bipartite graph containing nodes representing electric and magnetic
   8  * field values.
   9  *
  10  * <p><cite>
  11  * D. Culler, A. Dusseau, S. Goldstein, A. Krishnamurthy, S. Lumetta, T. von
  12  * Eicken and K. Yelick. "Parallel Programming in Split-C".  Supercomputing
  13  * 1993, pages 262-273.
  14  * </cite>
  15  **/
  16 public class Em3d extends Thread
  17 {
  18
  19   /**
  20    * The number of nodes (E and H)
  21    **/
  22   private int numNodes;
  23   /**
  24    * The out-degree of each node.
  25    **/
  26   private int numDegree;
  27   /**
  28    * The number of compute iterations
  29    **/
  30   private int numIter;
  31   /**
  32    * Should we print the results and other runtime messages
  33    **/
  34   private boolean printResult;
  35   /**
  36    * Print information messages?
  37    **/
  38   private boolean printMsgs;
  39
  40   int numThreads;
  41
  42   BiGraph bg;
  43   int upperlimit;
  44   int lowerlimit;
  45   Barrier mybarr;
  46
  47   public Em3d() {
  48     numNodes = 0;
  49     numDegree = 0;
  50     numIter = 1;
  51     printResult = false;
  52     printMsgs = false;
  53   }
  54
  55   public Em3d(BiGraph bg, int lowerlimit, int upperlimit, int numIter, Barrier mybarr) {
  56     this.bg = bg;
  57     this.lowerlimit = lowerlimit;
  58     this.upperlimit = upperlimit;
  59     this.numIter = numIter;
  60     this.mybarr = mybarr;
  61   }
  62
  63   public void run() {
  64     int iteration;
  65     Barrier barr;
  66
  67     atomic {
  68       iteration = numIter;
  69       barr=mybarr;
  70     }
  71
  72     for (int i = 0; i < iteration; i++) {
  73         /* for  eNodes */
  74         atomic {
  75             for(int j = lowerlimit; j<upperlimit; j++) {
  76                 Node n = bg.eNodes[j];
  77
  78                 for (int k = 0; k < n.fromCount; k++) {
  79                     n.value -= n.coeffs[k] * n.fromNodes[k].value;
  80                 }
  81             }
  82         }
  83
  84         Barrier.enterBarrier(barr);
  85
  86         /* for  hNodes */
  87         atomic {
  88             for(int j = lowerlimit; j<upperlimit; j++) {
  89                 Node n = bg.hNodes[j];
  90                 for (int k = 0; k < n.fromCount; k++) {
  91                     n.value -= n.coeffs[k] * n.fromNodes[k].value;
  92                 }
  93             }
  94         }
  95         Barrier.enterBarrier(barr);
  96     }
  97   }
  98
  99   /**
 100    * The main roitine that creates the irregular, linked data structure
 101    * that represents the electric and magnetic fields and propagates the
 102    * waves through the graph.
 103    * @param args the command line arguments
 104    **/
 105   public static void main(String args[]) {
 106     Em3d em = new Em3d();
 107     Em3d.parseCmdLine(args, em);
 108     if (em.printMsgs)
 109       System.printString("Initializing em3d random graph...\n");
 110     long start0 = System.currentTimeMillis();
 111     int numThreads = em.numThreads;
 112     int[] mid = new int[4];
 113     mid[0] = (128<<24)|(195<<16)|(175<<8)|79;
 114     mid[1] = (128<<24)|(195<<16)|(175<<8)|73;
 115     mid[2] = (128<<24)|(195<<16)|(175<<8)|78;
 116     mid[3] = (128<<24)|(195<<16)|(175<<8)|69;
 117     //System.printString("DEBUG -> numThreads = " + numThreads+"\n");
 118     Barrier mybarr;
 119     BiGraph graph;
 120     Random rand = new Random(783);
 121
 122     atomic {
 123       mybarr = global new Barrier(numThreads);
 124       graph =  BiGraph.create(em.numNodes, em.numDegree, em.printResult, rand);
 125     }
 126
 127     long end0 = System.currentTimeMillis();
 128
 129     // compute a single iteration of electro-magnetic propagation
 130     if (em.printMsgs)
 131       System.printString("Propagating field values for " + em.numIter +
 132           " iteration(s)...\n");
 133     long start1 = System.currentTimeMillis();
 134     Em3d[] em3d;
 135
 136     atomic {
 137       em3d = global new Em3d[numThreads];
 138       int increment=em.numNodes/numThreads;
 139       int base=0;
 140       for(int i=0;i<numThreads;i++) {
 141           if ((i+1)==numThreads)
 142               em3d[i] = global new Em3d(graph, base, em.numNodes, em.numIter, mybarr);
 143           else
 144               em3d[i] = global new Em3d(graph, base, base+increment, em.numIter, mybarr);
 145           base+=increment;
 146       }
 147     }
 148
 149     Em3d tmp;
 150     for(int i = 0; i<numThreads; i++) {
 151       atomic {
 152         tmp = em3d[i];
 153       }
 154       tmp.start(mid[i]);
 155     }
 156
 157     for(int i = 0; i<numThreads; i++) {
 158       atomic {
 159         tmp = em3d[i];
 160       }
 161       tmp.join();
 162     }
 163     long end1 = System.currentTimeMillis();
 164
 165     // print current field values
 166     if (em.printResult) {
 167       StringBuffer retval = new StringBuffer();
 168       double dvalue;
 169       atomic {
 170         dvalue = graph.hNodes[0].value;
 171       }
 172       int intvalue = (int)dvalue;
 173     }
 174
 175     if (em.printMsgs) {
 176       System.printString("EM3D build time "+ (long)((end0 - start0)/1000.0) + "\n");
 177       System.printString("EM3D compute time " + (long)((end1 - start1)/1000.0) + "\n");
 178       System.printString("EM3D total time " + (long)((end1 - start0)/1000.0) + "\n");
 179     }
 180     System.printString("Done!"+ "\n");
 181   }
 182
 183
 184   /**
 185    * Parse the command line options.
 186    * @param args the command line options.
 187    **/
 188
 189   public static void parseCmdLine(String args[], Em3d em)
 190   {
 191     int i = 0;
 192     String arg;
 193
 194     while (i < args.length && args[i].startsWith("-")) {
 195       arg = args[i++];
 196
 197       // check for options that require arguments
 198       if (arg.equals("-N")) {
 199         if (i < args.length) {
 200                 em.numNodes = new Integer(args[i++]).intValue();
 201         }
 202       } else if (arg.equals("-T")) {
 203         if (i < args.length) {
 204                 em.numThreads = new Integer(args[i++]).intValue();
 205         }
 206       } else if (arg.equals("-d")) {
 207         if (i < args.length) {
 208                 em.numDegree = new Integer(args[i++]).intValue();
 209         }
 210       } else if (arg.equals("-i")) {
 211         if (i < args.length) {
 212             em.numIter = new Integer(args[i++]).intValue();
 213         }
 214       } else if (arg.equals("-p")) {
 215               em.printResult = true;
 216       } else if (arg.equals("-m")) {
 217               em.printMsgs = true;
 218       } else if (arg.equals("-h")) {
 219         em.usage();
 220       }
 221     }
 222
 223     if (em.numNodes == 0 || em.numDegree == 0)
 224       em.usage();
 225   }
 226
 227   /**
 228    * The usage routine which describes the program options.
 229    **/
 230   public void usage()
 231   {
 232     System.printString("usage: java Em3d -T <threads> -N <nodes> -d <degree> [-p] [-m] [-h]\n");
 233     System.printString("    -N the number of nodes\n");
 234     System.printString("    -T the number of threads\n");
 235     System.printString("    -d the out-degree of each node\n");
 236     System.printString("    -i the number of iterations\n");
 237     System.printString("    -p (print detailed results\n)");
 238     System.printString("    -m (print informative messages)\n");
 239     System.printString("    -h (this message)\n");
 240   }
 241
 242 }