Se usó la API de Cloud Translation para traducir esta página.

Configura la comunicación de tareas con una biblioteca MPI

En este documento, se explica cómo configurar un trabajo por lotes con tareas con acoplamiento alto que se comunican entre sí a través de diferentes VMs con una interfaz de envío de mensajes (MPI) biblioteca.

Para los trabajos por lotes, acoplamiento describe las tareas de interdependencia; esto influye en la forma en que configuras la cantidad de tareas que pueden ejecutarse en paralelo (en lugar de secuencialmente) usando la configuración Campo parallelism. Las tareas se pueden describir con los siguientes tipos de acoplamiento:

Tareas con acoplamiento bajo: Tareas que pueden ejecutarse de forma independiente.
Tareas con acoplamiento alto: Tareas que dependen una de otra para ejecutarse.

También puedes crear un trabajo que use una biblioteca de la MPI para permitir el acceso se comunican entre sí en diferentes instancias de VM. Un caso de uso común para MPI son las cargas de trabajo de computación de alto rendimiento (HPC) estrechamente vinculadas.

Antes de comenzar

Si nunca usaste Batch, revisa Comienza a usar Batch y habilitar Batch completando el requisitos previos para los proyectos y usuarios.
A fin de obtener los permisos que necesitas para crear un trabajo, solicita a tu administrador que te otorgue el los siguientes roles de IAM:
- Editor de trabajos por lotes (roles/batch.jobsEditor) en el proyecto
- Usuario de la 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 otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.
Si especificas la red para este trabajo, asegúrate de que la red tenga una regla de firewall que permita conexiones entre las VMs del trabajo. Aprende a hacer lo siguiente: Configurar Reglas de firewall de VPC para casos de uso comunes

Crea y ejecuta un trabajo que use la MPI para tareas con acoplamiento alto

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

El primer ejecutable es una secuencia de comandos que prepara el trabajo para la MPI mediante inhabilita el multiprocesamiento simultáneo y, luego, instalar Intel MPI.
El segundo objeto ejecutable es un objeto ejecutable de barrera vacío (con formato { "barrier": {} }), que garantiza que todas las tareas terminen de configurar MPI antes de continuar con los objetos ejecutables futuros.
El tercer ejecutable (y cualquier ejecutable posterior) está disponible para la carga de trabajo del trabajo.

Puedes crear un trabajo que use la MPI para tareas con acoplamiento alto usando la gcloud CLI o la API de Batch.

gcloud

Crear un trabajo de script que use la MPI para tareas con acoplamiento alto usando el 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
        }
    ]
}
```
Reemplaza lo siguiente:
- SCRIPT: Una secuencia de comandos ejecutable para una carga de trabajo que usa MPI.
- TASK_COUNT: Es la cantidad 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 la MPI que proporciona Batch, este campo es obligatorio y debe establecerse en 2 o superior.
- TASK_COUNT_PER_NODE: Es la cantidad de tareas que puede ejecutar una tarea de forma simultánea en una instancia de VM. Para usar las bibliotecas de la MPI proporcionados por Batch, este campo es obligatorio y debe configurado en 1, lo que equivale a ejecutar una instancia de VM por tarea.
- REQUIRE_HOSTS_FILE: Cuando se establece en true, el trabajo crea un archivo que enumera las instancias de VM que se ejecutan en un grupo de tareas. El La ruta de acceso al archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usa las bibliotecas de la MPI proporcionadas por Batch, debe configurarse como true.
- PERMISSIVE_SSH: cuando se establece en true, Batch configura SSH para permitir el acceso sin contraseña entre las instancias de VM que se ejecutan en un grupo de tareas. Para usar Bibliotecas de la MPI proporcionadas por Batch, este campo se debe configurar como true.
Para crear el trabajo, usa el Comando gcloud batch jobs submit
```
gcloud batch jobs submit JOB_NAME \
  --location LOCATION \
  --config JSON_CONFIGURATION_FILE
```
Reemplaza lo siguiente:
- JOB_NAME: Es el nombre del trabajo.
- LOCATION: Es la ubicación. del trabajo.
- JSON_CONFIGURATION_FILE: Es la ruta de acceso para un JSON. con los detalles de configuración del trabajo.

Puedes aumentar el rendimiento de las bibliotecas de la MPI proporcionadas por lotes si haces lo siguiente:

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

Por ejemplo, para crear un trabajo de secuencia de comandos a partir de una plantilla de instancias que use MPI y hace que 1 tarea muestre el nombre de host de las 3 tareas de la tarea grupo:

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 secuencia de comandos que use un MPI para tareas estrechamente vinculadas con la API de 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
        }
    ]
}

Reemplaza lo siguiente:

PROJECT_ID: el ID del proyecto de tu proyecto.
LOCATION: Es la ubicación. del trabajo.
JOB_NAME: Es el nombre del trabajo.
SCRIPT: Es la secuencia de comandos. ejecutable para una carga de trabajo que usa MPI.
TASK_COUNT: Es la cantidad de tareas del trabajo. El El valor debe ser un número entero entre 1 y el límite de tareas por grupo de tareas. Para usar la MPI que proporciona Batch, este campo es obligatorio y debe establecerse en 2 o superior.
TASK_COUNT_PER_NODE: Es la cantidad de tareas que un puede ejecutarse simultáneamente en una instancia de VM. Para usar las bibliotecas MPI que proporciona Batch, este campo es obligatorio y se debe establecer en 1, lo que equivale a ejecutar una instancia de VM por tarea.
REQUIRE_HOSTS_FILE: Cuando se establece en true, el trabajo crea un archivo que enumera las instancias de VM que se ejecutan en un grupo de tareas. El archivo se almacena en la variable de entorno BATCH_HOSTS_FILE. Para usar Bibliotecas de la MPI proporcionadas por Batch, este campo se debe configurar como true.
PERMISSIVE_SSH: cuando se establece en 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 de la MPI que proporciona Batch, este campo se debe configurar como verdadero.

Puedes aumentar el rendimiento de las bibliotecas de la MPI proporcionadas por lotes si haces lo siguiente:

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

Por ejemplo, para crear un trabajo de secuencia de comandos a partir de una plantilla de instancias que use MPI y hace que la salida de 1 tarea sea el nombre de host de las 3 tareas del grupo de tareas, usa la siguiente solicitud:

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

En el ejemplo anterior, PROJECT_ID es el ID del proyecto de tu proyecto.

¿Qué sigue?

Para obtener un ejemplo más detallado de un trabajo que usa la MPI para tareas con acoplamiento alto, consulta Ejecuta el modelo de investigación y previsión del clima con lotes.
Obtén más información sobre cómo reducir la latencia para trabajos con tareas con acoplamiento alto.
Si tienes problemas para crear o ejecutar un trabajo, consulta Solución de problemas.
Visualiza trabajos y tareas.
Obtén más información sobre las opciones de creación de trabajos.