La multiplication de matrice à l'aide de plusieurs threads?

Je suis censé multiplier de 2 matrices à l'aide de threads. Deux choses: je reçois 0 quand je lance le programme. Je reçois aussi des messages d'erreurs(pour chacun d'eux, il dit: "warning: passing argument 1 of 'printMatrix' from incompatible pointer type" sur les lignes en gras(où j'essaie d'imprimer la sortie). Également à noter, le premier bloc qui est en gras, je que c'était ma tentative de résoudre le problème. Je pense que je suis proche, mais je ne peut pas l'être. Quelqu'un peut-il aider? Merci 🙂
La sortie ressemble à ceci:
A=
1 4
2 5
3 6
B=
8 7 6
5 4 3
A*B=
0 0 0
0 0 0
0 0 0

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#define M 3
#define K 2
#define N 3
struct v
{
int i; //row
int j; //column
};
int A[M][K] = {{1,4},{2,5},{3,6}};
int B[K][N] = {{8,7,6},{5,4,3}};
int C[M][N];
void *workerThread(void *data)
{
int i=((struct v*)data)->i;
int j=((struct v*)data)->j;
int accumulator = 0;
/*this is where you should calculate the assigned Cell. You will need to use the row(i) of
A and column[j] of B. Accumulate the result in accumulator */
**int k;
for(k=0; k<k; k++)
{
accumulator = A[i][k]*B[k][j];
}
C[i][j]=accumulator;
pthread_exit(NULL);**
}
void printMatrix(int *matrixIn, int rows, int columns)
{
int *matrix = matrixIn;
int i,j;
for (i=0;i<rows;i++)
{
}
int main (int argc, char *argv[])
{
pthread_t threads[M*N];
int i,j;
int counter = 0;
int numThreadsCreated = 0;
/*the following 5 lines demonstrates how to create 1 thread to calculate C[0][0], you
will need to create a loop for all of C's cells*/
struct v *data = (struct v *)malloc(sizeof(struct v));
data->i = 0; //assign the row of C for thread to calculate
data->j = 0; //assign the column of C for thread to calculate
pthread_create(&threads[0], NULL, workerThread, data);
numThreadsCreated++;
/*wait for all the threads to finish before printing out the matrices*/
for(j=0; j < numThreadsCreated; j++)
{
pthread_join( threads[j], NULL);
}
printf("A=\n");
**printMatrix(A,3,2);**
printf("B=\n");
**printMatrix(B,2,3);**
printf("A*B=\n");
**printMatrix(C,M,N);**
pthread_exit(NULL);
}

Cette ligne est erronée,--->for(k=0; k<k; k++)!
Comment alors? C'était la ligne j'ai été recommandé par quelqu'un d'autre. @shekharsuman
Vérifier ma réponse pour plus de précisions et d'essayer la même chose et puis d'autres commentaires au sujet de votre problème!!!!!!
À moins que votre M et N sont énormes, cela ne va pas être beaucoup d'un rendement gagner. Vous devriez la recherche pour "parallèle de multiplication de matrice" pour voir les différentes approches alternatives au problème lorsque vous traitez avec des matrices de grande taille.

OriginalL'auteur Jay | 2014-10-21

c matrix-multiplication pthreads

1

Votre programme semble avoir mis en œuvre un mauvais codage de l'algorithme de multiplication de matrice.

Le morceau de code suivant semble absurde :-
```
for(k=0; k<k; k++)
{
accumulator = A[i][k]*B[k][j];
}
C[i][j]=accumulator;    //  Not a code for matrix multiplication...
```
Vous devez mettre en place quelque chose comme :-
```
for(i=0;i<M;i++){
for(j=0;j<N;j++){
accumulator=0;
for(int something=0;something<K;something++){
accumulator=accumulator+A[i][something]*B[something][j];
}
C[i][j]=accumulator;
accumulator=0;
}
}
```
J'ai juste essayé ce. J'ai remplacé mon code précédent avec celui que vous avez recommandé. Il me donne ces messages d'erreur ("erreur:" k " non déclaré (première utilisation dans cette fonction)" & ("erreur: (chaque identificateur non déclaré est signalé qu'une seule fois pour chaque fonction, il apparaît dans") @shekharsuman
Vous avez besoin d'utiliser le capital OU de bloquer l'alphabet K au lieu de bas-de-casse k!!! Vous avez #define K=3. Comment peut-il donner d'erreur? Veuillez vérifier votre cas!
Les messages d'erreur se référer à cette ligne: for (int quelque chose = 0; quelque chose<k; quelque chose++)
Eh bien, c'est encore de me donner les mêmes 3 messages d'erreur à l'impression de ces matrices, et aussi un autre message d'erreur de la dernière ligne(fin de support) qui dit: erreur: taux de déclaration ou de déclaration à la fin de l'entrée
Il a travaillé! ... Je pense, il me donne toujours ce message d'erreur, mais il a multiplié.

OriginalL'auteur Am_I_Helpful
0

FWIW... pour une petite matrice le coût de la création de threads et qu'est-ce-pas est susceptible de dire tout cela est une perte de temps... et pour une matrice de grande taille vous semblent commencer M*N threads !!

Puisque l'on peut supposer que cela est liée au calcul, il n'y a pas beaucoup de point de départ à plus de threads qu'il y a de Processeurs à utiliser. Ensuite, chaque thread doit choisir le prochain élément de résultat de calculer, et de s'arrêter quand le résultat est plein. Une façon de le faire serait de passer d'un "contrôle" de la structure à tous les pthreads, le long des lignes de:
```
  struct control
{
pthread_mutex_t   mutex ;
int  q ;
} ;
```
et puis pthread avec fonction de boucle:
```
  while (1)
{
int q, i, j ;
pthread_mutex_lock(&ctrl->mutex) ;
q = ctrl->q ;
ctrl->q += 1 ;
pthread_mutex_unlock(&ctrl->mutex) ;
if (q >= (N * M))
break ;
i = q / K ;
j = q % K ;
....
} ;
```
Atomique chercher et ajouter 1 de q serait faire le travail aussi bien. (NB: suppose que N*M + thread-count <= INT_MAX !)

Vous pouvez, bien sûr, de diviser la N * M résultats de manière statique à travers le nombre de pthreads de commencer, donc passer chacun un différent initiale q et le nombre d'éléments de résultat dont il est responsable (se souvenir pour le reste de la division de N * M par le nombre de pthreads !). Cela évite tous besoin pour les pthreads d'interagir -- donc pas de mutex et pas de atomics nécessaire.

OriginalL'auteur

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
pthread_mutex_t lock;
typedef struct
{
int mat1;
int mat2;
}address;
int matrix1[3][3],matrix2[3][3],result[3][3];
void *matrixOne()
{
int i,j,data=0;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
matrix1[i][j]=data+1;
//         sleep(2);
data=data+1;
}
}
//printf matrix
printf("\n****matrix 1 created By thread-1***\n\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf("Element matrix[%d][%d] of matrixOne = %d\n",i,j,matrix1[i][j]);
sleep(1);
}
}
printf("\n**********1st matrix*********\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf(" %d ",matrix1[i][j]);
}
}
}
void *matrixTwo()
{
int i,j,data=9;
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
matrix2[i][j]=data;
//         sleep(2);
data=data-1;
}
}
//printf matrix
printf("\n\t\t\t\t\t****matrix 2 created By thread-2***\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf("\t\t\t\t\tElement matrix[%d][%d] of matrixTwo = %d\n",i,j,matrix2[i][j]);
sleep(1);
}
}
printf("\n**********2nd matrix*********\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf(" %d ",matrix2[i][j]);
}
}
printf("\n");
}
void *multiply(void *data)
{
pthread_mutex_lock(&lock);
int i,j,k,sum=0;
address *data1=(address*)data;
for(i=0;i<1;i++)
{
for(j=0;j<3;j++)
{
sum=0;
data1->mat2=0;
for(k=0;k<3;k++)
{
//printf("%d\n",data1->mat1[i][k]);
//             sum=sum+matrix1[i][k]*matrix2[k][j];
sum=sum+(matrix1[data1->mat1][k])*(matrix2[data1->mat2][j]);
++(data1->mat2);
}
result[data1->mat1][j]=sum;
//data1->mat2=0;
}
}
printf("\n**********thread %d multiplication of matrix*********\n",data1->mat1);
for(i=0;i<1;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf(" %d ",result[data1->mat1][j]);
}
}
printf("\n");
pthread_mutex_unlock(&lock);
}
void main()
{      
int i,j;
//     address add[3];
address *add = (address*) malloc(3 * sizeof(address));
pthread_t thread1,thread2,thread3[3];
pthread_create(&thread1,NULL,matrixOne,NULL);
//pthread_join(thread1,NULL);
pthread_create(&thread2,NULL,matrixTwo,NULL);
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
for(i=0;i<3;i++)
{
// add[i].mat1=*matrix1+i*3*4;
// add[i].mat2=*matrix2+i*4;
add[i].mat1=i;
add[i].mat2=i;
pthread_create(&thread3[i],NULL,multiply,&add[i]);
}
for(i=0;i<3;i++)
{
pthread_join(thread3[i],NULL);
}
printf("\n\n********** multiplication of matrix*********\n");
for(i=0;i<3;i++)
{
printf("\n");
for(j=0;j<3;j++)
{
printf(" %d ",result[i][j]);
}
}
printf("\n\n");
}

gcc programme.c -lpthread

OriginalL'auteur Sandeep Kumar

Vous devez vous connecter pour publier un commentaire.