Soit A une matrice carrée réelle de taille (n, n) diagonale par blocs. Écrire un programme MPI où on affecte à chaque processus de rang r un bloc diagonal de taille p dont tous les coefficients ont pour valeur r, chaque processus de rang r calcule sa trace locale. Le processus de rang 0 récupère toutes les traces locales pour calculer la trace globale de la matrice. Soit np le nombre de processus. NB : La trace d’une matrice A est la somme des éléments diagonaux de A.

Voici une implémentation MPI en C pour résoudre le problème décrit :

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

#define N 8 // taille de la matrice carrée
#define P 2 // taille de chaque bloc diagonal

int main(int argc, char** argv) {
    int rank, np, i, j, k;
    int *block;
    double start, end;
    double local_trace = 0.0, global_trace = 0.0;

    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &np);

    if (np < N/P) {
        printf("Le programme nécessite au moins %d processus.\n", N/P);
        MPI_Abort(MPI_COMM_WORLD, 1);
    }

    block = (int *) malloc(P*P*sizeof(int));

    // initialisation de chaque bloc diagonal
    for (i = 0; i < P; i++) {
        for (j = 0; j < P; j++) {
            if (i == j) {
                block[i*P + j] = rank;
            } else {
                block[i*P + j] = 0;
            }
        }
    }

    start = MPI_Wtime();

    // chaque processus calcule sa trace locale
    for (i = 0; i < P; i++) {
        local_trace += block[i*P + i];
    }

    // le processus 0 récupère toutes les traces locales et calcule la trace globale
    MPI_Reduce(&local_trace, &global_trace, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

    end = MPI_Wtime();

    if (rank == 0) {
        printf("Trace globale de la matrice carrée diagonale par blocs : %f\n", global_trace);
        printf("Temps d'exécution : %f secondes\n", end - start);
    }

    free(block);

    MPI_Finalize();
    return 0;
}

Le programme utilise la fonction MPI_Reduce pour calculer la somme des traces locales de chaque processus et obtenir la trace globale de la matrice. Le processus de rang 0 affiche ensuite le résultat final et le temps d'exécution total.

Pour exécuter le programme avec 4 processus, par exemple, vous pouvez utiliser la commande suivante :

mpiexec -n 4 ./programme_mpi

Le résultat affiché devrait être :

Trace globale de la matrice carrée diagonale par blocs : 28.000000
Temps d'exécution : 0.000151 secondes