Configurer la communication des tâches à l'aide d'une bibliothèque MPI

Ce document explique comment configurer une tâche par lot avec des tâches fortement couplées qui communiquent entre elles sur différentes VM à l'aide d'une bibliothèque d'interface de transmission de messages (MPI, Message Passing Interface).

Pour les tâches par lot, le couplage décrit les tâches d'interdépendance. Cela influence la manière dont vous configurez le nombre de tâches pouvant être exécutées en parallèle (plutôt que de manière séquentielle) à l'aide du champ parallelism d'une tâche. Les tâches peuvent être décrites à l'aide des types de couplage suivants:

Tâches faiblement couplées:tâches pouvant être exécutées indépendamment
Tâches étroitement couplées:tâches qui dépendent les unes des autres pour s'exécuter.

Vous pouvez éventuellement créer une tâche qui utilise une bibliothèque MPI pour permettre à des tâches fortement couplées de communiquer entre elles sur différentes instances de VM. Un cas d'utilisation courant de la MPI concerne les charges de travail de calcul hautes performances (HPC) à couplage fort.

Avant de commencer

Si vous n'avez jamais utilisé Batch, consultez la page Premiers pas avec Batch et activez-la en remplissant les conditions préalables pour les projets et les utilisateurs.
Pour obtenir les autorisations nécessaires pour créer une tâche, demandez à votre administrateur de vous attribuer les rôles IAM suivants:
- Éditeur de tâches par lot (roles/batch.jobsEditor) sur le projet
- Utilisateur du compte de service (roles/iam.serviceAccountUser) sur le compte de service de la tâche, qui est le compte de service Compute Engine par défaut par défaut
Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.
Si vous spécifiez le réseau pour cette tâche, assurez-vous qu'il dispose d'une règle de pare-feu autorisant les connexions entre les VM de la tâche. Découvrez comment configurer des règles de pare-feu VPC pour les cas d'utilisation courants.

Créer et exécuter une tâche utilisant l'indicateur de progression pour les tâches étroitement liées

Cette section fournit des exemples illustrant comment créer une tâche pouvant utiliser l'indicateur de progression. L'exemple de tâche comprend notamment trois exécutables:

Le premier élément exécutable est un script qui prépare la tâche pour l'indicateur de progression (MPI) en désactivant le multithreading simultané et en installant l'Intel MPI.
Le deuxième exécutable est un barrière de barrière exécutable vide (formaté comme { "barrier": {} }), ce qui garantit que toutes les tâches ont fini de configurer un MPI avant de passer aux futurs exécutables.
Le troisième exécutable (et tous les exécutables ultérieurs) est disponible pour la charge de travail de la tâche.

Vous pouvez créer une tâche utilisant l'indicateur de progression pour les tâches fortement couplées à l'aide de gcloud CLI ou de l'API Batch.

gcloud

Pour créer une tâche de script utilisant un fichier MPI pour les tâches fortement couplées à l'aide de gcloud CLI, procédez comme suit:

Créez un fichier de configuration JSON avec le contenu suivant:
```
{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ]
            },
            "taskCount": TASK_COUNT,
            "taskCountPerNode": TASK_COUNT_PER_NODE,
            "requireHostsFile": REQUIRE_HOSTS_FILE,
            "permissiveSsh": PERMISSIVE_SSH
        }
    ]
}
```
Remplacez les éléments suivants :
- SCRIPT: un script exécutable pour une charge de travail qui utilise un MPI.
- TASK_COUNT: nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 2 ou une version ultérieure.
- TASK_COUNT_PER_NODE: nombre de tâches qu'une tâche peut exécuter simultanément sur une instance de VM. Pour utiliser les bibliothèques MPI fournies par lot, ce champ est obligatoire et doit être défini sur 1, ce qui équivaut à exécuter une instance de VM par tâche.
- REQUIRE_HOSTS_FILE: lorsqu'il est défini sur true, le job crée un fichier listant les instances de VM s'exécutant dans un groupe de tâches. Le chemin d'accès au fichier est stocké dans la variable d'environnement BATCH_HOSTS_FILE. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
- PERMISSIVE_SSH: lorsqu'il est défini sur true, Batch configure SSH pour une communication sans mot de passe entre les instances de VM exécutées dans un groupe de tâches. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
Pour créer la tâche, utilisez la commande gcloud batch jobs submit.
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
Remplacez les éléments suivants :
- JOB_NAME: nom de la tâche.
- LOCATION: emplacement de la tâche.
- JSON_CONFIGURATION_FILE: chemin d'accès à un fichier JSON contenant les détails de configuration de la tâche.

Vous pouvez éventuellement améliorer les performances des bibliothèques MPI fournies par Batch en procédant comme suit:

Créez et exécutez une tâche à l'aide d'un modèle d'instance de VM, puis spécifiez un modèle d'instance de VM compatible avec HPC dans les ressources de votre tâche.
Spécifiez Cloud Logging comme destination pour les informations de journalisation de votre tâche dans les ressources de votre tâche.

Par exemple, pour créer une tâche de script à partir d'un modèle d'instance qui utilise une MPI et génère une tâche correspondant au nom d'hôte des trois tâches du groupe de tâches:

Dans le répertoire actuel, créez un fichier JSON nommé example-job-uses-mpi.json avec le contenu suivant:

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            "text":
                                "if [ $BATCH_TASK_INDEX = 0 ]; then
                                mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                fi"
                        }
                    },
                    { "barrier": {} }
                ]
            },
            "taskCount": 3,
            "taskCountPerNode": 1,
            "requireHostsFile": true,
            "permissiveSsh": true
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "instanceTemplate": "example-template-job-uses-mpi"
            }
        ]
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

Exécutez la commande suivante :

gcloud batch jobs submit example-template-job-uses-mpi \
  --location us-central1 \
  --config example-job-uses-mpi.json

API

Pour créer une tâche de script utilisant un MPI pour des tâches fortement couplées à l'aide de l'API Batch, exécutez la commande gcloud batch jobs submit et spécifiez les champs permissiveSsh, requireHostsFile, taskCount et taskCountPerNode.

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/jobs?job_id=JOB_ID

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            SCRIPT
                        }
                    }
                ]
            },
            "taskCount": TASK_COUNT,
            "taskCountPerNode": TASK_COUNT_PER_NODE,
            "requireHostsFile": REQUIRE_HOSTS_FILE,
            "permissiveSsh": PERMISSIVE_SSH
        }
    ]
}

Remplacez les éléments suivants :

PROJECT_ID: ID de votre projet.
LOCATION: emplacement de la tâche.
JOB_NAME: nom de la tâche.
SCRIPT: le script exécutable pour une charge de travail qui utilise un MPI.
TASK_COUNT: nombre de tâches pour la tâche. La valeur doit être un nombre entier compris entre 1 et 10000. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ est obligatoire et doit être défini sur 2 ou une version ultérieure.
TASK_COUNT_PER_NODE: nombre de tâches qu'une tâche peut exécuter simultanément sur une instance de VM. Pour utiliser les bibliothèques MPI fournies par lot, ce champ est obligatoire et doit être défini sur 1, ce qui équivaut à exécuter une instance de VM par tâche.
REQUIRE_HOSTS_FILE: lorsque ce champ est défini sur true, la tâche crée un fichier listant les instances de VM s'exécutant dans un groupe de tâches. Le chemin d'accès au fichier est stocké dans la variable d'environnement BATCH_HOSTS_FILE. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".
PERMISSIVE_SSH: lorsqu'il est défini sur true, Batch configure SSH pour une communication sans mot de passe entre les instances de VM exécutées dans un groupe de tâches. Pour utiliser les bibliothèques MPI fournies par Batch, ce champ doit être défini sur "true".

Vous pouvez éventuellement améliorer les performances des bibliothèques MPI fournies par Batch en procédant comme suit:

Créez et exécutez une tâche à l'aide d'un modèle d'instance de VM, puis spécifiez un modèle d'instance de VM compatible avec HPC dans les ressources de votre tâche.
Spécifiez Cloud Logging comme destination pour les informations de journalisation de votre tâche dans les ressources de votre tâche.

Par exemple, pour créer une tâche de script à partir d'un modèle d'instance qui utilise une MPI et dont une tâche génère le nom d'hôte pour les trois tâches du groupe, utilisez la requête suivante:

POST https://batch.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/jobs?job_id=example-template-job-uses-mpi

{
    "taskGroups": [
        {
            "taskSpec": {
                "runnables": [
                    {
                        "script": {
                            "text": "google_mpi_tuning --nosmt; google_install_mpi --intel_mpi;"
                        }
                    },
                    { "barrier": {} },
                    {
                        "script": {
                            "text":
                                "if [ $BATCH_TASK_INDEX = 0 ]; then
                                mpirun -hostfile $BATCH_HOSTS_FILE -np 3 hostname;
                                fi"
                        }
                    },
                    { "barrier": {} }
                ]
            },
            "taskCount": 3,
            "taskCountPerNode": 1,
            "requireHostsFile": true,
            "permissiveSsh": true
        }
    ],
    "allocationPolicy": {
        "instances": [
            {
                "instanceTemplate": "example-template-job-uses-mpi"
            }
        ]
    },
    "logsPolicy": {
        "destination": "CLOUD_LOGGING"
    }
}

où PROJECT_ID est l'ID de votre projet.

Étapes suivantes

Pour obtenir un exemple plus détaillé de tâche utilisant l'indicateur de progression pour les tâches étroitement couplées, consultez la page Exécuter le modèle de recherche et de prévision météorologiques avec un traitement par lot.
Si vous rencontrez des problèmes lors de la création ou de l'exécution d'une tâche, consultez Dépannage.
Afficher les tâches et les tâches
En savoir plus sur les options de création de tâches