Quel est le moyen le plus rapide pour vérifier si les fichiers sont identiques?
Si vous avez 1,000,0000 fichiers source, vous pensez qu'ils sont tous les mêmes, et que vous voulez comparer, ce qui est le courant à jeun méthode pour comparer ces fichiers? Supposons qu'ils sont les fichiers Java et de la plateforme où la comparaison est faite n'est pas important. cksum est de me faire pleurer. Quand je veux dire identiques je veux dire, TOUTES identiques.
Mise à jour: - je savoir sur la génération de sommes de contrôle. diff est risible ... je veux de la vitesse.
Mise à jour: Ne restez pas coincé sur le fait qu'ils sont des fichiers source. Prétendre par exemple que vous avez pris un million de pistes d'un programme avec de très réglementé de sortie. Vous voulez prouver à tous les 1 000 000 de versions de la sortie sont les mêmes.
Mise à jour: lire le nombre de blocs plutôt qu'en octets? Immédiatement jeter ceux-là? Est que plus rapide que de trouver le nombre d'octets?
Mise à jour: Est-ce si différent de la façon la plus rapide pour comparer deux fichiers?
- diff est risible seulement parce que c'est le mauvais outil, il vous donne calculé les différences. Si vous voulez simplement savoir si les deux fichiers sont identiques, l'utilisation du cpm.
- 1,000,0000 fichiers source, comparer, j'ai juste ne suis pas en mesure de visualiser l'endroit où 1 Million de fichiers source sont utilisés.
- Vous dire que ce sont les fichiers Java. Avez-vous besoin d'un outil qui peut aussi ignorer les espaces et les différences de mise en forme?
- Disons que vous exécutez un programme d'un million de fois... absolue de la même ness est nécessaire... Vous voulez comparer des millions de produits différents...
- Utiliser des threads... zoundsss d'entre eux.
Vous devez vous connecter pour publier un commentaire.
Je préfère quelque chose comme l'approche adoptée par le
cmpprogramme: ouvrir deux fichiers (dire le fichier 1 et le fichier 2), lire un bloc de chacune, et de les comparer, octet par octet. Si elles correspondent, de lire le prochain bloc de chacun, de les comparer octet-par-octet, etc. Si vous arrivez à la fin de ces deux fichiers sans détecter d'éventuelles différences, de retourner au début du fichier 1, fermer le fichier 2 et ouvrir le fichier 3 à sa place, et répétez jusqu'à ce que vous avez vérifié tous les fichiers. Je ne pense pas qu'il existe un moyen d'éviter de lire tous les octets de tous les fichiers s'ils sont tous identiques, mais je pense que cette approche est (ou proche de) la façon la plus rapide de détecter toute différence qui pourrait exister.Modification de l'OP: Levé important commentaire de Marque Bessey
"une autre optimisation évidente si les fichiers sont censés être la plupart du temps identiques, et s'ils sont relativement petits, est de garder l'un des fichiers entièrement en mémoire. Qui coupe bas sur l'écroulement d'essayer de lire les deux fichiers à la fois."
La plupart des gens dans leurs réponses sont en ignorant le fait que les fichiers doivent être comparés à plusieurs reprises. Ainsi, les sommes de contrôle sont plus rapides que la somme de contrôle est calculée une fois et stockées dans la mémoire (au lieu de lire les fichiers de manière séquentielle n fois).
En supposant que l'espoir est que les fichiers sont les mêmes (ce que le scénario), puis traiter avec les sommes de contrôle/hachages est une perte de temps - il est probable qu'ils vont être la même et que vous auriez à re-lire les fichiers pour obtenir la preuve finale (je suis aussi en supposant que, puisque vous voulez pour "prouver ... ce sont les mêmes", ont eux hachage à la même valeur n'est pas assez bon).
Si c'est le cas, je pense que la solution proposée par David est assez proche de ce que vous devez faire. Un couple de choses qui peut être fait pour optimiser la comparaison, une augmentation du niveau de complexité:
Mise à jour: Ne restez pas coincé sur le fait qu'ils sont des fichiers source. Prétendre par exemple que vous avez pris un million de pistes d'un programme avec de très réglementé de sortie. Vous voulez prouver à tous les 1 000 000 de versions de la sortie sont les mêmes.
si vous avez le contrôle sur la sortie du programme de création des fichiers de sortie /créer un md5 sur la volée et de les intégrer dans le fichier ou d'un flux de sortie ou même de rediriger la sortie à travers un programme qui crée le md5 sur le chemin et magasins le long de côté les données d'une certaine manière, le point est de faire les calculs lorsque les octets sont déjà en mémoire.
si vous ne pouvez pas y arriver alors, comme d'autres l'ont dit, de vérifier les tailles de fichier puis faire un tout droit octet par octet de comparaison sur la même taille de fichiers, je ne vois pas comment n'importe quelle sorte de division binaire ou md5 calcul est mieux qu'une comparaison directe, vous devrez toucher chaque octet de prouver l'égalité de la manière que vous le couper de sorte que vous pourriez ainsi réduire la quantité de calcul nécessaire par octet et d'acquérir la capacité de couper dès que vous trouvez une erreur.
le md5 de calcul serait utile si vous prévoyez de les comparer plus tard pour de nouvelles sorties, mais votre fondamentalement revenir à mon premier point de calcul du md5 dès que possible
Il y a un certain nombre de programmes qui permettent de comparer un ensemble de fichiers, en général, de trouver des images identiques. FDUPES est bonne: Lien. Un million de fichiers shoudln pas être un problème, en fonction de la nature exacte de l'entrée. Je pense que FDUPES nécessite Linux, mais il existe d'autres programmes de ce type pour d'autres plates-formes.
J'ai essayé d'écrire un programme plus rapide de moi-même, mais à l'exception de cas particuliers, FDUPES a été plus rapide.
De toute façon, l'idée générale est de commencer par vérifier la taille des fichiers. Les fichiers qui ont des tailles différentes ne peuvent pas être égaux, de sorte que vous avez seulement besoin de considérer les groupes de fichiers avec la même taille. Ensuite, il devient plus compliqué si vous souhaitez obtenir des performances optimales: Si les fichiers sont susceptibles d'être différents, nous vous conseillons de comparer les petites pièces des dossiers, dans l'espoir de trouver des différences dès le début afin que vous n'avez pas à lire le reste d'entre eux. Si les fichiers sont susceptibles d'être identiques, même si, il peut être plus rapide à lire par le biais de chaque fichier pour calculer une somme de contrôle, parce que vous pouvez lire dans l'ordre à partir du disque, au lieu de sauter en arrière et vient entre deux ou plusieurs fichiers. (Cela suppose que les disques normaux, alors SSD:s peut être différent.)
Dans mes repères lorsque l'on essaie de faire un programme plus rapide c' (un peu à ma grande surprise) s'est avéré pour être plus rapide à lire d'abord par le biais de chaque fichier pour calculer une somme de contrôle, et puis si les sommes sont égales, comparer les fichiers directement par la lecture d'un des blocs alternativement de chaque fichier, plutôt que de lire des blocs en alternance, sans les précédents calculs de somme de contrôle! Il s'est avéré que lors du calcul des sommes de contrôle, de Linux à la fois les fichiers mis en cache dans la mémoire principale, la lecture de chaque fichier séquentiellement, et la deuxième lectures étaient alors très rapide. Lors du démarrage d'une alternance de lit, les fichiers ne sont pas (physiquement) lire dans l'ordre.
EDIT:
Certaines personnes ont exprimé leur surprise de fin de doute même qu'il pourrait être plus rapide pour lire les fichiers deux fois plus que la lecture seule fois. Peut-être que je n'ai pas réussi à expliquer très clairement ce que je faisais. Je parle de cache de pré-chargement, afin d'avoir les fichiers dans le cache du disque lorsque, plus tard, d'accéder de manière à être lent à faire sur le lecteur de disque physique. Ici est une page web où j'ai essayé d'expliquer plus en détail, avec des images, du code C et des mesures.
Cependant, ce qui a (au mieux) marginal de la pertinence de la question d'origine.
Bien la plus optimale de l'algorithme dépend du nombre de fichiers en double.
En supposant que quelques-uns sont les mêmes, mais la plupart sont différents et que les fichiers sont gros.
Filtre à ceux qui ne sont évidemment pas les mêmes à l'aide d'un simple fichier de contrôle de la longueur.
Choisir octets aléatoires à partir du fichier, de calculer une valeur de hachage et de les comparer (disque en minimisant les cherche)
Qui suivent avec plein de fichier SHA1.
D'abord comparer le fichier des longueurs de tous les millions de dollars. Si vous avez un moyen pas cher pour ce faire, commencer par le plus grand des fichiers. Si ils passent tous que puis comparer chaque fichier à l'aide d'une division binaire de modèle; ceci ne fonctionnera pas plus rapide sur les fichiers qui sont similaires mais pas identiques. Pour plus d'informations sur cette méthode de comparaison voir Knuth-Morris-Pratt méthode.
À l'aide de
cksumn'est pas aussi fiable que d'utiliser quelque chose commemd5sum. Mais j'opterais pour un maximum de fiabilité, ce qui signifie un octet-par-octet de comparaison en utilisant lescmp.Vous devez lire chaque octet dans les deux fichiers pour toutes les méthodes de vérification de sorte que vous pourriez aussi opter pour celui qui est le plus fiable.
Comme une première passe, vous pouvez vérifier l'inscription à l'annuaire pour voir si les tailles sont différentes. C'est un moyen rapide d'obtenir plus rapidement des commentaires pour les différents fichiers.
Je ne pense pas que le hachage va être plus rapide que l'octet par octet des comparaisons. La comparaison octet par octet peut être optimisé un peu en canalisant la lecture et la comparaison des octets, également plusieurs sections du fichier pourrait être comparé à fils parallèles. Il serait quelque chose comme ceci:
Ou tout simplement courir un cmp (ou l'équivalent pour votre système d'exploitation) en parallèle. Cela pourrait être scripté facilement et vous obtenez toujours l'avantage de parallélisme.
Usage de la notion de Filtre de Bloom.
Une simple explication ici: http://crzyjcky.com/2013/01/03/the-magical-bloom-filter/
Il vous donne la constante de temps de comparer. Cependant, cette méthode ne peut pas être utilisé seul.
Apache Cassandra et HBase sont l'utilisation de cette technique à l'interne.
Il raconte essentiellement u les fichiers ne sont pas identiques dans moyen très rapide. Si il dit que le fichier sont identiques, que vous avez à faire un autre tour de la vérification à l'aide de méthode fiable.
Je voudrais exécuter quelque chose comme ceci
ensuite voir quels fichiers ont différentes sommes de contrôle MD5. Cela permettra de regrouper les fichiers par la somme de contrôle.
Vous pouvez remplacer md5sum qui sha1sum ou même rmd160 si vous le souhaitez.
Pourquoi réinventer la roue? Comment sur une application tierce? Accordée il n'a pas d'Api mais je ne peux pas imaginer que vous mettez votre auto dans cette situation souvent. J'aime cette application doublekiller il suffit de faire une sauvegarde avant de commencer. 🙂 C'est rapide et gratuit!
au-delà de comparer, synchroniser deux dossiers, super rapide! nous l'utilisons tout le temps, tous les jours.
Je viens d'écrire une application en c# qui fait quelque chose de similaire à ce que vous voulez. Ce que mon code n'est présent.
Lire toutes les tailles de chaque fichier dans une liste ou d'une matrice.
Utiliser une boucle for pour vérifier si l'une de ces tailles sont les mêmes.
si ils sont de la même taille, comparer un octet d'un fichier à un octet de l'autre fichier. Si les deux octets sont les mêmes, se déplacer sur l'octet suivant. Si un écart est constaté, le retour que les fichiers sont différents.
Si la fin de ces deux fichiers est atteint, et les deux derniers octets sont les mêmes, les fichiers doivent être identiques.
J'ai expérimenté avec la comparaison des hachages MD5 de fichiers, plutôt que de passer par octet, et j'ai trouvé que les fichiers identiques sont souvent manquées avec cette méthode, cependant, il est nettement plus rapide.
À mon avis, c'est un fichier de système d'exploitation. Alors d'abord, choisissez votre système de fichiers avec soin. Ensuite, dédoublonner. Puis comparer les inodes. Comme:
Si vous voulez comparer des fichiers, un par un, utilisez ExamDiff.
Hachage MD5 serait plus rapide que la comparaison, mais elle est plus lente que la normale CRC-case. Vous devez comprendre le type de la fiabilité que vous voulez dans la comparaison.