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 un exemple de code MPI en C pour résoudre ce problème :

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

int main(int argc, char** argv) {
    int size, rank, p;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    int n = 100;
    p = n / size;
    int local_trace = 0;

    // Création de la matrice diagonale par blocs
    int* A = (int*)malloc(n * n * sizeof(int));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i / p == j / p) {
                A[i * n + j] = rank;
            } else {
                A[i * n + j] = 0;
            }
        }
    }

    // Calcul de la trace locale
    for (int i = 0; i < p; i++) {
        local_trace += A[(rank * p + i) * n + rank * p + i];
    }

    // Réduction de la trace locale vers le processus 0
    int global_trace;
    MPI_Reduce(&local_trace, &global_trace, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);

    if (rank == 0) {
        printf("Trace globale = %d\n", global_trace);
    }

    MPI_Finalize();
    return 0;
}

Le programme commence par initialiser MPI et récupérer le nombre de processus (`size`) et le rang du processus courant (`rank`).

Ensuite, on crée la matrice diagonale par blocs en initialisant chaque élément avec la valeur du processus correspondant dans le bloc diagonal, et 0 pour les autres éléments.

Chaque processus calcule ensuite sa trace locale en sommant les éléments diagonaux de son bloc.

Enfin, la trace locale est réduite vers le processus 0 en utilisant l'opération `MPI_Reduce` avec l'opération de réduction `MPI_SUM`.

Le processus 0 affiche ensuite la trace globale calculée.

Notez que dans cet exemple, nous avons supposé que `n` est un multiple de `size`. Si ce n'est pas le cas, vous devrez ajuster la taille des blocs `p` en conséquence.