[Introduction] Solution 2 : Compute PI

This material is part of the course Practical Introduction to Parallel Programming and meant for educational purposes only.

Background

The area of a circle of radius \(R\) is \(\pi R^2\), the area of a square with side length \(2R\) is \(4R^2\). If the circle is inscribed inside the square then the ratio of both areas is \(\pi/4\).

Monte Carlo method

If we pick \(N\) points at random inside the square and count the number of points that are inside the circle (\(M\)) then we can compute the approximation \(\pi\approx 4M/N\).

02-compute-pi-introduction_sol/Pi_mc.png

Functions in `minimpi.h`

/* Initialization of parallel communication                   */
void init()

/* Finalization of parallel communication                     */
void finalize()

/* Get the total number of processors involved                */
int get_total_proc_number()

/* Get the number of the current processor                    */
int get_my_proc_number()

/* Send an integer to processor dest                          */
/* value  IN   Integer to be sent.                            */
/* dest   IN   Processor number to which the integer is sent. */
void send_int ( int value, int dest );

/* Receive an integer from processor source                   */
/* value  OUT  Pointer to the integer to be received.         */
/* source IN   Processor from which the message is received.  */
void recv_int ( int* value, int source );

Paste this command into your terminal:

The password to connect is

Question 1: Compute PI

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

#include "minimpi.h"

/* ---------------------------------------------------------------------
 * global variables, constants and types
 * ------------------------------------------------------------------ */

struct                      conf
{
  int                       steps;
};

typedef struct conf       conf_t;

/* ---------------------------------------------------------------------
 * error()
 * ------------------------------------------------------------------ */

void                      error

  ( const char*             fmt, ... )

{
  va_list  ap;

  va_start  ( ap, fmt );
  fprintf   ( stderr, "\n*** ERROR: " );
  vfprintf  ( stderr, fmt, ap );
  fprintf   ( stderr, "\n\n" );
  va_end    ( ap );
  MPI_Abort ( MPI_COMM_WORLD, 1 );
  exit      ( 1 );
}

/* ---------------------------------------------------------------------
 * parse_args()
 * ------------------------------------------------------------------ */

void parse_args

  ( conf_t*                 conf,
    int                     argc,
    char**                  argv )

{
    int  iarg;

    /* Set default values. */

    conf->steps  = 1000;

    for ( iarg = 1; iarg < argc; iarg++ )
    {
        if ( strcmp( argv[iarg], "--steps" ) == 0 )
        {
            iarg++;

            if ( iarg >= argc )
            {
                error ( "no number of steps specified" );
            }

            if ( sscanf( argv[iarg], " %d", &conf->steps ) != 1 ||
                 (conf->steps < 0) )
            {
                error ( "invalid number of steps specified" );
            }

            continue;
        }
    }
}

/* ---------------------------------------------------------------------
 * main()
 * ------------------------------------------------------------------ */

int                       main

  ( int                     argc,
    char**                  argv )

{
    conf_t       conf;
    int          i;
    int          M=0;
    int          nproc;
    int          my_proc;

    /* Initialization */
    init();

    nproc = get_total_proc_number ();
    my_proc = get_my_proc_number ();

    parse_args ( &conf,  argc,  argv );

    /* Monte Carlo calculation of PI */
    for (i=0; i<conf.steps; i++)
    {
        double x = rand()/(double)RAND_MAX;
        double y = rand()/(double)RAND_MAX;

        if (x*x + y*y < 1.0)
            M++;
    }

    /* Output */
    if ( my_proc == 0 )
    {
      printf("Sequential approximation of PI = %g\n", 4*M/(double)conf.steps);
    }

    srand ( my_proc );

    M     = 0;

    /* Run by all processes */
    for (i=0; i<conf.steps/nproc; i++)
    {
        double x = rand()/(double)RAND_MAX;
        double y = rand()/(double)RAND_MAX;

        if (x*x + y*y < 1.0)
            M++;
    }

    /* Send data to master */
    if (my_proc == 0)
    {
        int  itmp;
        int  iproc;

        for ( iproc = 1; iproc < nproc; iproc++ )
        {
          recv_int(&itmp, iproc);
          M += itmp;
        }
    }
    else
    {
        send_int(M, 0);
    }

    /* Finalization */
    finalize();

    /* Output */
    if ( my_proc == 0 )
    {
      printf("Parallel approximation of PI = %g\n", 4*M/(double)conf.steps);
    }

    return 0;
}

Question 2: Number of MPI processes

Specify the number of MPI processes (1-64) that should be used for running your program (mpirun -np <nproc>)

Question 3: Command Line Argument

Specify the command line arguments that should be passed to your program when it is run. Arguments must be given in quotes and separated by commas. Leave this filed empty if you do not want to specify command line arguments.

Example: "1","int","arg=2" is interpreted as three arguments 1, int, and arg=2.

Author(s)	Erik-Jan Lingen, Matthias Möller
Deadline	Keine Frist
Submission limit	No limitation

Information

Sign in