function FileData_Pairs(x)
{
x.t("fault","tolerant");
x.t("supports","standard");
x.t("four","drive");
x.t("example","existing");
x.t("transactions","simultaneously");
x.t("drive","survive");
x.t("drive","however");
x.t("drive","failures");
x.t("drive","group");
x.t("drive","mirror");
x.t("drive","fails");
x.t("drive","disadvantage");
x.t("drive","array");
x.t("drive","rebuilt");
x.t("drive","collection");
x.t("drive","particular");
x.t("drive","different");
x.t("drive","groups");
x.t("drive","losses");
x.t("drive","actual");
x.t("drive","data");
x.t("drive","raid");
x.t("drive","created");
x.t("drive","used");
x.t("drive","using");
x.t("drive","reading");
x.t("drive","contains");
x.t("protected","hot");
x.t("simultaneously","drive");
x.t("simultaneously","drives");
x.t("stripes","blocks");
x.t("files","faster");
x.t("create","eight");
x.t("create","virtual");
x.t("create","multiple-drive");
x.t("create","storage");
x.t("july","2015");
x.t("always","written");
x.t("required","block");
x.t("required","raid");
x.t("eight","physical");
x.t("eight","virtual");
x.t("eight","arrays");
x.t("having","virtual");
x.t("controlled","megasr");
x.t("creates","striped");
x.t("pair","mirror");
x.t("survive","loss");
x.t("implemented","two");
x.t("physical","drives");
x.t("best","implemented");
x.t("best","suited");
x.t("suited","networks");
x.t("time","data");
x.t("spare","drive");
x.t("spare","drives");
x.t("however","raid10");
x.t("however","data");
x.t("however","raid");
x.t("multiple","drive");
x.t("multiple","raid");
x.t("variants","scu");
x.t("automatically","replace");
x.t("networks","perform");
x.t("partial","space");
x.t("megaraid","sas");
x.t("new","configuration");
x.t("single","pair");
x.t("single","virtual");
x.t("configurations","several");
x.t("block","written");
x.t("block","stripe");
x.t("choice","fast");
x.t("failures","without");
x.t("includes","parity");
x.t("file","drive");
x.t("group","drive");
x.t("group","creates");
x.t("group","single");
x.t("group","requires");
x.t("group","exactly");
x.t("group","provides");
x.t("group","blocks");
x.t("group","sustain");
x.t("group","minimum");
x.t("group","allowed");
x.t("group","hot");
x.t("group","thus");
x.t("group","data");
x.t("group","two");
x.t("group","note");
x.t("group","spanned");
x.t("relatively","slow");
x.t("mirror","raid");
x.t("mirror","drives");
x.t("fails","drive");
x.t("fails","first");
x.t("fails","data");
x.t("supporting","maximum");
x.t("features","raid");
x.t("writing","entire");
x.t("high","level");
x.t("requires","high");
x.t("requires","minimum");
x.t("cycle","two");
x.t("controller","supports");
x.t("controller","create");
x.t("controller","virtual");
x.t("controller","comes");
x.t("creating","new");
x.t("stored","computer");
x.t("faster","writing");
x.t("faster","raid");
x.t("slow","write");
x.t("exactly","two");
x.t("virtual","drive");
x.t("virtual","drives");
x.t("objective","however");
x.t("disadvantage","raid");
x.t("perform","small");
x.t("mirrored","drive");
x.t("mirrored","drives");
x.t("provides","features");
x.t("provides","high");
x.t("provides","data");
x.t("slower","raid");
x.t("two-drive","raid");
x.t("place","concurrently");
x.t("standard","raid");
x.t("raid10","create");
x.t("arrays","drive");
x.t("arrays","virtual");
x.t("fast","read/write");
x.t("writes","slower");
x.t("writes","place");
x.t("array","independent");
x.t("array","next");
x.t("array","maximum");
x.t("array","raid");
x.t("(stripes)","written");
x.t("entire","file");
x.t("write","cycle");
x.t("write","operations");
x.t("sets","without");
x.t("obviously","faster");
x.t("three","drives");
x.t("second","drive");
x.t("second","parity");
x.t("striping","across");
x.t("divided","small");
x.t("small","blocks");
x.t("small","i/o");
x.t("failed","drive");
x.t("failed","mirrored");
x.t("ahci","supporting");
x.t("independent","disks");
x.t("blocks","stripes");
x.t("blocks","(stripes)");
x.t("blocks","data");
x.t("multiple-drive","arrays");
x.t("sustain","four");
x.t("sustain","multiple");
x.t("next","virtual");
x.t("rebuilt","raid");
x.t("disk","striping");
x.t("db09000202-21","rev");
x.t("means","redundant");
x.t("collection","individual");
x.t("long","two");
x.t("minimum","three");
x.t("minimum","six");
x.t("smaller","blocks");
x.t("six","drives");
x.t("allowed","example");
x.t("space","array");
x.t("fail","drive");
x.t("first","failed");
x.t("written","drive");
x.t("written","simultaneously");
x.t("written","successively");
x.t("written","raid");
x.t("written","two");
x.t("written","across");
x.t("recover","data");
x.t("maximum","eight");
x.t("different","types");
x.t("different","raid");
x.t("cannot","protected");
x.t("particular","array");
x.t("safe","second");
x.t("stripe","raid");
x.t("replace","failed");
x.t("2015","2015");
x.t("2015","avago");
x.t("redundant","array");
x.t("types","raid");
x.t("loss","db09000202-21");
x.t("loss","two");
x.t("read/write","capability");
x.t("capability","important");
x.t("important","objective");
x.t("capacity","raid");
x.t("lost","comprise");
x.t("hot","spare");
x.t("groups","fault");
x.t("groups","thus");
x.t("groups","data");
x.t("groups","raid");
x.t("thus","time");
x.t("thus","raid");
x.t("level","data");
x.t("level","protection");
x.t("operating","system");
x.t("losses","long");
x.t("parity","block");
x.t("parity","writes");
x.t("parity","disk");
x.t("parity","information");
x.t("successively","drives");
x.t("actual","capacity");
x.t("existing","raid");
x.t("configuration","creating");
x.t("configuration","understanding");
x.t("technology","called");
x.t("similar","raid");
x.t("disks","create");
x.t("several","different");
x.t("already","created");
x.t("computer","operating");
x.t("sees","drive");
x.t("read","operations");
x.t("breaks","data");
x.t("losing","data");
x.t("good","choice");
x.t("rev","2.2");
x.t("data","protected");
x.t("data","drive");
x.t("data","always");
x.t("data","block");
x.t("data","requires");
x.t("data","stored");
x.t("data","writes");
x.t("data","divided");
x.t("data","failed");
x.t("data","smaller");
x.t("data","written");
x.t("data","safe");
x.t("data","parity");
x.t("data","protection");
x.t("data","striped");
x.t("data","raid");
x.t("data","two");
x.t("information","written");
x.t("information","used");
x.t("sas","understanding");
x.t("striped","series");
x.t("striped","across");
x.t("protection","however");
x.t("protection","second");
x.t("protection","loss");
x.t("protection","raid");
x.t("raid","drive");
x.t("raid","controlled");
x.t("raid","best");
x.t("raid","includes");
x.t("raid","relatively");
x.t("raid","virtual");
x.t("raid","provides");
x.t("raid","sets");
x.t("raid","obviously");
x.t("raid","sustain");
x.t("raid","means");
x.t("raid","technology");
x.t("raid","breaks");
x.t("raid","good");
x.t("raid","data");
x.t("raid","raid");
x.t("raid","levels");
x.t("raid","megasr");
x.t("raid","spanned");
x.t("called","raid");
x.t("two","variants");
x.t("two","write");
x.t("two","read");
x.t("two","raid");
x.t("two","drives");
x.t("note","having");
x.t("note","megasr");
x.t("comes","two");
x.t("concurrently","note");
x.t("created","partial");
x.t("created","array");
x.t("created","using");
x.t("created","megasr");
x.t("storage","configurations");
x.t("system","sees");
x.t("individual","drives");
x.t("tolerant","cannot");
x.t("used","automatically");
x.t("used","recover");
x.t("understanding","raid");
x.t("using","raid");
x.t("2.2","july");
x.t("avago","technologies");
x.t("levels","create");
x.t("levels","configuration");
x.t("levels","raid");
x.t("levels","understanding");
x.t("series","mirrored");
x.t("series","raid");
x.t("across","drive");
x.t("across","multiple");
x.t("across","drives");
x.t("i/o","transactions");
x.t("megasr","controller");
x.t("operations","required");
x.t("operations","two");
x.t("without","losing");
x.t("drives","drive");
x.t("drives","required");
x.t("drives","fails");
x.t("drives","two-drive");
x.t("drives","blocks");
x.t("drives","fail");
x.t("drives","maximum");
x.t("drives","different");
x.t("drives","lost");
x.t("drives","parity");
x.t("drives","similar");
x.t("drives","already");
x.t("drives","data");
x.t("drives","raid");
x.t("drives","created");
x.t("spanned","drive");
x.t("reading","files");
x.t("comprise","single");
x.t("contains","data");
x.t("scu","ahci");
}
