PHP में सरणियाँ (और मान) कितनी बड़ी हैं? (संकेत: बहुत बड़ा)

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

यह एक अनुवाद है (मेरे जैसे लोगों के लिए जो अक्सर इसे नोटिस नहीं करते हैं)।

शुरुआत में मैं जोहान्स और टायरेल को स्मृति उपभोग के लिए छिपे हुए स्थानों को खोजने में उनकी मदद के लिए धन्यवाद देना चाहता हूं।

<?php $startMemory = memory_get_usage(); $array = range(1, 100000); echo memory_get_usage() - $startMemory, ' bytes'; 

आपको क्या लगता है क्या निकलेगा? यदि पूर्णांक 8 बाइट्स हैं (64 आर्किटेक्चर पर और लंबे प्रकार का उपयोग करके) और 100,000 पूर्णांक हैं, तो जाहिर है, 800,000 बाइट की आवश्यकता होगी। यह लगभग 0.76 एमबी है।

अब कोड को चलाने का प्रयास करें। इसे ऑन-लाइन किया जा सकता है। परिणाम 14,649,024 बाइट्स है। जी हाँ, आपने सही सुना, यह 13.97 MB - 18 गुना अधिक है जो हमने सोचा है।

तो, यह 18 गुना वृद्धि कहां से आई?

सारांश

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

  | 64 bit | 32 bit --------------------------------------------------- zval | 24 bytes | 16 bytes + cyclic GC info | 8 bytes | 4 bytes + allocation header | 16 bytes | 8 bytes =================================================== zval (value) total | 48 bytes | 28 bytes =================================================== bucket | 72 bytes | 36 bytes + allocation header | 16 bytes | 8 bytes + pointer | 8 bytes | 4 bytes =================================================== bucket (array element) total | 96 bytes | 48 bytes =================================================== total total | 144 bytes | 76 bytes 

आपके ऑपरेटिंग सिस्टम, कंपाइलर और संकलन विकल्पों के आधार पर उपरोक्त संख्या भिन्न हो सकती है। उदाहरण के लिए, यदि आप PHP को डीबग या थ्रेड-सुरक्षा के साथ संकलित करते हैं, तो आपको अलग-अलग मान मिलेंगे। लेकिन मुझे लगता है कि आप 64-बिट लिनक्स पर PHP 5.3 की साधारण असेंबली पर दिए गए आकार देखेंगे।

यदि आप इन १४४ बाइट्स को हमारे १००,००० नंबरों से गुणा करते हैं, तो आपको १४,४००,००० बाइट्स मिलते हैं, जो कि १३.3३ एमबी है। वास्तविक परिणाम के बहुत करीब, बाकी ज्यादातर अनइंस्टाल्यूटेड ब्लॉक (बाल्टी) के लिए संकेत हैं, लेकिन मैं इस बारे में बाद में बात करूंगा।

अब, यदि आप ऊपर दिए गए मानों का अधिक विस्तृत विश्लेषण करना चाहते हैं, तो :) पर पढ़ें।

संघ zvalue_value

सबसे पहले, आइए एक नजर डालते हैं कि PHP कैसे मूल्यों को स्टोर करता है। जैसा कि आप जानते हैं, PHP एक कमजोर टाइप की भाषा है, इसलिए इसे मूल्यों के बीच जल्दी से स्विच करने का एक तरीका चाहिए। PHP एक संघ का उपयोग करता है, जिसे zend.h # 307 (मेरी टिप्पणियाँ) के रूप में परिभाषित किया गया है:

 typedef union _zvalue_value { long lval; //     double dval; //      struct { //   char *val; //      int len; //    } str; HashTable *ht; //   (-) zend_object_value obj; //   } zvalue_value; 

यदि आप सी नहीं जानते हैं, तो यह कोई समस्या नहीं है - कोड बहुत सरल है: संघ का मतलब है कि मूल्य विभिन्न प्रकारों के रूप में कार्य कर सकता है। उदाहरण के लिए, यदि आप zvalue_value-> lval का उपयोग करते हैं, तो मान को पूर्णांक के रूप में समझा जाएगा। दूसरी ओर, यदि आप zvalue_value-> ht का उपयोग करते हैं, तो मान को एक हैश टेबल (उर्फ सरणी) के लिए सूचक के रूप में व्याख्या किया जाएगा।

हम इस पर नहीं झुकेंगे। हमारे लिए महत्वपूर्ण बात यह है कि संघ का आकार उसके सबसे बड़े घटक के आकार के बराबर है। सबसे बड़ा घटक स्ट्रिंग है (वास्तव में, zend_object_value संरचना भी आकार है, लेकिन मैं इस बिंदु को सरलता के लिए छोड़ दूंगा)। संरचना में एक सूचक (8 बाइट्स) और एक पूर्णांक (4 बाइट्स) होते हैं। कुल 12 बाइट्स। मेमोरी संरेखण के कारण (12 बाइट्स की संरचनाएं शांत नहीं होती हैं, क्योंकि वे 64 बिट्स / 8 बाइट्स का उत्पाद नहीं हैं), संरचना का अंतिम आकार 16 बाइट्स होगा और तदनुसार, पूरे संघ के रूप में।

तो, अब हम जानते हैं कि हमें प्रत्येक मूल्य के लिए 8 बाइट्स की आवश्यकता नहीं है, लेकिन 16 - PHP के गतिशील टाइपिंग के कारण। 100,000 से गुणा करने पर हमें 1,600,000 बाइट्स मिलते हैं, अर्थात्। 1.53 एमबी। लेकिन वास्तविक मात्रा 13.97 एमबी है, इसलिए हम अभी तक लक्ष्य तक नहीं पहुंचे हैं।

Zval संरचना

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

 struct _zval_struct { zvalue_value value; //  zend_uint refcount__gc; //     ( GC) zend_uchar type; //  zend_uchar is_ref__gc; //      (&) }; 

संरचना का आकार उसके सभी घटकों के आकार के योग से निर्धारित होता है: zvalue_value - 16 बाइट्स (ऊपर की गणना), zend_uint - 4 बाइट्स, zend_uchar - 1 बाइट प्रत्येक। कुल 22 बाइट्स। फिर से, मेमोरी संरेखण के कारण, वास्तविक आकार 24 बाइट्स होगा।

इसलिए, यदि हम 24 बाइट्स के 100,000 मानों को स्टोर करते हैं, तो यह 2,400,000 बाइट्स, या 2.29 एमबी होगा। अंतर कम हो रहा है, लेकिन वास्तविक मूल्य छह गुना बड़ा है।

परिपत्र संदर्भ के लिए कचरा कलेक्टर (PHP 5.3)

PHP 5.3 ने परिपत्र संदर्भ के लिए एक नया कचरा संग्रहकर्ता पेश किया। इसके लिए, PHP कुछ अतिरिक्त जानकारी संग्रहीत करता है। मैं यहां यह नहीं समझाना चाहता कि यह कैसे काम करता है, आप मैनुअल से आवश्यक जानकारी प्राप्त कर सकते हैं। हमारे आकार की गणना के लिए, यह महत्वपूर्ण है कि प्रत्येक zval खुद को zval_gc_info लपेटता है :

 typedef struct _zval_gc_info { zval z; union { gc_root_buffer *buffered; struct _zval_gc_info *next; } u; } zval_gc_info; 

जैसा कि आप देख सकते हैं, Zend केवल एक यूनियन जोड़ता है जिसमें दो पॉइंटर्स होते हैं। जैसा कि आपको याद है, संघ का आकार सबसे बड़े घटक द्वारा निर्धारित किया जाता है। दोनों घटक 8 बाइट्स के संकेत हैं। तदनुसार, संघ का आकार भी 8 बाइट्स है।

यदि हम प्राप्त 24 बाइट्स को ऊपर जोड़ते हैं, तो हमें 32 बाइट्स मिलते हैं। इसे 100,000 से गुणा करें और 3.05 एमबी प्राप्त करें।

ZEND मेमोरी मैनेजर

सी, PHP के विपरीत, आपके लिए मेमोरी का प्रबंधन नहीं करता है। आपको मेमोरी आवंटन की स्वतंत्र रूप से निगरानी करनी चाहिए। ऐसा करने के लिए, PHP अपनी जरूरतों के लिए अनुकूलित अपने स्वयं के मेमोरी मैनेजर का उपयोग करता है: Zend मेमोरी मैनेजर । MM Zend डग ले और अतिरिक्त PHP- विशिष्ट सुविधाओं और अनुकूलन (जैसे मेमोरी सीमा, प्रत्येक अनुरोध और बाद की तरह सफाई) के सभी प्रकार से मालॉक पर आधारित है।

इसमें हमारे लिए महत्वपूर्ण यह है कि एमएम प्रत्येक मेमोरी आवंटन के लिए एक हेडर जोड़ता है जो इसके माध्यम से गुजरता है। और निम्नानुसार परिभाषित किया गया है :

 typedef struct _zend_mm_block { zend_mm_block_info info; #if ZEND_DEBUG unsigned int magic; # ifdef ZTS THREAD_T thread_id; # endif zend_mm_debug_info debug; #elif ZEND_MM_HEAP_PROTECTION zend_mm_debug_info debug; #endif } zend_mm_block; typedef struct _zend_mm_block_info { #if ZEND_MM_COOKIES size_t _cookie; #endif size_t _size; //   size_t _prev; //   (   ) } zend_mm_block_info; 

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

उदाहरण के लिए, हम मानेंगे कि ये सभी विकल्प अक्षम हैं। इस स्थिति में, केवल दो घटक size_t _size और _prev बने रहते हैं । size_t में 8 बाइट्स (64 बिट्स) होते हैं, इसलिए हेडर का आकार 16 बाइट्स होता है - और यह हेडर आपके मेमोरी आवंटन के लिए जोड़ा जाता है।

इसलिए हमें ज़वल आकार को फिर से समायोजित करना होगा । दरअसल यह हेडर के कारण 32 बाइट्स नहीं, बल्कि 48 होंगे। हम अपने 100,000 तत्वों से गुणा करते हैं और 4,58 एमबी प्राप्त करते हैं। वास्तविक आकार 13.97 एमबी है, इसलिए हमने पहले ही लगभग एक तिहाई कवर किया है।

ब्लॉक

अब तक, हमने अलग-अलग मूल्यों को देखा है। लेकिन PHP में सरणी संरचना बहुत सी जगह लेती है। वास्तव में, "ऐरे" शब्द को यहाँ चुना गया है। PHP में, एक सरणी वास्तव में तालिकाओं / शब्दकोशों का हैश है। तो हैश टेबल कैसे काम करते हैं? मूल रूप से, प्रत्येक कुंजी के लिए एक हैश उत्पन्न होता है, और इस हैश का उपयोग "वास्तविक" सी सरणी में जाने के लिए किया जाता है। हैशिंग संघर्ष कर सकते हैं, सभी तत्व जिनके पास समान हैश एक लिंक्ड सूची में संग्रहीत हैं। किसी तत्व तक पहुंचने पर, PHP पहले हैश की गणना करता है, वांछित ब्लॉक (बाल्टी) की तलाश करता है, और तत्व द्वारा सटीक मिलान तत्व की तलाश में सूची से गुजरता है। एक ब्लॉक निम्नानुसार परिभाषित किया गया है ( zend_hash.h # 54 ):

 typedef struct bucket { ulong h; //  (    ) uint nKeyLength; //   (  ) void *pData; //  void *pDataPtr; // ???   ??? struct bucket *pListNext; // PHP  .     struct bucket *pListLast; //    struct bucket *pNext; //     ()   struct bucket *pLast; //     ()   const char *arKey; //  (  ) } Bucket; 

जैसा कि आप देख सकते हैं, एक सार डेटा सरणी को प्राप्त करने के लिए डेटा का "लोड" स्टोर करना आवश्यक है जैसे कि PHP (PHP सरणियों में उपयोग किए जाने वाले एरे, एक ही समय में शब्दकोशों, लिंक किए गए और सूचीबद्ध सूचियाँ हैं, जो निश्चित रूप से बहुत अधिक डेटा की आवश्यकता होती है)। अलग-अलग घटकों का आकार है: प्रकार के लिए 8 बाइट्स उलॉन्ग , यूइंट के लिए 4 बाइट्स , और पॉइंटर्स के लिए 7 बाइट्स। परिणाम 68 है। संरेखण जोड़ें और 72 बाइट्स प्राप्त करें।

ब्लॉकों के लिए, साथ ही साथ ज़वल के लिए, 16 बाइट हेडर जोड़े जाने चाहिए, जो हमें 88 बाइट्स देता है। हमें "वास्तविक" सी सरणी (बाल्टी ** arBuckets;) में इन ब्लॉकों को पॉइंटर्स स्टोर करने की भी आवश्यकता है, मैंने इसके ऊपर उल्लेख किया है, जो तत्व में एक और 8 बाइट्स जोड़ता है। तो सामान्य तौर पर, प्रत्येक ब्लॉक 96 बाइट्स मेमोरी का उपभोग करता है।

और इसलिए, अगर हमें प्रत्येक मूल्य के लिए एक ब्लॉक की आवश्यकता है, तो यह बाल्टी के लिए 96 बाइट्स और ज़वल के लिए 48 बाइट्स होंगे , जो कुल 144 बाइट्स है। 100,000 तत्वों के लिए, यह 14,400,000 बाइट्स या 13.73 एमबी होगा।

पहेली हल हो गई है।

रुको, अभी भी 0.24 एमबी है!

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

हमारे मामले में, यह 2 ^ 17 = 131 072 है। लेकिन हमें इन ब्लॉकों में से केवल 100,000 की आवश्यकता है, इसलिए हम 31 072 ब्लॉकों को अप्रयुक्त छोड़ देते हैं। उन, इन ब्लॉकों के लिए मेमोरी आवंटित नहीं की जाएगी (इसलिए, हमें पूरे 96 बाइट्स खर्च करने की आवश्यकता नहीं है), लेकिन पॉइंटर (जो ब्लॉकों के आंतरिक सरणी में संग्रहीत है) के लिए मेमोरी का उपयोग ब्लॉक पर किया जाना चाहिए। इसलिए, हम अतिरिक्त रूप से 8 बाइट्स (प्रति सूचक) * 31,072 तत्वों का उपयोग करते हैं। यह 248 576 बाइट्स या 0.23 एमबी है। जो लापता मेमोरी से मेल खाती है। (बेशक, कुछ और बाइट्स गायब हैं, लेकिन मैं पूरी तरह से सब कुछ कवर नहीं करना चाहता हूं। ये हैश टेबल की संरचना, चर आदि जैसी चीजें हैं)

पहेली वास्तव में हल है।

यह हमें क्या बताता है?

PHP C. नहीं है और यह केवल हमें बताता है। आप सुपर-गतिशील PHP भाषा की अपेक्षा नहीं कर सकते। सी। में मेमोरी का कुशलता से उपयोग करें। आप ऐसा नहीं कर सकते।

लेकिन, यदि आप स्मृति को बचाना चाहते हैं, तो आप बड़े स्थिर सरणियों के लिए SplFixedArray का उपयोग करने पर विचार कर सकते हैं।

आइए संशोधित स्क्रिप्ट देखें:

 <?php $startMemory = memory_get_usage(); $array = new SplFixedArray(100000); for ($i = 0; $i < 100000; ++$i) { $array[$i] = $i; } echo memory_get_usage() - $startMemory, ' bytes'; 

यह मूल रूप से एक ही काम करता है, लेकिन अगर आप इसे चलाते हैं, तो आप देखेंगे कि यह "केवल" 5,600,640 बाइट्स का उपयोग करता है। जो प्रति तत्व 56 बाइट्स है, जो कि एक नियमित सरणी के 144 बाइट्स प्रति तत्व से बहुत कम है। ऐसा इसलिए है क्योंकि एक निश्चित सरणी को एक बकेट संरचना की आवश्यकता नहीं है: इसलिए इसे प्रत्येक तत्व के लिए केवल एक zval (48 बाइट्स) और एक पॉइंटर (8 बाइट्स) की आवश्यकता होती है, जो हमें एक नमूदार 56 बाइट्स देगा।

PS कृपया लैन पर अनुवाद के संबंध में सभी टिप्पणियां लिखें, और मैं उन्हें तुरंत ठीक करने का प्रयास करूंगा।