seriestest.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]                     *
*                                                                         *
*                  Original version of this code by                       *
*                 Gabriel Zachmann ([e-mail])                      *
*                                                                         *
*      This version copyright (c) The University of Edinburgh, 2001.      *
*                         All rights reserved.                            *
*                                                                         *
**************************************************************************/

/**
* Class SeriesTest
*
* Performs the transcendental/trigonometric portion of the
* benchmark. This test calculates the first n fourier
* coefficients of the function (x+1)^x defined on the interval
* 0,2 (where n is an arbitrary number that is set to make the
* test last long enough to be accurately measured by the system
* clock). Results are reported in number of coefficients calculated
* per sec.
*
* The first four pairs of coefficients calculated shoud be:
* (2.83777, 0), (1.04578, -1.8791), (0.2741, -1.15884), and
* (0.0824148, -0.805759).
*/
package jgf_mpj_benchmarks.section2.series;

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

class SeriesTest 
{

// Declare class data.


int array_rows; 
int p_array_rows; 
int ref_p_array_rows; 
int rem_p_array_rows; 
double [] [] p_TestArray = null;  // Array of arrays on each process.
double [] [] TestArray = null;  // Array of arrays.


/*
* buildTestData
*
*/

// Instantiate array(s) to hold fourier coefficients.

void buildTestData()
{
    // Allocate appropriate length for the double array of doubles.

    if(JGFSeriesBench.rank==0) {
      TestArray = new double [2][array_rows];
    }
    p_TestArray = new double [2][p_array_rows];
}



/*
* Do
*
* This consists of calculating the
* first n pairs of fourier coefficients of the function (x+1)^x on
* the interval 0,2. n is given by array_rows, the array size.
* NOTE: The # of integration steps is fixed at 1000. 
*/

void Do() throws MPIException
{
    double omega;       // Fundamental frequency.
    int ilow;
//System.out.println(" Do "+JGFSeriesBench.rank);

    if(JGFSeriesBench.rank==0) {
      // Start the stopwatch.
      JGFInstrumentor.startTimer("Section2:Series:Kernel"); 

      // Calculate the fourier series. Begin by calculating A[0].

      TestArray[0][0]=TrapezoidIntegrate((double)0.0, // Lower bound.
                              (double)2.0,            // Upper bound.
                              1000,                    // # of steps.
                              (double)0.0,            // No omega*n needed.
                              0) / (double)2.0;       // 0 = term A[0].
    }
 
//System.out.println(" Do(1) "+JGFSeriesBench.rank);
    // Calculate the fundamental frequency.
    // ( 2 * pi ) / period...and since the period
    // is 2, omega is simply pi.

    omega = (double) 3.1415926535897932;

    if(JGFSeriesBench.rank==0) {
      ilow = 1;
    } else {
      ilow = 0;
    }

//System.out.println(" Do(2) "+JGFSeriesBench.rank);
//System.out.println(" p_array_rows "+p_array_rows);
//System.exit(0);
    for (int i = ilow; i < p_array_rows; i++)
    {
	    //System.out.println("i :"+i);
        // Calculate A[i] terms. Note, once again, that we
        // can ignore the 2/period term outside the integral
        // since the period is 2 and the term cancels itself
        // out.

//System.out.println(" Do(3) "+JGFSeriesBench.rank);
        p_TestArray[0][i] = TrapezoidIntegrate((double)0.0,
                          (double)2.0,
                          1000,
                          omega * ((double)i + (ref_p_array_rows*JGFSeriesBench.rank)),
                          1);                       // 1 = cosine term.

        // Calculate the B[i] terms.

        p_TestArray[1][i] = TrapezoidIntegrate((double)0.0,
                          (double)2.0,
                          1000,
                          omega * ((double)i + (ref_p_array_rows*JGFSeriesBench.rank)),
                          2);                       // 2 = sine term.
    }

//System.out.println("barrier starts "+ JGFSeriesBench.rank);
    MPI.COMM_WORLD.Barrier();
//System.out.println("barrier ends "+JGFSeriesBench.rank);

    // Send all the data to process 0
   
    if(JGFSeriesBench.rank==0) {

      for(int k=1;k<p_array_rows;k++){
        TestArray[0][k] = p_TestArray[0][k]; 
        TestArray[1][k] = p_TestArray[1][k];
      }

      for(int k=1;k<JGFSeriesBench.nprocess;k++) {
//System.out.println("recv "+JGFSeriesBench.rank);
MPI.COMM_WORLD.Recv(p_TestArray[0],0,p_TestArray[0].length,MPI.DOUBLE,k,k);
MPI.COMM_WORLD.Recv(p_TestArray[1],0,p_TestArray[1].length,MPI.DOUBLE,k,
        k+JGFSeriesBench.nprocess);

        if(k==(JGFSeriesBench.nprocess-1)) {
          p_array_rows = rem_p_array_rows;
        }

        for(int j=0;j<p_array_rows;j++){
          TestArray[0][j+(ref_p_array_rows*k)] = p_TestArray[0][j];
          TestArray[1][j+(ref_p_array_rows*k)] = p_TestArray[1][j];
        }

      } 

      p_array_rows = ref_p_array_rows;

    } else {

//System.out.println("ssend "+JGFSeriesBench.rank);
      MPI.COMM_WORLD.Ssend(p_TestArray[0],0,p_TestArray[0].length,
		      MPI.DOUBLE,0,JGFSeriesBench.rank);
      MPI.COMM_WORLD.Ssend(p_TestArray[1],0,p_TestArray[1].length,
	      MPI.DOUBLE,0,JGFSeriesBench.rank+JGFSeriesBench.nprocess);
    } 

    MPI.COMM_WORLD.Barrier();
   
    if(JGFSeriesBench.rank==0) {
      // Stop the stopwatch.
      JGFInstrumentor.stopTimer("Section2:Series:Kernel"); 

    }
}

/*
* TrapezoidIntegrate
*
* Perform a simple trapezoid integration on the function (x+1)**x.
* x0,x1 set the lower and upper bounds of the integration.
* nsteps indicates # of trapezoidal sections.
* omegan is the fundamental frequency times the series member #.
* select = 0 for the A[0] term, 1 for cosine terms, and 2 for
* sine terms. Returns the value.
*/

private double TrapezoidIntegrate (double x0,     // Lower bound.
                        double x1,                // Upper bound.
                        int nsteps,               // # of steps.
                        double omegan,            // omega * n.
                        int select)               // Term type.
{
    double x;               // Independent variable.
    double dx;              // Step size.
    double rvalue;          // Return value.

    // Initialize independent variable.

    x = x0;

    // Calculate stepsize.

    dx = (x1 - x0) / (double)nsteps;

    // Initialize the return value.

    rvalue = thefunction(x0, omegan, select) / (double)2.0;

    // Compute the other terms of the integral.

    if (nsteps != 1)
    {
            --nsteps;               // Already done 1 step.
            while (--nsteps > 0)
            {
                    x += dx;
                    rvalue += thefunction(x, omegan, select);
            }
    }

    // Finish computation.

    rvalue=(rvalue + thefunction(x1,omegan,select) / (double)2.0) * dx;
    return(rvalue);
}

/*
* thefunction
*
* This routine selects the function to be used in the Trapezoid
* integration. x is the independent variable, omegan is omega * n,
* and select chooses which of the sine/cosine functions
* are used. Note the special case for select=0.
*/

private double thefunction(double x,      // Independent variable.
                double omegan,              // Omega * term.
                int select)                 // Choose type.
{

    // Use select to pick which function we call.

    switch(select)
    {
        case 0: return(Math.pow(x+(double)1.0,x));

        case 1: return(Math.pow(x+(double)1.0,x) * Math.cos(omegan*x));

        case 2: return(Math.pow(x+(double)1.0,x) * Math.sin(omegan*x));
    }

    // We should never reach this point, but the following
    // keeps compilers from issuing a warning message.

    return (0.0);
}

/*
* freeTestData
*
* Nulls array that is created with every run and forces garbage
* collection to free up memory.
*/

void freeTestData()
{
    TestArray = null;    // Destroy the array.
    System.gc();         // Force garbage collection.
}


}