Benchmark SSD sur Linux: comment mesurer les mêmes choses que le CrystalDiskmark dans Windows

Je veux comparer un ssd (peut-être avec des systèmes de fichiers cryptés) et le comparer aux benchmarks effectués par crystaldiskmark sur Windows.

Alors, comment puis-je mesurer approximativement les mêmes choses que le crystaldiskmark?

Pour la première ligne (Seq), je pense que je pourrais faire quelque chose comme

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

Mais je ne suis pas sûr des ddparamètres.

Pour les tests de vitesse aléatoires de 512 Ko, 4 Ko, 4 Ko (profondeur de file d'attente = 32), je lis / écrit Je n'ai aucune idée de la façon de reproduire les mesures sous Linux. Alors, comment puis-je faire cela?

Pour tester les vitesses de lecture, quelque chose comme sudo hdparm -Tt /dev/sdane semble pas avoir de sens pour moi car je veux par exemple comparer quelque chose comme des encfsmontures.

modifier

@Alko, @iain

Je devrais peut-être écrire quelque chose sur la motivation de cette question: j'essaie de comparer mon SSD et de comparer certaines solutions de chiffrement. Mais c'est une autre question (la meilleure façon de comparer différentes solutions de chiffrement sur mon système ). En surfant sur le Web à propos des ssd et de l'analyse comparative, j'ai souvent vu des utilisateurs publier leurs résultats CrystelDiskMark dans des forums. C'est donc la seule motivation de la question. Je veux juste faire la même chose sur Linux. Pour mon analyse comparative particulière, voir mon autre question.

Je dirais que fio n'aurait aucun mal à produire ces charges de travail. Notez que malgré son nom, CrystalDiskMark est en fait une référence d'un système de fichiers sur un disque particulier - il ne peut pas faire d'E / S brutes sur le disque seul. En tant que tel, il y aura toujours une surcharge de système de fichiers (pas nécessairement une mauvaise chose mais quelque chose à savoir, par exemple parce que les systèmes de fichiers comparés peuvent ne pas être les mêmes).

Un exemple basé sur la réplication de la sortie dans la capture d'écran ci-dessus complétée par des informations du manuel CrystalDiskMark (ce n'est pas complet mais devrait donner une idée générale):

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 

ATTENTION : cet exemple détruit définitivement les données /mnt/fs/fiotest.tmp!

Une liste des paramètres fio peut être consultée sur http://fio.readthedocs.io/en/latest/fio_doc.html .

J'ai créé un script qui essaie de reproduire le comportement de crystaldiskmark avec fio. Le script effectue tous les tests disponibles dans les différentes versions de crystaldiskmark jusqu'à crystaldiskmark 6, y compris les tests 512K et 4KQ8T8.

Le script dépend de fio et df . Si vous ne souhaitez pas installer df, effacez les lignes 19 à 21 (le script n'affichera plus le lecteur testé) ou essayez la version modifiée à partir d'un commentateur . (Peut également résoudre d'autres problèmes possibles)

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

Ce qui produira des résultats comme celui-ci:

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

(Les résultats sont codés par couleur, pour supprimer le codage par couleur, supprimez toutes les instances de \033[x;xxm(où x est un nombre) de la commande echo au bas du script.)

Le script, exécuté sans arguments, testera la vitesse de votre lecteur / partition domestique. Vous pouvez également entrer un chemin d'accès à un répertoire sur un autre disque dur si vous souhaitez le tester à la place. Lors de l'exécution, le script crée des fichiers temporaires masqués dans le répertoire cible qu'il nettoie après avoir terminé son exécution (.fiomark.tmp et .fiomark.txt)

Vous ne pouvez pas voir les résultats des tests au fur et à mesure qu'ils se terminent, mais si vous annulez la commande pendant qu'elle est en cours d'exécution avant de terminer tous les tests, vous pourrez voir les résultats des tests terminés et les fichiers temporaires seront également supprimés par la suite.

Après quelques recherches, j'ai trouvé que les résultats du benchmark crystalaldiskmark sur le même modèle de lecteur que je semble correspondre relativement étroitement aux résultats de ce benchmark fio, au moins en un coup d'œil. Comme je n'ai pas d'installation Windows, je ne peux pas vérifier à quel point ils sont vraiment sûrs sur le même lecteur.

Notez que vous pouvez parfois obtenir des résultats légèrement inférieurs, surtout si vous faites quelque chose en arrière-plan pendant que les tests sont en cours, il est donc conseillé d'exécuter le test deux fois de suite pour comparer les résultats.

Ces tests sont longs à exécuter. Les paramètres par défaut du script conviennent actuellement pour un SSD standard (SATA).

Réglage de TAILLE recommandé pour différents lecteurs:

• (SATA) SSD: 1024 (par défaut)
• (TOUT) HDD: 256
• (NVME haut de gamme) SSD: 4096
• (NVME bas de gamme) SSD: 1024 (par défaut)

Un NVME haut de gamme a généralement des vitesses de lecture d'environ 2 Go / s (Intel Optane et Samsung 960 EVO en sont des exemples; mais dans le cas de ce dernier, je recommanderais 2048 à la place en raison de vitesses plus lentes de 4 Ko.), Un bas-milieu peut avoir n'importe où entre Vitesse de lecture de ~ 500-1800 Mo / s.

La principale raison pour laquelle ces tailles doivent être ajustées est la durée du test sinon, pour les disques durs plus anciens / plus faibles, par exemple, vous pouvez avoir des vitesses de lecture aussi faibles que 0,4 Mo / s 4 Ko. Vous essayez d'attendre 5 boucles de 1 Go à cette vitesse, les autres tests de 4 Ko ont généralement une vitesse d'environ 1 Mo / s. Nous en avons 6. Chaque exécution de 5 boucles, attendez-vous que 30 Go de données soient transférés à ces vitesses? Ou voulez-vous plutôt le réduire à 7,5 Go de données (à 256 Mo / s, c'est un test de 2-3 heures)

Bien sûr, la méthode idéale pour gérer cette situation serait d'exécuter des tests séquentiels et 512k séparés des tests 4k (exécutez donc les tests séquentiels et 512k avec quelque chose comme disons 512m, puis exécutez les tests 4k à 32m)

Les modèles de disques durs plus récents sont cependant plus haut de gamme et peuvent obtenir de bien meilleurs résultats que cela.

Et voila. Prendre plaisir!

Vous pouvez utiliser iozoneet bonnie. Ils peuvent faire ce que la marque de disque de cristal peut faire et plus encore.

Personnellement, j'ai iozonebeaucoup utilisé lors de l'analyse comparative et des tests de résistance des appareils, des ordinateurs personnels aux systèmes de stockage d'entreprise. Il dispose d'un mode automatique qui fait tout, mais vous pouvez l'adapter à vos besoins.

Je ne suis pas sûr que les différents tests plus approfondis aient un vrai sens lorsque l'on considère ce que vous faites en détail.

Les paramètres tels que la taille du bloc et la profondeur de la file d'attente sont des paramètres pour contrôler les paramètres d'entrée / sortie de bas niveau de l'interface ATA sur laquelle se trouve votre SSD.

C'est très bien quand vous exécutez un test de base sur un lecteur assez directement, comme un gros fichier dans un système de fichiers partitionné simple.

Une fois que vous commencez à parler de l'analyse comparative d'un encfs, ces paramètres ne s'appliquent plus particulièrement à votre système de fichiers, le système de fichiers n'est qu'une interface vers quelque chose d'autre qui finit par sauvegarder sur un système de fichiers qui sauvegarde sur un lecteur.

Je pense qu'il serait utile de comprendre exactement ce que vous essayez de mesurer, car il y a deux facteurs en jeu ici - la vitesse d'E / S du disque brut, que vous pouvez tester en chronométrant diverses commandes DD (pouvez donner des exemples si c'est ce que vous want) / without / encfs, ou le processus sera limité par le cryptage et vous essayez de tester le débit relatif de l'algorithme de cryptage. Dans ce cas, les paramètres de profondeur de file d'attente, etc. ne sont pas particulièrement pertinents.

Dans les deux cas, une commande DD temporisée vous donnera les statistiques de débit de base que vous recherchez, mais vous devez considérer ce que vous avez l'intention de mesurer et les paramètres pertinents pour cela.

Ce lien semble fournir un bon guide pour tester la vitesse du disque à l'aide de commandes DD chronométrées, y compris la couverture nécessaire sur la «défaite des tampons / cache», etc. Cela vous fournira probablement les informations dont vous avez besoin. Décidez ce qui vous intéresse le plus, les performances du disque ou les performances de chiffrement, l'un des deux sera le goulot d'étranglement, et le réglage du non-goulot d'étranglement ne profitera à rien.