SSD de referência no Linux: Como medir as mesmas coisas que o crystaldiskmark faz no Windows

Eu quero fazer um benchmark de um ssd (possivelmente com sistemas de arquivos criptografados) e compará-lo com os benchmarks feitos pelo crystaldiskmark no Windows.

Então, como posso medir aproximadamente as mesmas coisas que o crystaldiskmark faz?

Para a primeira linha (Seq), acho que poderia fazer 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

Mas não tenho certeza sobre os ddparâmetros.

Para os aleatórios 512KB, 4KB, 4KB (profundidade da fila = 32) lê / grava testes de velocidade. Não faço ideia de como reproduzir as medições no linux? Então, como posso fazer isso?

Para testar a velocidade de leitura, algo como sudo hdparm -Tt /dev/sdanão parece fazer sentido para mim, pois eu quero, por exemplo, comparar algo como encfsmontagens.

Editar

@Alko, @iain

Talvez eu devesse escrever algo sobre a motivação sobre esta questão: estou tentando comparar meu ssd e comparar algumas soluções de criptografia. Mas essa é outra questão (a melhor maneira de comparar diferentes soluções de criptografia no meu sistema ). Enquanto navegava na web sobre ssd e benchmarking, vi usuários postando seus resultados do CrystelDiskMark em fóruns. Portanto, essa é a única motivação para a pergunta. Eu só quero fazer o mesmo no linux. Para meu benchmarking específico, veja minha outra pergunta.

Eu diria que o fio não teria problemas para produzir essas cargas de trabalho. Observe que, apesar do nome, o CrystalDiskMark é, na verdade, uma referência de um sistema de arquivos em um disco específico - ele não pode fazer I / O cru apenas no disco. Como tal, ele sempre terá sobrecarga do sistema de arquivos (não necessariamente uma coisa ruim, mas algo a ter em atenção, por exemplo, porque os sistemas de arquivos comparados podem não ser os mesmos).

Um exemplo baseado na replicação da saída na captura de tela acima, complementada por informações do manual do CrystalDiskMark (isso não está completo, mas deve fornecer a idéia geral):

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 

CUIDADO - este exemplo destrói permanentemente os dados /mnt/fs/fiotest.tmp!

Uma lista de parâmetros do fio pode ser vista em http://fio.readthedocs.io/en/latest/fio_doc.html .

Eu criei um script que tenta replicar o comportamento do crystaldiskmark com fio. O script faz todos os testes disponíveis nas várias versões do crystaldiskmark até o crystaldiskmark 6, incluindo testes de 512K e 4KQ8T8.

O script depende de fio e df . Se você não deseja instalar o df, apague as linhas 19 a 21 (o script não exibirá mais qual unidade está sendo testada) ou tente a versão modificada de um comentarista . (Também pode resolver outros problemas possíveis)

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

O que produzirá 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

(Os resultados são codificados por cores, para remover a codificação por cores remova todas as instâncias de \033[x;xxm(onde x é um número) do comando echo na parte inferior do script.)

O script, quando executado sem argumentos, testará a velocidade da sua unidade / partição doméstica. Você também pode inserir um caminho para um diretório em outro disco rígido, se desejar testá-lo. Durante a execução, o script cria arquivos temporários ocultos no diretório de destino, que são limpos após a conclusão da execução (.fiomark.tmp e .fiomark.txt)

Você não pode ver os resultados do teste à medida que eles são concluídos, mas se você cancelar o comando enquanto ele estiver em execução antes de concluir todos os testes, poderá ver os resultados dos testes concluídos e os arquivos temporários também serão excluídos posteriormente.

Após algumas pesquisas, descobri que o benchmark crystaldiskmark resulta no mesmo modelo de acionamento, pois pareço corresponder relativamente aos resultados desse benchmark fio, pelo menos de relance. Como eu não tenho uma instalação do Windows, não posso verificar o quão perto eles realmente estão certos na mesma unidade.

Observe que, às vezes, você pode obter resultados levemente negativos, especialmente se estiver fazendo algo em segundo plano enquanto os testes estiverem sendo executados, portanto, é recomendável executar o teste duas vezes seguidas para comparar os resultados.

Esses testes levam muito tempo para serem executados. As configurações padrão no script atualmente são adequadas para um SSD regular (SATA).

Configuração de TAMANHO recomendada para diferentes unidades:

• (SATA) SSD: 1024 (padrão)
• (QUALQUER) HDD: 256
• (NVME de ponta) SSD: 4096
• (NVME de média e baixa extremidade) SSD: 1024 (padrão)

Um NVME High-end normalmente tem cerca de ~ 2 GB / s de velocidade de leitura (Intel Optane e Samsung 960 EVO são exemplos; mas no último caso, eu recomendaria 2048 devido a velocidades mais lentas de 4kb.), Um Low-Mid End pode ter qualquer lugar entre ~ 500-1800MB / s velocidades de leitura.

A principal razão pela qual esses tamanhos devem ser ajustados é devido ao tempo que os testes levariam, caso contrário, para HDDs mais antigos / mais fracos, por exemplo, você pode ter velocidades de leitura de 0.4kb / s de 4kb a 4kb. Você tenta esperar 5 loops de 1 GB nessa velocidade; outros testes de 4kb normalmente têm velocidades de aproximadamente 1 MB / s. Nós temos 6 deles. A cada 5 loops, você espera que 30 GB de dados sejam transferidos nessas velocidades? Ou você deseja diminuir isso para 7,5 GB de dados (a 256 MB / s é um teste de 2 a 3 horas)

Obviamente, o método ideal para lidar com essa situação seria executar testes sequenciais e 512k separados dos testes de 4k (portanto, execute os testes sequenciais e de 512k com algo como digamos 512m e depois execute os testes de 4k a 32m)

Os modelos mais recentes de HDDs são mais avançados e podem obter resultados muito melhores do que isso.

E aí está. Apreciar!

Você pode usar iozonee bonnie. Eles podem fazer o que a marca do disco de cristal pode fazer e muito mais.

Eu pessoalmente usei iozonemuito enquanto fazia comparações e dispositivos de teste de estresse, de computadores pessoais a sistemas de armazenamento corporativo. Possui um modo automático que faz tudo, mas você pode adaptá-lo às suas necessidades.

Não sei se os vários testes mais profundos fazem algum sentido ao considerar o que você está fazendo em detalhes.

As configurações como tamanho do bloco e profundidade da fila são parâmetros para controlar os parâmetros de baixo nível de entrada / saída da interface ATA em que o seu SSD está instalado.

Tudo bem quando você está executando algum teste básico em uma unidade de maneira bastante direta, como um arquivo grande em um sistema de arquivos particionado simples.

Depois que você começa a falar sobre o benchmarking de um encfs, esses parâmetros não se aplicam mais ao seu sistema de arquivos, o sistema de arquivos é apenas uma interface para outra coisa que eventualmente faz backup em um sistema de arquivos que faz backup em uma unidade.

Eu acho que seria útil entender o que exatamente você está tentando medir, porque existem dois fatores em jogo aqui - a velocidade de E / S do disco bruto, que você pode testar cronometrando vários comandos DD (pode dar exemplos, se é isso que você want) / without / encfs, ou o processo será limitado pela CPU pela criptografia e você está tentando testar a taxa de transferência relativa do algoritmo de criptografia. Nesse caso, os parâmetros para profundidade da fila etc. não são particularmente relevantes.

Nos dois aspectos, um comando DD cronometrado fornecerá as estatísticas básicas de taxa de transferência que você procura, mas considere o que pretende medir e os parâmetros relevantes para isso.

Esse link parece fornecer um bom guia para o teste de velocidade do disco usando comandos DD cronometrados, incluindo a cobertura necessária sobre 'derrotar buffers / cache' e assim por diante. Provavelmente, isso fornecerá as informações necessárias. Decida em que você está mais interessado, desempenho do disco ou criptografia, um dos dois será o gargalo e o ajuste do não gargalo não beneficiará nada.