समय की तलाश करें
मुद्दा यह है कि, लिखना है की तलाश लिखने के लिए बहुत अलग ढंग प्रवर्धन बर्ताव प्रवाह प्रवर्धन। समता के साथ न्यूनतम लेखन थ्रूपुट प्रवर्धन तब होता है जब एक बार में एक पूरी पट्टी लिखी जाती है (आइए इस विशेषण को 'पूर्ण-धारी' कहते हैं) फिर भी न्यूनतम लिखने का प्रयास प्रवर्धन होता है, इसके विपरीत, जब वर्चुअल में एक खोज के बाद पूरा लेखन फिट बैठता है एक अकेला हिस्सा। विस्तार में जाने से पहले, संबंधों को सारणीबद्ध रूप में व्यक्त करना बहुत आसान है:
RAID | write throughput amplification factor | write seek amplification factor
| full-stripe (e.g.) | single-chunk | full-stripe | single-chunk
0 | 1 ; 1 | 1 ; 1 | n ; 12 | 1 ; 1
1 | n ; 12 | n ; 12 | n ; 12 | n ; 12
5 | n/(n - 1) ; ~1.1 | min [3, n] ; 3 | n ; 12 | min [3, n] ; 3
6 | n/(n - 2) ; 1.2 | min [5, n] ; 5 | n ; 12 | min [5, n] ; 5
*1+0 | n₁ ; 3 | n₁ ; 3 | n ; 12 | n₁ ; 3*
1+5 | n/(n₅ - 1) ; 2.4 | expr₁ ; 5 | n ; 12 | expr₁ ; 5
*1+6 | n/(n₆ - 2) ; 3 | expr₂ ; 8 | n ; 12 | expr₂ ; 8*
expr₁ = 2n₁ + min [1, n₅ - 2]
expr₂ = 3n₁ + min [2, n₆ - 3]
जहां n ड्राइव की कुल संख्या है, n₁ RAID 1 समूहों में ड्राइव की संख्या है, और n₅ और n of क्रमशः RAID 5 या RAID 6 सरणियों में समूहों की संख्या है। प्रश्न में 12-ड्राइव उदाहरण से संबंधित उदाहरण (प्रासंगिक पंक्तियां ' *bolded*' हैं); RAID स्तर 1 + 0, 1 + 5, 1 + 6 के उदाहरण क्रमशः 4 × 3, 6 × 2, 6 × 2 हैं।
ध्यान दें कि केवल पूर्ण-पट्टी लेखन थ्रूपुट प्रवर्धन कारक सीधे अतिरेक के अनुपात से संबंधित है। एकल-चंक मामले समानता वाले लोगों के लिए अधिक जटिल हैं। वे उठते हैं क्योंकि एकल चंक को लिखने के लिए जो भी पढ़ने की आवश्यकता होती है जो नए डेटा चंक के साथ समता के विखंडू लिखने से पहले समता के विखंडू या अन्य डेटा विखंडू में से सबसे आसान होता है। (वे सीधे गुणक नहीं हैं, क्योंकि प्रेरित पठन को संबंधित पढ़े गए थ्रूपुट / आरईएम 1 के लिए प्रवर्धन कारक से गुणा किया जाना चाहिए, दोनों 1 होने के नाते; नीचे देखें।)
दुर्भाग्य से, इस अतिरिक्त लेखन थ्रूपुट प्रवर्धन को न्यूनतम करने वाले एक चंक आकार को वास्तव में अधिकतम करने का दुष्प्रभाव हैलिखने के प्रवर्धन की तलाश करें। एक छोटे से लिखने के समय की तुलना में नगण्य समय के साथ लिखने के लिए, बहुत छोटे चंक आकार (पूर्ण-धारी होने के लिए) के साथ स्ट्रिपिंग का प्रदर्शन केवल 1 × है, जैसे कि मिररिंग, क्योंकि इसके लिए सभी ड्राइव की आवश्यकता होती है प्रत्येक लेखन के लिए विखंडू और इन सभी ड्राइव को जुटाने से प्राप्त थ्रूपुट अप्रासंगिक है। इसने सरणी में ड्राइव की संख्या से समय लेने के लिए लिखने के समय के अनुपात को विभाजित किया है, लेकिन छोटे लेखन के लिए यह पहले से ही नगण्य था। यह एक छोटा आकार का उपयोग करने के लिए समझ में नहीं आता है ताकि छोटे-छोटे भी पूर्ण-पट्टी लिख सकें। लिखने के प्रभावों को महसूस करने के लिए पर्याप्त छोटे लिखने के लिए, यह सबसे अच्छा है कि वे एक ही भाग में फिट हों।
RAID | large contiguous write throughput | concurrent tiny writes throughput
| full-stripe | single-chunk | full-stripe | single-chunk
0 | n× ; 12× | n× ; 12× | 1× ; 1× | n× ; 12×
1 | 1× ; 1× | 1× ; 1× | 1× ; 1× | 1× ; 1×
5 | (n - 1)× ; 11× | max[n/3, 1]×; 4× | 1× ; 1× | max[n/3, 1]×; 4×
6 | (n - 2)× ; 10× | max[n/5, 1]×; 2.4× | 1× ; 1× | max[n/5, 1]×; 2.4×
*1+0 | n₀× ; 4× | n₀× ; 4× | 1× ; 1× | n₀× ; 4× *
1+5 | (n₅ - 1)×; 5× | expr₃× ; 2.4× | 1× ; 1× | expr₃× ; 2.4×
*1+6 | (n₆ - 2)×; 4× | expr₄× ; 1.5× | 1× ; 1× | expr₄× ; 1.5×*
expr₃ = n/(2n₁ + min [1, n₅ - 2]) = max [n/(2n₁ + 1), n/(2n₁ + n₅ - 2)]
expr₄ = n/(3n₁ + min [2, n₆ - 3]) = max [n/(3n₁ + 2), n/(3n₁ + n₆ - 3)]
नोट: मध्य 2 थ्रूपुट स्तंभों को एक समझदार चंक आकार दिया जा सकता है, जिसे लिखने से बड़ा है, जिसके लिए खोज समय महत्वपूर्ण है, लेकिन इतना छोटा है कि बड़े लेखन पूर्ण-धारी हैं। 2 डी थ्रूपुट कॉलम का बड़ा हिस्सा आकार स्पेंडेड ड्राइव के समान है। एक 'नन्हा' लेखन वह जगह है जहाँ थ्रूपुट का प्रभाव नगण्य है।
एक अनुचित रूप से छोटे चंक आकार होने से भी पढ़ने के लिए प्रवर्धन का प्रभाव बढ़ जाता है, हालांकि पूर्ण पट्टी मामले में उतना और केवल नहीं।
RAID | read throughput amplification factor | read seek amplification factor
| full-stripe | single-chunk | full-stripe (e.g.) | single-chunk
0 | 1 | 1 | n to n; 12 | 1
1 | 1 | 1 | 1 to n; 1–12 | 1
5 | 1 | 1 | n - 1 to n; 11–12 | 1
6 | 1 | 1 | n - 2 to n; 10–12 | 1
*1+0 | 1 | 1 | n₀ to n; 4–12 | 1 *
1+5 | 1 | 1 | n₅ - 1 to n; 5–12 | 1
*1+6 | 1 | 1 | n₆ - 2 to n; 4–12 | 1 *
नोट: 'एन' इसलिए है क्योंकि जब समवर्ती रूप से केवल एक ही रीडिंग हो रही है, तो सैद्धांतिक रूप से उपयुक्त स्थानों की तलाश के लिए सभी ड्राइव जुटाना और सामूहिक रूप से अधिकतम बड़े सन्निहित रीड थ्रूपुट के लिए डेटा पढ़ना संभव है।
RAID | large contiguous read throughput | concurrent tiny reads throughput
| full-stripe (e.g.)| single-chunk | full-stripe | single-chunk
0 | n× ; 12× | n× ; 12× | 1× ; 1× | n× ; 12×
1 | n× ; 12× | n× ; 12× | n× ; 12× | n× ; 12×
5 | n× ; 12× | n× ; 12× | n/(n - 1)× ; ~1.1× | n× ; 12×
6 | n× ; 12× | n× ; 12× | n/(n - 2)× ; 1.2× | n× ; 12×
*1+0 | n× ; 12× | n× ; 12× | n₁× ; 3× | n× ; 12×*
1+5 | n× ; 12× | n× ; 12× | n/(n₅ - 1)× ; 2.4× | n× ; 12×
*1+6 | n× ; 12× | n× ; 12× | n/(n₆ - 2)× ; 3× | n× ; 12×*
नोट: फिर से, मध्य 2 थ्रूपुट स्तंभों को एक समझदार चंक आकार दिए जाने पर ध्यान नहीं दिया जा सकता है। तीसरा थ्रूपुट स्तंभ फिर से अतिरेक के अनुपात से जुड़ा हुआ है।
हालांकि, एक बड़े पर्याप्त चंक आकार का अर्थ है कि छोटे रीड कभी पूर्ण-धारी नहीं हैं। इसलिए एक कुशल कार्यान्वयन और उचित चंक आकार दिया गया है, पढ़ा हुआ प्रदर्शन खराब नहीं होने पर समान ड्राइव की संख्या के लिए आनुपातिक होना चाहिए।
इसलिए वास्तव में, 'प्रवर्धन कारक' प्रश्न में सूत्र की तुलना में बहुत अधिक जटिल है, जहां केवल पूर्ण-धारी थ्रूपुट प्रवर्धन पर विचार किया गया था। विशेष रूप से, समवर्ती के लिए 6 × 2 RAID 1 + 6 का लेखन प्रदर्शन लिखता है जो कि छोटे-से-छोटे होते हैं जो 4-× 3 RAID 1 + 0 की तुलना में खराब होंगे। और छोटे लेखन के लिए, जो सभी की तलाश में हैं, प्रदर्शन केवल 4 × 3 RAID 1 + 0 में से 3 के बारे में हो सकता है, जो कि सबसे अच्छा है (यानी एक पूर्ण कार्यान्वयन दिया गया है)।
क्लीयर होने के बाद, 12-ड्राइव की तुलना में एक सटीक विजेता नहीं होता है:
| 4×3 RAID 1+0 | 6×2 RAID 1+6
number of identical 1TB drives | 12 | 12
storage capacity | 4TB | 4TB
redundancy proportion | 2/3 | 2/3
large contiguous write throughput | 4× | 4×
large contiguous read throughput | 12× | 12×
concurrent tiny writes throughput |*4× | 1.5×
concurrent tiny reads throughput | 12× | 12×
safe number of random drive loses | 2 |*5
12 - 1 large write throughput | 4× | 4×
12 - 1 large read throughput | 8× |*11×
12 - 1 tiny writes throughput |*4× | ~1.42×
12 - 1 tiny reads throughput | 8× |*~9.33×
can split-off a copy for backup | yes[1] | yes[1]
2-site failover | yes | yes
2-copy large write throughput | 4× | 4×
2-copy large read throughput |*8× | 6×
2-copy tiny writes throughput |*4× | ~1.28×
2-copy tiny reads throughput |*8× | 6×
2-copy safe random drive loses | 1 |*2
2-copy - 1 large write throughput | 4× | 4×
2-copy - 1 large read throughput | 4× |*5× or 6×[2]
2-copy - 1 tiny writes throughput |*4× | ~1.46× or 1.2×[2]
2-copy - 1 tiny reads throughput | 4× |*3.6x or 6×[2]
can be divided into 3 full copies | yes | yes
3-site failover | yes | yes
1-copy large write throughput | 4× | 4×
1-copy large read throughput | 4× | 4×
1-copy tiny writes throughput |*4× | ~0.85×
1-copy tiny reads throughput |*4× | 2×
1-copy safe random drive loses | 0 | 0
complexity |*simple | more complex
नोट 1: संग्रहीत डेटा की एक पूरी प्रति क्रमशः एक RAID 0 चौगुनी या 4/6 नीचा RAID 6 सरणी है। नोट 2: इस बात का भी एक मौका है कि क्या ड्राइव विफलता 4 अपमानित RAID 1 जोड़े में से एक को रद्द करती है या 2 सामान्य जोड़े में से एक को नीचा दिखाती है।
फिर भी, इसमें 6 ड्राइव के RAID 6 एरे के डबल प्रदर्शन को दोगुना करना होगा और छोटे से लिखता है कि 25% बेहतर होना चाहिए (1.5 / 1.2) आवश्यक रीड के कारण RAID 1 जोड़े के बीच विभाजित किया जा रहा है, और RAID 6 स्पष्ट रूप से होता है उपयुक्त अनुप्रयोगों, उच्च उपलब्धता अनुप्रयोगों बड़ा राईट है या कि है कि और अधिक लिखने प्रदर्शन की तुलना में पढ़ने के प्रदर्शन के बारे में चिंतित हैं में तो है, हो सकता है वहाँ है RAID 1 + 6 afterall के लिए एक जगह। लेकिन वह सब नहीं है…
जटिलता
यह अभी भी सिद्धांत में अभी तक (ज्यादातर कॉम्बीनेटरिक्स ) है, व्यवहार में जटिलता का मतलब होगा कि RAID 1 + 6 के कार्यान्वयन में कमियां हो सकती हैं जो अवसरों को याद करती हैं और सैद्धांतिक परिणामों को प्राप्त नहीं करती हैं। RAID 6 पहले से ही अधिक जटिल है, और नेस्टिंग इसमें से कुछ अधिक जटिलता जोड़ता है।
उदाहरण के लिए, यह तुरंत स्पष्ट नहीं है कि 6 × 2 RAID 1 + 6 को 3 स्वतंत्र वर्चुअल रीड हेड के रूप में सारगर्भित किया जा सकता है, जो 4 × थ्रूपुट प्रत्येक पर 3 सन्निहित बड़े रीड को पढ़ने में सक्षम है, जैसे 4 × 3 RAID 1 + 0। बस 6 RAID 1 जोड़े को एक RAID 6 सरणी में एक सॉफ्टवेयर का उपयोग करके RAID इतना सुंदर नहीं हो सकता है; कार्यान्वयन बेवकूफ़ और थ्रैश हो सकता है (मैंने इस परिकल्पना का अभी तक परीक्षण नहीं किया है)।
जटिलता कार्यान्वयन और उपकरणों के विकास की बढ़ी हुई लागत भी प्रस्तुत करती है। भले ही ऐसे अनुप्रयोग हो सकते हैं जो इस तरह के घोंसले से लाभ उठा सकते हैं, सुधार विकास लागत के लायक नहीं हो सकते हैं।