dd: จะคำนวณขนาดบล็อกที่เหมาะสมได้อย่างไร [ปิด]


122

คุณจะคำนวณขนาดบล็อกที่เหมาะสมที่สุดได้อย่างไรเมื่อเรียกใช้ a dd? ฉันได้ค้นคว้าข้อมูลเล็กน้อยและไม่พบสิ่งใดที่ชี้ให้เห็นว่าสิ่งนี้จะสำเร็จได้อย่างไร

ฉันรู้สึกว่าขนาดบล็อกที่ใหญ่ขึ้นจะส่งผลให้เร็วขึ้นdd... เป็นจริงหรือไม่?

ฉันกำลังจะddมี Hitachi HDDs ขนาด 500GB ที่เหมือนกันสองตัวที่ทำงานที่ 7200rpm บนกล่องที่ใช้ Intel Core i3 พร้อม 4GB DDR3 1333mhz RAM ดังนั้นฉันจึงพยายามหาว่าจะใช้บล็อกอะไร (ฉันจะบูต Ubuntu 10.10 x86 จากแฟลชไดรฟ์และเรียกใช้จากนั้น)


ใช้คำตอบ @ tdg5 สำหรับ macOS - macos_dd_ibs_test.shและmacos_dd_obs_test.sh
mixel

1
คำตอบที่ดีที่สุดคือการมีส่วนร่วมในddการค้นหา
Boris

เหตุใดสิ่งนี้จึงถูกทำเครื่องหมายเป็นหัวข้อและไม่ย้ายไปยัง superuser
user267092

คำตอบ:


95

ขนาดบล็อกที่เหมาะสมจะขึ้นอยู่กับปัจจัยต่างๆรวมถึงระบบปฏิบัติการ (และเวอร์ชัน) และฮาร์ดแวร์บัสและดิสก์ต่างๆที่เกี่ยวข้อง ระบบที่คล้าย Unix หลายระบบ (รวมถึง Linux และ BSD อย่างน้อยบางรสชาติ) กำหนดst_blksizeสมาชิกในstruct statสิ่งที่เคอร์เนลคิดว่าเป็นขนาดบล็อกที่เหมาะสมที่สุด:

#include <sys/stat.h>
#include <stdio.h>

int main(void)
{
    struct stat stats;

    if (!stat("/", &stats))
    {
        printf("%u\n", stats.st_blksize);
    }
}

วิธีที่ดีที่สุดคือการทดลอง: คัดลอกกิกะไบต์ที่มีขนาดบล็อกและเวลาที่หลากหลาย (อย่าลืมล้างเคอร์เนลบัฟเฟอร์แคชก่อนที่จะทำงานแต่ละ: echo 3 > /proc/sys/vm/drop_caches)

อย่างไรก็ตามตามกฎทั่วไปฉันพบว่าขนาดบล็อกที่ใหญ่พอddจะทำงานได้ดีและความแตกต่างระหว่างกล่าวคือ 64 KiB และ 1 MiB นั้นน้อยเมื่อเทียบกับ 4 KiB เทียบกับ 64 KiB (เป็นที่ยอมรับว่าเป็นเวลานานแล้วที่ฉันทำเช่นนั้นฉันใช้ mebibyte เป็นค่าเริ่มต้นในตอนนี้หรือเพียงแค่ปล่อยให้ddเลือกขนาด)


11
ฉันขอโทษที่ไม่เคยยอมรับคำตอบนี้ ... ขอบคุณ!
eckza

จุดยอดเยี่ยมเกี่ยวกับการจดจำการวางแคช นี่ทำให้การวัดของฉันสับสน! (แม้ว่าจะมีปัญหาเล็กน้อย: มันคือ "drop_caches" แต่มีขีดล่างการแก้ไขต้องมีอย่างน้อย 6 ตัวอักษร ... :()
ทอม

73

อย่างที่คนอื่น ๆ บอกไม่มีขนาดบล็อกที่ถูกต้องในระดับสากล สิ่งที่ดีที่สุดสำหรับสถานการณ์หนึ่งหรือฮาร์ดแวร์ชิ้นเดียวอาจไม่มีประสิทธิภาพอย่างมากสำหรับอีกชิ้นหนึ่ง นอกจากนี้ขึ้นอยู่กับความสมบูรณ์ของดิสก์อาจเป็นที่นิยมที่จะใช้ขนาดบล็อกที่แตกต่างจากที่ "เหมาะสมที่สุด"

สิ่งหนึ่งที่ค่อนข้างน่าเชื่อถือในฮาร์ดแวร์สมัยใหม่ก็คือขนาดบล็อกเริ่มต้น 512 ไบต์มีแนวโน้มที่จะเรียงลำดับขนาดได้ช้ากว่าทางเลือกที่ดีกว่า เมื่อมีข้อสงสัยฉันพบว่า 64K เป็นค่าเริ่มต้นที่ค่อนข้างทันสมัย แม้ว่า 64K จะไม่ใช่ขนาดบล็อกที่เหมาะสมที่สุด แต่จากประสบการณ์ของฉันมันมีแนวโน้มที่จะมีประสิทธิภาพมากกว่าค่าเริ่มต้นมาก 64K ยังมีประวัติที่มั่นคงในการเป็นนักแสดงที่น่าเชื่อถือ: คุณสามารถค้นหาข้อความจากรายชื่ออีเมลของ Eug-Lug ประมาณปี 2002 โดยแนะนำขนาดบล็อก 64K ที่นี่: http://www.mail-archive.com/eug- lug@efn.org/msg12073.html

สำหรับการกำหนดขนาดบล็อกเอาต์พุตที่ดีที่สุดฉันได้เขียนสคริปต์ต่อไปนี้ซึ่งทดสอบการเขียนไฟล์ทดสอบ 128M ด้วย dd ในช่วงของขนาดบล็อกที่แตกต่างกันตั้งแต่ค่าเริ่มต้น 512 ไบต์ไปจนถึงสูงสุด 64M ขอเตือนสคริปต์นี้ใช้ dd ภายในดังนั้นโปรดใช้ด้วยความระมัดระวัง

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

ดูบน GitHub

ฉันได้ทดสอบสคริปต์นี้บนระบบ Debian (Ubuntu) และบน OSX Yosemite เท่านั้นดังนั้นอาจต้องใช้การปรับแต่งเพื่อให้สามารถใช้งานกับรสชาติอื่น ๆ ของ Unix ได้

ตามค่าเริ่มต้นคำสั่งจะสร้างไฟล์ทดสอบชื่อdd_obs_testfileในไดเร็กทอรีปัจจุบัน หรือคุณสามารถระบุเส้นทางไปยังไฟล์ทดสอบที่กำหนดเองได้โดยระบุเส้นทางหลังชื่อสคริปต์:

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

ผลลัพธ์ของสคริปต์คือรายการขนาดบล็อกที่ทดสอบและอัตราการถ่ายโอนตามลำดับดังนี้:

$ ./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

(หมายเหตุ: หน่วยของอัตราการถ่ายโอนจะแตกต่างกันไปตามระบบปฏิบัติการ)

ในการทดสอบขนาดบล็อกการอ่านที่เหมาะสมที่สุดคุณสามารถใช้กระบวนการเดียวกันได้มากหรือน้อย แต่แทนที่จะอ่านจาก / dev / zero และเขียนลงดิสก์คุณจะอ่านจากดิสก์และเขียนลงใน / dev / null สคริปต์ในการดำเนินการนี้อาจมีลักษณะดังนี้:

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

ดูบน GitHub

ข้อแตกต่างที่สำคัญในกรณีนี้คือไฟล์ทดสอบเป็นไฟล์ที่เขียนโดยสคริปต์ อย่าชี้คำสั่งนี้ไปที่ไฟล์ที่มีอยู่มิฉะนั้นไฟล์ที่มีอยู่จะถูกเขียนทับด้วยศูนย์!

สำหรับฮาร์ดแวร์เฉพาะของฉันฉันพบว่า 128K เป็นขนาดบล็อกอินพุตที่เหมาะสมที่สุดบน HDD และ 32K เหมาะสมที่สุดสำหรับ SSD

แม้ว่าคำตอบนี้จะครอบคลุมการค้นพบส่วนใหญ่ของฉัน แต่ฉันก็พบกับสถานการณ์นี้หลายครั้งมากพอที่ฉันจะเขียนบล็อกโพสต์เกี่ยวกับเรื่องนี้: http://blog.tdg5.com/tuning-dd-block-size/คุณสามารถค้นหาข้อมูลเฉพาะเพิ่มเติมได้ ในการทดสอบที่ฉันทำที่นั่น


1
ฉันเรียกใช้สคริปต์ที่สองทดสอบประสิทธิภาพการอ่านบน 2015 rMBP พร้อม 512G SSD ขนาดบล็อกที่ดีที่สุดคือ 8388608: 3.582 GB ไบต์ / วินาที
Quinn Comendant

1
การแก้ไข: ฉันใช้สคริปต์ที่สองทดสอบประสิทธิภาพการอ่านบน 2015 rMBP พร้อม 512GB SSD ขนาดบล็อกที่ดีที่สุดคือ 524288 (5.754 GB / วินาที) ขนาดบล็อกที่ดีที่สุดอันดับสองคือ 131072 (5.133 GB / วินาที) (ฉันเรียงลำดับผลลัพธ์ไม่ถูกต้องในการสร้างค่าสำหรับความคิดเห็นล่าสุดของฉัน)
Quinn Comendant

For dd_obs_test.sh conv=fsyncไม่ทำงานบน macOS และสามารถลบออกได้
rynop

จากประสบการณ์ของฉันการเปรียบเทียบขนาดบล็อกที่ใหญ่ขึ้นจำเป็นต้องมีตัวอย่างที่ใหญ่กว่าเพื่อให้มีความแม่นยำ (หลายวินาทีฉันเดาว่าไฟล์ 128MB ควรจะทำให้ได้ แต่ฉันไม่แน่ใจ) ไม่แน่ใจว่าทำไม
Rolf

2
เพื่อน! ช่างเป็นคำตอบที่น่าทึ่ง มันเหมือนกับการค้นหาเหมืองทองขุดดินจำนวนมากจากนั้นประมวลผลเพื่อค้นหา GOLD NUGGET ที่ฉันต้องการ: 64K ขอบคุณมาก
SDsolar

10

ฉันพบว่าขนาดบล็อกที่ดีที่สุดของฉันคือ 8 MB (เท่ากับแคชของดิสก์?) ฉันจำเป็นต้องล้าง (บางคนบอกว่า: ล้าง) พื้นที่ว่างบนดิสก์ก่อนที่จะสร้างภาพบีบอัด ฉันใช้:

cd /media/DiskToWash/
dd if=/dev/zero of=zero bs=8M; rm zero

ฉันทดลองกับค่าตั้งแต่ 4K ถึง 100M

หลังจากปล่อยให้ dd ทำงานสักพักฉันก็ฆ่ามัน (Ctlr + C) และอ่านผลลัพธ์:

36+0 records in
36+0 records out
301989888 bytes (302 MB) copied, 15.8341 s, 19.1 MB/s

เนื่องจาก dd แสดงอัตราอินพุต / เอาต์พุต (ในกรณีนี้คือ 19.1MB / s) คุณสามารถดูได้ง่ายว่าค่าที่คุณเลือกนั้นมีประสิทธิภาพดีกว่าค่าก่อนหน้าหรือแย่กว่านั้น

คะแนนของฉัน:

bs=   I/O rate
---------------
4K    13.5 MB/s
64K   18.3 MB/s
8M    19.1 MB/s <--- winner!
10M   19.0 MB/s
20M   18.6 MB/s
100M  18.6 MB/s   

หมายเหตุ: ในการตรวจสอบขนาดแคช / บัฟเฟอร์ของดิสก์คุณสามารถใช้ได้ sudo hdparm -i /dev/sda


4
คุณทำการทดสอบเพียงครั้งเดียวหรือไม่ ฉันคิดว่าสิ่งที่คุณอาจเห็นจาก≥64Kคือบัฟเฟอร์เต็มแล้วและความแตกต่างเป็นเพียงความแปรปรวนแบบสุ่ม
Mads Y

ฉันเคยได้ยินมาครั้งหนึ่งว่าค่านิยมจำนวนมากอาจทำให้ระบบคอขวด บุคคลนั้นกำลังทำงานกับไฟล์ขนาดใหญ่ คงจะดีไม่น้อยหากได้รับฟังข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้
Todd Partridge

1
ประสบการณ์ของฉันชี้ให้เห็น8Mก็ยากที่จะเอาชนะ
Sridhar Sarnobat

น่าสนใจ คุณคิดว่าสิ่งนี้เกี่ยวข้องกับขนาดแคช L3 หรือไม่? ฉันสงสัยว่าขนาดบล็อกที่ใหญ่กว่าแคช L3 จะช้าลงหรือไม่
SurpriseDog

3

สิ่งนี้ขึ้นอยู่กับระบบทั้งหมด คุณควรทดลองเพื่อหาทางออกที่ดีที่สุด bs=8388608ลองเริ่มต้นด้วย (เนื่องจาก Hitachi HDDs ดูเหมือนจะมีแคช 8MB)


5
เวอร์ชัน dd จำนวนมากยอมรับ shorthands เช่นbs=8Mบน GNU / Linux หรือbs=8mบน BSD
pascal

4
ฮ่า ๆ คิดว่าคุณจะพูดว่า "ลองเริ่มที่bs=8388608และลดลงทุกๆก้าว"
ลินเด้

1
  • เพื่อประสิทธิภาพที่ดีขึ้นให้ใช้ขนาดบล็อกที่ใหญ่ที่สุดที่คุณสามารถรองรับ RAM ได้ (จะส่งการเรียก I / O ไปยัง OS น้อยลง)
  • เพื่อความถูกต้องและการกู้คืนข้อมูลที่ดีขึ้นให้ตั้งค่าขนาดบล็อกเป็นขนาดเซกเตอร์ดั้งเดิมของอินพุต

เนื่องจาก dd คัดลอกข้อมูลด้วยตัวเลือก conv = noerror, sync ข้อผิดพลาดใด ๆ ที่พบจะส่งผลให้ส่วนที่เหลือของบล็อกถูกแทนที่ด้วยศูนย์ไบต์ ขนาดบล็อกที่ใหญ่ขึ้นจะคัดลอกได้เร็วขึ้น แต่ทุกครั้งที่พบข้อผิดพลาดส่วนที่เหลือของบล็อกจะถูกละเว้น

แหล่ง


1
ฉันคิดว่าหากมีข้อผิดพลาดในการเขียนคุณควรเปลี่ยนสื่อไม่ใช่เปลี่ยนขนาดบล็อก ...
unfa
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.