Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Prueba de rendimiento

En los ejemplos de esta sección, se muestran los comandos comunes que recomendamos para evaluar el rendimiento con la herramienta de comparativa de IOR (GitHub).

Antes de instalar IOR, se debe instalar MPI para la sincronización entre los procesos de comparativas. Recomendamos usar la imagen de HPC para las VMs cliente, que incluye herramientas para instalar Intel MPI 2021. Para los clientes de Ubuntu, recomendamos openmpi.

Cómo verificar el rendimiento de la red

Antes de ejecutar IOR, puede ser útil asegurarse de que tu red tenga la capacidad de procesamiento esperada. Si tienes dos VMs 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 de iperf en una de tus VMs:

iperf -s -w 100m -P 30

Inicia un cliente de iperf en la otra VM:

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

Observa la cantidad de capacidad de procesamiento de la red entre las VMs. Para obtener el mayor rendimiento de un solo cliente, asegúrate de usar la red Tier_1.

Rendimiento de una sola VM

En las siguientes instrucciones, se proporcionan pasos y comparativas para medir el rendimiento de una sola VM. Las pruebas ejecutan varios procesos de E/S dentro y fuera de Parallelstore con la intención de saturar la tarjeta de interfaz de red (NIC).

Instala Intel MPI

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

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

export I_MPI_OFI_LIBRARY_INTERNAL=0

Luego:

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

Instala IOR

Para instalar IOR, haz lo siguiente:

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

Ejecuta los comandos de IOR

Ejecuta los siguientes comandos de IOR. Para ver las cifras de rendimiento esperadas, 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"

Aquí:

ior: Es la comparativa real. Asegúrate de que esté disponible en la ruta de acceso o proporciona la ruta de acceso completa.
-ppn: Es la cantidad de procesos (trabajos) que se ejecutarán. Te recomendamos que comiences con 1 y, luego, aumentes la cantidad hasta alcanzar el número de CPU virtuales para lograr el máximo rendimiento agregado.
-O useO_DIRECT=1: Fuerza el uso de E/S directa para omitir 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 sin procesar, pero omite la caché de páginas de Linux para los datos. Los metadatos aún se almacenan en caché.
-w: Realiza escrituras en archivos individuales.
-r: Realiza lecturas.
-e: Realiza fsync cuando se completan las escrituras.
-F: Usa archivos individuales.
-t "1m": Lee y escribe datos en fragmentos del tamaño especificado. Los tamaños de fragmentos más grandes generan un mejor rendimiento de E/S de transmisión de un solo subproceso.
-b "8g": Tamaño de cada archivo

IOPS máximas 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 baja desde 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 las E/S agregadas que se pueden lograr con E/S paralelas desde varias VMs. Las instrucciones de esta sección proporcionan detalles y comandos para hacerlo con mpirun y ior.

Consulta la guía de IOR para ver el conjunto completo de opciones que son útiles para realizar pruebas en un conjunto más grande de nodos. Ten en cuenta que hay varias formas de iniciar VMs de cliente para realizar pruebas con varios clientes, desde el uso de programadores como Batch y Slurm hasta el uso de los comandos masivos de Compute Engine. Además, el kit de herramientas de HPC puede ayudar a compilar plantillas para implementar nodos de procesamiento.

En esta guía, se usan los siguientes pasos para implementar varias instancias de cliente configuradas para usar Parallelstore:

Crea una clave SSH para configurar un usuario en cada VM del cliente. Si se habilitó el requisito de Acceso al SO en el proyecto, debes inhabilitarlo.
Obtén los puntos de acceso de la instancia de Parallelstore.
Crea una secuencia de comandos de inicio para implementarla en todas las instancias del cliente.
Crea de forma masiva las VMs de Compute Engine 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 proporcionan detalles sobre cada paso.

Configura las 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 a los que desees.

Crea una clave SSH

Crea una clave SSH y guárdala de forma local para distribuirla a las VMs cliente. La clave se asocia con el 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"

Obtén detalles de la red de Parallelstore

Obtén las direcciones IP del servidor de Parallelstore en un formato que pueda usar el agente de 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 con 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}')

Crea 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 requeridas
Activa tu instancia de Parallelstore en /tmp/parallelstore/ en cada VM.
Instala herramientas de prueba de rendimiento

Esta secuencia de comandos se puede usar para implementar tus aplicaciones personalizadas en varias máquinas. 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 las VMs 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

Crea las VMs de 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 valor de machine-type para aumentar el rendimiento con NIC más rápidas. Consulta la guía de comparación y recursos de familias de máquinas para obtener detalles 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}

Copia de claves y archivos

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

Cómo configurar

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

IP 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 el SSH sin contraseña entre nodos. Esto es necesario para la prueba de IOR que usa SSH para coordinar 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"

Recupera la IP del primer nodo y copia la lista de IPs internas en ese nodo. Este será el nodo principal de la ejecución de 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}:~

Ejecuta comandos de IOR en varias VMs

Conéctate al nodo principal con el usuario especificado:

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

Luego:

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

Probar el rendimiento en un escenario de capacidad de procesamiento máxima y varios procesos

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 de cliente

Probar el rendimiento en un escenario de varios procesos y con la mayor cantidad 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 de DAOS:
```
sudo umount /tmp/parallelstore/
```

Borra la instancia de Parallelstore:

gcloud CLI

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

Borra las VMs de Compute Engine:

Prueba de rendimiento Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Cómo verificar el rendimiento de la red

HPC Rocky 8

Ubuntu

Rendimiento de una sola VM

Instala Intel MPI

HPC Rocky 8

Ubuntu

Instala IOR

Ejecuta los comandos de IOR

Rendimiento máximo de una sola VM de cliente

HPC Rocky 8

Ubuntu

IOPS máximas 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 baja desde un solo subproceso de aplicación

HPC Rocky 8

Ubuntu

Pruebas de rendimiento de varias VMs

Configura las variables de entorno

Crea una clave SSH

Obtén detalles de la red de Parallelstore

Crea la secuencia de comandos de inicio

Crea las VMs de cliente

Copia de claves y archivos

Ejecuta comandos de IOR en varias VMs

Rendimiento máximo de varias VMs de cliente

IOPS máximas de varias VMs de cliente

Limpieza

gcloud CLI

REST

Prueba de rendimiento