[Threads] Solution 4 : Compute PI

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

Task

Modify the program that computes \(\pi\) in parallel from the previous exercise so that it uses a shared variable to keep track of the number of points within a unit circle.

That is, instead of defining a counter per thread, define one shared counter.

Use a mutex to avoid race conditions.

Is this new implementation more efficient than the previous one?

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;
};

struct                    counter
{
  pthread_mutex_t           mutex;
  int                       count;
};

struct                    data
{
  struct conf*              conf;
  struct counter*           counter;
};

typedef struct conf       conf_t;
typedef struct counter    counter_t;
typedef struct data       data_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 )

{
  data_t*     data    = (data_t*) arg;
  conf_t*     conf    = data->conf;
  counter_t*  counter = data->counter;
  int         i;

  /* Monte Carlo calculation of PI */

  for ( i = 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 )
    {
      pthread_mutex_lock   ( &counter->mutex );

      counter->count++;

      pthread_mutex_unlock ( &counter->mutex );
    }
  }

  return NULL;
}

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

int                       main

  ( int                     argc,
    char**                  argv )

{
  pthread_t*  threads = NULL;
  counter_t   counter;
  conf_t      conf;
  data_t      data;
  int         i;

  parse_args         ( &conf, argc, argv );
  pthread_mutex_init ( &counter.mutex, NULL );

  counter.count = 0;
  data.conf     = &conf;
  data.counter  = &counter;

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

  printf ( "Starting %d threads ...\n", conf.nthreads );

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

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

  free                  ( threads );
  pthread_mutex_destroy ( &counter.mutex );

  printf ( "Parallel approximation of PI = %g.\n",
           4 * counter.count / (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