मेमोरी के साथ काम करना (और अभी तक यह है)

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

सामान्य जानकारी

छोटा शैक्षिक कार्यक्रम

PHP में एक चर, जैसा कि यह था, दो भाग होते हैं: " नाम ", जो hash_table symbol_table में संग्रहीत होता है, और " मान ", जो ज़वल कंटेनर में संग्रहीत होता है।
यह तंत्र आपको कई चर बनाने की अनुमति देता है जो समान मूल्य को संदर्भित करते हैं, जो कुछ मामलों में आपको मेमोरी खपत को अनुकूलित करने की अनुमति देता है। यह व्यवहार में कैसा दिखता है यह बाद में लिखा जाएगा।

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

यह स्मृति के साथ काम करने के इन पहलुओं के बारे में है कि निम्नलिखित विवरण होगा। यह काफी मात्रा में निकला, लेकिन इसमें कुछ भी जटिल नहीं होगा और सब कुछ काफी सरल होगा, जाहिर है उदाहरणों के साथ।

स्मृति के साथ काम करने का पहला उदाहरण

शुरुआत के लिए, मेमोरी खपत विश्लेषण कैसे किया जाएगा, इसका एक मूल उदाहरण।
ऐसा करने के लिए, हमें कुछ सरल कार्यों ( func.php फ़ाइल) की आवश्यकता है:

<? php
फ़ंक्शन मेमोरीयूजेज ( $ उपयोग , $ base_memory_usage ) {
प्रिंटफ ( "बाइट्स भिन्न: % d \ n" , $ उपयोग - $ base_memory_usage ) ;
}
फंक्शन someBigValue ( ) {
वापसी str_repeat ( 'कुछ बड़े स्ट्रिंग' , 1024 ) ;
}
?>

और एक स्ट्रिंग के लिए मेमोरी खपत परीक्षण का एक सरल पहला उदाहरण:

<? php
शामिल ( 'func.php' ) ;
गूंज "स्ट्रिंग मेमोरी उपयोग परीक्षण। \ n \ n" ;
$ base_memory_usage = memory_get_usage ( ) ;
$ base_memory_usage = memory_get_usage ( ) ;

इको "स्टार्ट \ n" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

$ a = someBigValue ( ) ;

गूंज "स्ट्रिंग मूल्य बसे \ n" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a ) ;

गूंज "स्ट्रिंग मूल्य परेशान \ n" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
?>

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

कोड का परिणाम काफी स्पष्ट है:

स्ट्रिंग मेमोरी उपयोग परीक्षण।

प्रारंभ
बाइट्स अंतर: 0
स्ट्रिंग मूल्य बसे
बाइट्स अंतर: 15448
स्ट्रिंग मूल्य परेशान
बाइट्स अंतर: 0

एक ही उदाहरण, लेकिन परेशान ($ a) के बजाय हम $ a = null का उपयोग करते हैं ; :

प्रारंभ
बाइट्स अंतर: 0
स्ट्रिंग मूल्य बसे
बाइट्स अंतर: 15448
स्ट्रिंग मान शून्य करने के लिए सेट करें
बाइट्स अंतर: 76

जैसा कि आप देख सकते हैं, चर पूरी तरह से नष्ट नहीं हुआ था। इसके तहत एक और 76 बाइट्स आवंटित की गई हैं।
यह काफी सभ्य है, यह देखते हुए कि बूलियन, पूर्णांक, फ्लोट जैसे चरों के लिए समान राशि आवंटित की जाती है। यह चर मान के लिए आवंटित मेमोरी की मात्रा के बारे में नहीं है, लेकिन निर्दिष्ट चर के बारे में जानकारी संग्रहीत करने के लिए कुल स्मृति खपत के बारे में है (मूल्य और चर नाम के साथ ज़वल कंटेनर)।
इसलिए यदि आप एक असाइनमेंट के साथ मेमोरी को मुक्त करना चाहते हैं, तो यह बिल्कुल शून्य मान असाइन करना आवश्यक नहीं है। अभिव्यक्ति $ a = 10000; स्मृति खपत के लिए एक ही परिणाम देगा।

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

यदि अशांत () संभव है तो अशक्त असाइनमेंट का उपयोग क्यों करें?
एक असाइनमेंट एक असाइनमेंट है, (KO के लिए धन्यवाद), अर्थात्, एक चर का मूल्य बदलता है, तदनुसार, यदि एक नए मूल्य को कम मेमोरी की आवश्यकता होती है, तो इसे तुरंत मुक्त किया जाता है, हालांकि इसके लिए कम्प्यूटेशनल संसाधनों की आवश्यकता होती है (यद्यपि अपेक्षाकृत कम)।
unset () बदले में चर नाम और उसके मान के लिए आवंटित मेमोरी को मुक्त करता है।
अलग-अलग, यह इस तथ्य का उल्लेख करने योग्य है कि परेशान () और अशक्त असाइनमेंट चर संदर्भों के साथ बहुत अलग तरीके से काम करते हैं। Unset () केवल लिंक को नष्ट कर देगा, जबकि null असाइन करते समय चर नामों द्वारा संदर्भित मान को बदल देगा, इसलिए सभी चर शून्य मान को संदर्भित करेंगे।

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

$ unset_func_name = 'unset' ;
$ unset_func_name ( $ some_var ) ;

निष्क्रिय विचारों के लिए कुछ अतिरिक्त जानकारी (ऊपर उदाहरण बदलते समय):
$ = एक सरणी ();
164 बाइट्स आवंटित करें, unset ($ a) सब कुछ वापस कर देगा।

कक्षा ए {}
$ a = नया A ();
184 बाइट आवंटित करें, सब कुछ वापस कर देगा ($ a)।

$ a = नया stdClass ();
यह 272 बाइट्स आवंटित करेगा, लेकिन परेशान होने के बाद ($ a) 88 बाइट्स "लीक" होगा (मैंने यह पता लगाने का प्रबंधन नहीं किया कि वे कहां और क्यों लीक हुए)।

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

सरणियों

PHP में Arrays पर्याप्त मेमोरी "खाती है", और यह उनमें है कि वे आमतौर पर प्रसंस्करण के दौरान महत्वपूर्ण मात्रा में डेटा संग्रहीत करते हैं, इसलिए आपको उनके साथ काम करने के बारे में बहुत सावधान रहना चाहिए। हालांकि, PHP में सरणियों के साथ काम करने का अपना "अनुकूलन आकर्षण" है और स्मृति खपत से संबंधित उन मुद्दों में से एक का उल्लेख करने योग्य है।

कपटी उदाहरण १

< ? php
शामिल ( 'func.php' ) ;
गूंज "सरणी स्मृति उपयोग उदाहरण।" ;
$ base_memory_usage = memory_get_usage ( ) ;
$ base_memory_usage = memory_get_usage ( ) ;

गूंज 'आधार उपयोग।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

$ a = array ( someBigValue ( ) , someBigValue ( ) , someBigValue ( ) , someBigValue ( ) ) ;

गूंज 'एरे सेट है।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

foreach ( $ a $ k => $ v ) {
$ a [ $ k ] = someBigValue ( ) ;
unset ( $ k, $ v ) ;
गूंज 'पूर्व चक्र में।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
}

गूंज 'आगे के बाद सही उपयोग करें।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a ) ;
गूंज 'अर्रे परेशान।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
? >

पहली नज़र में, यह लग सकता है कि $ a सरणी की मेमोरी खपत नहीं बदलेगी (चर $ k और $ v को सेट करने के अलावा), हालांकि इस मामले में सरणियों के साथ काम करते समय PHP का एक विशेष दृष्टिकोण है।

आउटपुट को देखें:

मेमोरी उपयोग उदाहरणों का उपयोग करें। बेज़ उपयोग।
बाइट्स अंतर: 0
एरे सेट है।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 77632
FOREACH चक्र में।
बाइट्स अंतर: 93032
FOREACH चक्र में।
बाइट्स अंतर: 108432
FOREACH चक्र में।
बाइट्स अंतर: 123832
FOREACH के ठीक बाद का उपयोग करें।
बाइट्स अंतर: 61940
अर्रे परेशान।
बाइट्स अंतर: 0

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

नोट:
लूप के अंदर, $ [[$ k] के मूल्य को बदलने के बाद, आप उस मूल्य को प्राप्त नहीं कर सकते हैं जो अभी भी मूल सरणी में संग्रहीत है यदि आपने $ v का मान नहीं बचाया है। बार-बार कॉल करने के लिए $ [$ k] एक नए मूल्य का उत्पादन करेगा।

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

कपटी उदाहरण संख्या 2
कोड को थोड़ा बदल देते हैं।

गूंज 'एरे सेट है।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
$ b = & $ a ; // इसे जोड़ें
foreach ( $ a $ k => $ v ) {
$ a [ $ k ] = someBigValue ( ) ;
unset ( $ k, $ v ) ;
गूंज 'पूर्व चक्र में।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
}
अनसेट ( $ b ) ; // और यह
गूंज 'आगे के बाद सही उपयोग करें।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

हमने स्वयं ही लूप कोड नहीं बदला, केवल एक चीज जो हमने बदली, वह थी संदर्भ संख्या को स्रोत सरणी में बढ़ाना, लेकिन इसने मौलिक रूप से लूप ऑपरेशन को बदल दिया:

बाइट्स अंतर: 0
एरे सेट है।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 61988
FOREACH चक्र में।
बाइट्स अंतर: 61988
FOREACH चक्र में।
बाइट्स अंतर: 61988
FOREACH चक्र में।
बाइट्स अंतर: 61988
FOREACH के ठीक बाद का उपयोग करें।
बाइट्स अंतर: 61940
अर्रे परेशान।
बाइट्स अंतर: 0

एक छोटा परिवर्तन: (61988 - 61940 = 48 बाइट्स संदर्भ चर $ b स्टोर करने के लिए)।
अन्यथा, हम देखते हैं कि यदि लूप के लिए उपयोग किए जाने वाले ऐरे में स्वयं के लिए एक से अधिक संदर्भ हैं, तो उदाहरण संख्या 1 से अनुकूलन उस पर लागू नहीं होता है, अर्थात्। मूल सरणी का उपयोग असाइनमेंट के लिए किया जाता है।
यदि हम लूप के लिए $ b सरणी का उपयोग करते हैं या लूप में संदर्भ द्वारा मूल्य के हस्तांतरण का उपयोग करते हैं, तो हम बिल्कुल उसी परिणाम प्राप्त करेंगे:

गूंज 'एरे सेट है।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

foreach ( $ a $ k => & $ v ) {
$ a [ $ k ] = someBigValue ( ) ; // या $ v = someBigValue ();
unset ( $ k, $ v ) ;
गूंज 'पूर्व चक्र में।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
}

गूंज 'आगे के बाद सही उपयोग करें।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

परिणाम:

बाइट्स अंतर: 0
एरे सेट है।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 61940
FOREACH चक्र में।
बाइट्स अंतर: 61940
FOREACH के ठीक बाद का उपयोग करें।
बाइट्स अंतर: 61940
अर्रे परेशान।
बाइट्स अंतर: 0

यहां यह ध्यान देने योग्य है कि संदर्भ द्वारा $ v के हस्तांतरण को जोड़ना, हालांकि यह स्रोत सरणी की संदर्भ संख्या में वृद्धि नहीं करता है, यह "अनुकूलन" को भी अक्षम करता है।

संदर्भ द्वारा स्थानांतरण या प्रतिलिपि के माध्यम से स्थानांतरण

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

सबसे सरल उदाहरण के साथ शुरू करने के लिए (अब तक तर्क पारित किए बिना):

...
$ a = someBigValue ( ) ;
$ बी = $ ए ;

गूंज "स्ट्रिंग मूल्य बस गए" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a, $ b ) ;
...

"प्रत्यक्ष तर्क" द्वारा, चर के मान के लिए दो ब्लॉकों को स्मृति में आवंटित किया जाना चाहिए। हालाँकि, PHP इस बिंदु का अनुकूलन करता है:

प्रारंभ
बाइट्स अंतर: 0
स्ट्रिंग मूल्य बसे
बाइट्स अंतर: 15496
स्ट्रिंग मूल्य परेशान
बाइट्स अंतर: 0

इस स्थिति में, चर $ a पर 15448 बाइट्स का कब्जा है, जबकि शेष 48 बाइट्स को चर $ b के लिए आवंटित किया गया है, हालांकि उनके बीच कोई लिंक नहीं है। यह मेमोरी खपत तब तक संरक्षित रहती है जब तक कि हम किसी तरह इनमें से किसी एक चर को नहीं बदलते, या इसके मूल्य के साथ कुछ करते हैं, भले ही हम इसे वास्तव में नहीं बदलते हैं:

$ a = someBigValue ( ) ;
$ बी = $ ए ;
$ b = स्ट्रोक ( $ b ) ;

गूंज "स्ट्रिंग मूल्य बस गए" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a, $ b ) ;

परिणामस्वरूप, हम निष्कर्ष प्राप्त करते हैं:

बाइट्स अंतर: 0
स्ट्रिंग मूल्य बसे
बाइट्स अंतर: 30896
स्ट्रिंग मूल्य परेशान
बाइट्स अंतर: 0

जैसा कि हम देखते हैं, चर $ b के मूल्य को "छूने" का प्रयास इस तथ्य की ओर जाता है कि स्क्रिप्ट अब अपने भंडारण के लिए एक अलग मेमोरी क्षेत्र आवंटित करती है। यदि हम $ a के मूल्य को "स्पर्श" करने का प्रयास करते हैं तो भी ऐसा ही होता है।

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

$ a = array ( someBigValue ( ) , someBigValue ( ) ) ; // 31052 बाइट्स
$ बी = $ ए ; // + 48 बाइट्स = 31100 बाइट्स
$ b [ 0 ] = someBigValue ( ) ;

गूंज "स्ट्रिंग मूल्य बस गए" ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a, $ b ) ;

यह उदाहरण देगा:

बाइट्स अंतर: 0
स्ट्रिंग मूल्य बसे
बाइट्स अंतर: 46704
स्ट्रिंग मूल्य परेशान
बाइट्स अंतर: 0

यही है, परिणामस्वरूप, एक नई मेमोरी (15k + बाइट्स) को सरणी के शून्य तत्व के लिए केवल मूल्य की प्रतिलिपि बनाने के लिए आवंटित किया गया था, और पूरे $ b सरणी के लिए नहीं। $ B [1] का मूल्य अभी भी $ [1] के लिए "जानबूझकर संबंधित" है।

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

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

उदाहरण के लिए कोड:

< ? php
शामिल ( 'func.php' ) ;

समारोह testUsageInside ( $ big_value, $ base_memory_usage ) {
गूंज 'समारोह के अंदर उपयोग तो $ big_value नहीं बदला।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

$ big_value [ 0 ] = someBigValue ( ) ;
गूंज 'समारोह के अंदर उपयोग तब $ big_value [0] बदल गया।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

$ big_value [ 1 ] = someBigValue ( ) ;
गूंज 'समारोह के अंदर उपयोग तब भी $ big_value [1] बदल गया।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

}

गूंज "सरणी स्मृति उपयोग उदाहरण।" ;
$ base_memory_usage = memory_get_usage ( ) ;
$ base_memory_usage = memory_get_usage ( ) ;

गूंज 'आधार उपयोग।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

$ a = array ( someBigValue ( ) , someBigValue ( ) , someBigValue ( ) , someBigValue ( ) ) ;

गूंज 'एरे सेट है।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

testUsageInside ( $ a, $ base_memory_usage ) ;

गूंज 'फ़ंक्शन कॉल के ठीक बाद का उपयोग करें।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;

unset ( $ a ) ;
गूंज 'अर्रे परेशान।' । PHP_EOL ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
? >

निष्कर्ष:

स्मृति उपयोग उदाहरण।
आधार उपयोग।
बाइट्स अंतर: 0
एरे सेट है।
बाइट्स अंतर: 61940
फ़ंक्शन के अंदर उपयोग तब $ big_value नहीं बदला गया।
बाइट्स अंतर: 61940
फ़ंक्शन के अंदर उपयोग तब $ big_value [0] बदल गया।
बाइट्स अंतर: 77632
समारोह के अंदर उपयोग भी $ big_value [1] बदल गया।
बाइट्स अंतर: 93032
फ़ंक्शन कॉल के बाद सही उपयोग करें।
बाइट्स अंतर: 61940
अर्रे परेशान।
बाइट्स अंतर: 0

जैसा कि आप उदाहरण से देख सकते हैं, फ़ंक्शन में सरणी की एक प्रति नहीं बनाई गई थी, इस तथ्य के बावजूद कि मूल्य वास्तव में प्रतिलिपि द्वारा स्थानांतरित किया जा रहा है। और यहां तक ​​कि हस्तांतरित सरणी का एक आंशिक संशोधन पूर्ण प्रतिलिपि नहीं बनाता था, लेकिन केवल नए मूल्यों के लिए स्मृति आवंटित की गई थी।

केवल सूचना के उद्देश्यों के लिए, इन दो मूल्यों पर ध्यान देने योग्य है:

एरे सेट है।
बाइट्स अंतर: 61940
फ़ंक्शन के अंदर उपयोग तब $ big_value नहीं बदला गया।
बाइट्स अंतर: 61940

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

नोट:
PHP5 (PHP4 के विपरीत), सभी वस्तुओं को डिफ़ॉल्ट रूप से संदर्भ द्वारा पारित किया जाता है, हालांकि वास्तव में, यह एक अवर लिंक है। इस लेख को देखें।

संक्षिप्त निष्कर्ष

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

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

पुनश्च: इसे कई लेखों में विभाजित करना संभव होगा, लेकिन मैं इस बिंदु को नहीं देखता, क्योंकि ऐसी जानकारी को "एक साथ" संग्रहीत करना बेहतर है। मेरा मानना ​​है कि जिन लोगों के लिए यह जानकारी व्यावहारिक है, वे अधिक सुविधाजनक होंगे। PHP 5.3.2 (Ubuntu 32bit) में परीक्षण किया गया है, इसलिए आवंटित बाइट के लिए आपके मान भिन्न हो सकते हैं।

कई और उपयोगी चीजें, लेकिन अंग्रेजी में:
nikic.github.com/2011/12/12/How-big-are-PHP-arrays-really-Hint-BIG.html
nikic.github.com/2011/11/11/PHP-Internals-When-does-foreach-copy.html
blog.golemon.com/2007/01/youre-being-lied-to.html
hengrui-li.blogspot.com/2011/08/php-copy-on-write-how-php-manages.html
sldn.softlayer.com/blog/dmcaloon/PHP-Memory-Management-Foreach
blog.preinheimer.com/index.php?/archives/354-Memory-usage-in-PHP.html
derickrethans.nl/talks/phparch-php-variables-article.pdf

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

< ? php
शामिल ( 'func.php' ) ;
समारोह testFunc ( $ a, $ base_memory_usage ) {
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ;
}
$ बेस_मेमोरी_साज = 0 ;
$ base_memory_usage = memory_get_usage ( ) ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ; // 0 बाइट्स
$ a = someBigValue ( ) ;
$ b = & $ a ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ; // 15496 बाइट्स
testFunc ( $ a, $ base_memory_usage ) ; // 30896 बाइट्स
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ; // 15496 बाइट्स
unset ( $ a, $ b ) ;
memoryUsage ( memory_get_usage ( ) , $ base_memory_usage ) ; // 0 बाइट्स
? >