source: CIVL/examples/translation/pthread/bug6fix.cvl@ 764d472

/*****************************************************************************
* SOURCE: This is a translation of a Pthread program from the Lawrence Livermore
* Computing Center POSIX Threads Programming Exercise at:
* https://computing.llnl.gov/tutorials/pthreads/exercise.html
* FILE: bug6fix.cvl
* DESCRIPTION:
*   This solution uses a mutex variable to protect the global sum while each
*   thread updates it. A much more efficient method would be that used in the
*   dotprod_mutex.cvl example.
* Command line execution:
* civl verify -inputNUMTHRDS=8 -inputVECLEN=100000 bug6fix.cvl
******************************************************************************/

#include <civlc.h>
#include "pthread.h"
#include <stdio.h>
#include <stdlib.h>

/* Define global data where everyone can see them */
$input int NUMTHRDS;
$input int VECLEN;
pthread_mutex_t mutexsum;
int *a, *b; 
long sum=0.0;

void *dotprod(void *arg)
{
  /* Each thread works on a different set of data.
  * The offset is specified by the arg parameter. The size of
  * the data for each thread is indicated by VECLEN.
  */
  int i, start, end, offset, len;
  long tid;
  tid = (long)*arg; // Dereference rather than direct conv
  offset = tid;
  len = VECLEN;
  start = offset*len;
  end   = start + len;

  /* Perform my section of the dot product */
  printf("thread: %d starting. start=%d end=%d\n",tid,start,end-1); // Removed l from %ld, unsupported
  for (i=start; i<end ; i++) {
    pthread_mutex_lock(&mutexsum);
    int tmp = sum; 
    tmp += (a[i] * b[i]); 
    sum = tmp;
    pthread_mutex_unlock(&mutexsum);
  }
  printf("thread: %d done. Global sum now is=%d\n",tid,sum); // Removed l from %ld, unsupported

  pthread_exit(NULL, false, NULL, 0); //Different parameters
}

int main (void)
{
  long i;
  long j[NUMTHRDS];
  void *status;
  pthread_t threads[NUMTHRDS];
  pthread_attr_t attr;

  /* Assign storage and initialize values */
  a = (int*) malloc (NUMTHRDS*VECLEN*sizeof(int));
  b = (int*) malloc (NUMTHRDS*VECLEN*sizeof(int));
  
  for (i=0; i<VECLEN*NUMTHRDS; i++)
    a[i]=b[i]=1;

  /* Initialize mutex variable */
  pthread_mutex_init(&mutexsum, NULL);
         
  /* Create threads as joinable, each of which will execute the dot product
   * routine. Their offset into the global vectors is specified by passing
   * the "i" argument in pthread_create().
   */
  pthread_attr_init(&attr);
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  for(i=0;i<NUMTHRDS;i++){
    //Add values into array and use address so that each value is unique as int to void * conversion is not supported
    j[i] = (long)i;
    pthread_create(&threads[i], &attr, dotprod, (void *)&j[i]); 
  }
  pthread_attr_destroy(&attr);

  /* Wait on the other threads for final result */
  for(i=0;i<NUMTHRDS;i++) {
    pthread_join(threads[i], &status);
  }
  
  /* After joining, print out the results and cleanup */
  printf ("Final Global Sum=%d\n",sum);

  free (a);
  free (b);
  pthread_mutex_destroy(&mutexsum);
  //pthread_exit(NULL);
  return 0;
}