trying to fix possibly a memory issue? - c

Question

I'm running a 4x4 matrix in my code. Sometimes I get the correct answer, sometimes I get some of the right solution and the rest is weird numbers. For instance, my matrices are both
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
My solution should be
10 20 30 40
10 20 30 40
10 20 30 40
10 20 30 40
but sometimes I get
10 20 30 40
10 20 30 40
10 20 20 20
10 20 30 40
I believe I have a memory problem but I'm not sure how to fix it. I have tried deallocating memory but it didn't change anything, however, I could have put it in the wrong place.
Heres my code
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
//Create a typedef to pass vectors into the dot product
typedef struct {
int L;
float *v1;
float *v2;
} dotVectors;
//Prototype for the readMatrix method
float** readMatrix(int *nRows, int *nCols,FILE* f);
//Threaded dot product
void* pDotProduct(void *p){
//Recast the void pointer to a dotVectors pointer
dotVectors *p1 = (dotVectors*) p;
//Get all the stuff where the pointer is pointing
int L = p1->L;
float *v1 = p1->v1;
float *v2 = p1->v2;
float *sum = (float*)malloc(sizeof(float));
//Do the dot product
*sum=0;
int i; for(i=0;i<L;i++){
*sum+=v1[i]*v2[i];
} free(v2);
//Return the sum
pthread_exit((void*)sum);
}
//Creates an empty matrix with r rows and c columns
float** createFloatMatrix(int r, int c) {
float** newMatrix =(float**)malloc(r*sizeof(float*));
int i;
for(i=0; i<c; i++) newMatrix[i]=(float*)malloc(c*sizeof(float));
return newMatrix;
}
//Initializes a matrix with "value"
void initMatrix(float **M, int r, int c, float value){
int i,j;
for (i=0; i<r; i++)
for(j=0; j<c; j++)
M[i][j]=value;
}
//Prints out a matrix with r rows and c columns
void printMatrix(float** m, int r, int c) {
int i,j;
for(i=0;i<r;i++){
for(j=0; j<c; j++){ printf("%g ", m[i][j]);}
printf("\n");}
}
main() {
float **m1,**m2;
int i,j,r1,c1,r2,c2;
//Read in the first matrix from a file M1
FILE* f;
f=fopen("m1","r");
//Reads the matrices from standard input - one file at a time
m1 = readMatrix(&r1,&c1,f);
fclose(f);
//Read in a second matrix from a file M2
f=fopen("m2","r");
m2 = readMatrix(&r2,&c2,f);
fclose(f);
//*************//
pthread_t t[r1][c2];
//****************//
//Create a dotVectors and fill it in
int cr=c1; int rc; int k;
for(i=0;i<r1;i++){
for(j=0;j<c2;j++){
dotVectors *d= (dotVectors*)malloc(sizeof(dotVectors));
//Create a vector to store the jth column of the second matrix
float* temp = (float*)malloc(cr*sizeof(float));
for(k=0; k<cr; k++){ temp[k]=m2[k][j];}
d->L=c1;
d->v1=m1[i];
d->v2=temp;
rc = pthread_create(&t[i][j],NULL,pDotProduct,(void*)d);
}
}
//****************//
void* dp;
float** result=createFloatMatrix(r1,c2);
//initMatrix(result, r1, c2, 0);
for(i=0;i<r1;i++){
for(j=0;j<c2;j++){
pthread_join(t[i][j],&dp);
result[i][j] = *((float*)dp);
}
}printMatrix(result, r1,c2);
pthread_exit(NULL);
}
//Read a matrix from a file f
float** readMatrix(int *nRows, int *nCols, FILE* f) {
int i=0;
int j=0;
int k=0;
char c;
*nRows=1; //The number of rows
*nCols=1; //The number of columns
float nums[30][30];
char* num;
while(1) {
//Read in the numbers on a row
j=0; // j = the index of the number on the row - start at zero
while(1) {
//We will re-use the index i, so set to zero
i=0;
num = (char*)malloc(10*sizeof(char));
//Read characters from standard input until a space or EOL
while((c=getc(f))!=' ' && c!=10 && c!=EOF ) {
num[i++]=c;
}
//Null terminate the array of characters
num[i]=0;
//Changes the array of characters to a float
nums[k][j++]=atof(num);
//If we are at the end of the line or end of file - break
if( c==10 || c==EOF) break;
//Set the number of numbers
(*nCols)=j+1;
}
//Stop if you are at the end of file
if (c==EOF) break;
//Go to the next row
k++;
} //End while(1) outer loop
*nRows=k;
//Allocate memory for the row pointers
float** retMat = (float**)malloc((*nRows)*sizeof(float*));
//Allocate memory for the rows themselves
for(i=0; i<(*nRows); i++) retMat[i]=(float*)malloc((*nCols)*sizeof(float));
//Copy the nums matrix into the return matrix
for(i=0; i<(*nRows); i++) for(j=0; j<(*nCols); j++) retMat[i][j]=nums[i][j];
return retMat;
If I run through the debugger twenty or so times I get a segmentation fault that says it's in pthread_join (). But I do not see how it could be. Does anyone have any advice or help on this issue?

Answer 1

I just compiled this (missing a } at the end of your listing) with gcc -g -lpthread, then ran the resulting executable through valgrind. It generated lots of errors (memory allocated but not freed) but no segmentation faults - and the output was correct.
I definitely recommend getting this to work properly without threading first. You want to re-think your memory allocation strategy. For example, you can create a block of memory all at once, then create an array of pointers to it. This is what Numerical Recipes in C does - it allows you to "fake" a variable length 2D matrix. For each create you need a free as well. And make sure you keep track of rows vs columns. In your original code for creating an rxc matrix, you actually created cxc space - so if you had called it with r>c you would have had a segmentation fault just from that...
Example of doing this "better":
float** createFloatMatrix(int r, int c) {
float** newMatrix =(float**)malloc(r*sizeof(float*));
newMatrix[0] = malloc(r*c*sizeof (float) );
for(i=1; i<r; i++) newMatrix[i]=newMatrix[0] + i*c;
return newMatrix;
}
And the corresponding
void freeFloatMatrix(float** m) {
free(m[0]); // this frees the whole block
free(m); // this frees the array of pointers
}
Of course your readMatrix function is doing some horrible things - it is assuming that the input matrix cannot be larger than 30x30 but doesn't test to make sure that it stays in bounds; when you create a return matrix you don't use your own createFloatMatrix function, ...
Finally - it seems like you are doing matrix multiplication in an incredibly complex way. The following would appear to do the same thing, but in fewer lines. Is there a reason why you don't do it this way?
#include <stdio.h>
#include <stdlib.h>
//Prototypes
float** readMatrix(int *nRows, int *nCols,FILE* f);
void freeFloatMatrix(float**);
//Prints out a matrix with r rows and c columns
void printMatrix(float** m, int r, int c) {
int i,j;
for(i=0;i<r;i++) {
for(j=0; j<c; j++) {
printf("%g ", m[i][j]);
}
printf("\n");
}
}
// rewritten function for allocating float matrix:
float** createFloatMatrix(int r, int c) {
int i;
float** newMatrix =(float**)malloc(r*sizeof(float*));
newMatrix[0] = malloc(r*c*sizeof (float) );
for(i=1; i<r; i++) newMatrix[i]=newMatrix[0] + i*c;
return newMatrix;
}
// need a function to free the matrix!!
void freeFloatMatrix(float** m) {
free(m[0]); // this frees the whole block
free(m); // this frees the array of pointers
}
int main(void) { // <<<< let's get the signature right...
float **m1,**m2;
int i,j,r1,c1,r2,c2;
//Read in the first matrix from a file M1
FILE* f;
f=fopen("m1","r");
m1 = readMatrix(&r1,&c1,f);
fclose(f);
//Read in a second matrix from a file M2
f=fopen("m2","r");
m2 = readMatrix(&r2,&c2,f);
fclose(f);
// make sure that the dimensions match up:
if(c1 == r2) {
float temp, **m3;
int ii, jj, kk;
m3 = createFloatMatrix(r1, c2);
for(ii = 0; ii < r1; ii++) {
for(jj = 0; jj < c2; jj++) {
temp = 0;
for(kk = 0; kk < c1; kk++) {
temp += m1[ii][kk] * m2[kk][jj];
}
m3[ii][jj] = temp;
}
}
printf("The product of the matrices is:\n");
printMatrix(m3, r1, c2);
freeFloatMatrix(m3);
}
else printf("dimensions don't match!\n");
freeFloatMatrix(m2);
freeFloatMatrix(m1);
return 0;
}
//Read a matrix from a file f
float** readMatrix(int *nRows, int *nCols, FILE* f) {
int i=0;
int j=0;
int k=0;
char c;
*nRows=1; //The number of rows
*nCols=1; //The number of columns
float nums[30][30];
char num[10];
while(1) {
//Read in the numbers on a row
j=0; // j = the index of the number on the row - start at zero
while(1) {
//We will re-use the index i, so set to zero
i=0;
//Read characters from standard input until a space or EOL
while((c=getc(f))!=' ' && c!=10 && c!=EOF && i < 10) {
num[i++]=c;
}
//Null terminate the array of characters
num[i]=0;
//Changes the array of characters to a float
nums[k][j++]=atof(num);
//If we are at the end of the line or end of file - break
if( c==10 || c==EOF || j == 30) break;
//Set the number of numbers
(*nCols)=j+1;
}
//Stop if you are at the end of file
if (c==EOF) break;
//Go to the next row
k++;
if (k == 30) break;
} //End while(1) outer loop
*nRows=k;
//Allocate memory for the row pointers using the function we defined before
float** retMat = createFloatMatrix(*nRows, *nCols);
return retMat;
}
Note - there are plenty of other places where this code can be improved... but at least the above will do an OK job of matrix multiplication when you have well conditioned inputs which do not exceed the size you assumed in your code.
Once you convince yourself that this works you could consider adding threading at some level - assuming that your assignment includes making this code multi-threaded. My personal approach would be to #include <omp.h> and just add #pragma omp for in the appropriate place, but then I'm lazy when it comes to multi-threading.