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

Rendimento del test

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

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

Controllare le prestazioni della rete

Prima di eseguire IOR, può essere utile assicurarsi che la rete abbia la velocità effettiva prevista. Se hai due VM client, puoi utilizzare uno strumento chiamato iperf per testare la rete tra le VM.

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 velocità effettiva della rete tra le VM. Per ottenere le prestazioni migliori di un singolo client, assicurati che venga utilizzato il networking Tier_1.

Prestazioni di una singola VM

Le seguenti istruzioni forniscono passaggi e benchmark per misurare le prestazioni di una singola VM. I test eseguono più processi di I/O in Parallelstore e da Parallelstore 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 nell'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

Installare 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 di rendimento previsti, consulta la panoramica di Parallelstore.

Massime prestazioni 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 aumentare fino al numero di vCPU per ottenere le massime prestazioni aggregate.
-O useO_DIRECT=1: forza l'utilizzo di I/O diretto per bypassare la cache della pagina ed evitare la lettura dei dati memorizzati nella cache.
-genv LD_PRELOAD="/usr/lib64/libioil.so": utilizza la libreria di intercettazione DAOS. Questa opzione offre le prestazioni grezze più elevate, ma bypassa la cache di pagine Linux per i dati. I metadati sono ancora memorizzati nella cache.
-w: esegui scritture su singoli file.
-r: Esegui letture.
-e: esegui fsync al termine delle scritture.
-F: utilizza singoli file.
-t "1m": Leggi e scrivi i dati in blocchi di dimensioni specificate. Dimensioni dei chunk maggiori migliorano le prestazioni I/O di streaming a thread singolo.
-b "8g": dimensioni di ogni file

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

Massime prestazioni 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 \
    -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"

Latenza I/O ridotta 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 di più VM

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

Consulta la guida IOR per l'insieme completo di opzioni utili per i test su un insieme più ampio di nodi. Tieni presente che esistono vari modi per avviare VM client per test multi-client, ad esempio utilizzando scheduler come Batch, Slurm o utilizzando i comandi collettivi di Compute Engine. Inoltre, l'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 OS Login nel progetto se è stato attivato.
Ottieni i punti di accesso dell'istanza Parallelstore.
Crea uno script di avvio da implementare in tutte le istanze client.
Crea in blocco le VM Compute Engine utilizzando lo script di avvio e la chiave.
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

Le seguenti variabili di ambiente vengono utilizzate nei comandi di esempio in questo documento:

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"

Recuperare i dettagli di rete di Parallelstore

Ottieni 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))")

Recupera 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 è collegato alla VM e viene eseguito ogni volta che il sistema viene avviato. 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 che eseguono 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

Le prestazioni complessive dei carichi di lavoro dipendono 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 i dettagli sui tipi di macchine disponibili, consulta la guida alle risorse e al confronto per le famiglie di macchine.

Per creare più istanze VM contemporaneamente, 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}

Copia di chiavi e file

Recupera e salva gli indirizzi IP privati e pubblici per 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'SSH senza password tra i nodi. Questo è necessario per il test IOR utilizzando 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. Questo 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 comandi IOR su più VM

Connettiti al nodo head 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 multi-processo 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"

Numero massimo di IOPS da più VM client

Testa il rendimento in uno scenario multi-processo con IOPS massime.

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 container DAOS:
```
sudo umount /tmp/parallelstore/
```

Elimina l'istanza 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

Elimina le VM di Compute Engine:

Rendimento del test 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

Installare IOR

Esegui i comandi IOR

Massime prestazioni da una singola VM client

HPC Rocky 8

Ubuntu

IOPS massime da una singola VM client

HPC Rocky 8

Ubuntu

Massime prestazioni da un singolo thread dell'applicazione

HPC Rocky 8

Ubuntu

Latenza I/O ridotta da un singolo thread dell'applicazione

HPC Rocky 8

Ubuntu

Test delle prestazioni di più VM

Imposta le variabili di ambiente

Crea una chiave SSH

Recuperare i dettagli di rete di Parallelstore

Crea lo script di avvio

Crea le VM client

Copia di chiavi e file

Esegui comandi IOR su più VM

Massime prestazioni da più VM client

Numero massimo di IOPS da più VM client

Esegui la pulizia

gcloud CLI

REST

Rendimento del test