Come altri hanno già detto, non esiste una dimensione di blocco universalmente corretta; ciò che è ottimale per una situazione o un componente hardware può essere terribilmente inefficiente per un altro. Inoltre, a seconda dell'integrità dei dischi, può essere preferibile utilizzare una dimensione di blocco diversa da quella "ottimale".
Una cosa che è abbastanza affidabile su hardware moderno è che la dimensione del blocco predefinito di 512 byte tende ad essere quasi un ordine di grandezza più lento di un'alternativa più ottimale. In caso di dubbio, ho scoperto che 64 KB è un default moderno piuttosto solido. Sebbene 64K di solito non siano le dimensioni ottimali del blocco, nella mia esperienza tende ad essere molto più efficiente di quello predefinito. 64K ha anche una storia piuttosto solida di essere affidabile: puoi trovare un messaggio dalla mailing list di Eug-Lug , circa 2002, raccomandando una dimensione del blocco di 64K.
Per determinare la dimensione ottimale del blocco di output, ho scritto il seguente script che verifica la scrittura di un file di test da 128 M con dd in un intervallo di diverse dimensioni di blocco, dal valore predefinito di 512 byte a un massimo di 64 MB. Attenzione, questo script usa dd internamente, quindi usa con cautela.
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
Visualizza su GitHub
Ho testato questo script solo su un sistema Debian (Ubuntu) e su OSX Yosemite, quindi probabilmente ci vorranno alcune modifiche per far funzionare altri sapori Unix.
Per impostazione predefinita, il comando creerà un file di prova denominato dd_obs_testfilenella directory corrente. In alternativa, è possibile fornire un percorso a un file di test personalizzato fornendo un percorso dopo il nome dello script:
$ ./dd_obs_test.sh /path/to/disk/test_file
L'output dello script è un elenco delle dimensioni dei blocchi testati e delle rispettive velocità di trasferimento in questo modo:
$ ./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: l'unità delle velocità di trasferimento varia in base al sistema operativo)
Per testare le dimensioni ottimali del blocco di lettura, è possibile utilizzare più o meno lo stesso processo, ma invece di leggere /dev/zeroe scrivere sul disco, leggere dal disco e scrivere /dev/null. Una sceneggiatura per farlo potrebbe apparire così:
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
Visualizza su GitHub
Una differenza importante in questo caso è che il file di test è un file scritto dallo script. Non puntare questo comando su un file esistente o il file esistente verrà sovrascritto con dati casuali!
Per il mio hardware particolare ho scoperto che 128K era la dimensione del blocco di input più ottimale su un HDD e 32K era il più ottimale su un SSD.
Sebbene questa risposta copra la maggior parte delle mie scoperte, ho dovuto determinare una dimensione ottimale del blocco dd abbastanza volte che ho scritto un post sul blog al riguardo. Puoi trovare ulteriori dettagli sui test che ho eseguito lì.
Questo post StackOverflow può anche essere utile: dd: come calcolare la dimensione di blocco ottimale?
dd if=/dev/hda of=hdb? Ecco una risposta che mostra alcuni dettagli tra cui il runtime per 160 GB: askubuntu.com/questions/435694/…