Ive been trying to make a dot product program for pthreads and I've been having some difficulties. Im getting a segmentation fault when I try to run the program. I am using c to code it.
I had the program working initially with this code:
a = (double*) malloc (THREAD_COUNT* SIZE * sizeof(double));
b = (double*) malloc (THREAD_COUNT* SIZE * sizeof(double));
for (i=0; i<SIZE*THREAD_COUNT; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
gettimeofday (&time_start, NULL);
for(i=0;i<THREAD_COUNT;i++)
{
pthread_create(&callThd[i], &attr, dotprod, (void *)i);
}
pthread_attr_destroy(&attr);
for(i=0;i<THREAD_COUNT;i++) {
pthread_join(callThd[i], &status);
}
Then I changed the memory allocation because I didnt want the sum to increase by increasing the thread count.
this is the changed code:
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
gettimeofday (&time_start, NULL);
for(i=0;i<THREAD_COUNT;i++)
{
pthread_create(&callThd[i], &attr, dotprod, (void *)i);
}
pthread_attr_destroy(&attr);
for(i=0;i<THREAD_COUNT;i++) {
pthread_join(callThd[i], &status);
}
This is the entirety of my code:
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h> //gettimeofday()
typedef struct
{
double *a;
double *b;
double sum;
int size;
} DOTPROD;
/* Define globally accessible variables and a mutex */
typedef struct
{
int secs;
int microsecs;
}TIME;
//TIME * time_diff(struct timeval *, struct timeval *);
#define THREAD_COUNT 20
#define SIZE 100000
DOTPROD dot;
pthread_t callThd[THREAD_COUNT];
pthread_mutex_t mutexsum;
void *dotprod(void *arg)
{
/* Define and use local variables for convenience */
int i, start, end, reg_size ;
long offset;
double partsum, *x, *y;
offset = (long)arg;
reg_size = dot.size;
start = offset*reg_size;
end = start + reg_size;
x = dot.a;
y= dot.b; /*
* Perform the dot product and assign result
* to the appropriate variable in the structure.
* */
partsum = 0;
for (i=start; i<end ; i++)
{
partsum += (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);
dot.sum += partsum;
pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0);
}
int main (int argc, char *argv[])
{
long i;
double *a, *b;
void *status;
struct timeval time_start, time_end;
TIME*diff;
pthread_attr_t attr;
/* Assign storage and initialize values */
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
55,16 58%
* Perform the dot product and assign result
* to the appropriate variable in the structure.
* */
partsum = 0;
for (i=start; i<end ; i++)
{
partsum += (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);
dot.sum += partsum;
pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0);
}
int main (int argc, char *argv[])
{
long i;
double *a, *b;
void *status;
struct timeval time_start, time_end;
TIME*diff;
pthread_attr_t attr;
/* Assign storage and initialize values */
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
55,16 58%
* Perform the dot product and assign result
* to the appropriate variable in the structure.
* */
partsum = 0;
for (i=start; i<end ; i++)
{
partsum += (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);
dot.sum += partsum;
pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0);
}
int main (int argc, char *argv[])
{
long i;
double *a, *b;
void *status;
struct timeval time_start, time_end;
TIME*diff;
pthread_attr_t attr;
/* Assign storage and initialize values */
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
55,16 58%
* Perform the dot product and assign result
* to the appropriate variable in the structure.
* */
partsum = 0;
for (i=start; i<end ; i++)
{
partsum += (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);
dot.sum += partsum;
pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0);
}
int main (int argc, char *argv[])
{
long i;
double *a, *b;
void *status;
struct timeval time_start, time_end;
TIME*diff;
pthread_attr_t attr;
/* Assign storage and initialize values */
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
* Perform the dot product and assign result
* to the appropriate variable in the structure.
* */
partsum = 0;
for (i=start; i<end ; i++)
{
partsum += (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);
dot.sum += partsum;
pthread_mutex_unlock (&mutexsum);
pthread_exit((void*) 0);
}
int main (int argc, char *argv[])
{
long i;
double *a, *b;
void *status;
struct timeval time_start, time_end;
TIME*diff;
pthread_attr_t attr;
/* Assign storage and initialize values */
a = (double*) malloc ( SIZE * sizeof(double));
b = (double*) malloc (SIZE * sizeof(double));
for (i=0; i<SIZE; i++) {
a[i]=1;
b[i]=a[i];
}
dot.size = SIZE;
dot.a = a;
dot.b = b;
dot.sum=0;
pthread_mutex_init(&mutexsum, NULL);
/* Create threads to perform the dotproduct */
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
gettimeofday (&time_start, NULL);
for(i=0;i<THREAD_COUNT;i++)
{
pthread_create(&callThd[i], &attr, dotprod, (void *)i);
}
pthread_attr_destroy(&attr);
for(i=0;i<THREAD_COUNT;i++) {
pthread_join(callThd[i], &status);
}
/* After joining, print out the results and cleanup */
gettimeofday (&time_end, NULL);
long long elasped = (time_end.tv_sec - time_start.tv_sec)*1000000LL + time_end.tv_usec - time_start.tv_usec;
printf ("time diff in microseconds = %6d \n",elasped);
printf ("Sum = %f \n", dot.sum);
//diff = time_diff(&time_start, &time_end);
//printf("Time = %d. \%5d.%6d secs. \n", diff->secs, diff -> microsecs);
free (a);
free (b);
pthread_mutex_destroy(&mutexsum);
pthread_exit(NULL);
}