हम हमेशा स्थिरता की घोषणा 2 की शक्तियों के लिए क्यों करते हैं?

Question

स्थिरांक के अधिकांश मैं दूसरों कोड में देख, 2 की शक्तियों हैं यानी

#define SIZE 256 

या

public static final int SIZE = 2048; 

कोई विशेष कारण है कि हम करते हैं कि यानी

#define SIZE 257 

बजाय

?

Answer 1

2 की शक्तियां सुविधाजनक हैं क्योंकि वे हार्डवेयर में अंतर्निहित बाधाओं के लिए अच्छी तरह से मानचित्रण करते हैं।

जैसे:

1. पृष्ठ आकार
2. पता स्थान सीमा
3. संरेखण constaints (DWORD या आम तौर पर QWORD संरेखण, 2 के दोनों शक्तियों)

झंडे के लिए, 2 की शक्तियों हमेशा एक बिट सेट है। तो MY_FLAG_1 | MY_FLAG_2 | MY_FLAG_3 | ... जैसी चीजें केवल दो की शक्तियों के साथ काम करती हैं। इसी प्रकार & के साथ झंडे के परीक्षण के लिए।

बफर आकारों और इसी तरह के लिए दो की निकटतम बड़ी शक्ति चुनने के लिए यह एक सम्मेलन का कुछ भी है।

Answer 2

क्योंकि कंप्यूटर मेमोरी 0/1 के साथ काम करती है जो बाइनरी सिस्टम है।

Answer 3

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

Answer 4

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

Answer 5

वास्तव में बहुत अधिक कारण नहीं है। संरचित और ढेर में चर के संरेखण के कारण तीन बाइट्स की एक सरणी में स्मृति में 4 या 8 बाइट्स लगेंगे। मुझे लगता है कि यह अच्छा लगता है।

ढेर से पृष्ठों की पूरी संख्या आवंटित करना ढेर की आंतरिक संरचना के ऊपरी हिस्से के कारण वांछित रूप से वांछित काम नहीं कर सकता है। आवंटन 40 9 6 बाइट्स (32 बिट विंडोज मशीन के लिए 1 पृष्ठ) का परिणाम 4104 बाइट्स या उससे अधिक के आवंटन में हो सकता है।

यदि स्थिरांक झंडे हैं, तो कहानी बहुत अलग है। यह आमतौर पर कुछ आधारों में झंडे की तुलना में थोड़ा झंडे रखने के लिए अधिक कुशल है जो कि 2

Answer 6

हमारे चर आकार 2 (1, 2, 4, या 8 बाइट्स) की शक्तियां हैं। कंप्यूटर इन सीमाओं पर काम कर रहा है। पुराने दिनों में, हम अपने कोड को तेजी से जाने के लिए सावधानीपूर्वक पैड करते थे, और कभी-कभी पॉइंटर अंकगणित आसान बनाने के लिए।

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

यहाँ की 4.

alt text http://upload.wikimedia.org/wikipedia/en/2/2c/Hexedit-screenshot.png

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

तो वे सभी or'd और एक ही चर से and'd जा सकता है।

bits |= 8;  //00000100 
bits |= 32;  //00010000 

//bits is now 40 00010100 

bits &= 32;  //00010000 

//bits is now 32 00010000 

कई प्रोग्रामर के बजाय हेक्साडेसिमल में नंबर दशमलव बारे में इतना है कि यह आसान है देखने के लिए क्या अलग-अलग बिट्स के साथ हो रहा है होगा।

Answer 7

बाइनरी कंप्यूटर के साथ, मानकों-आधारित binary multiples जैसे Mebibyte (या किबी, गिबी, तेबी ...) का उपयोग करना सुविधाजनक है। Octal या Hex नोटेशन में 2 संख्याओं की ये शक्ति भी अच्छी लगती है।

Answer 8

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

यह भी एक विशेष बिट या सेट नहीं है पर निर्भर करता है लगातार बदलाव जोड़ने के जेनेरिक mulplication एल्गोरिथ्म के बजाय एक भी पारी का उपयोग कर गुणा करने के लिए आसान है। ओपनजीएल विशेष स्कैन लाइनों तक पहुंचने के लिए बनावट के लिए दो आकारों की शक्ति की आवश्यकता के लिए प्रसिद्ध था।

Answer 9

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

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

उदाहरण के लिए, सी में, एक चक्रीय बफर में पढ़ने के लिए उपलब्ध बाइट्स की संख्या से प्राप्त किया जा सकता:

pending = (SIZE + wr - rd) & (SIZE - 1); 

दो की शक्ति का उपयोग नहीं तो बराबर होगा:

pending = (SIZE + wr - rd) % (SIZE - 1); 

मशीनों है कि एक प्रभाग/मापांक अनुदेश लागू नहीं है कि छोटी "%" कई सौ चक्र का समय लग सकता है, तो आप की तरह कुछ की आवश्यकता होगी पर:

if (wr >= rd) 
    pending = wr - rd; 
else 
    pending = (SIZE + wr) - rd; 

कौन सा कोड बंद करता है और ब्रांचिंग का कारण बनता है जो निर्देश पाइपलाइन को रोक सकता है।

बफर जो था जैसे

buf[wr++] = x; 
if (wr == SIZE) 
    rd = 0; 

कुछ (आमतौर पर) और अधिक कुशल हो जाता है लेखन:

buf[wr++] = x; 
wr &= SIZE-1; 

बेशक

अगर आप सूचकांक एक 256 प्रविष्टि सरणी के लिए एक अहस्ताक्षरित 8 बिट चर इस्तेमाल किया तो आपको मास्किंग करने की भी आवश्यकता नहीं थी।