matrix multiplication using pthreads_create - c

Question

I can't figure out where the problem is. I'm guessing it is either the way I'm using pthread_create or the way I multiply the index. Can someone help me figure it out? I would like to in the same struct I used.
When I compile it, it returns
28 23 18
41 34 27
54 45 36
*** stack smashing detected ./matrix terminated
Aborted (core dumped)
The code:
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#define M 3
#define K 2
#define N 3
int A [M][K] ={{1,4},{2,5},{3,6}};
int B [K][N] ={{8,7,6},{5,4,3}};
int C [M][N];
/* structure for passing data to threads */
struct v
{
int i; /* row */
int j; /* column */
};
void *matrix_multiplication( void *ptr ); //the thread
int main (int argc, char* argv[]){
pthread_t workers[M*N];
int iret1;
int i = 0;
int j = 0;
int a = 1;
/* We have to create M * N worker threads */
for (i = 0; i < M ; i++) {
for (j = 0; j < N; j++){
struct v *data = (struct v *) malloc (sizeof(struct v));
data->i = i;
data->j = j;
/* Now create the thread passing it data as a parameter */
iret1 = pthread_create(&workers[a] , NULL , matrix_multiplication, (void *) data );
a++;
//free(data);
}
}
//wait for all the threads to be finished
for (i = 0; i<10 ; i++){
pthread_join(workers[i], NULL);
}
//printing the matrix
for (i = 0; i < M ; i++) {
for (j = 0; j < N; j++){
printf("%d ",C[i][j] );
}
printf("\n");
}
return 0;
}
void *matrix_multiplication( void *ptr ){
struct v *data = ptr;
int sum = 0, z;
for(z=0; z < K; z++){
sum += A[data->i][z] * B[z][data->j];
}
C[data->i][data->j] = sum;
printf("%d\n",sum );
//threads exit
pthread_exit(0);
}

Answer 1

You have a couple of small errors:
When you create the threads with
pthread_create(&workers[a], ...
a is in the first call already 1, because you've initialized it with 1. That
means that the last pthread_create call will access workers out of
bounds, you are passing a pointer to an undefined address and this is undefined
behaviour. You should initialize a with 0.
The second problem is when you join the threads:
for (i = 0; i<10 ; i++){
pthread_join(workers[i], NULL);
}
Because of a being initialized with 1, worker[0] is not an initialized
thread. The man page does not mention what happens when you pass an
uninitialized thread to pthread_join, but my guess is that it is undefined behaviour and most likely the reason
why you have the segfault. I would also write the condition i < M*N, because
if you change any of those values, you would be accessing workers out of
bounds.
You fail to free the memory for the struct v objects, you would have to do it
after the join. You are leaking memory there. I don't think that you even need
to use malloc here, you can declare an array of dimension M*N of struct v
objects, just like you did with the pthread_t array. When accessing the array,
I'd use i*N+j to calculate the correct index for both arrays.
I modified your code with my corrections and my suggestions:
#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>
#define M 3
#define K 2
#define N 3
int A [M][K] ={{1,4},{2,5},{3,6}};
int B [K][N] ={{8,7,6},{5,4,3}};
int C [M][N];
/* structure for passing data to threads */
struct v
{
int i; /* row */
int j; /* column */
};
void *matrix_multiplication( void *ptr ); //the thread
int main (int argc, char* argv[]){
pthread_t workers[M*N];
struct v data[M*N];
int i = 0;
int j = 0;
/* We have to create M * N worker threads */
for (i = 0; i < M ; i++) {
for (j = 0; j < N; j++){
int idx = i*N+j;
data[idx].i = i;
data[idx].j = j;
/* Now create the thread passing it data as a parameter */
pthread_create(workers + idx, NULL, matrix_multiplication, data+idx);
}
}
//wait for all the threads to be finished
for (i = 0; i<M*N ; i++)
pthread_join(workers[i], NULL);
//printing the matrix
for (i = 0; i < M ; i++) {
for (j = 0; j < N; j++){
printf("%d ",C[i][j] );
}
printf("\n");
}
return 0;
}
void *matrix_multiplication( void *ptr ){
struct v *data = ptr;
int sum = 0, z;
for(z=0; z < K; z++){
sum += A[data->i][z] * B[z][data->j];
}
C[data->i][data->j] = sum;
printf("%d\n",sum );
pthread_exit(0);
}
As you see, I don't use malloc, so I don't have to worry about freeing memory
afterwards. When I run this code, I get:
41
45
18
28
27
34
23
54
36
28 23 18
41 34 27
54 45 36
edit
OP asked in the comment section
How can I free memory If I used malloc for the struct?!
There are different ways, but the first step is to store the pointer that
malloc returns. Right now you are not storing that value.
The first option would be: free the memory in the thread. Let's use your way of
passing values to the threads:
struct v *data = malloc(sizeof(struct v));
data->i = i;
data->j = j;
/* Now create the thread passing it data as a parameter */
pthread_create(&workers[a] , NULL , matrix_multiplication, data);
Every single thread get's an own struct v object and you never use it outside
the thread. That's why you can do this in the thread:
void *matrix_multiplication( void *ptr ) {
...
free(ptr);
pthread_exit(0);
}
Let's say that the parent process needs to get the pointer passed to the thread.
For example because the thread wrote some value there that the main
threads wants to evaluate. Let's say the threads should calculate their
calculation time. Your struct v could look like this:
struct v {
int i;
int j;
double time;
}
The threads would calculate the time and write it on data->time. The
thread can pass to the main thread a pointer through pthread_exit, in this
case you the thread can pass the same pointer it got from the main thread:
#include <time.h>
void *matrix_multiplication( void *ptr ){
struct v *data = ptr;
int sum = 0, z;
clock_t begin = clock();
for(z=0; z < K; z++){
sum += A[data->i][z] * B[z][data->j];
}
C[data->i][data->j] = sum;
clock_t end = clock();
data->time = (double)(end - begin) / CLOCKS_PER_SEC;
//threads exit
pthread_exit(ptr);
}
Now when you joing the threads, you get the pointer you've pass to the thread,
you can use that pointer and then free it if you don't need it anymore.
double agg_time = 0;
for (i = 0; i<M*N ; i++) {
struct v *data;
pthread_join(workers[i], (void**) &data);
printf("i: %d, j: %d ,time: %lf\n", data->i, data->j, data->time);
agg_time += data->time;
free(data);
}
printf("aggregated time: %lf\n", agg_time);
The output of this would be
i: 0, j: 0 ,time: 0.000002
i: 0, j: 1 ,time: 0.000001
i: 0, j: 2 ,time: 0.000002
i: 1, j: 0 ,time: 0.000002
i: 1, j: 1 ,time: 0.000001
i: 1, j: 2 ,time: 0.000001
i: 2, j: 0 ,time: 0.000002
i: 2, j: 1 ,time: 0.000001
i: 2, j: 2 ,time: 0.000014
aggregated time: 0.000026
28 23 18
41 34 27
54 45 36
If you pass a malloced pointer to the threads, this is the one I like the most.
A third option would be to store the malloc data in an array and free it after
the join.
int main(void)
{
...
struct v *data[M*N];
...
for (i = 0; i < M ; i++) {
for (j = 0; j < N; j++) {
int idx = i*N+j;
data[idx] = malloc(sizeof *data[idx]);
data[idx]->i = i;
data[idx]->j = j;
pthread_create(workers + idx, NULL, matrix_multiplication, data[idx]);
}
}
// do the join
for (i = 0; i<M*N ; i++){
pthread_join(workers[i], NULL);
}
// do the free
for(int i = 0; i < M*N; ++i)
free(data[i]);
}
I don't like this version too much, because it makes the code larger, you need
to check that malloc doesn't return NULL (I've omitted this test) and have
an error handling strategy for when it fails. That was the nice thing about my very
first code, you don't do malloc, you don't have to worry about free. However
if you need to pass an allocated block of memory to the thread, I'd do the one
above, where the thread returns the pointer back to the main thread through
pthread_exit.