我一直在尝试为pthreads制作一个点积程序，但遇到了一些困难。当我试图运行程序时，遇到了分段错误。我用c来编码。
我的程序最初使用这个代码：
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);
}
然后我改变了内存分配，因为我不希望通过增加线程数来增加总和。
这是更改后的代码：
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);
}
这是我的全部代码：
#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);
}
在初始代码中，dot.size和SIZE是相同的，向量大小为SIZE * THREAD_COUNT。所以，如果你有4个线程，每个线程做5次乘法，那么向量大小是20。
在新代码中，SIZE现在是向量大小，您正试图在THREAD_COUNT线程之间分配工作。因此dot.size需要是SIZE / THREAD_COUNT。因此，如果SIZE是20，而THREAD_COUNT是4，则dot.size需要是20/4=5。