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

Tester les performances

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

Avant d'installer IOR, vous devez installer MPI pour la synchronisation entre les processus d'analyse comparative. Nous vous recommandons d'utiliser l'image HPC pour les VM clientes, qui inclut des outils permettant d'installer Intel MPI 2021. Pour les clients Ubuntu, nous vous recommandons openmpi.

Vérifier les performances du réseau

Avant d'exécuter IOR, il peut être utile de vous assurer 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 avec un seul client, assurez-vous que la mise en réseau Tier_1 est utilisée.

Performances d'une seule VM

Les instructions suivantes fournissent des étapes et des analyses comparatives 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.

Installer Intel MPI

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

Pour spécifier la pile de mise en 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 afficher les chiffres de performances attendus, consultez la présentation de Parallelstore.

Performances maximales 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 : analyse comparative réelle. 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 jusqu'au nombre de processeurs virtuels pour atteindre des performances agrégées maximales.
-O useO_DIRECT=1: force l'utilisation d'E/S directes pour contourner le cache de page et éviter de lire les données mises en cache.
-genv LD_PRELOAD="/usr/lib64/libioil.so" : utilise la bibliothèque d'interception DAOS. Cette option offre les meilleures performances brutes, mais contourne le cache de page Linux pour les données. Les métadonnées sont toujours mises en cache.
-w : effectue des écritures dans des fichiers individuels.
-r : effectue des lectures.
-e : effectue fsync une fois les écritures terminées.
-F : utilise des fichiers individuels.
-t "1m": lit et écrit des données par blocs de taille spécifiée. Des tailles de bloc plus importantes améliorent les performances d'E/S de diffusion à thread unique.
-b "8g" : taille de chaque fichier

IOPS maximales 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 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"

Faible latence d'E/S 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 de plusieurs VM

Pour atteindre les limites des instances Parallelstore, il est important de tester les E/S agrégées réalisables avec des E/S parallèles à partir de plusieurs VM. Les instructions de cette section fournissent des détails et des commandes sur la façon de procéder à l'aide de mpirun et ior.

Consultez le guide IOR pour obtenir l'ensemble complet des options utiles à tester sur un ensemble de nœuds plus volumineux. Notez qu'il existe différentes manières de lancer des VM clientes pour des tests multiclient à l'aide de planificateurs tels que Batch, Slurm, ou à l'aide des commandes groupées Compute Engine. De plus, le kit HPC peut vous aider à créer des modèles pour déployer des nœuds de calcul.

Ce guide suit 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 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 clientes.
Créez en bloc les VM Compute Engine à l'aide du script de démarrage et de la clé.
Copiez les clés et les fichiers hôtes nécessaires pour exécuter les tests.

Vous trouverez des informations détaillées sur chaque étape 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

Mettez-les à jour avec 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 du serveur 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 de 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 fois que le système démarre. 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 peut être utilisé pour 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 cartes d'interface réseau 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 en bloc, 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 les clés et les 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 autoriser le protocole SSH sans mot de passe entre les nœuds. Cela est nécessaire pour le test IOR à l'aide de SSH afin d'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 et copiez-y la liste des adresses IP internes. Il s'agira 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 de plusieurs VM clientes

Testez les performances dans un scénario multithread et à 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 maximales de plusieurs VM clientes

Testez les performances dans un scénario multithread et à IOPS maximales.

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émontez le conteneur DAOS :
```
sudo umount /tmp/parallelstore/
```

Supprimez l'instance 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

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 d'une seule VM cliente

HPC Rocky 8

Ubuntu

IOPS maximales d'une seule VM cliente

HPC Rocky 8

Ubuntu

Performances maximales d'un seul thread d'application

HPC Rocky 8

Ubuntu

Faible latence d'E/S d'un seul thread d'application

HPC Rocky 8

Ubuntu

Tests de performances de plusieurs 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 les clés et les fichiers

Exécuter des commandes IOR sur plusieurs VM

Performances maximales de plusieurs VM clientes

IOPS maximales de plusieurs VM clientes

Nettoyage

Gcloud CLI

REST

Tester les performances