इस लेख में आपको एक साथ जानकारी के दो स्रोत मिलेंगे:

1. पूरा कचरा कलेक्टर कोर्स रूसी में: CLRium # 6 ( वर्तमान कार्यशाला यहाँ )
2. Maoni स्टीवंस द्वारा BOTR "कचरा कलेक्टर डिवाइस" के एक लेख का अनुवाद।

1. CLRium # 5: पूरा कचरा कलेक्टर कोर्स

2. Maoni Stephens द्वारा कचरा संग्रहण उपकरण ( @ maoni0 )

नोट: सामान्य रूप से कचरा संग्रह के बारे में अधिक जानने के लिए, कचरा संग्रह पुस्तिका देखें ; CLR में कचरा इकट्ठा करने वालों के बारे में विशेष जानकारी प्रो .NET मेमोरी मैनेजमेंट की पुस्तक में दी गई है। दस्तावेज़ के अंत में दोनों संसाधनों के लिंक दिए गए हैं।

घटक वास्तुकला

कचरा संग्रह दो घटकों के साथ जुड़ा हुआ है: एक डिस्पेंसर और एक कलेक्टर। आवंटनकर्ता मेमोरी को आवंटित करने और आवश्यक होने पर कलेक्टर को कॉल करने के लिए जिम्मेदार है। कलेक्टर उन वस्तुओं का कचरा या स्मृति एकत्र करता है जिनका अब प्रोग्राम द्वारा उपयोग नहीं किया जाता है।

कलेक्टर को कॉल करने के अन्य तरीके हैं, उदाहरण के लिए, जीसी का उपयोग करके मैन्युअल रूप से। इसके अलावा, अंतिम सूत्र में अतुल्यकालिक अधिसूचना प्राप्त हो सकती है कि मेमोरी बाहर चल रही है (जो कलेक्टर का कारण होगा)।

वितरक डिवाइस

वितरक को निम्नलिखित सूचना के साथ रनटाइम के सहायक घटकों द्वारा बुलाया जाता है:

• आवंटित भूखंड का आवश्यक आकार;
• निष्पादन के धागे के लिए स्मृति आवंटन का संदर्भ;
• झंडे जो इंगित करते हैं, उदाहरण के लिए, चाहे वह वस्तु अंतिम हो।

कचरा संग्रहकर्ता विभिन्न प्रकार की वस्तुओं के लिए विशेष प्रसंस्करण विधि प्रदान नहीं करता है। यह रनटाइम से ऑब्जेक्ट के आकार के बारे में जानकारी प्राप्त करता है।

आकार के आधार पर, कलेक्टर वस्तुओं को दो श्रेणियों में विभाजित करता है: छोटी (<85,000 बाइट्स) और बड़ी (> = 85,000 बाइट्स)। सामान्य तौर पर, छोटी और बड़ी वस्तुओं का संयोजन उसी तरह हो सकता है। हालांकि, कलेक्टर उन्हें आकार से अलग करता है, क्योंकि बड़ी वस्तुओं को संकुचित करने के लिए बहुत सारे संसाधनों की आवश्यकता होती है।

कचरा कलेक्टर आवंटन संदर्भों के आधार पर आवंटनकर्ता को मेमोरी आवंटित करता है। आवंटन संदर्भ का आकार आवंटित स्मृति के ब्लॉकों द्वारा निर्धारित किया जाता है।

• चयन संदर्भ एक विशिष्ट ढेर खंड के छोटे क्षेत्र हैं, जिनमें से प्रत्येक एक विशिष्ट निष्पादन प्रवाह के लिए अभिप्रेत है। एक प्रोसेसर वाली मशीन पर (जिसका अर्थ 1 तार्किक प्रोसेसर है), एकल मेमोरी आवंटन संदर्भ का उपयोग पीढ़ी 0 की वस्तुओं के लिए किया जाता है।

  
  

• आबंटित मेमोरी के ब्लॉक - हर बार जब किसी ऑब्जेक्ट को क्षेत्र के अंदर रखने के लिए उसे अधिक मेमोरी की आवश्यकता होती है, तो आवंटनकर्ता द्वारा आवंटित मेमोरी की मात्रा। ब्लॉक का आकार आमतौर पर 8 KB है, और प्रबंधित ऑब्जेक्ट का औसत आकार 35 बाइट्स है। इसलिए, एक ब्लॉक में आप कई ऑब्जेक्ट रख सकते हैं।

  
  

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

वितरक को इस तरह बनाया गया है कि:

• जब आवश्यक हो तब कचरा कलेक्टर को कॉल करें: जब ऑब्जेक्ट के लिए आवंटित मेमोरी की मात्रा थ्रेसहोल्ड मान (कलेक्टर द्वारा निर्धारित) से अधिक हो, या यदि आवंटनकर्ता अब इस सेगमेंट में मेमोरी आवंटित नहीं कर सकता है, तो आवंटनकर्ता कलेक्टर को कॉल करता है। थ्रेसहोल्ड और नियंत्रित सेगमेंट बाद में विस्तार से वर्णित किए जाएंगे।

  
  

• वस्तुओं का स्थान बचाना: ढेर के एक खंड में एक साथ स्थित वस्तुओं को एक दूसरे के करीब आभासी पतों पर संग्रहीत किया जाता है।

  
  

• कैश का कुशलता से उपयोग करें: आवंटनकर्ता ब्लॉक में मेमोरी आवंटित करता है, और प्रत्येक ऑब्जेक्ट के लिए नहीं। यह प्रोसेसर कैश को तैयार करने के लिए इतनी मेमोरी को शून्य करता है, क्योंकि इसमें कुछ ऑब्जेक्ट सीधे रखे जाएंगे। आवंटित मेमोरी का ब्लॉक आमतौर पर 8 KB है।

  
  

• प्रभावी रूप से निष्पादन थ्रेड के लिए आवंटित क्षेत्र को सीमित करें: थ्रेड के लिए आवंटित संदर्भों और मेमोरी ब्लॉकों की निकटता यह सुनिश्चित करती है कि केवल एक थ्रेड आवंटित स्थान पर डेटा लिखेगा। नतीजतन, मेमोरी के आवंटन को सीमित करने की आवश्यकता नहीं है जब तक कि वर्तमान आवंटन संदर्भ में स्थान समाप्त नहीं हो जाता है।

  
  

• स्मृति अखंडता सुनिश्चित करें: कचरा कलेक्टर हमेशा नई आवंटित वस्तुओं के लिए स्मृति को शून्य करता है ताकि उनके लिंक स्मृति के मनमाने वर्गों को इंगित न करें।

  
  

• ढेर निरंतरता सुनिश्चित करें: आवंटनकर्ता प्रत्येक आवंटित ब्लॉक में शेष मेमोरी से एक मुफ्त वस्तु बनाता है। उदाहरण के लिए, यदि ब्लॉक में 30 बाइट्स बचे हैं, और अगली वस्तु को समायोजित करने के लिए 40 बाइट्स की आवश्यकता होती है, तो आवंटनकर्ता इन 30 बाइट्स को एक मुफ्त ऑब्जेक्ट में बदल देगा और एक नए मेमोरी ब्लॉक का अनुरोध करेगा।

  
  

एपीआई

Object* GCHeap::Alloc(size_t size,  DWORD); Object* GCHeap::Alloc(alloc_context* acontext, size_t size,  DWORD); 

इन कार्यों का उपयोग करके, आप छोटी और बड़ी दोनों वस्तुओं के लिए मेमोरी आवंटित कर सकते हैं। बड़ी वस्तुओं के ढेर (LOH) पर सही जगह आवंटित करने का एक कार्य है:

  Object* GCHeap::AllocLHeap(size_t size,  DWORD); 

कलेक्टर डिवाइस

कचरा संग्रहकर्ता कार्य

जीसी को कुशल मेमोरी प्रबंधन के लिए डिज़ाइन किया गया है। प्रबंधित कोड लिखने वाले डेवलपर्स इसे बहुत प्रयास के बिना उपयोग कर सकते हैं। सुशासन का अर्थ है:

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

प्रबंधित हीप का तार्किक विवरण

CLR कचरा संग्रहकर्ता उन वस्तुओं को इकट्ठा करता है जो पीढ़ी दर पीढ़ी अलग हो जाते हैं। पीढ़ी एन में वस्तुओं को इकट्ठा करने के बाद, शेष वस्तुओं को पीढ़ी एन + 1 से संबंधित के रूप में चिह्नित किया जाता है। इस प्रक्रिया को पीढ़ियों में वस्तुओं का प्रचार कहा जाता है। इस प्रक्रिया में कुछ अपवाद हैं जब किसी पीढ़ी को किसी वस्तु को नीचे स्थानांतरित करना आवश्यक होता है या उसे आगे नहीं बढ़ाना होता है।

छोटी वस्तुओं के मामले में, ढेर तीन पीढ़ियों में विभाजित है: gen0, gen1 और gen2। बड़ी वस्तुओं के लिए, केवल एक पीढ़ी है - जीन 3। Gen0 और gen1 को अल्पकालिक पीढ़ियां कहा जाता है (कुछ समय के लिए वस्तुएं उनमें रहती हैं)।

छोटी वस्तुओं के एक समूह के लिए, पीढ़ी संख्या का अर्थ है उनकी आयु। उदाहरण के लिए, gen0 सबसे युवा पीढ़ी है। इसका मतलब यह नहीं है कि gen0 की सभी वस्तुएं gen1 या gen2 की वस्तुओं से छोटी हैं। कुछ अपवाद हैं जो नीचे वर्णित हैं। एक पीढ़ी को इकट्ठा करने का मतलब है कि इस पीढ़ी में वस्तुओं को इकट्ठा करना, साथ ही साथ इसकी सभी युवा पीढ़ियों में।

सैद्धांतिक रूप से, बड़ी और छोटी वस्तुओं का संयोजन उसी तरह हो सकता है। हालांकि, चूंकि बड़ी वस्तुओं के संपीड़न के लिए बहुत अधिक संसाधनों की आवश्यकता होती है, इसलिए उनकी विधानसभा अलग तरीके से होती है। बड़ी वस्तुएं केवल जीन 2 में निहित होती हैं और केवल प्रदर्शन कारणों से इस पीढ़ी में कचरा संग्रह के दौरान एकत्र की जाती हैं। दोनों gen2 और gen3 बड़े हो सकते हैं, और पंचांग पीढ़ियों (gen0 और gen1) में किसी वस्तु का निर्माण बहुत अधिक संसाधन-गहन नहीं होना चाहिए।

वस्तुओं को सबसे युवा पीढ़ी में रखा गया है। छोटी वस्तुओं के लिए, यह जीन 0 है, और बड़े - जीन 3 के लिए।

प्रबंधित हीप का भौतिक विवरण

एक प्रबंधित ढेर में खंडों का एक समूह होता है। एक खंड मेमोरी का एक निरंतर ब्लॉक है जो ओएस कचरा कलेक्टर को पास करता है। छोटे और बड़े ऑब्जेक्ट को समायोजित करने के लिए हीप सेगमेंट को छोटे और बड़े वर्गों में विभाजित किया जाता है। प्रत्येक ढेर के खंड एक साथ जुड़े हुए हैं। सीएलआर लोड करते समय एक छोटी वस्तु के लिए कम से कम एक खंड और एक बड़े के लिए एक आरक्षित होता है।

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

बड़ी वस्तुओं के ढेर में एक या अधिक खंड होते हैं।

ढेर खंड निचले से उच्च पते पर आबादी है। इसका मतलब यह है कि सेगमेंट के निचले पते पर स्थित ऑब्जेक्ट सीनियर में स्थित की तुलना में पुराने हैं। कुछ अपवाद भी हैं जिनका वर्णन नीचे दिया गया है।

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

हीप सेगमेंट एक साथ चयन में शामिल होते हैं। श्रृंखला में अंतिम खंड हमेशा अल्पकालिक होता है। ऐसे खंड जिनमें सभी वस्तुओं को एकत्र किया जाता है, उनका पुन: उपयोग किया जा सकता है, उदाहरण के लिए, पंचांग के रूप में। खंड पुन: उपयोग केवल छोटी वस्तुओं के ढेर पर लागू होता है। हर बार बड़ी वस्तुओं को समायोजित करने के लिए बड़ी वस्तुओं का पूरा गुच्छा माना जाता है। छोटी वस्तुओं को केवल पंचांग खंडों में रखा जाता है।

आवंटित स्मृति का थ्रेसहोल्ड मान

यह प्रत्येक पीढ़ी के आकार से संबंधित एक तार्किक अवधारणा है। यदि इसे पार किया जाता है, तो पीढ़ी कचरा संग्रहण शुरू करती है।

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

कचरा संग्रहण के लिए सृजन चयन

सक्रिय होने पर, कलेक्टर को यह निर्धारित करना होगा कि किस पीढ़ी का निर्माण करना है। सीमा मूल्य के अलावा, अन्य कारक इस पसंद को प्रभावित करते हैं:

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

कचरा संग्रहण की प्रक्रिया

अंकन चरण

इस चरण के दौरान, सीएलआर को सभी जीवित वस्तुओं का पता लगाना चाहिए।

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

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

योजना चरण

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

गतिमान अवस्था

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

संपीड़न अवस्था

यह चरण काफी सरल है, क्योंकि कलेक्टर ने योजना चरण के दौरान वस्तुओं को स्थानांतरित करने के लिए पहले से ही नए पते निर्धारित किए हैं। संपीड़ित होने पर, ऑब्जेक्ट्स को इन पतों पर कॉपी किया जाएगा।

सफाई का चरण

इस चरण के दौरान, कलेक्टर जीवित वस्तुओं के बीच अप्रयुक्त स्थान की खोज करता है। इस स्थान के बजाय, वह मुक्त वस्तुओं का निर्माण करता है। आसपास के क्षेत्र में अनुपयोगी वस्तुएं एक मुक्त वस्तु बन जाती हैं। सभी मुक्त वस्तुओं को मुक्त वस्तुओं की सूची में रखा गया है।

कोड का प्रवाह

शर्तें:

• WKS GC: वर्कस्टेशन मोड में कचरा संग्रह
• SVR GC: सर्वर मोड कचरा संग्रह

क्रियात्मक व्यवहार

WKS जीसी समानांतर कचरा संग्रह के बिना

1. उपयोगकर्ता थ्रेड ने इसके लिए आवंटित सभी मेमोरी का उपयोग किया और कचरा कलेक्टर को कॉल किया।
2. कलेक्टर सभी प्रबंधित थ्रेड्स को निलंबित करने के लिए SuspendEE को SuspendEE ।
3. कलेक्टर सफाई के लिए एक पीढ़ी चुनता है।
4. वस्तुओं का अंकन शुरू होता है।
5. कलेक्टर नियोजन चरण में जाता है और संपीड़न की आवश्यकता निर्धारित करता है।
6. यदि आवश्यक हो, तो कलेक्टर ऑब्जेक्ट्स को स्थानांतरित करता है और संपीड़न करता है। एक अन्य मामले में, यह सिर्फ सफाई करता है।
7. कलेक्टर प्रबंधित थ्रेड्स को पुनरारंभ करने के लिए RestartEE को कॉल RestartEE है।
8. उपयोगकर्ता सूत्र काम करना जारी रखते हैं।

WKS जीसी समानांतर कचरा संग्रह के साथ

यह एल्गोरिथ्म पृष्ठभूमि कचरा संग्रह का वर्णन करता है।

1. उपयोगकर्ता थ्रेड ने इसके लिए आवंटित सभी मेमोरी का उपयोग किया और कचरा कलेक्टर को कॉल किया।
2. कलेक्टर सभी प्रबंधित थ्रेड्स को निलंबित करने के लिए SuspendEE को SuspendEE ।
3. कलेक्टर निर्धारित करता है कि पृष्ठभूमि कचरा संग्रह चलाना है या नहीं।
4. यदि हां, तो पृष्ठभूमि कचरा संग्रह धागा सक्रिय हो गया है। यह थ्रेड RestartEE को प्रबंधित थ्रेड्स को फिर से शुरू करने के लिए कहता है।
5. प्रबंधित प्रक्रियाओं के लिए मेमोरी का आवंटन पृष्ठभूमि कचरा संग्रह के रूप में एक ही समय में जारी है।
6. एक उपयोगकर्ता धागा इसके लिए आवंटित सभी मेमोरी का उपयोग कर सकता है और पंचांग कचरा संग्रह (जिसे उच्च-प्राथमिकता कचरा संग्रह भी कहा जाता है) शुरू कर सकता है। यह समानांतर कचरा संग्रह के बिना वर्कस्टेशन मोड में उसी तरह चलता है।
7. बैकग्राउंड कचरा संग्रह SuspendEE को पूरा करने के लिए फिर से RestartEE को बुलाता है, और फिर RestartEE को कॉल करता है RestartEE यूजर थ्रेड्स के साथ एक समानांतर सफाई शुरू कर सके।
8. पृष्ठभूमि कचरा संग्रह पूरा हो गया है।

समानांतर कचरा संग्रहण के बिना एसवीआर जीसी

1. उपयोगकर्ता थ्रेड ने इसके लिए आवंटित सभी मेमोरी का उपयोग किया और कचरा कलेक्टर को कॉल किया।
2. सर्वर-मोड कचरा संग्रह थ्रेड सक्रिय होते हैं और प्रबंधित थ्रेड्स के निष्पादन को रोकने के लिए SuspendEE का कारण SuspendEE ।
3. सर्वर मोड में कचरा संग्रह स्ट्रीम समान कचरा संग्रह के बिना वर्कस्टेशन मोड में समान संचालन करते हैं।
4. सर्वर-मोड कचरा संग्रह थ्रेड प्रबंधित थ्रेड प्रारंभ करने के लिए RestartEE को आमंत्रित RestartEE है।
5. उपयोगकर्ता सूत्र काम करना जारी रखते हैं।

समानांतर कचरा संग्रहण के साथ एसवीआर जीसी

एल्गोरिथ्म वर्कस्टेशन मोड में समानांतर कचरा संग्रह के मामले में ही है, सर्वर थ्रेड्स में केवल गैर-फोनन संग्रह किया जाता है।

भौतिक वास्तुकला

यह अनुभाग आपको कोड प्रवाह को समझने में मदद करेगा।

जब उपयोगकर्ता थ्रेड मेमोरी से बाहर निकलता है, तो वह try_allocate_more_space फ़ंक्शन का उपयोग करके निशुल्क स्थान प्राप्त कर सकता है।

जब आप कचरा संग्रहकर्ता को शुरू करने की आवश्यकता होती है, तो try_allocate_more_space फ़ंक्शन, try_allocate_more_space कॉल करता है।

यदि वर्कस्टेशन मोड में कचरा संग्रह समानांतर नहीं है, तो GarbageCollectGeneration को उपयोगकर्ता थ्रेड में निष्पादित किया जाता है जिसे गारबेज कलेक्टर कहा जाता है। कोड स्ट्रीम इस प्रकार है:

  GarbageCollectGeneration() { SuspendEE(); garbage_collect(); RestartEE(); } garbage_collect() { generation_to_condemn(); gc1(); } gc1() { mark_phase(); plan_phase(); } plan_phase() { //   ,   //    if (compact) { relocate_phase(); compact_phase(); } else make_free_lists(); } 

यदि कार्यस्थान मोड (डिफ़ॉल्ट रूप से) में समानांतर कचरा संग्रह किया जाता है, तो पृष्ठभूमि कचरा संग्रह के लिए कोड प्रवाह इस तरह दिखता है:

  GarbageCollectGeneration() { SuspendEE(); garbage_collect(); RestartEE(); } garbage_collect() { generation_to_condemn(); //     //      do_background_gc(); } do_background_gc() { init_background_gc(); start_c_gc (); //           . wait_to_proceed(); } bgc_thread_function() { while (1) { //    //  gc1(); } } gc1() { background_mark_phase(); background_sweep(); } 

संसाधन लिंक

• .NET CLR GC कार्यान्वयन
• कचरा संग्रह पुस्तिका: स्वचालित स्मृति प्रबंधन की कला
• कचरा संग्रह (विकिपीडिया)
• प्रो .NET मेमोरी मैनेजमेंट