Cree rápidamente un archivo grande en un sistema Windows

En la misma línea que crear rápidamente un archivo grande en un sistema Linux , me gustaría crear rápidamente un archivo grande en un sistema Windows. En general estoy pensando en 5 GB. El contenido no importa. Sería preferible un comando incorporado o un archivo por lotes corto, pero aceptaré una aplicación si no hay otras formas fáciles.

fsutil file createnew <filename> <length>

donde <length>está en bytes.

fsutil requiere privilegios administrativos sin embargo.

Puede usar la herramienta Contig de Sysinternals . Tiene un -ninterruptor que crea un nuevo archivo de un tamaño determinado. A diferencia fsutil, no requiere privilegios administrativos.

Estaba buscando una manera de generar archivos grandes con datos, no solo archivos dispersos. Encontré la siguiente técnica :

Si desea crear un archivo con datos reales, puede usar el siguiente script de línea de comandos.

echo "This is just a sample line appended to create a big file.. " > dummy.txt
for /L %i in (1,1,14) do type dummy.txt >> dummy.txt

(Ejecute los dos comandos anteriores uno tras otro o puede agregarlos a un archivo por lotes).

Los comandos anteriores crean un archivo dummy.txt de 1 MB en pocos segundos ...

Echa un vistazo a RDFC http://www.bertel.de/software/rdfc/index-en.html

RDFC probablemente no sea el más rápido, pero asigna bloques de datos. El más rápido tendría que usar API de nivel inferior para obtener cadenas de clúster y ponerlas en MFT sin escribir datos.

Tenga en cuenta que no hay una bala de plata aquí: si la "creación" regresa instantáneamente, eso significa que tiene un archivo disperso que simplemente falsifica un archivo grande, pero no obtendrá bloques / cadenas de datos hasta que escriba en él. Si acabas de leer, obtendrías ceros muy rápidos que podrían hacerte creer que tu disco de repente se volvió increíblemente rápido :-)

Verifique las herramientas del Kit de recursos de Windows Server 2003 . Hay una utilidad llamada Creatfil.

 CREATFIL.EXE
 -? : This message
 -FileName -- name of the new file
 -FileSize -- size of file in KBytes, default is 1024 KBytes

Es similar a mkfile en Solaris.

Necesitaba un archivo normal de 10 GB para probar, por lo que no pude usarlo fsutilporque crea archivos dispersos (gracias @ZXX).

@echo off

:: Create file with 2 bytes
echo.>file-big.txt

:: Expand to 1 KB
for /L %%i in (1, 1, 9) do type file-big.txt>>file-big.txt

:: Expand to 1 MB
for /L %%i in (1, 1, 10) do type file-big.txt>>file-big.txt

:: Expand to 1 GB
for /L %%i in (1, 1, 10) do type file-big.txt>>file-big.txt

:: Expand to 4 GB
del file-4gb.txt
for /L %%i in (1, 1, 4) do type file-big.txt>>file-4gb.txt

del file-big.txt

Quería crear un archivo de 10 GB, pero por alguna razón solo apareció como 4 GB, por lo que quería estar seguro y me detuve en 4 GB. Si realmente desea asegurarse de que su archivo será manejado adecuadamente por el sistema operativo y otras aplicaciones, deje de expandirlo a 1 GB.

Abra el Administrador de tareas de Windows, encuentre el proceso más grande que esté ejecutando, haga clic derecho y haga clic en Create dump file.

Esto creará un archivo relativo al tamaño del proceso en la memoria en su carpeta temporal.

Puede crear fácilmente un archivo de tamaño en gigabytes.

A falta de escribir una aplicación completa, los chicos de Python podemos lograr archivos de cualquier tamaño con cuatro líneas, el mismo fragmento en Windows y Linux (la os.stat()línea es solo un cheque):

>>> f = open('myfile.txt','w')
>>> f.seek(1024-1) # an example, pick any size
>>> f.write('\x00')
>>> f.close()
>>> os.stat('myfile.txt').st_size
1024L
>>>

PowerShell one-liner para crear un archivo C:\Temppara llenar el disco C: dejando solo 10 MB:

[io.file]::Create("C:\temp\bigblob.txt").SetLength((gwmi Win32_LogicalDisk -Filter "DeviceID='C:'").FreeSpace - 10MB).Close

Utilizar:

/*
Creates an empty file, which can take all of the disk
space. Just specify the desired file size on the
command line.
*/

#include <windows.h>
#include <stdlib.h>

int main (int argc, char* ARGV[])
{
    int size;
    size = atoi(ARGV[1]);
    const char* full = "fulldisk.dsk";
    HANDLE hf = CreateFile(full,
                           GENERIC_WRITE,
                           0,
                           0,
                           CREATE_ALWAYS,
                           0,
                           0);
    SetFilePointer(hf, size, 0, FILE_BEGIN);
    SetEndOfFile(hf);
    CloseHandle(hf);
    return 0;
}

Estaba buscando una forma de crear un archivo ficticio grande con asignación de espacio recientemente. Todas las soluciones se ven incómodas. Finalmente, acabo de iniciar la DISKPARTutilidad en Windows (integrada desde Windows Vista):

DISKPART
CREATE VDISK FILE="C:\test.vhd" MAXIMUM=20000 TYPE=FIXED

Donde MÁXIMO es el tamaño del archivo resultante, 20 GB aquí.

Encontré una excelente utilidad que es configurable en https://github.com/acch/genfiles .

Llena el archivo de destino con datos aleatorios, por lo que no hay problemas con los archivos dispersos, y para mis propósitos (probar algoritmos de compresión) proporciona un buen nivel de ruido blanco.

Los archivos temporales deben almacenarse en la carpeta temporal de Windows. Según la respuesta de Rod , puede usar el siguiente revestimiento para crear un archivo temporal de 5 GB que devuelve el nombre de archivo

[System.IO.Path]::GetTempFileName() | % { [System.IO.File]::Create($_).SetLength(5gb).Close;$_ } | ? { $_ }

Explicación:

• [System.IO.Path]::GetTempFileName() genera un nombre de archivo aleatorio con extensión aleatoria en la carpeta temporal de Windows
• La canalización se utiliza para pasar el nombre al [System.IO.File]::Create($_)que crea el archivo
• El nombre del archivo se establece en el archivo recién creado con .SetLength(5gb). Me sorprendió un poco descubrir que PowerShell admite la conversión de bytes , lo que es realmente útil.
• El identificador de archivo debe cerrarse .closepara permitir que otras aplicaciones accedan a él.
• Con ;$_el nombre de archivo se devuelve y | ? { $_ }se garantiza que solo se devuelva el nombre de archivo y no la cadena vacía devuelta por[System.IO.File]::Create($_)

La forma más simple que he encontrado es esta utilidad gratuita: http://www.mynikko.com/dummy/

Crea archivos ficticios de tamaño arbitrario que se llenan con espacios o con contenido no comprimible (usted elige). Aquí hay una captura de pantalla:

Plain ol 'C ... esto se construye bajo MinGW GCC en Windows XX y debería funcionar en cualquier plataforma C' genérica '.

Genera un archivo nulo de un tamaño especificado. El archivo resultante NO es solo una entrada de directorio que ocupa el espacio, y de hecho ocupa el número especificado de bytes. Esto es rápido porque no se producen escrituras reales, excepto el byte escrito antes del cierre.

Mi instancia produce un archivo lleno de ceros; esto puede variar según la plataforma; este programa esencialmente configura la estructura de directorios para cualquier dato que esté rondando.

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

FILE *file;

int main(int argc, char **argv)
{
    unsigned long  size;

    if(argc!=3)
    {
        printf("Error ... syntax: Fillerfile  size  Fname \n\n");
        exit(1);
    }

    size = atoi(&*argv[1]);

    printf("Creating %d byte file '%s'...\n", size, &*argv[2]);

    if(!(file = fopen(&*argv[2], "w+")))
    {
        printf("Error opening file %s!\n\n", &*argv[2]);
        exit(1);
    }

    fseek(file, size-1, SEEK_SET);
    fprintf(file, "%c", 0x00);
    fclose(file);
}

Encontré una solución usando DEBUG en http://www.scribd.com/doc/445750/Create-a-Huge-File , pero no conozco una manera fácil de escribirlo y parece que no puede para crear archivos de más de 1 GB.

... 1 MB de archivo dummy.txt en pocos segundos.

echo "This is just a sample line appended to create a big file.. " > dummy.txt for /L %i in (1,1,14) do type dummy.txt >> dummy.txt

Ver aquí: http://www.windows-commandline.com/how-to-create-large-dummy-file/

Puede usar el comando cat powershell.

Primero cree un archivo de texto simple con algunos caracteres. Cuantos más caracteres iniciales ingreses, más rápido se hará más grande. Vamos a llamarlo.txt. Luego en Powershell:

cat out.txt >> out.txt

Espere el tiempo que sea necesario para hacer el archivo lo suficientemente grande. Luego presione ctrl-c para finalizarlo.

Puedes probar este código C ++:

#include<stdlib.h>
#include<iostream>
#include<conio.h>
#include<fstream>
#using namespace std;

int main()
{
    int a;
    ofstream fcout ("big_file.txt");
    for(;;a += 1999999999){
        do{
            fcout << a;
        }
        while(!a);
    }
}

Tal vez tomará algún tiempo generarlo dependiendo de la velocidad de su CPU ...

Respuesta simple en Python: si necesita crear un archivo de texto real grande, simplemente utilicé un whilebucle simple y pude crear un archivo de 5 GB en aproximadamente 20 segundos. Sé que es crudo, pero es lo suficientemente rápido.

outfile = open("outfile.log", "a+")

def write(outfile):
    outfile.write("hello world hello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello worldhello world"+"\n")
    return

i=0
while i < 1000000:
    write(outfile)
    i += 1
outfile.close()

¿Rápido de ejecutar o rápido de escribir en un teclado? Si usa Python en Windows, puede intentar esto:

cmd /k py -3 -c "with open(r'C:\Users\LRiffel\BigFile.bin', 'wb') as file: file.truncate(5 * 1 << 30)"

Otra solución GUI: WinHex.

“File” > “New” > “Desired file size” = [X]
“File” > “Save as” = [Name]

Al contrario de algunas de las soluciones ya propuestas, en realidad escribe los datos (vacíos) en el dispositivo.

También permite llenar el nuevo archivo con un patrón seleccionable o datos aleatorios:

“Edit” > “Fill file” (or “Fill block” if a block is selected)

He hecho algunas adiciones al mismo fsutilmétodo que se menciona en la respuesta elegida. Esto es para crear archivos de muchas extensiones diferentes y / o de varios tamaños.

set file_list=avi bmp doc docm docx eps gif jpeg jpg key m4v mov mp4 mpg msg nsf odt pdf png pps ppsx ppt pptx rar rtf tif tiff txt wmv xls xlsb xlsm xlsx xps zip 7z
set file_size= 1
for %%f in (%file_list%) do (
fsutil file createnew valid_%%f.%%f %file_size%
) > xxlogs.txt

El código se puede clonar desde https://github.com/iamakidilam/bulkFileCreater.git