Valamikor szórakoztató nézni a számítási tapasztalat felületi szintjét, máskor pedig jó belemerülni a belső működésbe. Ma megvizsgáljuk a számítógép memóriájának felépítését és azt, hogy mennyi cuccot tud bepakolni egy RAM memóriába.
A mai Kérdések és válaszok ülés a SuperUser jóvoltából érkezik hozzánk - a Stack Exchange alosztályához, amely a Q & A webhelyek közösségvezérelt csoportosulása.
A kérdés
Johan Smohan, a SuperUser olvasója azzal küszködik, hogy a processzor típusa és a memória mérete hogyan működik együtt, és így összesen címet kap. Ír:
Hány memória címet kaphatunk 32 bites processzorral és 1 GB RAM-mal, és hányat 64 bites processzorral?
Azt hiszem, valami ilyesmi:
1 GB RAM osztva 32 bit 4 bittel (?), Hogy megkapjuk a memória címek számát?
Azt olvastam a Wikipédián, hogy 1 memóriacím 32 bit széles vagy 4 oktett (1 oktett = 8 bit), szemben egy 64 bites processzorral, ahol 1 memóriacím vagy 1 egész 64 bit széles vagy 8 oktett. De azt sem tudom, jól értettem-e.
Ezek a kérdések képesek éjszakánként fent tartani a kíváncsi strébereket. Hány cím áll rendelkezésre Johan hipotetikus rendszerei alatt?
A válasz
A SuperUser közreműködője, Gronostaj betekintést nyújt a RAM felosztásába és felhasználásába:
Rövid válasz: A rendelkezésre álló címek száma megegyezik a kisebbikkel:
- A memória mérete bájtokban
- A legnagyobb, aláíratlan egész szám, amely a CPU gépi szavába menthető
Hosszú válasz és a fentiek magyarázata:
A memória bájtokból áll (B). Minden bájt 8 bitből áll (b).
1 B = 8 b1 GB RAM valójában 1 GiB (gigibájt, nem gigabájt). A különbség:
1 GB = 10 ^ 9 B = 1 000 000 000 B 1 GiB = 2 ^ 30 B = 1 073 741 824 BA memória minden bájtjának megvan a saját címe, függetlenül attól, hogy mekkora a CPU gépszava. Például. Az Intel 8086 CPU 16 bites volt, és bájtokkal címezte a memóriát, ugyanúgy, mint a modern 32 bites és 64 bites CPU-k. Ez az első korlát oka - nem lehet több címe, mint memória bájtja.
A memóriacím csak néhány bájt, amelyet a CPU-nak ki kell hagynia a memória elejéről, hogy elérje a keresett címet.
- Az első bájt eléréséhez 0 bájtot kell kihagynia, tehát az első bájt címe 0.
- A második bájt eléréséhez 1 bájtot kell kihagynia, tehát címe 1.
- (és így tovább…)
- Az utolsó bájt eléréséhez a CPU kihagyja az 1073741823 bájtokat, így címe 1073741823.
Most már tudnia kell, mit is jelent valójában a 32 bites. Mint már korábban említettem, akkora, mint egy gépi szó.
A gépi szó az a memóriamennyiség, amelyet a processzor a számok tárolására használ (RAM, cache vagy belső regiszterekben). A 32 bites CPU 32 bitet (4 bájt) használ a számok megtartására. A memória címek is számok, tehát egy 32 bites CPU-n a memória cím 32 bitből áll.
Most gondoljon erre: ha van egy bitje, akkor két értéket menthet el rajta: 0 vagy 1. Adjon hozzá még egy bitet, és négy értéke van: 0, 1, 2, 3. Három biten nyolc értéket menthet el. : 0, 1, 2… 6, 7. Ez valójában egy bináris rendszer, és így működik:
Bináris tizedes 0 0000 1 0001 2 0010 3 0011 4 0100 5 0101 6 0110 7 0111 8 1000 9 1001 10 1010 11 1011 12 1100 13 1101 14 1110 15 1111Pontosan úgy működik, mint a szokásos összeadás, de a maximális számjegy 1, nem 9. Tizedes 0
0000, akkor hozzáadsz 1-et és megkapod0001, adj hozzá még egyszer egyet, és megvan0010. Ami itt történt, olyan, mintha tizedes lenne09és hozzáad egy: a 9-et 0-ra változtatja, és növeli a következő számjegyet.A fenti példából láthatja, hogy mindig van egy maximális érték, amelyet állandó számokkal megtarthat egy állandó számú bit mellett - mert amikor az összes bit 1, és megpróbálja 1-vel növelni az értéket, akkor az összes bit 0 lesz, így megtörve a szám. Egész túlcsordulásnak hívják, és sok kellemetlen problémát okoz mind a felhasználók, mind a fejlesztők számára.
11111111 = 255 + 1 ----------- 100000000 = 0 (9 bit itt, tehát 1 van vágva)
- 1 bit esetén a legnagyobb érték 1,
- 2 bit - 3,
- 3 bit - 7,
- 4 bit - 15
A lehető legnagyobb szám mindig 2 ^ N-1, ahol N a bitek száma. Mint korábban mondtam, a memóriacím egy szám, és ennek maximális értéke is van. Ezért a gépi szó mérete korlátozza a rendelkezésre álló memória címek számát is - néha a CPU egyszerűen nem képes feldolgozni a memóriát elég nagy számokat.
Tehát 32 biten 0 és 2 ^ 32-1 közötti számokat tarthat, ez pedig 4 294 967 295. Ez több, mint az 1 GB RAM legnagyobb címe, tehát a konkrét esetben a RAM mennyisége lesz a korlátozó tényező.
A 32 bites CPU RAM korlátja elméletileg 4 GB (2 ^ 32), a 64 bites CPU esetében pedig 16 EB (exabájt, 1 EB = 2 ^ 30 GB). Más szavakkal, a 64 bites CPU az egész internetet képes volt megszólítani… 200-szor; WolframAlpha ).
Azonban a valós operációs rendszerekben a 32 bites CPU-k kb. 3 GiB RAM-ot tudnak megszólítani. Ennek oka az operációs rendszer belső architektúrája - egyes címek más célokra vannak fenntartva. Bővebben olvashat erről az ún 3 GB korlát a Wikipédián . Ezzel a határértékkel emelheti Fizikai cím kiterjesztés .
A memóriacímzésről szólva néhány dolgot meg kell említenem: virtuális memória , szegmentálás és lapozás .
Virtuális memória
Ahogy @Daniel R Hicks egy másik válaszában rámutatott, az operációs rendszerek virtuális memóriát használnak. Ez azt jelenti, hogy az alkalmazások valójában nem valós memória címeken működnek, hanem az OS által biztosítottak.
Ez a technika lehetővé teszi az operációs rendszer számára, hogy bizonyos adatokat áthelyezzen a RAM-ból egy úgynevezett Pagefile (Windows) vagy Swap (* NIX) fájlba. A HDD néhány nagyságrenddel lassabb, mint a RAM, de ez nem jelent komoly problémát a ritkán elérhető adatok esetében, és lehetővé teszi az operációs rendszer számára, hogy több RAM-ot biztosítson az alkalmazások számára, mint amennyit ténylegesen telepített.
Lapozás
Amiről eddig beszéltünk, lapos címzési sémának hívják.
A személyhívás egy alternatív címzési séma, amely lehetővé teszi több memória címzését, amelyet általában egy gépi szóval lapos modellben lehetne megtenni.
Képzeljen el egy könyvet, amely tele van négy betűvel. Tegyük fel, hogy minden oldalon 1024 szám található. Egy szám címzéséhez két dolgot kell tudnia:
- Azon oldalak száma, amelyekre a szó nyomtatva van.
- Az oldalon melyik szót keresed.
Most a modern x86-os processzorok pontosan így kezelik a memóriát. 4 KiB oldalra van osztva (egyenként 1024 gépszóra), és ezek az oldalak számokkal rendelkeznek. (valójában az oldalak 4 MiB méretűek vagy 2 MiB méretűek lehetnek PAE ). Ha memóriacellát szeretne címezni, akkor meg kell adnia az oldal számát és címét. Vegye figyelembe, hogy minden memóriacellára pontosan egy számpár hivatkozik, ez nem lesz a szegmentálás esete.
Szegmentálás
Nos, ez nagyon hasonlít a lapozáshoz. Az Intel 8086-ban használták, csak hogy egy példát említsek. A címcsoportokat most memóriaszegmenseknek nevezzük, nem oldalaknak. A különbség az, hogy a szegmensek átfedhetnek, és nagyon is átfedik egymást. Például 8086-on a legtöbb memóriacella 4096 különböző szegmensből állt rendelkezésre.
Egy példa:
Tegyük fel, hogy van 8 bájt memóriánk, mind a nullával rendelkezik, kivéve a 4. bájtot, amely 255-tel egyenlő.
Illusztráció a lapos memória modellhez:
_____ | 0 | | 0 | | 0 | | 255 | | 0 | | 0 | | 0 | | 0 | -----Ábra a lapozott memória számára 4 bájtos oldalakkal:
0. OLDAL _____ | 0 | | 0 | | 0 | 1 OLDAL | 255 | _____ ----- | 0 | | 0 | | 0 | | 0 | -----A szegmentált memória illusztrációja 4 bájtos szegmensekkel 1-vel eltolva:
SEG 0 _____ SEG 1 | 0 | _____ SEG 2 | 0 | | 0 | _____ 3. sz | 0 | | 0 | | 0 | _____ 4. sz | 255 | | 255 | | 255 | | 255 | _____ 5. sz ----- | 0 | | 0 | | 0 | | 0 | _____ 6. sz ----- | 0 | | 0 | | 0 | | 0 | _____ 7. sz ----- | 0 | | 0 | | 0 | | 0 | _____ ----- | 0 | | 0 | | 0 | | 0 | ----- ----- ----- -----Mint látható, a 4. bájt négyféleképpen címezhető: (címzés 0-tól)
- 0. szegmens, 3. eltolás
- 1. szegmens, 2. eltolás
- 2. szegmens, 1. eltolás
- 3. szegmens, 0. eltolás
Mindig ugyanaz a memóriacella.
A valós életben a szegmensek több mint 1 bájttal vannak eltolva (8086 esetében 16 bájt volt).
A szegmentálásban az a rossz, hogy bonyolult (de azt hiszem, ezt már tudod;) Ami jó, hogy néhány okos technikával moduláris programokat hozhat létre.
Például betölthet egy modult egy szegmensbe, majd úgy tehet, mintha a szegmens kisebb lenne, mint amennyi valójában (éppen elég kicsi ahhoz, hogy megtartsa a modult), majd válassza az első szegmenst, amely nem fedi át azt az ál-kisebbet, és töltse be a következőt modul, és így tovább. Alapvetően, amit így kap, az változó méretű oldalak.
Van valami hozzáfűzhető a magyarázathoz? Hangzik el a megjegyzésekben. Szeretne további válaszokat olvasni más, hozzáértő Stack Exchange-felhasználóktól? Nézze meg a teljes vitafonalat itt .
