कचरा संग्रह और पीढ़ियों के बारे में थोड़ा सा

हर कोई जानता है कि अधिकांश आधुनिक प्रणालियां कचरे के संग्रह की दक्षता बढ़ाने के लिए पीढ़ियों का उपयोग करती हैं। लेकिन क्या आपने कभी सोचा है कि ये पीढ़ी सामान्य रूप से कैसे काम करती है, और हम प्रदर्शन लाभ कैसे प्राप्त करते हैं? लेकिन चलो खुद से आगे नहीं बढ़ें और इसे क्रम में लें।

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

पीढ़ियों का मुख्य विचार यह है कि हम युवा पीढ़ी के "कचरा" को अधिक बार इकट्ठा करते हैं और इस तथ्य के कारण अधिक तेज होते हैं कि हम प्रबंधित हीप की सभी वस्तुओं (जो बहुत, बहुत हो सकते हैं) का विश्लेषण करते हैं, लेकिन केवल इस युवा पीढ़ी की वस्तुएं।

आइए ऐसे एक उदाहरण को देखें। मान लीजिए कि हमारे पास कुछ वस्तु "ए" है जो अपनी संपत्ति को आस्थगित तरीके से शुरू करती है:

public class B { } public class A { private Lazy<B> _lazyB = new Lazy<B>( () => new B()); public BB { get { return _lazyB.Value; } } } 

और संपत्ति बी तक पहुंच, और इसलिए इस वस्तु का निर्माण तब भी होता है, जब वस्तु "ए" दूसरी पीढ़ी में होती है:

 var a = new A(); GC.Collect(); GC.Collect(); // output: A resides in Gen 2, AB resides in Gen 0 Console.WriteLine("A resides in Gen {0}, AB resides in Gen {1}", GC.GetGeneration(a), GC.GetGeneration(aB)); GC.Collect(); 

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



लेकिन हमारे मामले में, ऑब्जेक्ट "बी" सीधे रूट लिंक से पहुंच योग्य नहीं है, जिसका अर्थ है कि इसकी पहुंच निर्धारित करने के लिए कचरा कलेक्टर को हमारे आवेदन के सभी ढेरों में सभी वस्तुओं के क्षेत्रों का विश्लेषण करना होगा, अन्यथा नव निर्मित वस्तुओं को "गलती से" कचरा कलेक्टर द्वारा एकत्र किया जा सकता है जो हम स्पष्ट रूप से नहीं चाहेंगे। फिर पीढ़ियों की बात क्या है, अगर हर बार आपको शून्य पीढ़ी की वस्तुओं की पुन: गतिशीलता को निर्धारित करने के लिए संपूर्ण प्रबंधित हीप का विश्लेषण करने की आवश्यकता है?

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

कार्ड टेबल एक सरल डेटा संरचना है, जो एक बिटमास्क है, जिसमें से प्रत्येक बिट इंगित करता है कि एक निश्चित सीमा के साथ एक पते पर स्थित एक ऑब्जेक्ट "गंदा" है और इसमें "युवा" ऑब्जेक्ट का लिंक है। वर्तमान में, बिटमेस्क का एक बिट 128 बाइट्स की एक सीमा का प्रतिनिधित्व करता है, जिसका अर्थ है कि बिटमस्क के प्रत्येक बाइट में 1K रेंज के बारे में जानकारी होती है। यह दृष्टिकोण कार्यकुशलता के बीच एक व्यापार-बंद है और इस तालिका को अद्यतित रखने के लिए कचरा कलेक्टर द्वारा आवश्यक अतिरिक्त मेमोरी की मात्रा है। इस प्रकार, 32-बिट सिस्टम के लिए जिसमें 2 जीबी पता स्थान उपयोगकर्ता मोड के लिए उपलब्ध है, कार्ड तालिका का आकार 2 एमबी है। हालाँकि, जब से कार्ड टेबल में एक बिट पता स्थान की 128 बाइट्स की एक सीमा को चिह्नित करता है, हर बार जब आप कचरा इकट्ठा करते हैं, तो आपको दर्जनों अन्य वस्तुओं का विश्लेषण करना होगा जिसमें युवा पीढ़ियों के लिंक शामिल नहीं हो सकते हैं।



इस डेटा संरचना को अद्यतित रखने के लिए, प्रत्येक बार जब ऑब्जेक्ट फ़ील्ड लिखा जाता है, तो JIT कंपाइलर एक तथाकथित "राइट बैरियर" उत्पन्न करता है, जो कार्ड टेबल को अपडेट करने के लिए कम हो जाता है यदि लिखी जा रही वस्तु का पता पंचांग खंड में है यानी 0 या 1 पीढ़ी का एक युवा ऑब्जेक्ट है।

अब, हमारे मामले में, ऑब्जेक्ट "बी" कचरा कलेक्टर द्वारा एकत्र नहीं किया जाएगा, क्योंकि न केवल रूट लिंक (जो संदर्भित नहीं हैं) का पुन: विश्लेषण विश्लेषण के लिए विश्लेषण किया जाएगा, बल्कि दूसरी पीढ़ी के निचले 128 हैंडल पर स्थित सभी ऑब्जेक्ट भी। जहां हमारी वस्तु "ए" मिलती है।

मुझे यह सब क्यों चाहिए?

हां, कचरा संग्रहण कैसे लागू किया जाता है, इसकी जानकारी में कोई विशेष व्यावहारिक लाभ नहीं है (जब तक कि आप एक लंबे समय तक रहने वाली वस्तु की घटना की सदस्यता नहीं लेते हैं और सदस्यता समाप्त करना भूल जाते हैं)। यह सिर्फ इतना है कि हर बार जब कचरा संग्रह पर चर्चा की जाती है, तो पीढ़ियों का उल्लेख किया जाता है, लेकिन यह बहुत कम चर्चा की जाती है कि अतिरिक्त स्क्रैप और एक प्रसिद्ध मां के बिना कुशल कचरा संग्रह का एहसास करना असंभव है।

वैसे, इस कार्यान्वयन का एक छोटा व्यावहारिक परिणाम है: इस तथ्य के बावजूद कि पुरानी पीढ़ी की वस्तुएं नई वस्तुओं का निर्माण करती हैं और उन्हें खेतों में संग्रहीत नहीं करती हैं (ब्रिटिश वैज्ञानिकों ने पाया है कि दूसरी पीढ़ी की वस्तुओं का 1% से अधिक ऐसा नहीं होता है) ऑब्जेक्ट फ़ील्ड पर लिखने के लिए कार्ड टेबल को अपडेट करने के लिए आवश्यक बहुत हैक के लिए कुछ अतिरिक्त लागतों की आवश्यकता होती है। यह, उदाहरण के लिए, एक प्रबंधित दुनिया में एक अप्रबंधित दुनिया (उदाहरण के लिए, ++ के साथ) की तुलना में थोड़ा अधिक महंगा संचालन में एक लेखन क्षेत्र बनाता है।

संबंधित लिंक

• .NET कचरा संग्रहण स्रोत