Benchmark ssd su linux: come misurare le stesse cose che il crystaldiskmark fa in Windows


26

Voglio fare un benchmark di un ssd (possibilmente con filesystem crittografati) e confrontarlo con i benchmark fatti da crystaldiskmark su Windows.

CrystalDiskMark su Windows

Quindi, come posso misurare approssimativamente le stesse cose che fa il crystaldiskmark?

Per la prima fila (Seq) penso di poter fare qualcosa del genere

LC_ALL=C dd if=/dev/zero of=tempfile bs=1M count=1024 conv=fdatasync,notrunc

sudo su -c "echo 3 > /proc/sys/vm/drop_caches"
LC_ALL=C dd if=tempfile of=/dev/null bs=1M count=1024

Ma non sono sicuro dei ddparametri.

Per i 512 KB casuali, 4KB, 4KB (profondità della coda = 32) legge / scrive i test di velocità Non ho idea di come riprodurre le misurazioni in Linux? Quindi come posso farlo?

Per testare la velocità di lettura, qualcosa del genere sudo hdparm -Tt /dev/sdanon sembra avere senso per me, dal momento che voglio, ad esempio, fare un benchmark su qualcosa come i encfssupporti.

modificare

@Alko, @iain

Forse dovrei scrivere qualcosa sulla motivazione di questa domanda: sto cercando di confrontare il mio SSD e confrontare alcune soluzioni di crittografia. Ma questa è un'altra domanda (il modo migliore per confrontare diverse soluzioni di crittografia sul mio sistema ). Durante la navigazione in rete su ssd e benchmarking ho visto spesso utenti pubblicare i loro risultati CrystelDiskMark nei forum. Quindi questa è l'unica motivazione per la domanda. Voglio solo fare lo stesso su Linux. Per il mio benchmark specifico vedi la mia altra domanda.


Perché non usi uno strumento di benchmarking, che funziona su entrambi i sistemi?
Alko,

Ho trovato questo, sembra molto utile e nel mio breve test su tre unità separate ha dato numeri molto simili all'attuale cristalli di cristalli ... github.com/buty4649/fio-cdm
ljwobker

2019: questa Q merita un nuovo inizio - argomento importante, ma qui ha perso un po 'di attenzione. "Accetta e archivia".
rastafile,

Risposte:


22

Direi che fio non avrebbe problemi a produrre quei carichi di lavoro. Si noti che nonostante il suo nome CrystalDiskMark è in realtà un punto di riferimento di un filesystem su un determinato disco - non può fare I / O crudo sul solo disco. In quanto tale avrà sempre un sovraccarico di filesystem (non necessariamente una cosa negativa ma qualcosa di cui essere consapevoli, ad esempio perché i filesystem confrontati potrebbero non essere gli stessi).

Un esempio basato sulla replica dell'output nello screenshot sopra integrato integrato dalle informazioni del manuale CrystalDiskMark (questo non è completo ma dovrebbe dare l'idea generale):

fio --loops=5 --size=1000m --filename=/mnt/fs/fiotest.tmp --stonewall --ioengine=libaio --direct=1 \
  --name=Seqread --bs=1m --rw=read \
  --name=Seqwrite --bs=1m --rw=write \
  --name=512Kread --bs=512k --rw=randread \
  --name=512Kwrite --bs=512k --rw=randwrite \
  --name=4kQD32read --bs=4k --iodepth=32 --rw=randread \
  --name=4kQD32write --bs=4k --iodepth=32 --rw=randwrite
rm -f /mnt/fs/fiotest.tmp 

ATTENZIONE : questo esempio distrugge permanentemente i dati /mnt/fs/fiotest.tmp!

Un elenco di parametri fio è disponibile su http://fio.readthedocs.io/en/latest/fio_doc.html .


3
Ho provato fio in Ubuntu 16.04 e CrystalDiskMark in Windows 7. Alcuni numeri corrispondono mentre altri no. Il r / w sequenziale era disattivato di un fattore 2. Significato, i valori di Linux erano il 50% di quelli riportati da CDM v3.0.4 (nota: la versione corrente è 6.0.0, ma le versioni precedenti sono ancora disponibili per il download). Per giocherellare con la disparità ho impostato bs = 4m invece di 1m. Ciò ha reso i numeri più vicini. Provare 8m e 32m lo ha reso ancora più vicino. Alla fine, come ha detto Anon, la sua risposta non è completa e come @Alko, abbiamo bisogno dello stesso strumento su entrambi i sistemi operativi. Si noti inoltre che il più recente CDM 6 utilizza test diversi rispetto a OP. Informazioni utili Anon
Vahid Pazirandeh,

2
@VahidPazirandeh Interessante, github.com/buty4649/fio-cdm/blob/master/fio-cdm ha le stesse impostazioni di 1m, forse la documentazione di cdm non è abbastanza buona.
inf3rno,

@ vahid-pazirandeh Prego. NB: se si desidera lo stesso strumento su entrambi i sistemi operativi, tenere presente che esiste anche una versione di fio Windows.
Anon

8

Ho creato uno script che tenta di replicare il comportamento di crystaldiskmark con fio. Lo script esegue tutti i test disponibili nelle varie versioni di crystaldiskmark fino a crystaldiskmark 6, inclusi i test 512K e 4KQ8T8.

La sceneggiatura dipende da fio e df . Se non si desidera installare df, cancellare le righe da 19 a 21 (lo script non visualizzerà più quale unità è in fase di test) o provare la versione modificata da un commentatore . (Può anche risolvere altri possibili problemi)

#!/bin/bash

LOOPS=5 #How many times to run each test
SIZE=1024 #Size of each test, multiples of 32 recommended for Q32 tests to give the most accurate results.
WRITEZERO=0 #Set whether to write zeroes or randoms to testfile (random is the default for both fio and crystaldiskmark); dd benchmarks typically only write zeroes which is why there can be a speed difference.

QSIZE=$(($SIZE / 32)) #Size of Q32Seq tests
SIZE+=m
QSIZE+=m

if [ -z $1 ]; then
    TARGET=$HOME
    echo "Defaulting to $TARGET for testing"
else
    TARGET="$1"
    echo "Testing in $TARGET"
fi

DRIVE=$(df $TARGET | grep /dev | cut -d/ -f3 | cut -d" " -f1 | rev | cut -c 2- | rev)
DRIVEMODEL=$(cat /sys/block/$DRIVE/device/model)
DRIVESIZE=$(($(cat /sys/block/$DRIVE/size)*512/1024/1024/1024))GB

echo "Configuration: Size:$SIZE Loops:$LOOPS Write Only Zeroes:$WRITEZERO
Running Benchmark on: /dev/$DRIVE, $DRIVEMODEL ($DRIVESIZE), please wait...
"

fio --loops=$LOOPS --size=$SIZE --filename=$TARGET/.fiomark.tmp --stonewall --ioengine=libaio --direct=1 --zero_buffers=$WRITEZERO --output-format=json \
  --name=Bufread --loops=1 --bs=$SIZE --iodepth=1 --numjobs=1 --rw=readwrite \
  --name=Seqread --bs=$SIZE --iodepth=1 --numjobs=1 --rw=read \
  --name=Seqwrite --bs=$SIZE --iodepth=1 --numjobs=1 --rw=write \
  --name=512kread --bs=512k --iodepth=1 --numjobs=1 --rw=read \
  --name=512kwrite --bs=512k --iodepth=1 --numjobs=1 --rw=write \
  --name=SeqQ32T1read --bs=$QSIZE --iodepth=32 --numjobs=1 --rw=read \
  --name=SeqQ32T1write --bs=$QSIZE --iodepth=32 --numjobs=1 --rw=write \
  --name=4kread --bs=4k --iodepth=1 --numjobs=1 --rw=randread \
  --name=4kwrite --bs=4k --iodepth=1 --numjobs=1 --rw=randwrite \
  --name=4kQ32T1read --bs=4k --iodepth=32 --numjobs=1 --rw=randread \
  --name=4kQ32T1write --bs=4k --iodepth=32 --numjobs=1 --rw=randwrite \
  --name=4kQ8T8read --bs=4k --iodepth=8 --numjobs=8 --rw=randread \
  --name=4kQ8T8write --bs=4k --iodepth=8 --numjobs=8 --rw=randwrite > $TARGET/.fiomark.txt

SEQR="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "Seqread"' | grep bw_bytes | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "Seqread"' | grep -m1 iops | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
SEQW="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "Seqwrite"' | grep bw_bytes | sed '2!d' | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "Seqwrite"' | grep iops | sed '7!d' | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
F12KR="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "512kread"' | grep bw_bytes | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "512kread"' | grep -m1 iops | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
F12KW="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "512kwrite"' | grep bw_bytes | sed '2!d' | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "512kwrite"' | grep iops | sed '7!d' | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
SEQ32R="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "SeqQ32T1read"' | grep bw_bytes | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "SeqQ32T1read"' | grep -m1 iops | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
SEQ32W="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "SeqQ32T1write"' | grep bw_bytes | sed '2!d' | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "SeqQ32T1write"' | grep iops | sed '7!d' | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
FKR="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kread"' | grep bw_bytes | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kread"' | grep -m1 iops | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
FKW="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kwrite"' | grep bw_bytes | sed '2!d' | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kwrite"' | grep iops | sed '7!d' | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
FK32R="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kQ32T1read"' | grep bw_bytes | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kQ32T1read"' | grep -m1 iops | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
FK32W="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kQ32T1write"' | grep bw_bytes | sed '2!d' | cut -d: -f2 | sed s:,::g)/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kQ32T1write"' | grep iops | sed '7!d' | cut -d: -f2 | cut -d. -f1 | sed 's: ::g')"
FK8R="$(($(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kQ8T8read"' | grep bw_bytes | sed 's/        "bw_bytes" : //g' | sed 's:,::g' | awk '{ SUM += $1} END { print SUM }')/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A15 '"name" : "4kQ8T8read"' | grep iops | sed 's/        "iops" : //g' | sed 's:,::g' | awk '{ SUM += $1} END { print SUM }' | cut -d. -f1)"
FK8W="$(($(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kQ8T8write"' | grep bw_bytes | sed 's/        "bw_bytes" : //g' | sed 's:,::g' | awk '{ SUM += $1} END { print SUM }')/1024/1024))MB/s IOPS=$(cat $TARGET/.fiomark.txt | grep -A80 '"name" : "4kQ8T8write"' | grep '"iops" '| sed 's/        "iops" : //g' | sed 's:,::g' | awk '{ SUM += $1} END { print SUM }' | cut -d. -f1)"

echo -e "
Results from /dev/$DRIVE, $DRIVEMODEL ($DRIVESIZE):  
\033[0;33m
Sequential Read: $SEQR
Sequential Write: $SEQW
\033[0;32m
512KB Read: $F12KR
512KB Write: $F12KW
\033[1;36m
Sequential Q32T1 Read: $SEQ32R
Sequential Q32T1 Write: $SEQ32W
\033[0;36m
4KB Read: $FKR
4KB Write: $FKW
\033[1;33m
4KB Q32T1 Read: $FK32R
4KB Q32T1 Write: $FK32W
\033[1;35m
4KB Q8T8 Read: $FK8R
4KB Q8T8 Write: $FK8W
"

rm $TARGET/.fiomark.txt $TARGET/.fiomark.tmp

Che produrrà risultati come questo:

Results from /dev/sdb, Corsair Force GT (111GB):  

Sequential Read: 533MB/s IOPS=0
Sequential Write: 125MB/s IOPS=0

512KB Read: 457MB/s IOPS=914
512KB Write: 133MB/s IOPS=267

Sequential Q32T1 Read: 534MB/s IOPS=16
Sequential Q32T1 Write: 134MB/s IOPS=4

4KB Read: 32MB/s IOPS=8224
4KB Write: 150MB/s IOPS=38460

4KB Q32T1 Read: 195MB/s IOPS=49951
4KB Q32T1 Write: 121MB/s IOPS=31148

4KB Q8T8 Read: 129MB/s IOPS=33149
4KB Q8T8 Write: 132MB/s IOPS=33796

(I risultati sono codificati a colori, per rimuovere la codifica a colori rimuovere tutte le istanze di \033[x;xxm(dove x è un numero) dal comando echo nella parte inferiore dello script.)

Lo script eseguito senza argomenti verificherà la velocità dell'unità / partizione home. È anche possibile immettere un percorso per una directory su un altro disco rigido se si desidera testarlo. Durante l'esecuzione dello script crea file temporanei nascosti nella directory di destinazione che pulisce al termine dell'esecuzione (.fiomark.tmp e .fiomark.txt)

Non è possibile visualizzare i risultati del test mentre vengono completati, ma se si annulla il comando mentre è in esecuzione prima del completamento di tutti i test, si vedranno i risultati dei test completati e anche i file temporanei verranno eliminati in seguito.

Dopo alcune ricerche, ho scoperto che il benchmark dei cristalli di cristallo risulta sullo stesso modello di unità in cui mi sembra che corrisponda relativamente da vicino ai risultati di questo benchmark fio, almeno a prima vista. Dato che non ho un'installazione di Windows, non posso verificare quanto siano realmente vicini sulla stessa unità.

Nota che a volte potresti ottenere risultati leggermente diversi, specialmente se stai facendo qualcosa in background mentre i test sono in esecuzione, quindi è consigliabile eseguire il test due volte di seguito per confrontare i risultati.

Questi test richiedono molto tempo per essere eseguiti. Le impostazioni predefinite nello script sono attualmente adatte per un normale SSD (SATA).

Impostazione SIZE consigliata per unità diverse:

  • (SATA) SSD: 1024 (impostazione predefinita)
  • (QUALSIASI) HDD: 256
  • (NVME di fascia alta) SSD: 4096
  • (NVME di fascia medio bassa) SSD: 1024 (impostazione predefinita)

Un NVME di fascia alta in genere ha una velocità di lettura di circa 2 GB / s (Intel Optane e Samsung 960 EVO sono esempi; ma in quest'ultimo caso consiglierei 2048 invece a causa di velocità più basse di 4kb.), Un Low-Mid End può avere ovunque tra ~ 500-1800 MB / s velocità di lettura.

Il motivo principale per cui queste dimensioni devono essere regolate è a causa di quanto tempo richiederebbero i test altrimenti, ad esempio per gli HDD più vecchi / più deboli, è possibile avere velocità di lettura pari a 0,4 MB / s 4kb. Provi ad aspettare 5 loop da 1 GB a quella velocità, altri test da 4kb in genere hanno una velocità di circa 1 MB / s. Ne abbiamo 6. Ogni 5 cicli in esecuzione, aspetti che vengano trasferiti 30 GB di dati a quelle velocità? O vuoi invece ridurlo a 7,5 GB di dati (a 256 MB / s è un test di 2-3 ore)

Naturalmente, il metodo ideale per gestire quella situazione sarebbe quello di eseguire test sequenziali e 512k separati dai test 4k (quindi esegui i test sequenziali e 512k con qualcosa come dire 512m, quindi esegui i test 4k a 32m)

I modelli di HDD più recenti sono di fascia più alta e possono ottenere risultati molto migliori di così.

E il gioco è fatto. Godere!


Hai controllato come si comporta il tuo script con fio su Windows?
Anon,

1
(Una nota per i lettori diversi da Cestarian: se stai creando un nuovo strumento che utilizza fio quindi se possibile non raschiare l'output fio leggibile dall'uomo - usa --output-format=jsone analizza il JSON. L'output leggibile dall'uomo di Fio non è pensato per le macchine e non è stabile tra le versioni fio. Vedi questo video di YouTube di un caso in cui la produzione umana di fio ha portato a un risultato indesiderato )
Anon,

Grazie, lo terrò a mente, purtroppo non ho più un'installazione di Windows, quindi non posso provarlo ... ma, ho deciso di cercare i risultati del segno di cristallo per il mio SSD e sembra che la mia memoria fosse sbagliata, dal momento che il i risultati si sommano a quello che sto ricevendo su fio dopo tutto. È stato un malinteso da parte mia che mi ha portato a pensare che i risultati fossero più lenti: / lo correggerò. Presto aggiornerò anche questa risposta per usare l'output json per futureproofing, e forse una versione della GUI (ho iniziato a lavorarci su, ma gtkdialog è scarsamente documentato e la zenità è limitata, quindi mi sto divertendo)
Cestarian

1
@Cestarian, ottima sceneggiatura, ma non funziona "out of the box" su CentOS7. Ho dovuto modificarlo un po '.
Igor,

1
@Igor Interessante, sì, ce l'ho fatta su Manjaro e non sono un grande esperto di bash :) Ho menzionato la tua versione modificata nella risposta nel caso in cui qualcun altro abbia dei problemi.
Cestarian

5

Puoi usare iozonee bonnie. Possono fare ciò che il marchio del disco di cristallo può fare e altro ancora.

Personalmente ho usato iozonemolto durante l'analisi comparativa e i dispositivi di stress test dai personal computer ai sistemi di archiviazione aziendali. Ha una modalità automatica che fa tutto ma puoi adattarla alle tue esigenze.


5
Come riprodurre con questo le misure del segno di cristallo in dettaglio?
studente

2
Farò del mio meglio per scrivere un howto, ma ho bisogno dell'elenco dei test condotti da Crystal Disk Mark. Esistono altri test che il software esegue oltre a quelli visibili sullo screenshot.
Bayindirh,

1
Solo quelli nello screenshot.
tr

1

Non sono sicuro che i vari test più profondi abbiano un senso reale quando si considera ciò che si sta facendo in dettaglio.

Le impostazioni come la dimensione del blocco e la profondità della coda sono parametri per il controllo dei parametri di input / output di basso livello dell'interfaccia ATA su cui si trova l'SSD.

Questo è tutto bene quando stai eseguendo alcuni test di base su un'unità in modo abbastanza diretto, come ad un file di grandi dimensioni in un semplice file system partizionato.

Una volta che inizi a parlare del benchmarking di un encfs, questi parametri non si applicano più in particolare al tuo filesystem, il filesystem è solo un'interfaccia in qualcos'altro che alla fine esegue il backup su un filesystem che esegue il backup su un'unità.

Penso che sarebbe utile capire esattamente cosa stai cercando di misurare, perché ci sono due fattori in gioco qui: la velocità di IO del disco grezzo, che puoi testare temporizzando vari comandi DD (puoi dare esempi se questo è quello che vuoi) / senza / encfs, altrimenti il ​​processo sarà limitato dalla CPU dalla crittografia e stai provando a testare il throughput relativo dell'algoritmo di crittografia. Nel qual caso i parametri per la profondità della coda ecc. Non sono particolarmente rilevanti.

In entrambi i casi, un comando DD a tempo ti fornirà le statistiche di throughput di base che cerchi, ma dovresti considerare ciò che intendi misurare e i relativi parametri.

Questo collegamento sembra fornire una buona guida al test della velocità del disco usando i comandi DD temporizzati, inclusa la copertura necessaria su "sconfiggere buffer / cache" e così via. Probabilmente questo fornirà le informazioni di cui hai bisogno. Decidi quale ti interessa di più, prestazioni del disco o prestazioni di crittografia, uno dei due sarà il collo di bottiglia e la regolazione del non collo di bottiglia non gioverà a nulla.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.