Bom tamanho de bloco para clonagem de disco com diskdump (dd)

Eu uso o dd em sua forma mais simples para clonar um disco rígido:

dd if=INPUT of=OUTPUT

No entanto, li na página de manual que o dd conhece um parâmetro de tamanho do bloco. Existe um valor ideal para o parâmetro blocksize que acelera o procedimento de clonagem?

64k parece ser uma boa escolha:

Results:

  no bs=        78s     144584+0 records
  bs=512        78s     144584+0 records
  bs=1k         38s     72292+0 records
  bs=2k         38s     36146+0 records
  bs=4k         38s     18073+0 records
  bs=5k         39s     14458+1 records
  bs=50k        38s     1445+1 records
  bs=500k       39s     144+1 records
  bs=512k       39s     144+1 records
  bs=1M         39s     72+1 records
  bs=5M         39s     14+1 records
  bs=10M        39s     7+1 records

(tirada daqui ).

isso combina com minhas próprias descobertas sobre o buffer de leitura / gravação para acelerar um programa conversor pesado com io que eu já estava usando @work.

O dd copiará felizmente usando o BS do que você quiser e copiará um bloco parcial (no final).

Basicamente, o parâmetro do tamanho do bloco (bs) parece definir a quantidade de memória usada para ler um bloco de um disco antes de tentar gravar esse bloco no outro.

Se você tiver muita RAM, tornar o BS grande (mas totalmente contido na RAM) significa que o subsistema de E / S é utilizado o máximo possível, fazendo leituras e gravações massivamente grandes - explorando a RAM. Reduzir o tamanho da BS significa que a sobrecarga de E / S como uma proporção da atividade total aumenta.

É claro que há uma lei de retornos decrescentes. Minha aproximação aproximada é que um tamanho de bloco na faixa de 128K a 32M provavelmente fornecerá desempenho de forma que as despesas gerais sejam pequenas em comparação com a E / S simples, e aumentar ainda mais não fará muita diferença. O motivo pelo qual o limite inferior é de 128K a 32M é - depende do sistema operacional, hardware e assim por diante.

Se fosse eu, eu faria algumas experiências cronometrando uma cópia / clone usando um BS de 128K e novamente usando (digamos) 16M. Se alguém for consideravelmente mais rápido, use-o. Caso contrário, use o BS menor dos dois.

Para aqueles que acabam aqui via Google, mesmo que essa discussão seja um pouco antiga ...

Lembre-se de que dd é burro por um motivo: quanto mais simples, menos maneiras ele pode estragar.

Esquemas complexos de particionamento (considere um disco rígido de inicialização dupla que também usa o LVM para seu sistema Linux) começarão a extrair bugs da madeira em programas como o Clonezilla. Sistemas de arquivos mal desmontados podem explodir o ntfsclone muito alto.

Um sistema de arquivos corrompido, clonado setor por setor, não é pior que o original. Um sistema de arquivos corrompido após uma "cópia inteligente" com falha pode estar realmente em péssimo estado.

Em caso de dúvida, use dd e siga forense. A imagem forense requer cópias setor por setor (na verdade, pode exigir mais setores do que você conseguirá com o dd, mas essa é uma longa história). É lento e tedioso, mas ele fará o trabalho corretamente.

Além disso, conheça as opções "conv = noerror, sync", para que você possa clonar unidades que estão começando a falhar - ou criar ISOs a partir de CDs riscados ( sem tosse ) - sem levar meses.

Como outros já disseram, não há tamanho de bloco universalmente correto; o que é ideal para uma situação ou uma peça de hardware pode ser terrivelmente ineficiente para outra. Além disso, dependendo da integridade dos discos, pode ser preferível usar um tamanho de bloco diferente do que é "ideal".

Uma coisa que é bastante confiável no hardware moderno é que o tamanho padrão do bloco de 512 bytes tende a ser quase uma ordem de magnitude mais lenta que uma alternativa mais ideal. Na dúvida, descobri que 64K é um padrão moderno bastante sólido. Embora 64K geralmente não seja o tamanho ideal de bloco, na minha experiência, ele tende a ser muito mais eficiente que o padrão. O 64K também tem um histórico bastante sólido de desempenho confiável: Você pode encontrar uma mensagem na lista de discussão Eug-Lug, por volta de 2002, recomendando um tamanho de bloco de 64K aqui: http://www.mail-archive.com/eug- [email protected]/msg12073.html

Para determinar o tamanho ideal do bloco de saída, escrevi o seguinte script que testa a gravação de um arquivo de teste de 128M com dd em um intervalo de tamanhos de bloco diferentes, do padrão de 512 bytes a um máximo de 64M. Esteja avisado, este script usa dd internamente, portanto, use com cuidado.

dd_obs_test.sh:

#!/bin/bash

# Since we're dealing with dd, abort if any errors occur
set -e

TEST_FILE=${1:-dd_obs_testfile}
TEST_FILE_EXISTS=0
if [ -e "$TEST_FILE" ]; then TEST_FILE_EXISTS=1; fi
TEST_FILE_SIZE=134217728

if [ $EUID -ne 0 ]; then
  echo "NOTE: Kernel cache will not be cleared between tests without sudo. This will likely cause inaccurate results." 1>&2
fi

# Header
PRINTF_FORMAT="%8s : %s\n"
printf "$PRINTF_FORMAT" 'block size' 'transfer rate'

# Block sizes of 512b 1K 2K 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M
for BLOCK_SIZE in 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864
do
  # Calculate number of segments required to copy
  COUNT=$(($TEST_FILE_SIZE / $BLOCK_SIZE))

  if [ $COUNT -le 0 ]; then
    echo "Block size of $BLOCK_SIZE estimated to require $COUNT blocks, aborting further tests."
    break
  fi

  # Clear kernel cache to ensure more accurate test
  [ $EUID -eq 0 ] && [ -e /proc/sys/vm/drop_caches ] && echo 3 > /proc/sys/vm/drop_caches

  # Create a test file with the specified block size
  DD_RESULT=$(dd if=/dev/zero of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT conv=fsync 2>&1 1>/dev/null)

  # Extract the transfer rate from dd's STDERR output
  TRANSFER_RATE=$(echo $DD_RESULT | \grep --only-matching -E '[0-9.]+ ([MGk]?B|bytes)/s(ec)?')

  # Clean up the test file if we created one
  if [ $TEST_FILE_EXISTS -ne 0 ]; then rm $TEST_FILE; fi

  # Output the result
  printf "$PRINTF_FORMAT" "$BLOCK_SIZE" "$TRANSFER_RATE"
done

Ver no GitHub

Eu testei esse script apenas em um sistema Debian (Ubuntu) e no OSX Yosemite, por isso provavelmente será necessário alguns ajustes para fazer funcionar outros tipos de Unix.

Por padrão, o comando criará um arquivo de teste chamado dd_obs_testfile no diretório atual. Como alternativa, você pode fornecer um caminho para um arquivo de teste personalizado, fornecendo um caminho após o nome do script:

$ ./dd_obs_test.sh /path/to/disk/test_file

A saída do script é uma lista dos tamanhos de bloco testados e suas respectivas taxas de transferência da seguinte forma:

$ ./dd_obs_test.sh
block size : transfer rate
       512 : 11.3 MB/s
      1024 : 22.1 MB/s
      2048 : 42.3 MB/s
      4096 : 75.2 MB/s
      8192 : 90.7 MB/s
     16384 : 101 MB/s
     32768 : 104 MB/s
     65536 : 108 MB/s
    131072 : 113 MB/s
    262144 : 112 MB/s
    524288 : 133 MB/s
   1048576 : 125 MB/s
   2097152 : 113 MB/s
   4194304 : 106 MB/s
   8388608 : 107 MB/s
  16777216 : 110 MB/s
  33554432 : 119 MB/s
  67108864 : 134 MB/s

(Nota: a unidade das taxas de transferência variará de acordo com o sistema operacional)

Para testar o tamanho ideal do bloco de leitura, você pode usar mais ou menos o mesmo processo, mas em vez de ler / dev / zero e gravar no disco, você deve ler o disco e gravar em / dev / null. Um script para fazer isso pode ser assim:

dd_ibs_test.sh:

#!/bin/bash

# Since we're dealing with dd, abort if any errors occur
set -e

TEST_FILE=${1:-dd_ibs_testfile}
if [ -e "$TEST_FILE" ]; then TEST_FILE_EXISTS=$?; fi
TEST_FILE_SIZE=134217728

# Exit if file exists
if [ -e $TEST_FILE ]; then
  echo "Test file $TEST_FILE exists, aborting."
  exit 1
fi
TEST_FILE_EXISTS=1

if [ $EUID -ne 0 ]; then
  echo "NOTE: Kernel cache will not be cleared between tests without sudo. This will likely cause inaccurate results." 1>&2
fi

# Create test file
echo 'Generating test file...'
BLOCK_SIZE=65536
COUNT=$(($TEST_FILE_SIZE / $BLOCK_SIZE))
dd if=/dev/urandom of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT conv=fsync > /dev/null 2>&1

# Header
PRINTF_FORMAT="%8s : %s\n"
printf "$PRINTF_FORMAT" 'block size' 'transfer rate'

# Block sizes of 512b 1K 2K 4K 8K 16K 32K 64K 128K 256K 512K 1M 2M 4M 8M 16M 32M 64M
for BLOCK_SIZE in 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864
do
  # Clear kernel cache to ensure more accurate test
  [ $EUID -eq 0 ] && [ -e /proc/sys/vm/drop_caches ] && echo 3 > /proc/sys/vm/drop_caches

  # Read test file out to /dev/null with specified block size
  DD_RESULT=$(dd if=$TEST_FILE of=/dev/null bs=$BLOCK_SIZE 2>&1 1>/dev/null)

  # Extract transfer rate
  TRANSFER_RATE=$(echo $DD_RESULT | \grep --only-matching -E '[0-9.]+ ([MGk]?B|bytes)/s(ec)?')

  printf "$PRINTF_FORMAT" "$BLOCK_SIZE" "$TRANSFER_RATE"
done

# Clean up the test file if we created one
if [ $TEST_FILE_EXISTS -ne 0 ]; then rm $TEST_FILE; fi

Ver no GitHub

Uma diferença importante nesse caso é que o arquivo de teste é um arquivo gravado pelo script. Não aponte este comando para um arquivo existente ou o arquivo existente será substituído por dados aleatórios!

Para meu hardware em particular, descobri que 128K era o tamanho de bloco de entrada mais ideal em um HDD e 32K era o melhor em um SSD.

Embora esta resposta cubra a maioria das minhas descobertas, já me deparei com essa situação várias vezes em que escrevi uma postagem no blog sobre ela: http://blog.tdg5.com/tuning-dd-block-size/ Você pode encontrar mais detalhes nos testes que realizei lá.

Esta publicação do StackOverflow também pode ser útil: dd: Como calcular o tamanho ideal do bloco?

Sim, mas você não o encontrará sem muitos testes. Descobri que 32M é um bom valor para usar.

clonando a unidade de inicialização antiga para o novo ssd em sata externo (ssd para ssd)

• usando linux Ubuntu 18.04.2 LTS 64bit
• hp xw4600 (8 GB de RAM, intel Core 2 Quad Q6700 a 2.66GHz 4c / 4t no-HT)

usando Discos (ferramenta)> formato> ATA Secure Erase (2min)

$ lsblk -l /dev/sd?
NAME MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT
sda    8:0    0 119,2G  0 disk 
sda1   8:1    0 119,2G  0 part /
sdb    8:16   0   2,7T  0 disk 
sdc    8:32   0   2,7T  0 disk 
sdd    8:48   0  12,8T  0 disk 
sde    8:64   0   2,7T  0 disk
sdf    8:80   1 465,8G  0 disk 

$ sudo fdisk -l /dev/sda
Disk /dev/sda: 119,2 GiB, 128035676160 bytes, 250069680 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes

$ sudo fdisk -l /dev/sdf
Disk /dev/sdf: 465,8 GiB, 500107862016 bytes, 976773168 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 4096 bytes
I/O size (minimum/optimal): 4096 bytes / 4096 bytes

• sda: SSD Kingston (antigo; Disks relata uma taxa média de 263 MB / s com picos próximos a 270 MB / s - sem teste de gravação devido ao disco do sistema)
• sdf: Crucial MX500, 500GB, CT500MX500SSD1 (Relatórios de discos: taxa média de rd / wr 284/262 MB / se tempo de acesso 0,05ms, com picos de aproximadamente 290/270 MB / s)

Execuções de teste:

$ sudo dd if=/dev/sda of=/dev/sdf
250069680+0 records in
250069680+0 records out
128035676160 bytes (128 GB, 119 GiB) copied, 3391,72 s, 37,7 MB/s
#       --vvvvv--                            *********
$ sudo dd bs=1M if=/dev/sda of=/dev/sdf
122104+1 records in
122104+1 records out
128035676160 bytes (128 GB, 119 GiB) copied, 473,186 s, 271 MB/s
#                                            *********  ********

segunda tentativa após apagamento seguro com o mesmo resultado:

128035676160 bytes (128 GB, 119 GiB) copied, 472,797 s, 271 MB/s