जावा में सरणी आकार

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

स्मृति से कम्प्यूटेशनल एल्गोरिथ्म का अनुकूलन करते समय, मैं इस तथ्य के साथ आया था कि कुछ (काफी उचित) इनपुट मापदंडों के साथ, फ्लोट की एक सरणी [500] [14761] [2] बनाई गई है। यह मेमोरी में कितना ले सकता है (हॉटस्पॉट 1.6.0_26 32 बिट पर, अगर किसी को दिलचस्पी है)? मैंने मोटे तौर पर अनुमान लगाया था कि 500 * 14 761 * 2 * साइज़ोफ़ (फ्लोट) = 500 * 14 761 * 2 * 4 = 59 044 000 बाइट्स के अलावा किसी तरह का ओवरहेड। यह जाँचने का निर्णय लेना कि यह वास्तव में कैसा है, मैंने एक्लिप्स मेमोरी एनालाइज़र (एक अविश्वसनीय जादुई चीज़, जो मैं सुझाता हूँ!) का इस्तेमाल किया और पाया कि इस सरणी के लिए "रिटायर्ड हीप" 206 662 016 बाइट्स है ! अच्छा उपरि - 350%। आइए देखें कि ऐसा क्यों हुआ।

मैंने इंटरनेट पर इस विषय पर जो लिखा जा रहा है, उसकी खोज की, और अंग्रेजी में एक काफी समझ में आने वाला लेख आया " जावा सरणी के मेमोरी उपयोग की गणना कैसे करें "। संक्षेप में, प्रस्तुति का सार इस प्रकार है:

• हर जावा ऑब्जेक्ट में 8 बाइट्स का ओवरहेड होता है;
• जावा सरणी में एक अतिरिक्त 4 बाइट ओवरहेड (भंडारण आकार के लिए) है;
• लिंक आकार में 4 बाइट्स है;
• सभी वस्तुओं का आकार 8 बाइट्स द्वारा संरेखित किया गया है;
• एक बहुआयामी सरणी सरणी संदर्भों की एक सरणी है।

यह ज्ञान ही काफी है। इसलिए हमारे पास श्रृंखला के अंत में [2] सरणियाँ हैं। उनका आकार 2 फ्लोट (4 बाइट्स प्रत्येक) + 12 बाइट्स ओवरहेड - 20 बाइट्स है। 8 - 24 बाइट्स में संरेखित करें। कुल में, हमने 500 * 14 761 - 7 380 500 टुकड़ों के ढेर में ऐसे सरणियों का निर्माण किया है। कुल में, वे 177,132,000 बाइट्स का वजन करते हैं।

फिर हमारे पास एरेट्स फ्लोट [14761] [] - 14,761 अन्य सरणियों के सरणियाँ हैं। इस तरह के प्रत्येक सरणी में 14,761 लिंक (प्रत्येक 4 बाइट्स) + 12 बाइट्स ओवरहेड - 59,056 बाइट्स (8 से विभाजित - संरेखित करने की कोई आवश्यकता नहीं) होती है। कुल इन सरणियों में से 500 हैं, जिसका अर्थ है कि वे एक साथ 29,528,000 बाइट्स का वजन करते हैं।

अंत में, हमारे पास वास्तविक सरणी है जिसे हमने बनाया है - फ्लोट [500] [] [] - दो-आयामी सरणियों के लिए 500 संदर्भों की एक सरणी। इसमें 500 * 4 + 12 = 2 012 , और यहां तक ​​कि 4 संरेखण बाइट्स - 2 016 बाइट्स लगते हैं।

जो कुछ हुआ, उसे जोड़ें: 177 132 000 + 29 528 000 + 2 016 = 206 662 016 - सिर्फ मेमोरी एनालाइज़र द्वारा दिखाए गए नंबर।

तुरंत एक स्पष्ट निर्णय दिमाग में आया: आरोही क्रम में सरणी के आयामों को क्रमबद्ध करने के लिए। हम फ्लोट [2] [500] [14761] बनाएंगे और एल्गोरिथम को किसी भी तरह से नुकसान नहीं होगा। इस मामले में क्या आकार होगा?

• एरेट्स फ्लोट [14761]: 14 761 * 4 + 12 = 59 056 बाइट्स, कुल 1,000 ऐसे एरेज़, कुल 59 056 000 बाइट्स।
• Arrays फ्लोट [500] []: 500 * 4 + 12 = 2 012 , संरेखण के बाद - 2 016 , केवल 2 ऐसे सरणियों, कुल 4 032 बाइट्स।
• एरे फ्लोट [2] [] []: 2 * 4 + 12 = 20, संरेखण के बाद - 24 बाइट्स।

कुल मिलाकर, 59,060,056 बाइट्स, ओवरहेड 0.03% से कम, लगभग 150 मेगाबाइट मेमोरी बच गई।

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