function FileData_Pairs(x)
{
x.t("nytro","nytro");
x.t("nytro","flash");
x.t("nytro","group");
x.t("nytro","controller");
x.t("nytro","controllers");
x.t("nytro","virtual");
x.t("nytro","glossary");
x.t("nytro","sfms");
x.t("miscellaneous","functions");
x.t("example","pcix");
x.t("example","4-gb");
x.t("example","virtual");
x.t("example","max");
x.t("example","consider");
x.t("example","specific");
x.t("example","monitor");
x.t("supports","write");
x.t("states","unconfigured");
x.t("fault","tolerance");
x.t("pcix","host");
x.t("workstations","standalone");
x.t("four","increments");
x.t("four","disk");
x.t("nvram","nytro");
x.t("nvram","size");
x.t("nvram","acronym");
x.t("nvram","present");
x.t("nvram","used");
x.t("highlight","virtual");
x.t("appendix","provides");
x.t("possible","values");
x.t("provide","high");
x.t("provide","power");
x.t("provide","data");
x.t("available","elapsed");
x.t("available","capacity");
x.t("available","online");
x.t("reported","supercap");
x.t("reported","milliamperes");
x.t("below","cycle");
x.t("below","percent");
x.t("unchanged","previous");
x.t("ekm","external");
x.t("placed","supercap");
x.t("hexadecimal","value");
x.t("seven","days");
x.t("method","spreading");
x.t("method","undoing");
x.t("spreading","work");
x.t("rebuilding","data");
x.t("residing","drive");
x.t("drive","nytro");
x.t("drive","highlight");
x.t("drive","possible");
x.t("drive","available");
x.t("drive","ekm");
x.t("drive","method");
x.t("drive","drive");
x.t("drive","simultaneously");
x.t("drive","currently");
x.t("drive","fault-tolerant");
x.t("drive","cache");
x.t("drive","state");
x.t("drive","errors");
x.t("drive","type");
x.t("drive","property");
x.t("drive","original");
x.t("drive","automatically");
x.t("drive","product");
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","copyback");
x.t("drive","lsi");
x.t("drive","name");
x.t("drive","virtual");
x.t("drive","part");
x.t("drive","replaced");
x.t("drive","completed");
x.t("drive","destination");
x.t("drive","originally");
x.t("drive","allows");
x.t("drive","map");
x.t("drive","degradation");
x.t("drive","accessed");
x.t("drive","write");
x.t("drive","striping");
x.t("drive","marked");
x.t("drive","failed");
x.t("drive","configured");
x.t("drive","next");
x.t("drive","media");
x.t("drive","space");
x.t("drive","stripe");
x.t("drive","manufacturer");
x.t("drive","redundant");
x.t("drive","accessible");
x.t("drive","hot");
x.t("drive","invalid");
x.t("drive","groups");
x.t("drive","firmware");
x.t("drive","ready");
x.t("drive","affect");
x.t("drive","(vd)");
x.t("drive","failure");
x.t("drive","configuration");
x.t("drive","db15-001059-00-april");
x.t("drive","subsystem");
x.t("drive","sectors");
x.t("drive","online");
x.t("drive","data");
x.t("drive","host");
x.t("drive","information");
x.t("drive","examples");
x.t("drive","prevent");
x.t("drive","raid");
x.t("drive","mirroring");
x.t("drive","created");
x.t("drive","following");
x.t("drive","used");
x.t("drive","storage");
x.t("drive","coercion");
x.t("drive","using");
x.t("drive","coerced");
x.t("drive","unconfigured");
x.t("drive","generates");
x.t("drive","patrol");
x.t("flash","memory");
x.t("flash","modules");
x.t("microprocessor","peripheral");
x.t("microprocessor","memory");
x.t("stripes","virtual");
x.t("measure","current");
x.t("hardware","include");
x.t("hardware","controls");
x.t("formatted","manufactured");
x.t("throughput","response");
x.t("throughput","improves");
x.t("throughput","complete");
x.t("throughput","especially");
x.t("throughput","data");
x.t("throughput","offers");
x.t("detected","drive");
x.t("detected","drives");
x.t("drive\u2019s","firmware");
x.t("drive\u2019s","data");
x.t("lead","drive");
x.t("simultaneously","written");
x.t("simultaneously","raid");
x.t("pattern","example");
x.t("five","without");
x.t("five","drives");
x.t("version","current");
x.t("dirty/clean","cache");
x.t("supercap","reported");
x.t("supercap","possible");
x.t("supercap","supercap");
x.t("supercap","current");
x.t("supercap","type");
x.t("supercap","start");
x.t("supercap","status");
x.t("supercap","maintain");
x.t("supercap","average");
x.t("supercap","undergoes");
x.t("supercap","retention");
x.t("supercap","auto");
x.t("supercap","present");
x.t("supercap","discharged");
x.t("supercap","backup");
x.t("supercap","life");
x.t("supercap","pack");
x.t("supercap","capacity");
x.t("supercap","fully");
x.t("supercap","level");
x.t("supercap","given");
x.t("supercap","longer");
x.t("supercap","calibration");
x.t("supercap","value");
x.t("supercap","power");
x.t("supercap","measured");
x.t("supercap","stated");
x.t("supercap","module");
x.t("supercap","replacement");
x.t("supercap","assembly");
x.t("supercap","learn");
x.t("full","reset");
x.t("full","low");
x.t("full","predicted");
x.t("full","redundancy");
x.t("full","capacity");
x.t("full","operating");
x.t("full","charge");
x.t("full","discharge");
x.t("saved","cache");
x.t("flushed","caching");
x.t("accordance","policies");
x.t("accordance","write");
x.t("clear","configuration");
x.t("cpus","drives");
x.t("files","environment");
x.t("applied","reduce");
x.t("resides","single");
x.t("lists","number");
x.t("lists","additional");
x.t("background","fault");
x.t("background","initialization");
x.t("background","activity");
x.t("input/output","(i/o)");
x.t("input/output","system");
x.t("create","new");
x.t("create","restore");
x.t("currently","supports");
x.t("currently","host");
x.t("installed","mainframes");
x.t("maximize","resource");
x.t("controller\u2019s","nvram");
x.t("onto","new");
x.t("periodically","controller");
x.t("periodically","determine");
x.t("required","data");
x.t("source","drive");
x.t("key","management");
x.t("recharge","supercap");
x.t("recharge","estimated");
x.t("non-redundant","configuration");
x.t("enhances","overall");
x.t("normal","i/o");
x.t("normal","operations");
x.t("wizard","click");
x.t("performs","learn");
x.t("improve","write");
x.t("improve","read");
x.t("improve","data");
x.t("consistency","check");
x.t("completion","signal");
x.t("completion","learn");
x.t("flag","bits");
x.t("flag","unconfigured");
x.t("responsible","behavior");
x.t("foreign","configuration");
x.t("controlled","controller");
x.t("fault-tolerant","raid");
x.t("components","used");
x.t("likely","percent");
x.t("limits","learn");
x.t("energy","supercap");
x.t("leakage","compensation");
x.t("optimal","failed");
x.t("optimal","degraded");
x.t("current","measure");
x.t("current","start");
x.t("current","write");
x.t("current","bgi");
x.t("current","revision");
x.t("current","charge");
x.t("current","read");
x.t("current","flowing");
x.t("video","controller");
x.t("enabled","disabled");
x.t("formatting","usually");
x.t("formatting","process");
x.t("gas","gauge");
x.t("devoted","rebuilding");
x.t("reaches","certain");
x.t("last","cache");
x.t("last","measured");
x.t("last","sectors");
x.t("last","learn");
x.t("cache","drive");
x.t("cache","flushed");
x.t("cache","enabled");
x.t("cache","hit");
x.t("cache","usually");
x.t("cache","learning");
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","policy");
x.t("cache","flush");
x.t("program","system");
x.t("uses","hot");
x.t("uses","data");
x.t("generating","corresponding");
x.t("state","drive");
x.t("state","initialization");
x.t("state","indicates");
x.t("state","virtual");
x.t("state","charge");
x.t("state","based");
x.t("mode","supercap");
x.t("mode","applied");
x.t("mode","mode");
x.t("mode","rebuild");
x.t("mode","initialization");
x.t("mode","controller");
x.t("mode","write");
x.t("mode","reads");
x.t("mode","causes");
x.t("mode","offers");
x.t("mode","storage");
x.t("hit","read");
x.t("errors","detected");
x.t("errors","lead");
x.t("errors","full");
x.t("errors","raid");
x.t("physical","configuration");
x.t("physical","drives");
x.t("necessary","complete");
x.t("necessary","patrol");
x.t("support","required");
x.t("support","hot");
x.t("support","raid");
x.t("register","hole");
x.t("interface","controller");
x.t("interface","used");
x.t("collects","profile");
x.t("central","processing");
x.t("self-discharge","leakage");
x.t("resets","counter");
x.t("charged","supercap");
x.t("charged","state");
x.t("basic","input/output");
x.t("buses","copyback");
x.t("times","near");
x.t("near","fully");
x.t("missing","drive");
x.t("missing","optimal");
x.t("type","possible");
x.t("type","drive");
x.t("type","interface");
x.t("spares","used");
x.t("change","gas");
x.t("migration","feature");
x.t("migration","process");
x.t("providing","complete");
x.t("time","full");
x.t("time","supercap");
x.t("time","recharge");
x.t("time","gas");
x.t("time","last");
x.t("time","necessary");
x.t("time","time");
x.t("time","product");
x.t("time","hours");
x.t("time","empty");
x.t("time","low-power");
x.t("time","automatic");
x.t("time","next");
x.t("time","maximum");
x.t("time","charge");
x.t("time","reached");
x.t("time","learn");
x.t("initiate","learn");
x.t("spare","drive");
x.t("spare","new");
x.t("spare","status");
x.t("spare","failed");
x.t("spare","replace");
x.t("spare","hot");
x.t("spare","dedicated");
x.t("spare","firmware");
x.t("spare","reverts");
x.t("spare","online");
x.t("spare","drives");
x.t("spare","standby");
x.t("spare","pool");
x.t("external","key");
x.t("buffered","cache");
x.t("response","time");
x.t("calculation","example");
x.t("reset","gas");
x.t("sequential","pattern");
x.t("rate","drive");
x.t("rate","background");
x.t("rate","consistency");
x.t("rate","rate");
x.t("rate","controller");
x.t("rate","user-defined");
x.t("rate","expected");
x.t("rate","discharge");
x.t("rate","percentage");
x.t("rate","patrol");
x.t("peripheral","device");
x.t("peripheral","devices");
x.t("cached","cache");
x.t("cached","i/o");
x.t("copied","hot");
x.t("interchangeably","block");
x.t("multiple","virtual");
x.t("multiple","independent");
x.t("multiple","drives");
x.t("down","system");
x.t("fixed-size","units");
x.t("unknown","supercap");
x.t("property","lists");
x.t("property","indicates");
x.t("property","listing");
x.t("property","indicating");
x.t("property","storage");
x.t("automatically","uses");
x.t("automatically","mode");
x.t("automatically","replace");
x.t("automatically","fixes");
x.t("automatically","manually");
x.t("automatically","learn");
x.t("speed","drive");
x.t("speed","memory");
x.t("speed","computer");
x.t("back","mode");
x.t("back","policies");
x.t("back","write");
x.t("original","hot");
x.t("count","drive");
x.t("count","reaches");
x.t("count","count");
x.t("count","controller");
x.t("count","threshold");
x.t("count","based");
x.t("count","without");
x.t("default","write");
x.t("unrecoverable","error");
x.t("put","virtual");
x.t("detect","retain");
x.t("checks","drives");
x.t("product","info");
x.t("product","name");
x.t("product","data");
x.t("require","complete");
x.t("require","random");
x.t("reclaim","virtual");
x.t("reclaim","individual");
x.t("slots","used");
x.t("access","enhances");
x.t("access","allowed");
x.t("access","memory");
x.t("access","data");
x.t("access","policy");
x.t("access","raid");
x.t("4-gb","drive");
x.t("4-gb","manufacturer");
x.t("new","drive");
x.t("new","formatting");
x.t("new","controller");
x.t("new","virtual");
x.t("nickel","metal");
x.t("start","supercap");
x.t("start","time");
x.t("start","writing");
x.t("start","learn");
x.t("single","drive");
x.t("single","redundant");
x.t("single","storage");
x.t("turned","typical");
x.t("megaraid","storage");
x.t("low","supercap");
x.t("contents","drive");
x.t("contents","cache");
x.t("consists","consecutive");
x.t("certain","level");
x.t("document","absolute");
x.t("document","term");
x.t("usually","done");
x.t("usually","contains");
x.t("rebuild","drive");
x.t("rebuild","rate");
x.t("rebuild","normally");
x.t("rebuild","regeneration");
x.t("rebuild","failed");
x.t("designed","voltage");
x.t("designed","charge");
x.t("passes","control");
x.t("nearly","full");
x.t("block","empty");
x.t("block","read");
x.t("configurations","improve");
x.t("configurations","initialization");
x.t("168","hours");
x.t("nonvolatile","random");
x.t("size","controller");
x.t("size","virtual");
x.t("size","striping");
x.t("size","select");
x.t("size","strip");
x.t("size","portion");
x.t("interleaved","data");
x.t("includes","five");
x.t("repeating","drives");
x.t("counter","warns");
x.t("initialization","mode");
x.t("initialization","virtual");
x.t("initialization","erases");
x.t("initialization","quickly");
x.t("initialization","running");
x.t("initialization","process");
x.t("indicates","logical");
x.t("indicates","revision");
x.t("indicates","whether");
x.t("indicates","manufacturer");
x.t("indicates","often");
x.t("indicates","amount");
x.t("indicates","accurate");
x.t("indicates","learn");
x.t("policies","cache");
x.t("policies","controller");
x.t("policies","include");
x.t("reside","nytro");
x.t("status","hexadecimal");
x.t("status","drive");
x.t("status","supercap");
x.t("status","flag");
x.t("status","register");
x.t("status","copyback");
x.t("status","hold");
x.t("status","revision");
x.t("status","operating");
x.t("synonymous","used");
x.t("again","comes");
x.t("manufacturing","name");
x.t("manufacturing","date");
x.t("increments","cycle");
x.t("increments","max");
x.t("file","software");
x.t("info","drive");
x.t("revertible","hot");
x.t("need","attention");
x.t("group","nytro");
x.t("group","example");
x.t("group","provide");
x.t("group","drive");
x.t("group","physical");
x.t("group","multiple");
x.t("group","document");
x.t("group","group");
x.t("group","improves");
x.t("group","complete");
x.t("group","part");
x.t("group","modification");
x.t("group","array");
x.t("group","members");
x.t("group","collection");
x.t("group","stripe");
x.t("group","storage");
x.t("group","used");
x.t("group","without");
x.t("group","drives");
x.t("complete","recharge");
x.t("complete","mirrored");
x.t("complete","firmware");
x.t("complete","data");
x.t("unsupported","flag");
x.t("during","normal");
x.t("pdm","product");
x.t("improves","input/output");
x.t("improves","several");
x.t("milliamp","hours");
x.t("issued","firmware");
x.t("due","supercap");
x.t("check","rate");
x.t("check","operation");
x.t("check","parity");
x.t("check","operations");
x.t("voltage","designed");
x.t("voltage","capacity");
x.t("initialized","missing");
x.t("network","passes");
x.t("network","links");
x.t("bits","gas");
x.t("applies","reads");
x.t("unless","gas");
x.t("unless","max");
x.t("normally","occurs");
x.t("slot","slots");
x.t("rolling","average");
x.t("fails","megaraid");
x.t("fails","contents");
x.t("fails","expected");
x.t("fails","configuration");
x.t("units","drive");
x.t("units","(mah)");
x.t("metal","hydride");
x.t("offline","drive");
x.t("offline","part");
x.t("(rom)","programmable");
x.t("supporting","24-hour");
x.t("availability","fault");
x.t("availability","group");
x.t("large","files");
x.t("interrupting","normal");
x.t("controller","miscellaneous");
x.t("controller","nvram");
x.t("controller","drive");
x.t("controller","clear");
x.t("controller","supercap");
x.t("controller","installed");
x.t("controller","periodically");
x.t("controller","performs");
x.t("controller","cache");
x.t("controller","property");
x.t("controller","detect");
x.t("controller","policies");
x.t("controller","virtual");
x.t("controller","part");
x.t("controller","determine");
x.t("controller","sends");
x.t("controller","writes");
x.t("controller","attribute");
x.t("controller","configured");
x.t("controller","on-board");
x.t("controller","error");
x.t("controller","disconnecting");
x.t("controller","capacity");
x.t("controller","raid");
x.t("controller","attaching");
x.t("controller","vendor");
x.t("controller","chip");
x.t("controller","drives");
x.t("cycle","possible");
x.t("cycle","supercap");
x.t("cycle","performs");
x.t("cycle","initiate");
x.t("cycle","time");
x.t("cycle","automatically");
x.t("cycle","count");
x.t("cycle","complete");
x.t("cycle","due");
x.t("cycle","unless");
x.t("cycle","progress");
x.t("cycle","maximum");
x.t("cycle","schedule");
x.t("cycle","512/");
x.t("cycle","starts");
x.t("cycle","manually");
x.t("cycle","limited");
x.t("speeds","subsequent");
x.t("high","speed");
x.t("high","performance");
x.t("high","data");
x.t("copyback","operation");
x.t("copyback","procedure");
x.t("detects","unrecoverable");
x.t("directly","system");
x.t("writing","zeros");
x.t("writing","specific");
x.t("writing","data");
x.t("lsi","nytro");
x.t("learning","cycle");
x.t("potential","problem");
x.t("requires","data");
x.t("protects","data");
x.t("celsius","uncorrectable");
x.t("operation","drive");
x.t("operation","necessary");
x.t("operation","verifies");
x.t("operation","find");
x.t("operation","return");
x.t("operation","often");
x.t("operation","carried");
x.t("operation","runs");
x.t("operation","run");
x.t("operation","performed");
x.t("definition","hole");
x.t("stored","flash");
x.t("stored","cache");
x.t("stored","second");
x.t("stored","power");
x.t("stored","read-only");
x.t("keyboard","video");
x.t("overall","read/write");
x.t("overall","system");
x.t("connects","controllers");
x.t("auto-rebuild","feature");
x.t("programmable","rom");
x.t("hours","seven");
x.t("hours","supercap");
x.t("hours","value");
x.t("hours","days");
x.t("name","controller");
x.t("name","virtual");
x.t("name","device");
x.t("name","vendor");
x.t("maintain","contents");
x.t("maintain","integrity");
x.t("acronym","nonvolatile");
x.t("vendor-assigned","number");
x.t("vendor-assigned","model");
x.t("minute","rolling");
x.t("addresses","mapped");
x.t("addresses","subsequent");
x.t("performance","drive");
x.t("performance","cache");
x.t("performance","error");
x.t("performance","data");
x.t("performance","increasing");
x.t("margin","error");
x.t("user-assigned","name");
x.t("virtual","drive");
x.t("virtual","drives");
x.t("cycles","168");
x.t("cycles","delay");
x.t("cycles","manually");
x.t("cycles","learn");
x.t("average","time");
x.t("average","predicted");
x.t("average","charge");
x.t("controllers","hardware");
x.t("controllers","support");
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("manufactured","manufacturing");
x.t("initializing","fail");
x.t("direct","i/o");
x.t("consumption","lkm");
x.t("lose","data");
x.t("glossary","appendix");
x.t("glossary","glossary");
x.t("glossary","terms");
x.t("provides","fault");
x.t("provides","high");
x.t("provides","glossary");
x.t("compatible","drives");
x.t("mirrored","drive");
x.t("mirrored","data");
x.t("mirrored","copy");
x.t("replaced","new");
x.t("none","drive");
x.t("exists","replacement");
x.t("undergoes","qualified");
x.t("prior","host");
x.t("(i/o)","performance");
x.t("determine","condition");
x.t("bios","basic");
x.t("bios","stored");
x.t("bios","controls");
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("profile","information");
x.t("fast","initialization");
x.t("fast","memory");
x.t("address","cache");
x.t("consistent","automatically");
x.t("destination","drive");
x.t("originally","configured");
x.t("writes","zeroes");
x.t("writes","data");
x.t("writes","across");
x.t("allows","changing");
x.t("allows","import");
x.t("allows","immediately");
x.t("rom","(prom)");
x.t("map","unreadable");
x.t("degradation","performance");
x.t("modification","operation");
x.t("adjusts","value");
x.t("segments","nytro");
x.t("consumed","stripe");
x.t("array","drive");
x.t("array","hole");
x.t("empty","predicted");
x.t("empty","space");
x.t("empty","one-minute");
x.t("accessed","nytro");
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","performance");
x.t("write","write");
x.t("write","data");
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("local","key");
x.t("sets","max");
x.t("fix","potential");
x.t("pairs","drives");
x.t("regeneration","data");
x.t("lines","available");
x.t("lines","number");
x.t("predicted","supercap");
x.t("predicted","time");
x.t("predicted","remaining");
x.t("warn","firmware");
x.t("temporarily","store");
x.t("device","drive");
x.t("device","controller");
x.t("device","device");
x.t("device","code");
x.t("device","chemistry");
x.t("device","port");
x.t("device","i/o");
x.t("striping","technique");
x.t("striping","combination");
x.t("striping","parity");
x.t("striping","mirroring");
x.t("striping","two");
x.t("striping","itself");
x.t("striping","across");
x.t("relative","supercap");
x.t("relative","state");
x.t("ports","currently");
x.t("ports","controller");
x.t("resource","throughput");
x.t("low-power","storage");
x.t("256-mah","maximum");
x.t("moving","virtual");
x.t("second","drive");
x.t("retention","time");
x.t("three","drives");
x.t("attribute","indicating");
x.t("marked","failed");
x.t("auto","disabled");
x.t("auto","learn");
x.t("functions","striping");
x.t("functions","system");
x.t("store","firmware");
x.t("store","data");
x.t("failed","drive");
x.t("failed","reclaim");
x.t("failed","degraded");
x.t("failed","vendor");
x.t("redundancy","property");
x.t("redundancy","virtual");
x.t("redundancy","striping");
x.t("redundancy","especially");
x.t("redundancy","subvendor");
x.t("redundancy","raid");
x.t("redundancy","two");
x.t("concerned","none");
x.t("progress","load-balancing");
x.t("random","access");
x.t("present","rate");
x.t("present","controller");
x.t("24-hour","data");
x.t("small","databases");
x.t("small","applications");
x.t("uncorrectable","errors");
x.t("uncorrectable","error");
x.t("bgi","rate");
x.t("on-board","nytro");
x.t("on-board","supercap");
x.t("discharged","level");
x.t("configured","part");
x.t("configured","hot");
x.t("configured","online");
x.t("error","drive");
x.t("error","change");
x.t("error","count");
x.t("error","indicates");
x.t("error","recovery");
x.t("error","expected");
x.t("error","100");
x.t("error","already");
x.t("error","percent");
x.t("error","returns");
x.t("error","unconfigured");
x.t("error","(percentage)");
x.t("rebuilds","data");
x.t("sometimes","fix");
x.t("independent","drives");
x.t("raw","capacity");
x.t("backup","unit");
x.t("listing","name");
x.t("absolute","state");
x.t("absolute","state-of-charge");
x.t("next","learn");
x.t("period","time");
x.t("members","device");
x.t("rebuilt","hot");
x.t("loads","full");
x.t("install","computer");
x.t("erases","previous");
x.t("ahead","cache");
x.t("delay","current");
x.t("delay","start");
x.t("delay","interval");
x.t("automatic","learn");
x.t("logical","drives");
x.t("hold","24hr");
x.t("especially","large");
x.t("especially","applications");
x.t("occurs","without");
x.t("revision","supercap");
x.t("revision","level");
x.t("disk","drives");
x.t("mapped","fixed-size");
x.t("allowed","particular");
x.t("hole","synonymous");
x.t("hole","definition");
x.t("hole","array");
x.t("hole","auto");
x.t("hole","hole");
x.t("hole","terms");
x.t("options","supercap");
x.t("life","average");
x.t("life","present");
x.t("messages","cache");
x.t("collection","on-board");
x.t("collection","drives");
x.t("space","drive");
x.t("space","consumed");
x.t("space","data");
x.t("fail","consistency");
x.t("fail","data");
x.t("milliamperes","current");
x.t("nimh","nickel");
x.t("first","last");
x.t("first","turned");
x.t("feature","firmware");
x.t("feature","raid");
x.t("media","errors");
x.t("media","migration");
x.t("media","error");
x.t("load-balancing","method");
x.t("appears","host");
x.t("unit","provide");
x.t("unit","multiple");
x.t("unit","(cpu)");
x.t("unit","created");
x.t("databases","small");
x.t("serial","controller");
x.t("serial","number");
x.t("select","stripe");
x.t("communications","microprocessor");
x.t("written","drive");
x.t("written","restore");
x.t("written","main");
x.t("system\u2019s","overall");
x.t("activity","virtual");
x.t("number","drive");
x.t("number","cache");
x.t("number","errors");
x.t("number","times");
x.t("number","slot");
x.t("number","controller");
x.t("number","ports");
x.t("number","uncorrectable");
x.t("number","host");
x.t("number","drives");
x.t("managed","partitions");
x.t("processing","unit");
x.t("processing","capability");
x.t("control","operating");
x.t("standalone","desktop");
x.t("(cpu)","resources");
x.t("minutes","serial");
x.t("write-back","write-back");
x.t("write-back","caching");
x.t("design","voltage");
x.t("design","capacity");
x.t("design","charge");
x.t("state-of-charge","operation");
x.t("indicating","current");
x.t("indicating","type");
x.t("indicating","rate");
x.t("indicating","status");
x.t("indicating","manufacturing");
x.t("indicating","vendor-assigned");
x.t("indicating","user-assigned");
x.t("indicating","number");
x.t("indicating","length");
x.t("indicating","whether");
x.t("indicating","characteristics");
x.t("indicating","capacity");
x.t("indicating","kind");
x.t("indicating","actual");
x.t("indicating","manufacturer-assigned");
x.t("indicating","condition");
x.t("indicating","raid");
x.t("adjacent","drive");
x.t("signal","host");
x.t("length","time");
x.t("length","interleaved");
x.t("max","error");
x.t("maximum","168");
x.t("maximum","length");
x.t("maximum","adjustment");
x.t("maximum","learn");
x.t("technique","used");
x.t("elapsed","time");
x.t("2013","lsi");
x.t("2013","2013");
x.t("particular","virtual");
x.t("software","collects");
x.t("software","automatically");
x.t("software","stored");
x.t("software","allows");
x.t("software","monitors");
x.t("reads","required");
x.t("reads","buffered");
x.t("reads","specific");
x.t("stripe","drive");
x.t("stripe","resides");
x.t("stripe","consistency");
x.t("stripe","consists");
x.t("stripe","size");
x.t("stripe","writes");
x.t("stripe","case");
x.t("stripe","contains");
x.t("whether","nvram");
x.t("whether","supercap");
x.t("whether","cached");
x.t("whether","default");
x.t("whether","controller");
x.t("whether","virtual");
x.t("pack","design");
x.t("pack","less");
x.t("pack","measured");
x.t("pack","module");
x.t("pack","assembly");
x.t("(prom)","firmware");
x.t("represents","available");
x.t("represents","last");
x.t("represents","status");
x.t("define","virtual");
x.t("balancing","used");
x.t("recovery","during");
x.t("user-defined","rate");
x.t("combination","parity");
x.t("combination","raid");
x.t("(mv)","device");
x.t("characteristics","drive");
x.t("zeroes","first");
x.t("replace","failed");
x.t("replace","rebuilds");
x.t("replace","member");
x.t("disconnecting","drives");
x.t("accessing","data");
x.t("reduce","capacity");
x.t("consecutive","virtual");
x.t("degraded","need");
x.t("degraded","write-back");
x.t("one-minute","rolling");
x.t("manufacturer","components");
x.t("manufacturer","4,128");
x.t("manufacturer","4,196");
x.t("identical","capacity");
x.t("redundant","drive");
x.t("redundant","virtual");
x.t("redundant","configuration");
x.t("redundant","data");
x.t("redundant","raid");
x.t("capacity","example");
x.t("capacity","drive");
x.t("capacity","supercap");
x.t("capacity","controller\u2019s");
x.t("capacity","energy");
x.t("capacity","property");
x.t("capacity","designed");
x.t("capacity","status");
x.t("capacity","absolute");
x.t("capacity","design");
x.t("capacity","amount");
x.t("capacity","4,088");
x.t("capacity","capable");
x.t("capacity","read");
x.t("capacity","remaining");
x.t("capacity","expressed");
x.t("capacity","terms");
x.t("capacity","drives");
x.t("capacity","coerced");
x.t("read/write","performance");
x.t("read/write","read");
x.t("expected","margin");
x.t("expected","fail");
x.t("accessible","nytro");
x.t("accessible","virtual");
x.t("capability","drive");
x.t("capability","lsi");
x.t("lost","drive");
x.t("lost","hot");
x.t("lost","data");
x.t("works","small");
x.t("reconstruction","rate");
x.t("factors","revertible");
x.t("strip","size");
x.t("hot","spares");
x.t("hot","spare");
x.t("invalid","data");
x.t("prepare","removal");
x.t("dedicated","single");
x.t("code","indicates");
x.t("retain","virtual");
x.t("powering","down");
x.t("connected","controller");
x.t("connected","strip");
x.t("return","values");
x.t("tracks","time");
x.t("disabled","unchanged");
x.t("disabled","firmware");
x.t("disabled","warning");
x.t("fully","charged");
x.t("often","responsible");
x.t("often","data");
x.t("often","used");
x.t("level","below");
x.t("level","drive");
x.t("level","drive\u2019s");
x.t("level","gas");
x.t("level","virtual");
x.t("level","consistent");
x.t("level","level");
x.t("level","without");
x.t("groups","controlled");
x.t("groups","operation");
x.t("groups","provides");
x.t("groups","raid");
x.t("groups","work");
x.t("restore","full");
x.t("restore","specific");
x.t("arrangement","drive");
x.t("term","virtual");
x.t("undoing","configuration");
x.t("100","percent");
x.t("firmware","supercap");
x.t("firmware","resets");
x.t("firmware","new");
x.t("firmware","detects");
x.t("firmware","software");
x.t("firmware","tracks");
x.t("firmware","often");
x.t("firmware","configuration");
x.t("firmware","monitor");
x.t("firmware","run");
x.t("firmware","warns");
x.t("pending","learn");
x.t("memory","microprocessor");
x.t("memory","saved");
x.t("memory","supercap");
x.t("memory","cache");
x.t("memory","(rom)");
x.t("memory","speeds");
x.t("memory","direct");
x.t("memory","address");
x.t("memory","software");
x.t("memory","holds");
x.t("memory","already");
x.t("memory","read");
x.t("memory","data");
x.t("memory","policy");
x.t("memory","copy");
x.t("memory","immediately");
x.t("memory","storage");
x.t("memory","chip");
x.t("memory","associated");
x.t("memory","buffer");
x.t("threshold","default");
x.t("previous","data");
x.t("previous","setting");
x.t("known","virtual");
x.t("operating","status");
x.t("operating","system");
x.t("gauge","limits");
x.t("gauge","status");
x.t("gauge","increments");
x.t("gauge","adjusts");
x.t("gauge","sets");
x.t("parity","provide");
x.t("parity","put");
x.t("parity","provides");
x.t("parity","fields");
x.t("parity","data");
x.t("parity","drives");
x.t("ready","state");
x.t("affect","read");
x.t("exact","copy");
x.t("environment","requires");
x.t("given","time");
x.t("greater","100");
x.t("kind","access");
x.t("carried","bios");
x.t("carried","redundancy");
x.t("recently","accessed");
x.t("quickly","writes");
x.t("actual","full");
x.t("click","reclaim");
x.t("4,128","drives");
x.t("reverts","rebuild");
x.t("(mah)","design");
x.t("existing","configuration");
x.t("zeros","data");
x.t("less","power");
x.t("(vd)","indicates");
x.t("changing","raid");
x.t("consider","stripe");
x.t("longer","support");
x.t("seen","operating");
x.t("calibration","operation");
x.t("miss","fetched");
x.t("amount","dirty/clean");
x.t("amount","space");
x.t("amount","charge");
x.t("amount","storage");
x.t("amount","remaining");
x.t("4,196","4-gb");
x.t("usable","capacity");
x.t("usable","storage");
x.t("configuration","nytro");
x.t("configuration","drive");
x.t("configuration","create");
x.t("configuration","wizard");
x.t("configuration","consistency");
x.t("configuration","new");
x.t("configuration","protects");
x.t("configuration","virtual");
x.t("configuration","relative");
x.t("configuration","concerned");
x.t("configuration","failed");
x.t("configuration","redundant");
x.t("configuration","reconstruction");
x.t("configuration","already");
x.t("configuration","data");
x.t("configuration","raid");
x.t("configuration","prevents");
x.t("configuration","coercion");
x.t("manufacturer-assigned","device");
x.t("manufacturer-assigned","serial");
x.t("include","optimal");
x.t("include","amount");
x.t("include","intelligent");
x.t("undergo","single");
x.t("failure","nvram");
x.t("failure","drive");
x.t("failure","lost");
x.t("failure","temperature");
x.t("failure","per");
x.t("qualified","discharge");
x.t("transferred","cache");
x.t("saving","accessing");
x.t("main","memory");
x.t("aborted","started");
x.t("interval","controller");
x.t("interval","length");
x.t("far","raid");
x.t("running","background");
x.t("tolerance","redundant");
x.t("tolerance","capability");
x.t("value","represents");
x.t("value","charge");
x.t("value","data");
x.t("value","updated");
x.t("power","consumption");
x.t("power","failure");
x.t("power","save");
x.t("power","case");
x.t("power","removed");
x.t("modules","slots");
x.t("additional","vendor");
x.t("charge","placed");
x.t("charge","supercap");
x.t("charge","likely");
x.t("charge","current");
x.t("charge","self-discharge");
x.t("charge","calculation");
x.t("charge","rate");
x.t("charge","indicates");
x.t("charge","predicted");
x.t("charge","capacity");
x.t("charge","returns");
x.t("holds","recently");
x.t("already","below");
x.t("already","cache");
x.t("already","stored");
x.t("already","exists");
x.t("specific","physical");
x.t("specific","virtual");
x.t("specific","arrangement");
x.t("specific","value");
x.t("measured","full");
x.t("measured","celsius");
x.t("measured","milliampere-hour");
x.t("measured","millivolts");
x.t("bus","controller");
x.t("several","drives");
x.t("attention","unknown");
x.t("db15-001059-00-april","2013");
x.t("condition","supercap");
x.t("condition","virtual");
x.t("computer","bios");
x.t("computer","system\u2019s");
x.t("computer","host");
x.t("computer","system");
x.t("fetched","main");
x.t("process","providing");
x.t("process","checks");
x.t("process","writing");
x.t("process","moving");
x.t("process","using");
x.t("subsystem","accordance");
x.t("subsystem","improve");
x.t("subsystem","collection");
x.t("subsystem","undergo");
x.t("subsystem","received");
x.t("subsystem","occur");
x.t("sectors","improve");
x.t("sectors","virtual");
x.t("sectors","drives");
x.t("nominally","identical");
x.t("nominally","capacity");
x.t("fixes","errors");
x.t("compromising","data");
x.t("manager","software");
x.t("import","existing");
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","ahead");
x.t("read","written");
x.t("read","aborted");
x.t("read","process");
x.t("read","blocked");
x.t("read","policy");
x.t("read","operations");
x.t("4,088","drive");
x.t("runs","background");
x.t("chemistry","possible");
x.t("systems","hot");
x.t("systems","considered");
x.t("considered","host");
x.t("lkm","local");
x.t("capable","supporting");
x.t("subvendor","controller");
x.t("although","virtual");
x.t("schedule","learn");
x.t("sfms","reside");
x.t("transfer","completion");
x.t("transfer","data");
x.t("online","drive");
x.t("online","hot");
x.t("online","host");
x.t("online","removed");
x.t("good","drive");
x.t("good","offline");
x.t("location","offline");
x.t("stated","milliamp");
x.t("data","nytro");
x.t("data","residing");
x.t("data","microprocessor");
x.t("data","throughput");
x.t("data","drive");
x.t("data","accordance");
x.t("data","onto");
x.t("data","source");
x.t("data","cache");
x.t("data","cached");
x.t("data","copied");
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","ports");
x.t("data","second");
x.t("data","retention");
x.t("data","striping");
x.t("data","failed");
x.t("data","redundancy");
x.t("data","rebuilt");
x.t("data","written");
x.t("data","adjacent");
x.t("data","stripe");
x.t("data","lost");
x.t("data","accessible");
x.t("data","parity");
x.t("data","transferred");
x.t("data","far");
x.t("data","already");
x.t("data","read");
x.t("data","transfer");
x.t("data","data");
x.t("data","protection");
x.t("data","striped");
x.t("data","raid");
x.t("data","replacement");
x.t("data","case");
x.t("data","mirroring");
x.t("data","transaction");
x.t("data","management");
x.t("data","storage");
x.t("data","across");
x.t("data","drives");
x.t("data","patrol");
x.t("correct","mirrored");
x.t("host","drive");
x.t("host","current");
x.t("host","interface");
x.t("host","access");
x.t("host","controller");
x.t("host","systems");
x.t("host","data");
x.t("host","port");
x.t("host","concurrently");
x.t("host","system");
x.t("attached","nytro");
x.t("removal","operation");
x.t("typical","example");
x.t("discharge","supercap");
x.t("discharge","nearly");
x.t("discharge","minutes");
x.t("information","controller");
x.t("information","system");
x.t("information","drives");
x.t("module","version");
x.t("module","supercap");
x.t("temperature","supercap");
x.t("temperature","temperature");
x.t("protection","copyback");
x.t("protection","case");
x.t("protection","raid");
x.t("received","data");
x.t("read-only","memory");
x.t("mainframes","workstations");
x.t("save","supercap");
x.t("512/","256-mah");
x.t("striped","across");
x.t("increasing","number");
x.t("examples","include");
x.t("values","supercap");
x.t("values","missing");
x.t("values","auto");
x.t("values","nimh");
x.t("values","read/write");
x.t("values","greater");
x.t("values","learn");
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("blocked","array");
x.t("monitor","program");
x.t("monitor","initiate");
x.t("raid","provide");
x.t("raid","drive");
x.t("raid","uses");
x.t("raid","support");
x.t("raid","migration");
x.t("raid","configurations");
x.t("raid","group");
x.t("raid","virtual");
x.t("raid","functions");
x.t("raid","combination");
x.t("raid","works");
x.t("raid","level");
x.t("raid","configuration");
x.t("raid","raid");
x.t("raid","storage");
x.t("raid","levels");
x.t("raid","subsystems");
x.t("milliampere-hour","units");
x.t("replacement","drive");
x.t("replacement","warning");
x.t("replacement","drives");
x.t("prevent","data");
x.t("case","drive");
x.t("case","max");
x.t("case","stripe");
x.t("case","power");
x.t("mirroring","provide");
x.t("mirroring","pairs");
x.t("mirroring","parity");
x.t("mirroring","process");
x.t("procedure","data");
x.t("procedure","used");
x.t("port","count");
x.t("partitions","known");
x.t("global","hot");
x.t("problem","drives");
x.t("percentage","full");
x.t("percentage","central");
x.t("percentage","fast");
x.t("percentage","design");
x.t("flush","write");
x.t("flush","interval");
x.t("transaction","drive");
x.t("transaction","cycle");
x.t("transaction","write");
x.t("transaction","design");
x.t("transaction","data");
x.t("lion","lithium");
x.t("done","drive");
x.t("two","nytro");
x.t("two","mirrored");
x.t("two","drives");
x.t("two","computers");
x.t("date","supercap");
x.t("date","date");
x.t("based","minute");
x.t("based","number");
x.t("copy","drive\u2019s");
x.t("copy","saved");
x.t("copy","data");
x.t("monitors","addresses");
x.t("typically","drive");
x.t("unreadable","bad");
x.t("work","two");
x.t("work","without");
x.t("comes","cache");
x.t("attaching","firmware");
x.t("applications","require");
x.t("prevents","data");
x.t("itself","provide");
x.t("reached","auto");
x.t("controls","connects");
x.t("controls","communications");
x.t("controls","transfer");
x.t("immediately","start");
x.t("immediately","main");
x.t("created","nytro");
x.t("created","virtual");
x.t("created","several");
x.t("estimated","time");
x.t("accurate","reported");
x.t("concurrently","data");
x.t("causes","supercap");
x.t("24hr","charge");
x.t("used","four");
x.t("used","supercap");
x.t("used","create");
x.t("used","maximize");
x.t("used","interchangeably");
x.t("used","cached");
x.t("used","slots");
x.t("used","document");
x.t("used","rebuild");
x.t("used","maintain");
x.t("used","write");
x.t("used","store");
x.t("used","define");
x.t("used","saving");
x.t("used","computer");
x.t("used","raid");
x.t("used","two");
x.t("used","copy");
x.t("percent","four");
x.t("percent","full");
x.t("percent","completion");
x.t("percent","gas");
x.t("percent","access");
x.t("percent","unless");
x.t("percent","relative");
x.t("percent","case");
x.t("percent","percent");
x.t("offers","protection");
x.t("offers","following");
x.t("following","states");
x.t("following","options");
x.t("system","example");
x.t("system","drive");
x.t("system","foreign");
x.t("system","megaraid");
x.t("system","single");
x.t("system","rebuild");
x.t("system","pdm");
x.t("system","controller");
x.t("system","performance");
x.t("system","lose");
x.t("system","predicted");
x.t("system","raw");
x.t("system","loads");
x.t("system","messages");
x.t("system","first");
x.t("system","computer");
x.t("system","i/o");
x.t("caching","mode");
x.t("caching","process");
x.t("storage","mode");
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("run","time");
x.t("run","automatically");
x.t("run","computer");
x.t("management","manufacturing");
x.t("management","file");
x.t("management","estimated");
x.t("corresponding","parity");
x.t("links","cpus");
x.t("starts","non-redundant");
x.t("model","number");
x.t("individual","drives");
x.t("remaining","supercap");
x.t("remaining","relative");
x.t("remaining","capacity");
x.t("remaining","amount");
x.t("remaining","charge");
x.t("using","sequential");
x.t("using","high");
x.t("coercion","mode");
x.t("flowing","supercap");
x.t("ion","device");
x.t("setting","drive");
x.t("warning","issued");
x.t("warning","learn");
x.t("vendor","drive");
x.t("vendor","info");
x.t("vendor","controller");
x.t("vendor","information");
x.t("terms","hole");
x.t("terms","percentage");
x.t("terms","used");
x.t("expressed","percentage");
x.t("manually","supercap");
x.t("manually","automatically");
x.t("manually","typically");
x.t("manually","learn");
x.t("subsequent","access");
x.t("subsequent","reads");
x.t("i/o","mode");
x.t("i/o","buses");
x.t("i/o","operation");
x.t("i/o","direct");
x.t("i/o","bus");
x.t("i/o","used");
x.t("millivolts","(mv)");
x.t("bad","drive");
x.t("bad","sectors");
x.t("per","drive");
x.t("levels","generating");
x.t("levels","raid");
x.t("returns","percent");
x.t("adjustment","values");
x.t("across","multiple");
x.t("across","three");
x.t("across","two");
x.t("across","drives");
x.t("distributed","parity");
x.t("portion","stripe");
x.t("performed","nytro");
x.t("performed","periodically");
x.t("chip","bios");
x.t("chip","controls");
x.t("associated","main");
x.t("(forced)","compatible");
x.t("(forced)","usable");
x.t("operations","run");
x.t("operations","affected");
x.t("lithium","ion");
x.t("without","drive");
x.t("without","repeating");
x.t("without","interrupting");
x.t("without","initializing");
x.t("without","powering");
x.t("without","compromising");
x.t("without","learn");
x.t("behavior","system");
x.t("load","balancing");
x.t("assembly","manufactured");
x.t("assembly","max");
x.t("limited","gas");
x.t("occur","rebuild");
x.t("compensation","factors");
x.t("member","procedure");
x.t("drives","example");
x.t("drives","provide");
x.t("drives","drive");
x.t("drives","hardware");
x.t("drives","formatted");
x.t("drives","five");
x.t("drives","group");
x.t("drives","offline");
x.t("drives","controller");
x.t("drives","auto-rebuild");
x.t("drives","virtual");
x.t("drives","prior");
x.t("drives","accessed");
x.t("drives","install");
x.t("drives","appears");
x.t("drives","managed");
x.t("drives","stripe");
x.t("drives","hot");
x.t("drives","connected");
x.t("drives","carried");
x.t("drives","seen");
x.t("drives","amount");
x.t("drives","nominally");
x.t("drives","maintaining");
x.t("drives","although");
x.t("drives","attached");
x.t("drives","data");
x.t("drives","mirroring");
x.t("drives","created");
x.t("drives","storage");
x.t("drives","used");
x.t("drives","distributed");
x.t("drives","without");
x.t("drives","coerced");
x.t("drives","drives");
x.t("drives","attach");
x.t("drives","spanned");
x.t("drives","including");
x.t("drives","removed");
x.t("drives","resources");
x.t("coerced","capacity");
x.t("coerced","usable");
x.t("coerced","(forced)");
x.t("hydride","lion");
x.t("unconfigured","good");
x.t("unconfigured","bad");
x.t("attach","directly");
x.t("standby","drive");
x.t("days","media");
x.t("days","learn");
x.t("spanned","drive");
x.t("including","parity");
x.t("write-through","caching");
x.t("write-through","write-through");
x.t("learn","mode");
x.t("learn","state");
x.t("learn","time");
x.t("learn","cycle");
x.t("learn","cycles");
x.t("learn","warn");
x.t("learn","period");
x.t("learn","delay");
x.t("learn","disabled");
x.t("learn","firmware");
x.t("buffer","speed");
x.t("removed","nvram");
x.t("removed","virtual");
x.t("removed","location");
x.t("generates","media");
x.t("desktop","systems");
x.t("pool","drive");
x.t("computers","network");
x.t("patrol","read");
x.t("subsystems","allows");
x.t("affected","virtual");
x.t("warns","next");
x.t("warns","pending");
x.t("devices","keyboard");
x.t("higher","speed");
x.t("contains","drive");
x.t("contains","recently");
x.t("intelligent","controller");
x.t("updated","learn");
x.t("resources","devoted");
x.t("resources","load");
x.t("(percentage)","state");
}
