[geeks] recommended dual channel LVD controller, PC

[Phil Stracchino]

On Fri, Jul 23, 2004 at 10:49:27AM -0500, mrl wrote:
> On Fri, 2004-07-23 at 02:21, Bjvrn Ramqvist wrote:
> 
> > People here would probably go for the 
> > "striped-mirror" approach rather than the "mirrored-stripe" approach, 
> > since it's more tolerant to failures.
> 
> How could that be?
> 
> 1 2    (assumes 2 mirrors or stripes, total of 4 disks in array)
> 
> - -    This is a mirrored stripe. 
> - -    Any one disk in a column can fail. Beyond that, you're toast.
> 
> : :    This is a striped mirror. 
>        Again, any one disk in a column can fail.
> 
> (sorry if my ASCII "art" doesn't do it for you... it was half for my
> benefit, to make sure I was asking an intelligent question. :P)
> 
> So how's it more tolerant to failures?


On an array this small, it makes no difference.  But consider a larger
array.  Let's suppose you have 14 drives total, a fully populated
wide-SCSI bus, and let's indicate stripes by {} and mirrors by [].

This is 0+1 (striped, then mirrored):

[ {0 1 2 3 4 5 6} {7 8 9 a b c d} ]

This will survive one disk failure from a single stripe, at which point
that submirror will go offline, leaving this (where _ indicates a
failed subunit):

[ {0 1 2 3 4 5 6} {_ 8 9 a b c d} ]

Six of the seven drives in the second submirror are still fine, but
they aren't doing you any good, because the submirror has no redundancy.
Your array EFFECTIVELY now looks like this:

[ {0 1 2 3 4 5 6} {_} ]

A second failure of any of these seven remaining active drives will fail
the entire array.  Using 14 drives, there is a probability of 7/13, or
53.8%, that a second drive failure will bring down the entire array.


This is 1+0 (mirrored, then striped):

{ [0 1] [2 3] [4 5] [6 7] [8 9] [a b] [c d] [e f] }

If one disk fails, one subunit will lose its mirror, but the array now
looks like this:

{ [_ 1] [2 3] [4 5] [6 7] [8 9] [a b] [c d] [e f] }

Subunit 1 is now in degraded mode, but is still operating.  Another
drive failure may leave this:

{ [_ 1] [2 3] [4 5] [6 7] [8 9] [a _] [c d] [e f] }

And again, because each subinit is a mirror, the array as a whole
continues to operate.

This can survive as many as seven drive failures without going offline,
so long as one drive of each mirrored pair remains running.  If both
drives of any pair die, of course, you're still dead in the water.  The
probability that the second failure will take the entire array down is
1/13 (7.7%); three drive failures have a 1/6 (16.7%) chance of bringing
down the array; four drives, 3/11 (27.3%); five drives, 4/10 (40%); six
drives, 5/9 (5.5%).  So, six drives must fail before the chance of the
entire 1+0 array failing equals the change of the 0+1 array going down
on only the second failure.

(Failure of a seventh drive would have a 75% chance of bringing down the
entire array, and drive failure #8 would of course be 100% because there
would by then be no redundancy left.  But hey, look what we're saying
here.)



-- 
  ========== Fight Back!  It may not be just YOUR life at risk. ==========
  alaric at caerllewys.net : phil-stracchino at earthlink.net : phil at novylen.net
   phil stracchino : unix ronin : renaissance man : mystic zen biker geek
     2000 CBR929RR, 1991 VFR750F3 (foully murdered), 1986 VF500F (sold)
           Linux Now!  ...Friends don't let friends use Microsoft.