ฉันจะสร้างไฟล์ขนาดใหญ่บนระบบ Linux ( Red Hat Linux ) ได้อย่างรวดเร็วได้อย่างไร

ddจะทำงานได้ แต่การอ่าน/dev/zeroและเขียนจากไดรฟ์อาจใช้เวลานานเมื่อคุณต้องการไฟล์ที่มีขนาดหลายร้อย GB สำหรับการทดสอบ ... หากคุณต้องทำซ้ำหลาย ๆ ครั้งเวลาจะเพิ่มขึ้นอย่างแท้จริง

ฉันไม่สนใจเนื้อหาของไฟล์ฉันแค่อยากให้มันสร้างขึ้นอย่างรวดเร็ว สิ่งนี้สามารถทำได้?

การใช้ไฟล์ sparse จะไม่ทำงานสำหรับสิ่งนี้ ฉันต้องการไฟล์เพื่อจัดสรรพื้นที่ดิสก์

ddจากคำตอบอื่น ๆ เป็นทางออกที่ดี แต่ช้าสำหรับจุดประสงค์นี้ ใน Linux (และระบบ POSIX อื่น ๆ ) เรามีfallocateซึ่งใช้พื้นที่ที่ต้องการโดยไม่ต้องเขียนลงไปทำงานกับระบบไฟล์ที่ใช้ดิสก์ที่ทันสมัยที่สุดอย่างรวดเร็ว:

ตัวอย่างเช่น:

fallocate -l 10G gentoo_root.img

นี่เป็นคำถามที่พบบ่อยโดยเฉพาะในสภาพแวดล้อมปัจจุบันของสภาพแวดล้อมเสมือน น่าเสียดายที่คำตอบนั้นไม่ตรงไปตรงมาอย่างที่ใคร ๆ คิด

dd เป็นตัวเลือกแรกที่เห็นได้ชัด แต่ dd เป็นตัวคัดลอกและบังคับให้คุณเขียนบล็อกข้อมูลทุกอัน (เช่นการเริ่มต้นเนื้อหาไฟล์) ... และการเริ่มต้นนั้นเป็นสิ่งที่ใช้เวลา I / O มาก (ต้องการทำให้ใช้เวลานานขึ้นหรือไม่ใช้/ dev / randomแทน/ dev / ศูนย์ ! จากนั้นคุณจะใช้ CPU เช่นเดียวกับเวลา I / O!) ในที่สุดแม้ว่า dd เป็นตัวเลือกที่ไม่ดี ค่าเริ่มต้นที่ใช้โดย VM "สร้าง" GUIs) เช่น:

dd if=/dev/zero of=./gentoo_root.img bs=4k iflag=fullblock,count_bytes count=10G

truncateเป็นอีกทางเลือก - และน่าจะเร็วที่สุด ... แต่นั่นเป็นเพราะมันสร้าง "ไฟล์กระจัดกระจาย" โดยพื้นฐานแล้วไฟล์ที่กระจัดกระจายเป็นส่วนหนึ่งของดิสก์ที่มีข้อมูลจำนวนมากและระบบไฟล์พื้นฐาน "กลโกง" โดยไม่ได้เก็บข้อมูลทั้งหมดจริงๆ แต่เพียง "แกล้ง" ว่ามีทั้งหมด ดังนั้นเมื่อคุณใช้ truncate เพื่อสร้างไดรฟ์ 20 GB สำหรับ VM ของคุณระบบไฟล์จะไม่จัดสรร 20 GB แต่จะโกงและบอกว่ามีศูนย์ 20 GB ที่นั่นแม้ว่าจะมีแทร็กเดียวบนดิสก์เพียงเล็กน้อย อาจมีการใช้งานจริง ๆ เช่น:

 truncate -s 10G gentoo_root.img

fallocate เป็นครั้งสุดท้าย - และที่ดีที่สุด - ทางเลือกสำหรับการใช้งานกับการจัดสรรดิสก์ VM เพราะมันเป็นหลัก "สำรอง" (หรือ "จัดสรร" ทุกพื้นที่ที่คุณกำลังมองหา แต่ก็ไม่ได้รำคาญที่จะเขียนอะไรดังนั้น. เมื่อคุณใช้ fallocate เพื่อสร้างพื้นที่ว่างบนไดรฟ์เสมือน 20 GB คุณจะได้รับไฟล์ 20 GB (ไม่ใช่ "ไฟล์ที่กระจัดกระจาย" และคุณจะไม่ต้องกังวลที่จะเขียนอะไรลงไปซึ่งหมายความว่าทุกอย่างจะอยู่ใน มี - เช่นดิสก์ใหม่เอี่ยม!) เช่น:

fallocate -l 10G gentoo_root.img

Linux & ระบบไฟล์ทั้งหมด

xfs_mkfile 10240m 10Gigfile

Linux และระบบไฟล์บางส่วน (ext4, xfs, btrfs และ ocfs2)

fallocate -l 10G 10Gigfile

OS X, Solaris, SunOS และ UNIX อื่น ๆ

mkfile 10240m 10Gigfile

HP-UX

prealloc 10Gigfile 10737418240

คำอธิบาย

ลองmkfile <size>myfile ddเป็นทางเลือกของ ด้วย-nตัวเลือกขนาดจะถูกบันทึกไว้ แต่บล็อกดิสก์จะไม่ถูกจัดสรรจนกว่าข้อมูลจะถูกเขียนลงไป หากไม่มี-nตัวเลือกพื้นที่นั้นจะเต็มไปด้วยศูนย์ซึ่งหมายถึงการเขียนลงดิสก์ซึ่งหมายถึงการใช้เวลา

mkfileมาจาก SunOS และไม่สามารถใช้ได้ทุกที่ ระบบลีนุกซ์ส่วนใหญ่มีวิธีการxfs_mkfileทำงานที่เหมือนกันทุกประการและไม่ใช่แค่ในระบบไฟล์ XFS แม้จะมีชื่อก็ตาม มันรวมอยู่ในxfsprogs (สำหรับ Debian / Ubuntu) หรือแพ็คเกจที่มีชื่อคล้ายกัน

ระบบลีนุกซ์ส่วนใหญ่มีfallocate, ซึ่งทำงานบนระบบไฟล์บางระบบเท่านั้น (เช่น btrfs, ext4, ocfs2, และ xfs), แต่มันเร็วที่สุด, เพราะมันจัดสรรพื้นที่ทั้งหมดของไฟล์ (สร้างไฟล์ที่ไม่ใช่ช่องว่าง) แต่ไม่เริ่มต้นใด ๆ ของมัน

truncate -s 10M output.file

จะสร้างไฟล์ 10 M ทันที (M หมายถึง 1024 * 1024 ไบต์, MB ย่อมาจาก 1,000 * 1,000 - เหมือนกับ K, KB, G, GB ... )

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

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

แต่นี่ก็ยังเป็นคำสั่งที่มีประโยชน์ที่ต้องรู้

โดยที่ find คือขนาดของไฟล์ที่คุณต้องการเป็นไบต์ - 1

dd if=/dev/zero of=filename bs=1 count=1 seek=1048575

ตัวอย่างที่ค้นหาคือขนาดของไฟล์ที่คุณต้องการในหน่วยไบต์

#kilobytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200K

#megabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200M

#gigabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200G

#terabytes
dd if=/dev/zero of=filename bs=1 count=0 seek=200T

จาก dd manpage:

บล็อกและ BYTES อาจตามด้วยคำต่อท้ายแบบคูณต่อไปนี้: c = 1, w = 2, b = 512, kB = 1000, K = 1024, MB = 1000 * 1000, M = 1024 * 1024, GB = 1000 * 1000 * 1,000, G = 1024 * 1024 * 1024 และอื่น ๆ สำหรับ T, P, E, Z, Y

วิธีสร้างไฟล์ 1 GB:

dd if=/dev/zero of=filename bs=1G count=1

ฉันไม่รู้มากเกี่ยวกับลีนุกซ์ แต่นี่คือรหัส C ที่ฉันเขียนลงไฟล์ปลอมขนาดใหญ่ใน DC Share เมื่อหลายปีก่อน

#include < stdio.h >
#include < stdlib.h >

int main() {
    int i;
    FILE *fp;

    fp=fopen("bigfakefile.txt","w");

    for(i=0;i<(1024*1024);i++) {
        fseek(fp,(1024*1024),SEEK_CUR);
        fprintf(fp,"C");
    }
}

คุณสามารถใช้คำสั่ง "ใช่" ได้เช่นกัน ไวยากรณ์ค่อนข้างง่าย:

#yes >> myfile

กด "Ctrl + C" เพื่อหยุดสิ่งนี้มิฉะนั้นจะหมดพื้นที่ว่างของคุณ

เพื่อล้างไฟล์นี้ให้เรียกใช้:

#>myfile

จะล้างไฟล์นี้

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

แต่นี่เป็นความเป็นไปได้ที่อาจใช้ได้กับแอปพลิเคชันของคุณ หากคุณไม่สนใจเกี่ยวกับเนื้อหาของไฟล์วิธีการเกี่ยวกับการสร้างไฟล์ "เสมือน" ที่มีเนื้อหาเป็นเอาท์พุทแบบไดนามิกของโปรแกรม? แทนที่จะเปิด () ไอเอ็นจีไฟล์ให้ใช้ popen () เพื่อเปิดไพพ์ไปยังโปรแกรมภายนอก โปรแกรมภายนอกสร้างข้อมูลทุกครั้งที่จำเป็น เมื่อไพพ์เปิดแล้วมันจะทำหน้าที่เหมือนกับไฟล์ปกติที่โปรแกรมที่เปิดไพพ์นั้นสามารถ fseek () ย้อนกลับ () ฯลฯ คุณจะต้องใช้ pclose () แทนที่จะปิด () เมื่อคุณ ทำกับท่อ

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

วิธีการหนึ่ง: หากคุณสามารถรับประกันแอปพลิเคชันที่ไม่เกี่ยวข้องจะไม่ใช้ไฟล์ในลักษณะที่ขัดแย้งกันเพียงแค่สร้างกลุ่มของไฟล์ที่มีขนาดแตกต่างกันในไดเรกทอรีเฉพาะจากนั้นสร้างลิงก์ไปยังพวกเขาเมื่อต้องการ

ตัวอย่างเช่นมีกลุ่มของไฟล์ที่เรียกว่า:

• / home / bigfiles / 512M-A
• / home / bigfiles / 512M-B
• / home / bigfiles / 1024M-A
• / home / bigfiles / 1024M-B

จากนั้นหากคุณมีแอปพลิเคชันที่ต้องการไฟล์ 1G ชื่อ / home / oracle / logfile ให้รัน "ln /home/bigfiles/1024M-A /home/oracle/logfile "

หากอยู่ในระบบไฟล์แยกต่างหากคุณจะต้องใช้ลิงก์สัญลักษณ์

ไฟล์ A / B / etc สามารถใช้เพื่อให้แน่ใจว่าไม่มีการใช้ที่ขัดแย้งกันระหว่างแอปพลิเคชันที่ไม่เกี่ยวข้อง

การดำเนินการเชื่อมโยงนั้นเร็วพอ ๆ กับที่คุณจะได้รับ

GPL mkfile เป็นเพียง wrapper สคริปต์ (ba) sh รอบ dd; mkfile ของ BSD เพียงแค่จดจำบัฟเฟอร์ด้วย non-zero และเขียนมันซ้ำ ๆ ฉันจะไม่คาดหวังว่าอดีตที่จะออกเดท dd หลังอาจขอบออก dd ถ้า = / dev / ศูนย์เล็กน้อยเนื่องจากละเว้นการอ่าน แต่สิ่งที่ไม่ดีขึ้นอย่างมีนัยสำคัญอาจเป็นเพียงการสร้างไฟล์กระจัดกระจาย

ขาดการเรียกระบบที่จัดสรรพื้นที่สำหรับไฟล์โดยไม่ต้องเขียนข้อมูล (และ Linux และ BSD ขาดสิ่งนี้อาจเป็น Solaris เช่นกัน) คุณอาจได้รับการปรับปรุงประสิทธิภาพเล็กน้อยโดยใช้ ftrunc (2) / truncate (1) เพื่อขยายไฟล์ ตามขนาดที่ต้องการให้ mmap ไฟล์ลงในหน่วยความจำแล้วเขียนข้อมูลที่ไม่เป็นศูนย์ไปยังไบต์แรกของทุกบล็อกดิสก์ (ใช้ fgetconf เพื่อค้นหาขนาดบล็อกดิสก์)

ปลั๊กไร้ยางอาย: OTFFS จัดให้มีระบบไฟล์ที่มีขนาดใหญ่ตามอำเภอใจ (ดีเกือบ Exabytes เป็นขีด จำกัด ปัจจุบัน) ของเนื้อหาที่สร้างขึ้น มันเป็น Linux เท่านั้น, C ธรรมดาและในช่วงต้นอัลฟา

ดูhttps://github.com/s5k6/otffs

นี่เป็นวิธีที่เร็วที่สุดที่ฉันสามารถทำได้ (ซึ่งไม่เร็ว) ด้วยข้อ จำกัด ดังต่อไปนี้:

• เป้าหมายของไฟล์ขนาดใหญ่คือการเติมดิสก์ดังนั้นจึงไม่สามารถบีบอัดได้
• การใช้ระบบไฟล์ ext3 ( fallocateไม่พร้อมใช้งาน)

นี่คือส่วนสำคัญของมัน ...

// include stdlib.h, stdio.h, and stdint.h
int32_t buf[256]; // Block size.
for (int i = 0; i < 256; ++i)
{
    buf[i] = rand(); // random to be non-compressible.
}
FILE* file = fopen("/file/on/your/system", "wb");
int blocksToWrite = 1024 * 1024; // 1 GB
for (int i = 0; i < blocksToWrite; ++i)
{
   fwrite(buf, sizeof(int32_t), 256, file);
}

ในกรณีของเรานี่เป็นระบบลินุกซ์ในตัวและทำงานได้ดี แต่จะต้องการอะไรที่เร็วกว่า

FYI คำสั่งdd if=/dev/urandom of=outputfile bs=1024 count = XXช้ามากจนใช้ไม่ได้