¿Cómo puedo crear rápidamente un archivo grande en un sistema Linux ( Red Hat Linux )?

dd hará el trabajo, pero leer /dev/zeroy escribir en la unidad puede llevar mucho tiempo cuando necesita un archivo de varios cientos de GB de tamaño para probar ... Si necesita hacerlo repetidamente, el tiempo realmente se acumula.

No me importa el contenido del archivo, solo quiero que se cree rápidamente. ¿Cómo se puede hacer esto?

Usar un archivo disperso no funcionará para esto. Necesito que se le asigne espacio en disco al archivo.

ddde las otras respuestas es una buena solución, pero es lenta para este propósito. En Linux (y otros sistemas POSIX), tenemos fallocate, que utiliza el espacio deseado sin tener que escribir realmente, funciona con la mayoría de los sistemas de archivos basados ​​en disco modernos, muy rápido:

Por ejemplo:

fallocate -l 10G gentoo_root.img

Esta es una pregunta común, especialmente en el entorno actual de entornos virtuales. Desafortunadamente, la respuesta no es tan directa como se podría suponer.

dd es la primera opción obvia, pero dd es esencialmente una copia y eso te obliga a escribir cada bloque de datos (por lo tanto, inicializando el contenido del archivo) ... Y esa inicialización es lo que ocupa tanto tiempo de E / S. (¿Quiere que se demore aún más? ¡Use / dev / random en lugar de / dev / zero ! ¡Entonces usará la CPU y el tiempo de E / S!) Sin embargo, al final, dd es una mala elección (aunque esencialmente predeterminado utilizado por la VM "crear" GUI). P.ej:

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

truncar es otra opción, y es probable que sea la más rápida ... Pero eso se debe a que crea un "archivo disperso". Esencialmente, un archivo disperso es una sección del disco que tiene muchos de los mismos datos, y el sistema de archivos subyacente "engaña" al no almacenar realmente todos los datos, sino simplemente "pretender" que todo está allí. Por lo tanto, cuando usa truncar para crear una unidad de 20 GB para su VM, el sistema de archivos en realidad no asigna 20 GB, pero hace trampa y dice que hay 20 GB de ceros allí, a pesar de que solo hay una pista en el disco en realidad puede (realmente) estar en uso. P.ej:

 truncate -s 10G gentoo_root.img

fallocate es el final - y mejor - elección para su uso con asignación de disco VM, porque es esencialmente "reservas" (o "asigna" todo el espacio que usted está buscando, pero no se molestan en escribir nada lo tanto,. cuando usa Falocate para crear un espacio de disco virtual de 20 GB, realmente obtiene un archivo de 20 GB (no un "archivo disperso", y no se habrá molestado en escribirle nada, lo que significa que prácticamente cualquier cosa podría estar en allí, ¡como un disco nuevo!) Por ejemplo:

fallocate -l 10G gentoo_root.img

Linux y todos los sistemas de archivos

xfs_mkfile 10240m 10Gigfile

Linux y algunos sistemas de archivos (ext4, xfs, btrfs y ocfs2)

fallocate -l 10G 10Gigfile

OS X, Solaris, SunOS y probablemente otros UNIX

mkfile 10240m 10Gigfile

HP-UX

prealloc 10Gigfile 10737418240

Explicación

Pruebe mkfile <size>myfile como alternativa de dd. Con la -nopción se indica el tamaño, pero los bloques de disco no se asignan hasta que se escriben datos en ellos. Sin la -nopción, el espacio está lleno de cero, lo que significa escribir en el disco, lo que significa tomar tiempo.

mkfile se deriva de SunOS y no está disponible en todas partes. La mayoría de los sistemas Linux tienen lo xfs_mkfileque funciona exactamente de la misma manera, y no solo en los sistemas de archivos XFS a pesar del nombre. Se incluye en xfsprogs (para Debian / Ubuntu) o paquetes con nombre similares.

La mayoría de los sistemas Linux también tienen fallocate, que solo funciona en ciertos sistemas de archivos (como btrfs, ext4, ocfs2 y xfs), pero es el más rápido, ya que asigna todo el espacio de archivos (crea archivos que no son holey) pero no inicializa ninguno de eso.

truncate -s 10M output.file

creará un archivo de 10 M instantáneamente (M significa 1024 * 1024 bytes, MB significa 1000 * 1000 - lo mismo con K, KB, G, GB ...)

EDITAR: como muchos han señalado, esto no asignará físicamente el archivo en su dispositivo. Con esto, podría crear un archivo grande arbitrario, independientemente del espacio disponible en el dispositivo, ya que crea un archivo "disperso".

Entonces, al hacer esto, diferirá la asignación física hasta que se acceda al archivo. Si está asignando este archivo a la memoria, es posible que no tenga el rendimiento esperado.

Pero este sigue siendo un comando útil para saber

Donde search es el tamaño del archivo que desea en bytes - 1.

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

Ejemplos donde search es el tamaño del archivo que desea en bytes

#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

Desde la página de manual de dd:

Los BLOQUES y BYTES pueden ir seguidos de los siguientes sufijos multiplicativos: c = 1, w = 2, b = 512, kB = 1000, K = 1024, MB = 1000 * 1000, M = 1024 * 1024, GB = 1000 * 1000 * 1000, G = 1024 * 1024 * 1024, y así sucesivamente para T, P, E, Z, Y.

Para hacer un archivo de 1 GB:

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

No sé mucho sobre Linux, pero aquí está el código C que escribí para falsificar archivos enormes en DC Share hace muchos años.

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

También puede usar el comando "sí". La sintaxis es bastante simple:

#yes >> myfile

Presiona "Ctrl + C" para detener esto, de lo contrario se comerá todo tu espacio disponible.

Para limpiar este archivo, ejecute:

#>myfile

limpiará este archivo.

No creo que vaya a ser mucho más rápido que dd. El cuello de botella es el disco; escribir cientos de GB de datos en él llevará mucho tiempo sin importar cómo lo haga.

Pero aquí hay una posibilidad que podría funcionar para su aplicación. Si no le importa el contenido del archivo, ¿qué le parece crear un archivo "virtual" cuyo contenido sea la salida dinámica de un programa? En lugar de abrir () el archivo, use popen () para abrir una tubería a un programa externo. El programa externo genera datos cuando sea necesario. Una vez que la tubería está abierta, actúa como un archivo normal en el sentido de que el programa que abrió la tubería puede fseek (), rewind (), etc. Deberá usar pclose () en lugar de close () cuando esté hecho con la pipa.

Si su aplicación necesita que el archivo tenga un tamaño determinado, dependerá del programa externo realizar un seguimiento de dónde se encuentra el "archivo" y enviar un eof cuando se haya alcanzado el "final".

Un enfoque: si puede garantizar que las aplicaciones no relacionadas no utilizarán los archivos de manera conflictiva, simplemente cree un grupo de archivos de diferentes tamaños en un directorio específico, luego cree enlaces a ellos cuando sea necesario.

Por ejemplo, tenga un grupo de archivos llamado:

• / inicio / archivos grandes / 512M-A
• / inicio / archivos grandes / 512M-B
• / inicio / archivos grandes / 1024M-A
• / inicio / archivos grandes / 1024M-B

Luego, si tiene una aplicación que necesita un archivo 1G llamado / home / oracle / logfile, ejecute un " ln /home/bigfiles/1024M-A /home/oracle/logfile".

Si está en un sistema de archivos separado, deberá usar un enlace simbólico.

Los archivos A / B / etc. se pueden usar para garantizar que no haya un uso conflictivo entre aplicaciones no relacionadas.

La operación de enlace es lo más rápida posible.

El archivo GPL mk es solo un contenedor de script (ba) sh alrededor de dd; El archivo mk de BSD solo establece un búfer con un valor distinto de cero y lo escribe repetidamente. No esperaría que el primero superara a dd. Este último puede superar dd if = / dev / zero ligeramente ya que omite las lecturas, pero cualquier cosa que lo haga significativamente mejor probablemente solo esté creando un archivo disperso.

En ausencia de una llamada al sistema que realmente asigne espacio para un archivo sin escribir datos (y Linux y BSD carecen de esto, probablemente también Solaris), puede obtener una pequeña mejora en el rendimiento al usar ftrunc (2) / truncate (1) para extender el archivo al tamaño deseado, mmap el archivo en la memoria, luego escriba datos distintos de cero en los primeros bytes de cada bloque de disco (use fgetconf para encontrar el tamaño del bloque de disco).

Plug descarado: OTFFS proporciona un sistema de archivos que proporciona archivos arbitrariamente grandes (bueno, casi. Exabytes es el límite actual) de contenido generado. Es solo para Linux, C simple y en alfa temprano.

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

Esto es lo más rápido que podría hacer (que no es rápido) con las siguientes restricciones:

• El objetivo del archivo grande es llenar un disco, por lo que no puede ser comprimible.
• Usando el sistema de archivos ext3. ( fallocateno disponible)

Esta es la esencia de esto ...

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

En nuestro caso, esto es para un sistema Linux integrado y funciona bastante bien, pero preferiría algo más rápido.

FYI, el comando dd if=/dev/urandom of=outputfile bs=1024 count = XXfue tan lento que no se pudo utilizar.