यह सामान्य रूप से स्टैक्स के साथ दूर करने और स्मृति प्रबंधन के लिए हीप का उपयोग करने के लिए सिस्टम के लिए अधिक कुशल हो सकता है?

14

यह मुझे लगता है कि ढेर के साथ किया जा सकता है सब कुछ, ढेर के साथ किया जा सकता है, लेकिन ढेर के साथ किया जाने वाला सब कुछ ढेर के साथ नहीं किया जा सकता है। क्या वो सही है? फिर सादगी के लिए, और यहां तक कि अगर हम कुछ वर्कलोड के साथ प्रदर्शन की थोड़ी मात्रा खो देते हैं, तो क्या केवल एक मानक (यानी, ढेर) के साथ जाना बेहतर नहीं हो सकता है?

प्रतिरूपकता और प्रदर्शन के बीच व्यापार बंद के बारे में सोचें। मुझे पता है कि इस परिदृश्य का वर्णन करने का सबसे अच्छा तरीका नहीं है, लेकिन सामान्य तौर पर ऐसा लगता है कि बेहतर प्रदर्शन के लिए क्षमता होने पर भी समझ और डिजाइन की सरलता एक बेहतर विकल्प हो सकती है।

memory

— डार्क टेम्पलर
स्रोत

1

सी और सी ++ में, आपको स्पष्ट रूप से मेमोरी को डीलॉलेट करने की आवश्यकता है जो कि ढेर पर आवंटित की गई थी। यह सरल नहीं है।

— user16764

मैंने एक C # कार्यान्वयन का उपयोग किया था प्रोफाइलिंग से पता चला था कि ढेर वस्तुओं को भयानक कचरा संग्रह के साथ ढेर-जैसे क्षेत्र में आवंटित किया गया था। मेरा हल? ले जाएँ सब कुछ संभव है (जैसे पाश चर, अस्थायी चर, आदि) लगातार ढेर स्मृति करने के लिए। बनाया कार्यक्रम 10x RAM खाओ और 10x गति से चलाओ।

— imallett

@IanMallett: मैं समस्या और समाधान के आपके स्पष्टीकरण को नहीं समझता। क्या आपके पास कहीं और जानकारी के साथ लिंक है? आमतौर पर मुझे स्टैक-आधारित आवंटन अधिक तेज़ लगता है।

— फ्रैंक हिलमैन

@FrankHileman की मूल समस्या यह थी: C # के कार्यान्वयन से मेरे पास बहुत कम कचरा संग्रहण की गति थी। "समाधान" सभी चरों को निरंतर बनाना था ताकि रनटाइम पर कोई मेमोरी ऑपरेशन न हो। मैंने कुछ समय पहले C # / XNA के विकास के बारे में एक राय लिखी थी, जो कुछ संदर्भों पर भी चर्चा करता है।

— imallett

@IanMallett: धन्यवाद। एक पूर्व C / C ++ डेवलपर के रूप में, जो इन दिनों ज्यादातर C # का उपयोग करता है, मेरा अनुभव काफी अलग रहा है। मुझे लगता है कि पुस्तकालय सबसे बड़ी समस्या हैं। ऐसा लगता है कि .net डेवलपर्स के लिए XBox360 प्लेटफॉर्म आधा बेक किया गया था। आमतौर पर जब मुझे जीसी की समस्या होती है, तो मैं पूलिंग में बदल जाता हूं। यह मदद करता है।

— फ्रैंक हिलमैन

30

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

प्रोग्रामिंग भाषा को सरल बनाने के लिए पूरी तरह से स्टैक से छुटकारा पाना गलत तरीका है IMO - एक बेहतर तरीका यह होगा कि मतभेदों को दूर किया जाए, कंपाइलर यह पता लगाए कि किस तरह के स्टोरेज का उपयोग करना है, जबकि प्रोग्रामर एक साथ अधिक डालता है- स्तर के निर्माण जो मनुष्यों के सोचने के तरीके के करीब हैं - और वास्तव में, उच्च स्तरीय भाषाएं जैसे सी #, जावा, पायथन आदि वास्तव में यही हैं। वे ढेर-आबंटित वस्तुओं और स्टैक-आवंटित प्राइमिटिव ('संदर्भ प्रकार' बनाम 'मूल्य प्रकार' के लिए .NET लोंगो में) के लिए लगभग समान सिंटैक्स प्रदान करते हैं, या तो पूरी तरह से पारदर्शी, या कुछ कार्यात्मक अंतरों के साथ जो आपको भाषा का उपयोग करने के लिए समझना चाहिए सही ढंग से (लेकिन आपको वास्तव में यह जानने की ज़रूरत नहीं है कि स्टैक और ढेर आंतरिक रूप से कैसे काम करते हैं)।

— tdammers
स्रोत

2

वाह यह अच्छा था :) वास्तव में संक्षिप्त और एक शुरुआत के लिए जानकारीपूर्ण!

— डार्क टेम्पलर

1

कई सीपीयू पर स्टैक को हार्डवेयर में संभाला जाता है, जो कि बाहर की भाषा का एक मुद्दा है, लेकिन यह रन टाइम में एक बड़ी भूमिका निभाता है।

— पैट्रिक ह्यूजेस

@ पैट्रिक ह्यूजेस: हाँ, लेकिन हीप हार्डवेयर में भी स्थित है, है ना?

— डार्क टेम्पलर

@Dark पैट्रिक शायद क्या कहना चाहता है कि स्टैक को प्रबंधित करने और स्टैक से / पर कुछ डालने या हटाने के विशेष निर्देशों के लिए x86 जैसे आर्किटेक्चर के पास विशेष रजिस्टर हैं। जो इसे काफी तेज बनाता है।

— फ़ूजएक्सएक्सएल

3

@ डॉनल फेलो: बिलकुल सच। लेकिन मुद्दा यह है कि ढेर और ढेर दोनों के पास अपने मजबूत और कमजोर बिंदु हैं, और तदनुसार उनका उपयोग करना सबसे कुशल कोड प्राप्त करेगा।

— tdammers

8

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

— DeadMG
स्रोत

जब आप कहते हैं कि आधुनिक मशीनों में स्टैक के लिए हार्डवेयर समर्थन है तो आपका क्या मतलब है? स्टैक ही हार्डवेयर में पहले से ही है, है ना?

— डार्क टेम्पलर

1

x86 में स्टैक से निपटने के लिए विशेष रजिस्टर और निर्देश हैं। x86 में ढेर के लिए कोई समर्थन नहीं है - ऐसी चीजें ओएस द्वारा बनाई गई हैं।

— पबबी

8

नहीं

सी ++ में स्टैक क्षेत्र तुलना में अविश्वसनीय रूप से तेज है। मुझे लगता है कि C ++ डेवलपर्स का कोई उपक्रम नहीं है, उस कार्यक्षमता को अक्षम करने के लिए खुला होगा।

C ++ के साथ, आपके पास विकल्प है और आपके पास नियंत्रण है। डिज़ाइनर विशेष रूप से उन विशेषताओं को प्रस्तुत करने के लिए इच्छुक नहीं थे जो महत्वपूर्ण निष्पादन समय या स्थान को जोड़ते थे।

उस चुनाव का अभ्यास करना

यदि आप एक लाइब्रेरी या प्रोग्राम बनाना चाहते हैं जिसके लिए जरूरी है कि हर वस्तु को गतिशील रूप से आवंटित किया जाए, तो आप ऐसा कर सकते हैं C ++ के साथ। यह अपेक्षाकृत धीमी गति से क्रियान्वित होता है, लेकिन आप तब 'प्रतिरूपता' कर सकते थे। हम में से बाकी के लिए, प्रतिरूपकता हमेशा वैकल्पिक होती है, इसे आवश्यकतानुसार प्रस्तुत करें क्योंकि अच्छे / तेज़ कार्यान्वयन के लिए दोनों की आवश्यकता होती है।

वैकल्पिक

अन्य भाषाएं हैं जिनके लिए आवश्यक है कि प्रत्येक वस्तु के लिए भंडारण ढेर पर बनाया जाए; यह काफी धीमा है, जैसे कि यह डिजाइन (वास्तविक दुनिया के कार्यक्रमों) को इस तरह से समझौता करता है जो दोनों (आईएमओ) को सीखने से भी बदतर है।

दोनों महत्वपूर्ण हैं, और C ++ आपको प्रत्येक दिए गए परिदृश्य के लिए प्रभावी रूप से दोनों का उपयोग करता है। यह कहने के बाद कि, C ++ भाषा आपके डिज़ाइन के लिए आदर्श नहीं हो सकती है, यदि आपके OP में ये कारक आपके लिए महत्वपूर्ण हैं (उदाहरण के लिए, उच्च स्तर की भाषाओं पर पढ़ें)।

— जस्टिन
स्रोत

ढेर वास्तव में स्टैक के समान गति है, लेकिन आवंटन के लिए विशेष हार्डवेयर समर्थन नहीं है। दूसरी ओर, ढेरों को तेज करने के तरीके हैं (कई स्थितियों के अधीन जो उन्हें विशेषज्ञ-केवल तकनीक बनाते हैं)।

— डोनल फैलो

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

— सुपरकैट

6

फिर सादगी के लिए, और यहां तक कि अगर हम कुछ वर्कलोड के साथ प्रदर्शन की थोड़ी मात्रा खो देते हैं, तो क्या केवल एक मानक (यानी, ढेर) के साथ जाना बेहतर नहीं हो सकता है?

वास्तव में प्रदर्शन हिट काफी होने की संभावना है!

जैसा कि दूसरों ने बताया है कि LIFO का पालन करने वाले डेटा के प्रबंधन के लिए स्टाॅक एक अत्यंत कुशल संरचना है (अंतिम में प्रथम) नियम। स्टैक पर मेमोरी आवंटन / फ्रीजिंग आमतौर पर सीपीयू पर रजिस्टर में बदलाव होता है। एक रजिस्टर बदलना लगभग हमेशा सबसे तेज़ संचालन में से एक है जो एक प्रोसेसर प्रदर्शन कर सकता है।

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

— चार्ल्स ई। ग्रांट
स्रोत

5

सिमूला ने हर चीज के लिए ढेर का इस्तेमाल किया। सब कुछ ढेर पर रखना हमेशा स्थानीय चर के लिए अप्रत्यक्ष के एक और स्तर को प्रेरित करता है, और यह कचरा कलेक्टर पर अतिरिक्त दबाव डालता है (आपको ध्यान रखना है कि कचरा कलेक्टर वास्तव में वापस चूसा है)। यह आंशिक रूप से क्यों Bjarne C ++ का आविष्कार किया।

— fredoverflow
स्रोत

तो मूल रूप से C ++ केवल हीप का उपयोग करता है?

— डार्क टेम्पलर

2

@ डार्क: क्या? नहीं। सिमूला में ढेर की कमी इसे बेहतर करने की प्रेरणा थी।

— fredoverflow

आह मैं देख रहा हूँ कि अब तुम्हारा क्या मतलब है! धन्यवाद +1 :)

— डार्क टेम्पलर

3

उदाहरण के लिए फ़ंक्शन कॉल से जुड़े मेटा-डेटा जैसे LIFO डेटा के लिए स्टैक बेहद कुशल हैं। स्टैक सीपीयू के निहित डिजाइन सुविधाओं का भी लाभ उठाता है। चूंकि इस स्तर पर प्रदर्शन एक प्रक्रिया में बाकी सभी चीजों के लिए मौलिक है, इसलिए उस स्तर पर "छोटे" हिट को बहुत व्यापक रूप से प्रचारित किया जाएगा। इसके अलावा, हीप मेमोरी ओएस द्वारा जंगम है, जो स्टैक के लिए घातक होगा। जबकि एक ढेर को ढेर में लागू किया जा सकता है, इसके लिए ओवरहेड की आवश्यकता होती है जो प्रक्रिया के हर टुकड़े को सबसे अधिक दानेदार स्तर पर सचमुच प्रभावित करेगा।

— kylben
स्रोत

2

आप कोड लिखने के संदर्भ में "कुशल" हो सकता है, लेकिन निश्चित रूप से आपकी सॉफ़्टवेयर दक्षता के संदर्भ में नहीं। स्टैक आवंटन अनिवार्य रूप से नि: शुल्क हैं (स्टैक पॉइंटर को स्थानांतरित करने के लिए केवल कुछ मशीन निर्देश लगते हैं और स्थानीय चर के लिए स्टैक पर आरक्षित स्थान)।

चूंकि स्टैक आवंटन में लगभग कोई समय नहीं लगता है, इसलिए बहुत कुशल ढेर पर भी आवंटन 100k (यदि 1M + नहीं) कई बार धीमा हो जाएगा।

अब कल्पना करें कि एक विशिष्ट एप्लिकेशन उपयोग करने वाले कितने स्थानीय चर और अन्य डेटा संरचनाएं हैं। हर एक छोटा "i" जिसे आप लूप काउंटर के रूप में उपयोग करते हैं, एक लाख गुना धीमा आवंटित किया जा रहा है।

यकीन है कि अगर हार्डवेयर काफी तेज है, तो आप एक ऐसा एप्लिकेशन लिख सकते हैं जो केवल ढेर का उपयोग करता है। लेकिन अब इमेजिंग यदि आप ढेर का फायदा उठाते हैं और उसी हार्डवेयर का उपयोग करते हैं तो आप किस तरह का एप्लिकेशन लिख सकते हैं।

— DXM
स्रोत

जब आप कहते हैं "कल्पना करें कि एक विशिष्ट एप्लिकेशन का उपयोग करने वाले कितने स्थानीय चर और अन्य डेटा संरचनाएं हैं" तो आप विशेष रूप से किन अन्य डेटा संरचनाओं का उल्लेख कर रहे हैं?

— डार्क टमप्लर

1

क्या मूल्य "100k" और "1M +" किसी तरह वैज्ञानिक हैं? या यह "बहुत कुछ" कहने का एक तरीका है?

— ब्रूनो रीस

@Bruno - IMHO 100K और 1M संख्या जो मैंने उपयोग की है वह वास्तव में एक बिंदु साबित करने के लिए रूढ़िवादी अनुमान है। यदि आप VS और C ++ से परिचित हैं, तो एक प्रोग्राम लिखें जो स्टैक पर 100 बाइट्स आवंटित करता है और एक ऐसा लिखें जो ढेर पर 100 बाइट्स आवंटित करता है। फिर डिससैसम व्यू पर स्विच करें और बस प्रत्येक आवंटन के लिए विधानसभा निर्देशों की संख्या की गणना करें। ढेर संचालन आम तौर पर विंडोज़ DLL में कई फ़ंक्शन कॉल होते हैं, बाल्टी और लिंक की गई सूची होती है और फिर वहाँ coalescing और अन्य एल्गोरिदम होते हैं। स्टैक के साथ, यह एक असेंबली इंस्ट्रक्शन "ऐड एस्प, 100" को उबाल सकता है ...

— डीएक्सएम ऑक्ट

2

"100k (यदि 1 एम +) समय धीमा नहीं है"? यह काफी अतिरंजित है। इसे परिमाण के दो क्रमों को धीमा होने दें, शायद तीन, लेकिन यही है। कम से कम, मेरा लिनक्स कोर i5 पर 6 सेकंड से कम समय में 100M हीप आवंटन (+ कुछ आसपास के निर्देश) करने में सक्षम है, जो प्रति आवंटन कुछ सौ निर्देशों से अधिक नहीं हो सकता है - वास्तव में, यह लगभग निश्चित रूप से कम है। अगर यह स्टैक की तुलना में परिमाण के छह आदेश हैं, तो ओएस के ढेर कार्यान्वयन के साथ कुछ गलत है। यकीन है कि विंडोज के साथ बहुत कुछ गलत है, लेकिन वह ...

— वामावर्त

1

मध्यस्थ शायद इस पूरे टिप्पणी धागे को मारने वाले हैं। तो यहाँ सौदा है, मैंने स्वीकार किया है कि वास्तविक संख्या मेरे से बाहर खींची गई थी .... लेकिन चलो सहमत हूँ कि कारक वास्तव में है, वास्तव में बड़ा है और अधिक टिप्पणी नहीं :)

— DXM

2

आपको "कचरा संग्रह फास्ट है, लेकिन एक स्टैक तेज़ है" में रुचि हो सकती है।

http://dspace.mit.edu/bitstream/handle/1721.1/6622/AIM-1462.ps.Z

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

ढेर-आवंटित "स्टैक फ्रेम" आउटपरफॉर्म हीप-आवंटित "स्टैक फ्रेम" निर्णायक रूप से।

— ब्रूस एडिगर
स्रोत

1

कॉल स्टैक ढेर पर कैसे काम कर रहा है? अनिवार्य रूप से, आपको हर कार्यक्रम में ढेर पर एक स्टैक आवंटित करना होगा, इसलिए ओएस + हार्डवेयर आपके लिए क्यों नहीं है?

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

— Pubby
स्रोत

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

— बेन

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

— इंगो

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

— बेन

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

— ingo

1

दोनों ढेर और ढेर की आवश्यकता है। वे विभिन्न स्थितियों में उपयोग किए जाते हैं, उदाहरण के लिए:

हीप आवंटन में एक सीमा होती है जिसका आकार ([0]) == आकार (एक [1]) होता है
स्टैक आबंटन की एक सीमा है कि साइज़ोफ (ए) संकलन-समय स्थिर है
हीप आवंटन लूप, ग्राफ़ आदि जटिल डेटा संरचनाएं कर सकता है
ढेर का आवंटन संकलन-समय के आकार के पेड़ कर सकते हैं
हीप को स्वामित्व की ट्रैकिंग की आवश्यकता होती है
स्टैक आवंटन और डीललैक्शन स्वचालित है
हीप मेमोरी को पॉइंटर्स के माध्यम से एक दायरे से दूसरे में आसानी से पास किया जा सकता है
स्टैक मेमोरी प्रत्येक फ़ंक्शन के लिए स्थानीय है और वस्तुओं को अपने जीवनकाल का विस्तार करने के लिए ऊपरी दायरे में ले जाने की आवश्यकता है (या अंदर के सदस्य के बजाय वस्तुओं के अंदर संग्रहीत)
हीप प्रदर्शन के लिए खराब है
ढेर बहुत जल्दी है
ढेर वस्तुओं को उन बिंदुओं के माध्यम से कार्यों से लौटाया जाता है जो स्वामित्व लेते हैं। या share_ptrs।
ढेर वस्तुओं को उन संदर्भों के माध्यम से कार्यों से लौटाया जाता है जो स्वामित्व नहीं लेते हैं।
हीप को हर नए मेल को सही तरह से डिलीट या डिलीट करने की आवश्यकता होती है []
स्टैक ऑब्जेक्ट RAII और कंस्ट्रक्टर आरंभीकरण सूची का उपयोग करते हैं
हीप ऑब्जेक्ट्स को फंक्शन के अंदर किसी भी पॉइंट पर इनिशियलाइज़ किया जा सकता है, और कंस्ट्रक्टर पैरामीटर का उपयोग नहीं किया जा सकता है
स्टैक ऑब्जेक्ट्स आरंभीकरण के लिए कंस्ट्रक्टर पैरामीटर का उपयोग करते हैं
हीप सरणियों का उपयोग करता है और सरणी आकार रनटाइम पर बदल सकता है
स्टैक एकल ऑब्जेक्ट के लिए है, और आकार संकलन-समय पर तय किया गया है

मूल रूप से तंत्र की तुलना बिल्कुल नहीं की जा सकती क्योंकि इतने सारे विवरण अलग-अलग हैं। उनके साथ एक ही बात आम है कि वे दोनों किसी न किसी तरह से स्मृति को संभालते हैं।

— टीपी 1
स्रोत

1

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

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

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

— supercat
स्रोत