Benchmark ssd en linux: cómo medir las mismas cosas que crystalldiskmark en windows

Quiero comparar un ssd (posiblemente con sistemas de archivos encriptados) y compararlo con los puntos de referencia realizados por crystalldiskmark en Windows.

Entonces, ¿cómo puedo medir aproximadamente las mismas cosas que hace crystalldiskmark?

Para la primera fila (Seq) creo que podría hacer algo como

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

Pero no estoy seguro de los ddparámetros.

Para el aleatorio 512KB, 4KB, 4KB (Profundidad de cola = 32) lee / escribe pruebas de velocidad No tengo idea de cómo reproducir las mediciones en Linux. Entonces, ¿cómo puedo hacer esto?

Para probar velocidades de lectura, algo así sudo hdparm -Tt /dev/sdano parece tener sentido para mí, ya que quiero, por ejemplo, comparar algo como encfsmonturas.

Editar

@Alko, @iain

Quizás debería escribir algo sobre la motivación de esta pregunta: estoy tratando de comparar mi ssd y comparar algunas soluciones de cifrado. Pero esa es otra pregunta (la mejor manera de comparar diferentes soluciones de cifrado en mi sistema ). Mientras navegaba por la web sobre ssd y benchmarking, a menudo he visto a usuarios publicar sus resultados de CrystelDiskMark en foros. Entonces esta es la única motivación para la pregunta. Solo quiero hacer lo mismo en Linux. Para mi evaluación comparativa particular, vea mi otra pregunta.

Yo diría que fio no tendría problemas para producir esas cargas de trabajo. Tenga en cuenta que, a pesar de su nombre, CrystalDiskMark es en realidad un punto de referencia de un sistema de archivos en un disco en particular: no puede hacer E / S sin procesar en el disco solo. Como tal, siempre tendrá una sobrecarga del sistema de archivos (no necesariamente es algo malo, pero es algo a tener en cuenta, por ejemplo, porque los sistemas de archivos que se comparan podrían no ser los mismos).

Un ejemplo basado en la replicación de la salida en la captura de pantalla anterior complementada con información del manual CrystalDiskMark (esto no está completo pero debería dar la idea general):

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 

TEN CUIDADO : ¡este ejemplo destruye permanentemente los datos /mnt/fs/fiotest.tmp!

Puede ver una lista de parámetros de fio en http://fio.readthedocs.io/en/latest/fio_doc.html .

Creé un script que intenta replicar el comportamiento de crystalldiskmark con fio. El script realiza todas las pruebas disponibles en las diversas versiones de crystalldiskmark hasta crystaldiskmark 6, incluidas las pruebas 512K y 4KQ8T8.

El script depende de fio y df . Si no desea instalar df, borre las líneas 19 a 21 (el script ya no mostrará qué unidad se está probando) o pruebe la versión modificada de un comentarista . (También puede resolver otros posibles problemas)

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

Lo que arrojará resultados como este:

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

(Los resultados están codificados por colores, para eliminar la codificación de color, elimine todas las instancias \033[x;xxm(donde x es un número) del comando echo en la parte inferior del script).

El script cuando se ejecuta sin argumentos probará la velocidad de su unidad / partición de inicio. También puede ingresar una ruta a un directorio en otro disco duro si desea probar eso en su lugar. Mientras se ejecuta, el script crea archivos temporales ocultos en el directorio de destino que limpia después de que termina de ejecutarse (.fiomark.tmp y .fiomark.txt)

No puede ver los resultados de la prueba cuando se completan, pero si cancela el comando mientras se está ejecutando antes de que finalice todas las pruebas, podrá ver los resultados de las pruebas completadas y los archivos temporales también se eliminarán después.

Después de un poco de investigación, descubrí que el punto de referencia de crystalldiskmark resulta en el mismo modelo de unidad, ya que parece que coincida relativamente con los resultados de este punto de referencia de fio, al menos de un vistazo. Como no tengo una instalación de Windows, no puedo verificar qué tan cerca están realmente en la misma unidad.

Tenga en cuenta que a veces puede obtener resultados ligeramente bajos, especialmente si está haciendo algo en segundo plano mientras se ejecutan las pruebas, por lo que es recomendable ejecutar la prueba dos veces seguidas para comparar los resultados.

Estas pruebas tardan mucho tiempo en ejecutarse. La configuración predeterminada en el script actualmente es adecuada para un SSD normal (SATA).

Configuración de TAMAÑO recomendada para diferentes unidades:

• (SATA) SSD: 1024 (predeterminado)
• (CUALQUIERA) HDD: 256
• (High End NVME) SSD: 4096
• (SSD NVME de gama media baja): 1024 (predeterminado)

Un NVME de gama alta generalmente tiene una velocidad de lectura de ~ 2GB / s (Intel Optane y Samsung 960 EVO son ejemplos; pero en el caso de este último recomendaría 2048 en su lugar debido a velocidades más bajas de 4kb.), Un Low-Mid End puede tener entre ~ 500-1800MB / s velocidades de lectura.

La razón principal por la que estos tamaños deben ajustarse se debe a cuánto tiempo tomarían las pruebas, de lo contrario, para discos duros más viejos / más débiles, por ejemplo, puede tener velocidades de lectura tan bajas como 0.4MB / s 4kb. Intenta esperar 5 bucles de 1 GB a esa velocidad, otras pruebas de 4 kb suelen tener velocidades de alrededor de 1 MB / s. Tenemos 6 de ellos. Cada vez que ejecuta 5 bucles, ¿espera que se transfieran 30 GB de datos a esas velocidades? ¿O desea reducir eso a 7.5GB de datos en su lugar (a 256MB / s es una prueba de 2-3 horas)

Por supuesto, el método ideal para manejar esa situación sería ejecutar pruebas secuenciales y 512k separadas de las pruebas 4k (así que ejecute las pruebas secuenciales y 512k con algo como decir 512m, y luego ejecute las pruebas 4k a 32m)

Sin embargo, los modelos HDD más recientes son de gama alta y pueden obtener resultados mucho mejores que eso.

Y ahí lo tienes. ¡Disfrutar!

Puedes usar iozoney bonnie. Pueden hacer lo que puede hacer la marca de disco de cristal y más.

Personalmente, utilicé iozonemucho los dispositivos de evaluación comparativa y pruebas de estrés desde computadoras personales hasta sistemas de almacenamiento empresarial. Tiene un modo automático que hace todo pero puedes adaptarlo a tus necesidades.

No estoy seguro de que las diversas pruebas más profundas tengan algún sentido real al considerar lo que está haciendo en detalle.

Las configuraciones como el tamaño del bloque y la profundidad de la cola son parámetros para controlar los parámetros de entrada / salida de bajo nivel de la interfaz ATA en la que se encuentra su SSD.

Eso está muy bien cuando solo está ejecutando una prueba básica contra una unidad de disco de forma bastante directa, como un archivo grande en un sistema de archivos particionado simple.

Una vez que comience a hablar sobre la evaluación comparativa de un encfs, estos parámetros ya no se aplican particularmente a su sistema de archivos, el sistema de archivos es solo una interfaz en algo más que eventualmente retrocede en un sistema de archivos que retrocede en una unidad.

Creo que sería útil entender exactamente qué está tratando de medir, porque hay dos factores en juego aquí: la velocidad de E / S del disco sin procesar, que puede probar cronometrando varios comandos DD (puede dar ejemplos si esto es lo que usted querer) / sin / encfs, o el proceso estará limitado por el cifrado de la CPU y está intentando probar el rendimiento relativo del algoritmo de cifrado. En cuyo caso, los parámetros para la profundidad de la cola, etc. no son particularmente relevantes.

En ambos aspectos, un comando DD cronometrado le dará las estadísticas básicas de rendimiento que busca, pero debe considerar lo que pretende medir y los parámetros relevantes para eso.

Este enlace parece proporcionar una buena guía para la prueba de velocidad del disco utilizando comandos DD cronometrados, incluida la cobertura necesaria sobre 'derrotar buffers / caché', etc. Probablemente esto le proporcionará la información que necesita. Decida qué le interesa más, el rendimiento del disco o el rendimiento de cifrado, uno de los dos será el cuello de botella, y el ajuste del cuello de botella no beneficiará en nada.