l'augmentation du nombre de threads sur xcode augmente la durée du programme

des idées ce que je fais mal ou que dois-je faire?!

Il ne semble pas que vous fassiez quelque chose de mal en ce qui concerne votre code. Cependant, le multithreading entraîne une surcharge, à la fois au niveau logiciel et au niveau matériel. Par conséquent, appliquer plus de threads à un problème n'accélère pas toujours le calcul global et peut le ralentir. La façon dont cela affecte une tâche particulière dépend des détails de cette tâche et de l'architecture et de l'environnement de l'hôte.

Néanmoins, considérez ce programme de test complet construit autour de votre exemple de code:

#include <stdlib.h>

int main() {
    double a[400][400], b[400][400], c[400][400] = { { 0.0 } };
    int i, j, k, n = 400;

    srand(time(NULL));
    for (i = 0; i < n; ++i) {
        for (j = 0; j < n; ++j) {
            a[i][j] = rand() / (double) RAND_MAX;
            b[i][j] = rand() / (double) RAND_MAX;
        }
    }

    #pragma omp parallel for private(i,j,k) num_threads(4)
    for (i=0; i<n; ++i) {
        for (j=0; j<n; ++j) {
           for (k=0; k<n; ++k) {
               c[i][j] += a[i][k] * b[k][j];
           }
        } 
    }

    return EXIT_SUCCESS;
}

Vous utilisez une méthode mauvaise pour multiplier vos matrices. L'algorithme ijk génère de nombreux échecs de cache. Regardez votre boucle intérieure. Chaque fois que votre index k change, vous accédez à une nouvelle ligne de la matrice b au lieu d'utiliser un parcours convivial de cache le long d'une ligne. Et ce grand nombre de cache manque réduit vos performances et est plus mauvais pour le code parallèle en raison des algorithmes de cohérence du cache. L'algorithme ikj (voir code ci-dessous) est bien meilleur. Les matrices sont toutes traversées en ligne majeure et ne génèrent pas d'erreurs de cache.

J'ai essayé d'expérimenter votre code.

Pour avoir un timing régulier, je chronomètre 10 boucles de multiplication matricielle, et je le fais 10 fois et je garde le temps le plus bas.

En fonction des définitions, on peut choisir soit ijk ou ikj et contrôlez le parallélisme.

Un autre définit la version parallèle ou séquentielle.

am@Mandel$ cc -fopenmp -O3 -march=native -DTHREADS=0 -Uijk omp2.c; ./a.out
0.114659
am@Mandel$ cc -fopenmp -O3 -march=native -DTHREADS=4 -Uijk omp2.c; ./a.out
0.06113

Maintenant les expériences:

D'abord avec ijk

am@Mandel$ cc -fopenmp -O3 -march=native -DTHREADS=0 -Dijk omp2.c; ./a.out
0.196313
am@Mandel$ cc -fopenmp -O3 -march=native -DTHREADS=4 -Dijk omp2.c; ./a.out
0.293023

Et nous voyons que le parallèle La version est environ 50% plus lente.

Nous passons maintenant à ikj

#include <stdio.h>
#include <omp.h>
#include <stdlib.h>

int main() {
    double a[400][400], b[400][400], c[400][400] = { { 0.0 } };
    int i, j, k, n = 400;

    double t1, t2,t;

    srand(100); // better be deterministic when benchmarking
    for (i = 0; i < n; ++i) {
        for (j = 0; j < n; ++j) {
            a[i][j] = rand() / (double) RAND_MAX;
            b[i][j] = rand() / (double) RAND_MAX;
        }
    }

    t=1E100;
    for(int ll=0;ll<10;ll++){      
      t1 = omp_get_wtime();
      for(int mm=0;mm<10;mm++){
#if THREADS>1
#pragma omp parallel for private(i,j,k) num_threads(THREADS)
#endif
#ifdef ijk
        for (i=0; i<n; ++i) {
          for (j=0; j<n; ++j) {
            for (k=0; k<n; ++k) {
              c[i][j] += a[i][k] * b[k][j];
            }
          } 
        }
#else // ikj matrix multiplication
        for (i=0; i<n; ++i) {
          for (k=0; k<n; ++k) {
            double r=a[i][k];
            for (j=0; j<n; ++j) {
              c[i][j] += r * b[k][j];
            }
          } 
        }
#endif      
      }
      t2 = omp_get_wtime();
      if (t>t2-t1) t=t2-t1;
    }

    printf("%g\n",t);

    // to fool these smart optimizers, do something with c
    FILE* devnull=fopen("/dev/null","w");
    fprintf(devnull,"%g\n",c[0][0]);
    return EXIT_SUCCESS;
}

Le code séquentiel est ~ deux fois plus rapide et la version parallèle est ~ deux fois plus rapide que le séquentiel.

Probablement avec des matrices plus grandes, vous pouvez améliorer l'efficacité du code parallèle.