Pengujian performa dengan klien Compute Engine

Halaman ini menjelaskan cara menguji performa instance Google Cloud Managed Lustre menggunakan klien Compute Engine. Halaman ini memberikan petunjuk untuk mengukur performa klien tunggal menggunakan fio dan performa gabungan multi-klien menggunakan alat benchmark IOR.

Mengukur performa klien tunggal

Untuk menguji performa baca dan tulis dari satu klien Compute Engine, gunakan alat command line fio (Flexible I/O tester).

  1. Instal fio:

    Rocky 8 

    sudo dnf install fio -y

    Ubuntu 20.04 dan 22.04 

    sudo apt update
sudo install fio

  2. Jalankan perintah berikut:

    fio --ioengine=libaio --filesize=32G --ramp_time=2s \
--runtime=5m --numjobs=16 --direct=1 --verify=0 --randrepeat=0 \
--group_reporting --directory=/lustre --buffer_compress_percentage=50 \
--name=read --blocksize=1m --iodepth=64 --readwrite=read

Pengujian ini memerlukan waktu sekitar 5 menit untuk diselesaikan. Setelah selesai, hasilnya akan ditampilkan. Bergantung pada konfigurasi Anda, Anda dapat mengharapkan throughput hingga kecepatan jaringan maksimum VM, dan ribuan IOPS per TiB.

Mengukur performa multi-klien

Untuk menguji performa baca dan tulis Managed Lustre dari beberapa klien Compute Engine, gunakan alat benchmark IOR. Petunjuk berikut menunjukkan cara mengotomatiskan penyiapan klien dan menggunakan IOR untuk menguji I/O gabungan dari beberapa mesin klien. IOR menggunakan MPI \- protokol penerusan pesan - untuk memungkinkan beberapa mesin klien berkoordinasi satu sama lain.

Sebelum memulai, pastikan nilai mtu jaringan Anda ditetapkan ke 8896.

Menetapkan variabel lingkungan dan membuat kunci SSH

Sebelum men-deploy cluster, buat kunci SSH di mesin lokal Anda. Kunci ini akan didistribusikan ke mesin klien Anda selama pembuatan untuk mengaktifkan komunikasi tanpa sandi untuk MPI.

export SSH_USER="lustre-user"
export CLIENT_PREFIX="lustre-client"

# 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 metadata file formatted for Google Cloud
echo "${SSH_USER}:$(cat "./id_rsa.pub") ${SSH_USER}" > "./keys.txt"

Membuat skrip startup

Simpan konten berikut ke dalam file bernama install-ior.sh di mesin lokal Anda. Skrip ini mendeteksi sistem operasi, menunggu kunci booting dirilis, menginstal klien dan dependensi Lustre dengan aman, mengompilasi rilis IOR yang stabil, dan memasang sistem file Managed Lustre.

Ganti LUSTRE_IP dengan alamat IP instance Managed Lustre Anda, dan FS_NAME dengan nama sistem file Anda.

#!/bin/bash
source /etc/os-release

if [[ "$ID" == "ubuntu" ]]; then
    # Ubuntu
    # Wait for apt lock
    while fuser /var/lib/dpkg/lock-frontend >/dev/null 2>&1; do sleep 5; done

    # Configure Artifact Registry repo for Ubuntu
    curl -fsSL https://us-apt.pkg.dev/doc/repo-signing-key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/us-apt-pkg-dev.gpg

    if [[ "$VERSION_ID" == "22.04" ]]; then
        REPO_NAME="lustre-client-ubuntu-jammy"
    elif [[ "$VERSION_ID" == "24.04" ]]; then
        REPO_NAME="lustre-client-ubuntu-noble"
    fi

    echo "deb [signed-by=/usr/share/keyrings/us-apt-pkg-dev.gpg] https://us-apt.pkg.dev/projects/lustre-client-binaries $REPO_NAME main" | sudo tee /etc/apt/sources.list.d/lustre-client.list

    sudo apt-get update
    while ! sudo apt-get install -y lustre-client-modules-$(uname -r) lustre-client-utils openmpi-bin libopenmpi-dev make gcc g++ wget git automake autoconf libaio-dev; do
        sleep 5
    done
    sudo modprobe lustre
else
    # Red Hat / Rocky Linux
    while systemctl is-active --quiet dnf-makecache.service; do sleep 5; done

    if [[ "$ID" == "rocky" && "$VERSION_ID" == 8* ]]; then
        REPO="lustre-client-rocky-8"
    elif [[ "$ID" == "rocky" && "$VERSION_ID" == 9* ]]; then
        REPO="lustre-client-rocky-9"
    elif [[ "$ID" == "rhel" && "$VERSION_ID" == 9* ]]; then
        REPO="lustre-client-rocky-9"
    fi

    gcloud beta artifacts print-settings yum --repository=$REPO --location=us --project=lustre-client-binaries | sudo bash

    while ! sudo dnf -y --enablerepo=$REPO install kmod-lustre-client lustre-client; do sleep 5; done
    sudo modprobe lustre

    while ! sudo dnf install -y openmpi openmpi-devel make gcc gcc-c++ wget git automake autoconf libaio-devel; do sleep 5; done

    export PATH=$PATH:/usr/lib64/openmpi/bin
fi

# Build IOR from source
echo "Cloning repo: https://github.com/hpc/ior.git and building IOR"
pushd /tmp
git clone -b 4.0.0 https://github.com/hpc/ior
cd ior
./bootstrap
./configure --disable-dependency-tracking --with-aio
make clean
make -j"$(nproc)"
sudo make install
popd
echo "Finished building IOR"

# Mount the Managed Lustre file system
mkdir -p /lustre

if ! grep -q "/lustre" /etc/fstab; then
    echo "LUSTRE_IP@tcp:/FS_NAME /lustre lustre defaults,_netdev 0 0" >> /etc/fstab
fi

mount -a

Men-deploy mesin klien

Jalankan perintah berikut untuk membuat mesin klien Compute Engine secara massal.

gcloud compute instances bulk create \
  --name-pattern="${CLIENT_PREFIX}-####" \
  --zone="ZONE" \
  --machine-type="MACHINE_TYPE" \
  --scopes="https://www.googleapis.com/auth/cloud-platform" \
  --network-interface=subnet=SUBNET,nic-type=GVNIC \
  --network-performance-configs=total-egress-bandwidth-tier=TIER_1 \
  --metadata-from-file=ssh-keys=./keys.txt,startup-script=install-ior.sh \
  --create-disk=auto-delete=yes,boot=yes,\
image-family=IMAGE_FAMILY,\
image-project=IMAGE_PROJECT,\
mode=rw,size=100,type=DISK_TYPE \
  --count NUM_NODES

  • Ganti ZONE dan SUBNET dengan nilai deployment spesifik Anda.

  • Pilih MACHINE_TYPE. Performa keseluruhan benchmark Anda bergantung pada jenis mesin klien. Lihat Pertimbangan performa untuk mengetahui informasi tentang memilih jenis mesin guna mendapatkan throughput terbaik.

  • Jika jenis mesin Anda tidak mendukung jaringan TIER_1, hapus baris --network-performance-configs dari perintah.

  • Tetapkan DISK_TYPE ke salah satu dari hyperdisk-balanced (untuk jenis mesin dengan 4 dalam nama generasinya, seperti c4a atau n4) atau pd-balanced.

  • Tentukan IMAGE_FAMILY dan IMAGE_PROJECT. Nilai yang didukung adalah:

    OS Image family (x86) Image family (ARM) Image project
    HPC Rocky Linux 8 hpc-rocky-linux-8 Tidak didukung cloud-hpc-image-public
    Rocky Linux 9 rocky-linux-9 rocky-linux-9-arm64 rocky-linux-cloud
    RHEL 9 rhel-9 rhel-9-arm64 rhel-cloud
    Ubuntu 22.04 LTS ubuntu-2204-lts ubuntu-2204-lts-arm64 ubuntu-os-cloud
    Ubuntu 24.04 LTS Tidak didukung ubuntu-2404-lts-arm64 ubuntu-os-cloud

  • Tentukan NUM_NODES. Untuk memenuhi sistem file Anda, kapasitas jaringan gabungan cluster harus melebihi throughput yang disediakan sistem file Anda sebesar ~20%.

    Untuk mesin dengan jaringan Tingkat 1 yang diaktifkan, satu mesin dapat mendorong antara 25 Gbps–200 Gbps (~3.000–25.000 MBps), bergantung pada famili VM dan jumlah CPU. Untuk instance standar, traffic keluar biasanya dibatasi sekitar 2 Gbps per vCPU.

    Misalnya, jika kapasitas instance Managed Lustre Anda menghasilkan throughput teoretis sebesar 100.000 MBps, Anda memerlukan traffic keluar klien gabungan sebesar 120.000 MBps (100,000 * 1.2) untuk memenuhinya:

    • Dengan instance standar: Jika setiap mesin klien memiliki traffic keluar yang dipublikasikan sebesar 2.000 MBps, Anda harus menyediakan setidaknya 60 klien (120,000 / 2,000).
    • Dengan jaringan Tingkat 1: Jika setiap mesin klien memiliki traffic keluar yang dipublikasikan sebesar 10.000 MBps (~80 Gbps), Anda harus menyediakan setidaknya 12 klien (120,000 / 10,000).

Menyalin kunci dan file

Saat Anda menunggu mesin klien menyelesaikan skrip startup, jalankan perintah berikut secara lokal untuk mengonfigurasi semua node secara otomatis untuk komunikasi antar-node.

  1. Simpan alamat IP pribadi mesin klien untuk file host MPI, dan alamat IP publik untuk akses SSH dan SCP ke mesin klien:

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

  2. Salin kunci pribadi ke semua klien. Hal ini memungkinkan node pekerja berkomunikasi satu sama lain dengan aman selama benchmark:

    while IFS= read -r IP || [[ -n "$IP" ]]
do
  [[ -z "$IP" ]] && continue
  echo "Preparing and copying to ${SSH_USER}@${IP}..."
  # Ensure the .ssh directory exists
  ssh -i ./id_rsa -o StrictHostKeyChecking=no "${SSH_USER}@${IP}" "mkdir -p ~/.ssh && chmod 700 ~/.ssh"
  # Copy the file
  scp -i ./id_rsa -o StrictHostKeyChecking=no ./id_rsa "${SSH_USER}@${IP}:~/.ssh/id_rsa"
done < "./external_ips.txt"

  3. Tetapkan node utama dan salin file host ke node tersebut. Ini akan menjadi mesin tempat Anda menjalankan benchmark.

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

Menghubungkan dan memverifikasi

  1. Hubungkan ke node utama Anda:

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

  2. Pastikan skrip startup telah selesai dan sistem file berhasil dipasang sebelum menjalankan benchmark.

    Untuk memeriksa log skrip startup:

    sudo journalctl -u google-startup-scripts.service -f

    Untuk memverifikasi bahwa sistem file terpasang:

    df -h | grep lustre

    Jika sistem file tidak tercantum, tunggu beberapa menit lagi hingga skrip penginstalan latar belakang selesai. Setelah dipasang, sistem file akan tersedia di jalur absolut /lustre.

Menjalankan benchmark IOR

  1. Khusus Rocky Linux dan RHEL: Muat modul OpenMPI dari node utama.

    if [ -f /etc/profile.d/modules.sh ]; then
    source /etc/profile.d/modules.sh
    module load mpi/openmpi-$(arch)
fi

  2. Buat direktori pengujian dan ambil kepemilikan:

    sudo mkdir -p /lustre/test
sudo chown -R $USER:$USER /lustre/test

  3. Tentukan variabel pengujian:

    export NUM_NODES="NUM_NODES"
export PROCESSES_PER_NODE="PROCESSES_PER_NODE"
export NUM_PROCESSES=$(( NUM_NODES * PROCESSES_PER_NODE ))

    Dengan:

    • NUM_NODES: Jumlah total mesin klien yang berpartisipasi dalam pengujian.
    • PROCESSES_PER_NODE: Jumlah peringkat MPI yang akan dijalankan di setiap mesin klien. Sebaiknya mulai dengan menetapkan nilai ini agar sesuai dengan jumlah core fisik (atau setengah jumlah vCPU) di mesin klien Anda. Untuk jenis mesin berperforma tinggi, menetapkan nilai ini antara 8 dan 16 biasanya menghasilkan throughput jaringan terbaik. Menetapkan nilai ini terlalu tinggi dapat menyebabkan overhead pengalihan konteks dan menurunkan performa benchmark.

  4. Jalankan perintah untuk memulai benchmark:

    Rocky Linux dan RHEL

    Throughput tulis

    Perintah ini menulis secara terus-menerus selama 60 detik untuk menguji throughput kondisi stabil puncak. Ukuran file per tugas ditetapkan ke batas 50 TiB yang sangat besar untuk membuat tugas tetap menulis hingga waktu 60 detik berakhir.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --prefix /usr/lib64/openmpi \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -F -g -v -w -k \
  -t 4m -b 50t \
  -D 60 \
  -O stoneWallingWearOut=1 \
  -O stoneWallingStatusFile=/lustre/test/ior-easy.stonewall \
  -o /lustre/test/ior_file

    Throughput baca

    Fase ini membaca kembali jumlah data yang berhasil ditulis selama pengujian throughput tulis 60 detik. Meskipun ukuran file per tugas (-b) ditetapkan ke 50 TiB agar sesuai dengan geometri fase tulis, tanda -O stoneWallingWearOut=1 menginstruksikan IOR untuk berhenti membaca segera setelah mencapai batas data yang tepat yang tercatat dalam file status stonewall.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --prefix /usr/lib64/openmpi \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -F -g -v -r -k \
  -t 4m -b 50t \
  -D 60 \
  -O stoneWallingWearOut=1 \
  -O stoneWallingStatusFile=/lustre/test/ior-easy.stonewall \
  -o /lustre/test/ior_file

    IOPS tulis

    Pengujian ini menggunakan ukuran transfer kecil 4 KiB dan ukuran file per tugas 8 GiB untuk mengukur Operasi Input/Output Per Detik (IOPS) maksimum yang dapat ditangani sistem file.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --prefix /usr/lib64/openmpi \
  --np ${NUM_PROCESSES} \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -e \
  -t 4k \
  -b 8g \
  -s 1 \
  -a AIO \
  --posix.odirect \
  --aio.max-pending=256 \
  -w \
  -F \
  -z \
  -Q 1 \
  -G 1745405099 \
  -D 45 \
  -O stoneWallingWearOut=1 \
  -o /lustre/test/ior-random

    IOPS baca

    Untuk mencegah pembacaan dari file jarang, pengujian ini menggunakan dua perintah: tulis untuk membuat file solid menggunakan ukuran transfer 4 MiB dan ukuran file per tugas 8 GiB, diikuti dengan pengujian IOPS baca acak 4 KiB yang sebenarnya.

    1. Buat file untuk dibaca:

      mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --prefix /usr/lib64/openmpi \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -w \
  -F \
  -k \
  -t 4m \
  -b 8g \
  -s 1 \
  -Q 1 \
  -G 1745405099 \
  -o /lustre/test/ior_rand_read

    2. Jalankan pengujian baca IOR:

      mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --prefix /usr/lib64/openmpi \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  --aio.max-pending 256 \
  -r \
  -F \
  -z \
  -t 4k \
  -b 8g \
  -s 1 \
  -Q 1 \
  -G 1745405099 \
  -D 45 \
  -O stoneWallingWearOut=1 \
  -o /lustre/test/ior_rand_read

    Ubuntu

    Throughput tulis

    Perintah ini menulis secara terus-menerus selama 60 detik untuk menguji throughput kondisi stabil puncak. Ukuran file per tugas ditetapkan ke batas 50 TiB yang sangat besar untuk membuat tugas tetap menulis hingga waktu 60 detik berakhir.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -F -g -v -w -k \
  -t 4m -b 50t \
  -D 60 \
  -O stoneWallingWearOut=1 \
  -O stoneWallingStatusFile=/lustre/test/ior-easy.stonewall \
  -o /lustre/test/ior_file

    Throughput baca

    Fase ini membaca kembali jumlah data yang berhasil ditulis selama pengujian throughput tulis 60 detik. Meskipun ukuran file per tugas (-b) ditetapkan ke 50 TiB agar sesuai dengan geometri fase tulis, tanda -O stoneWallingWearOut=1 menginstruksikan IOR untuk berhenti membaca segera setelah mencapai batas data yang tepat yang tercatat dalam file status stonewall.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -F -g -v -r -k \
  -t 4m -b 50t \
  -D 60 \
  -O stoneWallingWearOut=1 \
  -O stoneWallingStatusFile=/lustre/test/ior-easy.stonewall \
  -o /lustre/test/ior_file

    IOPS tulis

    Pengujian ini menggunakan ukuran transfer kecil 4 KiB dan ukuran file per tugas 8 GiB untuk mengukur Operasi Input/Output Per Detik (IOPS) maksimum yang dapat ditangani sistem file.

    mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --np ${NUM_PROCESSES} \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -e \
  -t 4k \
  -b 8g \
  -s 1 \
  -a AIO \
  --posix.odirect \
  --aio.max-pending=256 \
  -w \
  -F \
  -z \
  -Q 1 \
  -G 1745405099 \
  -D 45 \
  -O stoneWallingWearOut=1 \
  -o /lustre/test/ior-random

    IOPS baca

    Untuk mencegah pembacaan dari file jarang, pengujian ini menggunakan dua perintah: tulis untuk membuat file solid menggunakan ukuran transfer 4 MiB dan ukuran file per tugas 8 GiB, diikuti dengan pengujian IOPS baca acak 4 KiB yang sebenarnya.

    1. Buat file untuk dibaca:

      mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  -w \
  -F \
  -k \
  -t 4m \
  -b 8g \
  -s 1 \
  -Q 1 \
  -G 1745405099 \
  -o /lustre/test/ior_rand_read

    2. Jalankan pengujian baca IOR:

      mpirun \
  --allow-run-as-root \
  --mca plm_rsh_no_tree_spawn 1 \
  --mca opal_set_max_sys_limits 1 \
  --mca plm_rsh_num_concurrent ${NUM_NODES} \
  --mca plm_rsh_args "-o StrictHostKeyChecking=no" \
  --oversubscribe \
  --map-by node \
  --bind-to socket \
  --npernode ${PROCESSES_PER_NODE} \
  --np ${NUM_PROCESSES} \
  --hostfile ~/hostfile \
  /usr/local/bin/ior \
  -a AIO \
  --posix.odirect \
  --aio.max-pending 256 \
  -r \
  -F \
  -z \
  -t 4k \
  -b 8g \
  -s 1 \
  -Q 1 \
  -G 1745405099 \
  -D 45 \
  -O stoneWallingWearOut=1 \
  -o /lustre/test/ior_rand_read

    Tanda mpirun adalah:

    • --mca plm_rsh_no_tree_spawn 1: Menonaktifkan pembuatan daemon berbasis pohon untuk meningkatkan keandalan peluncuran di seluruh node.
    • --mca opal_set_max_sys_limits 1: Otomatis mencoba menetapkan batas sistem batas (seperti file terbuka maks) ke nilai tertinggi yang diizinkan.
    • --mca plm_rsh_num_concurrent: Menetapkan jumlah maksimum koneksi SSH serentak mpirun yang akan digunakan saat meluncurkan daemon pekerja.
    • --mca plm_rsh_args ...: Melewati pemeriksaan kunci host yang ketat untuk mencegah perintah SSH interaktif menggantung peluncuran proses MPI.
    • --prefix ...: Menentukan jalur penginstalan OpenMPI secara eksplisit untuk Rocky Linux dan RHEL sehingga node pekerja dapat menemukan daemon yang diperlukan (orted).
    • --allow-run-as-root: Mengizinkan mpirun untuk dieksekusi sebagai pengguna root.
    • --oversubscribe: Mengizinkan MPI menjadwalkan lebih banyak proses di node daripada core fisik yang tersedia.
    • --map-by node: Mendistribusikan proses MPI secara round-robin secara merata di seluruh node yang tersedia.
    • --bind-to socket: Mengikat proses MPI ke soket CPU fisik untuk mengoptimalkan akses memori dan performa cache.
    • --npernode: Jumlah proses per node.
    • --np: Jumlah total proses MPI yang akan diluncurkan.
    • --hostfile: Menentukan file yang berisi daftar host yang akan dijalankan.

    Tanda ior adalah:

    • -a AIO --posix.odirect: Menggunakan mesin I/O Asinkron (AIO) yang dikombinasikan dengan I/O Langsung POSIX. Tindakan ini melewati cache halaman RAM sisi klien dan memaksa penulisan non-blocking serentak langsung ke server penyimpanan, sehingga memastikan benchmark mengukur performa penyimpanan jaringan yang sebenarnya, bukan buffer memori.
    • --aio.max-pending=256: Menentukan jumlah maksimum operasi I/O Asinkron serentak yang sedang berlangsung per proses.
    • -C: Mengurutkan ulang tugas untuk performa baca yang optimal.
    • -F: Mode file per proses.
    • -g: Menggunakan penghalang untuk memisahkan fase tulis dan baca pengujian.
    • -v: Menampilkan logging panjang.
    • -w / -r: Menginstruksikan IOR untuk menjalankan pengujian performa tulis (-w) atau baca (-r) .
    • -k: Mencegah IOR menghapus file pengujian setelah menulis, sehingga file tersebut tersedia untuk pengujian baca.
    • -e: Melakukan fsync setelah fase tulis untuk menjamin bahwa data di -commit ke drive penyimpanan.
    • -z: Menginstruksikan IOR untuk melakukan I/O akses acak, bukan akses berurutan.
    • -s 1: Menetapkan jumlah segmen ke 1.
    • -Q 1: Menetapkan offset tugas per node, menyelaraskan tugas sehingga benchmark berkoordinasi dengan benar di semua node.
    • -G 1745405099: Mengodekan stempel waktu seed acak sehingga fase baca menghasilkan offset file acak yang sama persis dengan yang digunakan fase tulis.
    • -t: Menetapkan ukuran transfer untuk setiap operasi I/O (misalnya, 4m untuk throughput, 4k untuk IOPS).
    • -b: Menetapkan ukuran blok target per proses (misalnya, 50t untuk throughput, 8g untuk IOPS) untuk memastikan pengujian tidak kehabisan data payload selama pengujian berjangka waktu.
    • -D: Membatasi durasi runtime pengujian ke jumlah detik tertentu (misalnya, 60 atau 45). "Stonewalling" ini menghentikan benchmark secara merata untuk mendapatkan pengukuran kondisi stabil yang sebenarnya.
    • -O stoneWallingWearOut=1: Memaksa semua thread serentak untuk terus menghasilkan beban tulis berkelanjutan selama durasi penuh, sehingga mencegah thread yang lebih cepat selesai lebih awal dan menurunkan tekanan jaringan secara keseluruhan.
    • -O stoneWallingStatusFile=<path>: Menulis file verifikasi status di akhir fase tulis. Fase baca berikutnya menggunakan file ini untuk membaca hanya blok yang berhasil di-commit, sehingga mencegah error pointer null selama pembacaan.
    • -o: Jalur ke file pengujian di sistem file Managed Lustre file system.

Melihat hasil

Setelah benchmark selesai, benchmark akan menampilkan metrik performa gabungan dari semua VM atau pod klien langsung di terminal Anda. Cari tabel Results di bagian bawah output untuk menemukan throughput atau IOPS maksimum Anda.

Metrik utama

  • aggregate filesize: Jumlah total data yang ditulis atau dibaca selama pengujian di semua klien yang berpartisipasi.

  • bw(MiB/s) / Max Write / Max Read: Metrik terpenting untuk pengujian berurutan. Metrik ini menunjukkan bandwidth gabungan yang dicapai oleh sistem file Managed Lustre.

  • IOPS: Metrik terpenting untuk pengujian I/O acak. Metrik ini menunjukkan Operasi Input/Output Per Detik maksimum.

Mengekspor hasil ke file

Jika ingin mengurai hasil secara terprogram, memasukkannya ke dalam database, atau menyimpannya untuk analisis nanti, Anda dapat menginstruksikan IOR untuk mengekspor data ringkasan dalam format JSON dan CSV, bukan hanya mencetaknya ke layar.

Untuk melakukannya, tambahkan tanda -O ke akhir string perintah ior Anda:

-O summaryFormat=JSON \
-O summaryFile=/lustre/test/perf-results/summary.json \
-O saveRankPerformanceDetailsCSV=/lustre/test/perf-results/details.csv

Direktori output harus ada di sistem file sebelum menjalankan benchmark.

Performa yang diharapkan versus performa di dunia nyata

Anda dapat menghitung throughput maksimum matematika sistem file berdasarkan kapasitas yang disediakan dan tingkat performa. Karena kapasitas penyimpanan disediakan dalam gibibyte (GiB) dan tingkat dinilai dalam tebibyte (TiB), Anda harus mengonversi kapasitas terlebih dahulu:

(Capacity GiB / 1024) * Tier MBps = MBps Maksimum Teoretis

Misalnya, instance 216.000 GiB di tingkat 500 MBps per TiB secara matematis memberikan throughput 105.469 MBps ((216000 / 1024) * 500).

Throughput maksimum yang diamati akan selalu dibatasi oleh kapasitas throughput yang disediakan sistem file Anda atau batas traffic keluar jaringan gabungan mesin klien Anda, mana pun yang lebih rendah.

Alasan umum mengapa angka benchmark Anda mungkin tidak mencapai kecepatan teoretis mencakup:

  • Overhead TCP/IP: Enkapsulasi jaringan standar dan header paket menggunakan sekitar 5-10% bandwidth mentah. Maksimum matematika Anda mencakup overhead ini, tetapi benchmark IOR hanya mengukur payload mentah yang ditulis ke disk.

  • Batas jaringan klien: Mesin klien memiliki batas bandwidth traffic keluar yang ketat. Jika Anda menggunakan sejumlah kecil klien atau node, atau jenis mesin tanpa jaringan Tingkat 1 yang diaktifkan, klien akan membatasi benchmark sebelum sistem file Managed Lustre mencapai batasnya.

  • Pengalihan konteks MPI: Jika PROCESSES_PER_NODE ditetapkan lebih tinggi dari jumlah core fisik di mesin klien Anda, pertentangan CPU dan overhead pengalihan konteks akan menurunkan performa I/O benchmark secara artifisial.

  • I/O Langsung tidak ada: Jika tanda --posix.odirect dihilangkan, data akan diteruskan melalui cache halaman RAM klien. Hal ini menyebabkan bottleneck memori dan overhead CPU yang menutupi performa penyimpanan jaringan yang sebenarnya.

Pembersihan

Agar akun Anda tidak dikenai biaya untuk resource yang digunakan pada halaman ini, ikuti langkah-langkah berikut: Google Cloud

  1. Hapus file pengujian dari volume Managed Lustre:

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

  2. Hapus mesin klien Compute Engine yang dibuat secara massal:

    gcloud compute instances delete $(gcloud compute instances list \
  --filter="name~'^${CLIENT_PREFIX}-'" --format="value(name)" --zones="ZONE") \
  --zone="ZONE"

    Atau, jika Anda mengetahui nama pastinya atau ingin menghapusnya satu per satu:

    gcloud compute instances delete CLIENT_PREFIX-0001 CLIENT_PREFIX-0002 ... --zone=ZONE

  3. Jika Anda membuat image kustom, Anda dapat menghapusnya:

    gcloud compute images delete CUSTOM_IMAGE_NAME

  4. Jika Anda membuat instance Managed Lustre khusus untuk pengujian ini dan tidak memerlukannya lagi, hapus instance tersebut:

    gcloud lustre instances delete INSTANCE_ID --location=LOCATION

Memecahkan masalah bottleneck benchmark umum

Jika hasil benchmark Anda jauh lebih rendah dari tingkat performa penyimpanan yang diharapkan, lihat Memecahkan masalah bottleneck umum.