Para fines de prueba, tengo que generar un archivo de cierto tamaño (para probar un límite de carga).
¿Qué es un comando para crear un archivo de cierto tamaño en Linux?
Para fines de prueba, tengo que generar un archivo de cierto tamaño (para probar un límite de carga).
¿Qué es un comando para crear un archivo de cierto tamaño en Linux?
Respuestas:
dd if=/dev/zero of=upload_test bs=file_size count=1
¿Dónde file_size
está el tamaño de su archivo de prueba en bytes?
dd
tiene un límite de 2 ^ 32 por sus valores, por lo que para crear un archivo de más de 4 GB, hay un truco: dd if=/dev/zero of=test bs=1M count=<size in megabytes>
.
Por favor, lo moderno es más fácil y más rápido. En Linux, (elige uno)
truncate -s 10G foo
fallocate -l 5G bar
Es necesario decir que truncate
en un sistema de archivos que admite archivos dispersos creará un archivo disperso y fallocate
no lo hará. Un archivo disperso es aquel en el que las unidades de asignación que componen el archivo no se asignan realmente hasta que se usan. Sin embargo, los metadatos para el archivo ocuparán un espacio considerable, pero probablemente no cerca del tamaño real del archivo. Debe consultar recursos sobre archivos dispersos para obtener más información, ya que existen ventajas y desventajas para este tipo de archivo. Un archivo no disperso tiene sus bloques (unidades de asignación) asignados con anticipación, lo que significa que el espacio está reservado hasta donde el sistema de archivos lo ve. Además fallocate
, ni truncate
no se establecerá el contenido del archivo a un valor especificado como dd
, en cambio, el contenido de un archivo asignado con fallocate
o truncate
puede ser cualquier valor de papelera que haya existido en las unidades asignadas durante la creación y este comportamiento puede o no ser deseado. El dd
es el más lento porque en realidad escribe el valor o el fragmento de datos en toda la secuencia de archivos como se especifica con sus opciones de línea de comandos.
Este comportamiento podría ser diferente, dependiendo del sistema de archivos utilizado y la conformidad de ese sistema de archivos con cualquier estándar o especificación. Por lo tanto, se aconseja que se realice una investigación adecuada para garantizar que se utilice el método apropiado.
truncate
. Produjo un archivo de tamaño cero usando la sintaxis anterior. La 'página de manual' fallocate
dice que los archivos que crea están llenos de space
datos vacíos en lugar de datos. Parece que no sería útil para algunos casos esperados como "cuánto tiempo lleva copiar un archivo 1G".
brew install coreutils
. Esto añadirá un g delante del comando, así que hay que ejecutarlo como esto: gtruncate -s 10G foo
. ¡Espero que esto ayude!
NTFS
partición.
Solo para seguir la publicación de Tom , también puedes usar dd para crear archivos dispersos:
dd if=/dev/zero of=the_file bs=1 count=0 seek=12345
Esto creará un archivo con un "agujero" en la mayoría de los Unixes: los datos en realidad no se escribirán en el disco ni ocuparán espacio hasta que se escriba algo distinto de cero.
count=0
, se bs * seek
convierte en el tamaño del archivo
En OSX (y Solaris, aparentemente), el mkfile
comando también está disponible:
mkfile 10g big_file
Esto crea un archivo de 10 GB llamado "big_file". Encontré este enfoque aquí.
truncate
y fallocate
no están disponibles. dd
También funciona como se describió anteriormente, aunque no es m
para megabytes M
.
Usa este comando:
dd if = $ ARCHIVO DE ENTRADA de = $ ARCHIVO DE SALIDA bs = $ BLOCK-SIZE count = $ NUM-BLOCKS
Para crear un archivo grande (vacío), establezca $INPUT-FILE=/dev/zero
.
El tamaño total del archivo será $BLOCK-SIZE * $NUM-BLOCKS
.
Nuevo archivo creado será $OUTPUT-FILE
.
Puedes hacerlo mediante programación:
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
int main() {
int fd = creat("/tmp/foo.txt", 0644);
ftruncate(fd, SIZE_IN_BYTES);
close(fd);
return 0;
}
Este enfoque es especialmente útil para posteriormente mapear el archivo en la memoria.
use el siguiente comando para verificar que el archivo tenga el tamaño correcto:
# du -B1 --apparent-size /tmp/foo.txt
Ten cuidado:
# du /tmp/foo.txt
probablemente imprimirá 0 porque se asigna como archivo Sparse si es compatible con su sistema de archivos
ver también: hombre 2 abierto y hombre 2 truncado
Algunas de estas respuestas lo tienen usando /dev/zero
para la fuente de sus datos. Si prueba las velocidades de carga de la red, puede que esta no sea la mejor idea si su aplicación está haciendo alguna compresión, un archivo lleno de ceros se comprime muy bien. Usando este comando para generar el archivo
dd if=/dev/zero of=upload_test bs=10000 count=1
Podría comprimir upload_test
hasta unos 200 bytes. Por lo tanto, podría ponerse en una situación en la que cree que está cargando un archivo de 10 KB, pero en realidad sería mucho menos.
Lo que sugiero es usar en /dev/urandom
lugar de /dev/zero
. No pude comprimir la salida de /dev/urandom
mucho en absoluto.
/dev/zero
, por lo que /dev/urandom
es bueno.
dd if=/dev/zero of=my_file.txt count=12345
Hay muchas respuestas, pero ninguna explicó bien qué más se puede hacer. Buscando en las páginas man para dd , es posible especificar mejor el tamaño de un archivo.
Esto va a crear /tmp/zero_big_data_file.bin lleno de ceros, que tiene un tamaño de 20 megabytes:
dd if=/dev/zero of=/tmp/zero_big_data_file.bin bs=1M count=20
Esto va a crear /tmp/zero_1000bytes_data_file.bin lleno de ceros, que tiene un tamaño de 1000 bytes:
dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin bs=1kB count=1
o
dd if=/dev/zero of=/tmp/zero_1000bytes_data_file.bin bs=1000 count=1
Como comando de shell:
< /dev/zero head -c 1048576 > output
Úselo fallocate
si no quiere esperar al disco.
Ejemplo:
fallocate -l 100G BigFile
Uso:
Usage:
fallocate [options] <filename>
Preallocate space to, or deallocate space from a file.
Options:
-c, --collapse-range remove a range from the file
-d, --dig-holes detect zeroes and replace with holes
-i, --insert-range insert a hole at range, shifting existing data
-l, --length <num> length for range operations, in bytes
-n, --keep-size maintain the apparent size of the file
-o, --offset <num> offset for range operations, in bytes
-p, --punch-hole replace a range with a hole (implies -n)
-z, --zero-range zero and ensure allocation of a range
-x, --posix use posix_fallocate(3) instead of fallocate(2)
-v, --verbose verbose mode
-h, --help display this help
-V, --version display version