pthreads/matrixmul/matrixmul.c

   1 /*
   2  * Compile with:
   3  * gcc matrixmul.c -o matrixmul -lpthread -Wall -W -Wextra -ansi -pedantic
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <pthread.h>
   9
  10 typedef struct matrix {
  11     size_t rows;
  12     size_t cols;
  13     int **data;
  14 } matrix_t;
  15
  16 typedef struct matrix_index {
  17     size_t row;
  18     size_t col;
  19 } matindex_t;
  20
  21 typedef enum {
  22     MM_OK,
  23     MM_ENOMEM,
  24     MM_EIO
  25 } mmret_t;
  26
  27 matrix_t *mat1, *mat2, *mat3;
  28
  29 /* Function prototypes */
  30 mmret_t matrix_alloc(matrix_t **mat, size_t rows, size_t cols);
  31 void matrix_free(matrix_t **mat);
  32 mmret_t matrix_read(const char *path, matrix_t **mat);
  33 void matrix_print(const matrix_t *mat);
  34 void *mulvect(void *arg);
  35 void diep(const char *s);
  36
  37 int main(int argc, char *argv[])
  38 {
  39     pthread_t *tid;
  40     matindex_t *v;
  41     size_t i, j, k, mdepth, numthreads;
  42
  43     /* Check argument count */
  44     if (argc != 3) {
  45         fprintf(stderr, "Usage: %s matfile1 matfile2\n", argv[0]);
  46         exit(EXIT_FAILURE);
  47     }
  48
  49     /*
  50      * Initialize `mdepth' variable
  51      *
  52      * We increase `mdepth' every time we succesfully call malloc().
  53      * That way we can keep track of the "allocation depth" and easily
  54      * free the memory whenever needed, e.g. if a fatal error occurs.
  55      */
  56     mdepth = 0;
  57
  58     /* Read matrix data from files */
  59     if (matrix_read(argv[1], &mat1) != MM_OK)
  60         goto CLEANUP_AND_EXIT;
  61     mdepth++;
  62
  63     if (matrix_read(argv[2], &mat2) != MM_OK)
  64         goto CLEANUP_AND_EXIT;
  65     mdepth++;
  66
  67     /* Is the multiplication feasible by definition? */
  68     if (mat1->cols != mat2->rows) {
  69         fprintf(stderr, "Matrices' dimensions size must satisfy (NxM)(MxK)=(NxK)\n");
  70         goto CLEANUP_AND_EXIT;
  71     }
  72
  73     /* Allocate memory for the result */
  74     if (matrix_alloc(&mat3, mat1->rows, mat2->cols) != MM_OK)
  75         goto CLEANUP_AND_EXIT;
  76     mdepth++;
  77
  78     /* How many threads do we need ? */
  79     numthreads = mat1->rows * mat2->cols;
  80
  81     /* v[k] holds the (i, j) pair in the k-th computation */
  82     if ((v = malloc(numthreads * sizeof *v)) == NULL) {
  83         perror("malloc");
  84         goto CLEANUP_AND_EXIT;
  85     }
  86     mdepth++;
  87
  88     /* Allocate memory for the threads' ids */
  89     if ((tid = malloc(numthreads * sizeof *tid)) == NULL) {
  90         perror("malloc");
  91         goto CLEANUP_AND_EXIT;
  92     }
  93     mdepth++;
  94
  95     /* Create the threads */
  96     for (i = 0; i < mat1->rows; i++) {
  97         for (j = 0; j < mat2->cols; j++) {
  98             k = i*mat1->rows + j;
  99             v[k].row = i;
 100             v[k].col = j;
 101             if (pthread_create(&tid[k], NULL, mulvect, (void *)&v[k])) {
 102                 perror("pthread_create");
 103                 goto CLEANUP_AND_EXIT;
 104             }
 105         }
 106     }
 107
 108     /* Make sure all threads are done  */
 109     for (i = 0; i < numthreads; i++)
 110         if (pthread_join(tid[i], NULL)) {
 111             perror("pthread_join");
 112             goto CLEANUP_AND_EXIT;
 113         }
 114
 115     /* Print the result */
 116     matrix_print(mat3);
 117
 118  CLEANUP_AND_EXIT:;
 119     switch(mdepth) {
 120     case 5: free(tid);
 121     case 4: free(v);
 122     case 3: matrix_free(&mat3);
 123     case 2: matrix_free(&mat2);
 124     case 1: matrix_free(&mat1);
 125     case 0:  ;    /* free nothing */
 126     }
 127
 128     return EXIT_SUCCESS;
 129 }
 130
 131 mmret_t matrix_alloc(matrix_t **mat, size_t rows, size_t cols)
 132 {
 133     size_t i, j, mdepth = 0;
 134
 135     *mat = malloc(sizeof **mat);
 136     if (*mat == NULL)
 137         goto CLEANUP_AND_RETURN;
 138     mdepth++;
 139
 140     (*mat)->rows = rows;
 141     (*mat)->cols = cols;
 142
 143     (*mat)->data = malloc(rows * sizeof(int *));
 144     if ((*mat)->data == NULL)
 145         goto CLEANUP_AND_RETURN;
 146     mdepth++;
 147
 148     for (i = 0; i < rows; i++) {
 149         (*mat)->data[i] = malloc(cols * sizeof(int));
 150         if ((*mat)->data[i] == NULL) {
 151             if (i != 0)
 152                 mdepth++;
 153             goto CLEANUP_AND_RETURN;
 154         }
 155     }
 156
 157     return MM_OK;
 158
 159  CLEANUP_AND_RETURN:;
 160     perror("malloc");
 161     switch(mdepth) {
 162     case 3: for (j = 0; j < i; j++) free((*mat)->data[j]);
 163     case 2: free((*mat)->data);
 164     case 1: free(*mat);
 165     case 0:  ;    /* free nothing */
 166     }
 167
 168     return MM_ENOMEM;
 169 }
 170
 171 void matrix_free(matrix_t **mat)
 172 {
 173     size_t i;
 174
 175     for (i = 0; i < (*mat)->rows; i++)
 176         free((*mat)->data[i]);
 177
 178     free((*mat)->data);
 179     free(*mat);
 180 }
 181
 182 mmret_t matrix_read(const char *path, matrix_t **mat)
 183 {
 184     FILE *fp;
 185     size_t i, j, rows, cols;
 186
 187     /* Open file */
 188     if ((fp = fopen(path, "r")) == NULL) {
 189         fprintf(stderr, "Error opening file: %s\n", path);
 190         return MM_EIO;
 191     }
 192
 193     /* Read matrix dimensions */
 194     fscanf(fp, "%u%u", &rows, &cols);
 195
 196     /* Allocate memory for matrix */
 197     if (matrix_alloc(mat, rows, cols) == MM_ENOMEM) {
 198         fclose(fp);
 199         return MM_ENOMEM;
 200     }
 201
 202     /* Read matrix elements */
 203     for (i = 0; i < (*mat)->rows; i++) {
 204         for (j = 0; j < (*mat)->cols; j++) {
 205             fscanf(fp, "%d", &(*mat)->data[i][j]);
 206         }
 207    }
 208
 209     /* Close file */
 210     fclose(fp);
 211
 212     return MM_OK;
 213 }
 214
 215 void matrix_print(const matrix_t *mat)
 216 {
 217     size_t i, j;
 218
 219     for (i = 0; i < mat->rows; i++) {
 220         for (j = 0; j < mat->cols; j++) {
 221             printf("%d ", mat->data[i][j]);
 222         }
 223         printf("\n");
 224     }
 225 }
 226
 227
 228 void *mulvect(void *arg)
 229 {
 230     size_t i, row, col;
 231
 232    row = *((int *)arg + 0);
 233    col = *((int *)arg + 1);
 234
 235    mat3->data[row][col] = 0;
 236    for (i = 0; i < mat1->cols; i++)
 237       mat3->data[row][col] += mat1->data[row][i] * mat2->data[i][col];
 238
 239    pthread_exit(NULL);
 240 }
 241
 242 void diep(const char *s)
 243 {
 244     perror(s);
 245     exit(EXIT_FAILURE);
 246 }