jgflufactbench.java

MPI for java for Distributed Programming

/**************************************************************************
*                                                                         *
*             Java Grande Forum Benchmark Suite - MPJ Version 1.0         *
*                                                                         *
*                            produced by                                  *
*                                                                         *
*                  Java Grande Benchmarking Project                       *
*                                                                         *
*                                at                                       *
*                                                                         *
*                Edinburgh Parallel Computing Centre                      *
*                                                                         * 
*                email: [e-mail]                     *
*                                                                         *
*                                                                         *
*      This version copyright (c) The University of Edinburgh, 2001.      *
*                         All rights reserved.                            *
*                                                                         *
**************************************************************************/

package jgf_mpj_benchmarks.section2.lufact;

//package lufact; 
import jgf_mpj_benchmarks.jgfutil.*; 
import mpi.*;

public class JGFLUFactBench extends Linpack implements JGFSection2{

  public static int nprocess;
  public static int rank;
  private int size;
  private int datasizes[] = {500,1000,2000};
  public static int rem_p_ldaa;
  public static int real_p_ldaa;

  public JGFLUFactBench(int nprocess, int rank) {
        this.nprocess=nprocess;
        this.rank=rank;
  }

  public void JGFsetsize(int size){
    this.size = size;
  }

  public void JGFinitialise() throws MPIException{

    int r_count,z_count;
    int p_ldaa;

    n = datasizes[size]; 
    ldaa = n; 
    lda = ldaa + 1;

    if(rank==0) {
      a = new double[ldaa][lda];
      b = new double [ldaa];
      x = new double [ldaa];
    }

    ipvt = new int [ldaa];

/* determine the size of the sub arrays and copy the data
   in a cyclic distribution to the sub arrays.  */

    p_ldaa = (ldaa + nprocess - 1) / nprocess;
    rem_p_ldaa = (p_ldaa*nprocess) - ldaa;

    real_p_ldaa = p_ldaa;
    for(int i=1;i<=rem_p_ldaa;i++){
      if(rank==(nprocess-i)){
        real_p_ldaa = p_ldaa-1;
      }
    }
 
    buf_a = new double[p_ldaa][lda];
    list = new int [ldaa];
    buf_list = new int [ldaa];

    if(rank==0) {
      long nl = (long) n;   //avoid integer overflow
      ops = (2.0*(nl*nl*nl))/3.0 + 2.0*(nl*nl);
    }

    if(rank==0) {
      norma = matgen(a,lda,n,b);    
    }

    if(rank==0) {
      r_count = 0;
      z_count = 0;
      for(int i=0;i<a.length;i++){
       if(r_count==0) {
         for(int l=0;l<a[0].length;l++){
           buf_a[z_count][l] = a[i][l]; 
         }
         z_count++;
       } else {
         MPI.COMM_WORLD.Send(a,i,1,MPI.OBJECT,r_count,10);     
       }
     
       buf_list[i] = z_count - 1;
       list[i] = r_count;
       r_count++;
       if(r_count == nprocess) {
        r_count = 0;
       }

      }

    } else {
      for(int i=0;i<real_p_ldaa;i++){
        MPI.COMM_WORLD.Recv(buf_a,i,1,MPI.OBJECT,0,10);
      }
      for(int i=real_p_ldaa;i<buf_a.length;i++){
        for(int ki=0;ki<buf_a[0].length;ki++){
          buf_a[i][ki] = -9.0;
        }
      }

    }

    MPI.COMM_WORLD.Bcast(list,0,list.length,MPI.INT,0);
    MPI.COMM_WORLD.Bcast(buf_list,0,list.length,MPI.INT,0);

  }

  public void JGFkernel() throws MPIException{

    MPI.COMM_WORLD.Barrier();
    if(rank==0) {    
      JGFInstrumentor.startTimer("Section2:LUFact:Kernel");  
    }
 
    info = dgefa(a,lda,n,ipvt);

    if(rank==0) {
    dgesl(a,lda,n,ipvt,b,0);
    }


    MPI.COMM_WORLD.Barrier();
    if(rank==0) {    
    JGFInstrumentor.stopTimer("Section2:LUFact:Kernel"); 
    }  
  }

  public void JGFvalidate(){

    int i;
    double eps,residn;
    final double ref[] = {6.0, 12.0, 20.0}; 

    if(rank==0) {
    for (i = 0; i < n; i++) {
      x[i] = b[i];
    }
    norma = matgen(a,lda,n,b);
    for (i = 0; i < n; i++) {
      b[i] = -b[i];
    }

    dmxpy(n,b,n,lda,x,a);
    resid = 0.0;
    normx = 0.0;
    for (i = 0; i < n; i++) {
      resid = (resid > abs(b[i])) ? resid : abs(b[i]);
      normx = (normx > abs(x[i])) ? normx : abs(x[i]);
    }

    eps =  epslon((double)1.0);
    residn = resid/( n*norma*normx*eps );
    
    if (residn > ref[size]) {
	System.out.println("Validation failed");
	System.out.println("Computed Norm Res = " + residn);
        System.out.println("Reference Norm Res = " + ref[size]); 
    }
    }

  }

    public void JGFtidyup(){
    // Make sure large arrays are gc'd.
    a = null; 
    b = null;
    x = null;
    ipvt = null; 
    System.gc();  
  }


  public void JGFrun(int size) throws MPIException{

    if(rank==0){
      JGFInstrumentor.addTimer("Section2:LUFact:Kernel", "Mflops",size);
    }

    JGFsetsize(size); 
    JGFinitialise(); 
    JGFkernel(); 
    JGFvalidate(); 
    JGFtidyup(); 

    if(rank==0){
      JGFInstrumentor.addOpsToTimer("Section2:LUFact:Kernel", ops/1.0e06);
      JGFInstrumentor.printTimer("Section2:LUFact:Kernel"); 
    }

  }

}