TiB से TB में बदलें

एक टेबीबाइट 1,024 गिबीबाइट की है। टेराबाइट से इसका फ़ासला हर सीढ़ी पर बढ़ता है: किलो पर 2.4%, मेगा पर 4.9%, गीगा पर 7.4% और टेरा पर 10%।

एक टेराबाइट एक हज़ार अरब बाइट है, यानी 10¹²। जो डिस्क 1 TB कहकर बेची जाती है उसमें ठीक इतना ही होता है: जो जगह कम लगती है वह इकाइयों का मतभेद है, कमी नहीं।

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

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

हर स्टोरेज-प्रोजेक्ट यह सीमा दो बार पार करता है। ड्राइव दशमलव टेराबाइट में लिखी price-list से चुनी जाती हैं, बनने वाला pool tebibyte गिनने वाले सॉफ़्टवेयर से बताया जाता है।

बदलाव ख़ुद एक गुणा है — tebibyte गुणा 1.099511627776 टेराबाइट देता है। पेज इसलिए ज़रूरी है क्योंकि अंक शायद ही कभी अकेला आता है — parity, fill-सुझाव, फ़ाइल-तंत्र, हर एक और हिस्सा काटता है।

raw क्षमता से शुरू कीजिए — चार 4 TB ड्राइव 16 TB हैं। 1,099,511,627,776 से बाँटने पर array 14.55 TiB रखता है, जो pool-रिपोर्ट redundancy से पहले दिखाएगी।

Single parity एक ड्राइव-भर क्षमता लेता है, 12 TB इस्तेमाल-योग्य छोड़ते हुए, यानी 10.91 TiB। Double parity 8 TB, या 7.28 TiB छोड़ता है।

ज़रूरतें tebibyte में तब आती हैं जब वे किसी चलते तंत्र से निकलती हैं — backup-कैटलॉग, डेटाबेस-आकार। ख़रीदारी से पहले ऊपर की तरफ़ बदलना कम-ख़रीद रोकता है।

ओवरहेड सही क्रम में जोड़िए — पहले दशमलव में बदलिए, फिर redundancy-layout छोड़े गए हिस्से से बाँटिए, फिर headroom-नीति जोड़िए।

Storage-सॉफ़्टवेयर आमतौर पर दो अलग कुल बताता है और वे एक अंक नहीं हैं। Pool-स्तर की कमानें raw क्षमता दिखाती हैं, फ़ाइल-तंत्र-स्तर की वह जो असल में लिखी जा सके।

सुलझाने वाली जाँच है दोनों अंकों को दशमलव टेराबाइट में बदलकर लगी असली ड्राइव के ख़िलाफ़ मिलाना। raw अंक बॉक्स-क्षमताओं के जोड़ के लगभग एक प्रतिशत भीतर होना चाहिए।

असहमति हर पायदान पर 1.024 के गुणक से जमा होती है। एक kibibyte किसी kilobyte से 2.4 प्रतिशत ऊपर बैठता है, एक mebibyte 4.9 प्रतिशत, एक gibibyte 7.4, और एक tebibyte 9.95 प्रतिशत।

यही वजह है array-पैमाने पर capacity-योजना ग़लत होती है, फ़ाइल-पैमाने पर लगभग कभी नहीं। किसी दस्तावेज़ पर इकाई मिलाना कुछ बाइट की क़ीमत लेता है।

Copy-on-write फ़ाइल-तंत्र भरने के पास पहुँचते ही साफ़ धीमे पड़ते हैं, और सामान्य सलाह है नियमित लिखावट वाले pool पर इस्तेमाल अस्सी प्रतिशत से नीचे रखना।

यह आरक्षण हर दूसरी कटौती के बाद आता है, इसलिए चार 4 TB single-parity ड्राइव से मिली 10.91 TiB व्यावहारिक रूप से 8.73 TiB बनती है।

Striped और parity-layout बराबर आकार की इकाइयों में काम करते हैं, इसलिए असमान क्षमता वाली ड्राइव का सेट आमतौर पर हर सदस्य के लिए सबसे छोटी ड्राइव का आकार इस्तेमाल करता है।

4 TB ड्राइव के सेट में 12 TB ड्राइव जोड़ना सिर्फ़ 4 TB जोड़ता है और बाक़ी 8 इस्तेमाल-रहित छोड़ता है — यह किसी इकाई-बदलाव से नहीं दिखता।

अलग निर्माताओं की नाम-मात्र बराबर ड्राइव हमेशा एक जैसी बाइट-गिनती नहीं देतीं, और असली ड्राइव से कुछ मेगाबाइट छोटा replacement किसी array द्वारा नकारा जा सकता है।

बचाव है लेबल के बजाय बाइट-गिनती दर्ज करना जब array बनाया जाए। 4 TB कहा गया कोई ड्राइव 4,000,787,030,016 बाइट दे सकता है — यही अंक रखने लायक़ है।