Esta página se ha traducido con Cloud Translation API.

Configurar la comunicación de tareas con una biblioteca MPI

En este documento se explica cómo configurar un trabajo de Batch con tareas estrechamente acopladas que se comunican entre sí en diferentes máquinas virtuales mediante una biblioteca de interfaz de transferencia de mensajes (MPI).

En el caso de los trabajos por lotes, el acoplamiento describe las tareas interdependientes, lo que influye en cómo se configura el número de tareas que se pueden ejecutar en paralelo (en lugar de secuencialmente) mediante el campo parallelism de un trabajo. Las tareas se pueden describir mediante los siguientes tipos de acoplamiento:

Tareas con bajo acoplamiento: tareas que se pueden ejecutar de forma independiente.
Tareas de alto acoplamiento: tareas que dependen unas de otras para ejecutarse.

También puedes crear un trabajo que use una biblioteca MPI para permitir que las tareas estrechamente acopladas se comuniquen entre sí en diferentes instancias de VM. Un caso de uso habitual de MPI son las cargas de trabajo de computación de alto rendimiento (HPC) de alto acoplamiento.

Antes de empezar

Si no has usado Batch antes, consulta el artículo Empezar a usar Batch y habilita Batch completando los requisitos previos para proyectos y usuarios.
Para obtener los permisos que necesitas para crear un trabajo, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos:
- Editor de trabajos por lotes (roles/batch.jobsEditor) en el proyecto
- Usuario de cuenta de servicio (roles/iam.serviceAccountUser) en la cuenta de servicio del trabajo, que de forma predeterminada es la cuenta de servicio predeterminada de Compute Engine
Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.
Si especificas la red de este trabajo, asegúrate de que la red tenga una regla de cortafuegos que permita las conexiones entre las VMs del trabajo. Consulta cómo configurar reglas de cortafuegos de VPC para casos prácticos habituales.

Crear y ejecutar un trabajo que use MPI para tareas estrechamente acopladas

En esta sección se proporcionan ejemplos de cómo crear un trabajo que pueda usar MPI. En concreto, el trabajo de ejemplo tiene 3 elementos ejecutables:

El primer ejecutable es una secuencia de comandos que prepara el trabajo para MPI inhabilitando el multihilo simultáneo e instalando Intel MPI.
El segundo elemento ejecutable es un elemento ejecutable de barrera vacío (con el formato { "barrier": {} }), que asegura que todas las tareas finalicen la configuración de MPI antes de continuar con los elementos ejecutables posteriores.
El tercer elemento ejecutable (y cualquier otro elemento ejecutable posterior) está disponible para la carga de trabajo de la tarea.

Puedes crear un trabajo que use MPI para tareas estrechamente acopladas mediante la CLI de gcloud o la API Batch.

gcloud

Para crear un trabajo de secuencia de comandos que use MPI para tareas estrechamente acopladas con gcloud CLI, haz lo siguiente:

Crea un archivo de configuración JSON con el siguiente contenido:
```
{
    "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
        }
    ]
}
```
Haz los cambios siguientes:
- SCRIPT: una secuencia de comandos ejecutable para una carga de trabajo que usa MPI.
- TASK_COUNT: el número de tareas del trabajo. El valor debe ser un número entero entre 1 y el límite de tareas por grupo de tareas. Para usar las bibliotecas MPI proporcionadas por Batch, este campo es obligatorio y debe tener el valor 2 o superior.
- TASK_COUNT_PER_NODE: el número de tareas que un trabajo puede ejecutar simultáneamente en una instancia de VM. Para usar las bibliotecas MPI proporcionadas por Batch, este campo es obligatorio y debe tener el valor 1, que equivale a ejecutar una instancia de VM por tarea.
- REQUIRE_HOSTS_FILE: si se define como true, el trabajo crea un archivo que muestra las instancias de VM que se ejecutan en un grupo de tareas. La ruta del archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usar las bibliotecas MPI proporcionadas por Batch, este campo debe tener el valor true.
- PERMISSIVE_SSH: si se define como true, Batch configura SSH para permitir la comunicación sin contraseña entre las instancias de VM que se ejecutan en un grupo de tareas. Para usar las bibliotecas MPI proporcionadas por Batch, este campo debe tener el valor "true".
Para crear el trabajo, usa el comando gcloud batch jobs submit.
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
Haz los cambios siguientes:
- JOB_NAME: el nombre del puesto.
- LOCATION: la ubicación del puesto.
- JSON_CONFIGURATION_FILE: la ruta de un archivo JSON con los detalles de configuración del trabajo.

También puede aumentar el rendimiento de las bibliotecas MPI proporcionadas por Batch haciendo lo siguiente:

Crea y ejecuta un trabajo con una plantilla de instancia de VM y especifica una plantilla de instancia de VM lista para HPC en los recursos del trabajo.
Especifica Cloud Logging como destino de la información de registro de tu trabajo en los recursos de este.

Por ejemplo, para crear un trabajo de secuencia de comandos a partir de una plantilla de instancia que use MPI y haga que una tarea genere el nombre de host de las tres tareas del grupo de tareas, haz lo siguiente:

Crea un archivo JSON en el directorio actual llamado example-job-uses-mpi.json con el siguiente contenido:

{
    "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"
    }
}

Ejecuta el siguiente comando:

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

API

Para crear un trabajo de script que use una MPI para tareas estrechamente acopladas mediante la API Batch, usa el método jobs.create y especifica los campos permissiveSsh, requireHostsFile, taskCount y 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
        }
    ]
}

Haz los cambios siguientes:

PROJECT_ID: el ID de proyecto de tu proyecto.
LOCATION: la ubicación del puesto.
JOB_NAME: el nombre del puesto.
SCRIPT: la secuencia de comandos ejecutable de una carga de trabajo que usa MPI.
TASK_COUNT: el número de tareas del trabajo. El valor debe ser un número entero entre 1 y el límite de tareas por grupo de tareas. Para usar las bibliotecas MPI proporcionadas por Batch, este campo es obligatorio y debe tener el valor 2 o superior.
TASK_COUNT_PER_NODE: número de tareas que un trabajo puede ejecutar simultáneamente en una instancia de VM. Para usar las bibliotecas MPI proporcionadas por Batch, este campo es obligatorio y debe tener el valor 1, que equivale a ejecutar una instancia de VM por tarea.
REQUIRE_HOSTS_FILE: si se define como true, el trabajo crea un archivo que muestra las instancias de VM que se ejecutan en un grupo de tareas. La ruta del archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usar las bibliotecas MPI proporcionadas por Batch, este campo debe tener el valor "true".
PERMISSIVE_SSH: si se define como true, Batch configura SSH para permitir la comunicación sin contraseña entre las instancias de VM que se ejecutan en un grupo de tareas. Para usar las bibliotecas MPI proporcionadas por Batch, este campo debe tener el valor "true".