Como otros han dicho, no es universalmente correcto tamaño de bloque; ¿qué es la óptima para una situación o una pieza de hardware puede ser terriblemente ineficiente para otro. También, dependiendo de la salud de los discos puede ser preferible utilizar un tamaño de bloque distinto de lo que es "óptima".
Una cosa que es bastante fiable en hardware moderno es que por defecto el tamaño de bloque de 512 bytes tiende a ser casi un orden de magnitud más lento que una más óptima alternativa. Cuando en duda, he encontrado que es de 64 kb de un sólido bonito modernas predeterminado. A pesar de 64 KB por lo general no es EL óptimo tamaño de bloque, en mi experiencia tiende a ser mucho más eficiente que el valor predeterminado. 64 también tiene una bonita historia sólida de ser fiable rendimiento: Usted puede encontrar un mensaje de la Eug-Lug lista de correo, circa 2002, recomendando un tamaño de bloque de 64 KB.
Para determinar EL óptimo de salida tamaño de bloque, he escrito el siguiente secuencia de comandos que las pruebas de la escritura de un 128M archivo de prueba con dd en una gama de diferentes tamaños de bloque, desde el valor predeterminado de 512 bytes para un máximo de 64 M. Se advirtió, este script utiliza dd internamente, a fin de utilizar con precaución.
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}
[ -e "$TEST_FILE" ]; TEST_FILE_EXISTS=$?
TEST_FILE_SIZE=134217728
# 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
# Create a test file with the specified block size
DD_RESULT=$(dd if=/dev/zero of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT 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
[ $TEST_FILE_EXISTS -ne 0 ] && rm $TEST_FILE
# Output the result
printf "$PRINTF_FORMAT" "$BLOCK_SIZE" "$TRANSFER_RATE"
done
Ver en GitHub
Yo sólo he probado este script en Debian (Ubuntu) y en OSX Yosemite, por lo que probablemente tendrá algunos ajustes para hacer que el trabajo en otras variantes de Unix.
Por defecto, el comando crea un archivo de pruebas nombre dd_obs_testfile
en el directorio actual. Alternativamente, usted puede proporcionar una ruta de acceso personalizado para un archivo de prueba mediante una vía después de que el nombre de secuencia de comandos:
$ ./dd_obs_test.sh /path/to/disk/test_file
La salida de la secuencia de comandos se muestra una lista de las pruebas de tamaños de bloque y su respectivo traslado
las tasas de este modo:
$ ./dd_obs_test.sh
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: La unidad de la transferencia de las tarifas varían por el sistema operativo)
A prueba óptima de lectura de bloque de tamaño, usted podría utilizar más o menos el mismo proceso,
pero en lugar de la lectura de /dev/zero
y la escritura en el disco, que había leído de
el disco y escribir /dev/null
. Un script para hacer esto podría ser así:
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}
[ -e "$TEST_FILE" ]; TEST_FILE_EXISTS=$?
TEST_FILE_SIZE=134217728
# Exit if file exists
if [ -e $TEST_FILE ]; then
echo "Test file $TEST_FILE exists, aborting."
exit 1
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 > /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
# 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
[ $TEST_FILE_EXISTS -ne 0 ] && rm $TEST_FILE
Ver en GitHub
Una diferencia importante en este caso es que el archivo de prueba es un archivo que está escrito el guión. No elija este comando en un archivo existente o el archivo existente se sobrescribe con datos aleatorios!
Para mi hardware en particular me pareció que 128K fue la más óptima de entrada tamaño de bloque en una unidad de disco duro y 32 k era el más óptimo en un SSD.
A pesar de esta respuesta, cubre la mayor parte de mis conclusiones, que he necesitado para determinar un óptimo dd tamaño de bloque suficiente de veces que escribí un post en el blog sobre ella. Usted puede encontrar más detalles sobre las pruebas que allí se llevan a cabo.
Este StackOverflow post también puede ser útil: dd: Cómo calcular el tamaño de bloque óptimo?