Come verificare le prestazioni di un disco rigido (tramite terminale o GUI). La velocità di scrittura La velocità di lettura. Dimensione e velocità della cache. Velocità casuale.
Come verificare le prestazioni di un disco rigido (tramite terminale o GUI). La velocità di scrittura La velocità di lettura. Dimensione e velocità della cache. Velocità casuale.
Risposte:
hdparm
è un buon punto di partenza.
sudo hdparm -Tt /dev/sda
/dev/sda:
Timing cached reads: 12540 MB in 2.00 seconds = 6277.67 MB/sec
Timing buffered disk reads: 234 MB in 3.00 seconds = 77.98 MB/sec
sudo hdparm -v /dev/sda
fornirà anche informazioni.
dd
ti darà informazioni sulla velocità di scrittura.
Se l'unità non ha un file system (e solo allora ), utilizzare of=/dev/sda
.
Altrimenti, montalo su / tmp e scrivi, quindi elimina il file di output del test.
dd if=/dev/zero of=/tmp/output bs=8k count=10k; rm -f /tmp/output
10240+0 records in
10240+0 records out
83886080 bytes (84 MB) copied, 1.08009 s, 77.7 MB/s
gnome-disks
C'è qualcos'altro che vuoi?
/dev/urandom
e gli /dev/zero
input per dd
testare un SSD poiché la compressibilità dei dati può avere un effetto enorme sulla velocità di scrittura.
/tmp
filesystem utilizza spesso un ramdisk. Quindi scrivere su /tmp
sembrerebbe testare la tua memoria, non il tuo sottosistema di dischi.
Suominen ha ragione, dovremmo usare una sorta di sincronizzazione; ma esiste un metodo più semplice, conv = fdatasync farà il lavoro:
dd if=/dev/zero of=/tmp/output conv=fdatasync bs=384k count=1k; rm -f /tmp/output
1024+0records in
1024+0 records out
402653184 bytes (403 MB) copied, 3.19232 s, 126 MB/s
Non consiglierei di usarlo /dev/urandom
perché è basato su software e lento come un maiale. Meglio prendere una fetta di dati casuali su ramdisk. Sul test del disco rigido casuale non importa, perché ogni byte è scritto così com'è (anche su ssd con dd). Ma se testiamo il pool zfs dedupped con zero puro o dati casuali, c'è un'enorme differenza di prestazioni.
Un altro punto di vista deve essere l'inclusione del tempo di sincronizzazione; tutti i moderni filesystem utilizzano la memorizzazione nella cache delle operazioni sui file.
Per misurare davvero la velocità del disco e non la memoria, è necessario sincronizzare il filesystem per eliminare l'effetto di memorizzazione nella cache. Questo può essere facilmente fatto da:
time sh -c "dd if=/dev/zero of=testfile bs=100k count=1k && sync"
con quel metodo ottieni output:
sync ; time sh -c "dd if=/dev/zero of=testfile bs=100k count=1k && sync" ; rm testfile
1024+0 records in
1024+0 records out
104857600 bytes (105 MB) copied, 0.270684 s, 387 MB/s
real 0m0.441s
user 0m0.004s
sys 0m0.124s
quindi il datarate del disco è solo 104857600 / 0.441 = 237772335 B / s -> 237 MB / s
È inferiore di oltre 100 MB / s rispetto alla memorizzazione nella cache.
Buon benchmarking,
Se si desidera monitorare la velocità di lettura e scrittura del disco in tempo reale, è possibile utilizzare lo strumento iotop .
Ciò è utile per ottenere informazioni esatte sull'esecuzione di un disco per una determinata applicazione o attività. L'output mostrerà la velocità di lettura / scrittura per processo e la velocità di lettura / scrittura totale per il server, molto simile a top
.
Per installare iotop:
sudo apt-get install iotop
Per eseguirlo:
sudo iotop
Se vuoi la precisione, dovresti usare fio
. Richiede la lettura del manuale ( man fio
) ma ti darà risultati accurati. Si noti che per qualsiasi precisione, è necessario specificare esattamente ciò che si desidera misurare. Qualche esempio:
Velocità READ sequenziale con blocchi grandi (questo dovrebbe essere vicino al numero che vedi nelle specifiche per il tuo disco):
fio --name TEST --eta-newline=5s --filename=fio-tempfile.dat --rw=read --size=500m --io_size=10g --blocksize=1024k --ioengine=libaio --fsync=10000 --iodepth=32 --direct=1 --numjobs=1 --runtime=60 --group_reporting
Velocità WRITE sequenziale con blocchi di grandi dimensioni (questo dovrebbe essere vicino al numero che vedi nelle specifiche del tuo disco):
fio --name TEST --eta-newline=5s --filename=fio-tempfile.dat --rw=write --size=500m --io_size=10g --blocksize=1024k --ioengine=libaio --fsync=10000 --iodepth=32 --direct=1 --numjobs=1 --runtime=60 --group_reporting
Lettura 4K casuale QD1 (questo è il numero che conta davvero per le prestazioni del mondo reale a meno che tu non lo sappia per certo):
fio --name TEST --eta-newline=5s --filename=fio-tempfile.dat --rw=randread --size=500m --io_size=10g --blocksize=4k --ioengine=libaio --fsync=1 --iodepth=1 --direct=1 --numjobs=1 --runtime=60 --group_reporting
Misto casuale 4K leggere e scrivere QD1 con sincronizzazione (questo è il numero peggiore che ci si possa aspettare dal proprio disco, in genere meno dell'1% dei numeri elencati nel foglio delle specifiche):
fio --name TEST --eta-newline=5s --filename=fio-tempfile.dat --rw=randrw --size=500m --io_size=10g --blocksize=4k --ioengine=libaio --fsync=1 --iodepth=1 --direct=1 --numjobs=1 --runtime=60 --group_reporting
Aumenta l' --size
argomento per aumentare le dimensioni del file. L'uso di file più grandi può ridurre i numeri ottenuti in base alla tecnologia dell'unità e al firmware. I file di piccole dimensioni daranno risultati "troppo buoni" per i media rotazionali perché la testina di lettura non deve spostarsi molto. Se il tuo dispositivo è quasi vuoto, l'utilizzo di un file abbastanza grande da riempire quasi completamente il disco ti darà il comportamento peggiore per ogni test. Nel caso di SSD, le dimensioni del file non contano molto.
Tuttavia, si noti che per alcuni supporti di archiviazione la dimensione del file non è importante quanto i byte totali scritti durante un breve periodo di tempo. Ad esempio, alcuni SSD possono avere prestazioni significativamente più veloci con blocchi pre-cancellati o potrebbero avere una piccola area flash SLC che viene utilizzata come cache di scrittura e le prestazioni cambiano quando la cache SLC è piena. Come altro esempio, gli HDD SMR Seagate hanno circa 20 GB di area cache PMR che ha prestazioni piuttosto elevate ma una volta che è pieno, scrivere direttamente nell'area SMR può ridurre le prestazioni al 10% rispetto all'originale. E l'unico modo per vedere questa degradazione delle prestazioni è innanzitutto scrivere 20+ GB il più velocemente possibile. Ovviamente, tutto dipende dal carico di lavoro: se l'accesso in scrittura è pieno di ritardi prolungati che consentono al dispositivo di pulire la cache interna, sequenze di test più brevi rispecchieranno meglio le prestazioni del mondo reale. Se devi fare un sacco di IO, devi aumentare entrambi--io_size
e --runtime
parametri. Si noti che alcuni supporti (ad esempio la maggior parte dei dispositivi flash) subiranno un'ulteriore usura da tali test. A mio avviso, se un dispositivo è abbastanza scarso da non gestire questo tipo di test, non dovrebbe essere utilizzato per conservare dati di valore in ogni caso.
Inoltre, alcuni dispositivi SSD di alta qualità potrebbero avere algoritmi di livellamento dell'usura ancora più intelligenti in cui la cache SLC interna ha abbastanza intelligenze per sostituire i dati in atto che vengono riscritti durante il test se colpisce lo stesso spazio di indirizzi (vale a dire, file di test è inferiore alla cache SLC totale). Per tali dispositivi, le dimensioni del file ricominciano a contare. Se hai bisogno del tuo carico di lavoro effettivo, è meglio provare con le dimensioni dei file che vedrai nella vita reale. Altrimenti i tuoi numeri potrebbero apparire troppo belli.
Si noti che fio
creerà il file temporaneo richiesto alla prima esecuzione. Sarà riempito con dati casuali per evitare di ottenere numeri troppo buoni da dispositivi che imbrogliano comprimendo i dati prima di scriverli nella memoria permanente. Il file temporaneo verrà chiamato fio-tempfile.dat
negli esempi precedenti e memorizzato nella directory di lavoro corrente. Quindi dovresti prima passare alla directory montata sul dispositivo che vuoi testare.
Se hai un buon SSD e vuoi vedere numeri ancora più alti, aumenta --numjobs
sopra. Ciò definisce la concorrenza per le letture e le scritture. Tutti gli esempi precedenti sono stati numjobs
impostati in 1
modo che il test riguardi la lettura e la scrittura di processi a thread singolo (possibilmente con una coda impostata con iodepth
). Gli SSD di fascia alta (ad esempio Intel Optane) dovrebbero ottenere numeri elevati anche senza aumentare di numjobs
molto (ad esempio 4
dovrebbe essere sufficiente per ottenere i numeri di specifica più elevati), ma alcuni SSD "Enterprise" devono andare a 32
- 128
per ottenere i numeri di specifica perché la latenza interna di quelli i dispositivi sono più alti ma il throughput complessivo è folle.
max_sectors_kb
. Ho modificato i comandi di esempio sopra per utilizzare una dimensione di blocco di 1 MB perché sembra funzionare con l'hardware del mondo reale. E ho anche testato che fsync
non importa per la lettura.
iodepth
per 1
per l'accesso casuale proprio perché i programmi del mondo reale spesso gestiti algoritmi / logica che non funziona con la profondità più in alto di 1. Di conseguenza, se tale profondità è "troppo bassa" il dispositivo di I / O è male. È vero che alcuni dispositivi SSD trarranno vantaggio da una profondità superiore a 32. Tuttavia, puoi indicare un carico di lavoro del mondo reale che richiede l'accesso in lettura ed è in grado di mantenere lo iodepth superiore a 32? TL; DR: se vuoi riprodurre un numero di riferimento di lettura follemente alto con un dispositivo ad alta latenza, usa iodepth=256 --numjobs=4
ma non aspettarti mai di vedere tali numeri per davvero.
bonnie ++ è l'ultima utility di benchmark che conosco per Linux.
(Attualmente sto preparando un livecd di Linux al lavoro con Bonnie ++ su di esso per testare la nostra macchina basata su Windows con esso!)
Si occupa di memorizzazione nella cache, sincronizzazione, dati casuali, posizione casuale sul disco, aggiornamenti di piccole dimensioni, aggiornamenti di grandi dimensioni, letture, scritture, ecc. il filesystem può essere molto istruttivo per il principiante.
Non ho idea se è incluso in Ubuntu, ma puoi compilarlo facilmente dal sorgente.
Velocità di scrittura
$ dd if=/dev/zero of=./largefile bs=1M count=1024
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB) copied, 4.82364 s, 223 MB/s
La dimensione del blocco è in realtà abbastanza grande. Puoi provare con dimensioni più piccole come 64k o addirittura 4k.
Velocità di lettura
Eseguire il comando seguente per cancellare la cache di memoria
$ sudo sh -c "sync && echo 3 > /proc/sys/vm/drop_caches"
Ora leggi il file che è stato creato nel test di scrittura:
$ dd if=./largefile of=/dev/null bs=4k
165118+0 records in
165118+0 records out
676323328 bytes (676 MB) copied, 3.0114 s, 225 MB/s
alcuni suggerimenti su come usare bonnie ++
bonnie++ -d [TEST_LOCATION] -s [TEST_SIZE] -n 0 -m [TEST_NAME] -f -b -u [TEST_USER]
bonnie++ -d /tmp -s 4G -n 0 -m TEST -f -b -u james
Un po 'di più su: ESEMPIO BONNIE ++ SEMPLICE .
Verifica l'integrità, rileva unità flash false e verifica le prestazioni, tutte e tre in un colpo solo.
Maggiori informazioni su questa risposta .