CSC352: Computing Pi in Parallel with Java

--D. Thiebaut (talk) 13:29, 2 September 2013 (EDT)

---

Computing an Approximation of Pi: Serial Version:

// PiSerial.java
// D. Thiebaut
// CSC352 Examples
// Computation of Pi.  This version is serial and takes a number of iterations to go 
// through from the command line and sums up terms to yield an approximation of Pi.
// To compile and run
//     mkdir DT
//     javac DT/PiSerial.java
//     java DT/PiSerial 1000000
//     1000000 iterations.  Result = 3.141593653589793
// 
// To time the execution:
//     time java DT/PiSerial 1000000
//     1000000 iterations.  Result = 3.141593653589793
//      real	0m0.253s
//      user	0m0.299s
//      sys	0m0.053s

package DT;

public class PiSerial {
	
	private static double f( double x ) {
		return 4.0 / ( 1 + x*x );
	}
	
	public static void main( String[] args ) {
	
		//--- syntax: java -jar PiSerial.jar N ---
		if ( args.length == 0 ) {
			System.out.println( "Syntax: PiSerial N\nwhere N is the number of iterations\n\n" );
			return;
		}
		
		int N = Integer.parseInt( args[0] );
		if ( N==0 ) N = 1000;
		
		double sum = 0;
		double deltaX = 1.0/N;
		
		//--- iterate ---
		for ( int i=0; i<N; i++ ) 
			sum += f( i * deltaX );
		
		System.out.println( N + " iterations.  Result = " + sum*deltaX + "\n\n" );
	}
}

Computing Pi with 2 Threads

This version uses two threads (extending Java Threads). The threads run independently in parallel while the main program waits for them to be done. The main program then gather the two results and stops
.

// PiParallel1.java
// D. Thiebaut
// CSC352 Examples
// Computation of Pi.  This version is parallel and takes a number of iterations to go 
// through from the command line and sums up terms to yield an approximation of Pi.
// It  uses two threads (extending Java Threads).  The threads run independently in parallel 
// while the main program waits for them to be done.  
// The main program then gather the two results and stops
// 
// To compile and run
//     javac DT/PiParallel1.java
//     java DT/PiSerial 1000000
//    1000000 iterations.  Result = 3.1415936535895885
// To time the execution:
//     time java DT/PiSerial 1000000
//     1000000 iterations.  Result = 3.1415936535895885
//     real	0m0.248s
//     user	0m0.331s
//     sys	0m0.057s

package DT;

public class PiParallel1 {
	
	public static void main( String[] args ) {
		//--- syntax: java -jar PiSerial.jar N ---
	    if ( args.length == 0 ) {
	            System.out.println( "Syntax: PiParallel1 N\nwhere N is the number of iterations\n\n" );
	            return;
	    }
	    
	    int N = Integer.parseInt( args[0] );
	    if ( N==0 ) N = 1000000;
	    //System.out.println( "N = " + N );
	    
	    //--- create two threads ---
		PiThread t1 = new PiThread( N, 0, N/2 );
		PiThread t2 = new PiThread( N, N/2, N );
		
		//--- start two threads ---
		t1.start();
		t2.start();
		
		//--- wait till they finish ---
		try {
			t1.join();
			t2.join();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		//--- get results and sum up ---
		 System.out.println( N + " iterations.  Result = " + (t1.getResult() + t2.getResult()) + "\n\n" );
	}
}

/**
 * PiThread.  A thread that computes a section of the area defining the
 * approximation of Pi.
 */
class PiThread extends Thread {
	private int N;			// the total number of samples/iterations 
	private int start;		// where this thread should start (included)
	private int stop;		// where this thread should stop iterating (excluded)
	private double result;	// the part of the approximation computed.
	
	
	/**
	 * Constructor.
	 * @param n:	the total number of samples used by the main program.
	 * @param sta	the starting point for the iterations
	 * @param sto	the stopping point for the iterations
	 */
	public PiThread( int N, int start, int stop ) {
		super( "Thread-"+start+"-"+stop ); // give a name to the thread
		this.N 		= N;
		this.start 	= start;
		this.stop 	= stop;
	}
	
	/**
	 * inspector. 
	 * @return result computed.
	 */
	public double getResult() {
		return result;
	}

	/**
	 * the function that computes the elementary term
	 * @param x
	 * @return
	 */
	double f( double x ) {
		return 4.0 / ( 1 + x*x );
	}
	
	/**
	 * the main RUN() method of the thread.  It will be automatically called
	 * by start().  Does all the work, iterating from start to stop and putting
	 * the finished slice of the sum in result.
	 */
	@Override
	public void run() {
		//System.out.println( getName() + " starting..." );
		result = 0;
		double deltaX = 1.0/N;
		for ( int i=start; i<stop; i++ ) 
			result += f( i*deltaX );
				
		result *= deltaX;
		//System.out.println( getName() + " done: partial result = " + result );
	}

}