[Threads] Solution 3 : 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\).

Hints

Use the conf_t data type to obtain the number of iterations \(N\) and the number of threads from the command-line arguments passed to the program.

Call the function parse_args to parse the command line arguments.

Pass the conf object to each thread so that it knows how many iterations it should execute.

Use malloc to allocate an array of thread identifiers in the main thread.

Test your program with the command-line arguments: "--niter","40000","--nthreads","4".

Copiez-collez cette commande dans votre terminal :

Le mot de pase pour se connecter est

Question 1: Compute PI

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

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

struct                    conf
{
  int                       niter;
  int                       nthreads;
};

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 );
  exit     ( 1 );
}

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

void parse_args

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

{
  int  iarg;

  /* Set default values. */

  conf->niter    = 1000;
  conf->nthreads = 1;

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

      if ( iarg >= argc )
      {
        error ( "missing number of iterations" );
      }

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

      continue;
    }

    if ( strcmp( argv[iarg], "--nthreads" ) == 0 )
    {
      iarg++;

      if ( iarg >= argc )
      {
        error ( "missing number of threads" );
      }

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

      continue;
    }

    error ( "invalid argument: %s", argv[iarg] );
  }

  /* Make sure that the number of iterations is divisible by the
   * number of threads. */

  conf->niter = (conf->niter / conf->nthreads) * conf->nthreads;
}

/* ---------------------------------------------------------------------
 * thread_func()
 * ------------------------------------------------------------------ */

void*                     thread_func

  ( void*                   arg )

{
  conf_t*  conf   = (conf_t*) arg;
  int*     result = (int*) malloc ( sizeof(int) );
  int      i, m;

  /* Monte Carlo calculation of PI */

  for ( i = 0, m = 0; i < (conf->niter / conf->nthreads); i++ )
  {
    double  x = rand () / (double) RAND_MAX;
    double  y = rand () / (double) RAND_MAX;

    if ( (x*x +  y*y) < 1.0 )
    {
      m++;
    }
  }

  *result = m;

  return result;
}

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

int                       main

  ( int                     argc,
    char**                  argv )

{
  pthread_t*  threads = NULL;
  void*       result  = NULL;
  conf_t      conf;
  int         i, m;

  parse_args ( &conf, argc, argv );

  threads = (pthread_t*) malloc ( conf.nthreads * sizeof(pthread_t) );

  for ( i = 0; i < conf.nthreads; i++ )
  {
    pthread_create ( &threads[i], NULL, thread_func, &conf );
  }

  for ( i = 0, m = 0; i < conf.nthreads; i++ )
  {
    pthread_join ( threads[i], &result );

    m += *((int*) result);

    free ( result );
  }

  free   ( threads );
  printf ( "Parallel approximation of PI = %g.\n",
           4 * m / (double) conf.niter );

  return 0;
}

Question 2: 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.

Auteur(s)	Erik-Jan Lingen, Matthias Möller
Date limite	Pas de date limite
Limite de soumission	Pas de limite

Informations

Se connecter