Matrice threaddata

/********************************************************
 * matrice_threads.c
 *
 * Il main genera un numero di thread pari al numero delle righe dell'array
 * Ognuno di essi riceve un puntatore a una struct che contengono gli indici
 * necessari per il calcolo. Tutti i thread possono essere eseguiti in parallelo
 * senza problemi di race condition, per cui il miglioramento dipende solo dal PC
 * utilizzato. Il main raccoglie tutti i thread ed esce.
 *
 *
 * Compilare con:
 * gcc -pthread -Wall matrice_threads.c -o matrice_threads
 * Tempo necessario: circa 2 secondi (con 1000 elementi).
 * Per vedere più dettagli (lieve perdita di prestazioni)
 * gcc -DDEBUG -pthread -Wall matrice_threads.c -o matrice_threads
 */

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include "timer.h"

#include <pthread.h>

#define ARRAY_SIZE 1000

typedef int matrix_t[ARRAY_SIZE][ARRAY_SIZE];

typedef struct {
  int       id;
  int       size;
  int       Arow;
  int       Bcol;
  matrix_t  *MA, *MB, *MC;
} package_t;

matrix_t MA,MB,MC;

  /* Riempimento delle matrici */
void initMatrices(int size,
      matrix_t MA,
      matrix_t MB)
{
  int row, column;
  for (row = 0; row < size; row++) {
    for (column = 0; column < size; column++) {
      MA[row][column] = 1;
    }
  }
  for (row = 0; row < size; row++) {
    for (column = 0; column < size; column++) {
      MB[row][column] = row + column + 1;
    }
  }
  printf("Matrici pronte:\n");
}


/* Funzione di aiuto che calcola il prodotto di un'intera riga
 * e pone il risultato nella matrice C */

void mult(int size, int row, matrix_t MA, matrix_t MB, matrix_t MC)
{
  int position, column;
  for (column = 0; column < size; column++){
      MC[row][column] = 0;
          for(position = 0; position < size; position++) {
            MC[row][column] += ( MA[row][position]  * MB[position][column] ) ;
          }
 }
}


/*
 * Funzione che fa partire il calcolo di una riga.
 */
void *mult_worker(void *arg)
{
  package_t *p=(package_t *)arg;
     #ifdef DEBUG
        printf("Thread n. %d: calcola il prodotto della riga  %d di A e la colonna  %d di B\n", p->id, p->Arow, p->Bcol );
     #endif
    mult(p->size, p->Arow, *(p->MA), *(p->MB), *(p->MC));
  free(p);

  return(NULL);
}

int main(int argc, char **argv)
{
  int       size, row, num_threads, i;
  pthread_t *threads;       /* array dinamica che contiene tutto gli id dei threads, in modo da poterli riunire tutti */
  package_t *p;             /* elenco dei parametri da passare a ogni thread */
  size = ARRAY_SIZE;

  /* creazione della matrice dinamica, un thread per ogni riga della matrice. */
  threads = (pthread_t *)malloc(size*sizeof(pthread_t));
  /* Inizializza le matrici */
  initMatrices(size, MA, MB);
  startTime();

  /*
   * Calcolo del prodotto delle matrici, per riga e colonna.
   * (Per dettagli http://it.wikipedia.org/wiki/Moltiplicazione_di_matrici)
   */
  num_threads = 0;
  for(row = 0; row < size; row++) {
      p = (package_t *)malloc(sizeof(package_t));
      p->id = num_threads;
      p->size = size;
      p->Arow = row;
      p->Bcol = 0;
      (p->MA) = &MA;
      (p->MB) = &MB;
      (p->MC) = &MC;

      pthread_create(&threads[num_threads], NULL, mult_worker,  (void *) p);
      num_threads++;
  }

  /* Sincronizza il risultato */
  for (i = 0; i < (size); i++) {
    pthread_join(threads[i], NULL);
    #ifdef DEBUG
        printf("Thread %d riunito al main...\n", i);
    #endif
  }
  stopTime();
  elapsedTime();

  return 0;
}