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

Testleistung

Die Beispiele in diesem Abschnitt zeigen gängige Befehle, die wir empfehlen, um die Leistung mit dem IOR-Benchmark-Tool (GitHub) zu bewerten.

Vor der Installation von IOR muss MPI für die Synchronisierung zwischen Benchmarking-Prozessen installiert werden. Wir empfehlen die Verwendung des HPC-Images für Client-VMs, das Tools zum Installieren von Intel MPI 2021 enthält. Für Ubuntu-Clients empfehlen wir OpenMPI.

Netzwerkleistung prüfen

Bevor Sie IOR ausführen, sollten Sie prüfen, ob Ihr Netzwerk den erwarteten Durchsatz hat. Wenn Sie zwei Client-VMs haben, können Sie das Tool iperf verwenden, um das Netzwerk zwischen ihnen zu testen.

Installieren Sie iperf auf beiden VMs:

HPC Rocky 8

sudo dnf -y install iperf

Ubuntu

sudo apt install -y iperf

Starten Sie einen iperf-Server auf einer Ihrer VMs:

iperf -s -w 100m -P 30

Starten Sie einen iperf-Client auf der anderen VM:

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

Sehen Sie sich den Netzwerkdurchsatz zwischen den VMs an. Für die höchste Leistung eines einzelnen Clients muss Tier_1-Netzwerk verwendet werden.

Leistung einzelner VMs

Die folgende Anleitung enthält Schritte und Benchmarks zum Messen der Leistung einzelner VMs. Bei den Tests werden mehrere Ein-/Ausgabe-Prozesse in Parallelstore und aus Parallelstore ausgeführt, um die Netzwerkkarte (NIC) zu sättigen.

Intel MPI installieren

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

Um den richtigen Libfabric-Netzwerkstack anzugeben, legen Sie die folgende Variable in Ihrer Umgebung fest:

export I_MPI_OFI_LIBRARY_INTERNAL=0

Gehen Sie anschließend so vor:

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

IOR installieren

So installieren Sie IOR:

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

IOR-Befehle ausführen

Führen Sie die folgenden IOR-Befehle aus. Erwartete Leistungszahlen finden Sie in der Parallelstore-Übersicht.

Maximale Leistung einer einzelnen Client-VM

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"

Wobei:

ior: tatsächlicher Benchmark. Achten Sie darauf, dass sie im Pfad verfügbar ist, oder geben Sie den vollständigen Pfad an.
-ppn: Die Anzahl der auszuführenden Prozesse (Jobs). Wir empfehlen, mit 1 zu beginnen und dann die Anzahl der vCPUs zu erhöhen, um die maximale Gesamtleistung zu erzielen.
-O useO_DIRECT=1: Erzwingt die Verwendung von Direct I/O, um den Seitencache zu umgehen und das Lesen von Daten aus dem Cache zu vermeiden.
-genv LD_PRELOAD="/usr/lib64/libioil.so": Verwenden Sie die DAOS-Abfangbibliothek. Diese Option bietet die höchste Rohleistung, umgeht aber den Linux-Seitencache für Daten. Metadaten werden weiterhin im Cache gespeichert.
-w: Schreibvorgänge für einzelne Dateien ausführen.
-r: Lesevorgänge ausführen.
-e: Führen Sie „fsync“ nach Abschluss der Schreibvorgänge aus.
-F: Einzelne Dateien verwenden.
-t "1m": Daten in Blöcken der angegebenen Größe lesen und schreiben. Größere Chunk-Größen führen zu einer besseren Single-Thread-Streaming-E/A-Leistung.
-b "8g" – Größe der einzelnen Dateien

Maximale IOPS von einer einzelnen Client-VM

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"

Maximale Leistung eines einzelnen Anwendungs-Threads

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"

Geringe E/A-Latenz durch einen einzelnen Anwendungs-Thread

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"

Leistungstests mit mehreren VMs

Um die Grenzwerte von Parallelstore-Instanzen zu erreichen, ist es wichtig, die aggregierte E/A zu testen, die mit paralleler E/A von mehreren VMs erreicht werden kann. Die Anleitung in diesem Abschnitt enthält Details und Befehle dazu, wie Sie dies mit mpirun und ior tun.

Eine vollständige Liste der Optionen, die sich für Tests auf einer größeren Anzahl von Knoten eignen, finden Sie im IOR-Leitfaden. Es gibt verschiedene Möglichkeiten, Client-VMs für Tests mit mehreren Clients zu starten, z. B. mit Schedulern wie Batch oder Slurm oder mit den Compute Engine-Bulk-Befehlen. Das HPC Toolkit kann auch beim Erstellen von Vorlagen zum Bereitstellen von Rechenknoten helfen.

In dieser Anleitung werden die folgenden Schritte verwendet, um mehrere Clientinstanzen bereitzustellen, die für die Verwendung von Parallelstore konfiguriert sind:

Erstellen Sie einen SSH-Schlüssel, mit dem Sie einen Nutzer auf jeder Client-VM einrichten können. Sie müssen die OS Login-Anforderung für das Projekt deaktivieren, falls sie aktiviert wurde.
Zugriffspunkte der Parallelstore-Instanz abrufen.
Erstellen Sie ein Startskript, das auf allen Clientinstanzen bereitgestellt werden soll.
Erstellen Sie die Compute Engine-VMs im Bulk mit dem Startskript und dem Schlüssel.
Kopieren Sie die erforderlichen Schlüssel und Hostdateien, die zum Ausführen der Tests benötigt werden.

Details zu den einzelnen Schritten finden Sie in den folgenden Abschnitten.

Umgebungsvariablen festlegen

Die folgenden Umgebungsvariablen werden in den Beispielbefehlen in diesem Dokument verwendet:

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

Aktualisieren Sie diese auf die gewünschten Werte.

SSH-Schlüssel erstellen

Erstellen Sie einen SSH-Schlüssel und speichern Sie ihn lokal, damit er auf die Client-VMs verteilt werden kann. Der Schlüssel ist dem in den Umgebungsvariablen angegebenen SSH-Nutzer zugeordnet und wird auf jeder VM erstellt:

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

Netzwerkdetails für Parallelstore abrufen

Rufen Sie die Parallelstore-Server-IP-Adressen in einem Format ab, das vom DAOS-Agent verwendet werden kann:

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

Rufen Sie den mit der Parallelstore-Instanz verknüpften Netzwerknamen ab:

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

Startskript erstellen

Das Startskript ist an die VM angehängt und wird jedes Mal ausgeführt, wenn das System gestartet wird. Das Startskript führt die folgenden Aktionen aus:

Konfiguriert den DAOS-Agenten
Erforderliche Bibliotheken werden installiert
Stellt Ihre Parallelstore-Instanz auf jeder VM in /tmp/parallelstore/ bereit
Installiert Tools für Leistungstests

Mit diesem Skript können Sie Ihre benutzerdefinierten Anwendungen auf mehreren Computern bereitstellen. Bearbeiten Sie den Abschnitt im Skript, der sich auf anwendungsspezifischen Code bezieht.

Das folgende Script funktioniert auf VMs, auf denen HPC Rocky 8 ausgeführt wird.

# 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

Client-VMs erstellen

Die Gesamtleistung Ihrer Arbeitslasten hängt von den Client-Maschinentypen ab. Im folgenden Beispiel werden c2-standard-30-VMs verwendet. Ändern Sie den machine-type-Wert, um die Leistung mit schnelleren NICs zu steigern. Weitere Informationen zu den verfügbaren Maschinentypen finden Sie im Leitfaden zu Ressourcen und Vergleichen für Maschinenfamilien.

Verwenden Sie den Befehl gcloud compute instances create, um VM-Instanzen im Bulk zu erstellen:

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}

Schlüssel und Dateien kopieren

Rufen Sie die privaten und öffentlichen IP-Adressen für alle VMs ab und speichern Sie sie.

Private IP-Adressen:

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

Öffentliche IP-Adressen:

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

Kopieren Sie den privaten Schlüssel, um die passwortlose SSH-Verbindung zwischen Knoten zu ermöglichen. Dies ist für den IOR-Test erforderlich, bei dem Maschinen über SSH orchestriert werden.

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"

Rufen Sie die IP-Adresse des ersten Knotens ab und kopieren Sie die Liste der internen IP-Adressen auf diesen Knoten. Dies ist der Head-Knoten für den Testlauf.

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

IOR-Befehle auf mehreren VMs ausführen

Stellen Sie mit dem angegebenen Nutzer eine Verbindung zum Hauptknoten her:

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

Gehen Sie anschließend so vor:

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

Maximale Leistung von mehreren Client-VMs

Testen Sie die Leistung in einem Szenario mit mehreren Prozessen und maximalem Durchsatz.

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"

Maximale IOPS von mehreren Client-VMs

Leistung in einem Szenario mit mehreren Prozessen und maximalen IOPS testen.

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"

Bereinigen

Heben Sie die Bereitstellung des DAOS-Containers auf:
```
sudo umount /tmp/parallelstore/
```

Löschen Sie die Parallelstore-Instanz:

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

Löschen Sie die Compute Engine-VMs:

Testleistung Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Netzwerkleistung prüfen

HPC Rocky 8

Ubuntu

Leistung einzelner VMs

Intel MPI installieren

HPC Rocky 8

Ubuntu

IOR installieren

IOR-Befehle ausführen

Maximale Leistung einer einzelnen Client-VM

HPC Rocky 8

Ubuntu

Maximale IOPS von einer einzelnen Client-VM

HPC Rocky 8

Ubuntu

Maximale Leistung eines einzelnen Anwendungs-Threads

HPC Rocky 8

Ubuntu

Geringe E/A-Latenz durch einen einzelnen Anwendungs-Thread

HPC Rocky 8

Ubuntu

Leistungstests mit mehreren VMs

Umgebungsvariablen festlegen

SSH-Schlüssel erstellen

Netzwerkdetails für Parallelstore abrufen

Startskript erstellen

Client-VMs erstellen

Schlüssel und Dateien kopieren

IOR-Befehle auf mehreren VMs ausführen

Maximale Leistung von mehreren Client-VMs

Maximale IOPS von mehreren Client-VMs

Bereinigen

gcloud-CLI

REST

Testleistung