git gc - प्रगतिशील बनाम git प्रतिनिधि

Question 1

मैं एक gitरिपॉजिटरी के आकार को कम करने के तरीकों की तलाश कर रहा हूं । खोज मुझे git gc --aggressiveज्यादातर समय तक ले जाता है । मैंने यह भी पढ़ा है कि यह पसंदीदा तरीका नहीं है।

क्यों? अगर मैं भाग रहा हूँ तो मुझे क्या पता होना चाहिए gc --aggressive?

git repack -a -d --depth=250 --window=250पर सिफारिश की है gc --aggressive। क्यों? repackएक भंडार का आकार कैसे कम करता है? इसके अलावा, मैं झंडे के बारे में काफी स्पष्ट नहीं कर रहा हूँ --depthऔर --window।

मुझे gcऔर के बीच क्या चुनना चाहिए repack? मुझे कब gcऔर repackकैसे उपयोग करना चाहिए ?

Question 2

आजकल कोई अंतर नहीं है: git gc --aggressive2007 में किए गए सुझाव के अनुसार काम करता है; निचे देखो। संस्करण २.११ (Q4 २०१६) के अनुसार, ५० की गहराई तक डिफॉल्ट करता है। आकार २५० की एक खिड़की अच्छी है क्योंकि यह प्रत्येक वस्तु के एक बड़े हिस्से को स्कैन करती है, लेकिन २५० की गहराई खराब है क्योंकि यह प्रत्येक श्रृंखला को बहुत गहरे पुराने का संदर्भ देती है ऑब्जेक्ट्स, जो भविष्य में कम डिस्क उपयोग के लिए सभी git ऑपरेशन को धीमा कर देते हैं।

ऐतिहासिक पृष्ठभूमि

लिनुस ने सुझाव दिया (पूरी मेलिंग लिस्ट पोस्ट के लिए नीचे देखें) का उपयोग git gc --aggressiveकेवल तभी करें जब आपके पास, उनके शब्दों में, " वास्तव में एक बुरा पैक" या "वास्तव में बुरी तरह से बुरा डेल्टा," हालांकि "लगभग हमेशा" अन्य मामलों में, यह वास्तव में एक बहुत बुरा है। करने के लिए।" परिणाम तब भी आपके भंडार को बदतर स्थिति में छोड़ सकता है जब आपने शुरू किया था!

"लंबे और सम्मिलित इतिहास" को आयात करने के बाद वह ठीक से ऐसा करने का सुझाव देता है

git repack -a -d -f --depth=250 --window=250

लेकिन यह माना जाता है कि आपने पहले से ही अपने भंडार इतिहास से अनचाहे गन को हटा दिया है और आपने git filter-branchदस्तावेज़ में पाए गए भंडार को सिकोड़ने के लिए चेकलिस्ट का पालन किया है ।

गिट-फिल्टर-शाखा का उपयोग फ़ाइलों के सबसेट से छुटकारा पाने के लिए किया जा सकता है, आमतौर पर --index-filterऔर के संयोजन के साथ --subdirectory-filter। लोग उम्मीद करते हैं कि परिणामी भंडार मूल से छोटा होगा, लेकिन वास्तव में इसे छोटा बनाने के लिए आपको कुछ और कदमों की आवश्यकता है, क्योंकि Git आपकी वस्तुओं को खोने की कोशिश नहीं करता है जब तक कि आप इसे नहीं बताते। पहले सुनिश्चित करें कि:

आपने वास्तव में एक फ़ाइल नाम के सभी प्रकारों को हटा दिया है, अगर एक बूँद अपने जीवनकाल में चली गई थी। git log --name-only --follow --all -- filenameआप नाम बदलने में मदद कर सकते हैं।

आपने वास्तव में सभी refs फ़िल्टर किए हैं: --tag-name-filter cat -- --allकॉल करते समय उपयोग करें git filter-branch।

फिर एक छोटा भंडार प्राप्त करने के दो तरीके हैं। एक सुरक्षित तरीका क्लोन करना है, जो आपके मूल को बरकरार रखता है।

इसके साथ क्लोन git clone file:///path/to/repo। क्लोन में हटाए गए ऑब्जेक्ट नहीं होंगे। गिट-क्लोन देखें। (ध्यान दें कि एक सादे पथ के साथ क्लोनिंग बस सब कुछ हार्डलिंक करता है!)

यदि आप वास्तव में इसे क्लोन नहीं करना चाहते हैं, तो जो भी कारणों से, इसके बजाय निम्नलिखित बिंदुओं की जांच करें (इस क्रम में)। यह एक बहुत विनाशकारी दृष्टिकोण है, इसलिए एक बैकअप बनाएं या इसे क्लोनिंग पर वापस जाएं। आपको चेतावनी दी गई है।
Git-filter-branch द्वारा समर्थित मूल refs निकालें: कहते हैं
git for-each-ref --format="%(refname)" refs/original/ |
  xargs -n 1 git update-ref -d
के साथ सभी reflogs समाप्त करें git reflog expire --expire=now --all।

कचरा सभी अपरिचित वस्तुओं को एकत्र करें git gc --prune=now(या यदि आपके पास git gcतर्क का समर्थन करने के लिए नया नहीं है --prune, तो git repack -ad; git pruneइसके बजाय उपयोग करें )।

Date: Wed, 5 Dec 2007 22:09:12 -0800 (PST)
From: Linus Torvalds <torvalds at linux-foundation dot org>
To: Daniel Berlin <dberlin at dberlin dot org>
cc: David Miller <davem at davemloft dot net>,
    ismail at pardus dot org dot tr,
    gcc at gcc dot gnu dot org,
    git at vger dot kernel dot org
Subject: Re: Git and GCC
In-Reply-To: <4aca3dc20712052111o730f6fb6h7a329ee811a70f28@mail.gmail.com>
Message-ID: <alpine.LFD.0.9999.0712052132450.13796@woody.linux-foundation.org>
References: <4aca3dc20712051947t5fbbb383ua1727c652eb25d7e@mail.gmail.com>
            <20071205.202047.58135920.davem@davemloft.net>
            <4aca3dc20712052032n521c344cla07a5df1f2c26cb8@mail.gmail.com>
            <20071205.204848.227521641.davem@davemloft.net>
            <4aca3dc20712052111o730f6fb6h7a329ee811a70f28@mail.gmail.com>
थू पर, 6 दिसंबर 2007, डैनियल बर्लिन ने लिखा:

वास्तव में, यह पता चला है कि git-gc --aggressiveयह डंबल फाइल को कभी-कभी फाइल पैक करने के लिए करता है चाहे आप एक SVN रेपो से परिवर्तित हो या नहीं।

पूर्ण रूप से। git --aggressiveज्यादातर गूंगा है। यह वास्तव में केवल "मुझे पता है कि मेरे पास वास्तव में खराब पैक है के मामले के लिए उपयोगी है , और मैं उन सभी खराब पैकिंग को फेंकना चाहता हूं जो मैंने किया है।"

यह समझाने के लिए, यह समझाने योग्य है (आप शायद इसके बारे में जानते हैं, लेकिन मुझे मूल रूप से वैसे भी जाने दें) कैसे डेल्टा डेल्टा-चेन काम करते हैं, और वे अन्य प्रणालियों से कितने अलग हैं।

अन्य SCM में, एक डेल्टा-चेन आमतौर पर तय की जाती है। यह "आगे" या "पीछे की ओर" हो सकता है, और जब आप रिपॉजिटरी के साथ काम करते हैं तो यह थोड़ा सा विकसित हो सकता है, लेकिन आम तौर पर यह एकल SCM इकाई के रूप में प्रतिनिधित्व की गई एकल फ़ाइल में परिवर्तन की एक श्रृंखला है। सीवीएस में, यह स्पष्ट रूप से *,vफ़ाइल है, और बहुत सारे अन्य सिस्टम समान चीजों को करते हैं।

गिट डेल्टा-चेन भी करते हैं, लेकिन यह उन्हें बहुत अधिक "शिथिल" करता है। कोई निश्चित इकाई नहीं है। डेल्टास किसी भी यादृच्छिक अन्य संस्करण के खिलाफ उत्पन्न होते हैं जो एक अच्छा डेल्टा उम्मीदवार (विभिन्न सफल उत्तराधिकारियों के साथ) होने के लिए देवता को मानते हैं, और बिल्कुल कठोर समूहन नियम नहीं हैं।

यह आम तौर पर एक बहुत अच्छी बात है। यह विभिन्न वैचारिक कारणों के लिए अच्छा है ( यानी , आंतरिक रूप से वास्तव में कभी भी पूरे संशोधन श्रृंखला के बारे में परवाह करने की आवश्यकता नहीं है - यह वास्तव में डेल्टास के संदर्भ में बिल्कुल भी नहीं सोचता है), लेकिन यह अनम्य डेल्टा नियमों से छुटकारा पाने के कारण बहुत अच्छा है उदाहरण के लिए दो फ़ाइलों को एक साथ मर्ज करने से उस git को कोई समस्या नहीं है - उदाहरण के लिए, कोई *,v" मनमानी फ़ाइलें" नहीं हैं जिनमें कुछ छिपे हुए अर्थ हैं।

इसका अर्थ यह भी है कि डेल्टास का चुनाव अधिक खुला प्रश्न है। यदि आप डेल्टा श्रृंखला को केवल एक फ़ाइल तक सीमित करते हैं, तो आपके पास वास्तव में डेल्टास के बारे में बहुत सारे विकल्प नहीं हैं, लेकिन गिट में, यह वास्तव में एक पूरी तरह से अलग मुद्दा हो सकता है।

और यह वह जगह है जहां वास्तव में बुरी तरह से नाम --aggressiveआता है। जबकि गिट आम तौर पर डेल्टा जानकारी का फिर से उपयोग करने की कोशिश करता है (क्योंकि यह एक अच्छा विचार है, और यह सीपीयू समय बर्बाद नहीं करता है जो हम पहले पाए गए सभी अच्छे डेल्टाों को फिर से खोज रहे हैं), कभी-कभी आप कहना चाहते हैं "चलो एक खाली स्लेट के साथ सभी शुरू करते हैं, और पिछले सभी डेल्टा जानकारी को अनदेखा करते हैं, और डेल्टास का एक नया सेट उत्पन्न करने का प्रयास करते हैं।"

तो --aggressiveवास्तव में आक्रामक होने के बारे में नहीं है, लेकिन सीपीयू के समय को बर्बाद करने के बारे में एक निर्णय जो हम पहले ही कर चुके थे!

कभी-कभी यह अच्छी बात है। विशेष रूप से कुछ आयात उपकरण वास्तव में बहुत खराब डेल्टास उत्पन्न कर सकते हैं। git fast-importउदाहरण के लिए, जो कुछ भी उपयोग करता है , उसके पास बहुत बड़ा डेल्टा लेआउट नहीं है, इसलिए यह कहने योग्य हो सकता है कि "मैं एक साफ स्लेट से शुरू करना चाहता हूं।"

लेकिन लगभग हमेशा, अन्य मामलों में, यह वास्तव में एक बहुत बुरा काम है। यह सीपीयू समय बर्बाद करने जा रहा है, और खासकर यदि आपने वास्तव में पहले डेल्टा में एक अच्छा काम किया था, तो अंतिम परिणाम उन सभी अच्छे डेल्टास का फिर से उपयोग करने वाला नहीं है जो आप पहले से ही पाए गए हैं, इसलिए आप वास्तव में बहुत कुछ खत्म करेंगे इससे भी बुरा परिणाम!

मैं सिर्फ git gc --aggressive दस्तावेज निकालने के लिए जूनियो को एक पैच भेजूंगा । यह उपयोगी हो सकता है, लेकिन यह आम तौर पर केवल तभी उपयोगी होता है जब आप वास्तव में बहुत गहरे स्तर पर समझते हैं कि यह क्या कर रहा है, और यह प्रलेखन आपको ऐसा करने में मदद नहीं करता है।

आमतौर पर, वृद्धिशील git gcकरना सही दृष्टिकोण है, और करने से बेहतर है git gc --aggressive। यह पुराने डेल्टास का फिर से उपयोग करने जा रहा है, और जब उन पुराने डेल्टास को नहीं पाया जा सकता है (पहली जगह में वृद्धिशील जीसी करने का कारण!) यह नया बनाने जा रहा है।

दूसरी ओर, यह निश्चित रूप से सच है कि एक "लंबे और सम्मिलित इतिहास का प्रारंभिक आयात" एक ऐसा बिंदु है जहां यह वास्तव में अच्छा डेल्टा खोजने में बहुत समय बिताने के लायक हो सकता है । फिर, प्रत्येक उपयोगकर्ता के बाद (जब तक वे git gc --aggressiveइसे पूर्ववत करने के लिए उपयोग नहीं करते !) को उस एक बार की घटना का लाभ मिलेगा। इसलिए विशेष रूप से एक लंबे इतिहास के साथ बड़ी परियोजनाओं के लिए, यह शायद कुछ अतिरिक्त काम करने के लायक है, डेल्टा खोजने के कोड को जंगली बताने के लिए।

तो समतुल्य git gc --aggressive- लेकिन ठीक से किया हुआ - करना है (रात भर) कुछ ऐसा
git repack -a -d --depth=250 --window=250
जहां गहराई की बात बस इतनी ही है कि डेल्टा चेन कितनी गहरी हो सकती है (पुराने इतिहास के लिए उन्हें अधिक समय तक बनाये रखें - यह अंतरिक्ष के ऊपर के लायक है), और खिड़की की बात इस बारे में है कि हम प्रत्येक डेल्टा उम्मीदवार को स्कैन करने के लिए कितनी बड़ी वस्तु चाहते हैं।

और यहाँ, आप अच्छी तरह से -fझंडे को जोड़ना चाहते हैं (जो कि "सभी पुराने डेल्टास को छोड़ दें", क्योंकि आप अब वास्तव में यह सुनिश्चित करने की कोशिश कर रहे हैं कि यह वास्तव में अच्छे उम्मीदवारों को ढूंढता है।

और फिर यह हमेशा के लिए ले जा रहा है और एक दिन ( यानी , "एक रात में यह काम करते हैं")। लेकिन अंतिम परिणाम यह है कि उस भंडार से प्रत्येक व्यक्ति को बहुत बेहतर पैक मिलेंगे, बिना उस पर कोई प्रयास किए।
          Linus

Question 3

मुझे gc और repack का उपयोग कब करना चाहिए?

जैसा कि मैंने " गिट कचरा संग्रह पूरी तरह से काम नहीं करता है " में उल्लेख किया है , एक git gc --aggressiveअपने आप में पर्याप्त या पर्याप्त नहीं है।
और, जैसा कि मैं नीचे समझाता हूं , अक्सर आवश्यकता नहीं होती है।

सबसे प्रभावी संयोजन जोड़ना होगा git repack, लेकिन यह भी git prune:

git gc
git repack -Ad      # kills in-pack garbage
git prune           # kills loose garbage

नोट: Git 2.11 (Q4 2016) डिफ़ॉल्ट gc aggressiveगहराई को 50 पर सेट करेगा

जेफ किंग ( ) द्वारा देखें प्रतिबद्ध 07e7dbf (11 अगस्त 2016 ) । ⁽^{जूनियो}^सी^{हमानो}^{द्वारा विलय}^-^-^में^{० ९}^{५२ ए}^{० 21, २१ सितंबर २०१६)}peff
^gitster

gc: डिफ़ॉल्ट आक्रामक गहराई 50 के लिए

" git gc --aggressive" डेल्टा-श्रृंखला की लंबाई को 250 तक सीमित करता था, जो अतिरिक्त अंतरिक्ष बचत प्राप्त करने के लिए बहुत गहरा है और रनटाइम प्रदर्शन के लिए हानिकारक है।
सीमा को घटाकर 50 कर दिया गया है।

सारांश यह है: 250 का वर्तमान डिफ़ॉल्ट ज्यादा जगह नहीं बचाता है, और सीपीयू की लागत है। यह एक अच्छा व्यापार नहीं है।

" --aggressive" झंडा git-gcतीन काम करता है:

-fमौजूदा डेल्टास को बाहर फेंकने के लिए " " का प्रयोग करें और स्क्रैच से फिर से चलाएँ

डेल्टास के लिए कठिन दिखने के लिए "--विंडो = 250" का उपयोग करें

लंबी श्रृंखला बनाने के लिए "--depth = 250" का उपयोग करें

आइटम (1) और (2) "आक्रामक" रिपैक के लिए अच्छे मैच हैं।
वे रिपैक को एक बेहतर पैक प्राप्त करने की उम्मीद में अधिक गणना कार्य करने के लिए कहते हैं। आप पुनर्खरीद के दौरान लागत का भुगतान करते हैं, और अन्य संचालन केवल लाभ देखते हैं।

आइटम (3) इतना स्पष्ट नहीं है।
लंबी श्रृंखलाओं को छोड़ने का अर्थ है डेल्टास पर कम प्रतिबंध, जिसका अर्थ है कि संभवतः बेहतर लोगों को ढूंढना और कुछ स्थान को बचाना।
लेकिन इसका मतलब यह भी है कि जो ऑपरेशन डेल्टास तक पहुंचते हैं उन्हें लंबी श्रृंखलाओं का पालन करना पड़ता है, जो उनके प्रदर्शन को प्रभावित करता है।
तो यह एक व्यापार है, और यह स्पष्ट नहीं है कि व्यापार एक अच्छा भी है।

( अध्ययन के लिए प्रतिबद्ध देखें )

आप देख सकते हैं कि नियमित संचालन के लिए सीपीयू की बचत में सुधार होता है क्योंकि हम गहराई को कम करते हैं।
लेकिन हम यह भी देख सकते हैं कि अंतरिक्ष की बचत उतनी महान नहीं है जितनी गहराई अधिक होती है। 10 और 50 के बीच 5-10% की बचत शायद सीपीयू ट्रेडऑफ के लायक है। 50% से 100 पर जाने के लिए 1% की बचत, या 100 से 250 तक जाने के लिए एक और 0.5% की बचत शायद नहीं है।

CPU सहेजने की बात करते हुए, " git repack" --threads=<n>विकल्प को स्वीकार करना और इसे पैक-ऑब्जेक्ट में पास करना सीखा ।

देखें 40bcf31 प्रतिबद्ध (26 अप्रैल 2017) से Junio सी Hamano ( gitster) ।
^{(द्वारा विलय Junio सी Hamano - gitster- में प्रतिबद्ध 31fb6f4 , 29 मई 2017)}

repack: स्वीकार करें --threads=<n>और इसे पास करेंpack-objects

हम पहले से ही ऐसा करते हैं --window=<n>और --depth=<n>; यह मदद करेगा जब उपयोगकर्ता --threads=1कई थ्रेड्स रेसिंग से प्रभावित हुए बिना प्रतिलिपि प्रस्तुत करने योग्य परीक्षण के लिए मजबूर करना चाहता है ।

Question 4

इसके साथ समस्या git gc --aggressiveयह है कि विकल्प नाम और प्रलेखन भ्रामक है।

जैसा कि लिनुस ने स्वयं इस मेल में बताया है, यहgit gc --aggressive मूल रूप से क्या करता है:

हालांकि आम तौर पर git डेल्टा जानकारी को फिर से उपयोग करने की कोशिश करता है (क्योंकि यह एक अच्छा विचार है, और यह सीपीयू समय बर्बाद नहीं करता है जो हमें पहले मिले सभी अच्छे डेल्टास को फिर से मिल रहा है), कभी-कभी आप कहना चाहते हैं "चलो शुरू करें सब, एक के साथ रिक्त स्लेट, और पिछले सभी डेल्टा जानकारी को अनदेखा करें, और डेल्टास का एक नया सेट उत्पन्न करने का प्रयास करें "।

आमतौर पर गिट में डेल्टास को पुन: संयोजित करने की आवश्यकता नहीं होती है, क्योंकि गिट इन डेल्टास को बहुत लचीला निर्धारित करता है। यह केवल समझ में आता है यदि आप जानते हैं कि आपके पास वास्तव में है, वास्तव में बुरा डेल्टा है। जैसा कि लिनस बताते हैं, मुख्यतः उपकरण जो git fast-importइस श्रेणी में गिरावट का उपयोग करते हैं।

अधिकांश समय गिट उपयोगी डेल्टास का निर्धारण करने में एक बहुत अच्छा काम करता है और उपयोग करने git gc --aggressiveसे आपको डेल्टास के साथ छोड़ देगा जो कि बहुत अधिक सीपीयू समय बर्बाद करते हुए संभवतः और भी बदतर हैं।

लिनुस अपने मेल को इस निष्कर्ष के साथ समाप्त करता है कि git repackएक बड़े के साथ --depthऔर --windowज्यादातर समय में बेहतर विकल्प है; विशेष रूप से आपके द्वारा एक बड़ी परियोजना को आयात करने के बाद और यह सुनिश्चित करना चाहते हैं कि गिट अच्छा डेल्टा पाता है।

तो समतुल्य git gc --aggressive- लेकिन ठीक से किया हुआ - करना है (रात भर) कुछ ऐसा

git repack -a -d --depth=250 --window=250

जहां गहराई की बात बस इतनी ही है कि डेल्टा चेन कितनी गहरी हो सकती है (पुराने इतिहास के लिए उन्हें अधिक समय तक बनाये रखें - यह अंतरिक्ष के ऊपर के लायक है), और खिड़की की बात इस बारे में है कि हम प्रत्येक डेल्टा उम्मीदवार को स्कैन करने के लिए कितनी बड़ी वस्तु चाहते हैं।

और यहाँ, आप अच्छी तरह से -fझंडा जोड़ना चाह सकते हैं (जो कि "सभी पुराने डेल्टास को छोड़ दें", क्योंकि आप अब वास्तव में यह सुनिश्चित करने की कोशिश कर रहे हैं कि यह वास्तव में अच्छे उम्मीदवारों को ढूंढता है।

Question 5

सावधान। git gc --agressiveयदि आपके पास कोई बैकअप नहीं है, तो रिपॉजिटरी के साथ न चलाएं जो रिमोट के साथ सिंक्रनाइज़ नहीं है।

यह ऑपरेशन खरोंच से डेल्टास को फिर से बनाता है और अगर ग्रेसफुल रूप से बाधित होता है तो डेटा हानि हो सकती है।

मेरे 8GB कंप्यूटर आक्रामक जीसी के लिए 1kb रिपॉजिटरी पर 10k छोटे कमिट के साथ मेमोरी से बाहर चला गया। जब ओओएम किलर ने गिट प्रक्रिया को समाप्त कर दिया - इसने मुझे लगभग खाली भंडार के साथ छोड़ दिया, केवल काम करने वाला पेड़ और कुछ डेल्टा बच गए।

बेशक, यह रिपॉजिटरी की एकमात्र प्रति नहीं थी, इसलिए मैंने इसे फिर से बनाया और रिमोट से खींचा (भ्रूण टूटी हुई रेपो पर काम नहीं करता था और 'डेल्टास को हल करने के लिए गतिरोध' के कदम पर मैंने ऐसा करने की कोशिश की), लेकिन आपका रेपो है एकल-डेवलपर लोकल रेपो को बिना किसी नुकसान के - इसे पहले वापस कर दें।

Question 6

नोट: git gc --aggressiveGit 2.22 (Q2 2019) के उपयोग से सावधान रहें , स्पष्ट करता है।

gc डॉक्स: की उपयोगिता को कम करते हैं --aggressive

मौजूदा " gc --aggressive" डॉक्स उपयोगकर्ताओं की सिफारिश करने के लिए कम है कि वे इसे नियमित रूप से चलाते हैं।
मैंने व्यक्तिगत रूप से कई उपयोगकर्ताओं से बात की है जिन्होंने इस विकल्प का उपयोग करने के लिए इन डॉक्स को लिया है, और आमतौर पर यह (ज्यादातर) समय की बर्बादी है ।

तो आइए स्पष्ट करें कि यह वास्तव में क्या करता है, और उपयोगकर्ता को अपने निष्कर्ष निकालने दें।

आइए जेफ किंग के स्पष्टीकरण के संक्षिप्त संस्करण को स्पष्ट करने के लिए "द इफेक्ट्स [...] लगातार हैं" को भी स्पष्ट करें ।

इसका मतलब है कि git-gc प्रलेखन में अब शामिल हैं :

आक्रामक

जब --aggressiveविकल्प आपूर्ति की है, git-repackद्वारा सक्रिय किया जाएगा -fझंडा, जो बारी में पारित करेंगे --no-reuse-deltaकरने के लिए Git पैक वस्तुओं ।
यह किसी भी मौजूदा डेल्टास को हटा देगा और उन्हें पुन: गणना करेगा, रिपैकिंग पर अधिक समय बिताने की कीमत पर।

इसके प्रभाव अधिकतर स्थिर होते हैं, उदाहरण के लिए जब पैक और ढीली वस्तुएं एक दूसरे पैक में जमा होती हैं, तो उस पैक में मौजूदा डेल्टा पुन: उपयोग हो सकता है, लेकिन ऐसे भी कई मामले हैं जहां हम एक नए से उप-इष्टतम डेल्टा चुन सकते हैं। इसके बजाय पैक करें।

इसके अलावा, आपूर्ति --aggressiveट्वीक करेगा --depthऔर --windowविकल्पों के लिए पारित किया git-repack।
देखें gc.aggressiveDepthऔर gc.aggressiveWindowसेटिंग्स नीचे।
एक बड़े विंडो आकार का उपयोग करके हम अधिक इष्टतम डेल्टास खोजने की संभावना रखते हैं।

यह संभव नहीं है कि किसी दिए गए भंडार पर इस विकल्प का उपयोग किए बिना उस पर अनुरूप प्रदर्शन मानदंड चलाए बिना इसका उपयोग किया जा सके ।
इसमें बहुत अधिक समय लगता है, और परिणामस्वरूप स्थान / डेल्टा अनुकूलन इसके लायक हो सकता है या नहीं हो सकता है। अधिकांश उपयोगकर्ताओं और उनकी रिपॉजिटरी के लिए सही ट्रेड-ऑफ का उपयोग नहीं करना।

और (कम से कम 080a448 ):

gcडॉक्स: ध्यान दें कि कैसे --aggressiveप्रभाव --windowऔर--depth

07e7dbf के बाद से ( gc: डिफ़ॉल्ट आक्रामक गहराई 50 से, 2016-08-11, Git v2.10.1) हम कुछ हद तक उसी गहराई का उपयोग करते हैं --aggressiveजैसा कि हम डिफ़ॉल्ट रूप से करते हैं।

जैसा कि उस प्रतिबद्ध में उल्लेख किया गया है जो समझ में आता है, "आक्रामक" के लिए अधिक गहराई को डिफ़ॉल्ट बनाना गलत था, और इस तरह रनटाइम प्रदर्शन की कीमत पर डिस्क स्थान को बचाते हैं, जो आमतौर पर "आक्रामक जीसी" की तरह किसी के विपरीत होता है। चाहता हे।

git gc - प्रगतिशील बनाम git प्रतिनिधि

ऐतिहासिक पृष्ठभूमि

`gc`: डिफ़ॉल्ट आक्रामक गहराई 50 के लिए

repack: स्वीकार करें `--threads=<n>`और इसे पास करें`pack-objects`

`gc` डॉक्स: की उपयोगिता को कम करते हैं `--aggressive`

आक्रामक

`gc`डॉक्स: ध्यान दें कि कैसे `--aggressive`प्रभाव `--window`और`--depth`

git gc - प्रगतिशील बनाम git प्रतिनिधि

ऐतिहासिक पृष्ठभूमि

gc: डिफ़ॉल्ट आक्रामक गहराई 50 के लिए

repack: स्वीकार करें --threads=<n>और इसे पास करेंpack-objects

gc डॉक्स: की उपयोगिता को कम करते हैं --aggressive

आक्रामक

gcडॉक्स: ध्यान दें कि कैसे --aggressiveप्रभाव --windowऔर--depth

`gc`: डिफ़ॉल्ट आक्रामक गहराई 50 के लिए

repack: स्वीकार करें `--threads=<n>`और इसे पास करें`pack-objects`

`gc` डॉक्स: की उपयोगिता को कम करते हैं `--aggressive`

`gc`डॉक्स: ध्यान दें कि कैसे `--aggressive`प्रभाव `--window`और`--depth`