Questa pagina è stata tradotta dall'API Cloud Translation.

Testare il rendimento
Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Gli esempi in questa sezione mostrano i comandi comuni che consigliamo per valutare il rendimento utilizzando lo strumento IOR benchmark (github).

Prima di installare IOR, è necessario installare MPI per la sincronizzazione tra i processi di benchmarking. Consigliamo di utilizzare l'immagine HPC per le VM client, che include gli strumenti per installare Intel MPI 2021. Per i client Ubuntu, consigliamo openmpi.

Controllare le prestazioni della rete

Prima di eseguire l'IOR, può essere utile assicurarsi che la rete abbia il throughput previsto. Se hai due VM client, puoi utilizzare uno strumento chiamato iperf per eseguire il test della rete tra di loro.

Installa iperf su entrambe le VM:

HPC Rocky 8

sudo dnf -y install iperf

Ubuntu

sudo apt install -y iperf

Avvia un server iperf su una delle tue VM:

iperf -s -w 100m -P 30

Avvia un client iperf sull'altra VM:

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

Osserva il numero di throughput di rete tra le VM. Per il rendimento migliore per singolo client, assicurati di utilizzare la networking Tier_1.

Prestazioni di una singola VM

Le istruzioni riportate di seguito forniscono passaggi e benchmark per misurare il rendimento di una singola VM. I test eseguono più processi di I/O in Parallelstore e in uscita con l'intenzione di saturare la scheda di interfaccia di rete (NIC).

Installa Intel MPI

HPC Rocky 8

sudo google_install_intelmpi --impi_2021

Per specificare lo stack di rete libfabric corretto, imposta la seguente variabile nel tuo ambiente:

export I_MPI_OFI_LIBRARY_INTERNAL=0

Quindi:

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

Installa IOR

Per installare IOR:

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

Esegui i comandi IOR

Esegui i seguenti comandi IOR. Per visualizzare i numeri relativi al rendimento previsti, consulta la panoramica di Parallelstore.

Prestazioni massime da una singola VM client

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"

Dove:

ior: benchmark effettivo. Assicurati che sia disponibile nel percorso o fornisci il percorso completo.
-ppn: il numero di processi (job) da eseguire. Ti consigliamo di iniziare con 1 e poi di aumentare il numero di vCPU fino a raggiungere il rendimento aggregato massimo.
-O useO_DIRECT=1: forza l'uso di I/O dirette per bypassare la cache della pagina ed evitare di leggere i dati memorizzati nella cache.
-genv LD_PRELOAD="/usr/lib64/libioil.so": utilizza la libreria di intercettazione DAOS. Questa opzione offre le prestazioni non elaborate più elevate, ma ignora la cache di pagine Linux per i dati. I metadati sono ancora memorizzati nella cache.
-w: esegui scritture in singoli file.
-r: esegui letture.
-e: esegui fsync al termine delle scritture.
-F: utilizza i singoli file.
-t "1m": leggi e scrivi i dati in blocchi di dimensioni specificate. Dimensioni dei chunk più grandi consentono di migliorare le prestazioni di I/O in streaming con un singolo thread.
-b "8g" - dimensioni di ogni file

IOPS massimi da una singola VM client

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"

Prestazioni massime da un singolo thread di applicazione

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"

Bassa latenza I/O da un singolo thread dell'applicazione

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"

Test delle prestazioni su più VM

Per raggiungere i limiti delle istanze Parallelstore, è importante testare l'I/O aggregata ottenibile con l'I/O parallela da più VM. Le istruzioni in questa sezione forniscono dettagli e comandi su come eseguire questa operazione utilizzando mpirun e ior.

Consulta la guida all'IOR per l'elenco completo delle opzioni utili per i test su un insieme più ampio di nodi. Tieni presente che esistono diversi modi per avviare VM client per i test multi-client, ad esempio utilizzando pianificatori come Batch, Slurm o i comandi collettivi di Compute Engine. Inoltre, HPC Toolkit può aiutarti a creare modelli per il deployment dei nodi di calcolo.

Questa guida utilizza i seguenti passaggi per eseguire il deployment di più istanze client configurate per l'utilizzo di Parallelstore:

Crea una chiave SSH da utilizzare per configurare un utente su ogni VM client. Devi disattivare il requisito di accesso al sistema operativo nel progetto se è stato attivato.
Ottieni i punti di accesso dell'istanza Parallelstore.
Crea uno script di avvio per il deployment in tutte le istanze client.
Crea in blocco le VM Compute Engine utilizzando la chiave e lo script di avvio.
Copia le chiavi e i file host necessari per eseguire i test.

I dettagli di ogni passaggio sono riportati nelle sezioni seguenti.

Imposta le variabili di ambiente

I comandi di esempio in questo documento utilizzano le seguenti variabili di ambiente:

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

Aggiornali con i valori che preferisci.

Crea una chiave SSH

Crea una chiave SSH e salvala localmente per distribuirla alle VM client. La chiave è associata all'utente SSH specificato nelle variabili di ambiente e verrà creata su ogni 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"

Ottenere i dettagli della rete di Parallelstore

Recupera gli indirizzi IP del server Parallelstore in un formato utilizzabile dall'agente daos:

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

Ottieni il nome della rete associata all'istanza Parallelstore:

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

Crea lo script di avvio

Lo script di avvio è associato alla VM e verrà eseguito ogni volta che viene avviato il sistema. Lo script di avvio esegue le seguenti operazioni:

Configura l'agente daos
Installa le librerie richieste
Monta l'istanza Parallelstore su /tmp/parallelstore/ su ogni VM
Installa strumenti di test delle prestazioni

Questo script può essere utilizzato per eseguire il deployment delle applicazioni personalizzate su più macchine. Modifica la sezione relativa al codice specifico dell'applicazione nello script.

Lo script seguente funziona sulle VM con 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 le VM client

Il rendimento complessivo dei carichi di lavoro dipende dai tipi di macchine client. L'esempio seguente utilizza VM c2-standard-30; modifica il valore machine-type per aumentare le prestazioni con NIC più veloci. Per informazioni dettagliate sui tipi di macchine disponibili, consulta la guida Risorsa e confronto tra famiglie di macchine.

Per creare istanze VM collettivamente, utilizza il 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}

Copiare chiavi e file

Recupera e salva gli indirizzi IP privati e pubblici di tutte le VM.

IP privati:

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

IP pubblici:

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

Copia la chiave privata per consentire l'accesso SSH senza password tra i nodi. Questo è obbligatorio per il test IOR che utilizza SSH per orchestrare le macchine.

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 l'IP del primo nodo e copia l'elenco degli IP interni in quel nodo. Sarà il nodo principale per l'esecuzione del 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}:~

Esegui i comandi IOR su più VM

Connettiti al nodo principale con l'utente specificato:

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

Quindi:

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

Massime prestazioni da più VM client

Testa le prestazioni in uno scenario multiprocesso con velocità effettiva massima.

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 massimi da più VM client

Testa le prestazioni in uno scenario multiprocesso con un numero massimo di 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"

Esegui la pulizia

Smonta il contenitore DAOS:
```
sudo umount /tmp/parallelstore/
```

Elimina l'istanza Parallelstore:

Interfaccia a riga di comando 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 le VM di Compute Engine:

Testare il rendimento Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Controllare le prestazioni della rete

HPC Rocky 8

Ubuntu

Prestazioni di una singola VM

Installa Intel MPI

HPC Rocky 8

Ubuntu

Installa IOR

Esegui i comandi IOR

Prestazioni massime da una singola VM client

HPC Rocky 8

Ubuntu

IOPS massimi da una singola VM client

HPC Rocky 8

Ubuntu

Prestazioni massime da un singolo thread di applicazione

HPC Rocky 8

Ubuntu

Bassa latenza I/O da un singolo thread dell'applicazione

HPC Rocky 8

Ubuntu

Test delle prestazioni su più VM

Imposta le variabili di ambiente

Crea una chiave SSH

Ottenere i dettagli della rete di Parallelstore

Crea lo script di avvio

Crea le VM client

Copiare chiavi e file

Esegui i comandi IOR su più VM

Massime prestazioni da più VM client

IOPS massimi da più VM client

Esegui la pulizia

Interfaccia a riga di comando gcloud

REST

Testare il rendimento
Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.