पायथन मेमोरी का उपयोग

1 मिलियन पूर्णांकों में कितनी मेमोरी लगती है?

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

सभी उदाहरण CPython संस्करण 2.7.4 में 32 बिट मशीन पर बनाए गए थे। अंत में 64 बिट मशीन पर मेमोरी आवश्यकताओं के लिए एक टेबल है।

आवश्यक उपकरण

sys.getsizeof और __sizeof __ () विधि

पहला उपकरण जो हमें चाहिए वह sys मानक पुस्तकालय में है। हम आधिकारिक दस्तावेज उद्धृत करते हैं:

sys.getsizeof (ऑब्जेक्ट [, default_value])

बाइट्स में ऑब्जेक्ट का आकार देता है।
यदि कोई डिफ़ॉल्ट मान निर्दिष्ट किया गया है, तो यह वापस आ जाएगा यदि ऑब्जेक्ट आकार प्राप्त करने का एक तरीका प्रदान नहीं करता है। अन्यथा, TypeError अपवाद को फेंक दिया जाएगा।
गेट्सिफ़ॉफ़ () __sizeof__ ऑब्जेक्ट विधि को कॉल करता है और उपयोग किए जाने पर कचरा कलेक्टर के लिए संग्रहीत अतिरिक्त जानकारी का आकार जोड़ता है।

गेटिज़ोफ़ का एल्गोरिथ्म (), पायथन में फिर से लिखा गया, इस तरह दिख सकता है:

Py_TPFLAGS_HAVE_GC = 1 << 14 # .     0b100000000000000 def sys_getsizeof(obj, default = None)     if obj.hasattr('__sizeof__'):         size = obj.__sizeof__()     elif default is not None:         return default     else:         raise TypeError('    __sizeof__')     #       HAVE_GC     if type(obj).__flags__ & Py_TPFLAGS_HAVE_GC:         size = size +  PyGC_Head     return size 

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

 typedef union _gc_head { struct { union _gc_head *gc_next; union _gc_head *gc_sourcev; Py_ssize_t gc_refs; } gc; long double dummy; } PyGC_Head; 

PyGC_Head का आकार 32 बिट मशीन पर 12 बाइट और 64 बिट मशीन पर 24 बाइट होगा।

चलो कंसोल में getizeof () देखें और देखें कि क्या होता है:

 >>> import sys >>> GC_FLAG = 1 << 14 >>> sys.getsizeof(1) 12 >>> (1).__sizeof__() 12 >>> bool(type(1).__flags__ & GC_FLAG) False >>> sys.getsizeof(1.1) 16 >>> (1.1).__sizeof__() 16 >>> bool(type(1.1).__flags__ & GC_FLAG) False >>> sys.getsizeof('') 21 >>> ''.__sizeof__() 21 >>> bool(type('').__flags__ & GC_FLAG) False >>> sys.getsizeof('hello') 26 >>> sys.getsizeof(tuple()) 24 >>> tuple().__sizeof__() 12 >>> bool(type(tuple()).__flags__ & GC_FLAG) True >>> sys.getsizeof(tuple((1, 2, 3))) 36 

झंडे की जाँच के जादू के अपवाद के साथ, सब कुछ बहुत सरल है।
जैसा कि आप उदाहरण से देख सकते हैं, int और float पर क्रमशः 12 और 16 बाइट्स हैं। सामग्री में प्रत्येक वर्ण के लिए Str 21 बाइट्स और दूसरा बाइट लेता है। एक खाली टपल में 12 बाइट्स होते हैं, और एक अतिरिक्त 4 बाइट्स प्रति तत्व। सरल डेटा प्रकारों के लिए (जिसमें अन्य वस्तुओं के संदर्भ नहीं होते हैं, और इसलिए कचरा कलेक्टर द्वारा ट्रैक नहीं किया जाता है), sys.getsizeof का मान __sizeof __ () विधि द्वारा लौटाए गए मूल्य के बराबर है।

आईडी () और ctypes.string_at

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

अंतर्निहित आईडी () फ़ंक्शन स्मृति पता लौटाता है जहां ऑब्जेक्ट की शुरुआत संग्रहीत होती है (ऑब्जेक्ट स्वयं एक सी संरचना है)

 >>> obj = 1 >>> id(obj) 158020320 

मेमोरी पते पर डेटा पढ़ने के लिए, आपको ctypes मॉड्यूल से string_at फ़ंक्शन का उपयोग करने की आवश्यकता है। उसका आधिकारिक विवरण बहुत विस्तृत नहीं है:

ctypes.string_at (पता [, लंबाई])
यह फ़ंक्शन स्मृति कोशिकाओं में पते की शुरुआत के साथ एक स्ट्रिंग लौटाता है। यदि "लंबाई" निर्दिष्ट नहीं है, तो यह माना जाता है कि स्ट्रिंग शून्य-टर्मिनेटेड है,

अब आइए उस पते पर डेटा पढ़ने की कोशिश करें जो आईडी () हमारे पास लौटा है:

 >>> import ctypes >>> obj = 1 >>> sys.getsizeof(obj) 12 >>> ctypes.string_at(id(obj), 12) 'u\x01\x00\x00 \xf2&\x08\x01\x00\x00\x003\x01\x00\x00 \xf2&\x08\x00\x00\x00\x001\x00\x00\x00' 

हेक्स कोड का लुक बहुत प्रभावशाली नहीं है, लेकिन हम सच्चाई के करीब हैं।

मॉडल संरचना

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

struct
यह मॉड्यूल पायथन मूल्यों और सी संरचनाओं के बीच परिवर्तित होता है, जिसे स्ट्रिंग्स के रूप में दर्शाया जाता है।

struct.unpack (प्रारूप, स्ट्रिंग)
दिए गए स्वरूपों के अनुसार एक स्ट्रिंग को पार करता है। हमेशा एक टपल लौटाता है, भले ही स्ट्रिंग में केवल एक तत्व हो। स्ट्रिंग में ठीक उसी प्रकार की जानकारी होनी चाहिए जैसा कि प्रारूप द्वारा वर्णित है।

डेटा प्रारूप जो हमें चाहिए।

प्रतीक	C मान	अजगर का मूल्य	एक 32 बिट मशीन पर लंबाई
ग	चार	एकल चरित्र स्ट्रिंग	1
मैं	पूर्णांक	पूर्णांक	4
एल	लंबे समय तक	पूर्णांक	4
एल	अहस्ताक्षरित लंबे	पूर्णांक	4
घ	दोहरा	नाव	8

अब हम सब कुछ एक साथ इकट्ठा करते हैं और कुछ प्रकार के डेटा की आंतरिक संरचना को देखते हैं।

इंट

 >>> obj = 1 >>> sys.getsizeof(obj), obj.__sizeof__() (12, 12) >>> struct.unpack('LLl', ctypes.string_at(id(obj), 12)) (373, 136770080, 1) 

मूल्य प्रारूप का अनुमान लगाना आसान है।

पहला नंबर (373) ऑब्जेक्ट को पॉइंटर्स की संख्या है।

 >>> obj2 = obj >>> struct.unpack('LLl', ctypes.string_at(id(obj), 12)) (374, 136770080, 1) 

जैसा कि आप देख सकते हैं, एक के बाद एक संख्या में वृद्धि हुई, जब हमने ऑब्जेक्ट के लिए एक और लिंक बनाया।

दूसरा नंबर (136770080) ऑब्जेक्ट के प्रकार के लिए एक पॉइंटर (आईडी) है:

 >>> type(obj) <type 'int'> >>> id(type(obj) ) 136770080 

तीसरा नंबर (1) सीधे ऑब्जेक्ट की सामग्री है।

 >>> obj = 1234567 >>> struct.unpack('LLl', ctypes.string_at(id(obj), 12)) (1, 136770080, 1234567) 

CPython के सोर्स कोड को देखकर हमारे अनुमानों की पुष्टि की जा सकती है।

 typedef struct { PyObject_HEAD long ob_ival; } PyIntObject; 

यहाँ PyObject_HEAD सभी निर्मित वस्तुओं में एक सामान्य आम है, और ob_ival एक प्रकार का लंबा मूल्य है। PyObject_HEAD मैक्रो किसी ऑब्जेक्ट के लिए पॉइंटर्स की संख्या और ऑब्जेक्ट के मूल प्रकार के लिए एक पॉइंटर - जो हमने देखा था, के लिए एक काउंटर जोड़ता है।

फ्लोट

फ्लोटिंग पॉइंट संख्या इंट के समान है, लेकिन सी मेमोरी में टाइप डबल के मान से दर्शाया गया है।

 typedef struct { PyObject_HEAD double ob_fval; } PyFloatObject; 

यह सत्यापित करना आसान है:

 >>> obj = 1.1 >>> sys.getsizeof(obj), obj.__sizeof__() (16, 16) >>> struct.unpack('LLd', ctypes.string_at(id(obj), 16) (1, 136763968, 1.1) 

स्ट्रिंग (Str)

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

 typedef struct { PyObject_VAR_HEAD long ob_shash; #    int ob_sstate; #    ? char ob_sval[1]; #   +   } PyStringObject; 

PyObject_VAR_HEAD मैक्रो में PyObject_HEAD शामिल है और लंबे ob_ival मान को जोड़ता है, जो स्ट्रिंग की लंबाई संग्रहीत करता है।

 >>> obj = 'hello world' >>> sys.getsizeof(obj), obj.__sizeof__() (32, 32) >>> struct.unpack('LLLli' + 'c' * (len(obj) + 1), ctypes.string_at(id(obj), 4*5 + len(obj) + 1)) (1, 136790112, 11, -1500746465, 0, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\x00') 

चौथा मान स्ट्रिंग से हैश से मेल खाता है, जो सत्यापित करना आसान है।

 >>> hash(obj) -1500746465 

जैसा कि आप देख सकते हैं, sstate मान 0 है, इसलिए लाइन अभी कैश नहीं की गई है। आइए इसे कैश में जोड़ने का प्रयास करें:

 >>> intern(obj) 'hello world' >>> struct.unpack('LLLli' + 'c' * (len(obj) + 1), ctypes.string_at(id(obj), 4*5 + len(obj) + 1)) (2, 136790112, 11, -1500746465, 1, 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '\x00') 

टपल (टपल)

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

टपल संरचना एक स्ट्रिंग के समान है, केवल लंबाई के अलावा कोई विशेष क्षेत्र नहीं हैं।

 typedef struct { PyObject_VAR_HEAD PyObject *ob_item[1]; } PyTupleObject; 

 >>> obj = (1,2,3) >>> sys.getsizeof(obj), obj.__sizeof__() (36, 24) >>> struct.unpack('LLL'+'L'*len(obj), ctypes.string_at(id(obj), 12+4*len(obj))) (1, 136532800, 3, 146763112, 146763100, 146763088) >>> for i in obj: print i, id(i) 1 146763112 2 146763100 3 146763088 

जैसा कि आप उदाहरण से देख सकते हैं, टपल के अंतिम तीन तत्व इसकी सामग्री के संकेत हैं।

शेष मूल डेटा प्रकार (यूनिकोड, सूची, तानाशाही, सेट, फ्रोज़ेनसेट) को एक समान तरीके से खोजा जा सकता है।

परिणाम क्या है?

टाइप	CPython में नाम	प्रारूप	नेस्टेड ऑब्जेक्ट्स के लिए प्रारूप	32 बिट लंबाई	64 बिट लंबाई	जीसी के लिए मेमोरी *
इंट	PyIntObject	एल एल एल		12	24
नाव	PyFloatObject	lld		16	24
str	PyStringObject	LLLli + c * (लंबाई + 1)		21 + लंबाई	37 + लंबाई
यूनिकोड	PyUnicodeObject	LLLLlL	एल * (लंबाई + 1)	28 + 4 * लंबाई	५२ + ४ * लंबाई
टपल	PyTupleObject	एलएलएल + एल * लंबाई		12 + 4 * लंबाई	24 + 8 * लंबाई	वहाँ है
सूची	PyListObject	एल * ५	एल * लंबाई	20 + 4 * लंबाई	40 + 8 * लंबाई	वहाँ है
सेट करें / frozenset	PySetObject	एल * 7 + (एलएल) * 8 + एलएल	एलएल * लंबाई	(<= 5 आइटम) 100 (> 5 आइटम) 100 + 8 * लंबाई	(<= 5 आइटम) 200 (> 5 आइटम) 200 + 16 * लंबाई	वहाँ है
dict	PyDictObject	एल * 7 + (एलएलएल) * 8	एलएलएल * लंबाई	(<= 5 आइटम) 124 (> 5 आइटम) 124 + 12 * लंबाई	(<= 5 आइटम) 248 (> 5 आइटम) 248 + 24 * लंबाई	वहाँ है

* 32 बिट मशीन पर 12 बाइट और 64 बिट मशीन पर 32 बाइट जोड़ता है

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

तार और टुपल्स के लिए, अंतर इतना महत्वपूर्ण नहीं है - कुछ निरंतर मूल्य जोड़ा जाता है।

और सूची, शब्दकोश और सेट, एक नियम के रूप में, आवश्यक से 1/3 अधिक कब्जा। यह नए तत्वों को जोड़ने के लिए एल्गोरिथ्म के कार्यान्वयन के कारण है, जो प्रोसेसर समय को बचाने के लिए स्मृति का बलिदान करता है।

तो, हम लेख की शुरुआत में सवाल का जवाब देते हैं: 1 मिलियन पूर्णांक बचाने के लिए, हमें 11.4 मेगाबाइट्स (12 * 10 ^ 6 बाइट्स) की जरूरत है, संख्याओं के लिए खुद को और एक अतिरिक्त 3.8 मेगाबाइट्स (12 + 4 + 4 * 10 + 6 बट्स) प्रति ट्यूपल, जो कि उनके लिए लिंक स्टोर करेगा।

UPD: टाइपो।
UPD: "1 मिलियन प्राइम्स" के बजाय उपशीर्षक में "1 मिलियन पूर्णांक,"