Per eseguire il benchmark delle prestazioni di Google Cloud Hyperdisk,
utilizza Flexible I/O tester (FIO)
al posto di altri strumenti di benchmarking del disco come dd.
Per impostazione predefinita, dd utilizza una profondità di coda di I/O molto bassa, pertanto è difficile garantire
che il benchmark generi un numero di byte e operazioni di I/O sufficienti
per testare con accuratezza le prestazioni del disco.
Inoltre, i dispositivi speciali utilizzati con dd sono spesso molto lenti e non
rispecchiano accuratamente 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 il throughput 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 workload realistico senza perdere i contenuti del disco esistente. Tieni presente che quando esegui il benchmark del file system su un disco esistente, ci sono molti fattori specifici legati all'ambiente di sviluppo che possono influire sui risultati del benchmarking. Quindi potresti non raggiungere i limiti di prestazioni del disco.
Per misurare le prestazioni non elaborate di un Hyperdisk, esegui il benchmark direttamente sul dispositivo a blocchi. Utilizza questa opzione per confrontare le prestazioni del disco non formattato con i limiti di prestazioni di Hyperdisk.
I seguenti comandi funzionano con i sistemi operativi Debian o Ubuntu con il
gestore di pacchetti apt.
Benchmarking delle IOPS e del throughput di un disco su un'istanza in esecuzione
Se vuoi misurare le IOPS e il throughput per un workload 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.
Preparati per i test
Installa le dipendenze:
sudo apt update sudo apt install -y fioSe il volume Hyperdisk non è ancora formattato, formatta e monta il disco.
Nel terminale crea un elenco dei 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 viene testato un volume Hyperdisk Extreme da 3500 GiB con
nvme0n2come nome del dispositivo.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 di disco NVMe per il collegamento del volume Hyperdisk (se il nome del disco non formattato è preceduto da
nvme), esegui i passaggi riportati di seguito per ottenere il numero di nodi NUMA disponibili per la VM.Alle VM con un solo nucleo NUMA e a quelle con più di un nucleo NUMA si applicano strategie di benchmarking per i dischi NVMe diverse. Quando testi le prestazioni di Hyperdisk tramite l'interfaccia del disco NVMe, vengono allocate solo 256 dimensioni della coda NVMe a ciascuna coda. A causa delle dimensioni limitate delle code NVMe disponibili e dei potenziali conflitti derivanti dagli altri dischi collegati alla stessa VM, queste analisi comparative utilizzano due code dei dischi NVMe per mantenere una dimensione della coda aggregata in grado di gestire una profondità di I/O di 256.
Ottieni 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")
Testa il throughput di scrittura
Testa il throughput di scrittura eseguendo scritture sequenziali con più stream paralleli (più di 16), utilizzando una dimensione dei blocchi di I/O di 1 MB e una profondità di I/O di almeno 64.
Se il volume 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 il volume 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 dei blocchi di I/O di 4 KB e una profondità di I/O di almeno 256.
Se il volume Hyperdisk è collegato tramite 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=randwrite \ --iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \ --name=write_iops
Se il volume 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
Testa il throughput di lettura
Testa il throughput di lettura eseguendo letture sequenziali con più stream paralleli (più di 16), utilizzando una dimensione dei blocchi di I/O di 1 MB e una profondità di I/O di almeno 64.
Se il volume 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 il volume 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
Testa le IOPS di lettura
Testa le IOPS di lettura eseguendo letture casuali, utilizzando una dimensione dei blocchi di I/O di 4 KB e una profondità di I/O di almeno 256.
Se il volume 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 il volume 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
Google Cloud Hyperdisk Extreme 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 workload realistico sui dischi attivi di una VM C3 in esecuzione senza perdere i contenuti dei tuoi dischi di dati esistenti, esegui il 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 workload di I/O su tutte le code NVMe disponibili per la VM. Così si massimizza la prestazione del volume Hyperdisk. Nelle VM C3 con 176 vCPU sono presenti quattro nodi NUMA mappati 1:1 su quattro code NVMe. Questa mappatura è un requisito per le analisi comparative di questa sezione.
Preparati 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 raggiungere le prestazioni target.
Connettiti all'istanza:
Installa le dipendenze:
sudo apt update sudo apt install -y fioElenca i dischi collegati alla VM e trova quello 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 vengono testate le prestazioni di Google Cloud Hyperdisk su tre volumi Hyperdisk Extreme da 2500 GiB con dispositivi denominati
nvme0n2,nvme0n3envme0n4.
Esegui il benchmark del throughput di Hyperdisk Extreme su C3
Questa sezione mostra come eseguire il benchmark del throughput di lettura e scrittura per i dischi Hyperdisk Extreme.
Preparazione ai test
Prima di iniziare a eseguire il benchmark delle prestazioni dei dischi Hyperdisk Extreme che sono 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 root è/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 prestazione più elevati, per semplicità, usa RAID 0 su tutti i volumi Hyperdisk collegati. Così è più facile distribuire i dati in modo uniforme su più volumi Hyperdisk.
In questo esempio, RAID 0 rappresenta le prestazioni 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.
Testa il throughput di scrittura
Testa il throughput di scrittura eseguendo scritture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione dei blocchi di I/O di 1 MiB e una profondità di I/O totale di almeno 32 per ciascuna 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
Testa il throughput di lettura
Testa il throughput in lettura eseguendo letture sequenziali con più stream paralleli (almeno 16), utilizzando una dimensione dei blocchi di I/O di 1 MiB e una profondità di I/O totale di almeno 32 per ciascuna 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
Esegui il benchmark delle IOPS di Hyperdisk Extreme su C3
Per eseguire il benchmark delle prestazioni in termini di operazioni di I/O al secondo (IOPS), ti consigliamo di eseguire piccole operazioni di 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 dei blocchi di I/O di 4 KiB e una profondità di 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
Testa le IOPS di lettura
Testa le IOPS di lettura eseguendo letture casuali, utilizzando una dimensione dei blocchi di I/O di 4 KiB e una profondità di I/O di almeno 256, utilizzano 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
Esegui il benchmark del tempo di latenza di Hyperdisk Extreme su C3
Durante il test della latenza di 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 di I/O effettiva di Hyperdisk.
Ad esempio, se la VM raggiunge il limite di IOPS a una profondità di I/O di 30 e il
comando fio lo ha raddoppiato, le IOPS totali rimangono invariate e la
latenza di I/O registrata raddoppia.
Per ottenere latenze di I/O realistiche, è sufficiente scegliere come target un singolo disco non formattato.
Testa la latenza di scrittura
Testa la latenza di scrittura eseguendo scritture casuali, utilizzando una dimensione dei blocchi di I/O di 4 KiB e una profondità 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
Testa la latenza di lettura
Testa la latenza di lettura eseguendo letture casuali, utilizzando una dimensione dei blocchi di I/O di 4 KiB e una profondità di 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. Fai riferimento ai comandi
gcloud compute instances detach-diskegcloud compute disks delete.
Esegui il benchmark 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.
Per i comandi seguenti è richiesto un volume Hyperdisk Extreme da 3500 GiB
collegato alla VM. Queste dimensioni di 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.
Preparati per i test
Installa le dipendenze:
sudo apt-get update sudo apt-get install -y fioOttieni il percorso del disco non formattato. Archivia il percorso in una variabile. L'esempio seguente utilizza
/dev/nvme0n2come percorso del disco non formattato:TEST_DIR=/dev/nvme0n2Riempi il disco con dati diversi da zero. Le letture di Hyperdisk di 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 attività di benchmarking 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 di disco NVMe per il collegamento di Hyperdisk (se il nome del disco non formattato è preceduto da
nvme), esegui i passaggi riportati di seguito per ottenere il numero di nodi NUMA disponibili per la VM.Alle VM con un solo nucleo NUMA e a quelle con più di un nucleo NUMA si applicano strategie di benchmarking per i dischi NVMe diverse. Quando testi le prestazioni di Hyperdisk tramite l'interfaccia del disco NVMe, vengono allocate solo 256 dimensioni della coda NVMe a ciascuna coda. A causa delle dimensioni limitate delle code NVMe disponibili e dei potenziali conflitti derivanti dagli altri dischi collegati alla stessa VM, queste analisi comparative utilizzano due code dei dischi NVMe per mantenere una dimensione della coda aggregata in grado di gestire una profondità di I/O di 256.
Ottieni 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")
Testa il throughput di scrittura
Testa il throughput in scrittura eseguendo scritture sequenziali con più stream paralleli (più di 16), utilizzando 1 MB come dimensione di I/O e una profondità di I/O di almeno 64.
Se l'Hyperdisk è collegato tramite 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 il volume 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 dalle IOPS di HyperDisk, devi mantenere una profondità della coda di I/O elevata. Ad esempio, se 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 in esecuzione almeno 15 operazioni di I/O. Se il disco e la VM possono raggiungere 30.000 IOPS in scrittura, devono esserci almeno 30 operazioni di I/O in esecuzione. Se le dimensioni di I/O sono superiori a 4 KB, la VM potrebbe raggiungere il limite di larghezza di banda prima del limite di IOPS.
Testa le IOPS di scrittura eseguendo scritture casuali, utilizzando una dimensione dei blocchi di I/O di 4 KB e una profondità di I/O di almeno 256.
Se il volume Hyperdisk Extreme è collegato tramite 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 tramite 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 di I/O, la VM non deve raggiungere la larghezza di banda o le IOPS massime;
altrimenti, la latenza osservata non rifletterà la latenza di I/O effettiva
di Hyperdisk. Ad esempio, se il limite di IOPS viene raggiunto a una profondità di I/O di 30 e
il comando fio ha raddoppiato questo valore, le IOPS totali rimangono invariate e
la latenza di 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
Testa la larghezza di banda di lettura
Testa la larghezza di banda di lettura eseguendo letture sequenziali con più stream paralleli (più di 16), utilizzando una dimensione di I/O di 1 MB e una profondità di I/O di almeno 64.
Se il volume Hyperdisk Extreme è collegato tramite 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 tramite 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
Testa le IOPS di lettura
Per raggiungere le IOPS massime di HyperDisk, devi mantenere una profondità della coda di I/O elevata.
Ad esempio, se le dimensioni di I/O sono superiori a 4 KB, la VM potrebbe raggiungere
il limite di larghezza di banda prima del 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 tramite 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 tramite 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
Testa la latenza di lettura
È importante riempire il disco con dei dati per ottenere una misurazione realistica della latenza. È importante che la VM non raggiunga i limiti di IOPS o throughput durante il test perché, una volta che il volume Hyperdisk ha raggiunto il limite di saturazione, respinge le operazioni di I/O in entrata. Questo provoca un aumento artificiale della latenza di 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 delle analisi comparative puoi:
- scollegare ed eliminare il disco;
- eliminare la VM.
Passaggi successivi
- Scopri di più sui prezzi di Hyperdisk.