Per eseguire il benchmark delle prestazioni di Hyperdisk,
utilizza Flexible I/O tester (FIO)
invece di altri strumenti di benchmarking del disco come dd.
Per impostazione predefinita, dd utilizza una profondità della coda I/O molto bassa, pertanto è difficile garantire che il benchmark generi un numero sufficiente di byte e operazioni I/O per testare con precisione le prestazioni del disco.
Inoltre, i dispositivi speciali utilizzati con dd sono spesso molto lenti e non rispecchiano con precisione le prestazioni del disco. In generale, evita di utilizzare dispositivi speciali come /dev/urandom, /dev/random e /dev/zero nei benchmark delle prestazioni di Hyperdisk.
Per misurare le IOPS e la velocità effettiva di un disco in uso su un'istanza in esecuzione, esegui il benchmark del file system con la configurazione prevista. Utilizza questa opzione per testare un carico di lavoro realistico senza perdere i contenuti del disco esistente. Tieni presente che quando esegui il benchmark del file system su un disco esistente, esistono molti fattori specifici del tuo ambiente di sviluppo che possono influire sui risultati del benchmark e potresti non raggiungere i limiti di prestazioni del disco.
Per misurare il rendimento non elaborato di un Hyperdisk, esegui un benchmark direttamente sul dispositivo a blocchi. Utilizza questa opzione per confrontare le prestazioni del disco non elaborate con i limiti di prestazioni del disco.
I seguenti comandi funzionano con i sistemi operativi Debian o Ubuntu con il gestore dei pacchetti apt.
Benchmarking delle IOPS e della velocità effettiva di un disco su un'istanza in esecuzione
Se vuoi misurare le IOPS e il throughput per un carico di lavoro realistico su un disco attivo di un'istanza VM in esecuzione senza perdere i contenuti del disco, esegui il benchmark rispetto a una nuova directory sul file system esistente.
Prepararsi per i test
Installa le dipendenze:
sudo apt update sudo apt install -y fioSe l'hyperdisk non è ancora formattato, formatta e monta il disco.
Nel terminale, elenca i dischi collegati alla VM e trova il disco che vuoi testare.
sudo lsblkIl comando precedente produce un output simile al seguente:
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT nvme0n1 259:0 0 10G 0 disk ├─nvme0n1p1 259:1 0 9.9G 0 part / ├─nvme0n1p14 259:2 0 4M 0 part └─nvme0n1p15 259:3 0 106M 0 part /boot/efi nvme0n2 259:4 0 3.4T 0 disk
In questo esempio, stiamo testando un volume Hyperdisk Extreme da 3500 GiB con il nome del dispositivo
nvme0n2.Crea una nuova directory,
fiotest, sul disco. In questo esempio, il disco è montato su/mnt/disks/mnt_dir:TEST_DIR=/mnt/disks/mnt_dir/fiotest sudo mkdir -p $TEST_DIRSe la VM utilizza l'interfaccia del disco NVMe per il collegamento Hyperdisk (se il nome del disco non elaborato è preceduto da
nvme), svolgi i passaggi che seguono per ottenere il numero di nodi NUMA disponibili per la VM.La strategia di benchmarking per i dischi NVMe è diversa per le VM con un solo nucleo NUMA e per le VM con più di un nucleo NUMA. Quando testi le prestazioni di Hyperdisk utilizzando l'interfaccia del disco NVMe, vengono allocati solo 256 dimensioni della coda NVMe per coda. A causa delle dimensioni limitate delle code NVMe disponibili e della potenziale contesa proveniente dagli altri dischi collegati alla stessa VM, questi test di benchmark utilizzano due code dei dischi NVMe per mantenere una dimensione della coda aggregata in grado di gestire la profondità io di 256.
Recupera il numero di nodi NUMA.
lscpu | grep -i 'numa node(s)' | awk '{print $NF}'Se la VM ha un solo nodo NUMA, ottieni la mappatura della coda CPU-NVMe. Utilizzerai queste informazioni in un secondo momento per il parametro
--cpus-allowed.QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t") QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")
Testare la velocità effettiva di scrittura
Testa la velocità effettiva in scrittura eseguendo scritture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione del blocco I/O di 1 MB e una profondità I/O di almeno 64.
Se l'Hyperdisk utilizza l'interfaccia SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --name=write_throughput
Se l'Hyperdisk utilizza l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --group_reporting \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_2 --numa_cpu_nodes=1
Testa le IOPS di scrittura
Testa le IOPS di scrittura eseguendo scritture casuali, utilizzando una dimensione del blocco I/O di 4 KB e una profondità I/O di almeno 256.
Se l'Hyperdisk è collegato tramite interfaccia SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G -time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=write_iops
Se l'Hyperdisk utilizza l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 \ --size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=write_iops_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=write_iops --numa_cpu_nodes=0 \ --name=write_iops_2 --numa_cpu_nodes=1
Testare la velocità effettiva di lettura
Testa la velocità effettiva di lettura eseguendo letture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione del blocco I/O di 1 MB e una profondità I/O di almeno 64.
Se l'Hyperdisk utilizza l'interfaccia SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --name=read_throughput
Se l'Hyperdisk utilizza l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=read_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --group_reporting \ --name=read_throughput --numa_cpu_nodes=0 \ --name=read_throughput_2 --numa_cpu_nodes=1
Testare le IOPS di lettura
Testa le IOPS di lettura eseguendo letture casuali, utilizzando una dimensione del blocco I/O di 4 KB e una profondità I/O di almeno 256.
Se l'Hyperdisk utilizza l'interfaccia SCSI:
sudo fio --directory=$TEST_DIR \ --numjobs=16 --size=10G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=read_iops
Se l'Hyperdisk utilizza l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=read_iops --numa_cpu_nodes=0 \ --name=read_iops_2 --numa_cpu_nodes=1
Esegui la pulizia
Rimuovi le directory di test.
sudo rm $TEST_DIR/write* $TEST_DIR/read*
Benchmarking di IOPS e throughput per Hyperdisk Extreme su VM C3
Hyperdisk Extreme di Google Cloud offre prestazioni più elevate sulle VM C3 con 176 vCPU. Per raggiungere i limiti di prestazioni più elevati, devi collegare più volumi Hyperdisk Extreme alla VM.
Per misurare le operazioni di I/O al secondo (IOPS) o il throughput per un carico di lavoro realistico sui dischi attivi di una VM C3 in esecuzione senza perdere i contenuti dei dischi di dati esistenti, esegui un benchmark rispetto a una nuova directory sul file system esistente e collega nuovi volumi Hyperdisk Extreme alla VM per le attività di benchmarking.
Per i dischi collegati con l'interfaccia NVMe, è consigliabile distribuire il carico di lavoro I/O su tutte le code NVMe disponibili per la VM. In questo modo, viene massimizzato il rendimento di Hyperdisk. Nelle VM C3 con 176 vCPU sono presenti quattro nodi NUMA mappati 1:1 a quattro code NVMe. Questa mappatura è presupposta per i test di benchmarking in questa sezione.
Prepararsi per i test
Aggiungi nuovi dischi Hyperdisk Extreme alla tua VM e consulta i limiti di prestazioni di Hyperdisk per ricavare la configurazione del disco necessaria per le prestazioni target.
Connettiti all'istanza:
Installa le dipendenze:
sudo apt update sudo apt install -y fioElenca i dischi collegati alla VM e trova il disco che vuoi testare.
sudo lsblkIl comando precedente produce un output simile al seguente:
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT nvme0n1 259:0 0 10G 0 disk ├─nvme0n1p1 259:1 0 9.9G 0 part / ├─nvme0n1p14 259:2 0 4M 0 part └─nvme0n1p15 259:3 0 106M 0 part /boot/efi nvme0n2 259:4 0 2.5T 0 disk nvme0n3 259:5 0 2.5T 0 disk nvme0n4 259:6 0 2.5T 0 disk
In questo esempio, stiamo testando le prestazioni di Google Cloud Hyperdisk su tre volumi Hyperdisk Extreme da 2500 GiB con dispositivi denominati
nvme0n2,nvme0n3envme0n4.
Benchmark della velocità effettiva di Hyperdisk Extreme su C3
Questa sezione mostra come eseguire il benchmark della velocità effettiva di lettura e scrittura per i dischi Hyperdisk Extreme.
Preparazione per i test
Prima di iniziare a eseguire il benchmarking delle prestazioni dei dischi Hyperdisk Extreme collegati a una VM C3 con 176 vCPU, completa i seguenti passaggi.
Crea una nuova directory,
fiotest, nel sistema operativo. In questo esempio, la directory principale è/mnt/disks/mnt_dir:TEST_DIR=/mnt/disks/mnt_dir/fiotest sudo mkdir -p $TEST_DIRPoiché la VM richiede più di un disco per raggiungere i livelli di prestazioni più elevati, per semplificare, esegui RAID 0 su tutti i volumi Hyperdisk collegati. In questo modo, i dati possono essere distribuiti più facilmente su più volumi Hyperdisk.
In questo esempio, RAID 0 è il rendimento su tre volumi Hyperdisk Extreme collegati alla VM C3.
sudo mdadm --create /dev/md0 --level=0 --raid-devices=3 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4
Formatta e monta il volume RAID
/dev/md0.
Testare la velocità effettiva di scrittura
Testa la velocità effettiva di scrittura eseguendo scritture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione del blocco I/O di 1 MiB e una profondità I/O totale di almeno 32 per coda NVMe.
# Running this command causes data loss on the targeted file on the device. # We strongly recommend using a throwaway disk. sudo fio --name=global --group_reporting=1 --filesize=1024G \ --filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \ --offset_increment=64G --time_based --runtime=5m \ --ramp_time=10s --ioengine=libaio --direct=1 --verify=0 \ --bs=1M --iodepth=8 --rw=write \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_1 --numa_cpu_nodes=1 \ --name=write_throughput_2 --numa_cpu_nodes=2 \ --name=write_throughput_3 --numa_cpu_nodes=3
Testare la velocità effettiva di lettura
Testa la velocità in lettura eseguendo letture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione del blocco I/O di 1 MiB e una profondità I/O totale di almeno 32 per coda NVMe.
sudo fio --name=global --group_reporting=1 --filesize=1024G \ --filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \ --offset_increment=64G --time_based --runtime=5m \ --ramp_time=10s --ioengine=libaio --direct=1 \ --verify=0 --bs=1M --iodepth=8 --rw=read \ --name=read_throughput --numa_cpu_nodes=0 \ --name=read_throughput_1 --numa_cpu_nodes=1 \ --name=read_throughput_2 --numa_cpu_nodes=2 \ --name=read_throughput_3 --numa_cpu_nodes=3
Benchmark IOPS di Hyperdisk Extreme su C3
Per eseguire il benchmark delle prestazioni in termini di operazioni I/O al secondo (IOPS), ti consigliamo di eseguire piccole operazioni I/O in parallelo direttamente su o da dischi non formattati (senza RAID).
Testa le IOPS di scrittura
Testa le IOPS in scrittura eseguendo scritture casuali, utilizzando una dimensione del blocco I/O di 4 KiB e una profondità I/O di almeno 256, utilizzando almeno 2 code NVMe.
# Running this command causes data loss on the targeted device. # We strongly recommend using a throwaway disk. sudo fio --name=global --group_reporting=1 \ --directory=/ --bs=4K --direct=1 \ --filesize=512G --iodepth=256 \ --iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \ --ioengine=libaio --numjobs=5 --ramp_time=10s \ --randrepeat=0 --runtime=5m --rw=randwrite \ --time_based=1 --verify=0 \ --name=write_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \ --name=write_iops_test_1 --filename=/dev/nvme0n3 --numa_cpu_nodes=1 \ --name=write_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2
Testare le IOPS di lettura
Testa le IOPS in lettura eseguendo letture casuali, utilizzando una dimensione del blocco I/O di 4 KiB e una profondità I/O di almeno 256, utilizzando almeno 2 code NVMe.
sudo fio --name=global --group_reporting=1 --directory=/ \ --bs=4K --direct=1 --filesize=512G --iodepth=256 \ --iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \ --ioengine=libaio --numjobs=5 --ramp_time=10s \ --randrepeat=0 --runtime=5m --rw=randread \ --time_based=1 --verify=0 \ --name=read_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \ --name=read_iops_test_1 --filename=/dev/nvme0n3 --numa_cpu_nodes=1 \ --name=read_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2
Latenza del benchmark di Hyperdisk Extreme su C3
Durante il test della latenza I/O, la VM non deve raggiungere la larghezza di banda o le IOPS massime. In questo caso, la latenza osservata non rifletterà la latenza I/O effettiva di Hyperdisk.
Ad esempio, se la VM raggiunge il limite di IOPS a una profondità I/O di 30 e il comando fio lo ha raddoppiato, le IOPS totali rimangono invariate e la latenza I/O registrata raddoppia.
Per ottenere latenze I/O realistiche, è sufficiente scegliere come target un singolo dispositivo di disco non formattato.
Testa la latenza di scrittura
Testa la latenza di scrittura eseguendo scritture casuali, utilizzando una dimensione del blocco I/O di 4 KiB e una profondità di I/O di 4.
# Running this command causes data loss on the targeted device. # We strongly recommend using a throwaway disk. sudo fio --filename=/dev/nvme0n2 \ --filesize=512G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=write_latency
Testare la latenza di lettura
Testa la latenza di lettura eseguendo letture casuali, utilizzando una dimensione del blocco I/O di 4 KiB e una profondità I/O di 4.
sudo fio --filename=/dev/nvme0n2 \ --filesize=512G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=read_latency
Esegui la pulizia
Rimuovi i file di test.
sudo rm -rf $TEST_DIR/*Smonta e interrompi il volume RAID.
sudo umount /dev/md0 sudo mdadm --stop /dev/md0Scollega ed elimina i volumi Hyperdisk collegati. Consulta i comandi
gcloud compute instances detach-diskegcloud compute disks delete.
Benchmarking delle prestazioni di Hyperdisk non elaborate
Se vuoi misurare le prestazioni solo dei volumi Hyperdisk, al di fuori del tuo ambiente di sviluppo, puoi testare le prestazioni di lettura e scrittura di un dispositivo a blocchi su un disco e una VM usa e getta.
I comandi seguenti presuppongono un volume Hyperdisk Extreme da 3500 GiB collegato alla VM. Queste dimensioni del disco sono necessarie per raggiungere i limiti di throughput delle VM con 32 vCPU. Se le dimensioni del dispositivo sono diverse,
modifica il valore dell'argomento --filesize nei comandi che seguono.
Per ulteriori informazioni sui limiti di prestazioni per i tipi di VM, consulta
Supporto dei tipi di macchine.
Prepararsi per i test
Installa le dipendenze:
sudo apt-get update sudo apt-get install -y fioOttieni il percorso del disco non elaborato. Memorizza il percorso in una variabile. L'esempio seguente utilizza
/dev/nvme0n2come percorso del disco non elaborato:TEST_DIR=/dev/nvme0n2Riempi il disco con dati diversi da zero. Le letture di Hyperdisk da blocchi vuoti hanno un profilo di latenza diverso da quello dei blocchi che contengono dati. Ti consigliamo di riempire il disco prima di eseguire qualsiasi benchmark della latenza di lettura.
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --name=fill_disk \ --filename=$TEST_DIR --filesize=2500G \ --ioengine=libaio --direct=1 --verify=0 --randrepeat=0 \ --bs=128K --iodepth=64 --rw=randwrite \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64
Se la VM utilizza l'interfaccia del disco NVMe per il collegamento dell'hyperdisk (se il nome del disco non elaborato è preceduto da
nvme), segui questi passaggi per ottenere il numero di nodi NUMA disponibili per la VM.La strategia di benchmarking per i dischi NVMe è diversa per le VM con un solo nucleo NUMA e per le VM con più di un nucleo NUMA. Quando testi le prestazioni di Hyperdisk utilizzando l'interfaccia del disco NVMe, vengono allocati solo 256 dimensioni della coda NVMe per coda. A causa delle dimensioni limitate delle code NVMe disponibili e della potenziale contesa proveniente dagli altri dischi collegati alla stessa VM, questi test di benchmark utilizzano due code dei dischi NVMe per mantenere una dimensione della coda aggregata in grado di gestire la profondità di I/O di 256.
Recupera il numero di nodi NUMA.
lscpu | grep -i 'numa node(s)' | awk '{print $NF}'Se la VM ha un solo nodo NUMA, ottieni la mappatura della coda CPU-NVMe. Utilizzerai queste informazioni in un secondo momento per il parametro
--cpus-allowed.QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t") QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")
Testare la velocità effettiva di scrittura
Testa la velocità effettiva in scrittura eseguendo scritture sequenziali con più stream paralleli (almeno 16), utilizzando 1 MB come dimensione I/O e una profondità I/O di almeno 64.
Se l'Hyperdisk è collegato utilizzando l'interfaccia SCSI:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G \ --name=write_throughput
Se l'Hyperdisk utilizza l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --offset_increment=20G --group_reporting \ --name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \ --name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --group_reporting \ --name=write_throughput --numa_cpu_nodes=0 \ --name=write_throughput_2 --numa_cpu_nodes=1
Testa le IOPS di scrittura
Per ottenere il massimo delle IOPS di HyperDisk, devi mantenere una coda I/O profonda. Se, ad esempio, la latenza di scrittura è di 1 millisecondo, la VM può raggiungere al massimo 1000 IOPS per ogni I/O in esecuzione. Per raggiungere 15.000 IOPS in scrittura, la VM deve mantenere almeno 15 operazioni I/O in esecuzione. Se il disco e la VM possono raggiungere 30.000 IOPS in scrittura, il numero di operazioni I/O in esecuzione deve essere almeno 30. Se le dimensioni di I/O sono superiori a 4 KB, la VM potrebbe raggiungere il limite di larghezza di banda prima di raggiungere il limite di IOPS.
Testa le IOPS di scrittura eseguendo scritture casuali, utilizzando una dimensione del blocco I/O di 4 KB e una profondità I/O di almeno 256.
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia SCSI:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G -time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=write_iops
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=write_write_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=write_write_iops_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=write_iops --numa_cpu_nodes=0 \ --name=write_iops_2 --numa_cpu_nodes=1
Testa la latenza di scrittura
Durante il test della latenza I/O, la VM non deve raggiungere la larghezza di banda o le IOPS massime;
altrimenti, la latenza osservata non rifletterà la latenza I/O effettiva di Hyperdisk. Ad esempio, se il limite di IOPS viene raggiunto con una profondità I/O di 30 e il comando fio la raddoppia, le IOPS totali rimangono invariate e la latenza I/O registrata raddoppia.
# Running this command causes data loss on the second device. # We strongly recommend using a throwaway VM and disk. sudo fio --filename=$TEST_DIR \ --filesize=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=write_latency
Testare la larghezza di banda di lettura
Testa la larghezza di banda di lettura eseguendo letture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione I/O di 1 MB e una profondità I/O di almeno 64.
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia SCSI:
sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --name=read_bandwidth
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --cpus_allowed_policy=split \ --offset_increment=20G --group_reporting \ --name=read_bandwidth --cpus_allowed=$QUEUE_1_CPUS \ --name=read_bandwidth_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \ --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \ --offset_increment=20G --group_reporting \ --name=read_bandwidth --numa_cpu_nodes=0 \ --name=read_bandwidth_2 --numa_cpu_nodes=1
Testare le IOPS di lettura
Per raggiungere il numero massimo di IOPS di HyperDisk, devi mantenere una coda I/O profonda.
Ad esempio, se le dimensioni di I/O sono superiori a 4 KB, la VM potrebbe raggiungere il limite di larghezza di banda prima di raggiungere il limite di IOPS. Per ottenere le IOPS di lettura massime disponibili per un tipo di macchina, specifica --iodepth=256 per questo test.
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia SCSI:
sudo fio --filename=$TEST_DIR \ --numjobs=16 --size=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=read_iops
Se il volume Hyperdisk Extreme è collegato utilizzando l'interfaccia NVMe:
Se la VM ha un solo nodo NUMA, utilizza il seguente comando:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --cpus_allowed_policy=split \ --group_reporting \ --name=read_iops --cpus_allowed=$QUEUE_1_CPUS \ --name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS
Se la VM ha più di un nodo NUMA, utilizza il seguente comando:
sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \ --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --group_reporting \ --name=read_iops --numa_cpu_nodes=0 \ --name=read_iops_2 --numa_cpu_nodes=1
Testare la latenza di lettura
È importante riempire il disco con dati per ottenere una misurazione della latenza realistica. È importante che la VM non raggiunga i limiti di IOPS o throughput durante questo test perché, dopo che il volume Hyperdisk ha raggiunto il limite di saturazione, restituisce le operazioni I/O in entrata. Questo ritardo si riflette come un aumento artificiale della latenza I/O.
sudo fio --filename=$TEST_DIR \ --filesize=500G --time_based \ --runtime=5m --ramp_time=10s --ioengine=libaio \ --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \ --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \ --name=read_latency
Esegui la pulizia
Se hai utilizzato un disco e una VM usa e getta come consigliato, al termine dei test di benchmark puoi:
- Scollega ed elimina il disco.
- Elimina la VM.
Passaggi successivi
- Scopri di più sui prezzi di Hyperdisk.