Así que he estado jugando con pthreads, específicamente tratando de calcular el producto de dos matrices. Mi código es extremadamente complicado, ya que se acaba supone que es un proyecto divertido poco rápido para mí, pero la teoría hilo que utilicé fue muy similar a:Multiplicación de matriz con subprocesos: ¿Por qué no es más rápido?
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define M 3
#define K 2
#define N 3
#define NUM_THREADS 10
int A [M][K] = { {1,4}, {2,5}, {3,6} };
int B [K][N] = { {8,7,6}, {5,4,3} };
int C [M][N];
struct v {
int i; /* row */
int j; /* column */
};
void *runner(void *param); /* the thread */
int main(int argc, char *argv[]) {
int i,j, count = 0;
for(i = 0; i < M; i++) {
for(j = 0; j < N; j++) {
//Assign a row and column for each thread
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 */
pthread_t tid; //Thread ID
pthread_attr_t attr; //Set of thread attributes
//Get the default attributes
pthread_attr_init(&attr);
//Create the thread
pthread_create(&tid,&attr,runner,data);
//Make sure the parent waits for all thread to complete
pthread_join(tid, NULL);
count++;
}
}
//Print out the resulting matrix
for(i = 0; i < M; i++) {
for(j = 0; j < N; j++) {
printf("%d ", C[i][j]);
}
printf("\n");
}
}
//The thread will begin control in this function
void *runner(void *param) {
struct v *data = param; // the structure that holds our data
int n, sum = 0; //the counter and sum
//Row multiplied by column
for(n = 0; n< K; n++){
sum += A[data->i][n] * B[n][data->j];
}
//assign the sum to its coordinate
C[data->i][data->j] = sum;
//Exit the thread
pthread_exit(0);
}
fuente: http://macboypro.com/blog/2009/06/29/matrix-multiplication-in-c-using-pthreads-on-linux/
Para los no roscada versión, utilicé la misma configuración (3 matrices de 2 d, estructuras dinámicamente asignadas para mantener r/c) y agregué un temporizador. Los primeros ensayos indicaron que la versión sin hilos era más rápida. Lo primero que pensé fue que las dimensiones eran demasiado pequeñas para notar una diferencia, y se tardó más tiempo en crear los hilos. Así que aumenté las dimensiones a aproximadamente 50x50, llené aleatoriamente y lo ejecuté, y todavía no veo ninguna actualización de rendimiento con la versión enhebrada.
¿Qué me falta aquí?
¿En qué tipo de procesador lo está ejecutando? Si no es multiproceso o de doble núcleo, no verá ninguna ventaja de usar múltiples hilos. De hecho, la conmutación de contexto que debe tener lugar para ejecutar ambos subprocesos simultáneamente puede dañar el rendimiento. –
Una matriz de 50x50 es demasiado pequeña para las computadoras modernas. Si está buscando problemas de rendimiento, tendrá que pasar a tamaños mucho más grandes: decenas de miles de filas y columnas. Entonces, es importante buscar optimizaciones (con multihilo, por ejemplo). – PeterK