Note :

Utiliser une interface MPI ouverte sur Oracle Roving Edge Infrastructure

Présentation

Oracle Roving Edge Infrastructure est une plate-forme de calcul et de stockage en nuage robuste adaptée au déploiement à la périphérie du réseau ou dans des emplacements dotés d'une connectivité externe limitée ou inexistante Au fur et à mesure que les charges de travail plus importantes, plus complexes et plus exigeantes se déplacent vers la périphérie du réseau, cela peut présenter des défis pour une infrastructure en périphérie.

L'interface MPI ouverte est une mise en oeuvre de la norme MPI (Message Passing Interface) utilisée pour développer des applications parallèles dans le calcul de haute performance. L'interface MPI ouverte peut être utilisée pour déployer le calcul haute performance et les charges de travail hautement parallèles sur des éléments d'infrastructure relativement plus petits qui fonctionnent alors comme un ensemble plus grand et agrégé de ressources. Cette approche peut être utilisée pour répartir une charge de travail entre les unités centrales et d'autres ressources de calcul telles que les processeurs graphiques, ce qui permet le déploiement de tâches plus importantes et intensives en calcul en périphérie du réseau telles que la modélisation prédictive ou d'autres tâches d'intelligence artificielle/apprentissage automatique.

L'interface MPI ouverte peut être utilisée pour déployer des charges de travail parallèles en utilisant des ressources sur les noeuds d'Oracle Roving Edge Infrastructure. Netfilter fournit la traduction d'adresses de réseau de destination (DNAT) et la traduction d'adresses de réseau source (SNAT) nécessaires pour les instances de machine virtuelle utilisant un logiciel de mise en grappe hébergé sur les noeuds d'Oracle Roving Edge Infrastructure. Ce tutoriel met en oeuvre l'interface MPI ouverte à l'aide de Netfilter sur Oracle Roving Edge Infrastructure en exécutant un calculateur de nombres premiers pour démontrer une performance améliorée lors de l'utilisation de ressources parallèles.

Informations sur les antécédents

L'interface MPI ouverte peut s'exécuter sur plusieurs instances de machine virtuelle au sein d'un seul noeud d'Oracle Roving Edge Infrastructure ou sur plusieurs noeuds d'Oracle Roving Edge Infrastructure. L'exécution sur un seul noeud du service Oracle Roving Edge Infrastructure est transparente et ne pose aucun problème. Lors de l'exécution sur plusieurs noeuds d'Oracle Roving Edge Infrastructure, il est important de comprendre le réseau sur les instances de machine virtuelle d'Oracle Roving Edge Infrastructure et la façon dont l'Open MPI achemine le trafic pour éviter d'éventuels problèmes.

Service de réseau sur les instances de machine virtuelle d'Oracle Roving Edge Infrastructure

Les instances de machine virtuelle exécutées sur Oracle Roving Edge Infrastructure utilisent des adresses IP privées pour communiquer avec d'autres instances de machine virtuelle sur le même sous-réseau hébergé sur le même noeud. Des adresses IP publiques peuvent être affectées aux instances de machine virtuelle hébergées sur Oracle Roving Edge Infrastructure pour permettre aux instances de communiquer avec d'autres sous-réseaux et ressources s'exécutant en dehors du noeud d'Oracle Roving Edge Infrastructure où il est hébergé.

Note : Les adresses IP publiques sont affectées aux cartes vNIC d'instance de machine virtuelle à partir d'un groupe d'adresses IP publiques. Alors que les adresses sont appelées adresses IP publiques, il s'agit en fait d'adresses IP sur le même réseau local que celui où le noeud Oracle Roving Edge Infrastructure est connecté au moyen de son port RJ-45. Ces adresses peuvent être une adresse IPv4 accessible à partir d'Internet ou il s'agit d'adresses sur un sous-réseau privé du réseau local. Ces adresses sont également appelées adresses IP externes, car elles peuvent être connectées à des ressources externes au noeud où l'instance de machine virtuelle est hébergée.

Il est important de comprendre quand une instance de machine virtuelle s'exécutant dans un noeud Oracle Roving Edge Infrastructure tente d'accéder à des ressources en dehors du noeud, le trafic passe par l'adresse IP externe qui est acheminée dans le noeud et vers la connexion réseau externe.

Un exemple d'instance de machine virtuelle sur le noeud Oracle Roving Edge Infrastructure est affiché dans l'image suivante, notez les adresses IP publiques et privées affectées.

Exemple d'instance de machine virtuelle sur un noeud d'Oracle Roving Edge Infrastructure

Défis liés à l'exécution d'une interface MPI ouverte sur plusieurs noeuds d'Oracle Roving Edge Infrastructure

L'utilisation des adresses IP privées d'instance de machine virtuelle est problématique pour les logiciels de mise en grappe, comme les interfaces MPI ouvertes, lorsqu'elles sont mises en oeuvre sur plusieurs noeuds d'Oracle Roving Edge Infrastructure. Chaque noeud n'est pas au courant des mappages d'adresses IP privées à publiques et de la traduction des mappages pour les instances de machine virtuelle hébergées sur d'autres noeuds. Comme les mappages ne sont pas partagés, les paquets utilisant des adresses IP privées sont acheminés incorrectement ou perdus.

Voici un exemple de l'aspect de ce problème avec Open MPI :

L'interface MPI ouverte exécutée sur les instances de machine virtuelle tentera de déterminer le meilleur chemin réseau à utiliser pour atteindre d'autres membres d'instance de machine virtuelle. Le logiciel peut examiner les interfaces et les adresses IP locales et les enregistrer auprès d'autres noeuds de la grappe.

Mettre en oeuvre un MPI ouvert sur l'ensemble d'Oracle Roving Edge Infrastructure

Pour remédier à la nature non partagée du réseau interne d'Oracle Roving Edge Infrastructure, le logiciel Netfilter sur les instances de machine virtuelle Linux est utilisé pour réécrire les paquets réseau en provenance et à destination des machines virtuelles hébergées sur d'autres noeuds d'Oracle Roving Edge Infrastructure.

Points à considérer pour la conception

Dans ce tutoriel, trois noeuds d'appareils en périphérie de réseau Rover (RED) d'Oracle Roving Edge Infrastructure sont utilisés pour créer une grappe MPI ouverte. Tous les RED sont connectés à un réseau externe partagé. Chaque noeud a été configuré avec son propre groupe d'adresses IP externes pour être affecté à des instances de machine virtuelle.

Table CIDR de VCN et de sous-réseau

Nom RED CIDR du VCN Bloc CIDR de sous-réseau
RED1 10/16 10/24
RED2 10/16 10/24
RED3 10/16 10/24

Cet exemple est illustré dans l'image suivante, deux configurations de réseau provenant de deux RED différents.

Exemple de VCN et de sous-réseau sur "RED1"

Exemple de VCN et de sous-réseau sur "RED2"

Public cible

Administrateurs, développeurs et utilisateurs du service Oracle Roving Edge Infrastructure.

Objectifs

Préalables

Tâche 1 : Créer des instances de machine virtuelle

Créez une instance de machine virtuelle dans chaque sous-réseau sur chaque appareil RED.

Exemples d'affectation d'adresses IP :

Nom RED Nom de la machine virtuelle VM O/S Adresse IP privée de la machine virtuelle Adresse IP publique de la machine virtuelle
RED1 redvm1 Ubuntu 22.04 10/24 10.123
RED2 redvm2 Ubuntu 22.04 10/24 10.123
RED3 redvm3 Ubuntu 22.04 10/24 10.123

Note : Les instances de machine virtuelle de cette tâche sont créées à l'aide d'une image exportée depuis Oracle Cloud Infrastructure (OCI) à l'aide d'OCI Ubuntu 22.04 LTS. Toute distribution Linux avec des ensembles Open MPI appropriés peut être utilisée, par exemple, Oracle Linux 8 ou 9, Fedora, etc.

Exemple de liste de machines virtuelles sur "RED3"

  1. Sur chaque appareil RED, naviguez jusqu'à Calcul, Instance et cliquez sur Créer une instance.

  2. Dans Créer une instance de calcul, entrez Nom, sélectionnez l'image personnalisée importée, la forme, la configuration du réseau, les clés SSH et cliquez sur Créer.

    Création d'une image de calcul sur chaque appareil RED

Tâche 2 : Installer l'ensemble MPI ouvert sur chaque instance de machine virtuelle

Une fois toutes les instances de machine virtuelle créées, connectez-vous à chaque instance de machine virtuelle au moyen de SSH avec la clé fournie lors du provisionnement. Les commandes suivantes conviennent à Ubuntu 22.04. Vous devrez peut-être adapter ces instructions ou inclure des référentiels de paquetages supplémentaires si vous utilisez une distribution Linux différente.

  1. Exécutez la commande suivante pour mettre à jour le système et redémarrer.

    sudo apt update && sudo apt upgrade -y

    Cette opération peut prendre un certain temps. Une fois cette opération terminée, redémarrez l'instance.

    sudo shutdown -r now

  2. Connectez-vous à l'instance et installez les ensembles Open MPI.

    Note :

    • Cela entraînera quelques dépendances.

    • L'ensemble libopenmpi-dev n'est requis que pour compiler ultérieurement un exemple de programme à tester. Si vous ne compilez pas les fonctionnalités Open MPI dans des programmes, ce package n'est pas nécessaire.

    sudo apt install openmpi-bin libopenmpi-dev -y

Tâche 3 : Configurer la traduction d'adresses de réseau de destination (DNAT) et la traduction d'adresses de réseau source (SNAT)

  1. Consultez les détails de chaque instance de machine virtuelle lancée et notez les adresses IP publiques privées et affectées de façon aléatoire. Naviguez jusqu'à Calcul, Instance et cliquez sur le nom de l'instance pour en voir les détails.

    Exemple de machine virtuelle sur "RED3"

  2. Créez les SNAT.

    • Si nous mappons les règles SNAT pour chaque machine virtuelle d'une table, cela devrait ressembler à ceci :

      Palette SNAT À partir de RED1 À partir de RED2 À partir de RED3
      Sur redvm1 S.O Entrez src 10.123.123.67 SNAT to src 10.0.2.2 Entrez src 10.123.123.101 SNAT to src 10.0.3.2
      Sur redvm2 Entrez src 10.123.123.32 SNAT to src 10.0.1.2 S.O Entrez src 10.123.123.101 SNAT to src 10.0.3.2
      Sur redvm3 Entrez src 10.123.123.32 SNAT to src 10.0.1.2 Entrez src 10.123.123.67 SNAT to src 10.0.2.2 S.O

    • Utilisez les commandes iptables pour chaque machine virtuelle.

      • Sur redvm1.

        sudo iptables -I INPUT --src 10.123.123.0/24 -j ACCEPT -m comment --comment "Allow REDs public subnet access."
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.67 -j SNAT --to-source 10.0.2.2
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.101 -j SNAT --to-source 10.0.3.2
sudo netfilter-persistent save

      • Sur redvm2.

        sudo iptables -I INPUT --src 10.123.123.0/24 -j ACCEPT -m comment --comment "Allow REDs public subnet access."
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.32 -j SNAT --to-source 10.0.1.2
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.101 -j SNAT --to-source 10.0.3.2
sudo netfilter-persistent save

      • Sur redvm3.

        sudo iptables -I INPUT --src 10.123.123.0/24 -j ACCEPT -m comment --comment "Allow REDs public subnet access."
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.32 -j SNAT --to-source 10.0.1.2
sudo iptables -t nat -I INPUT -p tcp -s 10.123.123.67 -j SNAT --to-source 10.0.2.2
sudo netfilter-persistent save

      Note : Ajout de la première règle (sudo iptables -I INPUT --src 10.123.123.0/24 -j ACCEPT) pour autoriser l'accès à partir du sous-réseau que les appareils en périphérie de réseau Rover utilisent pour leurs adresses IP publiques. Sans cela (ou une règle similaire), le trafic entrant de RED vers RED est susceptible d'être abandonné par le RED récepteur. Sur ces machines virtuelles, les nouvelles règles sont conservées avec sudo netfilter-persistent save, mais cette commande sera probablement autre chose si vous utilisez une distribution Linux différente.

  3. Créez les DNAT.

    • De même, si nous mappons les règles DNAT pour chaque machine virtuelle d'une table, cela devrait ressembler à ceci :

      NAT Accès à RED1 Accès à RED2 Accès à RED3
      Sur redvm1 S.O Sortie dst 10.0.2.2 DNAT to dst 10.123.123.67 Sortie dst 10.0.3.2 DNAT to dst 10.123.123.101
      Sur redvm2 Sortie dst 10.0.1.2 DNAT to dst 10.123.123.32 S.O Sortie dst 10.0.3.2 DNAT to dst 10.123.123.101
      Sur redvm3 Sortie dst 10.0.1.2 DNAT to dst 10.123.123.32 Sortie dst 10.0.2.2 DNAT to dst 10.123.123.67 S.O

    • Utilisez les commandes iptables pour chaque machine virtuelle.

      • Sur redvm1.

        sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.2.2 -j DNAT --to-destination 10.123.123.67
sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.3.2 -j DNAT --to-destination 10.123.123.101
sudo netfilter-persistent save

      • Sur redvm2.

        sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.1.2 -j DNAT --to-destination 10.123.123.32
sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.3.2 -j DNAT --to-destination 10.123.123.101
sudo netfilter-persistent save

      • Sur redvm3.

        sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.1.2 -j DNAT --to-destination 10.123.123.32
sudo iptables -t nat -I OUTPUT -p tcp -d 10.0.2.2 -j DNAT --to-destination 10.123.123.67
sudo netfilter-persistent save

      Note : Sur les instances de machine virtuelle, les nouvelles règles sont conservées avec sudo netfilter-persistent save.

Tâche 4 : Configurer l'interface MPI ouverte

Open MPI utilise SSH pour communiquer entre les membres du cluster, il y a donc quelques choses à prendre en charge avant de pouvoir exécuter des travaux.

  1. L'interface MPI ouverte utilisera les adresses IP privées de chacune des machines virtuelles, créera des entrées /etc/hosts pour chaque instance de machine virtuelle et leur adresse IP privée sur chaque instance de machine virtuelle MPI ouverte.

    Par exemple, l'utilisation de la configuration au-dessus de l'entrée /etc/hosts sur redvm1 contiendra les entrées suivantes :

    127.0.0.1 localhost
127.0.1.1 redvm1  redvm1
10.0.2.2  redvm2
10.0.3.2  redvm3

    Sur redvm2, /etc/hosts contiendra les entrées suivantes :

    127.0.0.1 localhost
127.0.1.1 redvm2  redvm2
10.0.1.2  redvm1
10.0.3.2  redvm3

    Sur redvm3, /etc/hosts contiendra les entrées suivantes :

    127.0.0.1 localhost
127.0.1.1 redvm3  redvm3
10.0.1.2  redvm1
10.0.2.2  redvm2

  2. Nous devons également nous assurer que l'équivalence SSH existe entre chaque VM pour que l'Open MPI puisse l'utiliser.

    Note : Nous supposons ici qu'il s'agit de nouvelles machines virtuelles qui ne contiennent pas de clés SSH existantes pour l'utilisateur Ubuntu. Si vous utilisez d'anciennes machines virtuelles pour lesquelles des clés SSH ont déjà été créées, vous devrez adapter ces instructions. Ces instructions pourraient remplacer les clés existantes et vous verrouiller de vos machines virtuelles.

    1. Sur redvm1, créez une nouvelle paire de clés publique ou privée (si vous n'avez pas déjà créé de clés). Utilisez la commande ssh-keygen similaire à ssh-keygen -b 4096 -t rsa (acceptez les valeurs par défaut, ne définissez pas de mot de passe pour les nouvelles clés). Cela générera ~/.ssh/id_rsa et ~/.ssh/id_rsa.pub.

    2. Ajoutez la nouvelle clé publique au fichier authorized_keys en exécutant cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys ou en les copiant manuellement au moyen d'un éditeur de texte.

    3. Copiez id_rsa et id_rsa.pub dans le répertoire ~/.ssh de l'utilisateur ubuntu sur redvm2 et redvm3. Assurez-vous d'ajouter id_rsa.pub à authorized_keys, exécutez cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys sur redvm2 et redvm3.

    4. Une fois cela fait, à partir de chaque machine virtuelle, connectez-vous à toutes les autres machines virtuelles, y compris la machine virtuelle elle-même, pour vous assurer que la connectivité fonctionne et que SSH fait confiance aux autres hôtes.

      • Connexion SSH sur redvm1.

        ubuntu@redvm1:~$ ssh redvm1 date
The authenticity of host 'redvm1 (127.0.1.1)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'redvm1' (ED25519) to the list of known hosts.
Fri Apr  5 04:28:57 UTC 2024
ubuntu@redvm1:~$
ubuntu@redvm1:~$ ssh redvm2 date
The authenticity of host 'redvm2 (10.0.2.2)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'redvm2' (ED25519) to the list of known hosts.
Wed Jan 31 04:29:11 UTC 2024
ubuntu@redvm1:~$
ubuntu@redvm1:~$ ssh redvm3 date
The authenticity of host 'redvm3 (10.0.3.2)' can't be established.
ED25519 key fingerprint is SHA256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'redvm3' (ED25519) to the list of known hosts.
Wed Jan 31 04:29:19 UTC 2024

    5. Répétez les étapes ci-dessus pour la connexion de redvm2 à redvm2, redvm1 et redvm3 et redvm3 à redvm3, redvm1 et redvm2.

  3. Créez un emplacement de stockage commun pour chaque membre du cluster.

    Note : Idéalement, toutes les instances de machine virtuelle utilisant l'interface MPI ouverte ont un emplacement de stockage partagé. Cela peut prendre la forme de NFS, GlusterFS, OCFS2 ou d'un certain nombre d'autres solutions de système de fichiers partagés. Ceci est particulièrement important si un répertoire de travail ou un jeu de données commun est nécessaire pour la charge globale.

    Un système de fichiers partagé n'est pas nécessaire pour cet exemple, seulement un emplacement avec un nom commun pour nos fichiers binaires de test. Sur chaque machine virtuelle, créez l'emplacement de nom commun /mpitest.

    sudo mkdir /mpitest && sudo chown ubuntu:ubuntu /mpitest

    Si nous utilisons un système de fichiers partagé, le système de fichiers partagé sera alors monté à cet emplacement sur toutes les instances de machine virtuelle.

  4. Créez un fichier hostfile à utiliser avec mpirun. Pour plus d'informations, voir Comment utiliser l'option -hostfile pour mpirun?.

    1. Nous allons créer deux hostfiles pour les tests. Sur redvm1, à l'aide de notre emplacement de nom commun /mpitest créé ci-dessus, créez un fichier /mpitest/mpihosts.txt avec le contenu suivant :

      redvm1
redvm2
redvm3

    2. Créez un fichier /mpitest/mpihosts_slots.txt avec le contenu suivant :

      redvm1 slots=1
redvm2 slots=1
redvm3 slots=1

Note : Dans ce tutoriel, les tests ne seront exécutés qu'à partir de redvm1. Nous n'avons donc pas besoin de copier ces fichiers vers redvm2 et redvm3. Si vous voulez également exécuter des tâches à partir d'autres machines virtuelles, vous devrez copier ces fichiers vers les autres instances de machine virtuelle ou utiliser un système de fichiers partagé approprié tel que NFS.

Tâche 5 : Tester l'instance de machine virtuelle

  1. Un test simple des commandes distribuées.

    • Un test simple consiste simplement à appeler une commande telle que hostname sur tous les membres de la grappe. Voici la sortie attendue s'exécutant sur trois noeuds avec le fichier slots=1 (mpihosts_slots.txt). La directive slots informe mpirun du nombre de processus pouvant être affectés à ce noeud plutôt que mpirun pour déterminer le nombre de processus.

      Note : La spécification de slots peut être nécessaire si vous utilisez des ressources limitées autres que l'UC (par exemple, les GPU), où vous souhaitez limiter les processus au nombre de l'autre ressource. Si vous ne le faites pas, les processus risquent d'échouer en raison de l'impossibilité d'allouer les autres ressources.

      ubuntu@redvm1:~$ cd /mpitest

ubuntu@redvm1:/mpitest$ cat mpihosts_slots.txt
redvm1 slots=1
redvm2 slots=1
redvm3 slots=1

ubuntu@redvm1:/mpitest$ mpirun --hostfile mpihosts_slots.txt hostname
redvm1
redvm2
redvm3

    • Exécutez le même test, mais sans spécifier le fichier slots (mpihosts.txt), mpirun déterminera les UC disponibles et exécutera le nombre de commandes UC hostname sur chaque noeud. Ces trois machines virtuelles ont 16 CPU, donc nous devrions obtenir 3 x 16 réponses (16 de chaque nom d'hôte).

      ubuntu@redvm1:/mpitest$ cat mpihosts.txt
redvm1
redvm2
redvm3

ubuntu@redvm1:/mpitest$ mpirun --hostfile mpihosts.txt hostname | sort | uniq -c
    16 redvm1
    16 redvm2
    16 redvm3

  2. Créez un fichier binaire de test MPI ouvert.

    Pour un test approprié avec un programme qui utilise Open MPI, nous utilisons un exemple de calculateur de nombres premiers de John Burkardt. Cela devra être téléchargé et compilé sur redvm1. Pour plus d'informations, voir Calculateur de nombres premiers par John Burkardt.

    ubuntu@redvm1:~$ cd /mpitest

ubuntu@redvm1:/mpitest$ curl https://people.sc.fsu.edu/~jburkardt/c_src/prime_mpi/prime_mpi.c -o prime_mpi.c
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                Dload  Upload   Total   Spent    Left  Speed
100  4699  100  4699    0     0   2990      0  0:00:01  0:00:01 --:--:--  2991

ubuntu@redvm1:/mpitest$ mpicc prime_mpi.c -o prime_mpi

ubuntu@redvm1:/mpitest$ ls -l prime_mpi
-rwxrwxr-x 1 ubuntu ubuntu 16736 Apr  5 05:38 prime_mpi

    Comme un système de fichiers partagé n'est pas configuré pour le test, le fichier binaire prime_mpi doit être copié dans redvm2 et redvm3 au même emplacement que sur redvm1. Exécutez la commande suivante .

    ubuntu@redvm1:/mpitest$ scp prime_mpi redvm2:/mpitest
prime_mpi                                                                                                                     100%   16KB  27.4MB/s   00:00
ubuntu@redvm1:/mpitest$ scp prime_mpi redvm3:/mpitest
prime_mpi                                                                                                                     100%   16KB  28.3MB/s   00:00

  3. Pour comparer une ligne de base, exécutez un fichier binaire autonome Open MPI. Exécutez prime_mpi sans MPI ouvert pour une référence ou une comparaison.

    ubuntu@redvm1:/mpitest$ ./prime_mpi
31 January 2024 06:08:17 AM

PRIME_MPI
  C/MPI version

  An MPI example program to count the number of primes.
  The number of processes is 1

        N        Pi          Time

        1         0        0.000003
        2         1        0.000000
        4         2        0.000000
        8         4        0.000000
        16         6        0.000000
        32        11        0.000001
        64        18        0.000002
      128        31        0.000022
      256        54        0.000019
      512        97        0.000066
      1024       172        0.000231
      2048       309        0.000810
      4096       564        0.002846
      8192      1028        0.010093
    16384      1900        0.037234
    32768      3512        0.137078
    65536      6542        0.515210
    131072     12251        1.932970
    262144     23000        7.243419

PRIME_MPI - Master process:
  Normal end of execution.

31 January 2024 06:08:27 AM

    Note : Le nombre de processus est de 1 et il faut environ 10 secondes.

  4. Une exécution distribuée utilisant Open MPI. Exécutez prime_mpi avec l'interface MPI ouverte sur toutes les UC disponibles sur les trois instances de machine virtuelle à l'aide du fichier mpihosts.txt.

    ubuntu@redvm1:/mpitest$ mpirun --hostfile mpihosts.txt ./prime_mpi
31 January 2024 06:09:02 AM

PRIME_MPI
  C/MPI version

  An MPI example program to count the number of primes.
  The number of processes is 48

        N        Pi          Time

        1         0        0.020740
        2         1        0.000428
        4         2        0.000331
        8         4        0.000392
        16         6        0.000269
        32        11        0.000295
        64        18        0.000374
      128        31        0.000390
      256        54        0.000380
      512        97        0.000331
      1024       172        0.000351
      2048       309        0.000385
      4096       564        0.000740
      8192      1028        0.001931
    16384      1900        0.006316
    32768      3512        0.021577
    65536      6542        0.078834
    131072     12251        0.273368
    262144     23000        0.808825

PRIME_MPI - Master process:
  Normal end of execution.

31 January 2024 06:09:03 AM

    48 processus sont utilisés et leur exécution prend environ 1 seconde.

    Explorez Open MPI en exécutant le même exemple, mais avec le fichier mpihosts_slots.txt. Vous devriez constater une amélioration par rapport à l'exécution de prime_mpi autonome, mais il n'utilisera que 1 processeur sur chaque noeud (total de 3) plutôt que le complément complet sur tous les noeuds. En modifiant le nombre d'emplacements sur chaque instance de machine virtuelle, vous pouvez contrôler la distribution du travail.

Confirmation

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.