कचरा संग्रहण (कंप्यूटर विज्ञान)

From alpha
Jump to navigation Jump to search
This article is about garbage collection in memory management. For garbage collection in a solid-state drive, see garbage collection (SSD).
For other uses, see garbage collection (disambiguation).

लिस्प (प्रोग्रामिंग भाषा) में कचरा संग्रहण को रोकें और कॉपी करें:[1]मेमोरी को कार्यशील और मुक्त मेमोरी में विभाजित किया गया है; पूर्व में नई वस्तुएँ आवंटित की जाती हैं। जब यह भर जाता है (चित्रित), कचरा संग्रहण किया जाता है: अभी भी उपयोग में आने वाली सभी डेटा संरचनाएं पॉइंटर ट्रेसिंग द्वारा स्थित होती हैं और मुक्त मेमोरी में लगातार स्थानों पर कॉपी की जाती हैं।
उसके बाद, कार्यशील मेमोरी सामग्री को संपीड़ित प्रतिलिपि के पक्ष में छोड़ दिया जाता है, और कार्यशील और मुक्त मेमोरी की भूमिका का आदान-प्रदान किया जाता है (चित्रित)।

कंप्यूटर विज्ञान में, कचरा संग्रहण (जीसी) स्वचालित मेमोरी प्रबंधन का एक रूप है। कचरा संग्रहकर्ता उस मेमोरी को पुनः प्राप्त करने का प्रयास करता है जिसे प्रोग्राम द्वारा आवंटित किया गया था, लेकिन अब संदर्भित नहीं किया गया है; ऐसी मेमोरी को कचरा (कंप्यूटर विज्ञान) कहा जाता है। कचरा संग्रह का आविष्कार अमेरिकी कंप्यूटर वैज्ञानिक जॉन मैक्कार्थी (कंप्यूटर वैज्ञानिक) द्वारा 1959 के आसपास लिस्प (प्रोग्रामिंग भाषा) में मैन्युअल मेमोरी प्रबंधन को सरल बनाने के लिए किया गया था।[2]

कचरा संग्रह प्रोग्रामर को मैन्युअल मेमोरी प्रबंधन करने से राहत देता है, जहां प्रोग्रामर निर्दिष्ट करता है कि किन वस्तुओं को डी-आवंटित करना है और मेमोरी सिस्टम में वापस लौटना है और ऐसा कब करना है।[3] अन्य समान तकनीकों में स्टैक-आधारित मेमोरी आवंटन, क्षेत्र अनुमान, और मेमोरी स्वामित्व और उनके संयोजन शामिल हैं। कचरा संग्रहण में प्रोग्राम के कुल प्रसंस्करण समय का एक महत्वपूर्ण हिस्सा लग सकता है, और परिणामस्वरूप कंप्यूटर का प्रदर्शन प्रभावित हो सकता है।

मेमोरी के अलावा अन्य संसाधन, जैसे नेटवर्क सॉकेट, डेटाबेस हैंडल (कंप्यूटिंग) एस, विंडो (कंप्यूटिंग) एस, फ़ाइल (कंप्यूटिंग) डिस्क्रिप्टर, और डिवाइस डिस्क्रिप्टर, आमतौर पर कचरा संग्रहण द्वारा प्रबंधित नहीं किए जाते हैं, बल्कि अन्य विधि (कंप्यूटर प्रोग्रामिंग) द्वारा प्रबंधित किए जाते हैं। s (उदाहरण के लिए विध्वंसक (कंप्यूटर प्रोग्रामिंग) s)। ऐसे कुछ तरीके मेमोरी को डी-आवंटित भी करते हैं।

सिंहावलोकन

कई प्रोग्रामिंग भाषाओं को कचरा संग्रहण की आवश्यकता होती है, या तो भाषा विनिर्देश के भाग के रूप में (उदाहरण के लिए, आरपीएल (प्रोग्रामिंग भाषा), जावा (प्रोग्रामिंग भाषा), सी शार्प (प्रोग्रामिंग भाषा)|सी#, डी (प्रोग्रामिंग भाषा),[4]जाओ (प्रोग्रामिंग भाषा), और अधिकांश स्क्रिप्टिंग भाषाएं) या व्यावहारिक कार्यान्वयन के लिए प्रभावी ढंग से (उदाहरण के लिए, लैम्ब्डा कैलकुलस जैसी औपचारिक भाषाएं)[citation needed]. इन्हें कचरा एकत्रित करने वाली भाषाएँ कहा जाता है। अन्य भाषाएँ, जैसे C (प्रोग्रामिंग भाषा) और C++, मैन्युअल मेमोरी प्रबंधन के साथ उपयोग के लिए डिज़ाइन की गई थीं, लेकिन कचरा-एकत्रित कार्यान्वयन उपलब्ध हैं। कुछ भाषाएँ, जैसे Ada (प्रोग्रामिंग भाषा), Modula-3, और C++/CLI, एकत्रित और मैन्युअल रूप से प्रबंधित ऑब्जेक्ट के लिए अलग-अलग हीप (डेटा संरचना) का उपयोग करके कचरा संग्रहण और मैन्युअल मेमोरी प्रबंधन दोनों को एक ही एप्लिकेशन में सह-अस्तित्व में रखने की अनुमति देती हैं। . फिर भी अन्य, जैसे डी (प्रोग्रामिंग भाषा), कचरा-संग्रहित होते हैं लेकिन उपयोगकर्ता को गति की आवश्यकता होने पर वस्तुओं को मैन्युअल रूप से हटाने या यहां तक ​​कि कचरा संग्रह को पूरी तरह से अक्षम करने की अनुमति देते हैं।

हालाँकि कई भाषाएँ GC को अपने संकलक और रनटाइम सिस्टम में एकीकृत करती हैं, पोस्ट-हॉक GC सिस्टम भी मौजूद हैं, जैसे स्वचालित संदर्भ गणना (ARC)। इनमें से कुछ पोस्ट-हॉक जीसी प्रणालियों को पुनर्संकलन की आवश्यकता नहीं होती है। पोस्ट-हॉक जीसी को सामान्य जीसी से अलग करने के लिए कभी-कभी कूड़े का संग्रह भी कहा जाता है।[5]

लाभ

जीसी प्रोग्रामर को मेमोरी को मैन्युअल रूप से डी-आवंटित करने से मुक्त करता है। यह कुछ प्रकार के बग (सॉफ़्टवेयर) से बचने में मदद करता है:

  • लटकता हुआ सूचक ्स, जो तब होता है जब मेमोरी का एक टुकड़ा मुक्त हो जाता है जबकि इसमें अभी भी सूचक (कंप्यूटर प्रोग्रामिंग) होते हैं, और उन पॉइंटर्स में से एक डीरेफ़रेंस ऑपरेटर होता है। तब तक मेमोरी को अप्रत्याशित परिणामों के साथ किसी अन्य उपयोग के लिए पुनः सौंपा जा चुका होगा।
  • डबल फ्री बग, जो तब होते हैं जब प्रोग्राम मेमोरी के उस क्षेत्र को मुक्त करने का प्रयास करता है जो पहले ही मुक्त हो चुका है, और शायद पहले से ही फिर से आवंटित किया गया है।
  • कुछ प्रकार की स्मृति रिसाव , जिसमें प्रोग्राम उन वस्तुओं द्वारा कब्जा की गई मेमोरी को मुक्त करने में विफल रहता है जो पहुंच से बाहर हो गई हैं, जिससे मेमोरी समाप्त हो सकती है।[6]


नुकसान

जीसी कंप्यूटिंग संसाधनों का उपयोग यह तय करने के लिए करता है कि कौन सी मेमोरी खाली करनी है। इसलिए, स्रोत कोड में ऑब्जेक्ट जीवनकाल को मैन्युअल रूप से एनोटेट न करने की सुविधा के लिए जुर्माना ओवरहेड (कंप्यूटिंग) है, जो प्रोग्राम के प्रदर्शन को ख़राब कर सकता है।[7]2005 के एक सहकर्मी-समीक्षित पेपर ने निष्कर्ष निकाला कि जीसी को इस ओवरहेड की भरपाई करने और आदर्शीकृत स्पष्ट मेमोरी प्रबंधन का उपयोग करके उसी प्रोग्राम के समान तेज़ प्रदर्शन करने के लिए पांच गुना मेमोरी की आवश्यकता है। हालाँकि तुलना एक ओरेकल मशीन का उपयोग करके डीलोकेशन कॉल डालने से उत्पन्न प्रोग्राम से की जाती है, जिसे एक प्रोफाइलर के तहत चलाए गए प्रोग्राम से निशान एकत्र करके कार्यान्वित किया जाता है, और प्रोग्राम केवल प्रोग्राम के एक विशेष निष्पादन के लिए सही है।[8]स्मृति पदानुक्रम प्रभावों के साथ अंतःक्रिया इस ओवरहेड को उन परिस्थितियों में असहनीय बना सकती है जिनकी भविष्यवाणी करना या नियमित परीक्षण में पता लगाना कठिन है। सबसे वांछित सुविधा होने के बावजूद, iOS में कचरा संग्रहण को न अपनाने के लिए Apple द्वारा प्रदर्शन पर प्रभाव को एक कारण बताया गया था।[9]

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

रणनीतियाँ

ट्रेसिंग

Main article: Tracing garbage collection

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

संदर्भ गिनती

Main article: Reference counting

संदर्भ गिनती कचरा संग्रह वह है जहां प्रत्येक वस्तु में उसके संदर्भों की संख्या की गिनती होती है। कूड़े की पहचान शून्य की संदर्भ संख्या होने से की जाती है। किसी ऑब्जेक्ट का संदर्भ बनाते समय उसकी संदर्भ संख्या बढ़ जाती है, और संदर्भ नष्ट होने पर घट जाती है। जब गिनती शून्य तक पहुंच जाती है, तो ऑब्जेक्ट की मेमोरी पुनः प्राप्त हो जाती है।[10]

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

संदर्भ गणना के कई नुकसान हैं; इसे आम तौर पर अधिक परिष्कृत एल्गोरिदम द्वारा हल या कम किया जा सकता है:

चक्र
यदि दो या दो से अधिक वस्तुएं एक-दूसरे को संदर्भित करती हैं, तो वे एक चक्र बना सकते हैं जिससे उनमें से किसी को भी एकत्र नहीं किया जाएगा क्योंकि उनके पारस्परिक संदर्भ कभी भी उनकी संदर्भ संख्या को शून्य नहीं होने देते हैं। संदर्भ गणना का उपयोग करने वाली कुछ कचरा संग्रहण प्रणालियाँ (जैसे कि सीपीथॉन में) इस समस्या से निपटने के लिए विशिष्ट चक्र-पहचान एल्गोरिदम का उपयोग करती हैं।[11]एक अन्य रणनीति बैकपॉइंटर्स के लिए कमजोर संदर्भों का उपयोग करना है जो चक्र बनाते हैं। संदर्भ गिनती के तहत, एक कमजोर संदर्भ एक ट्रेसिंग कचरा संग्रहकर्ता के तहत एक कमजोर संदर्भ के समान है। यह एक विशेष संदर्भ वस्तु है जिसके अस्तित्व से संदर्भित वस्तु की संदर्भ संख्या में वृद्धि नहीं होती है। इसके अलावा, एक कमजोर संदर्भ इस मायने में सुरक्षित है कि जब संदर्भित वस्तु कचरा बन जाती है, तो इसका कोई भी कमजोर संदर्भ लटके रहने की बजाय लुप्त हो जाता है, जिसका अर्थ है कि यह एक पूर्वानुमानित मूल्य में बदल जाता है, जैसे कि शून्य संदर्भ।
स्पेस ओवरहेड (संदर्भ गणना)
संदर्भ गणना के लिए प्रत्येक ऑब्जेक्ट को उसकी संदर्भ गणना संग्रहीत करने के लिए स्थान आवंटित करने की आवश्यकता होती है। गिनती को ऑब्जेक्ट की मेमोरी के बगल में या कहीं और साइड टेबल में संग्रहीत किया जा सकता है, लेकिन किसी भी स्थिति में, प्रत्येक संदर्भ-गिनती वाली वस्तु को अपनी संदर्भ गिनती के लिए अतिरिक्त भंडारण की आवश्यकता होती है। एक अहस्ताक्षरित पॉइंटर के आकार के साथ मेमोरी स्पेस का उपयोग आमतौर पर इस कार्य के लिए किया जाता है, जिसका अर्थ है कि प्रत्येक ऑब्जेक्ट के लिए 32 या 64 बिट्स रेफरेंस काउंट स्टोरेज आवंटित किया जाना चाहिए। कुछ प्रणालियों पर, ऑब्जेक्ट की मेमोरी के अप्रयुक्त क्षेत्रों में संदर्भ गणना को संग्रहीत करने के लिए टैग किए टैग किया गया सूचक का उपयोग करके इस ओवरहेड को कम करना संभव हो सकता है। अक्सर, एक आर्किटेक्चर वास्तव में प्रोग्राम को मेमोरी पतों की पूरी श्रृंखला तक पहुंचने की अनुमति नहीं देता है जिसे उसके मूल सूचक आकार में संग्रहीत किया जा सकता है; पते में उच्च बिट्स की निश्चित संख्या को या तो अनदेखा कर दिया जाता है या शून्य होना आवश्यक है। यदि किसी ऑब्जेक्ट में किसी निश्चित स्थान पर विश्वसनीय रूप से पॉइंटर है, तो संदर्भ गणना पॉइंटर के अप्रयुक्त बिट्स में संग्रहीत की जा सकती है। उदाहरण के लिए, उद्देश्य सी में प्रत्येक ऑब्जेक्ट की मेमोरी की शुरुआत में उसके वर्ग (कंप्यूटर प्रोग्रामिंग) के लिए एक पॉइंटर होता है; iOS 7 का उपयोग करते हुए ARM64 आर्किटेक्चर पर, इस क्लास पॉइंटर के 19 अप्रयुक्त बिट्स का उपयोग ऑब्जेक्ट की संदर्भ गणना को संग्रहीत करने के लिए किया जाता है।[12][13]
स्पीड ओवरहेड (वृद्धि/कमी)
सरल कार्यान्वयन में, संदर्भ के प्रत्येक असाइनमेंट और दायरे से बाहर होने वाले प्रत्येक संदर्भ को अक्सर एक या अधिक संदर्भ काउंटरों के संशोधन की आवश्यकता होती है। हालाँकि, एक सामान्य मामले में जब किसी संदर्भ को बाहरी स्कोप वैरिएबल से आंतरिक स्कोप वैरिएबल में कॉपी किया जाता है, जैसे कि आंतरिक वैरिएबल का जीवनकाल बाहरी वैरिएबल के जीवनकाल से घिरा होता है, तो संदर्भ वृद्धि को समाप्त किया जा सकता है। बाहरी चर संदर्भ का स्वामी है। प्रोग्रामिंग भाषा C++ में, इस तकनीक को आसानी से लागू किया जाता है और इसके उपयोग से प्रदर्शित किया जाता है const संदर्भ। C++ में संदर्भ गणना आमतौर पर स्मार्ट सूचक ्स का उपयोग करके कार्यान्वित की जाती है[14]जिनके कंस्ट्रक्टर, डिस्ट्रक्टर और असाइनमेंट ऑपरेटर संदर्भों का प्रबंधन करते हैं। एक स्मार्ट पॉइंटर को एक फ़ंक्शन के संदर्भ में पारित किया जा सकता है, जो एक नए स्मार्ट पॉइंटर की प्रतिलिपि बनाने की आवश्यकता से बचाता है (जो फ़ंक्शन में प्रवेश पर संदर्भ गिनती बढ़ाएगा और बाहर निकलने पर इसे कम कर देगा)। इसके बजाय फ़ंक्शन को स्मार्ट पॉइंटर का संदर्भ प्राप्त होता है जो सस्ते में तैयार किया जाता है। संदर्भ गणना की डॉयचे-बॉब्रो विधि इस तथ्य पर आधारित है कि अधिकांश संदर्भ गणना अपडेट वास्तव में स्थानीय चर में संग्रहीत संदर्भों द्वारा उत्पन्न होते हैं। यह इन संदर्भों को नजरअंदाज करता है, केवल ढेर में संदर्भों की गिनती करता है, लेकिन संदर्भ संख्या शून्य वाली किसी वस्तु को हटाने से पहले, सिस्टम को स्टैक के स्कैन के साथ सत्यापित करना होगा और पंजीकृत करना होगा कि इसका कोई अन्य संदर्भ अभी भी मौजूद नहीं है। काउंटर अपडेट पर ओवरहेड में एक और पर्याप्त कमी लेवानोनी और इरेज़ पेट्रैंक द्वारा शुरू किए गए अपडेट कोलेसिंग द्वारा प्राप्त की जा सकती है।[15][16]एक सूचक पर विचार करें कि निष्पादन के दिए गए अंतराल में कई बार अद्यतन किया जाता है। यह सबसे पहले किसी वस्तु की ओर इशारा करता है O1, फिर किसी वस्तु पर O2, और इसी तरह अंतराल के अंत तक यह किसी वस्तु की ओर इशारा करता है On. एक संदर्भ गिनती एल्गोरिदम आम तौर पर निष्पादित होगा rc(O1)--, rc(O2)++, rc(O2)--, rc(O3)++, rc(O3)--, ..., rc(On)++. लेकिन इनमें से अधिकतर अपडेट अनावश्यक हैं। अंतराल के अंत में संदर्भ गणना का उचित मूल्यांकन करने के लिए यह प्रदर्शन करने के लिए पर्याप्त है rc(O1)-- और rc(On)++. लेवानोनी और पेट्रैंक ने विशिष्ट जावा बेंचमार्क में 99% से अधिक काउंटर अपडेट के उन्मूलन को मापा।
परमाणुता की आवश्यकता होती है
जब थ्रेड (कंप्यूटिंग) वातावरण में उपयोग किया जाता है, तो इन संशोधनों (वृद्धि और कमी) को तुलना-और-स्वैप जैसे परमाणु संचालन की आवश्यकता हो सकती है, कम से कम किसी भी ऑब्जेक्ट के लिए जो साझा किया जाता है, या संभावित रूप से कई थ्रेड्स के बीच साझा किया जाता है। मल्टीप्रोसेसर पर परमाणु संचालन महंगा है, और यदि उन्हें सॉफ्टवेयर एल्गोरिदम के साथ अनुकरण करना हो तो और भी महंगा है। प्रति-थ्रेड या प्रति-सीपीयू संदर्भ गणना जोड़कर और वैश्विक संदर्भ गणना तक केवल तभी पहुंच कर इस समस्या से बचना संभव है जब स्थानीय संदर्भ गणना शून्य हो जाती है या नहीं रह जाती है (या, वैकल्पिक रूप से, संदर्भ गणना के बाइनरी ट्री का उपयोग करके, या यहां तक ​​कि वैश्विक संदर्भ गिनती न होने के बदले में नियतात्मक विनाश को छोड़ देना), लेकिन यह महत्वपूर्ण मेमोरी ओवरहेड जोड़ता है और इस प्रकार केवल विशेष मामलों में उपयोगी होता है (उदाहरण के लिए, लिनक्स कर्नेल मॉड्यूल की संदर्भ गिनती में इसका उपयोग किया जाता है) ). लेवानोनी और पेट्रैंक द्वारा समेकन को अद्यतन करें[15][16]राइट-बैरियर से सभी परमाणु संचालन को खत्म करने के लिए इसका उपयोग किया जा सकता है। प्रोग्राम निष्पादन के दौरान प्रोग्राम थ्रेड द्वारा काउंटरों को कभी भी अपडेट नहीं किया जाता है। उन्हें केवल कलेक्टर द्वारा संशोधित किया जाता है जो बिना किसी सिंक्रनाइज़ेशन के एकल अतिरिक्त थ्रेड के रूप में निष्पादित होता है। इस पद्धति का उपयोग समानांतर कार्यक्रमों के लिए स्टॉप-द-वर्ल्ड तंत्र के रूप में और समवर्ती संदर्भ गिनती कलेक्टर के साथ भी किया जा सकता है।
वास्तविक समय नहीं
संदर्भ गिनती के सरल कार्यान्वयन आम तौर पर वास्तविक समय व्यवहार प्रदान नहीं करते हैं, क्योंकि कोई भी सूचक असाइनमेंट संभावित रूप से कुल आवंटित मेमोरी आकार से बंधे कई ऑब्जेक्ट्स को पुनरावर्ती रूप से मुक्त कर सकता है जबकि थ्रेड अन्य कार्य करने में असमर्थ है . अतिरिक्त ओवरहेड की कीमत पर, गैर-संदर्भित वस्तुओं को अन्य थ्रेड्स को मुक्त करने का काम सौंपकर इस समस्या से बचना संभव है।

पलायन विश्लेषण

Main article: Escape analysis

एस्केप विश्लेषण एक संकलन-समय तकनीक है जो [[ढेर आवंटन]] को स्टैक आवंटन में परिवर्तित कर सकती है, जिससे किए जाने वाले कचरा संग्रहण की मात्रा कम हो जाती है। यह विश्लेषण यह निर्धारित करता है कि किसी फ़ंक्शन के अंदर आवंटित वस्तु उसके बाहर पहुंच योग्य है या नहीं। यदि कोई फ़ंक्शन-स्थानीय आवंटन किसी अन्य फ़ंक्शन या थ्रेड के लिए पहुंच योग्य पाया जाता है, तो आवंटन को भागने के लिए कहा जाता है और स्टैक पर नहीं किया जा सकता है। अन्यथा, ऑब्जेक्ट को सीधे स्टैक पर आवंटित किया जा सकता है और जब फ़ंक्शन वापस आता है, तो हीप और संबंधित मेमोरी प्रबंधन लागतों को दरकिनार करते हुए जारी किया जा सकता है।[17]


उपलब्धता

सामान्यतया, उच्च-स्तरीय प्रोग्रामिंग भाषा|उच्च-स्तरीय प्रोग्रामिंग भाषाओं में मानक सुविधा के रूप में कचरा संग्रहण होने की अधिक संभावना होती है। कुछ भाषाओं में कचरा संग्रह में अंतर्निहित कमी है, इसे लाइब्रेरी के माध्यम से जोड़ा जा सकता है, जैसे सी और सी++ के लिए बोहेम कचरा संग्रहकर्ता के साथ।

अधिकांश कार्यात्मक प्रोग्रामिंग भाषाएं, जैसे एमएल (प्रोग्रामिंग भाषा), हास्केल, और एपीएल (प्रोग्रामिंग भाषा) में कचरा संग्रहण अंतर्निहित है। लिस्प (प्रोग्रामिंग भाषा) पहली कार्यात्मक प्रोग्रामिंग भाषा और कचरा पेश करने वाली पहली भाषा दोनों के रूप में विशेष रूप से उल्लेखनीय है। संग्रह।[18]

अन्य गतिशील भाषाएँ, जैसे रूबी (प्रोग्रामिंग भाषा) और जूलिया (प्रोग्रामिंग भाषा) (लेकिन संस्करण 5.3 से पहले पर्ल 5 या PHP नहीं,[19]जो दोनों संदर्भ गिनती का उपयोग करते हैं), एकमा स्क्रिप्ट और ईसीएमएस्क्रिप्ट भी जीसी का उपयोग करते हैं। ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग भाषाएं जैसे स्मॉलटॉक, आरपीएल (प्रोग्रामिंग भाषा) और जावा (प्रोग्रामिंग भाषा) आमतौर पर एकीकृत कचरा संग्रहण प्रदान करती हैं। उल्लेखनीय अपवाद C++ और डेल्फ़ी (प्रोग्रामिंग भाषा) हैं, जिनमें डिस्ट्रक्टर (कंप्यूटर प्रोग्रामिंग) हैं।

बुनियादी

बेसिक और लोगो (प्रोग्रामिंग भाषा) ने अक्सर स्ट्रिंग और सूचियों जैसे चर-लंबाई डेटा प्रकारों के लिए कचरा संग्रहण का उपयोग किया है, ताकि प्रोग्रामर पर मेमोरी प्रबंधन विवरण का बोझ न पड़े। अल्टेयर 8800 पर, कई स्ट्रिंग वेरिएबल्स और कम स्ट्रिंग स्पेस वाले प्रोग्राम कचरा संग्रहण के कारण लंबे समय तक रुक सकते हैं।[20]इसी प्रकार Applesoft BASIC दुभाषिया का कचरा संग्रहण एल्गोरिदम उच्चतम पते वाली स्ट्रिंग के लिए स्ट्रिंग डिस्क्रिप्टर को बार-बार स्कैन करता है ताकि इसे उच्च मेमोरी की ओर कॉम्पैक्ट किया जा सके, जिसके परिणामस्वरूप बिग ओ नोटेशन होता है।प्रदर्शन[21]और कुछ सेकंड से लेकर कुछ मिनटों तक कहीं भी रुकता है।[22]रैंडी विग्गिंटन द्वारा Applesoft BASIC के लिए एक प्रतिस्थापन कचरा संग्रहकर्ता ढेर के ऊपर से गुजरने वाले हर हिस्से में तारों के एक समूह की पहचान करता है, जिससे संग्रह का समय नाटकीय रूप से कम हो जाता है।[23]BASIC.System, 1983 में ProDOS के साथ जारी किया गया, BASIC के लिए एक विंडोिंग कचरा संग्रहकर्ता प्रदान करता है जो कई गुना तेज़ है।[24]


उद्देश्य-सी

जबकि ऑब्जेक्टिव-सी में परंपरागत रूप से कोई कचरा संग्रहण नहीं था, 2007 में ओएस एक्स 10.5 की रिलीज के साथ ऐप्पल इंक ने इन-हाउस विकसित रनटाइम कलेक्टर का उपयोग करके ऑब्जेक्टिव-सी 2.0 के लिए कचरा संग्रह पेश किया।[25]हालाँकि, 2012 में OS[26]इसके अलावा, मई 2015 से ऐप्पल ने ऐप स्टोर (आईओएस) में नए ओएस एक्स अनुप्रयोगों के लिए कचरा संग्रहण के उपयोग पर भी रोक लगा दी है।[27][28]आईओएस के लिए, एप्लिकेशन की प्रतिक्रियाशीलता और प्रदर्शन में समस्याओं के कारण कचरा संग्रहण कभी शुरू नहीं किया गया है;[9][29]इसके बजाय, iOS ARC का उपयोग करता है।[30][31]


सीमित वातावरण

सीमित संसाधनों के उपयोग पर बहुत सख्त नियंत्रण की सामान्य आवश्यकता के कारण एंबेडेड कंप्यूटिंग या रीयल-टाइम सिस्टम पर कचरा संग्रहण का उपयोग शायद ही कभी किया जाता है। हालाँकि, कई सीमित वातावरणों के साथ संगत कचरा संग्रहकर्ता विकसित किए गए हैं।[32]माइक्रोसॉफ्ट .NET माइक्रो फ्रेमवर्क, .NET नैनोफ्रेमवर्क[33]और जावा प्लेटफ़ॉर्म, माइक्रो एडिशन एम्बेडेड सॉफ़्टवेयर प्लेटफ़ॉर्म हैं, जिनमें अपने बड़े समकक्षों की तरह, कचरा संग्रहण शामिल है।

जावा

जावा जेडीके में उपलब्ध कचरा संग्रहकर्ताओं में शामिल हैं:

संकलन-समय उपयोग

संकलन-समय कचरा संग्रह स्थैतिक प्रोग्राम विश्लेषण का एक रूप है जो संकलन के दौरान ज्ञात आविष्कारों के आधार पर मेमोरी का पुन: उपयोग और पुनः दावा करने की अनुमति देता है।

कचरा संग्रहण के इस रूप का अध्ययन मरकरी (प्रोग्रामिंग भाषा) में किया गया है,[35]और 2011 में एप्पल के इकोसिस्टम (आईओएस और ओएस एक्स) में एलएलवीएम की ऑटोमैटिक रेफरेंस काउंटिंग (एआरसी) की शुरुआत के साथ इसका अधिक उपयोग देखा गया।[30][31][27]


वास्तविक समय प्रणाली

वृद्धिशील, समवर्ती और वास्तविक समय कचरा संग्रहकर्ता विकसित किए गए हैं, उदाहरण के लिए हेनरी बेकर (कंप्यूटर वैज्ञानिक) और हेनरी लिबरमैन द्वारा।[36][37][38]

बेकर के एल्गोरिदम में, आवंटन मेमोरी के एक ही क्षेत्र के आधे हिस्से में किया जाता है। जब यह आधा भर जाता है, तो एक कचरा संग्रहण किया जाता है जो जीवित वस्तुओं को दूसरे आधे हिस्से में ले जाता है और शेष वस्तुओं को स्पष्ट रूप से हटा दिया जाता है। चल रहे प्रोग्राम ('म्यूटेटर') को यह जांचना होगा कि वह जिस भी ऑब्जेक्ट का संदर्भ देता है वह सही आधे हिस्से में है, और यदि नहीं तो उसे पार ले जाएं, जबकि एक पृष्ठभूमि कार्य सभी ऑब्जेक्ट्स को ढूंढ रहा है।[39]

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

कुछ उच्च-स्तरीय भाषा कंप्यूटर आर्किटेक्चर में वास्तविक समय कचरा संग्रहण के लिए हार्डवेयर समर्थन शामिल है।

रीयल-टाइम कचरा संग्रहकर्ताओं के अधिकांश कार्यान्वयन ट्रेसिंग कचरा संग्रहण#रीयल-टाइम कचरा संग्रहण का उपयोग करते हैं।[citation needed] ऐसे वास्तविक समय कचरा संग्रहकर्ता वास्तविक समय ऑपरेटिंग सिस्टम के साथ उपयोग किए जाने पर कठिन वास्तविक समय की बाधाओं को पूरा करते हैं।[40]


यह भी देखें

संदर्भ

  1. ↑ Abelson, Harold; Sussman, Gerald Jay; Sussman, Julie (2016). Structure and Interpretation of Computer Programs (PDF) (2nd ed.). Cambridge, Massachusetts, USA: MIT Press. pp. 734–736.
  2. ↑ McCarthy, John (1960). "Recursive functions of symbolic expressions and their computation by machine, Part I". Communications of the ACM. 3 (4): 184–195. doi:10.1145/367177.367199. S2CID 1489409. Retrieved 2009-05-29.
  3. ↑ "What is garbage collection (GC) in programming?". SearchStorage. Retrieved 2022-10-17.
  4. ↑ "Overview – D Programming Language". dlang.org. Digital Mars. Retrieved 2014-07-29.
  5. ↑ "कचरा संग्रहण - डी प्रोग्रामिंग भाषा". dlang.org. Retrieved 2022-10-17.
  6. ↑ Microsoft. "Fundamentals of garbage collection | Microsoft Learn". Retrieved 2023-03-29.
  7. ↑ Zorn, Benjamin (1993-01-22). "The Measured Cost of Conservative Garbage Collection". Software: Practice and Experience. Department of Computer Science, University of Colorado Boulder. 23 (7): 733–756. CiteSeerX 10.1.1.14.1816. doi:10.1002/spe.4380230704. S2CID 16182444.
  8. ↑ Hertz, Matthew; Berger, Emery D. (2005). "Quantifying the Performance of Garbage Collection vs. Explicit Memory Management" (PDF). Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications - OOPSLA '05. pp. 313–326. doi:10.1145/1094811.1094836. ISBN 1-59593031-0. S2CID 6570650. Archived (PDF) from the original on 2012-04-02. Retrieved 2015-03-15.
  9. ↑ 9.0 9.1 "Developer Tools Kickoff – session 300" (PDF). WWDC 2011. Apple, Inc. 2011-06-24. Retrieved 2015-03-27.
  10. ↑ Microsoft. "Reference Counting Garbage Collection". Retrieved 2023-03-29.
  11. ↑ "Reference Counts". Extending and Embedding the Python Interpreter. 2008-02-21. Retrieved 2014-05-22.
  12. ↑ Ash, Mike. "Friday Q&A 2013-09-27: ARM64 and You". mikeash.com. Retrieved 2014-04-27.
  13. ↑ "Hamster Emporium: [objc explain]: Non-pointer isa". Sealiesoftware.com. 2013-09-24. Retrieved 2014-04-27.
  14. ↑ Pibinger, Roland (2005-05-03) [2005-04-17]. "RAII, Dynamic Objects, and Factories in C++".
  15. ↑ 15.0 15.1 Levanoni, Yossi; Petrank, Erez (2001). "An on-the-fly reference-counting garbage collector for java". Proceedings of the 16th ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications. OOPSLA 2001. pp. 367–380. doi:10.1145/504282.504309.
  16. ↑ 16.0 16.1 Levanoni, Yossi; Petrank, Erez (2006). "An on-the-fly reference-counting garbage collector for java". ACM Trans. Program. Lang. Syst. 28: 31–69. CiteSeerX 10.1.1.15.9106. doi:10.1145/1111596.1111597. S2CID 14777709.
  17. ↑ Salagnac, Guillaume; Yovine, Sergio; Garbervetsky, Diego (2005-05-24). "Fast Escape Analysis for Region-based Memory Management". Electronic Notes in Theoretical Computer Science. 131: 99–110. doi:10.1016/j.entcs.2005.01.026.
  18. ↑ Chisnall, David (2011-01-12). Influential Programming Languages, Part 4: Lisp.
  19. ↑ "PHP: Performance Considerations". php.net. Retrieved 2015-01-14.
  20. ↑ "Altair 8800 Basic 4.1 Reference Manual" (PDF). The Vintage Technology Digital Archive. April 1977. p. 108. Archived (PDF) from the original on 2021-06-29. Retrieved 2021-06-29.
  21. ↑ "I did some work to speed up string garbage collection under Applesoft..." Hacker News. Retrieved 2021-06-29.
  22. ↑ Little, Gary B. (1985). Inside the Apple IIc. Bowie, Md.: Brady Communications Co. p. 82. ISBN 0-89303-564-5. Retrieved 2021-06-29.
  23. ↑ "Fast Garbage Collection". Call-A.P.P.L.E.: 40–45. January 1981.
  24. ↑ Worth, Don (1984). Beneath Apple Pro DOS (PDF) (March 1985 printing ed.). Chatsworth, California, USA: Quality Software. pp. 2–6. ISBN 0-912985-05-4. Archived (PDF) from the original on 2008-12-03. Retrieved 2021-06-29.
  25. ↑ "Objective-C 2.0 Overview". Archived from the original on 2010-07-24.
  26. ↑ Siracusa, John (2011-07-20). "Mac OS X 10.7 Lion: the Ars Technica review".
  27. ↑ 27.0 27.1 "Apple says Mac app makers must transition to ARC memory management by May". AppleInsider. 2015-02-20.
  28. ↑ Cichon, Waldemar (2015-02-21). "App Store: Apple entfernt Programme mit Garbage Collection". Heise.de. Retrieved 2015-03-30.
  29. ↑ Silva, Precious (2014-11-18). "iOS 8 vs Android 5.0 Lollipop: Apple Kills Google with Memory Efficiency". International Business Times. Retrieved 2015-04-07.
  30. ↑ 30.0 30.1 Napier, Rob; Kumar, Mugunth (2012-11-20). iOS 6 Programming Pushing the Limit. John Wiley & Sons. ISBN 978-1-11844997-4. Retrieved 2015-03-30.
  31. ↑ 31.0 31.1 Cruz, José R. C. (2012-05-22). "Automatic Reference Counting on iOS". Dr. Dobbs. Archived from the original on 2020-05-16. Retrieved 2015-03-30.
  32. ↑ Fu, Wei; Hauser, Carl (2005). "A real-time garbage collection framework for embedded systems". Proceedings of the 2005 Workshop on Software and Compilers for Embedded Systems - SCOPES '05. pp. 20–26. doi:10.1145/1140389.1140392. ISBN 1-59593207-0. S2CID 8635481.
  33. ↑ ".NET nanoFramework".
  34. ↑ Tene, Gil; Iyengar, Balaji; Wolf, Michael (2011). "C4: the continuously concurrent compacting collector" (PDF). ISMM '11: Proceedings of the international symposium on Memory management. doi:10.1145/1993478. ISBN 978-1-45030263-0. Archived (PDF) from the original on 2017-08-09.
  35. ↑ Mazur, Nancy (May 2004). Compile-time garbage collection for the declarative language Mercury (PDF) (Thesis). Katholieke Universiteit Leuven. Archived (PDF) from the original on 2014-04-27.
  36. ↑ Huelsbergen, Lorenz; Winterbottom, Phil (1998). "Very concurrent mark-&-sweep garbage collection without fine-grain synchronization" (PDF). Proceedings of the First International Symposium on Memory Management - ISMM '98. pp. 166–175. doi:10.1145/286860.286878. ISBN 1-58113114-3. S2CID 14399427. Archived (PDF) from the original on 2008-05-13.
  37. ↑ "GC FAQ".
  38. ↑ Lieberman, Henry; Hewitt, Carl (1983). "A real-time garbage collector based on the lifetimes of objects". Communications of the ACM. 26 (6): 419–429. doi:10.1145/358141.358147. hdl:1721.1/6335. S2CID 14161480.
  39. ↑ Baker, Henry G. (1978). "List processing in real time on a serial computer". Communications of the ACM. 21 (4): 280–294. doi:10.1145/359460.359470. hdl:1721.1/41976. S2CID 17661259. see also description
  40. ↑ McCloskey; Bacon; Cheng; Grove (2008), Staccato: A Parallel and Concurrent Real-time Compacting Garbage Collector for Multiprocessors (PDF), archived (PDF) from the original on 2014-03-11


अग्रिम पठन


बाहरी संबंध

The Wikibook Memory Management has a page on the topic of: Garbage Collection
Retrieved from "https://alpha.indicwiki.in/index.php?title=कचरा_संग्रहण_(कंप्यूटर_विज्ञान)&oldid=232205"