Mencari waktu
Masalahnya adalah bahwa, amplifikasi pencarian tulis berperilaku sangat berbeda dengan amplifikasi throughput tulis . Amplifikasi throughput tulis minimal dengan paritas terjadi ketika seluruh strip dituliskan sekaligus (sebut saja kata sifat ini 'strip penuh') namun amplifikasi pencarian tulis minimal terjadi, sebaliknya, ketika seluruh penulisan yang mengikuti pencarian di perangkat virtual cocok dengan sepotong tunggal. Sebelum masuk ke detail, hubungan lebih mudah disampaikan dalam bentuk tabulasi:
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]
di mana n adalah jumlah total drive, n₁ adalah jumlah drive dalam grup RAID 1, dan n₅ dan n₆ adalah jumlah grup dalam array RAID 5 atau RAID 6 masing-masing. Contoh terkait dengan contoh 12-drive dalam pertanyaan (baris yang relevan adalah ' *bolded*
'); contoh untuk level RAID 1 + 0, 1 + 5, 1 + 6 masing-masing adalah 4 × 3, 6 × 2, 6 × 2.
Perhatikan bahwa hanya faktor amplifikasi throughput tulis jalur penuh yang secara langsung terkait dengan proporsi redundansi. Kotak-kotak tunggal lebih rumit bagi mereka yang memiliki paritas. Mereka muncul karena menulis potongan tunggal memerlukan pembacaan mana yang paling mudah dari potongan paritas atau potongan data lainnya, sebelum menulis potongan paritas bersama dengan potongan data baru. (Mereka tidak langsung multiplikasi karena pembacaan yang diinduksi harus dikalikan dengan masing-masing throughput baca / cari faktor amplifikasi untuk RAID 1, keduanya 1; lihat di bawah.)
Sayangnya, memilih ukuran chunk yang meminimalkan amplifikasi throughput tulis ekstra ini memiliki efek samping yang sebenarnya memaksimalkanPenulisan mencari amplifikasi. Untuk tulisan kecil dengan waktu tulis yang dapat diabaikan dibandingkan dengan waktu mencari, kinerja penulisan garis-garis dengan ukuran potongan yang sangat kecil (menjadi garis-penuh) hanya 1 ×, seperti mirroring, karena memerlukan semua drive untuk mencari potongan untuk setiap penulisan dan throughput yang diperoleh dari memobilisasi semua drive ini tidak relevan. Ini telah membagi rasio waktu menulis untuk mencari waktu dengan jumlah drive dalam array, tetapi untuk menulis kecil ini sudah dapat diabaikan. Tidak masuk akal untuk menggunakan ukuran chunk yang sangat kecil sehingga membuat tulisan kecil menjadi full-stripe. Untuk menulis yang cukup kecil untuk merasakan efek pencarian, yang terbaik adalah mereka cocok dalam satu potongan.
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)]
Catatan: Kolom 2 throughput tengah dapat diabaikan dengan ukuran chunk yang masuk akal yang lebih besar dari pada penulisan yang waktu pencariannya signifikan, tetapi cukup kecil sehingga tulisan besar berukuran penuh. Ukuran potongan besar dari kolom throughput ke-2 lebih mirip dengan drive yang direntang. Tulisan 'kecil' adalah di mana efek throughput dapat diabaikan.
Memiliki ukuran chunk kecil yang tidak tepat juga meningkatkan efek mencari amplifikasi untuk dibaca, meskipun tidak sebanyak dan hanya dalam case full-stripe.
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 *
Catatan: 'ke n' adalah karena ketika hanya ada satu pembacaan yang terjadi secara bersamaan, secara teori dimungkinkan untuk memobilisasi semua drive untuk mencari ke tempat yang tepat dan secara bersama-sama membaca data untuk throughput baca bersebelahan maksimum yang besar.
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×*
Catatan: Sekali lagi, kolom 2 throughput tengah dapat diabaikan mengingat ukuran potongan yang masuk akal. Kolom throughput ke-3 sekali lagi terkait erat dengan proporsi redundansi.
Namun, ukuran bongkahan yang cukup besar berarti bacaan kecil tidak pernah penuh. Jadi mengingat implementasi yang efisien dan ukuran chunk yang tepat, kinerja baca harus proporsional dengan jumlah drive yang identik saat tidak terdegradasi.
Jadi sebenarnya, 'faktor amplifikasi' jauh lebih rumit daripada rumus dalam pertanyaan, di mana hanya amplifikasi throughput jalur penuh yang dipertimbangkan. Secara khusus, kinerja penulisan 6 × 2 RAID 1 + 6 untuk penulisan bersamaan yang cukup kecil untuk diikat akan lebih buruk daripada kinerja 4 × 3 RAID 1 + 0. Dan untuk penulisan kecil, yang semuanya dicari, kinerja hanya dapat sekitar sepertiga dari yang 4 × 3 RAID 1 + 0 di terbaik absolut (yaitu diberi implementasi yang sempurna).
Setelah menyelesaikan masalah itu, perbandingan 12-drive tidak memiliki pemenang langsung:
| 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
Catatan 1: Salinan lengkap dari data yang disimpan masing-masing adalah RAID 0 quadruple atau array RAID 6 4/6 yang terdegradasi. Catatan 2: Ada kemungkinan bahkan apakah kegagalan drive menyinggung salah satu dari 4 pasangan RAID 1 terdegradasi atau menurunkan salah satu dari 2 pasangan normal.
Namun demikian, itu akan menggandakan kinerja membaca dari array RAID 6 dari 6 drive dan throughput menulis kecil harus 25% lebih baik (1,5 / 1.2) karena bacaan wajib dibagi antara pasangan RAID 1, dan RAID 6 jelas tidak memiliki aplikasi yang cocok, sehingga dalam aplikasi ketersediaan tinggi yang memiliki menulis yang lebih besar atau yang lebih prihatin tentang kinerja membaca dari menulis kinerja, mungkin ada adalah ceruk untuk RAID 1 + 6 afterall. Tapi bukan itu saja ...
Kompleksitas
Ini masih hanya dalam teori sejauh ini (sebagian besar kombinatorik ), dalam praktiknya kompleksitas akan berarti bahwa implementasi RAID 1 + 6 mungkin memiliki kekurangan yang kehilangan peluang dan tidak mencapai hasil teoritis. RAID 6 sudah lebih kompleks, dan bersarang menambah sedikit kompleksitas di atas ini.
Sebagai contoh, itu tidak segera jelas bahwa 6 × 2 RAID 1 + 6 dapat diabstraksikan sebagai memiliki 3 kepala baca virtual independen yang mampu secara bersamaan membaca 3 besar membaca bersebelahan pada throughput 4 × masing-masing, sama seperti 4 × 3 RAID 1 + 0. Cukup membuat 6 pasangan RAID 1 dalam array RAID 6 menggunakan perangkat lunak RAID mungkin tidak begitu elegan; implementasinya mungkin bodoh dan berlebihan (saya belum menguji hipotesis ini).
Kompleksitas juga menghadirkan peningkatan biaya pengembangan implementasi dan alat. Meskipun mungkin ada aplikasi yang dapat mengambil manfaat dari sarang seperti itu, perbaikannya mungkin tidak sebanding dengan biaya pengembangan.