Quel est le moyen le plus rapide de créer une somme de contrôle pour les fichiers volumineux en C #

Je dois synchroniser de gros fichiers sur certaines machines. Les fichiers peuvent atteindre jusqu'à 6 Go. La synchronisation sera effectuée manuellement toutes les quelques semaines. Je ne peux pas prendre le nom de fichier en considération car ils peuvent changer à tout moment.

Mon plan est de créer des sommes de contrôle sur le PC de destination et sur le PC source, puis de copier tous les fichiers avec une somme de contrôle, qui ne sont pas déjà dans la destination, vers la destination. Ma première tentative était quelque chose comme ceci:

using System.IO;
using System.Security.Cryptography;

private static string GetChecksum(string file)
{
    using (FileStream stream = File.OpenRead(file))
    {
        SHA256Managed sha = new SHA256Managed();
        byte[] checksum = sha.ComputeHash(stream);
        return BitConverter.ToString(checksum).Replace("-", String.Empty);
    }
}

Le problème était l'exécution:
- avec SHA256 avec un fichier de 1,6 Go -> 20 minutes
- avec MD5 avec un fichier de 1,6 Go -> 6,15 minutes

Existe-t-il un meilleur moyen - plus rapide - d'obtenir la somme de contrôle (peut-être avec une meilleure fonction de hachage)?

Le problème ici est que SHA256Managedlit 4096 octets à la fois (hériter de FileStreamet remplacerRead(byte[], int, int) pour voir combien il lit dans le flux de fichiers), ce qui est un tampon trop petit pour les E / S de disque.

Pour accélérer les choses (2 minutes pour hachant fichier 2 Gb sur ma machine avec SHA256, 1 minute pour MD5) wrap FileStreamdans BufferedStreamet définir la taille de la mémoire tampon de taille raisonnable (j'ai essayé avec un tampon ~ 1 Mb):

// Not sure if BufferedStream should be wrapped in using block
using(var stream = new BufferedStream(File.OpenRead(filePath), 1200000))
{
    // The rest remains the same
}

Ne faites pas la somme de contrôle du fichier entier, créez des sommes de contrôle tous les 100 Mo environ, de sorte que chaque fichier possède une collection de sommes de contrôle.

Ensuite, lorsque vous comparez les sommes de contrôle, vous pouvez arrêter de comparer après la première somme de contrôle différente, sortir tôt et vous éviter de traiter l'ensemble du fichier.

Cela prendra encore tout le temps pour des fichiers identiques.

Comme l'a noté Anton Gogolev , FileStream lit 4096 octets à la fois par défaut, mais vous pouvez spécifier toute autre valeur à l'aide du constructeur FileStream:

new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 16 * 1024 * 1024)

Notez que Brad Abrams de Microsoft a écrit en 2004:

il n'y a aucun avantage à envelopper un BufferedStream autour d'un FileStream. Nous avons copié la logique de mise en mémoire tampon de BufferedStream dans FileStream il y a environ 4 ans pour encourager de meilleures performances par défaut

la source

Appelez le port Windows de md5sum.exe . C'est environ deux fois plus rapide que l'implémentation .NET (au moins sur ma machine en utilisant un fichier de 1,2 Go)

public static string Md5SumByProcess(string file) {
    var p = new Process ();
    p.StartInfo.FileName = "md5sum.exe";
    p.StartInfo.Arguments = file;            
    p.StartInfo.UseShellExecute = false;
    p.StartInfo.RedirectStandardOutput = true;
    p.Start();
    p.WaitForExit();           
    string output = p.StandardOutput.ReadToEnd();
    return output.Split(' ')[0].Substring(1).ToUpper ();
}

Ok - merci à vous tous - laissez-moi conclure ceci:

1. l'utilisation d'un exe "natif" pour faire le hachage a pris du temps de 6 minutes à 10 secondes, ce qui est énorme.
2. L'augmentation de la mémoire tampon était encore plus rapide - un fichier de 1,6 Go a pris 5,2 secondes en utilisant MD5 dans .Net, donc j'irai avec cette solution - merci encore

J'ai fait des tests avec la taille du tampon, en exécutant ce code

using (var stream = new BufferedStream(File.OpenRead(file), bufferSize))
{
    SHA256Managed sha = new SHA256Managed();
    byte[] checksum = sha.ComputeHash(stream);
    return BitConverter.ToString(checksum).Replace("-", String.Empty).ToLower();
}

Et j'ai testé avec un fichier de 29½ Go, les résultats étaient

• 10 000: 369,24s
• 100 000: 362,55s
• 1.000.000: 361,53s
• 10.000.000: 434,15s
• 100.000.000: 435,15s
• 1.000.000.000: 434,31s
• Et 376,22s lors de l'utilisation du code original, sans tampon.

J'utilise un processeur i5 2500K, 12 Go de RAM et un disque SSD OCZ Vertex 4 256 Go.

Alors j'ai pensé, qu'en est-il d'un disque dur standard de 2 To. Et les résultats étaient comme ça

• 10.000: 368,52s
• 100 000: 364,15s
• 1.000.000: 363,06s
• 10.000.000: 678,96s
• 100.000.000: 617,89s
• 1.000.000.000: 626,86s
• Et pour aucun tamponné 368,24

Je recommanderais donc soit pas de tampon, soit un tampon de max 1 mill.

Vous faites quelque chose de mal (probablement trop petit tampon de lecture). Sur une machine d'un âge indécent (Athlon 2x1800MP de 2002) qui a DMA sur le disque probablement hors de contrôle (6,6M / s est sacrément lent lors de lectures séquentielles):

Créez un fichier 1G avec des données "aléatoires":

# dd if=/dev/sdb of=temp.dat bs=1M count=1024    
1073741824 bytes (1.1 GB) copied, 161.698 s, 6.6 MB/s

# time sha1sum -b temp.dat
abb88a0081f5db999d0701de2117d2cb21d192a2 *temp.dat

1m5.299s

# time md5sum -b temp.dat
9995e1c1a704f9c1eb6ca11e7ecb7276 *temp.dat

1m58.832s

C'est aussi bizarre, md5 est toujours plus lent que sha1 pour moi (relance plusieurs fois).

Je sais que je suis en retard pour faire la fête mais que j'ai effectué des tests avant de mettre en œuvre la solution.

J'ai effectué des tests contre la classe MD5 intégrée et aussi md5sum.exe . Dans mon cas, la classe intégrée a pris 13 secondes où md5sum.exe environ 16-18 secondes à chaque exécution.

    DateTime current = DateTime.Now;
    string file = @"C:\text.iso";//It's 2.5 Gb file
    string output;
    using (var md5 = MD5.Create())
    {
        using (var stream = File.OpenRead(file))
        {
            byte[] checksum = md5.ComputeHash(stream);
            output = BitConverter.ToString(checksum).Replace("-", String.Empty).ToLower();
            Console.WriteLine("Total seconds : " + (DateTime.Now - current).TotalSeconds.ToString() + " " + output);
        }
    }

Vous pouvez jeter un œil à XxHash.Net ( https://github.com/wilhelmliao/xxHash.NET )
L'algorithme xxHash semble être plus rapide que tous les autres.
Quelques benchmarks sur le site xxHash: https://github.com/Cyan4973/xxHash

PS: je ne l'ai pas encore utilisé.