1
$\begingroup$

I guess the question does not apply just to CS as I'm trying to understand how it applies to RAIDs, but I guess it's maybe the most suitable place to ask anyway.

There's a lot of info that RS codes are often used to implement second parity for RAID-6. There are some systems that implement triple-parity.

Am I right that by using enough Reed-Solomon parity bits I can implement 4-way parity etc., up to arbitrary-way parity (as long the the stripe is long enough, e.g. by writing each n bit stripe as k data bits + t parity bits)?

I'm just surprised why, if it's true, parity counts > 3 are not implemented in any production systems.

Improve this question
$\endgroup$
3
  • 1
    $\begingroup$ R-S error detection and correction get more complex with increasing length. $\endgroup$
    – user16034
    Commented Nov 14, 2022 at 10:43
  • $\begingroup$ @YvesDaoust do you mean that what I asked is possible, but would just quickly become impractical (prohibitively slow)? $\endgroup$
    – ledonter
    Commented Nov 14, 2022 at 11:00
  • 1
    $\begingroup$ It is obviously possible. And probably economically unreasonable. $\endgroup$
    – user16034
    Commented Nov 14, 2022 at 11:01

2 Answers 2

Reset to default
4
$\begingroup$

A Reed-Solomon code applied to 512-byte (4096-bit) sectors can support up to $n=2^{4096}$ drives in an array, of which any fraction may be parity drives. The limits of real-world RAID setups come from practical considerations, not theory.

RAID can defend against the random failure of up to $t$ drives, but it can't defend against a power surge or fire or software bug or anything else that destroys the entire array. There is some $t_\text{max}$ such that for $t\ge t_\text{max}$ the probability of failure is largely independent of $t$ because failure modes that can't be prevented by RAID dominate. Probably $t_\text{max}\approx 3$.

Improve this answer
$\endgroup$
0
1
$\begingroup$

More broadly, the issue of repairing Reed-Solomon codes currently employed in industry has been discussed in the literature. It is important to find algorithms with low-bandwidth repair schemes for codes of short lengths with typical redundancies.

A recent paper is a good place to start since it has tables of current best repair schemes for $[n,k]$ Reed-Solomon codes over $\mathbb{GF}(2^8)$ with $4≤n≤16$ and redundancy $r=n−k∈{2,3,4}. $The tables cover most known codes currently used in the distributed storage industry. For convenience, I have reproduced a figure from that paper which has examples of the codes used in industry.

enter image description here

See the paper available here.

Improve this answer
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.