Vraag Hoe de prestaties van de harde schijf te controleren


Hoe de prestaties van een harde schijf te controleren (via terminal of GUI). De schrijfsnelheid. De leessnelheid. Cachegrootte en -snelheid. Willekeurige snelheid.


260
2017-12-12 00:22


oorsprong


Een soortgelijke vraag is al eerder gesteld unix.stackexchange.com/questions/108838/... , stackoverflow.com/questions/1198691/... en serverfault.com/questions/219739/... . - Anon


antwoorden:


Terminal methode

hdparm is een goede plaats om te beginnen.

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 zal ook informatie geven.

dd geeft u informatie over schrijfsnelheid.

Als de drive geen bestandssysteem heeft (en alleen dan), gebruik of=/dev/sda.

Anders mount het op / tmp en schrijf en verwijder vervolgens het testuitvoerbestand.

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

Grafische methode

  1. Ga naar Systeem -> Beheer -> Schijfhulpprogramma.
    • U kunt ook het Gnome-schijfhulpprogramma vanaf de opdrachtregel starten door het uit te voeren gnome-disks
  2. Selecteer uw harde schijf in het linkerdeelvenster.
  3. Klik nu op "Benchmark - Meet de prestaties van de schijf" in het rechterdeelvenster.
  4. Een nieuw venster met grafieken opent. Je zult twee knoppen vinden. De ene is voor "Start alleen lezen Benchmark" en een andere is "Start lezen / schrijven benchmark". Wanneer u op een knop klikt, wordt de benchmark van de harde schijf gestart.

test

Hoe de schijf-I / O te benchmarken

Artikel

Is er iets meer dat je wilt?


342
2017-12-12 00:34



Ik zou testen aanraden /dev/urandom net zoals /dev/zero als invoer voor dd bij het testen van een SSD omdat de compressibiliteit van de gegevens een enorm effect kan hebben op de schrijfsnelheid. - Ian Mackinnon
Er is geen dergelijk "Systeem ->" op mijn Ubuntu 12.04 Unity. Of ik heb het tenminste niet gevonden. En ik zie dat schijfhulpprogramma ook niet binnen Systeeminstellingen ... Oei Maar ik kon het uiteindelijk wel uitvoeren: / usr / bin / palimpsest - Fran Marzoa
Merk op dat sinds 12.10 het wordt gewoon schijven genoemd en is te vinden via Unity. - Paul Lammertsma
Op Gnome is dit verplaatst naar Toepassingen -> Systeemwerkset -> Voorkeuren -> Schijfhulpprogramma. Voor gebruikers die Unity haten. - Ken Sharp
De /tmp bestandssysteem gebruikt tegenwoordig vaak een ramdisk. Dus schrijven naar /tmp lijkt je geheugen te testen, niet je schijfsubsysteem. - Zoredache


Suominen heeft gelijk, we zouden een soort van synchronisatie moeten gebruiken; maar er is een eenvoudigere methode, conv = fdatasync zal het werk doen:

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

73
2017-08-18 18:31



Het is een antwoord met een andere opdracht / optie dan de andere. Ik zie dat het een antwoord is dat een eigen post waardig is. - Alaa Ali
Waarom heb je 384k als blokgrootte gebruikt? - Diego F. Durán
@Diego Er is geen reden. Het was maar een voorbeeld. Je kunt iets anders gebruiken. (tussen ongeveer 4k ... 1M) Uiteraard zullen grotere blokken groter zijn voor betere prestaties. En natuurlijk verlaagt u het telnummer wanneer u grote bs gebruikt, anders duurt het een jaar om te voltooien. - Tele
het is niet betrouwbaar door bench mark-tools zoals iozone en sysbench-getallen zijn veel veel lager - MSS


Ik zou het gebruik niet aanbevelen /dev/urandom omdat het op software is gebaseerd en langzaam is als een varken. Het is beter om stukjes willekeurige gegevens op ramdisk te nemen. Bij het testen van de harde schijf maakt het niet uit, omdat elke byte is geschreven zoals is (ook op ssd met dd). Maar als we getoetste zfs-pool testen met pure nul of willekeurige gegevens, is er een enorm verschil in prestaties.

Een ander gezichtspunt moet de sync-tijdinclusie zijn; alle moderne bestandssystemen gebruiken caching bij bestandsbewerkingen.

Om de schijfsnelheid en niet het geheugen echt te meten, moeten we het bestandssysteem synchroniseren om het caching-effect kwijt te raken. Dat kan eenvoudig worden gedaan door:

time sh -c "dd if=/dev/zero of=testfile bs=100k count=1k && sync"

met die methode krijg je 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

dus de schijf datarate is slechts 104857600 / 0.441 = 237772335 B / s -> 237MB / s

Dat is meer dan 100MB / s lager dan bij caching.

Happy benchmarking,


42
2017-12-06 23:18





Als u de lees- en schrijfsnelheid van de schijf in realtime wilt controleren, kunt u de iotop tool.

Dit is handig om exacte informatie te krijgen over hoe een schijf presteert voor een bepaalde toepassing of taak. De uitvoer toont u de lees- / schrijfsnelheid per proces en de totale lees- / schrijfsnelheid voor de server, vergelijkbaar met top.

Om iotop te installeren:

sudo apt-get install iotop  

Om het uit te voeren:

sudo iotop

30
2017-09-17 14:24





bonnie ++ is het ultieme benchmark hulpprogramma dat ik ken voor Linux.

(Ik ben momenteel bezig met het voorbereiden van een Linux LiveCD op het werk met Bonnie ++ erop om onze Windows-gebaseerde machine ermee te testen!)

Het zorgt voor caching, synchronisatie, willekeurige gegevens, willekeurige locatie op schijf, kleine updates, grote updates, lezen, schrijven, enz. Vergelijken van een usbkey, een harde schijf (roterend), een solid-state schijf en een ram-gebaseerde bestandssysteem kan zeer informatief zijn voor de newbie.

Ik heb geen idee of het in Ubuntu is opgenomen, maar je kunt het gemakkelijk van de bron compileren.

http://www.coker.com.au/bonnie++/


23
2018-02-03 16:13





Schrijfsnelheid

$ 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

De blokgrootte is eigenlijk behoorlijk groot. Je kunt het proberen met kleinere maten zoals 64k of zelfs 4k.


Leessnelheid

Voer de volgende opdracht uit om de geheugencache leeg te maken

$ sudo sh -c "sync && echo 3 > /proc/sys/vm/drop_caches"

Lees nu het bestand dat in schrijftest is gemaakt:

$ 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

17
2018-05-05 22:12





enkele tips voor het gebruik van 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

Een beetje meer naar: EENVOUDIG BONNIE ++ VOORBEELD.


12
2017-09-28 19:02





Als u nauwkeurigheid wilt, moet u gebruiken fio. Het vereist het lezen van de handleiding (man fio) maar het geeft u nauwkeurige resultaten. Merk op dat voor elke nauwkeurigheid, u precies moet specificeren wat u wilt meten. Een paar voorbeelden:

Sequentiële READ-snelheid met grote blokken (dit moet in de buurt zijn van het nummer dat u ziet in de specificaties van uw drive):

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

Sequentiële SCHRIJFsnelheid met grote blokken (dit moet in de buurt zijn van het nummer dat u ziet in de specificaties van uw drive):

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

Willekeurige 4K lees QD1 (dit is het nummer dat er echt toe doet voor echte wereldprestaties, tenzij je het zeker weet):

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

Gemengde willekeurige 4K lezen en schrijven QD1 met synchronisatie (dit is het slechtste gevalnummer dat je ooit zou verwachten van je rit, gewoonlijk 1-10% van het aantal dat op het specificatieblad staat):

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

Verhogen --size argument om de bestandsgrootte te vergroten. Het gebruik van grotere bestanden kan de aantallen die u krijgt verminderen, afhankelijk van de schijftechnologie en de firmware. Kleine bestanden geven "te goed" resultaten voor rotatiemedia omdat de leeskop niet zo veel hoeft te verplaatsen. Als uw apparaat bijna leeg is, krijgt u met het bestand dat groot genoeg is om de schijf bijna vol te maken, het slechtste gedrag voor elke test. In het geval van een SSD maakt de bestandsgrootte niet zoveel uit.

Let daar op fio maakt het vereiste tijdelijke bestand bij de eerste uitvoering. Het zal worden gevuld met willekeurige gegevens om te voorkomen dat te goede nummers van apparaten die vals spelen door de gegevens te comprimeren voordat ze worden geschreven naar permanente opslag. Het tijdelijke bestand wordt gebeld fio-tempfile.dat in bovenstaande voorbeelden en opgeslagen in de huidige werkmap. Dus je moet eerst naar de map gaan die is gemount op het apparaat dat je wilt testen.


9
2018-01-01 18:14



Sommige van de fio-instellingen zijn een beetje vreemd en zijn mogelijk niet optimaal. Als u bijvoorbeeld een enorme blokgrootte (2Mbytes) hebt wanneer u directe I / O uitvoert met een asynchrone I / O-engine, leidt dit waarschijnlijk tot veel splitsen in de kernel en wordt dus overhead gecreëerd. Periodiek verzenden fsyncs wanneer je alleen aan het lezen bent, ziet het er ook vreemd uit. Ik ben het ermee eens dat fio nuttig is, maar ik zou aanraden dat lezers zorgvuldig onderzoeken met welke parameters ze willen werken in plaats van ze letterlijk te kopiëren vanuit de 20180102-versie van het bovenstaande antwoord ... - Anon
@Anon: je hebt gelijk, het optimum voor sequentieel lezen zou overeenkomen /sys/block/sd?/queue/max_sectors_kb omdat het mogelijk lager is dan de feitelijke hardwarelimiet die meestal veel meer is dan de 2 MB in het bovenstaande voorbeeld. Ik neem echter aan dat de kleine overhead veroorzaakt door de CPU niet van belang is in vergelijking met de snelheid van het werkelijke I / O-apparaat. De fsync is geen bewerking voor leesbewerkingen, dus dit heeft geen invloed op de resultaten. Ik heb het zo gehouden dat het eenvoudiger is om de verschillen tussen verschillende opdrachtregels te begrijpen. Heeft u problemen om de resultaten te krijgen die overeenkomen met de specificaties van de fabrikant? - Mikko Rantalainen
Niet echt, ik heb gewoon (enige) ervaring met werken met fio en Linux. Eigenlijk, als je de beste blokgrootte vermoedt, is het verstandig om te beginnen met optimal_io_size als het beschikbaar is (maar je kunt er van uitgaan 64Kbytes als het 0 is - dat is wat de kernel doet). Niet precies, ik heb gewoon (enige) ervaring met werken fio en Linux. Als je de beste blokgrootte vermoed, zou het verstandig zijn om te beginnen met optimal_io_size als het beschikbaar is (maar je kunt er van uitgaan dat 64Kbytes het 0 is - dat is wat de kernel doet). - Anon
Ik heb een aantal apparaten opnieuw getest. Met behulp van bovenstaande sequentiële leestest (2MB blokgrootte) kreeg ik 280 MB / s van Samsung SSD 850 EVO en 1070 MB / s van Intel 910 SSD. Met 64k blokgrootte en anderszins identieke commandline kreeg ik 268 MB / s van 850 EVO en 1055 MB / s van 910 SSD. In ieder geval voor dit soort apparaten lijkt het gebruik van een blokgrootte van 2 MB de resultaten rond 1-5% te verbeteren, hoewel dit ertoe leidt dat de kernel verzoeken splitst naar hardware. Ik denk dat zelfs met kernel-optimalisaties de overhead van het indienen van meer syscalls slechter is dan het splitsen in de kernel. - Mikko Rantalainen
Bij verder testen lijkt het erop dat ik de hoogste sequentiële doorvoer verkrijg met een macht van 2 waarde die kleiner is dan max_sectors_kb. Ik heb de bovenstaande voorbeeldopdrachten gewijzigd in een blokgrootte van 1 MB, omdat dat lijkt te werken met echte wereldhardware. En ik heb dat ook getest fsync maakt niet uit voor het lezen. - Mikko Rantalainen