MiB से B में बदलें

एक मेबीबाइट 1,024 किबीबाइट की है, यानी 1,048,576 बाइट। Linux के औज़ार और याददाश्त की संख्याएँ लगभग हमेशा यही कहती हैं, भले लिखा «MB» हो।

एक बाइट आठ बिट की होती है, और यह हमेशा तय नहीं था: शुरुआती कंप्यूटर छह, सात या नौ इस्तेमाल करते थे। आठ इसलिए जीता कि उसमें एक अक्षर बैठ जाता है और वह संख्या साफ़-साफ़ आधों में बँटती है।

इस तरफ़ हिसाब गुणा का है, और वह भी पूरे अंक से: एक मेबीबाइट बराबर 10,48,576 बाइट, ठीक-ठीक। 10,48,576 कोई नाप नहीं है जो पास आ गई हो, यह परिभाषा है।

इसीलिए यह उन गिनी-चुनी गिनतियों में है जो दिमाग़ में करने लायक़ हैं, और नतीजा जाँचा भी जा सकता है: वापस भाग दीजिए और आपको ठीक उसी अंक पर लौटना होगा जहाँ से चले थे, बिना किसी बची हुई गुंजाइश के।

एक MiB अपने नीचे वाली इकाई का 1,024 गुना होता है; एक MB 1,000 गुना। इस पेज पर यह 1048576 B और 1000000 B का फ़र्क़ है — 4.9 % — और हर सीढ़ी पर यह फ़ासला बढ़ता जाता है। इसीलिए एक तस्वीर पर यह गोलाई भर है और हार्ड डिस्क पर दिखने लायक़ हिस्सा।

ग़ायब जगह का पूरा रहस्य इतना ही है, और इस पेज पर वह 4.9 % का बनता है। MB के नाम पर बिकी डिस्क में ठीक उतना ही होता है जितना डिब्बे पर लिखा है — दशमलव हिसाब से एक MB यानी 1000000 B। विंडोज़ उसे 1,000 के बजाय 1,024 से बाँटता है और नाम दशमलव वाला ही रखता है, इसलिए उसका «एक MB» दरअसल 1048576 B का निकलता है और डिस्क का अंक उतना ही छोटा दिखने लगता है। ऐपल का मैकओएस 10.6 से इन्हें दशमलव इकाइयों में ही गिनता है, और यही वजह है कि एक ही डिस्क दो मशीनों पर दो अलग आकार की दिख सकती है। न कुछ ग़ायब हुआ है, न कोई गोलाई हुई है — वही बाइट दो नामों से गिने जा रहे हैं।

ज़्यादातर आकार-बदलाव इसलिए होते हैं ताकि कोई इंसान मात्रा समझ सके। यह अक्सर इसलिए होता है ताकि कोई मशीन उसे लागू कर सके — अपलोड-सीमा, heap-आकार, buffer।

यहाँ काम का अंक 1,048,576 और उसके गुणक हैं, कोई अंदाज़ा नहीं। दस MiB है 10,485,760 बाइट; 64 MiB है 67,108,864।

बहुत सारा सॉफ़्टवेयर अंक के आगे एक अक्षर लेता है और उसे 1,024-आधारित मानता है। nginx के k और m suffix बाइनरी हैं। JVM के heap-फ़्लैग बाइनरी हैं।

GNU dd दोनों परंपराएँ स्वीकारता है और लंबाई से अलग करता है — bs=1M है 1,048,576 बाइट, bs=1MB है 1,000,000। स्क्रिप्ट के बीच block-size कॉपी करते वक़्त suffix ठीक-ठीक कॉपी कीजिए।

Kubernetes दोनों पैमाने साफ़ स्वीकारता है — memory: 512Mi है 536,870,912 बाइट और memory: 512M है 512,000,000। दोनों वैध हैं, दोनों schema-जाँच पार करते हैं।

फ़र्क़ ऊपर के पैमाने पर चौड़ा होता है — mega क़दम पर 4.86 प्रतिशत, giga पर 7.37, इसलिए 4Gi और 4G लगभग 295 मेगाबाइट अलग हैं।

कोड में गुणा-अंक साफ़ लिखा हुआ अंक हरा देता है। 1024 * 1024 और 1 << 20 दोनों बताते हैं मान क्या है और कोई समीक्षक शून्य गिने बिना जाँच सकता है।

अनुशासन का दूसरा हिस्सा नामकरण है। maxBytes नाम का खाना ग़लती से mebibyte-अंक नहीं ले सकता; maxSize नाम का खाना ले सकता है।

यहाँ पहुँचने वाला अंक आमतौर पर किसी ऐसी चीज़ से आता है जो डिफ़ॉल्ट रूप से बाइनरी इकाई में मापती है। free डिफ़ॉल्ट रूप से kibibyte में बताता है। /proc/meminfo kB छापता है और kibibyte का मतलब रखता है।

यह सुविधाजनक है — उस पढ़ाई को 1,048,576 से गुणा करना बिना किसी नुक़सान के असली बाइट-अंक तक वापस पहुँचाता है।

MiB में साफ़ अंक बाइट में अटपटा हो जाता है, और दोनों पैमाने पर एक साथ साफ़ रहने की कोई व्यवस्था नहीं। 700 MiB है 734,003,200 बाइट। 250 MiB है 262,144,000।

क्लासिक मिसाल है CD — अस्सी-मिनट की डेटा-डिस्क 737,280,000 बाइट रखती है, यानी 703.125 MiB। तीस साल से इसे «700 MB डिस्क» कहा जाता रहा है, जो न दशमलव 700 MB है, न बाइनरी 700 MiB।

एक mebibyte ठीक 256 मेमोरी-page है 4,096 बाइट के, या 2,048 डिस्क-सेक्टर 512 बाइट के। हर सीमा पूरे अंक पर बैठती है — यही वजह है buffer, ring-buffer, mmap-क्षेत्र बाइनरी इकाई में तय होते हैं।

दशमलव मेगाबाइट इनमें से किसी में साफ़ नहीं बँटता — 1,000,000 बाइट 244.14 page है, इसलिए किसी buffer का एक सिरा किसी page-सीमा को लाँघता है।

mebibyte में बताई सीमा के लिए एक नहीं, तीन fixture चाहिए, और उनके आकार इसी बदलाव से निकलते हैं। 10 MiB की सीमा के लिए काम के बाइट हैं 10,485,759, 10,485,760, 10,485,761।

ऐसे fixture इकाई में नहीं, बाइट-गिनती में बनाना बेहतर है। किसी सहज इकाई में बनाई फ़ाइल उसी आधार को विरासत में लेती है जो बनाने वाले औज़ार ने चुना।