MPI calcul parallèle

Bonjour !
J'ai un énorme problème, je m'explique:

J'ai un algo très simple permettant de tester si de très grands nombres sont premiers ou non (j'utilise gmp pour gérer les nombres en question).

Afin de conclure mon projet, il me reste moins d'une semaine pour reussir à 'paralléliser' l'algo.

Je pensais utiliser MPI, mais je me demande comment m'y prendre car je ne veut pas diviser les taches entre plusieurs processeurs au sein d'une même machine mais diviser les taches au sein de plusieurs machines.

Est-ce possible? si oui, de quelle manière les ordinateurs doivent-ils être reliés entre eux? (cable, internet ... ?)

De plus, j'ai énormément de mal à comprendre le fonctionnement de la bibliothèque !

Je vous met le code que je possède actuellement:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h> // Librairie mathématique
 
 
 
 //=================================================================//
 // Fonction principale du programme                                //
 //=================================================================//
 
 int main(int argc, char* argv[])
 {
//Declarations et Initialisations d'entiers
 int n;
 int j=0;
 int l;
 
 long int x;
 mpz_t nbre;    //Declaration nbre
 mpz_t i;       //Declaration i
 mpz_t r;       //Declaration r
 
 mpz_t div[100];//Declaration d'un tableau de structure div
 mpz_t a;
 mpz_init(a);
 
 mpz_init(r);   //Initialisation r
 mpz_init(i);   //Initialisation i
  for(l=0;l<100;l++)
    mpz_init(div[l]);
 
 // Affiche ce que l'on fait
 printf("Affichage et test de primalite d'un nombre sous la forme 2^(2^n) + 1\n");
 printf("Vous devez rentrer une valeur de n, le programme testera ainsi le n-ieme nombre de Fermat\n");
 
 // Demande et récupère une valeur de n
 printf("Valeur de n = ");
 scanf("%d", &n);
 x=pow(2,n);    // calcul de x=2^n
 
 mpz_init(nbre); // Initialise la variable
 
 mpz_add_ui(nbre, nbre, 2); // Place 2 dedans
 
 
 mpz_pow_ui(nbre, nbre, x); // Calcul 2^x
 
 mpz_add_ui(nbre, nbre, 1); // ajoute 1
 
 // Affiche le nombre
 gmp_printf("%Zd\n", nbre);
 
// Initialise i à la valeur 'racine de nombre'
 
 mpz_set(i, mpz_root(nbre, nbre, 2));
 
 
while( mpz_cmp_ui(i, 0) > 0)           // Tant que i est strictement supèrieur à 0
{
    mpz_mod(r, nbre, i);           // On calcul nbre%i et on place le résultat dans r
    if(mpz_cmp_ui (r, 0)==0)        // Si le résultat r vaut zero,
    {
        j++;                        // Alors on incrémente notre compteur de diviseur j
    mpz_set(div[j], i);        // On met la valeur i dans la case k du tableau de structure div
    }
 
    mpz_sub_ui(i, i, 1);           // On décrémente i de 1
 
}
 
// Affichage du nombre de divisteurs
 printf("il y a %d diviseurs\n", j);
 
for(l=0;l<j;l++)
{
    gmp_printf("Le diviseur numero %d est %Zd\n", l+1, div[l]);
}
 
 system("pause");
 return 0;
 }