Benchmark ssd unter Linux: Wie misst man die gleichen Dinge wie crystaldiskmark unter Windows?

Ich möchte eine ssd (möglicherweise mit verschlüsselten Dateisystemen) benchmarken und mit Benchmarks vergleichen, die von crystaldiskmark unter Windows erstellt wurden.

Wie kann ich also ungefähr die gleichen Werte wie bei crystaldiskmark messen?

Für die erste Reihe (Seq) denke ich, dass ich so etwas machen könnte

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

Bei den ddParametern bin ich mir aber nicht sicher .

Für die zufälligen 512KB, 4KB, 4KB (Queue Depth = 32) liest / schreibt Speed-Tests Ich habe keine Ahnung, wie man die Messungen unter Linux reproduziert? Wie kann ich das machen?

Zum Testen der Lesegeschwindigkeit sudo hdparm -Tt /dev/sdaerscheint mir so etwas nicht sinnvoll, da ich zum Beispiel so etwas wie encfsReittiere messen möchte .

Bearbeiten

@Alko, @iain

Vielleicht sollte ich etwas über die Motivation zu dieser Frage schreiben: Ich versuche, meine SSD zu vergleichen und einige Verschlüsselungslösungen zu vergleichen. Aber das ist eine andere Frage (der beste Weg, um verschiedene Verschlüsselungslösungen auf meinem System zu vergleichen ). Beim Surfen im Internet über SSDs und Benchmarking habe ich oft gesehen, dass Benutzer ihre CrystelDiskMark-Ergebnisse in Foren gepostet haben. Das ist also die einzige Motivation für die Frage. Ich möchte nur das gleiche unter Linux tun. Für mein spezielles Benchmarking siehe meine andere Frage.

Ich würde sagen, fio würde keine Probleme damit haben, diese Workloads zu produzieren. Beachten Sie, dass CrystalDiskMark trotz seines Namens eigentlich ein Benchmark eines Dateisystems auf einer bestimmten Festplatte ist - es kann keine E / A-Vorgänge für die Festplatte alleine ausführen. Als solches hat es immer Dateisystem-Overhead (nicht unbedingt eine schlechte Sache, aber etwas, das man beachten muss, zB weil die Dateisysteme, die verglichen werden, möglicherweise nicht gleich sind).

Ein Beispiel, das auf der Replikation der Ausgabe im obigen Screenshot basiert und durch Informationen aus dem CrystalDiskMark-Handbuch ergänzt wird (dies ist nicht vollständig, sollte aber die allgemeine Idee vermitteln):

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 

ACHTUNG - in diesem Beispiel werden die Daten dauerhaft gelöscht/mnt/fs/fiotest.tmp !

Eine Liste der fio-Parameter finden Sie unter http://fio.readthedocs.io/en/latest/fio_doc.html .

Ich habe ein Skript erstellt, das versucht, das Verhalten von crystaldiskmark mit fio zu replizieren. Das Skript führt alle Tests aus, die in den verschiedenen Versionen von crystaldiskmark bis crystaldiskmark 6 verfügbar sind, einschließlich 512K- und 4KQ8T8-Tests.

Das Skript hängt von fio und df ab . Wenn Sie df nicht installieren möchten, löschen Sie die Zeilen 19 bis 21 (das Skript zeigt nicht mehr an, welches Laufwerk getestet wird) oder versuchen Sie die geänderte Version von einem Kommentator . (Kann auch andere mögliche Probleme lösen)

#!/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

Welche Ergebnisse wie folgt ausgeben:

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

(Die Ergebnisse sind farbcodiert. Um die Farbcodierung zu entfernen, entfernen Sie alle Instanzen von \033[x;xxm(wobei x eine Zahl ist) aus dem Echo-Befehl am unteren Rand des Skripts.)

Wenn das Skript ohne Argumente ausgeführt wird, wird die Geschwindigkeit Ihres Home-Laufwerks / Ihrer Home-Partition getestet. Sie können auch einen Pfad zu einem Verzeichnis auf einer anderen Festplatte eingeben, wenn Sie dies stattdessen testen möchten. Während der Ausführung des Skripts werden im Zielverzeichnis versteckte temporäre Dateien erstellt, die nach Abschluss der Ausführung gelöscht werden (.fiomark.tmp und .fiomark.txt).

Sie können die Testergebnisse nicht sehen, wenn sie abgeschlossen sind. Wenn Sie den Befehl jedoch abbrechen, während er ausgeführt wird, bevor alle Tests abgeschlossen sind, werden die Ergebnisse der abgeschlossenen Tests angezeigt und die temporären Dateien werden anschließend ebenfalls gelöscht.

Nach einigen Nachforschungen stellte ich fest, dass die Ergebnisse des Crystaldiskmark-Benchmarks auf demselben Laufwerksmodell basieren wie ich, zumindest auf einen Blick, relativ genau mit den Ergebnissen dieses FIO-Benchmarks übereinstimmen. Da ich keine Windows-Installation habe, kann ich nicht überprüfen, wie nahe sie sich tatsächlich auf demselben Laufwerk befinden.

Beachten Sie, dass Sie manchmal geringfügige Abweichungen von den Ergebnissen erhalten, insbesondere wenn Sie während der Ausführung der Tests etwas im Hintergrund tun. Daher ist es ratsam, den Test zweimal hintereinander auszuführen, um die Ergebnisse zu vergleichen.

Diese Tests dauern lange. Die Standardeinstellungen im Skript sind derzeit für eine normale (SATA) SSD geeignet.

Empfohlene GRÖSSENeinstellung für verschiedene Laufwerke:

• (SATA) SSD: 1024 (Standard)
• (JEDE) Festplatte: 256
• (High End NVME) SSD: 4096
• (Low-Mid-End NVME) SSD: 1024 (Standard)

Ein High-End-NVME hat normalerweise eine Lesegeschwindigkeit von ca. 2 GB / s (Intel Optane und Samsung 960 EVO sind Beispiele; im letzteren Fall würde ich 2048 empfehlen, da die 4-KB-Geschwindigkeit geringer ist.). Ein Low-Mid-End kann eine beliebige Geschwindigkeit aufweisen ~ 500-1800 MB / s Lesegeschwindigkeit.

Der Hauptgrund, warum diese Größen angepasst werden sollten, ist, wie lange die Tests andernfalls dauern würden. Bei älteren / schwächeren Festplatten können Sie beispielsweise eine Lesegeschwindigkeit von nur 0,4 MB / s (4 KB) erreichen. Sie versuchen, auf 5 Schleifen von 1 GB bei dieser Geschwindigkeit zu warten, andere 4-KB-Tests haben normalerweise eine Geschwindigkeit von etwa 1 MB / s. Wir haben 6 davon. Warten Sie nach jeweils 5 Durchläufen, bis 30 GB Daten mit dieser Geschwindigkeit übertragen wurden? Oder möchten Sie diesen Wert stattdessen auf 7,5 GB Daten reduzieren (bei 256 MB / s ist dies ein 2-3-stündiger Test)?

Die ideale Methode, um mit dieser Situation umzugehen, wäre natürlich, sequenzielle und 512-k-Tests getrennt von den 4-k-Tests durchzuführen (also führen Sie die sequenziellen und 512-k-Tests mit etwa 512 m aus und führen Sie dann die 4-k-Tests bei 32 m aus).

Neuere HDD-Modelle sind jedoch höherwertig und erzielen viel bessere Ergebnisse.

Und da hast du es. Genießen!

Sie können iozoneund verwenden bonnie. Sie können das tun, was Kristallscheibenmarkierungen können und vieles mehr.

Ich persönlich habe iozonebeim Benchmarking und beim Stresstest von Geräten von PCs bis hin zu Enterprise-Speichersystemen viel verwendet. Es hat einen Auto-Modus, der alles macht, aber Sie können es an Ihre Bedürfnisse anpassen.

Ich bin mir nicht sicher, ob die verschiedenen Tests wirklich Sinn ergeben, wenn man bedenkt, was Sie im Detail tun.

Die Einstellungen wie Blockgröße und Warteschlangentiefe sind Parameter zur Steuerung der Ein- / Ausgabeparameter auf niedriger Ebene der ATA-Schnittstelle, auf der sich Ihre SSD befindet.

Das ist alles schön und gut, wenn Sie nur einen einfachen Test gegen ein Laufwerk ziemlich direkt ausführen, wie bei einer großen Datei in einem einfachen partitionierten Dateisystem.

Sobald Sie über das Benchmarking eines Encfs sprechen, gelten diese Parameter nicht mehr speziell für Ihr Dateisystem. Das Dateisystem ist nur eine Schnittstelle zu etwas anderem, das sich irgendwann auf ein Dateisystem zurücksetzt, das sich auf ein Laufwerk zurücksetzt.

Ich denke, es wäre hilfreich, zu verstehen, was genau Sie messen möchten, da hier zwei Faktoren eine Rolle spielen: die E / A-Geschwindigkeit der Raw-Festplatte, die Sie testen können, indem Sie verschiedene DD-Befehle zeitlich steuern (Sie können Beispiele angeben, wenn Sie dies möchten) wollen) / ohne / encfs, oder der Prozess ist CPU-gebunden durch die Verschlüsselung und Sie versuchen, den relativen Durchsatz des Verschlüsselungsalgorithmus zu testen. In diesem Fall sind die Parameter für die Warteschlangentiefe usw. nicht besonders relevant.

In beiden Fällen erhalten Sie mit einem zeitgesteuerten DD-Befehl die grundlegenden Durchsatzstatistiken, die Sie suchen. Sie sollten sich jedoch überlegen, was Sie messen möchten und welche Parameter dafür relevant sind.

Dieser Link scheint einen guten Leitfaden für das Testen der Festplattengeschwindigkeit mit zeitgesteuerten DD-Befehlen zu bieten, einschließlich der erforderlichen Informationen zum 'Löschen von Puffern / Cache' und so weiter. Wahrscheinlich liefert dies die Informationen, die Sie benötigen. Entscheiden Sie, was Sie mehr interessiert: Festplatten- oder Verschlüsselungsleistung. Einer der beiden Gründe ist der Engpass, und die Optimierung des Nicht-Engpasses wird nichts nützen.