Memóriachipeknél miért nem alkalmazzák azt a módszert, hogy a bit mellé beépítenek egy SSD-bitet is, és ha valamilyen áramkimaradás van, akkor még gyorsan el tudja menteni a memória tartalmát a gép?

> és ha valamilyen áramkimaradás van, akkor még gyorsan el tudja menteni

Az SSD bár gyors, de még mindig lassabb, mint a RAM. Így folyamatosan nem lehetne minden memóriában történő változást azonnal tárolni is. Ha te egy másodperc alatt 3 számjegyet tudsz leírni, akkor nem tudod írással követni egy kijelzőn megjelenő 10 számjegyes szám másodpercenkénti 10-szer történő változását. Még ha próbálnád is követni, az sem lesz konzisztens állapot, könnyen lehet olyan számok lesznek a papírodon leríva, amik így egymás után nem voltak a kijelzőn. Ráadásul mivel az SSD nem írható korlátlanul, így villámgyorsan tönkre is menne.

Ha az SSD állapotának a változás tudná követni a RAM változásának a sebességét, akkor kvázi nem lenne szükség RAM-ra.

Olyan meg nincs, hogy „még gyorsan”. Ha áramszünet van, akkor elveszik a memória tartalma.

Olyat lehetne, hogy áramszünet esetén még lenne némi tartalék energia, ami az SSD-re íráshoz kell. De erre meg ott vannak a szünetmentes tápegységek. Áramszünet esetén a gép ki tudja írni a memória tartalmát, hibernálni a gépet.

A memória nem egy statikus és független valami. Egy hibernálásnál fontos, hogy a memória egy konzisztens állapotban legyen letárolva, a hardverek le legyenek állítva, majd a helyreállítás során vissza ez az állapot legyen visszaállítva. Random pillanatban a processzor állapotát is le kellene tárolni, ha azt akarjuk, hogy a folyamatok folytathatók legyenek. Mondok egy egyszerű példát, tegyük fel a program összeadja az első 10 pozitív egész szám összegét. A dolog egyszerű, van egy memóriacella, ami az aktuális számot tárolja (1-től 10-ig), meg egy másik memóriacella, ami az addig kiszámolt összeget. Valami ilyesmi történik:

1. kezdőértékek beállítása: szám = 1; osszeg = 0

2. növelem az összeget a számmal: szám = 1; osszeg = 1

3. növelem a számot eggyel: szám = 2; osszeg = 1

4. növelem az összeget a számmal: szám = 2; osszeg = 3

5. növelem a számot eggyel: szám = 3; osszeg = 3

6. növelem az összeget a számmal: szám = 3; osszeg = 6

7. növelem a számot eggyel: szám = 4; osszeg = 6

8. növelem az összeget a számmal: szám = 4; osszeg = 10

9. növelem a számot eggyel: szám = 5; osszeg = 10

10. növelem az összeget a számmal: szám = 5; osszeg = 15

stb…

Oké, jön az áramszünet, a memóriában az van, hogy a szám 5, az összeg meg 10. Oké, de mi a következő lépés? Az összeget kell növelni a számmal? Vagy előbb még a számot kell növelni eggyel? Hol tartott a processzor a ciklusban, melyik utasítás következik?

Hab a tortán, hogy a processzornak is van saját memóriája (regiszterek).

Már az alapgondolat is meglehetősen szélsőséges, hisz egy más típusú memória teljesen más gyártástechnológiát igényel, mások a belső struktúra üzemi feszültségei (Az SSD-be be is kel injektálni azokat a töltéseket), és gyakorlatilag néhányszorosára drágulna a technológia a két eltérő rendszer egybehozása miatt.

Ha üzembiztonság kell, akkor ott vannak a hibernálást biztosító tápegységek, melyek viszonylag olcsóak és kis helyen is elférnek, vagy lehet rendes hosszútávú szünetmentes ellátást biztosítani. A notebookoknak, tableteknek és okostelefonoknak meg már alapból van saját akkumulátoruk.

Régen készítettek úgy gépeket, speicális alkalmazásokra, hogy valami hasonló megoldás volt bennük. Ezt általában BBU-nak nevezték az egységet Backup Battery Unit az volt a szerepe, hogy ha a gép áramkimaradás miatt megáll akkor az operatív memória, és a CPU belső regiszterei kapjanak tápellátást és ne történjen adatvesztés. A vissza indításkor egy (általában) szervíz processzor el tudta végezni ennek fájlba mentését általában diszkre (amúgy pl. a diszk kontrollerek esetén a write cache is meg volt támogatva BBU-val) mentését és vagy eldobta a kezelő ezt, vagy vissza állította és ott folytatta ahol abba maradt a gép futása. Ez akkoriban volt még amikor nem voltak még elérhetőek kellő teljesítményben szünetmentes áramforrások.

Ma ahol ez igény ez úgy van megoldva, hogy van egy szünetmentes áramforrás amelyik x ideig (ez igénytől és mérettől függően néhány tíz másodperc esetleg negyed-fél óra ld.: [link] ), majd elindul egy letelepített dízel áramfejlesztő (ilyen helyeken ezek egészen extrém megoldások is lehetnek 5-8-10 másodperces indítási idővel képesek indulni) és átveszi az egész rendszer tápellátását. És a gép üzemel tovább. Illetve ez ki van egészítve azzal, hogy kettős esetleg hármas tápellátást kap maga a gép (2-3 darab olyan tápegység van benne, amelyek közül bármelyik képes a gépet maximálisan ellátni energiával) és ha egészen a gép tápegységéig van hiba akkor meg átveszi az egészet egy másik tápegység (olyan rövid idő alatt, hogy nem okoz zavart a gép működésében).

Ez a megoldás (hogy a tápellátást biztosítják) egyszerűbb, mint "barkácsolni" a memóriával.

Szoftveres megoldás volt (szintén régen elterjedt, ma már ritkán használják) a checkpointing technika, ezt az op.rendszer támogatta és a fordításkor, illetve a job kontrolnál kellett jól beállítani. Ez azt csinálta,hogy ha nagy számításigényes feladat volt akkor x időnként(vagy műveletenként rendszer függően) az adott job memória területét lementette egy fájlba, és ha a job futása bármi miatt megszakadt az újraindításkor az utolsó checkpointing állapotról folytatta.

Még régebben meg eleve olyan memória volt a gépben ami nem felejtette el, hogy mi van a memóriában, ha ki lett kapcsolva /youtubeon vannak videók, amikor 40-50 éve kikapcsolt gépek memóriatartalmát olvassák vissza, hogy mit csinált utoljára a gép amikor ki lett kapcsolva/. Ki lehetett menteni utána a memóriát és lehetett vele dolgozni ha valakinek ez nagyon fontos volt.

Amúgy:

[link]