pourquoi fsutil.exe prend moins de temps pour écrire un énorme fichier dans le disque que programme?

Question

cette question est selon ce sujet: créer un énorme fichier fictif dans une affaire de secondes dans c #

Je viens de vérifier le fsutil.exe dans xp / vista / seven à écrire une énorme quantité de données fictives dans le disque de stockage et il faut moins de temps pour écrire un tel fichier par rapport à programmaticly manière.

Quand je suis en train de faire la même chose avec l'aide de .net cela prendra beaucoup plus de temps que fsutil.exe.

Note: Je sais que .net ne pas utiliser du code natif en raison de ce que je viens de vérifier cette question avec api natif aussi comme suit:

long int size = DiskFree('L' - 64);
const char* full = "fulldisk.dsk";
__try{
Application->ProcessMessages();
HANDLE hf = CreateFile(full,
                       GENERIC_WRITE,
                       0,
                       0,
                       CREATE_ALWAYS,
                       0,
                       0);
SetFilePointer(hf, size, 0, FILE_BEGIN);
SetEndOfFile(hf);
CloseHandle(hf);
}__finally{
    ShowMessage("Finished");
    exit(0);

et la réponse était aussi égale que les résultats .net.

mais avec l'aide de fsutil.exe il ne faut moins que la durée au-dessus ou approches .net dire qu'il est 2 fois plus rapide

exemple

: pour écrire 400MB avec .net, il prendra 40 secondes ~ le même montant avec fsutil.exe prendra environ 20secs ou moins.

est-il une explication à ce sujet? ou dont la fonction fsutil.exe utilise-t qui a cette vitesse d'importance pour écrire?

Answer 1

Je ne sais pas exactement ce que fsutil est en train de faire, mais je ne sais de deux façons d'écrire un fichier volumineux qui sont plus rapides que ce que vous avez fait ci-dessus (ou en cherchant à la longueur que vous voulez et l'écriture d'un zéro, ce qui a le même résultat).

Le problème avec ces approches est qu'elles zéro remplir le fichier au moment où vous faites l'écriture.

Vous pouvez éviter le remplissage de zéros soit:

1. Création d'un fichier clairsemé. La taille est marquée où vous le souhaitez, mais les données n'existe pas réellement sur le disque jusqu'à ce que vous écrivez. Toutes les lectures des zones non écrites renverra des zéros.
2. Utilisation de la fonction SetFileValidData définir la longueur de données valides sans réduction à zéro d'abord le fichier. Cependant, en raison de problèmes de sécurité potentiels, cette commande nécessite des autorisations élevées.

Answer 2

Je suis d'accord avec le dernier commentaire. Je faisais des expériences avec un chauffeur de minifiltres et a été la capture IRP_MJ_WRITE en rappel IRPs. Lorsque je crée ou écrire dans le fichier de la ligne cmd ou une application win32, je peux voir descendre écrit. Mais quand je créé un fichier en utilisant la commande « fsutil file createnew ... », je ne vois aucun écrit. Je vois ce comportement sur win2k8 volume NTFS sur r2. Et je ne pense pas (pas sûr à 100% si) est un fichier clairsemé soit. Il est sans doute les propriétés couchait de taille dans MFT sans allouer de cluster. fsutil faire vérifier l'espace libre disponible, donc si la taille du fichier est plus grand que l'espace libre sur le disque, vous obtenez une erreur 1.

J'ai aussi couru les FSCTL_GET_RETRIEVAL_POINTERS du programme au dossier et je suis une mesure pour l'ensemble de la taille du fichier. Mais je crois qu'il obtient toutes les données

Answer 3

Ceci est quelque chose qui pourrait être

• Ecrit en Assembleur (vitesse aveuglante Raw)
• Natif C / C ++ code pour le faire
• Peut-être un appel système non documenté faire ceci ou un truc non documenté nulle part.

Les trois points ci-dessus pourraient avoir un énorme facteur important - quand on y pense, quand un code .NET est chargé, il se jit'ted par le moteur d'exécution (Ok, le facteur temps ne serait pas visible si vous avez un flamboyante machine rapide -. sur un pentium final humble, il serait chargement notable, lent)

Plus que probablement, il aurait pu être écrite en C / C ++. Il peut vous surprendre si elle a été écrit en Assembleur.

Vous pouvez vérifier par vous-même - regardez la taille du fichier de l'exécutable et le comparer à l'exécutable d'un .NET. Vous pourriez dire que le fichier est compressé, ce dont je doute qu'il serait donc enclin à exclure cette, Microsoft ne serait pas aller jusque-là, je pense à l'entreprise de compression executables.

Espérons que cela répond à votre question, Meilleures salutations, Tom.

Answer 4

fsutil est seulement rapide sur NTFS et exFAT, pas FAT32, FAT16 En effet, un système de fichiers ont un concespt et soutenir ainsi l'initialisation rapide des fichiers « taille initialisées ». Cette réserve seulement les groupes mais ne les pas à zéro, car il note dans le système de fichiers qu'aucune donnée n'a été écrite dans le fichier et valide lit retournera tous les 00 tampons remplis.