/* This exmple illustrates the use of mutex variables in a thread program that performs
* a dot product. The main data is made available to all threads though a globally accessible
* structure Each thread works on a different part of the data. The main thread waits for all
* the threads to compete their computations, and then it prints the resulting sum
*/

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

/* The structure containing the necessary information to allow the function
* "dotprod" to access its input data and place its output into the structure
*/

typedef struct
{
 double *a;
 double *b;
 double sum;
 int veclen;
}DOTDATA;

/*Globally accessible variables and a mutex*/
#define NUMTHRDS 4
#define VECLEN 100

//structure variable
DOTDATA dotstr;
//pthread_t is an opaque type which acts as a handle for the new thread
pthread_t callThd[NUMTHRDS];
//a mutex variable
pthread_mutex_t mutexsum;

/* The function dotprod is activated when the thread is created.
* All input to this routine is obtained from a structure of type
* DOTDATA(shared data) and all output from this function is written
* into this structure. The benefit of this approach is apparent for the
* multi-thread program: when a thread is created we pass a single argument
* to the activated function - typically this argument is a thread number. All
* the other information required is accessed from the globally accessible strcture
*/
void *dotprod(void *arg)
{
 //local variables
 int i, start, end, len;
 long offset;
 double mysum, *x, *y;
 offset = (long) arg;

 len = dotstr.veclen;
 start = offset * len;
 end = start + len;
 x = dotstr.a;
 y = dotstr.b;

 /*
 Perform the dot product and assign result
 to the appropriate variable in the structure
 */
 mysum = 0;
 for(i = start; i < end; i++)
 {
  mysum += (x[i] * y[i]);
 }

 /*
 Lock a mutex prior to updating the value in the shared
 structure, and unlock it upon updating
 */
 pthread_mutex_lock(&mutexsum);
 dotstr.sum += mysum;
 pthread_mutex_unlock(&mutexsum);

 pthread_exit((void*) 0);

 return 0;
}

/*
The main program creates threads which do all the work and then
print out result upon completion. Before creating the threads, the
input data is created. Since all threads update a shared structure,
we need a mutex for mutual exclusion. The main thread needs to wait for
all threads to complete, it waits for each one of the threads. We specify
a thread attribute value that allow the main thread to join with the
threads it creates. Note also that we feed up handles when they are no
longer needed.
*/
int main(int argc, char *argv[])
{
 long i;
 double *a, *b;
 void *status;
 pthread_attr_t attr;

 a = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double));
 b = (double*) malloc (NUMTHRDS*VECLEN*sizeof(double));

 for (i=0; i<VECLEN*NUMTHRDS; i++)
 {
  a[i]=1.0;
  b[i]=a[i];
 }

 dotstr.veclen = VECLEN;
 dotstr.a = a;
 dotstr.b = b;
 dotstr.sum=0;

 pthread_mutex_init(&mutexsum, NULL);

 /* Create threads to perform the dotproduct  */
 pthread_attr_init(&attr);
 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

 for (i = 0; i < NUMTHRDS; i++)
 {
  /*
  Each thread works on a different set of data.
  The offset is specified by 'i'. The size of the
  data for each thread is indicated by VECLEN
  */
  pthread_create(&callThd[i], &attr, dotprod, (void *)i);
  printf("In main: creating thread %ld\n", i);
 }

 pthread_attr_destroy(&attr);

 /* Wait on the other threads */
 for(i=0; i<NUMTHRDS; i++)
 {
  pthread_join(callThd[i], &status);
 }

 /* After joining, print out the results and cleanup */
 printf ("Sum =  %f \n", dotstr.sum);
 free (a);
 free (b);
 pthread_mutex_destroy(&mutexsum);
 pthread_exit(NULL);

 return 0;
}