Cette page a été traduite par l'API Cloud Translation.

Tester les performances
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Les exemples de cette section présentent des commandes courantes que nous recommandons d'utiliser pour évaluer les performances à l'aide de l'outil IOR benchmark (github).

Avant d'installer IOR, MPI doit être installé pour la synchronisation entre les processus de benchmarking. Nous vous recommandons d'utiliser l'image HPC pour les VM clientes, qui inclut les outils permettant d'installer Intel MPI 2021. Pour les clients Ubuntu, nous recommandons openmpi.

Vérifier les performances du réseau

Avant d'exécuter l'IOR, il peut être utile de vérifier que votre réseau dispose du débit attendu. Si vous disposez de deux VM clientes, vous pouvez utiliser un outil appelé iperf pour tester le réseau entre elles.

Installez iperf sur les deux VM:

HPC Rocky 8

sudo dnf -y install iperf

Ubuntu

sudo apt install -y iperf

Démarrez un serveur iperf sur l'une de vos VM:

iperf -s -w 100m -P 30

Démarrez un client iperf sur l'autre VM:

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

Observez le débit réseau entre les VM. Pour obtenir les meilleures performances pour un seul client, assurez-vous d'utiliser la mise en réseau Tier_1.

Performances d'une seule VM

Les instructions suivantes fournissent des étapes et des benchmarks pour mesurer les performances d'une seule VM. Les tests exécutent plusieurs processus d'E/S dans et hors de Parallelstore dans le but de saturer la carte d'interface réseau (NIC).

Installer Intel MPI

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

Pour spécifier la pile réseau libfabric appropriée, définissez la variable suivante dans votre environnement:

export I_MPI_OFI_LIBRARY_INTERNAL=0

Puis :

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

Installer IOR

Pour installer IOR:

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

Exécuter les commandes IOR

Exécutez les commandes IOR suivantes. Pour consulter les performances attendues, consultez la présentation de Parallelstore.

Performances maximales à partir d'une seule VM 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"

Où :

ior: benchmark réel. Assurez-vous qu'il est disponible dans le chemin d'accès ou fournissez le chemin d'accès complet.
-ppn: nombre de processus (tâches) à exécuter. Nous vous recommandons de commencer par 1, puis d'augmenter la valeur jusqu'au nombre de vCPU pour obtenir des performances agrégées maximales.
-O useO_DIRECT=1: force l'utilisation d'E/S directes pour contourner le cache de pages et éviter de lire les données mises en cache.
-genv LD_PRELOAD="/usr/lib64/libioil.so": utilisez la bibliothèque d'interception DAOS. Cette option offre les performances brutes les plus élevées, mais contourne le cache de pages Linux pour les données. Les métadonnées sont toujours mises en cache.
-w: effectue des écritures dans des fichiers individuels.
-r: effectuer des lectures.
-e: effectuez une fsync à la fin des écritures.
-F: utiliser des fichiers individuels.
-t "1m": lit et écrit des données par blocs de taille spécifiée. Des tailles de blocs plus importantes améliorent les performances d'E/S de streaming à un seul thread.
-b "8g" : taille de chaque fichier

IOPS max d'une seule 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"

Performances maximales à partir d'un seul thread d'application

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"

Latence d'E/S faible à partir d'un seul thread d'application

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"

Tests de performances multi-VM

Pour atteindre les limites des instances Parallelstore, il est important de tester les E/S agrégées réalisables avec les E/S parallèles de plusieurs VM. Les instructions de cette section fournissent des informations et des commandes pour effectuer cette opération à l'aide de mpirun et ior.

Consultez le guide de l'IOR pour obtenir l'ensemble complet des options utiles à tester sur un ensemble plus important de nœuds. Notez qu'il existe plusieurs façons de lancer des VM clientes pour les tests multi-clients, par exemple à l'aide de planificateurs tels que Batch, Slurm ou des commandes groupées Compute Engine. Le kit HPC peut également vous aider à créer des modèles pour déployer des nœuds de calcul.

Ce guide utilise les étapes suivantes pour déployer plusieurs instances clientes configurées pour utiliser Parallelstore:

Créez une clé SSH à utiliser pour configurer un utilisateur sur chaque VM cliente. Vous devez désactiver l'exigence d'OS Login sur le projet si elle a été activée.
Obtenez les points d'accès de l'instance Parallelstore.
Créez un script de démarrage à déployer sur toutes les instances client.
Créez les VM Compute Engine de manière groupée à l'aide du script de démarrage et de la clé.
Copiez les clés et les fichiers d'hôte nécessaires pour exécuter les tests.

Les détails de chaque étape sont fournis dans les sections suivantes.

Définir des variables d'environnement

Les variables d'environnement suivantes sont utilisées dans les exemples de commandes de ce document:

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

Remplacez-les par les valeurs souhaitées.

Créer une clé SSH

Créez une clé SSH et enregistrez-la localement pour la distribuer aux VM clientes. La clé est associée à l'utilisateur SSH spécifié dans les variables d'environnement et sera créée sur chaque 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"

Obtenir les détails du réseau Parallelstore

Obtenez les adresses IP des serveurs Parallelstore dans un format utilisable par l'agent daos:

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

Obtenez le nom du réseau associé à l'instance Parallelstore:

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

Créer le script de démarrage

Le script de démarrage est associé à la VM et s'exécute à chaque démarrage du système. Le script de démarrage effectue les opérations suivantes:

Configure l'agent daos
Installe les bibliothèques requises
Installe votre instance Parallelstore sur /tmp/parallelstore/ sur chaque VM.
Installe des outils de test des performances

Ce script permet de déployer vos applications personnalisées sur plusieurs machines. Modifiez la section liée au code spécifique à l'application dans le script.

Le script suivant fonctionne sur les VM exécutant 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

Créer les VM clientes

Les performances globales de vos charges de travail dépendent des types de machines clientes. L'exemple suivant utilise des VM c2-standard-30. Modifiez la valeur machine-type pour améliorer les performances avec des NIC plus rapides. Pour en savoir plus sur les types de machines disponibles, consultez le Guide des ressources de familles de machines et guide comparatif.

Pour créer des instances de VM de manière groupée, utilisez la commande 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}

Copier des clés et des fichiers

Récupérez et enregistrez les adresses IP privées et publiques de toutes les VM.

Adresses IP privées:

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

Adresses IP publiques:

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

Copiez la clé privée pour permettre l'accès SSH sans mot de passe entre les nœuds. Cela est nécessaire pour le test d'IOR à l'aide de SSH pour orchestrer les machines.

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"

Récupérez l'adresse IP du premier nœud, puis copiez la liste des adresses IP internes sur ce nœud. Il s'agit du nœud principal de l'exécution du test.

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}:~

Exécuter des commandes IOR sur plusieurs VM

Connectez-vous au nœud principal avec l'utilisateur spécifié:

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

Puis :

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

Performances maximales à partir de plusieurs VM clientes

Testez les performances dans un scénario multiprocessus avec débit maximal.

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 maximaux de plusieurs VM clientes

Testez les performances dans un scénario multiprocessus avec un nombre maximal d'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"

Nettoyage

Désinstallez le conteneur DAOS:
```
sudo umount /tmp/parallelstore/
```

Supprimez l'instance Parallelstore:

CLI 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

Supprimez les VM Compute Engine:

Tester les performances Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Vérifier les performances du réseau

HPC Rocky 8

Ubuntu

Performances d'une seule VM

Installer Intel MPI

HPC Rocky 8

Ubuntu

Installer IOR

Exécuter les commandes IOR

Performances maximales à partir d'une seule VM cliente

HPC Rocky 8

Ubuntu

IOPS max d'une seule VM cliente

HPC Rocky 8

Ubuntu

Performances maximales à partir d'un seul thread d'application

HPC Rocky 8

Ubuntu

Latence d'E/S faible à partir d'un seul thread d'application

HPC Rocky 8

Ubuntu

Tests de performances multi-VM

Définir des variables d'environnement

Créer une clé SSH

Obtenir les détails du réseau Parallelstore

Créer le script de démarrage

Créer les VM clientes

Copier des clés et des fichiers

Exécuter des commandes IOR sur plusieurs VM

Performances maximales à partir de plusieurs VM clientes

IOPS maximaux de plusieurs VM clientes

Nettoyage

CLI gcloud

REST

Tester les performances
Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.