2010-10-29 6 views
7

Disons que je crée un référentiel, ajouter x fichiers et commettent. Dites la taille est un Mb après la validation initiale.Comment un dépôt Mercurial se développe-t-il avec le temps?

  • Y a-t-il un moyen d'estimer la taille du dépôt dans une année?

  • Si les lignes de code a augmenté de 10%, sera le dépôt ont augmenté en conséquence?

  • Comment nombre de commits, des branches, des étiquettes etc. facteur dans la taille du référentiel?

  • Will 10000 engage la même année faire croître le dépôt (nettement) plus dire 1000 commits?

  • Peut-être que ma question est mal phrasé?

+0

Cela devrait vraiment être deux questions - l'une sur git et l'autre sur mercurial. Bien sûr, ils sont tous deux DVCS, mais ils ne sont pas les mêmes. Ils n'ont pas les mêmes internes, et ils ne vont pas se comporter de manière complètement identique. – Cascabel

+1

@Jefromi: Ils utilisent tous deux la deltaification, ils stockent tous deux des versions complètes tous les N deltas, ils compressent les deltas et les versions complètes. –

+1

@Jakub: assez bien. Je n'étais pas totalement confiant à propos de mercurial, je savais juste que c'était similaire. Bien sûr, étant donné que la question a été posée, le PO ne la connaissait presque certainement pas. (Et même si la réponse est la même pour les deux, un instinct à moi les veut toujours en tant que questions séparées, semble plus propre, d'autant plus qu'il y a des réponses séparées sur git et mercurial.) Qui accepter?) – Cascabel

Répondre

5

Les modifications apportées à un dépôt Mercurial sont stockés sous forme soit d'un dossier complet ou un delta comprimé contre la version précédente:

https://www.mercurial-scm.org/wiki/FAQ#FAQ.2BAC8-TechnicalDetails.How_does_Mercurial_store_its_data.3F

Mercurial prend la décision sur l'opportunité de stocker un dossier complet par rapport à un delta basé sur le montant des modifications apportées.

Cela signifie qu'il est non seulement l'ajout de lignes de code qui augmentera la taille totale d'un dépôt, mais aussi:

  1. Le nombre de modifications apportées au code existant.
  2. Le nombre de modifications apportées à chaque fichier par validation.
  3. Le nombre de fichiers ajoutés et supprimés par la suite.

Mercurial conserve tous les fichiers supprimés. Vous pouvez ajouter un fichier de 1 Go à votre dépôt, puis le supprimer; le nombre de lignes n'a pas augmenté, mais parce que le fichier reste dans le référentiel, le dépôt sera considérablement plus grand.

Pour répondre à vos questions, à son tour:

  • J'imagine qu'il est possible d'estimer à peu près la taille d'un dépôt après x mois, en supposant que vous maintenir un taux constant de changement du référentiel au total (c.-à- vous ajoutez/supprimez/modifiez les fichiers au même rythme, en changeant à peu près le même nombre de lignes par commit). L'augmentation de 10% du nombre de lignes de code ne nous dit pas combien de lignes ont été supprimées/modifiées, donc une augmentation des lignes de code ne correspondra pas nécessairement à la même augmentation de la taille des pensions.

  • Les balises n'affectent pas la taille de dépôt de Mercurial de plus d'une poignée d'octets. Pas plus que les branches, jusqu'à ce que vous commenciez à travailler sur eux, à quel point ils ajoutent les mêmes frais généraux que de travailler sur la pointe. Le nombre de commissions devrait être raisonnablement proportionnel à la taille de la pension, en supposant que le même taux de changement se produit. Commettre 10 fois aussi souvent n'augmentera probablement pas la taille du fichier, car c'est le taux de changement qui est l'influence principale sur la taille des pensions, pas le nombre de commits.

+0

Le dernier point n'est pas vrai je pense. Si vous vous engagez 10 fois plus souvent, la taille de la somme des deltas devrait être à peu près la même. – tonfa

+1

Et même quand il stocke des fichiers complets, ils sont des fichiers compressés complets. C'est un delta compressé ou un compressé complet, mais il est toujours compressé. –

+0

Merci pour les commentaires. J'ai modifié le dernier point. – Ant

0

Si vous êtes préoccupé par la taille de champignons, allez cloner quelques projets en ligne et examinez la taille de leurs dépôts. Mon expérience est que git & mercurial et assez bon de garder la taille vers le bas, la taille est un reflet plus des fichiers que vous mettez en eux (et leur taille) plutôt que les frais généraux.

+0

Le référentiel que j'ai créé dans Mercurial mesure environ 70 Mo et s'étend sur plus de 10000 fichiers. J'étais juste un peu inquiet que dans quelques années, nous aurions des problèmes de taille, mais en regardant d'autres projets liés ici, il ne semble pas que nous serions plus mal lotis. – MdaG

3

estimer directement la taille d'une année est évidemment impossible, sauf si vous avez une idée du nombre de livraisons et la taille finale de l'arbre de travail.

Cela dit, git est plutôt efficace sur le plan de l'espace disque. Il ne stocke absolument jamais plus d'une copie d'une version donnée d'un fichier (ceci est représenté en interne comme un blob), et les blobs plus anciens sont compressés en delta en paquets. Cela signifie qu'il est très efficace pour stocker du texte brut et très inefficace avec de gros fichiers binaires. Si votre projet est majoritairement en texte brut, vous n'avez presque rien à craindre.

Les branches et les étiquettes n'ont essentiellement aucun effet sur la taille. Bien sûr, le reflet d'une branche peut atteindre quelques Ko, mais ce n'est pas grave. Les balises légères sont quasiment des SHA1 stockées, et les balises annotées ajoutent juste un tout petit peu de métadonnées. En ce qui concerne les lignes de code et le nombre de commits, il est difficile de dire exactement. Généralement les commits sont un facteur beaucoup plus grand que les lignes de code; vous pouvez avoir beaucoup de nombreuses versions de fichiers tout en ajoutant (même représenté sous forme de deltas), mais le contenu réel doit seulement être stocké une fois. Ceci est sauvegardé par le fait que les arbres de travail ont tendance à être beaucoup plus que le répertoire .git. Par exemple, mon clone de git.git a une arborescence de travail de 17 Mo et un répertoire .git de 39 Mo. Les autres projets que j'ai examinés ont des ratios similaires.

Plus commets de taille égale augmenterait certainement le dépôt, mais en prenant 1000 validations et en les divisant en 10000 (englobant les mêmes changements) ne ferait pas le dépôt beaucoup plus grand. Les objets commit eux-mêmes sont petits; ce sont les différences dans les fichiers qui prennent de l'espace. Vous pourriez voir un pic initial de taille, car les commits ne sont que périodiquement compressés en delta, mais une fois que git gc --auto est déclenché, ces commits seront de nouveau compressés.

La meilleure généralisation que je peux faire est que tend le répertoire .git d'un référentiel croître à un taux proportionnel à la quantité de delta par temps, ce qui en général devrait être proportionnelle à la taille de l'arbre de travail et le taux auquel les gens modifient le projet. Ceci est bien sûr si général qu'il est complètement inutile, mais vous y êtes.

Si vous voulez estimer, je prendrais juste quelques données au cours du premier mois, et j'essaierais d'ajuster une courbe.

+0

bonne explication. –

+1

On dirait que vous devez remballer votre git.git. Le mien est seulement 36MB après avoir exécuté 'git gc'. Dans mon expérience, les dépôts avec un plus petit historique ont tendance à avoir le .git dir plus petit que le worktree après un garbage collection. –

+0

@Kevin: Oups. Je suis surpris d'avoir réussi à aller aussi longtemps sans déclencher un 'gc --auto'. Merci d'avoir attrapé ça. – Cascabel

1

Jetez un oeil à GitBenchmarks la page sur le wiki Git, la section « repères de la taille du référentiel » et « Autres repères et références » (en prenant en compte lorsque l'indice de référence a été fait, et ce que versions il utilise), en notamment l'entrée à la page fin:

  • DVCS Round-up: One System to Rule Them All? -- Part 3 par Robert Fendt sur Linux Developer Network, à partir 27-01-2009, contient les résultats de deux tests de benchmarks synthétiques comment un système agit sous contrainte (nombre de livraisons dans le dépôt , ou le nombre de fichiers demandés). Le système de test était une VM exécutant Ubuntu 8.10, et les versions logicielles utilisées étaient SVK 2.0.2 (dernier est 2.2.3), Darcs 2.1.0 (dernier est 2.4.4), monotone 0.42 (dernier est 0.48), Bazar 1.10 (dernier est 2.2.1), Mercurial 1.1.2 (le dernier est 1.6.4), et Git 1.6.1 (le dernier est 1.7.3).

Questions connexes