function FileData_Pairs(x)
{
x.t("states","unconfigured");
x.t("fault","tolerance");
x.t("example","virtual");
x.t("example","consider");
x.t("example","monitor");
x.t("workstations","stand-alone");
x.t("read-ahead","cache");
x.t("read-ahead","mode");
x.t("read-ahead","capability");
x.t("read-ahead","two");
x.t("nvram","size");
x.t("nvram","offline");
x.t("nvram","acronym");
x.t("nvram","stores");
x.t("possible","values");
x.t("provide","high");
x.t("provide","data");
x.t("residing","drive");
x.t("available","elapsed");
x.t("drive","nvram");
x.t("drive","possible");
x.t("drive","drive");
x.t("drive","simultaneously");
x.t("drive","consistency");
x.t("drive","fault-tolerant");
x.t("drive","state");
x.t("drive","mode");
x.t("drive","errors");
x.t("drive","type");
x.t("drive","property");
x.t("drive","automatically");
x.t("drive","rebuild");
x.t("drive","includes");
x.t("drive","initialization");
x.t("drive","group");
x.t("drive","unsupported");
x.t("drive","initialized");
x.t("drive","network");
x.t("drive","fails");
x.t("drive","offline");
x.t("drive","maintain");
x.t("drive","virtual");
x.t("drive","part");
x.t("drive","mirrored");
x.t("drive","completed");
x.t("drive","originally");
x.t("drive","map");
x.t("drive","write");
x.t("drive","device");
x.t("drive","striping");
x.t("drive","failed");
x.t("drive","configured");
x.t("drive","db09000202-21");
x.t("drive","space");
x.t("drive","stripe");
x.t("drive","redundant");
x.t("drive","accessible");
x.t("drive","hot");
x.t("drive","invalid");
x.t("drive","retain");
x.t("drive","groups");
x.t("drive","thus");
x.t("drive","firmware");
x.t("drive","ready");
x.t("drive","affect");
x.t("drive","losses");
x.t("drive","accesses");
x.t("drive","failure");
x.t("drive","depending");
x.t("drive","subsystem");
x.t("drive","sectors");
x.t("drive","although");
x.t("drive","online");
x.t("drive","data");
x.t("drive","raid");
x.t("drive","prevent");
x.t("drive","created");
x.t("drive","following");
x.t("drive","storage");
x.t("drive","using");
x.t("drive","unconfigured");
x.t("drive","generates");
x.t("drive","patrol");
x.t("drive","integrated");
x.t("stripes","virtual");
x.t("microprocessor","peripheral");
x.t("microprocessor","memory");
x.t("formatted","manufactured");
x.t("drive\u2019s","data");
x.t("lead","drive");
x.t("throughput","improves");
x.t("throughput","especially");
x.t("simultaneously","written");
x.t("simultaneously","raid");
x.t("protected","mirroring");
x.t("improved","performance");
x.t("simplified","cabling");
x.t("pattern","example");
x.t("five","without");
x.t("five","drives");
x.t("dirty/clean","cache");
x.t("saved","cache");
x.t("accordance","policies");
x.t("accordance","write-back");
x.t("full","redundancy");
x.t("full","operating");
x.t("clear","configuration");
x.t("files","environment");
x.t("background","fault");
x.t("create","new");
x.t("installed","mainframes");
x.t("controller\u2019s","nvram");
x.t("input/output","(i/o)");
x.t("july","2015");
x.t("required","data");
x.t("enhances","overall");
x.t("normal","i/o");
x.t("normal","operations");
x.t("always","read-ahead");
x.t("improve","write");
x.t("improve","read");
x.t("improve","data");
x.t("consistency","check");
x.t("completion","signal");
x.t("flag","unconfigured");
x.t("responsible","behavior");
x.t("foreign","configuration");
x.t("controlled","controller.when");
x.t("fault-tolerant","raid");
x.t("action","speeds");
x.t("formatting","usually");
x.t("formatting","process");
x.t("creates","striped");
x.t("current","read");
x.t("user","select");
x.t("cache","hit");
x.t("cache","usually");
x.t("cache","fast");
x.t("cache","accessed");
x.t("cache","lines");
x.t("cache","temporarily");
x.t("cache","memory");
x.t("cache","miss");
x.t("cache","host");
x.t("cache","received");
x.t("cache","mirroring");
x.t("cache","flush");
x.t("last","cache");
x.t("last","sectors");
x.t("program","system");
x.t("uses","hot");
x.t("uses","data");
x.t("generating","corresponding");
x.t("pair","mirror");
x.t("hit","read");
x.t("errors","lead");
x.t("errors","host");
x.t("errors","raid");
x.t("mode","read-ahead");
x.t("mode","always");
x.t("mode","rebuild");
x.t("mode","initialization");
x.t("mode","lets");
x.t("mode","controller");
x.t("mode","read");
x.t("state","drive");
x.t("state","initialization");
x.t("support","hot");
x.t("support","raid");
x.t("necessary","patrol");
x.t("interface","(scsi)");
x.t("interface","provides");
x.t("interface","leverages");
x.t("type","drive");
x.t("type","access");
x.t("missing","drive");
x.t("spares","used");
x.t("providing","complete");
x.t("spare","drive");
x.t("spare","replace");
x.t("spare","hot");
x.t("spare","dedicated");
x.t("spare","firmware");
x.t("spare","online");
x.t("spare","drives");
x.t("spare","standby");
x.t("spare","pool");
x.t("buffered","cache");
x.t("sequential","pattern");
x.t("sequential","sectors");
x.t("sequential","data");
x.t("pin","count");
x.t("time","last");
x.t("cached","cache");
x.t("cached","i/o");
x.t("peripheral","device");
x.t("rate","user-defined");
x.t("rate","patrol");
x.t("multiple","drive");
x.t("multiple","virtual");
x.t("multiple","independent");
x.t("multiple","drives");
x.t("fixed-size","units");
x.t("property","indicates");
x.t("property","indicating");
x.t("property","storage");
x.t("speed","drive");
x.t("automatically","uses");
x.t("automatically","replace");
x.t("automatically","fixes");
x.t("default","write");
x.t("back","mode");
x.t("back","write");
x.t("unrecoverable","error");
x.t("count","controller");
x.t("count","lower");
x.t("put","virtual");
x.t("checks","drives");
x.t("require","complete");
x.t("needed","soon");
x.t("access","permitted");
x.t("access","operation");
x.t("access","part");
x.t("access","memory");
x.t("access","data");
x.t("access","policy");
x.t("megaraid","storage");
x.t("start","writing");
x.t("single","drive");
x.t("single","pair");
x.t("single","redundant");
x.t("single","storage");
x.t("turned","typical");
x.t("new","formatting");
x.t("contents","drive");
x.t("consists","consecutive");
x.t("usually","occurs");
x.t("usually","done");
x.t("usually","contains");
x.t("rebuild","drive");
x.t("rebuild","usually");
x.t("rebuild","regeneration");
x.t("rebuild","failed");
x.t("passes","control");
x.t("configurations","improve");
x.t("configurations","initialization");
x.t("block","read");
x.t("nonvolatile","random");
x.t("size","user");
x.t("size","controller");
x.t("size","virtual");
x.t("size","striping");
x.t("size","strip");
x.t("interleaved","data");
x.t("includes","five");
x.t("repeating","drives");
x.t("indicates","current");
x.t("indicates","type");
x.t("indicates","status");
x.t("indicates","length");
x.t("indicates","whether");
x.t("indicates","characteristics");
x.t("indicates","capacity");
x.t("indicates","amount");
x.t("indicates","manufacturer-assigned");
x.t("indicates","raid");
x.t("policies","controller");
x.t("policies","capacity");
x.t("policies","include");
x.t("status","drive");
x.t("initialization","mode");
x.t("initialization","erases");
x.t("initialization","quickly");
x.t("initialization","running");
x.t("initialization","process");
x.t("lets","immediately");
x.t("again","comes");
x.t("group","drive");
x.t("group","creates");
x.t("group","cache");
x.t("group","uses");
x.t("group","multiple");
x.t("group","group");
x.t("group","improves");
x.t("group","complete");
x.t("group","fails");
x.t("group","performance");
x.t("group","part");
x.t("group","sustain");
x.t("group","works");
x.t("group","raid");
x.t("group","except");
x.t("group","used");
x.t("group","without");
x.t("group","drives");
x.t("group","spanned");
x.t("unsupported","flag");
x.t("complete","mirrored");
x.t("complete","data");
x.t("during","normal");
x.t("improves","input/output");
x.t("improves","several");
x.t("parallel","scsi");
x.t("permitted","particular");
x.t("increase","computer");
x.t("check","operation");
x.t("check","parity");
x.t("initialized","missing");
x.t("network","passes");
x.t("applies","read");
x.t("requested","data");
x.t("offline","drive");
x.t("offline","part");
x.t("(rom)","programmable");
x.t("fails","megaraid");
x.t("fails","contents");
x.t("fails","hot");
x.t("fails","configuration");
x.t("availability","fault");
x.t("availability","group");
x.t("large","files");
x.t("mirror","raid");
x.t("anticipating","data");
x.t("interrupting","normal");
x.t("(scsi)","protocol");
x.t("units","drive");
x.t("speeds","read");
x.t("speeds","subsequent");
x.t("controller","nvram");
x.t("controller","drive");
x.t("controller","clear");
x.t("controller","installed");
x.t("controller","cache");
x.t("controller","property");
x.t("controller","access");
x.t("controller","virtual");
x.t("controller","sends");
x.t("controller","fast");
x.t("controller","writes");
x.t("controller","sets");
x.t("controller","attribute");
x.t("controller","configured");
x.t("controller","reads");
x.t("controller","begins");
x.t("controller","reverts");
x.t("controller","chip");
x.t("controller","drives");
x.t("detects","unrecoverable");
x.t("writing","specific");
x.t("writing","data");
x.t("potential","problem");
x.t("high","performance");
x.t("high","data");
x.t("requires","data");
x.t("protects","data");
x.t("requirements","compared");
x.t("stored","cache");
x.t("stored","second");
x.t("stored","power");
x.t("stored","read-only");
x.t("overall","read/write");
x.t("overall","system");
x.t("operation","drive");
x.t("operation","enhances");
x.t("operation","verifies");
x.t("operation","find");
x.t("operation","somewhat");
x.t("operation","may");
x.t("auto-rebuild","feature");
x.t("programmable","rom");
x.t("maintain","integrity");
x.t("acronym","nonvolatile");
x.t("acronym","serial");
x.t("addresses","mapped");
x.t("addresses","subsequent");
x.t("performance","drive");
x.t("performance","simplified");
x.t("performance","cache");
x.t("performance","error");
x.t("performance","roughly");
x.t("performance","data");
x.t("performance","increasing");
x.t("connectors","lower");
x.t("virtual","drive");
x.t("virtual","drives");
x.t("controllers","support");
x.t("controllers","default");
x.t("controllers","perform");
x.t("controllers","provides");
x.t("perform","raid");
x.t("part","virtual");
x.t("part","global");
x.t("manufactured","formatting");
x.t("initializing","fail");
x.t("direct","i/o");
x.t("lose","data");
x.t("soon","action");
x.t("glossary","access");
x.t("glossary","glossary");
x.t("mirrored","drive");
x.t("mirrored","data");
x.t("mirrored","copy");
x.t("mirrored","drives");
x.t("none","drive");
x.t("provides","fault");
x.t("provides","improved");
x.t("exists","accessing");
x.t("exists","replacement");
x.t("(i/o)","performance");
x.t("slower","raid");
x.t("verifies","stripes");
x.t("verifies","correct");
x.t("sends","data");
x.t("completed","write");
x.t("completed","prepare");
x.t("find","sometimes");
x.t("fast","initialization");
x.t("fast","memory");
x.t("address","cache");
x.t("consistent","automatically");
x.t("originally","configured");
x.t("writes","first");
x.t("writes","data");
x.t("writes","across");
x.t("rom","(prom)");
x.t("allows","import");
x.t("map","unreadable");
x.t("stand-alone","desktop");
x.t("degradation","performance");
x.t("segments","raid");
x.t("consumed","stripe");
x.t("array","drive");
x.t("accessed","simultaneously");
x.t("accessed","data");
x.t("accessed","higher");
x.t("started","data");
x.t("write","mode");
x.t("write","back");
x.t("write","operation");
x.t("write","performance");
x.t("write","write");
x.t("write","policy");
x.t("write","transaction");
x.t("integrity","processing");
x.t("integrity","system");
x.t("fields","drive");
x.t("fields","virtual");
x.t("fields","generated");
x.t("fix","potential");
x.t("pairs","drives");
x.t("regeneration","data");
x.t("sets","policies");
x.t("lines","available");
x.t("lines","number");
x.t("temporarily","store");
x.t("device","drive");
x.t("device","interface");
x.t("device","controller");
x.t("device","port");
x.t("striping","technique");
x.t("striping","combination");
x.t("striping","mirroring");
x.t("striping","itself");
x.t("striping","drives");
x.t("ports","controller");
x.t("controller.when","drive");
x.t("second","drive");
x.t("attribute","indicates");
x.t("store","data");
x.t("functions","striping");
x.t("redundancy","property");
x.t("redundancy","virtual");
x.t("redundancy","striping");
x.t("redundancy","raid");
x.t("redundancy","two");
x.t("failed","drive");
x.t("concerned","none");
x.t("random","access");
x.t("random","controller");
x.t("random","data");
x.t("small","databases");
x.t("small","computer");
x.t("small","applications");
x.t("divided","strips");
x.t("recent","drive");
x.t("configured","part");
x.t("configured","hot");
x.t("configured","online");
x.t("error","drive");
x.t("error","recovery");
x.t("error","unconfigured");
x.t("rebuilds","data");
x.t("sometimes","fix");
x.t("independent","drives");
x.t("loads","full");
x.t("install","computer");
x.t("erases","previous");
x.t("especially","large");
x.t("sustain","multiple");
x.t("ahead","requested");
x.t("occurs","without");
x.t("mapped","fixed-size");
x.t("db09000202-21","rev");
x.t("space","drive");
x.t("space","consumed");
x.t("space","data");
x.t("first","last");
x.t("first","turned");
x.t("feature","firmware");
x.t("media","errors");
x.t("fail","consistency");
x.t("appears","host");
x.t("unit","multiple");
x.t("unit","created");
x.t("databases","small");
x.t("somewhat","slower");
x.t("long","two");
x.t("serial","attached");
x.t("serial","point-to-point");
x.t("smaller","connectors");
x.t("select","stripe");
x.t("written","drive");
x.t("written","restore");
x.t("written","main");
x.t("system\u2019s","overall");
x.t("write-back","policies");
x.t("write-back","write-back");
x.t("write-back","caching");
x.t("number","cache");
x.t("number","ports");
x.t("number","drives");
x.t("processing","capability");
x.t("control","operating");
x.t("adjacent","drive");
x.t("signal","host");
x.t("indicating","number");
x.t("length","interleaved");
x.t("technique","writes");
x.t("elapsed","time");
x.t("particular","virtual");
x.t("software","automatically");
x.t("software","stored");
x.t("software","allows");
x.t("software","runs");
x.t("software","monitors");
x.t("reads","whether");
x.t("reads","sequentially");
x.t("whether","required");
x.t("whether","cached");
x.t("whether","default");
x.t("stripe","drive");
x.t("stripe","consists");
x.t("stripe","size");
x.t("stripe","controller");
x.t("stripe","writes");
x.t("stripe","case");
x.t("stripe","contains");
x.t("(prom)","firmware");
x.t("recovery","during");
x.t("may","necessary");
x.t("user-defined","rate");
x.t("combination","parity");
x.t("characteristics","drive");
x.t("replace","failed");
x.t("replace","rebuilds");
x.t("replace","raid");
x.t("stores","firmware");
x.t("stores","additional");
x.t("accessing","random");
x.t("accessing","data");
x.t("begins","using");
x.t("requests","random");
x.t("consecutive","virtual");
x.t("2015","2015");
x.t("2015","avago");
x.t("redundant","drive");
x.t("redundant","virtual");
x.t("redundant","configuration");
x.t("redundant","data");
x.t("redundant","raid");
x.t("read/write","performance");
x.t("read/write","read");
x.t("capacity","controller\u2019s");
x.t("capacity","property");
x.t("accessible","virtual");
x.t("accessible","raid");
x.t("capability","drive");
x.t("capability","disabled");
x.t("capability","avago");
x.t("lost","drive");
x.t("lost","hot");
x.t("lost","data");
x.t("lost","comprise");
x.t("works","small");
x.t("strip","size");
x.t("strip","written");
x.t("leverages","small");
x.t("hot","spares");
x.t("hot","spare");
x.t("invalid","data");
x.t("prepare","removal");
x.t("dedicated","single");
x.t("retain","redundant");
x.t("level","drive");
x.t("level","virtual");
x.t("level","consistent");
x.t("level","used");
x.t("groups","controlled");
x.t("groups","operation");
x.t("groups","raid");
x.t("groups","work");
x.t("restore","full");
x.t("often","responsible");
x.t("thus","data");
x.t("arrangement","raid");
x.t("sequentially","ahead");
x.t("disabled","adaptive");
x.t("parity-data-striped","across");
x.t("memory","microprocessor");
x.t("memory","saved");
x.t("memory","cache");
x.t("memory","(rom)");
x.t("memory","anticipating");
x.t("memory","speeds");
x.t("memory","direct");
x.t("memory","address");
x.t("memory","software");
x.t("memory","holds");
x.t("memory","read");
x.t("memory","data");
x.t("memory","policy");
x.t("memory","copy");
x.t("memory","immediately");
x.t("memory","caching");
x.t("memory","storage");
x.t("memory","associated");
x.t("memory","buffer");
x.t("firmware","detects");
x.t("firmware","software");
x.t("firmware","often");
x.t("firmware","configuration");
x.t("operating","system");
x.t("parity","provide");
x.t("parity","put");
x.t("parity","fields");
x.t("parity","drives");
x.t("ready","state");
x.t("previous","data");
x.t("affect","read-ahead");
x.t("exact","copy");
x.t("environment","requires");
x.t("losses","long");
x.t("lower","pin");
x.t("lower","power");
x.t("recently","accessed");
x.t("quickly","writes");
x.t("roughly","single");
x.t("accesses","occurred");
x.t("existing","configuration");
x.t("occurred","sequential");
x.t("reverts","read-ahead");
x.t("compared","parallel");
x.t("consider","stripe");
x.t("seen","operating");
x.t("miss","fetched");
x.t("amount","dirty/clean");
x.t("amount","space");
x.t("amount","storage");
x.t("manufacturer-assigned","device");
x.t("configuration","drive");
x.t("configuration","create");
x.t("configuration","protects");
x.t("configuration","virtual");
x.t("configuration","concerned");
x.t("configuration","redundant");
x.t("configuration","already");
x.t("configuration","data");
x.t("configuration","sas");
x.t("configuration","raid");
x.t("configuration","prevents");
x.t("undergo","single");
x.t("failure","drive");
x.t("failure","write-back");
x.t("failure","lost");
x.t("failure","per");
x.t("transferred","cache");
x.t("saving","accessing");
x.t("instances","dual");
x.t("include","amount");
x.t("main","memory");
x.t("aborted","started");
x.t("far","raid");
x.t("running","background");
x.t("tolerance","redundant");
x.t("tolerance","capability");
x.t("value","data");
x.t("power","requirements");
x.t("power","removed");
x.t("additional","data");
x.t("holds","recently");
x.t("already","cache");
x.t("already","stored");
x.t("already","exists");
x.t("specific","virtual");
x.t("specific","value");
x.t("several","drives");
x.t("little","improvement");
x.t("adaptive","read-ahead");
x.t("depending","raid");
x.t("fetched","main");
x.t("computer","system\u2019s");
x.t("computer","system");
x.t("subsystem","accordance");
x.t("subsystem","improve");
x.t("subsystem","undergo");
x.t("subsystem","received");
x.t("subsystem","occur");
x.t("sectors","improve");
x.t("sectors","virtual");
x.t("sectors","read");
x.t("sectors","drives");
x.t("fixes","errors");
x.t("manager","software");
x.t("compromising","data");
x.t("import","existing");
x.t("process","providing");
x.t("process","checks");
x.t("process","writing");
x.t("generated","policy");
x.t("maintaining","exact");
x.t("read","cache");
x.t("read","rate");
x.t("read","again");
x.t("read","operation");
x.t("read","performance");
x.t("read","written");
x.t("read","requests");
x.t("read","aborted");
x.t("read","process");
x.t("read","blocked");
x.t("read","policy");
x.t("read","operations");
x.t("runs","avago");
x.t("systems","hot");
x.t("systems","considered");
x.t("considered","host");
x.t("although","virtual");
x.t("although","degradation");
x.t("although","instances");
x.t("transfer","completion");
x.t("transfer","data");
x.t("good","drive");
x.t("good","offline");
x.t("online","drive");
x.t("online","hot");
x.t("online","removed");
x.t("location","offline");
x.t("strips","strip");
x.t("rev","2.2");
x.t("data","read-ahead");
x.t("data","residing");
x.t("data","microprocessor");
x.t("data","throughput");
x.t("data","protected");
x.t("data","drive");
x.t("data","accordance");
x.t("data","cache");
x.t("data","cached");
x.t("data","needed");
x.t("data","block");
x.t("data","availability");
x.t("data","stored");
x.t("data","addresses");
x.t("data","virtual");
x.t("data","completed");
x.t("data","segments");
x.t("data","integrity");
x.t("data","fields");
x.t("data","second");
x.t("data","striping");
x.t("data","failed");
x.t("data","redundancy");
x.t("data","divided");
x.t("data","written");
x.t("data","adjacent");
x.t("data","stripe");
x.t("data","stores");
x.t("data","lost");
x.t("data","accessible");
x.t("data","parity-data-striped");
x.t("data","transferred");
x.t("data","far");
x.t("data","already");
x.t("data","little");
x.t("data","read");
x.t("data","transfer");
x.t("data","data");
x.t("data","protection");
x.t("data","raid");
x.t("data","replacement");
x.t("data","case");
x.t("data","mirroring");
x.t("data","transaction");
x.t("data","storage");
x.t("data","across");
x.t("data","drives");
x.t("data","patrol");
x.t("high-speed","memory");
x.t("correct","mirrored");
x.t("host","drive");
x.t("host","access");
x.t("host","controller");
x.t("host","systems");
x.t("host","concurrently");
x.t("host","system");
x.t("attached","raid");
x.t("attached","scsi");
x.t("removal","operation");
x.t("typical","example");
x.t("dual","write");
x.t("enterprise-level","device");
x.t("protection","megaraid");
x.t("protection","raid");
x.t("sas","interface");
x.t("sas","acronym");
x.t("sas","controllers");
x.t("sas","serial");
x.t("sas","raid");
x.t("received","data");
x.t("read-only","memory");
x.t("mainframes","workstations");
x.t("increasing","number");
x.t("striped","series");
x.t("policy","mode");
x.t("policy","default");
x.t("policy","applies");
x.t("policy","controller");
x.t("policy","virtual");
x.t("policy","write");
x.t("policy","write-through");
x.t("values","read/write");
x.t("blocked","array");
x.t("raid","drive");
x.t("raid","configurations");
x.t("raid","group");
x.t("raid","controller");
x.t("raid","controllers");
x.t("raid","functions");
x.t("raid","level");
x.t("raid","configuration");
x.t("raid","raid");
x.t("raid","storage");
x.t("raid","levels");
x.t("monitor","program");
x.t("replacement","drive");
x.t("replacement","drives");
x.t("prevent","data");
x.t("case","drive");
x.t("case","stripe");
x.t("mirroring","provide");
x.t("mirroring","pairs");
x.t("mirroring","arrangement");
x.t("mirroring","process");
x.t("port","count");
x.t("global","hot");
x.t("problem","drives");
x.t("transaction","drive");
x.t("transaction","write");
x.t("transaction","device");
x.t("transaction","data");
x.t("done","drive");
x.t("two","recent");
x.t("two","drives");
x.t("improvement","exists");
x.t("protocol","sas");
x.t("flush","write");
x.t("copy","drive\u2019s");
x.t("copy","saved");
x.t("copy","data");
x.t("monitors","addresses");
x.t("unreadable","bad");
x.t("work","without");
x.t("comes","cache");
x.t("applications","require");
x.t("prevents","data");
x.t("itself","provide");
x.t("immediately","start");
x.t("immediately","main");
x.t("controls","transfer");
x.t("created","virtual");
x.t("created","several");
x.t("created","raid");
x.t("concurrently","data");
x.t("caching","mode");
x.t("caching","using");
x.t("storage","configurations");
x.t("storage","availability");
x.t("storage","space");
x.t("storage","unit");
x.t("storage","configuration");
x.t("storage","manager");
x.t("storage","system");
x.t("following","states");
x.t("system","drive");
x.t("system","foreign");
x.t("system","interface");
x.t("system","megaraid");
x.t("system","single");
x.t("system","rebuild");
x.t("system","controller");
x.t("system","performance");
x.t("system","lose");
x.t("system","loads");
x.t("system","first");
x.t("system","computer");
x.t("system","raid");
x.t("used","cached");
x.t("used","rebuild");
x.t("used","virtual");
x.t("used","saving");
x.t("used","raid");
x.t("corresponding","parity");
x.t("except","data");
x.t("using","read-ahead");
x.t("using","sequential");
x.t("using","high-speed");
x.t("avago","technologies");
x.t("avago","sas");
x.t("scsi","stripe");
x.t("scsi","sas");
x.t("2.2","july");
x.t("subsequent","access");
x.t("subsequent","reads");
x.t("bad","drive");
x.t("bad","sectors");
x.t("per","drive");
x.t("levels","provide");
x.t("levels","generating");
x.t("levels","support");
x.t("levels","read");
x.t("levels","raid");
x.t("i/o","mode");
x.t("i/o","operation");
x.t("i/o","direct");
x.t("i/o","used");
x.t("series","mirrored");
x.t("across","multiple");
x.t("across","drives");
x.t("associated","main");
x.t("chip","controls");
x.t("without","repeating");
x.t("without","interrupting");
x.t("without","initializing");
x.t("without","compromising");
x.t("behavior","system");
x.t("operations","buffered");
x.t("operations","sequential");
x.t("operations","specific");
x.t("operations","performed");
x.t("operations","affected");
x.t("performed","computer");
x.t("occur","redundancy");
x.t("cabling","smaller");
x.t("drives","example");
x.t("drives","provide");
x.t("drives","drive");
x.t("drives","formatted");
x.t("drives","five");
x.t("drives","auto-rebuild");
x.t("drives","virtual");
x.t("drives","accessed");
x.t("drives","install");
x.t("drives","appears");
x.t("drives","stripe");
x.t("drives","lost");
x.t("drives","seen");
x.t("drives","amount");
x.t("drives","maintaining");
x.t("drives","although");
x.t("drives","attached");
x.t("drives","host");
x.t("drives","data");
x.t("drives","created");
x.t("drives","storage");
x.t("drives","used");
x.t("drives","including");
x.t("unconfigured","good");
x.t("unconfigured","bad");
x.t("standby","drive");
x.t("spanned","drive");
x.t("point-to-point","enterprise-level");
x.t("including","parity");
x.t("write-through","caching");
x.t("write-through","write-through");
x.t("buffer","increase");
x.t("removed","nvram");
x.t("removed","location");
x.t("generates","media");
x.t("desktop","systems");
x.t("pool","drive");
x.t("patrol","read");
x.t("comprise","single");
x.t("affected","virtual");
x.t("higher","speed");
x.t("contains","drive");
x.t("contains","recently");
x.t("integrated","raid");
}
