Bagaimana saya dapat dengan cepat membuat file besar di sistem Linux ( Red Hat Linux )?

dd akan melakukan pekerjaan itu, tetapi membaca dari /dev/zerodan menulis ke drive bisa memakan waktu lama ketika Anda membutuhkan file beberapa ratus GB dalam ukuran untuk pengujian ... Jika Anda perlu melakukannya berulang kali, waktu benar-benar bertambah.

Saya tidak peduli tentang isi file, saya hanya ingin itu dibuat dengan cepat. Bagaimana ini bisa dilakukan?

Menggunakan file jarang tidak akan berfungsi untuk ini. Saya perlu file tersebut dialokasikan ruang disk.

dddari jawaban lain adalah solusi yang baik, tetapi lambat untuk tujuan ini. Di Linux (dan sistem POSIX lainnya), kami memiliki fallocate, yang menggunakan ruang yang diinginkan tanpa harus benar-benar menulisnya, bekerja dengan sebagian besar sistem file berbasis disk modern, sangat cepat:

Sebagai contoh:

fallocate -l 10G gentoo_root.img

Ini adalah pertanyaan umum - terutama di lingkungan lingkungan virtual saat ini. Sayangnya, jawabannya tidak semudah yang diperkirakan.

dd adalah pilihan pertama yang jelas, tetapi dd pada dasarnya adalah salinan dan yang memaksa Anda untuk menulis setiap blok data (dengan demikian, menginisialisasi isi file) ... Dan inisialisasi itulah yang memakan banyak waktu I / O. (Ingin membuatnya lebih lama? Gunakan / dev / acak bukan / dev / nol ! Maka Anda akan menggunakan CPU serta waktu I / O!) Pada akhirnya, dd adalah pilihan yang buruk (meskipun pada dasarnya standar yang digunakan oleh VM "buat" GUI). Misalnya:

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

truncate adalah pilihan lain - dan mungkin yang tercepat ... Tapi itu karena ia membuat "file jarang". Pada dasarnya, file jarang adalah bagian dari disk yang memiliki banyak data yang sama, dan sistem file yang mendasarinya "menipu" dengan tidak benar-benar menyimpan semua data, tetapi hanya "berpura-pura" bahwa semua ada di sana. Jadi, ketika Anda menggunakan truncate untuk membuat drive 20 GB untuk VM Anda, filesystem tidak benar-benar mengalokasikan 20 GB, tetapi itu menipu dan mengatakan bahwa ada 20 GB nol di sana, meskipun hanya satu track pada disk. sebenarnya (benar-benar) sedang digunakan. Misalnya:

 truncate -s 10G gentoo_root.img

fallocate adalah akhir - dan terbaik - pilihan untuk digunakan dengan alokasi disk yang VM, karena pada dasarnya "cadangan" (atau "mengalokasikan" semua ruang Anda sedang mencari, tetapi tidak repot-repot untuk menulis apa-apa Jadi,. ketika Anda menggunakan fallocate untuk membuat ruang drive virtual 20 GB, Anda benar-benar mendapatkan file 20 GB (bukan "file jarang", dan Anda tidak akan repot-repot menulis apa pun untuk itu - yang berarti hampir apa pun bisa berada di sana - jenis seperti disk baru!) Mis:

fallocate -l 10G gentoo_root.img

Linux & semua sistem file

xfs_mkfile 10240m 10Gigfile

Linux & dan beberapa sistem file (ext4, xfs, btrfs dan ocfs2)

fallocate -l 10G 10Gigfile

OS X, Solaris, SunOS dan mungkin UNIX lainnya

mkfile 10240m 10Gigfile

HP-UX

prealloc 10Gigfile 10737418240

Penjelasan

Coba mkfile <size>myfile sebagai alternatif dd. Dengan -nopsi ukuran dicatat, tetapi blok disk tidak dialokasikan sampai data ditulis kepada mereka. Tanpa -nopsi, ruang kosong, yang berarti menulis ke disk, yang berarti membutuhkan waktu.

mkfile berasal dari SunOS dan tidak tersedia di mana-mana. Sebagian besar sistem Linux memiliki cara xfs_mkfileyang persis sama, dan tidak hanya pada sistem file XFS meskipun namanya. Ini termasuk dalam xfsprogs (untuk Debian / Ubuntu) atau paket bernama serupa.

Sebagian besar sistem Linux juga memiliki fallocate, yang hanya bekerja pada sistem file tertentu (seperti btrfs, ext4, ocfs2, dan xfs), tetapi merupakan yang tercepat, karena ia mengalokasikan semua ruang file (membuat file non-berlubang) tetapi tidak menginisialisasi semua itu.

truncate -s 10M output.file

akan membuat file 10 M secara instan (M berarti 1024 * 1024 byte, MB berarti 1000 * 1000 - sama dengan K, KB, G, GB ...)

EDIT: seperti yang telah ditunjukkan banyak orang, ini tidak akan secara fisik mengalokasikan file pada perangkat Anda. Dengan ini, Anda benar-benar dapat membuat file besar sembarang, terlepas dari ruang yang tersedia pada perangkat, karena itu membuat file "jarang".

Jadi, ketika melakukan ini, Anda akan menunda alokasi fisik hingga file diakses. Jika Anda memetakan file ini ke memori, Anda mungkin tidak memiliki kinerja yang diharapkan.

Tapi ini masih perintah yang berguna untuk diketahui

Di mana seek adalah ukuran file yang Anda inginkan dalam bytes - 1.

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

Contoh di mana mencari adalah ukuran file yang Anda inginkan dalam byte

#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

Dari halaman dd:

BLOK dan BANTUAN dapat diikuti oleh sufiks multiplikasi berikut: c = 1, w = 2, b = 512, kB = 1000, K = 1024, MB = 1000 * 1000, M = 1024 * 1024, GB = 1000 * 1000 * 1000, G = 1024 * 1024 * 1024, dan seterusnya untuk T, P, E, Z, Y.

Untuk membuat file 1 GB:

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

Saya tidak tahu banyak tentang Linux, tapi ini C Code yang saya tulis untuk memalsukan file besar di DC Share bertahun-tahun yang lalu.

#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");
    }
}

Anda dapat menggunakan perintah "ya" juga. Sintaksnya cukup sederhana:

#yes >> myfile

Tekan "Ctrl + C" untuk menghentikan ini, jika tidak maka akan memakan semua ruang Anda yang tersedia.

Untuk membersihkan file ini jalankan:

#>myfile

akan membersihkan file ini.

Saya tidak berpikir Anda akan mendapatkan lebih cepat daripada dd. Hambatannya adalah disk; menulis ratusan GB data untuk itu akan memakan waktu lama tidak peduli bagaimana Anda melakukannya.

Tapi di sini ada kemungkinan yang bisa digunakan untuk aplikasi Anda. Jika Anda tidak peduli dengan isi file, bagaimana dengan membuat file "virtual" yang isinya merupakan output dinamis dari suatu program? Alih-alih membuka () file, gunakan popen () untuk membuka pipa ke program eksternal. Program eksternal menghasilkan data kapan pun dibutuhkan. Setelah pipa terbuka, ini berfungsi seperti file biasa karena program yang membuka pipa dapat fseek (), mundur (), dll. Anda harus menggunakan pclose () alih-alih menutup () ketika Anda dilakukan dengan pipa.

Jika aplikasi Anda membutuhkan file dengan ukuran tertentu, itu akan tergantung pada program eksternal untuk melacak di mana di "file" itu dan mengirimkan bukti ketika "end" telah tercapai.

Satu pendekatan: jika Anda dapat menjamin aplikasi yang tidak terkait tidak akan menggunakan file dengan cara yang bertentangan, buat saja kumpulan file dengan ukuran yang berbeda-beda di direktori tertentu, lalu buat tautan ke sana jika diperlukan.

Misalnya, minta kumpulan file yang disebut:

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

Kemudian, jika Anda memiliki aplikasi yang membutuhkan file 1G bernama / home / oracle / logfile, jalankan " ln /home/bigfiles/1024M-A /home/oracle/logfile".

Jika ada pada sistem file yang terpisah, Anda harus menggunakan tautan simbolik.

File A / B / etc dapat digunakan untuk memastikan tidak ada penggunaan yang saling bertentangan antara aplikasi yang tidak terkait.

Operasi tautan hampir secepat yang Anda bisa.

GPL mkfile hanyalah pembungkus skrip (ba) di sekitar dd; Mkfile BSD hanya memsets buffer dengan non-zero dan menulisnya berulang kali. Saya tidak akan mengharapkan mantan untuk melakukan dd. Yang terakhir mungkin lebih baik dd jika = / dev / nol sedikit karena menghilangkan membaca, tetapi apa pun yang secara signifikan lebih baik mungkin hanya membuat file jarang.

Tidak ada panggilan sistem yang benar-benar mengalokasikan ruang untuk file tanpa menulis data (dan Linux dan BSD tidak memilikinya, mungkin Solaris juga) Anda mungkin mendapatkan sedikit peningkatan dalam kinerja dengan menggunakan ftrunc (2) / truncate (1) untuk memperpanjang file ke ukuran yang diinginkan, mmap file ke dalam memori, kemudian tulis data bukan nol ke byte pertama dari setiap blok disk (gunakan fgetconf untuk menemukan ukuran blok disk).

Steker tak tahu malu: OTFFS menyediakan sistem file yang menyediakan file besar yang sewenang-wenang (well, hampir. Exabytes adalah batas saat ini) dari konten yang dihasilkan. Ini hanya Linux, C biasa, dan dalam alpha awal.

Lihat https://github.com/s5k6/otffs .

Ini adalah yang tercepat yang bisa saya lakukan (yang tidak cepat) dengan batasan-batasan berikut:

• Tujuan dari file besar adalah untuk mengisi disk, jadi tidak dapat dikompres.
• Menggunakan sistem file ext3. ( fallocatetidak tersedia)

Ini adalah intinya ...

// 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);
}

Dalam kasus kami, ini untuk sistem linux tertanam dan ini berfungsi cukup baik, tetapi lebih suka sesuatu yang lebih cepat.

FYI perintahnya dd if=/dev/urandom of=outputfile bs=1024 count = XXsangat lambat sehingga tidak bisa digunakan.