Créez rapidement un fichier volumineux sur un système Windows

Dans la même veine que Créer rapidement un gros fichier sur un système Linux , je voudrais créer rapidement un gros fichier sur un système Windows. En gros, je pense à 5 Go. Le contenu n'a pas d'importance. Une commande intégrée ou un fichier batch court serait préférable, mais j'accepterai une application s'il n'y a pas d'autres moyens faciles.

fsutil file createnew <filename> <length>

où <length>est en octets.

fsutil nécessite cependant des privilèges administratifs.

Vous pouvez utiliser l' outil Sysinternals Contig . Il a un -ncommutateur qui crée un nouveau fichier d'une taille donnée. Contrairement à fsutilcela, il ne nécessite pas de privilèges administratifs.

Je cherchais un moyen de générer de gros fichiers avec des données, pas seulement des fichiers clairsemés. Je suis tombé sur la technique ci-dessous :

Si vous souhaitez créer un fichier avec des données réelles, vous pouvez utiliser le script de ligne de commande ci-dessous.

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

(Exécutez les deux commandes ci-dessus l'une après l'autre ou vous pouvez les ajouter à un fichier de commandes.)

Les commandes ci-dessus créent un fichier dummy.txt de 1 Mo en quelques secondes ...

Consultez RDFC http://www.bertel.de/software/rdfc/index-en.html

RDFC n'est probablement pas le plus rapide, mais il alloue des blocs de données. Le plus rapide devrait utiliser une API de niveau inférieur pour obtenir simplement des chaînes de cluster et les mettre dans MFT sans écrire de données.

Attention, il n'y a pas de solution miracle ici - si la "création" revient instantanément, cela signifie que vous avez un fichier clairsemé qui ne fait que truquer un gros fichier, mais vous n'obtiendrez pas de blocs / chaînes de données jusqu'à ce que vous y écriviez. Si vous venez de lire, vous obtiendrez des zéros très rapides, ce qui pourrait vous faire croire que votre lecteur est soudainement devenu extrêmement rapide :-)

Vérifiez les outils du Kit de ressources Windows Server 2003 . Il existe un utilitaire appelé Creatfil.

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

Il est similaire à mkfile sur Solaris.

J'avais besoin d'un fichier régulier de 10 Go pour les tests, donc je ne pouvais pas l'utiliser fsutilcar il crée des fichiers clairsemés (merci @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

Je voulais créer un fichier de 10 Go, mais pour une raison quelconque, il n'apparaissait que comme 4 Go, donc je voulais être en sécurité et arrêté à 4 Go. Si vous voulez vraiment être sûr que votre fichier sera géré correctement par le système d'exploitation et d'autres applications, arrêtez de l'étendre à 1 Go.

Ouvrez le Gestionnaire des tâches de Windows, trouvez le plus gros processus que vous avez exécuté, cliquez avec le bouton droit et cliquez sur Create dump file.

Cela créera un fichier relatif à la taille du processus en mémoire dans votre dossier temporaire.

Vous pouvez facilement créer un fichier de taille en gigaoctets.

À moins d'écrire une application complète, nous, les gars de Python, pouvons obtenir des fichiers de n'importe quelle taille avec quatre lignes, le même extrait sur Windows et Linux (la os.stat()ligne n'est qu'un contrôle):

>>> 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 pour créer un fichier C:\Temppour remplir le disque C: ne laissant que 10 Mo:

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

Utilisation:

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

Je cherchais un moyen de créer un grand fichier factice avec une allocation d'espace récemment. Toutes les solutions semblent maladroites. Enfin, je viens de démarrer l' DISKPARTutilitaire sous Windows (intégré depuis Windows Vista):

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

Où MAXIMUM est la taille du fichier résultant, 20 Go ici.

J'ai trouvé un excellent utilitaire configurable sur https://github.com/acch/genfiles .

Il remplit le fichier cible avec des données aléatoires, il n'y a donc aucun problème avec les fichiers clairsemés et pour mes besoins (test des algorithmes de compression), il donne un bon niveau de bruit blanc.

Les fichiers temporaires doivent être stockés dans le dossier temporaire Windows. Sur la base de la réponse de Rod, vous pouvez utiliser la doublure suivante pour créer un fichier temporaire de 5 Go qui renvoie le nom de fichier

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

Explication:

• [System.IO.Path]::GetTempFileName() génère un nom de fichier aléatoire avec une extension aléatoire dans le dossier temporaire de Windows
• Le Pipeline est utilisé pour transmettre le nom [System.IO.File]::Create($_)auquel crée le fichier
• Le nom de fichier est défini sur le fichier nouvellement créé avec .SetLength(5gb). J'ai été un peu surpris de découvrir que PowerShell prend en charge la conversion d'octets , ce qui est vraiment utile.
• Le descripteur de fichier doit être fermé avec .closepour permettre à d'autres applications d'y accéder
• Avec ;$_le nom de fichier est retourné et avec | ? { $_ }il est garanti que seul le nom de fichier est retourné et non la chaîne vide retournée par[System.IO.File]::Create($_)

Le moyen le plus simple que j'ai trouvé est cet utilitaire gratuit: http://www.mynikko.com/dummy/

Crée des fichiers factices de taille arbitraire qui sont remplis d'espaces ou remplis de contenu non compressible (votre choix). Voici une capture d'écran:

Plain ol 'C ... cela se construit sous MinGW GCC sur Windows XX et devrait fonctionner sur n'importe quelle plate-forme C "générique".

Il génère un fichier nul d'une taille spécifiée. Le fichier résultant n'est PAS seulement une entrée occupant l'espace du répertoire, et occupe en fait le nombre spécifié d'octets. Ceci est rapide car aucune écriture réelle ne se produit, à l'exception de l'octet écrit avant la fermeture.

Mon instance produit un fichier plein de zéros - cela peut varier selon la plateforme; ce programme configure essentiellement la structure de répertoires pour toutes les données qui traînent.

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

J'ai trouvé une solution en utilisant DEBUG sur http://www.scribd.com/doc/445750/Create-a-Huge-File , mais je ne connais pas de moyen facile de l'écrire et il ne semble pas pouvoir pour créer des fichiers de plus de 1 Go.

... 1 Mo de fichier dummy.txt en quelques secondes.

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

Voir ici: http://www.windows-commandline.com/how-to-create-large-dummy-file/

Vous pouvez utiliser la commande cat powershell.

Créez d'abord un fichier texte simple avec quelques caractères. Plus vous saisissez de caractères initiaux, plus il s'agrandit rapidement. Appelons-le out.txt. Puis à Powershell:

cat out.txt >> out.txt

Attendez aussi longtemps que nécessaire pour rendre le fichier suffisamment volumineux. Appuyez ensuite sur ctrl-c pour y mettre fin.

Vous pouvez essayer ce code 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);
    }
}

Il faudra peut-être un certain temps pour générer en fonction de la vitesse de votre CPU ...

Réponse simple en Python: Si vous avez besoin de créer un gros fichier texte réel, je viens d'utiliser une whileboucle simple et j'ai pu créer un fichier de 5 Go en environ 20 secondes. Je sais que c'est brut, mais c'est assez rapide.

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()

Rapide à exécuter ou rapide à taper sur un clavier? Si vous utilisez Python sous Windows, vous pouvez essayer ceci:

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

Une autre solution graphique: WinHex.

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

Contrairement à certaines des solutions déjà proposées, il écrit en fait les données (vides) sur l'appareil.

Il permet également de remplir le nouveau fichier avec un motif sélectionnable ou des données aléatoires:

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

J'ai fait quelques ajouts à la même fsutilméthode que celle mentionnée dans la réponse choisie. Il s'agit de créer des fichiers de nombreuses extensions différentes et / ou de différentes tailles.

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

Le code peut être cloné depuis https://github.com/iamakidilam/bulkFileCreater.git