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

26

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.

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.

étudiant
la source
Pourquoi n'utilisez-vous pas un outil d'analyse comparative qui fonctionne sur les deux systèmes?
Alko
J'ai trouvé cela, cela semble très utile et dans mes brefs tests sur trois disques séparés, j'ai donné des chiffres très similaires à la marque de cristal réelle ... github.com/buty4649/fio-cdm
ljwobker
2019: ce Q mérite un nouveau départ - sujet important, mais a un peu perdu le focus ici. "Accepter et archiver".
rastafile

Réponses:

22

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 .

Anon
la source
3
J'ai essayé fio dans Ubuntu 16.04 et CrystalDiskMark dans Windows 7. Certains chiffres correspondent alors que d'autres non. Le r / w séquentiel était désactivé par un facteur de 2. Signification, les valeurs Linux étaient 50% de celles rapportées par CDM v3.0.4 (note: la version actuelle est 6.0.0, mais les anciennes versions sont toujours disponibles pour téléchargement). Pour jouer avec la disparité, je mets bs = 4m au lieu de 1m. Cela a rapproché les chiffres. Essayer 8 m et 32 ​​m l'a rendu encore plus proche. En fin de compte, comme Anon l'a dit, sa réponse n'est pas complète et, comme @Alko, nous avons besoin du même outil sur les deux systèmes d'exploitation. Notez également que le plus récent CDM 6 utilise des tests différents de OP. Nice info Anon
Vahid Pazirandeh
2
@VahidPazirandeh Intéressant, github.com/buty4649/fio-cdm/blob/master/fio-cdm a les mêmes paramètres 1m, peut-être que la documentation de cdm n'est pas assez bonne.
inf3rno
@ vahid-pazirandeh Vous êtes les bienvenus. NB: si vous voulez le même outil sur les deux OS, notez qu'il existe aussi une version de fio pour Windows.
Anon
8

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!

Cestarian
la source
Avez-vous vérifié le comportement de votre script avec fio sous Windows?
Anon
1
(Une note pour les lecteurs autres que Cestarian: si vous créez un nouvel outil qui utilise fio, si possible, ne grattez pas la sortie fio lisible par l'homme - utilisez --output-format=jsonet analysez le JSON. La sortie lisible par l'homme de Fio n'est pas destinée aux machines et n'est pas stable entre les versions fio. Voir cette vidéo YouTube d'un cas où le raclage de la production humaine de fio a conduit à un résultat indésirable )
Anon
Merci, je garderai cela à l'esprit, malheureusement je n'ai plus d'installation Windows, donc je ne peux pas tester cela ... mais, j'ai décidé de rechercher les résultats de la marque de cristal pour mon ssd et il semble que ma mémoire était fausse, car le les résultats s'ajoutent à ce que je reçois sur fio après tout. C'est un malentendu de ma part qui m'a fait penser que les résultats étaient plus lents: / Je vais le corriger. Je mettrai également à jour cette réponse bientôt pour utiliser la sortie json pour la protection future, et peut-être une version graphique (j'ai commencé à y travailler, mais gtkdialog est mal documenté et la zénité est limitée, donc j'ai du mal)
Cestarian
1
@Cestarian, excellent script, mais ne fonctionne pas "prêt à l'emploi" sur CentOS7. J'ai dû le modifier un peu.
Igor
1
@Igor Intéressant, ouais je l'ai fait sur manjaro et je ne suis pas vraiment un expert en bash :) J'ai mentionné votre version modifiée dans la réponse au cas où quelqu'un d'autre aurait des problèmes.
Cestarian
5

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.

bayindirh
la source
5
Comment reproduire avec cela les mesures cristallines en détail?
étudiant
2
Je ferai de mon mieux pour écrire un guide, mais j'ai besoin de la liste des tests que Crystal Disk Mark effectue. Existe-t-il d'autres tests que le logiciel exécute à côté de ceux visibles sur la capture d'écran?
bayindirh
1
Juste ceux de la capture d'écran.
trr
1

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.

Iain
la source