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

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

एक गिबीबाइट 1,073,741,824 बाइट की है, यानी गीगाबाइट से क़रीब 7% ज़्यादा। Windows गिबीबाइट में नापता है पर उन्हें «GB» कहता है — और «जगह कम क्यों दिख रही है» वाली पूरी पहेली इसी में है।

इस तरफ़ हिसाब भाग का है, और वह भी पूरे अंक से: 1,07,37,41,824 इकाइयाँ एक गिबीबाइट में बिना कुछ बचे समा जाती हैं। असुविधा बस इतनी है कि नतीजे भिन्न में आते हैं — एक तिहाई, एक बटा बारह — उन गोल अंकों की जगह जो उलटी दिशा देती है।

फिर भी गोलाई में कुछ नहीं खोता, क्योंकि भाग पूरा उतरता है। अगर नतीजा दशमलव में टिकता ही न हो — 0.0833… और उसके जैसे — तो वह भिन्न झलक रही है, कोई ग़लती नहीं घुस रही।

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

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

कोई सॉफ़्टवेयर आकार बाइट में देता है सिद्धांत के तौर पर: संख्या में कोई उपसर्ग नहीं जिसे समझना पड़े, कोई गोलाई नहीं जो पलटनी पड़े, और JSON एक्सपोर्ट, Content-Length हेडर और लॉग की लाइन बिना पहले सहमत हुए आपस में तुलना हो सकते हैं। यही चीज़ नतीजे को अपठनीय भी बनाती है — 17,179,869,184 बाँटे बिना कुछ नहीं कहता।

जब मशीन खुद बाइनरी में सोचती है — मेमोरी, पेज कैश, डिस्क पर जगह, ज़्यादातर ऑपरेटिंग-सिस्टम काउंटर — तब बाँटने की संख्या 1,073,741,824 है। यह ठीक 16 GiB पर उतरती है। इसकी जगह एक अरब से बाँटना यह छिपा देता है कि मान एक सफ़ाई से बनी 2 की घात था।

बाँटने से पहले अंक गिन लीजिए। दस अंक आपको 0.93 से 9.3 GiB के बीच रखते हैं, ग्यारह 9.3 से 93 के बीच, बारह 93 से 931 के बीच, और तेरह अंक आपको लगभग एक टेबिबाइट के आस-पास ले जाते हैं। यह एक झलक ही ज़्यादातर सवालों का जवाब दे देती है।

यह आदत ख़ासतौर पर उन आउटपुट पर काम आती है जो अलग-अलग पैमाने मिलाते हैं। कोई API जो बारह बाइट-काउंटर लौटाए, उनमें कुछ लाखों में और कुछ अरबों में होंगे, और आँख लंबाई से जल्दी छाँट लेती है, मान से नहीं।

कुछ संख्याएँ ख़ुद अपनी पहचान बताती हैं। 1,073,741,824 एक गिबिबाइट है, 2,147,483,648 दो, 4,294,967,296 चार, 8,589,934,592 आठ, 17,179,869,184 सोलह। इनमें से कोई भी किसी आउटपुट में दिखे तो वह लगभग हमेशा कोई क्षमता या सीमा है, क्योंकि कोई असली मापा हुआ आँकड़ा ठीक 2 की घात पर नहीं उतरता।

उलटा भी काम आता है। कोई बाइट-काउंटर जो कई शून्यों पर ख़त्म होता है — 1,000,000,000, 50,000,000,000 — किसी इंसान ने टाइप किया या किसी दशमलव मान से निकाला गया, हार्डवेयर की अपनी उपज नहीं।

जो भाषाएँ हर संख्या को double-precision float में रखती हैं, वे 9,007,199,254,740,991 तक — यानी 2⁵³ घटा एक, लगभग 8 PiB तक — पूर्णांक को ठीक-ठीक दर्शाती हैं। इससे ऊपर मान चुपचाप गोल हो जाते हैं, और दो अलग-अलग आकार बराबर तुलना कर सकते हैं बिना कोई त्रुटि दिए।

ज़्यादातर सिस्टम कभी यहाँ नहीं पहुँचते, और जो पहुँचते हैं वे इकाई की बजाय जोड़-योग पर वहाँ पहुँचते हैं — किसी बेड़े का कुल, आजीवन ट्रांसफ़र-काउंटर। बचाव है काउंटर को 64-बिट पूर्णांक या स्ट्रिंग में रखना।

ज़्यादातर उपयोगिताओं में एक मोड होता है जो उनकी पढ़ने-लायक़ फ़ॉर्मेटिंग हटा देता है, और जब आउटपुट स्क्रीन से आगे कहीं जाना हो तो उसका इस्तेमाल करना समझदारी है। डिस्क-स्पेस औज़ार एक की ब्लॉक-साइज़ स्वीकारते हैं, फ़ाइल-मेटाडेटा क्वेरी सटीक लंबाई लौटाती हैं, और ऑब्जेक्ट-स्टोरेज API सिद्धांत से बाइट में content-length लौटाते हैं।

गुम हुई सटीकता बाद में वापस नहीं आती। स्क्रीन पर 1.4 GiB दिखने वाला मान असल में 1,449,551,462 और 1,556,925,644 के बीच कहीं भी हो सकता है — 100 MB से ज़्यादा का फ़र्क़ — और कोई गुणा उस अनिश्चितता को नहीं सिकोड़ता।

ज़्यादातर बहस से बचने वाला नियम है वही इकाई दिखाना जिसमें मापा गया सिस्टम गिनता है। मेमोरी, पेज कैश, वॉल्यूम पर घिरी जगह — ये बाइनरी में हैं, तो उन्हें दिखाने वाला चार्ट GiB में होना चाहिए। ऑब्जेक्ट-स्टोरेज कुल, egress-मात्रा और बिल पर दिखने वाला कुछ भी दशमलव में है, तो GB में।

जो भी इकाई चुनी जाए, अक्ष का लेबल यह बताना चाहिए कि वह कौन-सी है। GB लिखी हुई मेमोरी-चार्ट जो असल में 2³⁰ से भाग रही हो, वही ग़लती दोहराती है जो Windows करता है — किसी दिन उसे बिल के दशमलव मान से मिलाया जाएगा।

सबसे सस्ती जाँच है ऑपरेशन उलटकर दोहराना। GiB वाला आँकड़ा लीजिए, 1,073,741,824 से गुणा कीजिए, और मूल अंकों की लड़ी से मिलाइए। नतीजा लगभग सात प्रतिशत कम हो तो भाजक एक अरब था, 2³⁰ नहीं; अगर 1,024 के गुणक जितना अलग हो, तो कहीं एक उपसर्ग छूट गया।

जहाँ बदलाव किसी कोड में एम्बेडेड हो, वही जाँच किसी टेस्ट में जगह पाती है: 5,368,709,120 बाइट का मतलब है 5 GiB, और जो भी implementation 5.37 दे वह दशमलव भाजक इस्तेमाल कर रहा है।