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

एक किबीबाइट ठीक 1,024 बाइट की है। यह नाम 1998 में इसलिए लाया गया कि «किलोबाइट» फिर से 1,000 का मतलब दे सके, हालाँकि चलन कभी पूरी तरह जमा नहीं।

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

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

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

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

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

हिसाब सबसे छोटी बात है: 1,024 से गुणा कीजिए और बाइट गिनती सटीक है। यह पेज इसलिए लायक़ है क्योंकि स्रोत आँकड़ा आधा दर्जन अलग-अलग लेबल में आता है। Kernel इंटरफ़ेस kB छापते हैं और किबिबाइट का मतलब रखते हैं। k फ़्लैग वाले टूल किबिबाइट में रिपोर्ट करते हैं और कुछ नहीं कहते।

यह पाठक को गुणा से पहले पहचान का क़दम उठाने पर मजबूर करता है। भरोसेमंद जाँच है टूल, लेबल नहीं: Unix-जैसे सिस्टम पर memory या block इस्तेमाल बताने वाली कोई भी चीज़ 1,024 की इकाई में गिनती करती है जब तक साफ़ तौर पर SI इकाई न माँगी गई हो।

किसी फ़ाइल की सहेजी block count 512-बाइट इकाई में बताई जाती है, फ़ाइलसिस्टम के भीतर असल में जो भी allocate हो। तो एक 4,096-बाइट block वाली फ़ाइल आठ block बताती है। वही फ़ाइल du -k के तहत 4 बताती है, क्योंकि वह टूल किबिबाइट में गिनता है। दोनों आँकड़े सही हैं।

व्यावहारिक नियम है तुलना से पहले सब कुछ बाइट में बदलना। आठ 512-बाइट block और चार किबिबाइट दोनों 4,096 बाइट हैं, और यह सहमति तब तक अदृश्य है जब तक दोनों को उसी तरह बताया न जाए।

शब्द "आकार" के पीछे दो अलग सवाल छुपे हैं। फ़ाइल की लंबाई वह बाइट गिनती है जो इसमें है; यह जो जगह घेरती है वह allocated block गिनती गुणा block आकार है। 100-बाइट कॉन्फ़िग फ़ाइल के लिए ये 100 बाइट और 4,096 बाइट हैं, चालीस गुना फ़र्क़।

यह फ़र्क़ दोनों दिशाओं में जाता है। Sparse फ़ाइल — जिसमें कभी allocate न हुए बिना-लिखे इलाक़े हों — अपने रखे block से कहीं बड़ी लंबाई बताती है, यही वजह है virtual disk image 40 GiB दिखा सकती है और 3 इस्तेमाल कर सकती है।

Shell resource limit अपनी इकाई मिलाती हैं और यह मिलावट आउटपुट से साफ़ नहीं दिखती। Stack size limit और virtual memory limit किबिबाइट में हैं, तो 8192 पढ़ती stack limit 8,388,608 बाइट है। File size limit bash में डिफ़ॉल्ट रूप से 512-बाइट block में है।

इन्हें बदलने की वजह आम तौर पर यह है कि कुछ और बाइट में बताया जा रहा है। Memory error से फ़ेल हुई प्रोसेस अपनी कोशिश की गई allocation बाइट में बताती है; इसे किबिबाइट में बताई limit से मिलाना एक गुणा लेता है।

एक निश्चित बारीकी से नीचे बाइट गिनती काम की संख्या नहीं रहती। Memory पन्नों में बँटी जाती है, और ज़्यादातर सिस्टम पर पन्ना 4,096 बाइट का होता है। फ़ाइलसिस्टम block में allocate करते हैं, और आम डिफ़ॉल्ट वही आँकड़ा है।

यही alignment वजह है buffer आकार, cache प्रविष्टियाँ और record लंबाई 4,096 के गुणज पर जमा होती हैं। 4,000 बाइट पढ़ना उसी पन्ने को छूता है जो 4,096 का और उतनी ही क़ीमत लेता है; 4,100-बाइट record दो block में फैलता है।

इस पैमाने पर किलोबाइट और किबिबाइट के बीच फ़र्क़ 24 बाइट है, और ज़्यादातर मक़सद के लिए यह गोलाई में खो जाता है। यह मायने रखने लगता है जब गुणा हो। चार-KiB की दस लाख record 4,096,000,000 बाइट हैं, 4,000,000,000 नहीं, और दूसरे आँकड़े पर बनी क्षमता योजना 96 MB कम पड़ जाती है।

यही रिक्वेस्ट-दर-रिक्वेस्ट लेखा, quota गणना और किसी और चीज़ पर लागू होता है जहाँ छोटी इकाई बड़ी गिनती से गुणा होती है: फ़र्क़ बढ़ता नहीं, पर वह गिनती बढ़ती है जिससे गुणा होता है।

हर k, 1,024 नहीं है, और उल्टा मान लेना अपनी ही ग़लती है। Network throughput, transfer allowance, storage क्षमता और पैकेजिंग पर छपी कोई भी चीज़ दशमलव हैं, तो वहाँ किलोबाइट 1,000 बाइट है और 1,024 से गुणा करना नतीजा 2.4 प्रतिशत ज़्यादा बताता है।

दोनों को ज़्यादा सोचे बिना ढँकने वाला नियम: अगर संख्या यह बताती है मशीन भीतर क्या कर रही है, यह binary है; अगर यह बताती है क्या बेचा, ट्रांसफ़र या विज्ञापित हो रहा है, यह दशमलव है।

बाइट गिनती किसी भी पर्याप्त चौड़े integer टाइप में सटीक रहती है, और 1,024 से गुणी किबिबाइट संख्या भी सटीक रहती है। मुसीबत तब शुरू होती है जब मान पहले ही दिखावे के लिए गोल किया जा चुका हो: 1.4 KiB छापने वाला टूल असली बाइट गिनती फेंक चुका है।

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