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

Rendimiento de las pruebas

En los ejemplos de esta sección se muestran los comandos habituales que recomendamos para evaluar el rendimiento con la herramienta IOR benchmark (github).

Antes de instalar IOR, es necesario instalar MPI para sincronizar los procesos de creación de comparativas. Recomendamos usar la imagen de HPC para las máquinas virtuales cliente, que incluye herramientas para instalar Intel MPI 2021. En el caso de los clientes de Ubuntu, recomendamos Open MPI.

Comprobar el rendimiento de la red

Antes de ejecutar IOR, puede ser útil asegurarse de que su red tiene el rendimiento esperado. Si tienes dos máquinas virtuales cliente, puedes usar una herramienta llamada iperf para probar la red entre ellas.

Instala iperf en ambas VMs:

HPC Rocky 8

sudo dnf -y install iperf

Ubuntu

sudo apt install -y iperf

Inicia un servidor iperf en una de tus VMs:

iperf -s -w 100m -P 30

Inicia un cliente iperf en la otra VM:

iperf -c <IP ADDRESS OF iperf server VM> -w 100m -t 30s -P 30

Observa el número de rendimiento de la red entre las VMs. Para obtener el mejor rendimiento de un solo cliente, asegúrate de usar la red de nivel 1.

Rendimiento de una sola VM

En las siguientes instrucciones se indican los pasos y las métricas para medir el rendimiento de una sola máquina virtual. Las pruebas ejecutan varios procesos de E/en Parallelstore y fuera de él con el objetivo de saturar la tarjeta de interfaz de red (NIC).

Instalar Intel MPI

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

Para especificar la pila de redes libfabric correcta, define la siguiente variable en tu entorno:

export I_MPI_OFI_LIBRARY_INTERNAL=0

A continuación, haz lo siguiente:

source /opt/intel/setvars.sh

Ubuntu

sudo apt install -y autoconf
sudo apt install -y pkg-config
sudo apt install -y libopenmpi-dev
sudo apt install -y make

Instalar IOR

Para instalar IOR, sigue estos pasos:

git clone https://github.com/hpc/ior.git
cd ior
./bootstrap
./configure
make
sudo make install

Ejecutar los comandos de IOR

Ejecuta los siguientes comandos IOR. Para ver las cifras de rendimiento previstas, consulta la descripción general de Parallelstore.

Rendimiento máximo de una sola VM de cliente

HPC Rocky 8

mpirun -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 1 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "1m" -b "8g"

Ubuntu

mpirun --oversubscribe -x LD_PRELOAD="/usr/lib64/libioil.so" -n 1 \
    ior -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "1m" -b "8g"

Donde:

ior: comparativa real. Asegúrate de que esté disponible en la ruta o proporciona la ruta completa.
-ppn: número de procesos (trabajos) que se van a ejecutar. Te recomendamos que empieces con 1 y, después, aumentes el número de vCPUs hasta alcanzar el rendimiento agregado máximo.
-O useO_DIRECT=1: fuerza el uso de E/S directa para saltarse la caché de páginas y evitar la lectura de datos almacenados en caché.
-genv LD_PRELOAD="/usr/lib64/libioil.so": usa la biblioteca de interceptación de DAOS. Esta opción ofrece el mayor rendimiento bruto, pero omite la caché de páginas de Linux para los datos. Los metadatos siguen almacenados en caché.
-w: realiza escrituras en archivos individuales.
-r: realiza lecturas.
-e: realiza fsync al completar las escrituras.
-F: usa archivos individuales.
-t "1m": lee y escribe datos en fragmentos del tamaño especificado. Los tamaños de fragmento más grandes dan como resultado un mejor rendimiento de E/S de streaming de un solo hilo.
-b "8g": tamaño de cada archivo

IOPS máximo de una sola VM cliente

HPC Rocky 8

mpirun -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 80 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "4k" -b "1g"

Ubuntu

mpirun --oversubscribe -x LD_PRELOAD="/usr/lib64/libioil.so" -n 80 \
    ior -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "4k" -b "1g"

Rendimiento máximo de un solo subproceso de aplicación

HPC Rocky 8

mpirun -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 1 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "32m" -b "64g"

Ubuntu

mpirun -x LD_PRELOAD="/usr/lib64/libioil.so" -n 1 \
    ior -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "32m" -b "64g"

Latencia de E/S pequeña de un solo subproceso de aplicación

HPC Rocky 8

mpirun -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 1 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -z -w -r -e -F -t "4k" -b "100m"

Ubuntu

mpirun -x LD_PRELOAD="/usr/lib64/libioil.so" -n 1 \
    ior -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -z -w -r -e -F -t "4k" -b "100m"

Pruebas de rendimiento de varias VMs

Para alcanzar los límites de las instancias de Parallelstore, es importante probar la E/S agregada que se puede conseguir con la E/S paralela de varias máquinas virtuales. Las instrucciones de esta sección proporcionan detalles y comandos sobre cómo hacerlo con mpirun y ior.

Consulta la guía de IOR para ver el conjunto completo de opciones que son útiles para hacer pruebas en un conjunto de nodos más grande. Ten en cuenta que hay varias formas de iniciar máquinas virtuales de cliente para realizar pruebas con varios clientes. Puedes usar programadores como Batch o Slurm, o bien los comandos masivos de Compute Engine. Además, el kit de herramientas de HPC puede ayudarte a crear plantillas para desplegar nodos de cálculo.

En esta guía se siguen estos pasos para implementar varias instancias de cliente configuradas para usar Parallelstore:

Crea una clave SSH para configurar un usuario en cada VM cliente. Si está habilitado, debes inhabilitar el requisito de inicio de sesión del SO en el proyecto.
Obtén los puntos de acceso de la instancia de Parallelstore.
Crea una secuencia de comandos de inicio para desplegarla en todas las instancias de cliente.
Crea las VMs de Compute Engine de forma masiva con la secuencia de comandos de inicio y la clave.
Copia las claves y los archivos de host necesarios para ejecutar las pruebas.

En las siguientes secciones se detallan los pasos.

Establece variables de entorno:

En los comandos de ejemplo de este documento se usan las siguientes variables de entorno:

export SSH_USER="daos-user"
export CLIENT_PREFIX="daos-client-vm"
export NUM_CLIENTS=10

Actualiza estos valores según tus preferencias.

Crear una clave SSH

Crea una clave SSH y guárdala localmente para distribuirla a las VMs cliente. La clave está asociada al usuario de SSH especificado en las variables de entorno y se creará en cada VM:

# Generate an SSH key for the specified user
ssh-keygen -t rsa -b 4096 -C "${SSH_USER}" -N '' -f "./id_rsa"
chmod 600 "./id_rsa"

#Create a new file in the format [user]:[public key] user
echo "${SSH_USER}:$(cat "./id_rsa.pub") ${SSH_USER}" > "./keys.txt"

Obtener los detalles de la red de Parallelstore

Obtén las direcciones IP del servidor Parallelstore en un formato que pueda usar el agente daos:

export ACCESS_POINTS=$(gcloud beta parallelstore instances describe INSTANCE_NAME \
  --location LOCATION \
  --format "value[delimiter=', '](format("{0}", accessPoints))")

Obtén el nombre de la red asociada a la instancia de ParallelStore:

export NETWORK=$(gcloud beta parallelstore instances describe INSTANCE_NAME \
  --location LOCATION \
  --format "value[delimiter=', '](format('{0}', network))" | awk -F '/' '{print $NF}')

Crear la secuencia de comandos de inicio

La secuencia de comandos de inicio se adjunta a la VM y se ejecutará cada vez que se inicie el sistema. La secuencia de comandos de inicio hace lo siguiente:

Configura el agente de daos.
Instala las bibliotecas necesarias.
Monta tu instancia de Parallelstore en /tmp/parallelstore/ en cada VM.
Instala herramientas de pruebas de rendimiento.

Esta secuencia de comandos se puede usar para implementar tus aplicaciones personalizadas en varios ordenadores. Edita la sección relacionada con el código específico de la aplicación en la secuencia de comandos.

La siguiente secuencia de comandos funciona en máquinas virtuales que ejecutan HPC Rocky 8.

# Create a startup script that configures the VM
cat > ./startup-script << EOF
sudo tee /etc/yum.repos.d/parallelstore-v2-6-el8.repo << INNEREOF
[parallelstore-v2-6-el8]
name=Parallelstore EL8 v2.6
baseurl=https://us-central1-yum.pkg.dev/projects/parallelstore-packages/v2-6-el8
enabled=1
repo_gpgcheck=0
gpgcheck=0
INNEREOF
sudo dnf makecache

# 2) Install daos-client
dnf install -y epel-release # needed for capstone
dnf install -y daos-client

# 3) Upgrade libfabric
dnf upgrade -y libfabric

systemctl stop daos_agent

mkdir -p /etc/daos
cat > /etc/daos/daos_agent.yml << INNEREOF
access_points: ${ACCESS_POINTS}

transport_config:
  allow_insecure: true

fabric_ifaces:
- numa_node: 0
  devices:
  - iface: eth0
    domain: eth0
INNEREOF

echo -e "Host *\n\tStrictHostKeyChecking no\n\tUserKnownHostsFile /dev/null" > /home/${SSH_USER}/.ssh/config
chmod 600 /home/${SSH_USER}/.ssh/config

usermod -u 2000 ${SSH_USER}
groupmod -g 2000 ${SSH_USER}
chown -R ${SSH_USER}:${SSH_USER} /home/${SSH_USER}

chown -R daos_agent:daos_agent /etc/daos/

systemctl enable daos_agent
systemctl start daos_agent

mkdir -p /tmp/parallelstore
dfuse -m /tmp/parallelstore --pool default-pool --container default-container --disable-wb-cache --thread-count=16 --eq-count=8 --multi-user
chmod 777 /tmp/parallelstore

#Application specific code
#Install Intel MPI:
sudo google_install_intelmpi --impi_2021
export I_MPI_OFI_LIBRARY_INTERNAL=0
source /opt/intel/setvars.sh

#Install IOR
git clone https://github.com/hpc/ior.git
cd ior
./bootstrap
./configure
make
make install
EOF

Crear las VMs cliente

El rendimiento general de tus cargas de trabajo depende de los tipos de máquinas cliente. En el siguiente ejemplo se usan VMs c2-standard-30. Modifica el machine-type valor para aumentar el rendimiento con NICs más rápidas. Consulta la guía de recursos y comparación de familias de máquinas para obtener información sobre los tipos de máquinas disponibles.

Para crear instancias de VM de forma masiva, usa el comando gcloud compute instances create:

gcloud compute instances bulk create \
  --name-pattern="${CLIENT_PREFIX}-####" \
  --zone="LOCATION" \
  --machine-type="c2-standard-30" \
  --network-interface=subnet=${NETWORK},nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --create-disk=auto-delete=yes,boot=yes,device-name=client-vm1,image=projects/cloud-hpc-image-public/global/images/hpc-rocky-linux-8-v20240126,mode=rw,size=100,type=pd-balanced \
  --metadata=enable-oslogin=FALSE \
  --metadata-from-file=ssh-keys=./keys.txt,startup-script=./startup-script \
  --count ${NUM_CLIENTS}

Copiar claves y archivos

Obtiene y guarda las direcciones IP privadas y públicas de todas las VMs.

IPs privadas:

gcloud compute instances list --filter="name ~ '^${CLIENT_PREFIX}*'" --format="csv[no-heading](INTERNAL_IP)" > hosts.txt

IPs públicas:

gcloud compute instances list --filter="name ~ '^${CLIENT_PREFIX}*'" --format="csv[no-heading](EXTERNAL_IP)" > external_ips.txt

Copia la clave privada para permitir la conexión SSH sin contraseña entre nodos. Este paso es necesario para la prueba de IOR mediante SSH para orquestar máquinas.

while IFS= read -r IP
do
    echo "Copying id_rsa to  ${SSH_USER}@$IP"
    scp -i ./id_rsa -o StrictHostKeyChecking=no ./id_rsa ${SSH_USER}@$IP:~/.ssh/
done < "./external_ips.txt"

Obtén la IP del primer nodo y copia la lista de IPs internas en ese nodo. Este será el nodo principal de la prueba.

export HEAD_NODE=$(head -n 1 ./external_ips.txt)
scp -i ./id_rsa -o "StrictHostKeyChecking=no" -o UserKnownHostsFile=/dev/null   ./hosts.txt ${SSH_USER}@${HEAD_NODE}:~

Ejecutar comandos de IOR en varias máquinas virtuales

Conéctate al nodo principal con el usuario especificado:

ssh -i ./id_rsa -o "StrictHostKeyChecking=no" -o UserKnownHostsFile=/dev/null ${SSH_USER}@${HEAD_NODE}

A continuación, haz lo siguiente:

source /opt/intel/setvars.sh
export I_MPI_OFI_LIBRARY_INTERNAL=0
export D_LOG_MASK=INFO
export D_LOG_FILE_APPEND_PID=1
rm -f /tmp/client.log.*
export D_LOG_FILE=/tmp/client.log

Rendimiento máximo de varias VMs de cliente

Prueba el rendimiento en un escenario de varios procesos y rendimiento máximo.

mpirun -f hosts.txt -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 30 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "1m" -b "8g"

IOPS máximas de varias VMs cliente

Prueba el rendimiento en un escenario de varios procesos y máximo de IOPs.

mpirun -f hosts.txt -genv LD_PRELOAD="/usr/lib64/libioil.so" -ppn 30 \
    --bind-to socket ior \
    -o "/tmp/parallelstore/test" -O useO_DIRECT=1 \
    -w -r -e -F -t "4k" -b "1g"

Limpieza

Desmonta el contenedor DAOS:
```
sudo umount /tmp/parallelstore/
```

Elimina la instancia de Parallelstore:

CLI de gcloud

gcloud beta parallelstore instances delete INSTANCE_NAME --location=LOCATION

REST

curl -X DELETE -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" https://parallelstore.googleapis.com/v1beta/projects/PROJECT_ID/locations/LOCATION/instances/INSTANCE_NAME

Elimina las VMs de Compute Engine:

Rendimiento de las pruebas Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Comprobar el rendimiento de la red

HPC Rocky 8

Ubuntu

Rendimiento de una sola VM

Instalar Intel MPI

HPC Rocky 8

Ubuntu

Instalar IOR

Ejecutar los comandos de IOR

Rendimiento máximo de una sola VM de cliente

HPC Rocky 8

Ubuntu

IOPS máximo de una sola VM cliente

HPC Rocky 8

Ubuntu

Rendimiento máximo de un solo subproceso de aplicación

HPC Rocky 8

Ubuntu

Latencia de E/S pequeña de un solo subproceso de aplicación

HPC Rocky 8

Ubuntu

Pruebas de rendimiento de varias VMs

Establece variables de entorno:

Crear una clave SSH

Obtener los detalles de la red de Parallelstore

Crear la secuencia de comandos de inicio

Crear las VMs cliente

Copiar claves y archivos

Ejecutar comandos de IOR en varias máquinas virtuales

Rendimiento máximo de varias VMs de cliente

IOPS máximas de varias VMs cliente

Limpieza

CLI de gcloud

REST

Rendimiento de las pruebas