Megszakítási rendszer

Architektúrák II. 2007. 2. félév Koschek Vilmos előadása alapján

Megszakítási rendszer Megszakítások fogalma: A számítógép működése közben igen gyakran következnek be olyan események, amelyek a feldolgozás szempontjából váratlanak tekinthetők. Ezek a váratlan események a megszakítások. Ezen megszakítások kezelésére szolgál a megszakítási rendszer.

A megszakítások elsődleges célja, előzménye: Az I/O műveletek és a velük átlapoltan végrehajtható utasítások szinkronizálása, összehangolása.

I/O művelet indulása I/O művelet befejezése Elindul egy I/O művelet, pl. winchesterről szeretnénk beolvasni néhány byteot. Kiadódik az I/O olvasási parancs, és eltelik valamennyi idő (Tw) amíg válasz érkezik a winchesterről. Ez idő alatt a CPU: • Várakozhat – nem hatékony • Másik folyamat – amíg válasz nem érkezik a perifériáról, elindít egy másik folyamatot Másik folyamat indítása

1. oldal


A CPU az első folyamatot hajtja végre. Az I/O indítás pillanatában átvált, és elindít egy új folyamatot. Ennek a végrehajtása folyik egészen addig, amíg jön egy jelzés, hogy befejeződött az I/O, pl. winchester jelez, hogy lehet olvasni, küldi az adatokat. Ez a jelzés megszakítás formájában jelenik meg, ennek eredményeképpen az új folyamat megszakad, a vezérlés visszakerül az eredeti folyamatra, ahol elvégzésre kerül az I/O folyamat befejezése, lekezelése. Billentyűzet példája

Működés: Fut egy program a számítógépen ami a billentyűzet leütésére vár, és folyamatosan kérdezi le a billentyűzetet, hogy történt e leütés. Ha leütünk egy billentyűt, pl. ESC-et, a billentyűzetben lévő processzor jelzi ezt a tényt a CPU-nak. Ez egy megszakítás vezérlő áramkörön keresztül történik, ami fogadja ezeket a hardver jelzéseket, lekezeli, és továbbítja megfelelő módon a CPU-nak. Tehát a billentyű leütése egy jelzést generált a CPU felé, amit az tudomásul vesz és várja a további adatot. Ezek után a billentyű processzor átküldi a SCAN kódot, a billentyű sorszámát. ESC-nél 1. Ezután a CPU ténylegesen beolvassa ezt a billentyű kódot, majd beteszi egy billentyűzet pufferbe, egy FIFO tárba. Ide már az ASCII kódja kerül be a billentyűnek. A konverziót az „IT vezérlő, BIOS” végzi. Jelen esetben az ESC megfelelő ASCII kódja az 1B lesz. Ezt követően a program folyamatosan olvassa ezt a puffert és kiolvassa az ASCII kódot. A pufferes működés DOS ablakon keresztül a felhasználó számára is érzékelhető, sípolással jelzi, ha sokáig nyomunk egy billentyűt, ilyenkor megtelik a puffer (Kb. 16 byte nagyságrendű). A megszakítást itt a billentyűzet leütése jelenti. Amikor a felhasználó leüt egy billentyűt a billentyűzet processzora jelzést küld a CPU megszakítás vezérlőjének.

2. oldal


Másik folyamat és billentyűzet példája összefoglalva

Fut egy aktuális program. Futás közben történik egy váratlan esemény (processzor szempontjából nem tudjuk hogy mikor), egy megszakítás. Ekkor megszakad az aktuális program és egy másik szinten elindul egy kiszolgáló rutin – elvégzi a megszakítás kiszolgálását, megszünteti a megszakítás okát. Ha ez befejeződik visszatér az aktuális programhoz.

Megszakítások, események csoportosítása: •

Szinkron: A program futása során meghatározható helyen és időben történnek, szinkronban vannak a program futásával. Az események reprodukálhatók. Általában szoftverrel kapcsolatos események. Pl: o 0-val való osztás o Aritmetikai túlcsordulás (adott ábrázolási tartományban, melyet biztosít az adattípus nem férünk el.) o Illegális gépikód – olyan adatterületről olvasunk be adatot ami nem értelmezhető. Pl.: Ha egy program futása végén nem adja vissza a vezérlést az operációs rendszernek, így az nem talál a memóriában végrehajtható utasítást. o Laphiba – a CPU a fizikai memóriát kiterjeszti egy winchesteren levő háttértárra, és a kettő ad együtt egy virtuális címtartományt. Ennek mindig csak egy részét tarja a memóriában. Ha olyan részre hivatkozik ami nincs a memóriában azt be kell olvasni a háttértárról. Amikor ilyen van, azt hívják laphibának. o Tömb index – Intel processzoroknál meg lehet nézni, hogy egy adott index egy adott tartományban van e. Ha nem akkor egy megszakításkérés keletkezik.

•

Aszinkron: az esemény időpontja nem ismert, nincs szinkronban a programmal. o Várható – tudom, hogy be fog következni adatátvitel, DMA soros port – Billentyűzethez hasonló a működése. Amikor a soros portra érkezik az adat, generál egy megszakítást és beteszi egy puffer tárba, amit a program folyamatosan olvas.

3. oldal


o Nem várható Memória paritás – hiba jelzésre szolgál, páratlan számú hibát jelez HDD hiba Megszakítási okok prioritási sorendben: 1. Géphibák – azonnal le kell kezelni: • Jellemzően HW hibák • Az egyes eszközök maguk ismerik fel a hibákat valamilyen hibajelző (pl. paritás) vagy hibajavító kóddal. - CPU regiszterei - Operatív tár - OPT - Adatátvitel • Energiaellátás • Klimatizációs hiba (hűtés) 2. I/O források: Perifériák megszakítás kérése (CPU-n belüli) Pl.: Nyomtató CPU átvitel igény nyomtató CPU megszakítás nyomtató CPU adatátvitel nyomtató CPU jelez a nyomtatónak, hogy szeretne nyomtatni. A nyomtató amikor tud nyomtani, megszakítást küld a CPU-nak hogy jöhet a megfelelő adat. Végül a CPU átküldi a megfelelő adatot a nyomtatónak. Ilyen esetekben a megszakítás sebességbeli különbségekből eredő problémákra is megoldást jelent. 3. Külső források: Külső eszközök által generált megszakítások. • Pl.: hálózati kommunikáció 4. Programozói források: utasítás végrehajtásakor • Szándékos – rendszerhívás. Az operációs rendszer funkcióit, vagy a BIOS funkciókat rendszerhívásokon keresztül lehet elérni, ezek is megszakítási mechanizmuson keresztül működnek. • Hiba - Memóriavédelem megsértése: Minden program, ami betöltődik, saját memória címteret kap, ami védve van a többi programtól. Ha egy alkalmazás olyan címtérre szeretne hivatkozni, ami nem hozzá tartozik akkor ilyen hiba keletkezik. - Tényleges tárkapacitás túlcímzése - Címzési előírások megsértése: Egyes esetekben meg van határozva, hogy bizonyos adatok címhatárai illeszkedjenek e 2, 4, 8… -al osztható címhatárra. Pl. C nyelvekben lehet ezt megmondani hogy egy adatstruktúra milyen címhatárokra illeszkedjen. Ennek előnye hogy a processzor az adott címhatárra illeszkedő memória részeket gyorsabban elérhet a memóriából. Abban az esetben, ha valamilyen előírás van, hogy az utasítások pl. 4 bytos címem kezdődhetnek és a processzor egy páratlan

4. oldal


-

címre szeretne hivatkozni, ott szeretne utasítást végrehajtani, akkor ebből hiba keletkezik. Aritmetiaki, logikai műveletek

Megszakítások csoportosítása • Szinkron/aszinkron • Utasítások végrehajtása között (az előző utasítás eredményeképpen) vagy közben (külső) történő megszakítások. Amikor a processzor végrehajt egy utasítást beolvassa a műveleti kódot, értelmezi azt, beolvassa az operandusokat. Ezután jön a végrehajtás fázisa. Miután végrehajtotta az utasítást megvizsgálja hogy jött e valamilyen megszakítás kérés. Ezek a kérések bekerülnek egy regiszterbe, a processzor itt vizsgálja meg. Előfordulhat olyan is hogy a végrehajtás közben is megtudja vizsgálni. Pl.: DEC/VAX architektúra esetében volt egy „move” utasítás, ami sok adatot tudott mozgatni. Mivel ez sokáig tartott, ezért az utasítás végrehajtása közben is megvizsgálták, hogy jött e megszakítás • Felhasználó által explicit módon kért (rendszerhívások) ill. nem kért (magától jön) megszakítások • A megszakított program folyatódik, vagy befejeződik (HW hiba) Normális esetben folytatódik. Hiba esetén befejeződik. • Felhasználó által maszkolható (letiltható) vagy nem maszkolható megszakítások A megszakítás folyamata

Az utasítások végrehajtása után a processzor megvizsgálja, hogy jött e megszakítás. Ha nem jött folytatja a következő utasítást. Ha jött, meg kell vizsgálni, hogy elfogadható e. Ha igen következik az analízis. Meg kell nézni, mi okozta a megszakítást, és mik azok a feltételek, hogy ki lehessen szolgálni. Ezután következik az állapot mentése. Célja hogy a megszakított

5. oldal


programhoz vissza lehessen térni. Ezt követi a kiszolgálás, a megszakítás okának a megszüntetése. Végül az állapot visszaállítása és a visszatérés. A megszakítás folyamatának részletezése 1. Elfogadható- e a megszakítás? A processzoroknak van egy INTR (Interrupt Request) bemenete. Ha jön egy megszakítás ez a bemenet aktívvá válik. Ebből a processzornak 1 db van. Egy megszakítás bemeneten nehezen tudna megkülönböztetni több megszakítást. Ezért van egy megszakítás áramkör melyre a különböző hardver eszközök vannak kötve. Ez van rákötve a processzor interrupt bementére. A megszakítás akkor jut érvényre, ha: • Megszakítható a megszakítás vagy az aktuális program. Pl. egy mentés folyamata nem megszakítható. • Prioritás – Megfelelő a prioritás nagysága. • Maszkolás – ez a megszakítás nincs letiltva. Ha a megszakítás el lett fogadva a CPU az INTACK (Interrupt Acknowledge) kimenetén keresztül jelzi a megszakításvezérlőnek ezt a tényt. Prioritások Egyszerre több megszakítás érkezik. Melyik a fontosabb? Prioritás kezelése: • Prioritás nélküli: a beérkezés sorrendjében kezelem le a megszakításokat. Hátránya: időérzékeny megszakítások nem megfelelő kezelése (pl. a soros portra érkező adatot azonnal fogadni kell, különben adatvesztés) • Prioritásos: sorrendet rendelünk a megszakításokhoz Prioritás hozzárendelése • Fix prioritás – nem lehet módisítani a prioritást amit a megszakításokhoz rendeltünk. Hátránya: lehet, hogy egy kisebb prioritással rendelkező megszakítás soha nem kerül kiszolgálásra. •

Körbeforgó prioritás – több eszköz rendelkezik azonos prioritással, azonos prioritások esetén az elsőnek kiszolgált megszakítás a prioritási sor végére kerül. Különböző szintek vannak, a szinten belül a beérkezés sorrendjében történik a kiszolgálás.

A B C

először a C hajtódik végre, utána az ilyen típusúnak lesz a legkisebb a prioritása (de csak az azonos prioritásúak között)

Azonos prioritás

6. oldal


• Speciális maszk (bizonyos programokat le lehet tiltani) Maszkolás

Működési elve: Megszakítási flag regiszter: 4 db megszakítási bemenetet tud kezelni. A megszakítások bármelyik pillanatban jöhetnek, de a processzor nem tud rájuk rögtön válaszolni. A CPU bizonyos időnként vizsgálja meg hogy jött e megszakítás. A megszakításokat ezért el kell tárolni. Ha jön egy megszakításkérés az bebillent egy bitet a megfelelő helyen, hogy onnan jött egy megszakítás. Erre szolgál ez a flag regiszter. A CPU ezt foglya megvizsgálni, és tudni fogja honnan jött a megszakítás. Maszk regiszter: ezzel lehet szabályozni, hogy melyik az a megszakítás, amelyik érvényre juthat. Pl. ha jön a 3-as megszakítás és ha a maszk regiszternek a 3dik bitje 0, akkor az le lesz tiltva. Jelen pillanatban a maszk regiszter 0-ás és 1-es bitjében 1-es áll, így csak ezek a megszakítások juthatnak érvényre. Bal oldalt lehet látni, hogy az aktuális folyamatnak a prioritása 2-es. Jön két megszakítás, a 0-s és a 2-es. A 2-es le van tiltva, ezzel szemben a 0-ás érvényre juthat, mert a maszk regiszterben engedélyezve van. Ennek a prioritása 0-ás lesz, fontosabb. Érkezik egy jel a megszakítás ellenőrzésére (bal oldalt 1-es). Először összeveti, hogy ez a megszakítás le van e maszkolva vagy nincs. Következő lépésben megnézi hogy a prioritása milyen viszonyban van az aktuális folyamat prioritásával. Minek után a prioritása magasabb, ezért a megszakítást el lehet fogadni. Megjön jobb oldalon, hogy az elfogadott prioritás 0, és az 1 engedély, a parancs a megszakításra.

7. oldal


2. Megszakítás analízis Szerepe a megszakítást kérő egység azonosítása. ahhoz a megszakításhoz tartozik.

Azt a rutint tudjam elindítani ami

Módszerei: o Lekérdezéses Hardveres megoldás: hw elemek elhelyezkedése a döntő. Pl. amelyik közelebb fekszik a CPU-hoz annak lesz nagyobb prioritása, azt szolgálja ki előbb. Szoftveres megoldás: sw polling. Ha jön egy megszakításkérés, lekérdezi az egyes elemeket, hogy ki kérte a megszakítást. Az egységek lekérdezésének sorrendjét a szoftver algoritmusa határozza meg. o Vektoros : A megszakítás vezérlő egység egy azonosító kódot küld be a CPU-nak, ami alapján az el tudja dönteni hogy mi az a rutin amit el kell indítania. Rutin címe Azonosítókód Daisy chain (HW)

INTR: megszakításkérő INTACK: megszakítás nyugtázó. U1-Un: egységek A CPU-hoz nem csatlakozik az adatbusz!!!!!!!(hibás az ábra) Alap állapotban minden kimenet 0. Az U1-es egység megszakítást kér, ez az 1 megjelenik az INTR bemenetén a CPU-nak. Eldönti az előbbiek alapján hogy érvényre juthat e a megszakítás. Ha engedélyezi, az INTACK kimenetén kiadja az 1 engedélyező jelet. Ez az 1 átfolyik az U0-ás egységen, mivel az nem kért megszakítást ezért átengedi. Az U1 így megkapja az engedélyező jelet és elkezdi a megszakítást kiszolgálni. Eközben az U0-ás egység is kér egy megszakítást, megjelenik az 1 a CPU INTR bemenetén. A CPU engedélyezi a megszakítást és kiadja ismét az 1-et a kimenetén. Ekkor az U0-ás egység már nem engedi tovább a nyugtázó jelet, átváltja 0ra. Ennek következtében az U1-es egységnek megszakad a feldolgozási folyamata, a megszakítás kezelése. 8. oldal


Vektoros

Cím 4 bájt: 0. Vektor -> 0 x 4 bájt = 0 1. Vektor -> 1 x 4 bájt = 4 2. Vektor -> 2 x 4 bájt = 8 . . n. Vektor -> n x 4 bájt = n x 4 Feladat, hogy a megszakítást kérő egységhez hozzá lehessen kapcsolni azt a rutint, ami a kezeléséhez szükséges. Minden esetben egy kódot küld be a CPU-nak. Intel processzorok esetbén megszakítási vektort, ami egy sorszám és a megszakítást kezelő rutinra utal. Jelen esetünkben van egy táblázat, melyben a 004-es megszakítási vektorhoz tartozik egy rutin, melynek a címe 350. Tehát az 1-es megszakítási vektorhoz - amit beküld a megszakítási egység - tartozik az 1-es rutin melynek a címe hozzá van rendelve a sorszámhoz. A beolvasott vektor kicímzi a megfelelő rutinnak a címét, ami bekerül az utasítás számlálóba és így végre hajtódik a hozzá tartozó rutin. 3. Mentés Megszakított program állapotának mentése. o El kell menteni annak a programnak az állapotát ami megszakítottunk. PSW – Program Status Word Legfontosabb az utasítás számláló (PC). Menteni kell az állapot flageket, és a regiszter tömböt. Legtöbb esetben ezeknek az adatoknak az elmentéséről nem kell gondoskodnunk, sok esetben maga az assembly utasítás elmenti. Pl. call utasítás esetén PC Ha megszakítás kezelő utasítás történik a flagek is elmentődnek. A regiszterek mentéséről nekem kell gondoskodni. 9. oldal


o Az operatív tárba kell menteni. o Stackbe, veremszerűen kell elmenteni.

Fut az 1-es alkalmazás, jön egy megszakítás. Mielőtt elkezdeném a 2.dik alkalmazás végrehajtását előtte el kell végezni a mentést. Ha megint jön egy megszakítás a 2-es állapotát kell elmentenem. Tehát elmentettem az 1-est, rátettem a 2-est. Ha visszatérek a 3-as alkalmazásból először a 2-es állapotát, majd pedig az 1-est kell kivenni.

PSW0, PSW1, PSW2 megszakítási állapotok érkezési sorrendben bekerülnek a stackbe. Kiolvasásuk PSW2, PSW1, PSW0 sorrendben történik. A stack kezelése stack pointerrel, mutatóval történik. Ez fogja megmondani, hogy éppen hol tart a stack. Tipikusan fentről lefele, a magasabb címtől csökken a stack pointer. Stack törlésénél a pointert állítom. gyors, nem igényel adatmozgást, nem törli a stacket, ott marad az eredeti adat (hibás működés esetén is megtévesztő jó eredmény)

10. oldal


A Stacket használják: o Állapot mentésre o Paraméterek átadása o Lokális változók tárolása. Pl. alább.

Van két két bájtos int változónk, melyekkel meghívunk egy f függvényt. Először átadásra kerülnek a paraméterek a hívott helyről a függvénynek. Paraméterek átadása a stacken keresztül történik – bekerülnek a paraméterek. Intelnél több bájtos integerek úgy tárolódnak el, hogy az adat alacsonyabb helyiértéke az alacsonyabb címre kerül. 136-os részre kerül a 44, ami az alsó része az integernek (1). Ezután elmentésre kerül az utasítás számálló értéke. Ezt a call utasítás hajtsa végre, átadja a vezérlést a függvénynek, de előtte elmenti a PC értékét (2). Ezután el kell menteni a regiszterek értékeit (3). A megszakított program állapotát el kell menteni. Jelen esetben van egy programom és meghívok egy másik függvényt. Ahoz hogy vissza tudjak térni a függvényből a meghívó programba, el kell menteni annak az állapotát. Ebben az esetben ez az utasítás számlálót jelenti, valamint a regisztereket. Ezt a mentést az „f” függvény végzi. Azért kell elmeneti a megszakított program állapotát, mert ezeket a regiszter tömböket a függvény ugyan úgy fogja használni. Következő lépésben a függvényen belül létrehozunk 2 változót. Egy 2 bájtos int típusút, és egy karakter tömböt, ami 4 bájtos. Ezeknek a tárolása is a stackben történik. (4) A stackben a 136, 134 a paraméter átadás, a következő 5 a PSW, az állapota, alatta pedig a lokális változók találhatók. ---Érték szerinti paraméter átadás: a paraméternek egy másolatát adom át a függvénynek. Jelen esetben az x, y-nak egy másolata került be a stackbe. Ez miatt az „f” függvény nem tud visszahatni az eredeti x, y-ra.-----Hiba lehetőség: 4 bájtos tömbe 6 bájtos adatot másolunk be. Ezt pl. C++-ban senki nem fogja látni. 0-tól elkezdi írni a tömböt, és felül írhat további helyen lévő változókat. A függvényen belül meghívunk egy másik függvényt, „q”-t. Ismét bekerülnek a stackbe a PSW-k (114-től 106-ig.) (5).

11. oldal


4. Kiszolgálás Megszakítás okának megszüntetése, a megszakítás tényleges kiszolgálása. Pl.: o Billentyű kód beolvasása o Nyomtatónak az adatok kiküldése o Adatok olvasása HDD-ről 5. Visszaállítás, visszatérés Megszakított program állapotának visszaállítása, visszatérés a megszakított programhoz.

Amikor a 3dik alkalmazásból visszatérek, vissza kell állítani a 2dik alkalmazásnak az állapotát, végül az első alkalmazás állapotát.

Megszakítási rendszer szintek szerint • •

Egyszintű – egyszerű, nem nagyon használják. Többszintű

Egyszintű

12. oldal


Két szint van. A normál és a megszakítási szint. 3 prioritás – 0,1,2. Legmagasabb a 0-s. Jelen esetben fut a program a normál szinten, majd jön egy 1-es, 2-es szintű megszakítás. A megszakítási rendszer eldönti melyik a magasabb prioritású, és azt engedi érvényre jutni – 1-est. Közben jön egy 0-s prioritású – fontosabb, mint ami éppen fut. Azonban mivel két szint van ezért az 1-est nem tudja megszakítani. Befejeződik az 1-es kiszolgálása, majd a megszakítási rendszer kiértékeli milyen megszakítások várnak, 0-ás, és 2-es, itt jut szóhoz a 0-s. A 2-es csak a végén kerül lekezelésre. A probléma, hogy a 0-s megszakítás nem jut szóhoz azonnal, hiába magasabb a prioritása. Tw időt kell várnia, mivel az 1-es megszakítást kiszolgáló utasításokat nem tudja megszakítani. Többszintű

Több prioritás és több szint van. Jön egy 1-es, 2-es megszakítás, elkezdődik az 1-es kiszolgálása. Jön a 0-ás szintű megszakítás, ami megszakítja az 1-es szintűt. Amikor befejeződik, akkor folytatódik az 1-es megszakítás kiszolgálása. Ennek végeztével következik a 2-es lekezelése. Valóságban sokkal több megszakítás van. Ezzel a szisztémával akkor tudnánk őket lekezelni, ha annyi szint lenne, ahány megszakítás. drága. Többszintű, több vonalú

13. oldal


Vannak prioritások, osztályok, az osztályokon belül alprioritások. Jön egy 1/a, 2/a, 2/b megszakítás, ebben az esetben az 1-es fog szóhoz jutni. Közben jön egy 0/a, ami magasabb, ez megszakítja 1/a-t. Befejeződik a kiszolgálása 0/a-nak. Jön az 1/b ami szinten belül van 1/a-val. Ő nem tudja megszakítani 1/a-t, így csak akkor jut szóhoz, ha az befejeződött. Ezután jön az 1/b. Ha ez is befejeződik akkor jut szóhoz a 2/a és 2/b. Maga a szisztéma egy több szintű megszakítás, de szinteken belül úgy viselkedik, mint egy egyszintű. INTEL (Pentium) processzorok megszakítási rendszere Amikor beszélünk valamiről, használunk egyfajta terminológiát. Amikor egy konkrét processzort nézünk, a processzor gyártója egy másik terminológiát használ, másképp hív dolgokat. Pl.: PC (Program Counter) IP (Instruction Counter) [következő utasítás címét mutatja] Megszakítások csoportosítása: • Megszakítás (Interrupt) • Eltérülés (Exception) Megszakítások Megszakításokat processzoron kívüli aszinkron események váltanak ki. A processzornak 2 megszakítás kezelő bemenete van + egy áramkör ami fogadja a többi megszakítást. Bemenetek: • Maszkolható – Letiltható, nem minden esetben jut érvényre. (INTR) Kezelésére az IF flag használható közvetlenül. Assembly utasításból a Clear interrupt és a Set interrupt utasításokkal lehet beállítani az értékét. (CLI, STI) Folyamata: Megszakítás kérés érkezik az INTR bementeten. INTA kimeneten ezt nyugtázza a processzor Beolvassa azt a vektort, ami azonosítja a megszakítás kérő egységet Ez táblázat alapján meghatározza annak a rutinnak a címét, ami a megszakítást kiszolgálja. • Ha valós üzembe működik a processzor akkor ez 4 bájt • Ha védett üzemmódban akkor 8 bájtos, deszkriptor tábla a neve. • Nem maszkolható, NMI (Non Maskable Interrupt) – Minden esetben érvényre jut. A folyamat ua. mint a maszkolhatónál, kivéve hogy nincs nyugtázás, mivel mindig érvényre jut. Ezeket a megszakításokat szoftverből is lehet aktivizálni. Az operációs rendszer szolgáltatásait is el lehet érni megszakításokon keresztül. Ezek a rendszerhívások. INT utasítás, majd az utasítás sorszáma. Amikor sub rutin hívás történik arra a call utasítás szolgál. Ez elmenti az utasítás számláló értékét, és betölti a PC-be azt a címet ahova ugornia kell. Ennek a párja a IRET, amivel vissza lehet térni a hívás helyére. A stackből az utolsó 2, vagy 4 bájtot (processzortól függ) kiolvassa és betölti az utasítás számlálóba. Megszakításnál a flagek is elmentődnek. Az IRET a flagaket is kiveszi a stackből. (INT x –IRET: PC+flag!) 14. oldal


Problémák: • A stackben felül írható a cím, nincs kitüntetve. • Az IRET nem tudja, hogy mit kell betölteni, azt tölti be ahova a stack pointer mutat. Ez akkor baj, ha el van csúszva a stack. Rosszat fog betölteni. Pl.: Beágyozott ciklusok esetén a ciklus változó értékét elmenthetjük a stackbe. Figyelni kell a ciklusból való visszatérésnél, hogy a behelyezett értéket vegyük ki, különben elcsúszik a stack pointer és a program hibásan fog működni. Eltérülés Processzor működésével szinkron események. Processzoron belüli események. Fajtái: • Processzor által felismert esemény o Hibák (faults) o Csapdák (traps) - egyik utasítás végrehajtás közben, másik utasítás végrehajtás után fordul elő o Végzetes hiba (aborts) – A processzor nem tud mit kezdeni a hibával, nem tudja felismerni. Tipikusan akkor fordul elő, ha olyan sérül meg a rendszerben, ami az ő adminisztrációjához kell. Pl. rendszer leíró tábla. • Programozott eltérülések o SW megszakítások (INT x) Néhány konkrétum: Minden megszakításhoz és egy kivételhez azonosító van rendelve. 256 ilyen létezik. Első sorszáma 0, utolsóé 255. Az első 32 az NMI, nem maszkolható megszakítások és a kivételek. • • • •

• •

• • • •

0: osztási hiba 1: debug kivétel – ha engedélyezve van, a processzor minden assembly utasítás után meghív egy megszakítást. hibakeresés, a program lépésenként hajtható végre. 2: NMI (hw hiba) – pl. memória hiba. 3: töréspont (1byte!)– debugolásnál fontos hogy lépésenként tudom végrehajtani a programot, valamint hogy az elhelyezett töréspontig fut. Ha kijelölök a forráskodban egy sort, egy utasítást, akkor oda betesz egy olyan utasítást, amire ha ráfut a vezérlés, a debugger fogja megkapni a vezérlést. Az első utasítást kicseréli egy interrupt hívással, ami ezt hívja meg. Betesz egy INT3-at, ami ezt a megszakítást hívja meg és visszakerül a debuggerhez a vezérlés. Fontos hogy 1 bytos legyen, hogy bármilyen utasítás helyére be lehessen tenni. 4: túlcsordulás (overflow) 5: index túllépés (BOUND index, határ) meg kell adni egy index értéket, és egy memória terület címet, ahol az alsó, felső határ el van tárolva, leellenőrzi a processzor hogy az alsó felső határ közé beesik-e az index értéke, ha nem akkor az 5-ös megszakítást generálja. 6: nem megengedett utasítás – nincs minden kombináció lefedve 13: általános védelmi hiba - Pl.: több alkalmazás fut egyszerre, mindegyik virtuális memóriát kap. Ha abból ki akar nyúlni egy olyan memória területre ami nincs hozzá rendelve, akkor tipikusan ilyen hiba keletkezhet. (Win9x) 14: laphiba 17: illeszkedés (operandus ellenörzés) – ha az operandus nem illeszkedik valamilyen határra (2, 4 bájt), akkor egy megszakítás generálódik. 15. oldal


•

32-255 HW függő maszkolható megszakítások (más operációs környezetben más értékek lehetnek) o IRQ1 - billentyűzet o IRQ4 – infra port o IRQ5 – SD kártya o IRQ11 – rádiós kártya o IRQ12 – egér

16. oldal


Címzési módok A címzési mód az az út (algoritmus), ahogyan az operandus címét meghatározzuk

Minden utasítás 2 részből áll. MK – műveleti kód, valamint egy olyan rész, ami meghatározza az operandust. Az MK mondja meg mit kell csinálni, a második rész pedig hogy mivel. Itt lehet több operandus is. Címzési módok

címmegadás

címmódosítás

címértelmezés

Címértelmezés A műveleti kód után szerepelhet: • Adat o Közvetlen adat megadás o Rejtett címzés • Cím o Közvetlen címzés o Közvetett címzés • Valós/virtuális cím Közvetlen (immediate) adat megadás

MK és utána következik maga az adat a gépi kódú utasításban. Pl.: MOV AL,28H egy tárterületre betölti a 28-at. Ez a tárterület az AL regiszter. Ennek 2 operandusa van, egy forrás, a 28 hexa, és van egy cél, ami jelen esetben egy regiszter. Ez egy két bájtos utasítás. Az első tartalmazza a műveleti kódot, illetve az arra vonatkozó információt, hogy ez az AL regiszter (regiszter sorszámát tartalmazza). A második bájtban pedig benne van a hexa 28.

17. oldal


Rejtett (inherent), vagy implicit címzés

Maga az utasítás 1 bájtos. Az adat nincs benne az utasításba, a műveleti kód utal rá, határozza meg, mire vonatkozik. A példában a CLI egy 1 bájtos utasítás (törli az interrupt reget). 0-át tölt egy memória helyre. Van neki forrás operandusa a 0, cél operandusa, hogy hova tölti, ami jelen esetben a flag regiszter egy bitje. De egyikre sincs utalás, nem találom meg közvetlenül a 0-át az utasításban, mert indirekt módon a műveleti kód az ami ezt megadja nekem. Közvetlen (direkt) címzés

A műveleti kód után egy cím található, ami megcímzi az operandust. Jelen esetben a 106os címen lévő operandust, a 33-at töltjük be az AL regiszterbe.

18. oldal


Közvetett (indirekt) címzés

Az a cím, ami az utasításban van nem az adat címe, az adat címének a címe. Jelen esetben az utasításban egy regiszter található. A regiszterben van egy cím, ami tartalmazza az adat címét. Maga az utasításban a regiszternek a címe van benne. Amiben benne van annak a címe, ahol az adat van. Itt van benne a közvetettség. Ezt regiszter indirekt címzésnek is mondják, mert regisztert használunk fel az indirekcióra. Címmegadás Lehet: • Abszolút • Rövidített (relatív) o Lapcímes o Bázisregiszteres Abszolút

A műveleti kód után található egy cím, amivel a teljes tárat meg tudom címezni, olyan hosszú hogy a teljes logikai tár címezhető. Előnye: címezhető a teljes tár. Hátránya: Egyrészt nagy, sok helyet foglal el az utasításból. Egy utasításnál nem probléma, több ezernél már igen. Lassú A processzor beolvassa a műveleti kódot, majd 19. oldal


az operandust. Nem mindegy hogy az operandus eléréséhez szükséges cím 1, 4, vagy 8 bájt, mivel annyival többször fordul a memóriához (egyik esetben 1xer, másik esetben 4xer). Programozásnál akkor használjuk, ha valami olyasmit szeretnék elérni, ami nem a program környezetében van. Olyan külső objektumot, közös használatú rutint, ami nem közvetlen az én programomban van. Ha van egy külső dll-m, és abból meghívok valamit, szinte biztos, hogy 1 bájttal nem fogom tudni megcímezni. Rövidített vagy relatív címzés

A műveleti kód után a címrész nem egy teljes cím, hanem egy cím töredék, tehát önmagában nem tudom megcímezni a teljes tárat. Displacementnek, vagy offsetnek is szokták hívni D jelölés. Itt a címzés mindig valamihez képest történik. Egy bázishoz adódik hozzá a cím töredék, ami az MK után található. A Cím (D) hozzá adódik a bázishoz és úgy címzi meg a 106-ot, a bázis pedig a 102-be mutat a címrész jelen esetben 4-et tartalmaz. Jellemzői: • Nem tudom megcímezni a teljes tárat, csak a bázis környékét. • Kisebb a mérete, ezáltal gyorsabbak is ezek az utasítások • Gyakran használják ezt a címzési módot. Adott környezetbe hajtjuk végre a programot, nem ugrálunk „messzire”. Két típusa: • Lapcímes: A tárat lapokra osztjuk, melyek egyforma méretűek. A címrész két részből áll, magából a bázisból és eltolásból. Ebben a konstrukcióban a bázist lapcímnek hívjuk, megadja a lapnak a címét, és a lapon belüli címet adja meg az eltolás. Minek után a cím (D) egy lapon belüli címet ad meg, ezért egy pozitív egész szám. A bázis a PC valamelyik magasabb helyiértékű része, ezt futólaposnak hívják. Ha a bázis (lapcím) 0 ebben az esetben egy 0 lapos címzésről beszélünk. Két memória területet tudok használni: az operatív tárat, és a regisztereket. A regiszterből kevesebb van, mint az operatív tárból, viszont gyorsabbak. A 0 lapos kicsit a kettő között van, ezzel defaultként a memória alsó 256 bájtját éri el a processzor meglehetősen gyorsan, gyorsabban mint egy memória címzés, mert rövidebb a címrész, de lassabban mint a regisztereket. 20. oldal


•

Bázisregiszteres: A bázishoz hozzáadnak egy előjeles számot. Intelnél és régebben a Motorola processzoroknál használták.

Címmódosítás Az előállt címet módosítjuk valamilyen módon. Erre legkézenfekvőbb az indexelés: egymás utáni azonos típusú adatok (tömb) címzésére szolgál. MOV AL, CÍM [SI] Automatikus módosítása: Lehet: • Növelés - Autoinkrementálás • Csökkentés – Autodekrementálás • Címzés előtt (pre) – először növeli az indexet és utána címzi meg az operandust • Címzés után (post) – előbb címzi meg az operandust és utána változtatja meg az indexet. Pl. van egy regiszterem, melyben van egy cím, értéke 5. Ha pre autoinkrementálás történik, akkor először inkrementálom, lesz 6 és onnan veszem ki az adatot. Post esetén az 5-ösről kiveszem az adatot és utána növelem az értékét és úgy lesz 6. Valós cím meghatározásnak tervezési tere !!!!!

Rejtett címzés pl. azért nem szerepel, mert ott nem cím van, hanem adat!! Címzésnél van a cím megadás, ezzel megmondom hogy az egy abszolút cím vagy egy relatív cím. A relatív címnél a bázis lehet regiszter, PC, TOS – Top of Stack (akár a stack pointer is), Yi index regiszter. Vizsgán önmagában kevés, kell az egyes levelek jelentése is. (lásd fentebb)

21. oldal


INTEL (16/32) processzorok architektúrája Programozható regiszterek: programozó által használható regiszterek. Csoportjai: • Általános regiszterek • Szegmens regiszterek • Státusz és vezérlő regiszterek Általános regiszterek

4 általános célú regiszter van, ezeknek a hossza maximum 32 bit - processzortól függ. 32 bites processzoroknál működnek az „E”-sek. Az AX regiszterre hivatkozhatok magában ahogy van, ilyenkor az AH és AL együtt adják a 16 bitet. Ennek a felső részét el tudom érni AH-ként, az alsó 8 bitet AL-ként, az egész 32-őt EAX-ként. Mindennek az oka a kompatibilitás megőrzése. Az AX a 16 bites processzoroknál van. Előtte a 8 biteseknél AH és AL volt. Az Intel mindig nagyon figyelt, hogy kompatibilis legyen visszafelé a processzor. Ami fut egy öreg processzoron, annak az új processzoron is kell futnia. Ennek előnye hogy kompatibilisek a processzorok, hátránya hogy megkötést jelent, szabályok keretek közé van szorítva a fejlesztés, figyelembe kell venni a múltat. Annak ellenére hogy ezek általános célú regiszterek, mindegyiknek van valamilyen speciális funkciója, amit csak az a regiszter képes végrehajtani. AX, EAX szorzás, osztásnál az operandus tárolására alkalmas. Régebbi architektúrákban volt egy akkumulátor regiszter. Minden aritmetikai műveletben benne volt. Ehhez lehetett hozzá adni, ebből lehetett kivonni. DX, EDX ez a párja szorzás-osztásnál (AX-DX, EAX-EDX). Ha két 32 bites számot összeszorzok az eredmény kétszer akkora lehet. A DX regiszter használható továbbá a perifériák indirekt címzésére. A periféria cím kerül be a DX regiszterbe. CX, ECX ciklusváltozó. Ha szeretném hogy egy utasítás (pl. egy adatmozgató) többször végrehajtódjon, akkor az utasítás elé egy prefix-et kell tenni, ami hatására az utasítás annyiszor végrehajtódik, ami a CX-be be van állítva. (Egy-két kitüntetett utasításra működik). A CX CL részét még léptetésnél lehetett használni. BX, EBX 16 bites processzornál címzésre csak a BX-et lehetett használni, az előző hármat nem. 32 bitesnél mind a 4-et lehet használni címzésre. 22. oldal


DI, EDI, SI, ESI index regiszterek, címzésre használhatók. + általános szerepek. Kitüntetett szerep: string műveletek. Van egy memória területem, ahonnan át akarok 1000 bájtot mozgatni egy másik memória területre. Ebben az esetben erre ezt a két regisztert lehet használni. SI-vel megcímzem a forrást, DI-vel pedig a cél memória területet. SP, ESP Stack pointer, kizárólag csak a stack használatára használják. Nagyon ritkán használják közvetlenül. PUSH és POP utasítások változtatják a stack pointer értékét. BP, EBP bázis pointer, speciális funkciója van. A stackben lévő paraméterek, változók megcímzésére használjuk a BP-t. Minden egyes címzésnél a címrész két részből áll. Egy relatív címből vagy offset címből, valamint áll egy szegmens címből. Amikor címzek valamit ahhoz az utasításhoz hozzá van rendelve egy szegmens regiszter alapértelmezésként. A BP-hez a stack szegmens van hozzá rendelve.

Szegmens regiszterek

Egy program tipikusan 2 részből áll. Egy kódrészből, ahol a program kód található, és egy adatrészből ahol a programnak az adatai vannak. Maga az adatrész szinte mindig 2 részből áll. Van egy dinamikus rész, ez a stack-et (pl. lokális változók) jelenti, és van egy statikus rész.(külső változók, static változók). Ezek egy idejű kezelésére szegmens regisztereket használnak, amik az egyes részek kezelésére alkalmasak. Pl. a CS a kód megcímzésére szolgál, az SS a stack-et, a többi 4 az adatszegmenseket címzi. Ezek a regiszterek mind a 16 és 32 bites processzoroknál 16 bitesek, a nevük is ugyan az. A funkciójuk és a használatuk eltérő, a processzor valós és védett módjában más-más jelentéssel bírnak ezek a regiszterek.

23. oldal


Státusz és vezérlő regiszterek

IP, EIP utasítás számláló, Instruction Pointer. A Flag regiszterekben találhatók azok az állapotjelző flagek, melyek legtöbbjének értéke 1 bit. A bit értéke informál minket valamilyen állapotról. Példák flagekre (szinte minden processzor architektúrájában megtalálhatók): • OF: Overflow, túlcsordulás • SF: előjel. Amikor megnézzük egy regiszternek a tartalmát és elképzeljük binárisan, 2-es komplemens módban ábrázolva, akkor a legmagasabb helyiértékű bitből megállapítható az előjele. Ha negatív akkor 1. Ez a bit kerül bemásolásra ebbe a flagbe. • ZF: zéró. Az eredmény kimeneteléről ad tájékoztatást. Akkor lesz 1, ha az eredmény 0. Ezt a flaget tipikusan az aritmetikai utasítások állítják. • AF: fél átvitel. BCD számok összeadásánál átvitel keletkezik, ez lesz az az átvitel. • PF: paritás (páratlanra egészít ki) • CF: átvitel. A carry átvitel a legmagasabb helyiértékről az átvitelt jelenti. • DF: irány. Vannak string műveletek egyik memória területről átmásolnak valamit egy másik memória területre. Ebben az esetben a regisztereket (ESI, EDI) automatikusan változtatják. A változtatás irányát, hogy növeli vagy csökkenti, azt határozza meg ez a flag. • AC: illeszkedés ellenőrzés. Bizonyos esetekben utasításoknak, operandusoknak valamilyen szóhatárra, címre illeszkedniük kell, ennek az engedélyezésére szolgál. • VM: 1, virtuális 8086. 32 bites processzornak van olyan módja, hogy eljátszik, úgy viselkedik, mint egy 8086-os processzort. Ezt a módot jelzi ez a bit. • IF: megszakítás maszkolása • TF: utasítás után kivétel Példa:

24. oldal


Összeadunk két decimális számot 8 biten. Ehez tartoznak a különböző flagek. Első: Az előjel bit 0. A zérus flag is 0. A carry flag is 0, a legfelső helyiértékről való átvitelt jelenti. Overflow flag is 0. Második: Negatív szám lesz. Kifolytunk a számábrázolási tartományból. A maximum 127 lehetne. Ebben az esetben a kapott eredmény hibás. Az előjel flag 1, zérus, carry 0, az overflow 1et ad. Az OF flag akkor lesz 1, ha a szám előjele nem helyes. Harmadik: Két negatív számot adok össze, az eredmény -136. Binárisan azonban pozitív értéket kapok, és megjelenik a carry. táblázatban CF és OF is 1. Negyedik: 0 lett az eredmény, tehát a zérus flag is 1. Ha az overflow 1, a sign bit hibás. Utasítás forma Lehet: • 16 bites • 32 bites Maga az utasítás 6 bájtos lehet. Azonban az utasítás előtt lehetnek prefix-ek. (Pl. Szegmens átdefiniálása, meg van határozva, hogy adott utasításhoz milyen szegmens tartozik. Ha ez át szeretném definiálni, akkor ide bekerül 1 bájt. Vagy string kezelő utasításoknál, ha azt szeretném, hogy az többször hajtódjon végre mint ahányszor a CXben beállítottam, akkor szintén prefixet kell használni, ezzel bővül az utasítás hossza.). Ezért mondjuk az egyszerűség kedvéért, hogy 8. 16 bites

Első 6 bit az utasítás műveleti kódja. Ez mondja meg mit fog az utasítás tenni. A következő azt mondja meg, hogy az utasítás iránya regiszterből, vagy regiszterbe történik. A W azt mondja meg hogy az utasítás 1 vagy 2 bájtos. Következő a címzési MOD bájt. Az utasítások 3 operandusúak lehetnek. Ezek vagy regiszterben vannak, vagy memóriában. A regiszterben lévő operandust a REG 3 bitje határozza meg, a másik 25. oldal


operandust a MOD és R/M mezők határozzák meg. A következő két bájt vagy egy adat, vagy egy cím. L és a H az alacsony és a magas értéket jelenti. Az alacsonybb címen az adatnak az alacsonyabb helyiértékű címe tárolódik el az Intel processzoroknál. Az utolsó két bájt adat lehet, más nem. A leghosszabb utasítás így, ha egy címrész és egy adatrész van benne. Címzési mód bájt

Az adat átvitelnek két célja és forrása lehet. A memória és a regiszter. 4 eset állhat elő, azonban a 16 bites Intel processzoroknál az utolsó lehetőség nincsen. Az egyik operandus mindenképp egy regiszterben van, a másik vagy regiszterben, vagy memória címen található. D: regiszterbe, vagy regiszterből történik az átvitel. Az irányt jelzi. A táblázatban láthatók a második, címzési MOD bájt tartalmai. (REG, MOD, R/M) Esetek: • Ha D=0 akkor ez egy R M irány lehet. Itt a regisztert a REG mező, a memóriát a MOD R/M mező határozza meg. • Ha D=1 akkor minden fordítva történik. A regiszterbe történik a művelet. A 3 bites REG mező egy regisztert határoz meg, az 5 bites MOD R/M együttesen egy memóriacímzést határoz meg. • Előfordulhat hogy a MOD R/M rész is egy regisztert határoz meg. A MOV AX,BX utasítás az utolsó két sor bármelyike lehet, mivel az egyik esetben az AX-et a REG mező címzi meg (4dik sor), a másik esetben a BX-et címzi meg a REG mező (3dik sor). Ez az iránytól függ. Következménye: ehhez az utasításhoz két különböző gépi kód tartozik. Az eredmény ugyan az, de az utasítások egyes bitjei különböznek.

26. oldal


Baloldalon lehet látni a regiszter mező értékét. Attól függően, hogy mi a regiszter mező és a W bit értéke az egyik operandus ezekben található. Jobb oldali táblázat a másik operandus elérésére szolgál. A jobb oldali oszlop jelenti a regisztert. Ha mind a 2 operandus a regiszterben van, akkor az egyiket ez az oszlop határozza meg. De lehet a másik operandus egy memória címen is, pl. bx+si –t összeadva kapom meg az operandus címét (regiszter indirekt címzés). --- d cím-nél sima direkt címzést használ --Ha D=0, akkor a középső mezővel címzem meg a BX regisztert, aminek az értéke 001. AX-et a MOD és R/M határozza meg. Ha D=1 akkor a középső mezővel az AX regisztert címzem meg, aminek az értéke 000. BX-et a MOD és R/M határozza meg. 32 bites • A műveleti kód rész lehet 2 bájtos is, mivel bővült az utasítás készlet. • A 32 bites tulajdonságából adódik, hogy az adat és a cím is lehet 4 bájtos. • A címzési módot kibővítették a SIB bájttal. Scale, Index, Base. SIB működése:

A 2dik oszlopban lévő regiszterek közül kiválaszt 1-et, azt megszorozza egy skála faktorral, és hozzá adja a 3dik oszlopban található regiszterhez. Használata: veszünk egy tömböt, amiben 4 bájtos adatokat tárolunk. Ebben az esetben ha ki kell címezni a processzornak egy 4 bájtos tömb elemet, akkor először veszi a tömb kezdő címét és azt betölti egy bázis regiszterbe (3dik oszlop). Ezután veszi az indexet (2dik oszlop), majd azt megszorozza a tömb elemének a méretével. Az eredményt hozzá adja a bázishoz. több utasítást jelent. 27. oldal


A szorzás helyett léptetést használ, ellépteti balra az index értékét. Gyakran használják a SIB-et.

Címzési lehetőségek A processzor két módban tud működni: • Védett – ebben nem tud működni a 16 bites processzor, csak a 32 bites • Valós: ebben az esetben a processzor úgy működik, mint egy 16 bites 8086-os processzor. A fizikai cím tartománya 1 MB, 20 bitet tud kezelni. A kérdés hogy 16 biten hogy lehet megcímezni 1 MB-ot. 16 biten 64KB-tot lehet megcímezni. A címet két részből generálták. Van egy szegmens rész, egy 16 bites szegmens regiszter, és van egy 16 bites eltolás. Ennek az eltolásnak az előállítása történik ezzel a címzési móddal. Úgy adódik a 20 bites cím, hogy a szegmens regisztert eltoltja 4 bittel balra, majd hozzáadja az eltolást és így kiadódik a 20 bit.

Hátránya, hogy ebben a módban a processzor 4*64 KB memóriát lát. Ennél többet úgy tud látni, hogy ha szegmens regisztert vált. 64 KB-os szegmensekben tudja kezelni a memóriát. Pl. régi 16 bites processzornál nem volt mindegy milyen tömböt definiálunk, 64 K alattit vagy felettit. Egy 64 KB-nál nagyobb tömböt nem tudtam kezelni egy 16 bites pointerrel, csak 2 16 bites értékkel. +3,4 utasítás ha el akar érni a memóriában egy adatot. Logikai cím számításának forrásai

28. oldal


• • • • • •

Amikor egy utasítás lehívás van, egy program végrehajtás, akkor minden esetben a CS regiszter van hozzárendelve, és az eltolás értékét az utasítás számláló adja. Ez mindig így van. Stack műveletnél az SS adja a szegmens részt, az ESP az eltolást. Változók elérésére alapértelmezett az adatszegmens regiszter (DS), de ezt felül lehet bírálni, és a többi regisztert is használhatom. Az eltolásnak, az effektív címnek a kiszámítása az előző ábrán látható. String forrásnál DS a szegmens, vannak alternatívák, az eltolás az ESI. String célnál ES a szegmens, nincs alternatívája, EDI az eltolás. BP, mint bázisregiszterhez alapértelmezésben a stack szegmens (SS) van hozzárendelve. A stackből a paraméterek elérésére a BP-t használják. pl. BP+4 és ki vesz a stackből valamit. A BP+0-át nem nagyon használják, mert ha kivesznek egy paramétert, vagy lokális változót, mindig valamit hozzá kell adni a BP-hez. --Így adódik a stack felépítése.-Az utasítás elé lehet egy szegmens override prefixet tenni, amivel a szegmenst lehet felülbírálni. Utasítás, majd az operandus elé a használni kívánt szegmens regiszter, és akkor azt fogja használni a default helyett.

Még néhány példa… Címzési módok Intel processzoroknál: • Regiszter címzés: INC ECX – ECX regisztert címzi meg, 1-el növeli az értékét. • Bennfoglalt (közvetlen adat): MOV EAX, 112233H – itt a közvetlen adat a hexa szám, ez töltődik be az EAX-ba. • Direkt memória: ADD CÍM, AL – A „CÍM”-en lévő adathoz hozzá adja az AL tartalmát. • Regiszter indirekt: MOV [SI], 7 – az SI által mutatott címre kitölti a 7-et. (A fordítónak nem egyértelmű, mert nem tudja eldönteni, hogy 1 vagy 2 bájtos 7-es.) • Bázis címzés: SUB [BX]CÍM, AH – A bázis regiszter és a CÍM összege által meghatározott címre tölti ki az AH értékét. • Indexelt címzés: MOV CÍM[EDI], 25 – CÍM a tömb címe, EDI az index. • Bázis indexelt címzés: ADD [EBX]CÍM[ESI], AL – Két regiszter + 1 eltolás érték szerepel a címzésben. • String címzés: o MOV SI,CIM1 – betölti az egyik címet o MOV DI,CIM2 – betölti a másik címet o MOVSB [DS:SI] [ES:DI] – Ezzel 1 bájt átkerül a DS:SI címről az ES:DI címre. Az SI és DI értéke a direction flag értékétől függően növekszik vagy csökken 1-el, vagy ha word-ös utasítás akkor 2 bájttal. Először a DS értéke másolódik át az ES-be, majd növeli az indexeket. ---Ha az utasítás elé beteszek egy re prefixet, és beállítom a CX regisztert 5-re, akkor az indexeket 5xör fogja emelni (SI, DI) 5-el utána lévő címre fog mutatni.--• I/O port címzése: IN és OUT utasításokkal lehet kezelni a portokat. OUT-al kiküld, IN-el beolvas adatokat. Mindig meg kell mondani azt a portot, amit megszeretnék címezni. Lehet: o Direkt: OUT 30,AL – 30-as portra szeretném az AL tartalmát kiküldeni. o Indirekt: IN DX,AX – A DX-ben lévő portról szeretnék adatot betölteni az AX regiszterbe.

29. oldal


Egyes processzoroknál a perifériák címei be vannak ágyazva a fizikai címtartományba. Van pl. egy 64K-s címrész, ami periféria címzést jelent. Ezekre a címekre ugyan úgy írok ki, mintha memória lenne, MOV utasítással, de az valójában nem memóriára történik, hanem perifériára.

30. oldal


Virtuális tárkezelés Fogalom

Amit a programozó lát. Két címtérről beszélhetünk. • Egyik a logikai (virtuális). Ez az, amit minden esetben a programozó lát. • Másik a fizikai (valós). Az a memória kapacitás, amit megtalálunk az adott számítógépbe. A kettő közt egy transzformáció teremt kapcsolatot – virtuális tártechnika. Minden esetben a logikai címtér nagyságrenddel nagyobb, mint a fizikai címtér. Lapcímzés, működés

A lap azonos méretű memória blokkokat jelent. Jelen esetben van egy operatív táram, ezt felbontottam 4 azonos méretű lapra. Van egy winchester, ahol van 2 program – P1 és P0. Az egyik program 4xeres lapméretű, a P0-ás 3xorosa a lapméretnek. 31. oldal


Első lépésben betöltődik a P0-ás program 0dik lapja a valós és virtuális címtérbe is. Következik az 1-es lap, ez is betöltődik a két címtérbe. A továbbiakban betöltődik az utolsó lapja ennek a programnak, majd elkezd betöltődni a P1-es program. Be kell tölteni a P1-es program 1-es lapját, de nincsen már hely a fizikai tárban. Ezért a fizikai tárban ki kell választani 1 lapot, aminek a helyére be tudom tölteni a P1-es program soron következő lapját. Azonban azt a memória területet el kell tárolni, mert még szükség lehet rá. Ezért ezt a lapot tipikusan a winchesteren egy kijelölt területre – swap fájlba – menti ki, miután már be tud kerülni a P1-es program lapja a fizikai címtérbe is. A programozónak nincsen annyi memóriája, mint amennyire szüksége van. Ezt a problémát a virtuális transzformáció fedi el. A továbbiakban ha szeretném betölteni a következő lapot, el kell valamilyen algoritmus szerint döntenem, hogy melyik lap helyére fogom betölteni az új lapot. Majd annak a lapnak a tartalmát elmentem, és betöltődik az új lap. Ez így folytatódik. Tehát definiálok egy nagy virtuális címtartományt, ezt kezelnem kell. A valós címtartomány ennél kisebb, a kettő között ezért kell konverziót végeznem, amihez szükségem van egy háttértárra, amivel kiegészítem a valós címteret. Lapméret

Két szélső érték: a lap 1 bájt, vagy sokkal nagyobb. Ha nagyobbak a lapok, gyorsabban lehet kiírni őket winchesterre (az írás bufferelt módon történik ezért a nagyobb adatmennyiség a kedvezőbb). Ha bájtokat írok az nagyon lassú. Nagy lapok esetén viszont rossz lesz a kihasználtságuk. Ezért n*KB-tól MB-ig terjednek a lapok méretei. Régebben tipikus méret volt az 512 bájt, Pentiumnál 4 MB. Kompromisszumot kell kötni.

32. oldal


Transzformáció

Kiindulási alap a logikai cím. Ez két részből áll. Egy lapcímből, és egy lapon belüli címből. Van egy bázis regiszter, és egy SW laptábla. A bázis regiszter a SW laptáblára mutat, ahol különböző bejegyzések vannak. A bázis regiszter tartalmához hozzá adódik a lapnak a sorszáma, a lapcím, majd ez egy bejegyzést kicímez a laptáblából. A laptáblában ebben a bejegyzésben több dolog található. Egyik legfontosabb ennek a logikai lapnak a fizikai címe. Az adott logika lap a fizikai tárban hol található. A Q a logikai laphoz tartozó fizikai lapnak a címe. A ténylegesen valós fizikai cím a Q-ból és a D-ből adódik ki. Laptábla bejegyzés tartalma: • Fizikai lapcím (Q). • Ez mellett van benne egy olyan bit, ami azt mondja meg, hogy használták-e a lapot vagy nem. Amikor el kell dönteni, hogy melyik lapot válasszam ki, lehetőleg olyat kell választani, amit nem használtak. • W írtak e bele. Ha nem írtak bele, akkor nem kell elmentenem. Lapcsere esetén ennek a tartalmát nem kell elmenteni a winchesterre. • Jogosultságok • Érvényes –e a lap. A logikai címtér lényegesen nagyobb mint a fizikai címtér. logikai lapból sokkal több van, mint fizikai lapból. Ebben a táblázatban annyi bejegyzés van ahány logikai lap. Mivel a fizikai lapok száma kevesebb, ezért a bejegyzések egy része üres. Ezért kell eltárolni hogy az adott bejegyzés érvényes –e vagy sem. Példa az ábra alapján Lapon belüli cím 100, a lapszám 18. Mivel a lapszám 12 bites, ezért a laptáblában 4096 bejegyzés van. Ehhez a 18-as logikai laphoz a 6-os fizikai lap tartozik.

33. oldal


Számítás Mekkora a logikai címtér? Logikai lapszám * egy lapméret. 16 MB Számítás Mekkora a fizikai címtér? Fizikai lapszám * lapméret. 0,5 MB Laphiba: Ha a logikai lap nincs bent a fizikai tárban, egy nem érvényes bejegyzést akar betölteni. Ilyenkor egy megszakítás történik és az operációs rendszer beolvassa azt a lapot a háttértárról az operatív tárba. Problémák: • Memóriaolvasás. Normális esetben csak 1xer kell a memóriához fordulni. Azonban a laptábla bejegyzést ki kell olvasni, így minimum +1 memória ciklus van. Minden egyes bájthoz 2 memóriaolvasás jár. azonban erre a problémára különböző technikákat dolgoztak ki. • Memória felhasználás hatékonysága. Tegyük fel, hogy 10 alkalmazás fut. Minden alkalmazáshoz ki kell építeni egy laptáblát, egy lapbejegyzés 3 bájt. 10*4096*3 = 120 KB. Ebből a 120 KB-ből 128*3=384 bájt van kitöltve, mert annyi fizikai lap van összesen. Ebben a példában a fizikai tár mérete 0,5 MB. Akkor hatékony a működés, ha a laptáblák a fizikai címtérbe vannak, így a 0,5 MB-ból csak adminisztrációra elhasználom a ¼-ét, holott valójában csak 384 bájtra lenne szükségem.

Asszociatív tár

Asszociatív tár: tartalom alapján címezhető, nem cím szerint. A tár cellákból áll, mindegyik cella egy bitet tárol el. A tárhoz úgy lehet hozzá férni, hogy egyszerre kiolvasom a 4 bitet – megcímzem (ábrán balról cím vezetékek). 34. oldal


Azonban ahhoz hogy asszociatív tár legyen, tehát tartalom szerint tudjam címezni, ki kell egészíteni az egyes cellákat összehasonlító áramkörökkel. Ennek a feladata, hogy amikor kezdődik az olvasás, a megadott kereső szóval összehasonlítja az adott cella tartalmát. Abban az esetben, ha mind a 4 bit megegyezik a kereső szó 4 bitjével, a találat jelző fogja jelezni. Az összehasonlító áramkörök a start után időben egyszerre, párhuzamosan összehasonlítják a tartalmakat, és ahol ez megegyezik, ott a találat jelző 1 lesz. Jelen esetben a 3dik tárnál egyeznek meg a bitek, tehát ott a találat jelző értéke 1 lesz. ----Tegyük fel hogy a 4 bitet ketté osztjuk. Tekintsük két mezőnek. Az egyik mező megmondja a kocsik színét, a másik pedig a kocsiknak a típusát. Ebben az esetben olyan kérést tudok feltenni a tárnak, hogy szeretném látni, hogy Fordokból milyen színű autó van. Ekkor csak a típust jelző két bitre kell keresni, a többit lemaszkolom, és minden olyan rekordnál a találat jelző 1-be fog billenni, ahol Fordot fog jelenteni az a mező. Tehát egy időben egyszerre megkapom, melyek azok a rekordok, amik Ford autóknak a színét tartalmazzák.---A példa lényege, hogyha keresek valamit, a hozzá tartozó információra vagyok kíváncsi. Ennek az ára: egy ilyen cellába +4 tranzisztor van. Ez a megoldás (asszociatív) egy normális tárra van ráültetve. Hozzáférési idő

Asszociatív tár használata: Beteszünk egy asszociatív tárat, amit gyakran HW laptáblának is szoktak hívni. Két dolgot tárolok el benne. A P (logikai lapcím) és Q (fizikai lapcím) kapcsolatot. Elindul párhuzamosan a kereséssel a transzformációs folyamat. Abban az esetben ha a HW táblában megtalálja az adott logikai laphoz tartozó fizikai lap címét, akkor a másik folyamat leáll, és a HW-ben szereplő Q valamint a D fogja megadni a tényleges fizikai címet. Ez az áramkör bele van integrálva a processzorba. lényegesen gyorsabb, mintha a másik útvonalat követnénk. Abban az esetben, ha nincs a HW táblában benne a logikai címhez tartozó fizikai cím, mindenképp a másik útvonalon megy a folyamat. Azonban ezután ez a P – Q kapcsolat 35. oldal


bekerül a HW laptáblába. Ha betelik a laptábla hasonló helyzet áll elő, mint a fizikai tárak esetén. Többszintű lapcímzés

Megoldás a memória felhasználására. (Tipikusan ezt használják) A laptáblát felbontjuk 2 szintre. Az eddigi 1 lapcímet 2 mezőre bontjuk (S, P). Az S kicímez 1 darab bejegyzést a szoftver laptáblából. Azonban ez az M bejegyzés nem közvetlen a fizikai lap címét fogja megmondani, hanem egy második szintű szoftver laptáblát fog kijelölni. Ezek után a P ebből fog kiemelni egy bejegyzést. Innentől kezdve a működés ugyan az mint idáig. A 12 bites lapcím el lett osztva 2 * 6 bitre. Ez a megoldás lényegesen dinamikusabb, mint a másik, mert itt csak annyi laptáblát kell felépíteni, amennyire ténylegesen szüksége van. 1 ilyen laptábla kevesebb helyet foglal el, mint az előző (64 darab bejegyzés lehet benne). Egyet mindenféle képen ki kell építeni, utána pedig már csak annyi laptáblát kell kiépíteni a rendszernek, amennyi a címtér. Ha elég neki 64 lap, az 64*4K, akkor ki kell építeni neki 2 darab 64K-s laptáblát. Ha a teljes logikai címteret használni szeretné, ki lehet építeni a teljes címteret, mint az előzőnél.

36. oldal


Általában 2 vagy 3 szintű lapcímzés szokott lenni.

A kétszintű lapcímzés használata lényegesen kevesebb memóriát fog elfoglalni, mint az előző megoldás. Memóriaolvasás problémája: ha ki szeretnék címezni egy bájtot, 3 olvasási ciklust kell végrehajtani. Azonban itt is használható az asszociatív tár. Viszont a P helyett az S – P kapcsolatot tárolják el. Lehetséges változatok: • Se a P, se az S nem egyezik meg: ilyenkor nincs semmiféle találat, nem lehet felhasználni. • Ha az S nem egyezik meg, de a P igen: ezt sem lehet használni, mert az a lap, amit keresek pl. az 1-es sorszámon van (ezt mondja meg a P) a különböző táblákban, de ebből lehet 64 darab. Hogy melyik ezek közül azt nem tudom, ezért ez nem jelent előnyt. • Ha az S megegyezik, akkor az első laptáblából az olvasást meg tudom spórolni. • Ha mind a 2 megegyezik mind a 2 helyről megspóroltam az olvasást. Az egész szisztéma meglehetősen hatékony, a találati arány, hogy ez az eset hányszor fordul elő az kb. 98%. Ennek oka a programok természete, hogy szekvenciálisan hajtódnak végre, nagy valószínűséggel a következő adat is abba a lapba lesz, amit éppen használt az alkalmazás.

Melyik lapot dobjam el? Keletkezik egy lapigény – laphiba, nincs bent a lap a tárban. Két eset lehetséges. Ha van szabad fizikai lap le lehet azt foglalni, nincs gond. Ha nincs szabad fizikai lap, el kell dobni egyet. Figyelembe kell venni, hogy melyik a legalkalmasabb • Maga a lapcsere a legkevesebb munkával jár (nem kell elmenteni) – nem történt benne változtatás – tiszta lap. Ilyenek a kódterületek. • Az eldobott lap következtében lehetőleg a későbbi lapváltások száma minimális legyen. Azt a lapot válasszam ki, amire az adott környezetben a legkésőbb lesz szükségem. Ezen lapok kiválasztására szolgálnak a lapváltási algoritmusok. 37. oldal


Lapváltási algoritmusok • • •

FIFO LRU FINUFO

FIFO

Lehető legegyszerűbb. A tárban lévő lapok közül a legrégebben betöltöttet dobja el. Van a fizikai lapokról egy nyilvántartás. Tegyük fel, hogy ez üres egyetlen fizikai lapot sem használtam fel. Ebben az esetben ha szükségem van egy fizikai lapra, ez az algoritmus ki fogja jelölni az első, 0-s fizikai lapot. Utána szükségem van az 1,2,3…-ra. Ha betelik, az algoritmus a 0dikat adja ki újból, vagyis a legrégebben kitöltődöttet választja ki, dobja el. Előnye hogy egyszerű.

38. oldal


LRU

Ezzel találkozunk a leggyakrabban. A tárban lévő lapok közül a legrégebben használtat választja ki. A nyilvántartás kiegészül 1 bittel + 1 számlálóval: • Használati bit • Korjelző számláló Maga az operációs rendszer bizonyos időközönként (Tw) megvizsgálja ezt a táblázatot, azon belül ezt a HB bitet laponként. A használati bit célja, hogy amikor valaki használja azt a laptáblát, akkor ez a bit bebillen 1-be. Az ábrán látható időpontokban megvizsgálja a használati bitek értékét, hogy 1-e. Ha ez 0, az azt jelenti, hogy ezt a lapot nem használták, nem történt hozzáfordulás. Ebben az esetben a korjelző számláló értékét növeli 1-el. Ha a használati bit értéke 1, akkor történt hozzáfordulás, a lapot használták, nullázza a korjelző és használati bitet. Lapváltásnál azt dobja el, amelyiknél a KSZ a legnagyobb, mert ez azt mondja, hogy ezt használták a legrégebben. Ha a Tw idők minél kisebbek annál pontosabb értékeket kaphatunk. Azonban ha folyamatosan vizsgálná ezeket, akkor a gép nem foglalkozna mással csak a saját adminisztrálásával, ezért kell egy ésszerű határt szabni, hogy milyen gyakran vizsgálja meg a laptáblát.

39. oldal


LRU és FIFO összehasonlítása

Tegyük fel, hogy van 4 db logikai és 3 db fizikai lapom. Definiálok egy címláncot, ilyen sorrendben van szükségem a logikai lapokra. Látható benne egy ismétlődés. Az első lap igény a 4-esnél merül fel. 3 fizikai lap van, szükség van az 1,2,3-ra, ezek bekerülnek a tárba, a 4-es viszont már nem fér be. FIFO az 1-est fogja eldobni, mert az töltődött be a legrégebben. Ezután szüksége van újból az 1-esre, eldobja a 2-est. Így tovább… Ez 5 darab lapváltást eredményezett. Az LRU a 4-es lapnál a legrégebben használtat dobja el, ez a 3-as. Amikor a 3-asra van szüksége eldobja a legrégebben használtat, a 4-est. Így tovább… Ez 3 lapváltást eredményezett. Jobb LRU, mert kevesebb lapváltás van. Ennek oka az algoritmus. A FIFO nem veszi figyelembe az ismétléseket, szemben az LRU-val. Közelebb van a valóságos program működéséhez. A kettő akkor lesz egyforma, ha a címlánc folytonos, nincsenek ismétlések. FINUFO

A FIFO és az LRU közé lehet pozícionálni. A nyilvántartást egy használati bittel bővíti ki, aminek a funkciója ugyan az mint az LRU esetében. Amikor használja valaki, bebillenti 40. oldal


azt a bitet. A FIFO szerint, ha körbefordult egyszer, akkor az első lapot dobná el. Azonban megpróbálja megkeresni az első olyat, ahol a használati bit értéke 0. Tehát ha a 0,1,2 lapokat használták, de a 3dikat nem, akkor ő a 3dikat foglya kiválasztani. Utána 0-za a HB-t. Ez akkor fog megegyezni a FIFO-val ha mindegyik lapot használták. Probléma •

•

A lapcímzés a társzervezést a fizikai tár oldaláról közelíti meg. Fizikai tárhoz próbál illeszkedni, hogy ugyan olyan méretű lapok vannak itt is, ott is. A lapméret kialakításánál a fizikai tár kihasználtságát vettük figyelembe, nem pedig az alkalmazások számára kedvezőbb lehetőségeket. Sok címbitet kell kezelni, nagyméretű, hézagosan kitöltött laptáblák vannak.

Erre a megoldás hogy a címtartományt változó hosszúságú szakaszokra, szegmensekre osztjuk. (szegmens változó hosszúságú, lap minden fix) Szegmentálás, működés

A memóriát különböző méretű szegmensekre bontjuk. Minden szegmenshez tartozik valamilyen bázis cím, valamilyen bázis regiszterbe, ami megmondja, hogy az a szegmens hol kezdődik a memóriában. Erre a változó szegmens méret miatt van szükség. Itt a bázishoz képesti relatív adatpozíciót kell megadni. Az fogja az adatot megcímezni. Egy szegmensben logikailag összetartozó adatokat szoktunk tárolni. Tipikusan ilyenek az eljárások, tömbök, táblázatok, stack-ek. A szegmentálás a társzervezést a logikai tár oldaláról közelíti meg. Tipikusan a logikai címtér kezelésére használják.

41. oldal


A szegmentálás működése

A logikai cím két részből áll. Egy szelektorból, ami meghatározza a szegmenst, és egy szegmensen belüli címből. Van egy szegmenstábla, egy bázisregiszter, és a fizikai cím. A szelektor hozzá adódik a bázis regiszterhez, majd 1 db deszkriptort ki fog választani, a szegmenstáblába. A bejegyzésbe ugyan olyan jellegű mezők találhatók, mint a lapcímzésnél. Azonban van két fontos különbség: • Benne van a szegmens kezdő címe, hogy ténylegesen hol kezdődik az a szegmens (picit eltér az előző dián mutatottól, de a lényeg ugyan az) • Benne van a szegmens hossza (mivel nem fix hosszú, ezért el kell tárolni) • A különböző jogosultságok, írtak –e bele, használták, u.úgy megtalálhatók benne, mint a másik algoritmusnál. Itt hozzá adódik a szegmens címhez a szegmensen belüli kezdő cím. Ez a cím lényegesen kevesebb bitet fog elfoglalni, mint az előző. Ennek a gyorsítására is asszociatív tárat lehet használni. Az Intel processzornál az utoljára használt deszkriptort eltárolják a szegmens regiszterben (ez a szelektor). Amikor használok egy szegmens regisztert (tehát egy szelektort), kiolvasásra kerül hozzá a bejegyzés, és amíg az nem változik, megtartja. Pl.: van a 0-ás szegmens, első esetben erre hivatkozok. Vagyis a szelektorban benne lesz a 0. Ezzel ő kicímzi a deszkriptort, meghatározza a fizikai címet. Utána megint jön egy hivatkozás a következő bájtra abban szegmensben. Akkor már nem fogja nézni a deszkriptor táblát, mert az Intel processzor szegmens regiszterének van egy olyan nem látható része, amibe bekerül minden olvasásnál ez a bejegyzés. Az itt eltárolt deszkriptor adatokat fogja használni.

42. oldal


Szegmensváltás

A tárat felosztottuk szegmensekre. Kialakult két lyuk. Az S4-s szegmensnek szeretnék helyet foglalni. El kell dönteni hova akarom betenni. Be tudom tenni az alsó helyre, mert ott passzol, de felülre is be lehet tenni, de akkor a szegmentációt növelem. Két lehetőség: • Oda illesztem be, amit a leghamarabb találok meg, kevésbé figyelek a tárkihasználásra • Azt keresem meg, amibe a legjobban illeszkedik, hogy kevésbé fregmentálódjon a táram. Két eljárás: • Legpontosabb illeszkedés (Best Fit) – A lyukakról tartunk egy nyilvántartást, a lyuktábla a lyukak mérete szerint van rendezve. Azok közül amibe pont belefér, a legkisebbet tudom itt kiválasztani. • Legelső illeszkedés (First Fit) – A lyukakat a címek szerint tartom nyilván leggyorsabb

43. oldal


32 bites Intel processzorok virtuális tárkezelése

Kétféle címzési lehetőség (transzformáció) van. • Egyik a flat (sík) címtér ebben az esetben a memória egyetlen 4 GB-os tömbnek látszik, mert beállítottam a szegmens regisztert, ahhoz hozzá adtam az offsetet. A címteret a 32 bites offset adja. 232 = 4 GB. Gyakorlatilag itt a szegmens regisztert egyszer beállítom, és utána nem használom. • A szegmentált címtérnél 64 TBájt lesz a logikai címtér. van egy 16 bites szelektor, ebből sok szegmenst tudok megcímezni, a szegmensek 4 GB-osak lehetnek. Gyakorlatilag 16000 4 GB-os szegmensem van. Ebből adódik ki a 64 TB. A virtuális transzformáció

Minden esetben két forrás szükséges, egy 16 bites szelektor és egy 32 bites offset. A 16 bites szelektor minden esetben szegmens regiszterben van. A 32 bites offset különböző címzési módokkal áll elő. Első lépés egy szegmens transzformáció. Ezután el lehet dönteni, hogy legyen lap transzformáció, vagy ne. Ha nincs akkor előáll egy 32 bites fizikai cím. Ha csak szegmens 44. oldal


transzformáció van, akkor sík címzésről beszélünk. Abban az esetben hogyha a lap transzformáció engedélyezve van, akkor elő áll egy lineáris cím, ami még egy virtuális cím. Ez 3 részből áll, mert ez egy 2 szintű lapcímzés lesz. DIR egyik laptábla (SW1), Page másik laptábla (SW2). Ezek után jön egy lap transzformáció, majd ez adja ki a 32 bites fizikai címet. Szegmens transzformáció

A szegmens transzformáció bemenete és kimenete (lineáris cím) is logikai cím. Ebből fog a lap transzformáció fizikai címet készíteni. A szegmens transzformáció a logikai címek kezelésére szolgál. A lap transzformáció pedig a fizikai címeket kezeli. 32 bites lineárisból egy 32 bites fizikait csinál. A kiindulás egy 16 bites szelektor, ami a szegmens regiszterbe található, valamint egy 32 bites offset. Megtalálható a deszkriptor tábla, ahol 1 db deszkriptor van. 2 típusú deszkriptor lehet. Lokális és globális deszkriptor tábla regiszter. A globális deszkriptor táblát minden alkalmazás látja, a lokálist csak az adott alkalmazás látja. --A deszkriptornál lesz a logikai címből lineáris cím.— Szelektor

45. oldal


Látható rész: 16 bites szegmens regiszter. Van egy 2 bites, jogosultsággal kapcsolatos 2 bit. Van 1 bit, ami megmondja, hogy a lokális, vagy a globális deszkriptor táblát használja. Maradt 13 bit a bejegyzések címzésére. Így adódik ki, hogy 214 db szegmenst lehet címezni. 8192, ebből 8000 lehet a lokális, 8000 a globális táblában. Nem látható rész: ha használok egy szelektort, az első használatkor bekerül maga a deszkriptor, nem kell még egyszer hozzá fordulni a táblához.

Deszkriptor • • • • • • •

Bázis, 32 bit – hol kezdődik a szegmens Limit, 20 bit – mekkora a szegmens. Attól függ, hogy a G bit hogy van beállítva. Granulaty bit o G=0-Limit*1 bájt 1 Mbájt o G=1-Limit*4096 bájt 1 Gbájt Type, 3 bit: leírónak milyen a típusa, mit lehet vele csinálni: read, write, code, data. DPL 2 bit, deszkriptor privilégium szint. Hozzáférés jelző bit Present bit – jelen van e a bejegyzés, vagy nincs jelen

Lap transzformáció

A lineáris címből lesz a fizikai cím. A lapkönyvtár címét az egyik controll regiszter tartalmazza. Ez nem a programozható által közvetlenül elérhető programozható regiszter. Működés: tiszta kétszintű lapcímzés. 46. oldal


Bejegyzések: LKB, LTB • • • • •

Present, 1bit Accessed, 1 bit – hozzáférés Dirty 1 bit - írtak-e bele vagy nem U/S, R/W 2 bit – lapszintű tárvédelem, a felhasználás módját lehet szabályozni. 20 bit: a laptábla fizikai címének felső része.

Ezek a bejegyzések 4 bájtosak. A 32 bit a fent ábrázolt módon adódik. A controll regiszterhez hozzá adódik a 10 bites cím, ebből adódik az adott lapkönyvtár bejegyzés. Ez egy sorszám. 1024 db bejegyzés lehet a lapkönyvtárban, ez megszorzódik 4-el, mert 4 bájtonként vannak a bejegyzések. Így adódik ki a lap könyvtár bejegyzés. Majd az itt lévő 20 bites címhez hozzá adódik a 10 bites lapcím. A bejegyzések 4 bájttal oszthatók. Tehát csak olyan címen kezdődhetnek a bejegyzések, amiknek az alsó két bitje 0. Az alsó két 0-át fixen nem kell eltárolni. Így adódik ki a 32 bit. Majd a laptábla bejegyzésében található 20 bites fizikai címhez hozzá adódik a 12 bites offset, és így adódik ki a tényleges fizikai cím. Asszociatív tár Lineáris cím Fizikai cím, kétszintes lassú. Ezért 32 elemű asszociatív tárat alkalmazunk (386-os CPU) TLB (Translation Looaside Buffer), benne van a processzorban. Az LKB és az LTB párokat tárolja el. (Szegmensnél ez nem kellett, mert volt egy rész, ami eltárolta) Ennek a találati aránya 98 % 100 hivatkozásnál 98xor benne van az asszociatív tárban a cím nem kell a laptáblához fordulnia.

47. oldal


Memóriák Operatív tárként a félvezetős tárak előtt ferrit tárakat alkalmaztak. Félvezetős memóriák előnyei a többi tárral szemben: • Működési sebesség: nagy, ns nagyságrendű (winchesteré ms) • Kapacitás: manapság 1 GB. A működési sebesség és a kapacitás szükséges, de nem elégséges feltétel, hogy egy eszköz elterjedjen. Pl. mágnes buborékos tárak 60-as években IBM fejlesztette ki, gyors volt, nem volt benne mozgó alkatrész. Azonban nem lehetett gazdaságosan gyártani. • Tömeggyárthatóság: gazdaságos előállítás kedvező ár. • Megbízhatóság: manapság természetesnek vesszük. • Energiaigény: nagyságrendekkel kisebb, mint a korai típusoknál. • Helyigény • Modul rendszerű bővíthető • Az OPT és a CPU azonos technológiával készül nem kell illesztés Kikapcsoláskor tartalmát elveszíti. Hozzáférési idő

Információ kérés igénye lép fel a tár felé, valamennyi idő múlva megjelenik a kért információ. Ezután újabb információkérés következik, majd ismét megjelenik az információ. Azonban ezek nem egymás után következnek. Információ kérés kiadása után van egy bizonyos idő, miután megkapom az információt. Ezután pedig van egy bizonyos idő, miután kiadhatom újból az információkérést. A kérés és a megjelenés közötti idő a hozzáférési idő, a két kérés, tárhozzáférés közti idő a ciklus idő.

48. oldal


Csoportosításuk

Többféle képpen lehet csoportosítani. Hozzáférés szerint: • Soros elérésű FIFO és LIFO elrendezésű tárak. Az adatokhoz szekvenciálisan, nem pedig tetszőleges sorrendben férhetek hozzá. Olvashatók/Írhatók. Az információ tárolás statikus. • Szabadon címezhető – cím függetlenül lehet elérni az adatokat. Mindegy hogy a tár melyik részén található az adat, az elérési jellemzői ugyan azok. Vannak Olvashatók/Írhatók ezek információ tárolása lehet dinamikus és statikus (RAM). Vannak csak Olvashatók statikus (ROM) • Tartalommal címezhető tár – előző előadás. (asszociatív). Olvashatók/Írhatók. Statikus információ tárolás. Statikus, dinamikus Statikus SRAM Flip-Flop tárolja el az információt

A flip-flop keresztben van csatolva. Két tranzisztor kapuzza a flip-flop tartalmát. Az M2, M4 ellenállást biztosítja. Ezek a megoldások 4-6 tranzisztorral működnek. Sebességük 1-3 ns.

49. oldal


Dinamikus DRAM Az információt kondenzátorban tárolják el.

1 cellához 1 db tranzisztor és 1 db kapacitás szükséges. Kisebb a fogyasztása. Kevesebb elemből áll Nagyobb az elem sűrűség: ugyan annyi tranzisztorból nagyobb tárat lehet elkészíteni. Kisebb lesz az előállítási költség. A kondenzátor miatt kisebb lesz a sebesség a másik eszközhöz képest Ez a technika lassabb, olcsóbb, nagyobb kapacitású eszköz kialakítását teszi lehetővé szemben az SRAM-al, amiben több tranzisztor van, gyorsabb, relatív drágább és kisebb kapacitású. Összehasonlítás

Az elemsűrűség-, fogyasztás-, sebesség- és árjellemzőknek a következménye, hogy: • az SRAM-ot speciális, kis kapacitás igényű helyeken használják (videokártya, processzor, cache tárak, regisztertár, winchesterben buffer tárnak – >nagy és alacsony sebességű eszköz összeköttetése), • a DRAM-ot az operatív tár kialakítására használják. DRAM és HDD összevetése (2007.02.25) DRAM: Kingston, DDR2, 512 MB, 10 ns, 7390 Ft (nettó) HDD: Samsung, IDE, 160 GB, 8.9 ms, 11830 Ft (nettó) Sebesség: ~ 106 6 nagyságrenddel gyorsabb a DRAM. Ár: ~ 103 3 nagyságrenddel drágább a DRAM.

50. oldal

1MB = 14,44 Ft. 1 MB = 0,07 Ft.


Szervezés

A félvezető tárak szervezése mátrix formában történik. A piros négyzetek fognak 1 bitnyi információt tárolni. Ezek elérése sor és oszlop cím megadásával lehetséges, ezért szükség van még további készülékekre: • Sor dekóder: ha ráadok valamilyen kombinációt, egy sort választok ki. • Oszlop dekóder: egy oszlopot tudok kiválasztani. • Oszlopkapuk: Az oszlop dekóder és a sor dekóder által kiválaszott cella bemenetét, vagy kimenetét kapuzza rá az adat pufferre. A sor dekóder és az oszlop dekóder egy kombinációs hálózat alapján működik. Ha 0 a két bemenet a Q1 lesz 1… Így tovább. Ahhoz hogy a memória modul jól működjön kellenek: • tápfeszültségek, • címbementek, amivel ki tudom választani a megfelelő cellát • WE – Write Enable bemenet (negált szokott lenni). Megmondja hogy írni, vagy olvasni szeretnék a modulból. • 2 adatbemenet/kimenet • CS – Chip Select bemenet: az egészet engedélyezni, illetve tiltani lehet. (Pl.: van egy busz, több ic rá szeretne kapcsolódni, de egy időben csak 1 kapcsolódhat rá, mert a kimeneteket nem lehet összekötni. Erre két megoldás van: Open collector, tri-state kimenet – a kimeneteknek 2 állapotuk van, alacsony és magas, ezekhez jól definiált feszültség tartomány tartotozik. Van egy 3dik állapotű kimenet, mikor olyan nagy impedanciát mutatnak a kimenetek, mintha ott sem lenne.) CS is hasonló módon működik. A modulban 16 bit található. Két szervezése van: • Bitszervezés. [Hozzáférési szélesség – az az adat szélesség, amit egy tárművelettel ki tudok olvasni az adott egységből.] Jelen esetben ez 1 bit. 16x1 bit • Szószervezés: a hozzáférési szélesség egy szó (1 sor, 4 bit). 4x4

51. oldal


DRAM

Áll egy kondenzátorból és egy tranzisztorból, valamint egy szóvezetékből (szelekciós vezeték) és egy bitvezetékből ahol az adatot lehet be és kiolvasni a tárcellába. 1 db kondenzátor tárolja el töltés formájában az információt. Amikor a kondenzátor fel van töltve, akkor tárol 1-et, amikor ki van sütve, akkor tárol 0-át. A tranzisztor szerepe hogy kapuzza a tárcellát. Olvasás: Megcímzem a szóvezetéken keresztül a cellát ki kell nyitni a tranzisztort majd kisütöm a kondenzátort áram folyik megfelelő erősítőkkel lehet érzékelni, hogy fel volt töltve vagy nem. Ezzel a probléma, hogy olvasáskor törlődik. (Az SRAM nem törlődik olvasáskor, de a ferrit tár igen) Ezért minden egyes olvasás után vissza kell írni az információt. ehhez idő szükséges, ezért csak ennyi idő múlva tudom újra használni a tárcellát. Ez nem a frissítést jelenti!!!! Írás: Fel kell tölteni a kondenzátort töltésekkel. Ha 1 van benne, de 0-át szeretnék bele írni, akkor ki kell sütni előtte. Előállhat egy olyan megoldás, hogy írás előtt olvasni kell. Frissítés: A kondenzátor töltése nagyon kicsi, hamar elszivárog (1 ms, pár száz mikros). Ilyen nagyságrendenként ezt frissíteni kell bele kell írni újból az adatot. A beírás valójában egy olvasást és egy írást jelent. Először ki kell olvasnom, aztán vissza kell írnom olvasási ciklust jelent. Ha végig olvasom a cellákat, akkor már frissítettem is őket, mert maga az olvasás egy olvasást és egy írást jelent

52. oldal


Két megoldás a frissítés kezelésére: • DMA + rendszeridőzítő segítségével végzi a rendszeres olvasást • A memória modulban lévő logikai végzi, a CPU-tól függetlenül (nem terhelve azt.) Feltesszük, hogy ez egy 16 KB-os tár, ami egy 128x128-as mátrixba van szervezve (128 sora, 128 oszlopa van). • Első esetben 1 ms-onkét a teljes tárat frissítettem. Burst Refresh • Második esetben a frissítést elosztva végzem. 1 ms alatt végig olvasok minden sort, 1/128-ad ms-onként végig olvasom a sorokat. Eloszott frissítés, Distributed Refresh • Az utasítás végrehajtás a frissítés szempontjából 2 részből áll. Van egy előkészítő ciklus (F-fetch) és egy végrehajtó ciklus (E). Az előkészítő ciklusban a processzor eldönti, hogy mit kell csinálnia, és meghatározza, hogy mivel. Beolvassa a műveleti kódot, dekódolja a műveleti kódot, beolvas egy vagy több operandust a memóriából. Ezután jön az execute ciklus, ami az utasítást hajtja végre. A frissítés akkor történik, amikor a processzor nem használja az operatív tárat. Amikor nem fordul hozzá, akkor frissíti a rendszer a memóriát. A dekódolásnál és a végrehajtó fázisnál nem használja a memóriát. Transparent Syncronous Refresh Szervezés RAS/CAS

1MB-os tár megcímzéséhez 20 bit szükséges. A 20 bitnek nehézkes a kezelése. Ezért a 20 bitet kettévágták. Lett egy sor és egy oszlop cím. Ezt a két címet egymás után adjuk át a memóriának. Először lekerül a sor cím, bekerül egy puffer tárba, majd lekerül az oszlop cím, az is bekerül egy puffer tárba. Amikor ez bekerül, ez fogja elindítani magát a memóriaolvasást. Két lépésben történik a memória kezelése, a cím két menetben kerül le. Ehhez két vezérlő bemenet jelenik meg: • RAS – sor címek megjelenésének jelzése a címbuszon • CAS – oszlop címek megjelenésének jelzése a címbuszon A valóságban több bank van egymás mögött

53. oldal


DRAM olvasási ciklusa

Legfelül az órajel. R/W bemenet megmondja, hogy olvasás, vagy írás történik. Adat kimeneten megjelenik a megcímzett adat. Rákerül a sorcím a címvezetékre, majd a RAS aktív lesz. Amikor az órajelnek és a RASnak is lefutó éle van, akkor kerül be a sor puffer tárba a sor címe. Következő ciklusban aktív lesz a Read bemenet, tehát olvasás történik. Következőkben az oszlop cím kerül ki a címvezetékre. Aktív lesz a CAS vezérlő bemenet, és az oszlop cím beírodik az oszlop pufferbe tárba. Innentől kezdődik az olvasás. Mostmár előállt a sor és az oszlop cím a memória tömb bemenetén, és az oszlop cím megjelenésekor indul el az olvasás. Maga az olvasás 2 ciklusig tart, amikor megjelenik az adat. Ekkor a CAS jel visszavételénél mintavételezi a rendszer az adatbuszon lévő adatokat, és beolvassa őket. Végül visszaveszi a többi vezérlő jelet is. Ez a folyamat kb 60 ns-ig tart. egy olvasás 6 órajelig tart. Ha 4 adatot szeretnék kiolvasni, akkor az 4*6 órajelig fog tartani. Manapság az olvasás csak 1 órajelig tart, ezért 5+5+5+5. Ez az 1 tranzisztor és kondenzátoros DRAM működése. Ezt a megoldást soha nem alkalmazták PC-be. Fast Page Mode DRAM – FPM DRAM Ezt használták ténylegesen először PCkben. Általában egymás utáni adatokat olvasok legtöbbször a memóriából. Ennek az a következménye, hogy azonos sorban lévő adatokat olvasom egymás után. A mátrix szervezésből adódóan kiadok egy sor címet, és az oszlop címekkel címezgetem meg a következő oszlopokat. Tehát a RAS-t csak 1xer kell kiadni és visszavenni. Ennek következtében, ha ismét 4 adatot veszünk figyelembe, akkor a ciklus így néz ki: 5+3+3+3. Az elején megmarad az 5, lesz 1 teljes ciklusom, utána pedig 3 db 3 órajelig tartó ciklusom. Ez valójában 4+3+3+4 (mert az elején lemegy a RAS, a végén pedig vissza), de általánosságban ezt 5+3+3+3-nak írják.

54. oldal


Extended Data Out DRAM – EDO RAM A CAS felfutó élére továbbítódnak az adatok a memóriából. A kimeneten azonban csak a CAS-nak (oszlopcímnek) megfelelő adatok látszódhatnak. Ha bemeneten megváltoztatom az oszlop - sorcímeket, akkor ez a kimeneten is megváltozik, mert törlődik a kimeneti puffer. Tehát ha változik a CAS bemenet, változik a kimenet is. A következő olvasás csak akkor lehetséges, ha a CAS visszaért az eredeti állapotába. Azonban a memória kimenethez egy átmeneti tárolót tettek, ahova amikor megjelenik az adat, rögtön bekerül. Ehhez felhasználtak egy új kimenetet, így a CAS jel nem jelent korlátozást, előbb vissza lehet venni a jel értékét, nem kell megvárni, míg megjelenik az adat. Ha előbb vissza tudom venni, akkor előbb tudom indítani a következő olvasást. Ebben az esetben 5+2+2+2 ciklus lesz. Synchronous DRAM - SDRAM Itt is egymás utáni címekről kell olvasni. Ezek után elég csak a kezdő címet megadni, nem kell megvárni a következő oszlopcímet sem. Ez megoldható például egy belső számláló használatával. Másik megoldás, hogy a memória működjön szinkronba a processzorral. Idáig nem a processzorral, hanem a busszal működött szinkronba. Tehát az eddigi DRAM-ok asszinkronban működtek az adatot kérő egységgel, jelen esetben a CPU-val. Az SDRAM-tól szinkronban működnek (minden egyes órajel ütemre olvas 1 adatot)---, ezért a CAS és RAS jeleknek már nem nagyon van szerepe---. Ciklus igénye: 5+1+1+1. Kell egy teljes ciklus + amelyeknél 1 adatot kiolvas. Összefoglalva

A ciklus idő 60 ns, ez 5 órajelre bomlik, 4 adatot olvasunk egymás után. • DRAM esetén a 4 adat kiolvasása 20 ciklust igényel, ezt vesszük 100%-nak. Az átlagos ciklus idő 60 ns lesz. A sávszélessége 100 MB/s. • FPM esetén 14 ciklus van, 70%-a a DRAM-nak, 42 ns-os átlagos ciklusidő jön ki. 150 MB/s a sávszélessége. • EDO-nál 11 ciklus, ez már csak 55%, 33 ns-os ciklus idő, 200 MB/s a sávszélesség. • SDRAM-nál 8 ciklus, 40% 8 ns ciklusidő.

55. oldal


Ugyan azokat az elemeket használva, az architektúrát változtatva értük el a sebesség növekedést. Memória tömbök használata

Van egy 32bites címtér, amivel 4 GB-ot tudok megcímezni. Ezt 4 db 1 GB-os memóriamodulnak fogom kialakítani, egy ilyen modul címzéséhez 30 bit szükséges. Van 4 blokk, minden blokk 1 GB-os. Minden blokk megcímzéséhez 30 bit szükséges. A teljes rendszer megcímzéséhez 32 bit szükséges, azonban a felső 30 bitet használom az egyes modulokon belüli bájtok eléréséhez. Az alsó 2 bitet az egyes modulok kiválasztásához használom. A modulok 1 bájtosak, így kialakul a 32 bites adat. A 0-ás cím a 0-ás blokk 0-ás címén van. Az 1-es cím az 1-es blokk 0-ás címén van…

A 4-es címről olvasunk 4 bájtot. Az első bájt a 0.blokk 1-es címén lesz. Ennek a 32 bites címében alul van két 0. Ez a két bit megy a blokk választó áramkörre. Következő az 5ös, majd a 6-os, végül a 7-es. 56. oldal


Ha a 3-as címről szeretnék 4 bájtot kiolvasni, ugyan úgy felírhatom az értékeket táblázat. Fontos különbség hogy a bal oldali esetben a felső 30 bit egyforma, a másiknál nem. Ennek az a következménye, hogyha ki szeretnénk olvasni a 4-es címről 4 bájtot, akkor mindegyik memória modulra egyforma cím kerül (a felső 30 bit). Az alsó 2 bit a dekóder egységre kerül rá. A másik esetben viszont az utolsó 3 címnek egyezik, de az elsőnél eltér a 30 bit. Ha ki szeretnék olvasni a 4-es címről 4 bájtot, elég 1xer átvenni a 30 bitet. – elég 1 ciklus (nem kell változtatnom a blokkoknak a címét.). A másiknál nem elég, mert 2 ciklusra van szükségem. Ezért van az, hogy a fordítók az adatstruktúrákat 4-el, 8-al, 16-al.. osztható címre igazítják. Ezért van az, hogy ezekről a címekről, 2 hatványainak megfelelőekről, hatékonyabban tud olvasni a CPU. Ennek a megoldásnak Low order interleaving a neve.

A Low order interleaving-nél a címek balról jobbra, lentről lefelé helyezkednek el. High order interleaving esetén a felső 2 bit szolgál a dekóder bemenetére, az alsó 30 bitet használom a modulok címzésére. Ebben az esetben azonban, amikor címzek, egy konkrét modult választok ki.

57. oldal


SDRAM felépítése

Van benne 4 db bank, ami a mátrixot jelenti. Ezek egy lapkán találhatók, a kimenetük 8 bites. Ebből van 8 db lapka, ezeknek a kimenete 32 bites. Ezek egy 32 bájtos kimeneti pufferbe vannak bekötve. Ami kimeneti puffer kommunikál az adatbusszal, ami 64 bites. Ez lesz egy DIM modulnak a felépítése. A lapkán belül az egyes bank-ek kezelése úgy történik, ahogy az előbbiekben néztük (alsó két bit mondja meg melyik modulról van szó). Viszont a lapkák kezelésére a másik megoldás használatos (felső két bit) – modulokat külön működtetik.

Rambus DRAM Jellemzők: • 1996: Intel+ Rambus, 2001-ben Intel kiszállt • Teljesen új architektúra, nagy sebesség (3-4 ns) • Több egymástól független memória • Nagy (1 SDRAM sor) belső cache, 1MB-> 2 KB • Nincs RAS,CAS -> egy lépésben • Speciális illesztő áramkör, gyártás! • Blokkos átvitel: 8…256 bájt Ehhez a memória modul készítéséhez teljesen más technológiai gyártósor kellett, szemben az SD és DDR ramokkal, amiket a meglévő eszközökkel lehetett készíteni. Emiatt drága technológia volt. Sony playstation-okben alkalmazzák őket.

58. oldal


Double Data Rate Synchronous DRAM – DDR DRAM

DDR Magát a ram egységet, a belső modult ketté választották. Egy memóriára és egy illesztő egységre. Az illesztő egység gyorsabban működik (SRAM-ok, gyors tranzisztorokból épülnek fel), a memória tömbök ugyan úgy működnek mint eddig. Az órajel lefutó és felfutó élére is történik egy-egy olvasás, memória hozzáférés. a memória blokkok egymástól függetlenül vezérelhetők, így párhuzamosan működtethetők. Ebből adódik hogy a DDR sebessége nagyobb is lehet mint az előzőknek, mert ugyan annyi idő alatt 2xer annyi adatot lehet belőle kiolvasni. --Az egyiket a felfutó, a másikat a lefutó élnél nézi.-DDR2 Memória tömbbe több modul tettek, így egy időben több adatot tudtak kiolvasni. Ennyivel több a DDR2. 4*64 bit megy memória tömbök és az illesztő egység között. Az illesztő egység órajelét változtatták. DDR3 Növelték az adatszélességet, 8*64 bitet lehet áttölteni. A memória elemek ugyan azok, hozzáférési idejük nem nőtt, azonban növelték az illesztő egység frekvenciáját, és az áteresztő képességet. Tokozások

59. oldal


Notebookok számára más felépítést használnak, kisebbet (2dik, 3dik) Ha van paritás bit, vagy ECC, akkor az adatbitek száma nem 64, hanem 72 és 80.

Külön hűtőrész található rajta, ami csökkenti a termelt hőt. Memóriák fejlődése

„Kérdés: Ismertesse a memóriák fejlődését, mikor milyenek jelentek meg, mi a tendencia.”

60. oldal


SDRAM jellemzők

Megvan adva a frekvencia, amin az egység működik. Sávszélesség számolás (PC133 esetén keresztül): A frekvencia 133MHz, ami 133x106 órajel másodpercenként. 1 órajel alatt 1 adat továbbítása történik. 1 adat 8 bájt, ebből kifolyólag adódik ez a teljesítmény. Sávszélességről beszélünk, nem hozzáférési időről. Ennek oka, hogy a fejlődésben az adatszélesség változik, amivel hozzá lehet férni a memóriához. DDR Ramok jellemzői

Itt külön válik a memória modul frekvenciája, és az illesztő egység frekvenciája. Az illesztő egység 2xeres frekvenciával működik, mert 2 adatot kell neki kivenni, a felfutó élre és a lefutó élre. A névben nem a frekvenciára, hanem a sávszélességre utaló szám található. (PC-1600) Sávszélesség számítás (PC2100 esetén keresztül): A sebesség 133MHz, de 1 órajel alatt 2 adat továbbítódik. 1 adat 8 bájt. 133x106x8x2 ~2100

61. oldal


DDR2 Ramok jellemzői

Külön válik az illesztő egység és az adat frekvencia – az az ütem, ahogy az adatot kapja az adatot kérő egység. A névben itt is a sávszélesség jelenik meg. Egy órajel alatt 4 adat továbbítására képes. képlet ugyan az. Kijön a ~4200.

Memória konfigurációjának detektálása Amikor a PC bebootol, a BIOS megvizsgálja a PC-ben lévő memória konfigurációját, hogy milyen memória van benne. Két féle módszer: • Kapcsolókkal be van égetve. Van 12 kapcsoló, ami 0 vagy 1 értéket jelent, ebből a kódból egy táblázat segítségével meghatározza a BIOS az adott memória konfigurációját. Paralell Presence Detect (régen) • Serial Presence Detect

Az információ EEPROM-ban van eltárolva - elektromosan programozható ROM.

62. oldal


Cache A processzor teljesítményének a növelésére 2 út kínálkozik: • Technológiai o Nagyobb memória o Magasabb frekvencia o Bitszám növelése o Gyorsabb áramkörök használata (SRAM, DRAM) • Architektúrális (memóriára korlátozzuk jelen pillanatban) o Virtuális tár technika – tár méretét növeltük látszólagosan meg. o Különböző típusú memóriák alkalmazása: DRAM, FPM, EDO, SD, DDR. --A DDR-ben is ugyan az a memória cella van, mint a szimpla DRAM-ban.— o Memória tömbök használata – technológiai fejlődés nélkül a teljesítményt növeli. o Asszociatív tár o Cache Alapvető probléma a CPU és a memória közti sebesség különbség. 8 MHz 125 ns 50 MHz 20 ns 500 MHz 2 ns A memória nagyon lassú a CPU-hoz képest. A megoldás egy nagyméretű, olcsó, gyors memória ☺ Ilyen azonban nincs Megoldás Régebben wait state úgy kellett a memóriát illeszteni a CPU-hoz, hogy egy jumpert kellett betenni, amivel meg lehetett mondani, a memóriaolvasási ciklusok számát. Minden memória olvasásánál a CPU hány ciklusig várjon, míg megjön az adat a memóriából. Megoldás lehetne egy gyors memória a CPU lapkán (mivel a bus is lassú), de ez nem jó, mert a CPU gyártása nem lenne gazdaságos, a lapka nem lehet tetszőleges méretű. fizikai, gazdaságossági korlátok. Valóság • Van egy nagy, de relatív lassú memória, Dinamikus RAM • Kicsi, de gyors, SRAM-ból készülnek

63. oldal


Cache működési elve

Veszünk egy kicsi és gyors (az OPT-hez képest) tárat, és betesszük a CPU és az OPT közé. A leggyakrabban használt adatokat a cahcben tartjuk. Amikor a CPU adatot szeretne kérni az operatív tárból, pl. beszeretne olvasni 1 bájtot, beolvassa azt az OPTből és beteszi a cache-be. Utána beolvas pl. 16 bájtot, mert feltételezi, hogy a következő olvasás a következő címről következik. Ezután szeretné olvasni a következő bájtot. Amikor azonban olvassa azt, már megtalálja a cache-ben, és onnan fogja kiolvasni, nem az OPT-ből. A cache tár alkalmazását lehetővé teszi a lokalitás elve: Egy rövid időintervallum alatt a memóriahivatkozások a teljes memória csak egy kis részét érintik! Két része van: • Térbeli: a processzor olvassa az adatokat a memóriából, a következő memória címet fogja olvasni. • Időbeli: van egy ciklikusság, ismétlődés ugyan azt a környezetet többször fogja beolvasni. Ez is a programok természetéből adódik. Számolás…

Képlet: Átlagos elérési idő = Pt x Tcache + (1-Pt) x Tc Tegyük fel, hogy a tár ciklus ideje 8 ns, a cache-é 1 ns, a találati arány 98% (100 esetből 98xor benne van a kért adat a cache-ben). A képletben a valószínűségüknek megfelelően veszem figyelembe a két időt. A cache-nek lesz a 0.98, a tárnak pedig 0,02. Eszerint a képlet szerint kijön egy átlagos elérési idő. Ez elvi számítás, de közelít a valósághoz pl. a nagyságrenddel, hogy mennyivel lesz gyorsabb a memória egy cache tár alkalmazásával.

64. oldal


Főtár és cache aktualizálása 3 féle módon lehetséges: • Átíró (write trough): amikor a főtárba írok, rögtön a cache tárba is írom az adatokat. lassú • Visszaíró (write back): amikor blokkot cserélek, a cache-be, amikor beolvasok valamit, akkor nem 1 bájtot olvasok, hanem minden esetben annak valamilyen környezetét. Hasonlóan a virtuális tárkezeléshez, blokkonként kezelem a cache-t. Amikor a blokkot cserélem, akkor írom vissza. Két esetben kell a blokkot cserélni: o Amikor elfogyott a cache (nincs benne szabad memória), ilyenkor 1 cache blokkot ki kell választanom. A kiválasztásnál az LRU algoritmust használják. o Másik eset, ha esetleg egy másik eszköz hozzá szeretne férni ahhoz a memória blokkhoz, ebben az estben a cache vezérlő figyeli ezt, és akkor is visszaírja a cache-t az operatív tárba, addig nem engedi azt az eszközt hozzáférni az operatív tárhoz, amíg nincs szinkronban a cache és az operatív tár. • Késleltetett írás (burst write) – amikor lehet, akkor írja vissza. Van olyan idő, amikor az operatív tár nincs használva (pl. frissítésnél), akkor írja vissza a cache-ből az adatokat az operatív tárba. Amíg nem írja vissza, nem enged más eszközt a memóriához hozzáférni. Az előző két megoldás közé pozicionálható.

A memória hierarchia lehetséges alternatívái az adatcache szempontjából!!!!

P = Processzor. A CPU lapkán található egy adat (L1) és egy utasítás cache. Lehetőségek, hogy hol találhatunk még cache-t: • Nincs máshol, ilyenkor ez közvetlenül van kapcsolatban a memóriával. • Van 1 L2 cache, ezen keresztül férhetünk hozzá a memóriához. • Bejön az L3 cache. Intel fejlődésénél: először a CPU-n kívül voltak, majd bekerültek egy dedikált buszon keresztül a processzorhoz, végül bekerült a processzorba. Itaniumnál már bent van az L1 és L2, az L3 dedikált buszon keresztül csatlakozik. (lásd részletesen az anyag végén). Hozzávetőleges méretük az ábrán. 65. oldal


Az adatcache tervezési terének alapkomponensei

Az adatcache tervezési tere két részből áll: • Adatcache architektúra: funkcionális leírása a cachnek. Írási, olvasási eljárások, hibavédelem található benne. • Adatcache mikroarchitektúrája áll: o Belső struktúra (ábrán) o Műveletek (ábrán) Szervezés • Közvetlen leképzésű (direct mapped) • Csoport asszociatív (n-way set associative) Közvetlen leképzésű

A 32 bites cím (fizikai) cím 4 részből áll: Tag, Line, W (word), B (bájt). A cache az alsó táblázat. Az adminisztrációs részhez a V, D és Tag tartozik, ahol különböző bitek találhatók, hasonlóan a laptábla bejegyzéshez (V – Valid: érvényes –e, D – Dirty: használták-e). A cache adatrésze a 7-től 0ig terjedő szakasza a táblának.

66. oldal


Működés: Tegyük fel, hogy 1 cache line 32 bájt. 8 szóbol áll, 1 szó 4 bájt. A táblában 1 kis 4zet 4 bájtot fog jelenteni. Összesen van 2048 bejegyzés. Ezek után a cache-nek a mérete 32x2048 = 64 K A line, ami 11 bites, kicímez egy bejegyzést a cacheből. Jelenleg a tartalma 2, ezért kicímzi a 2-es bejegyzést. Ezután összehasonlításra kerül a címnek a TAG része a 2-es bejegyzésben eltárolt TAG-el. Ha ezek megegyeznek, és a Valid bit rendben van, tehát érvényes, akkor a keresett adat megtalálható a cach-ben. Ha nincs benne cache miss következik be. Azaz a memóriaolvasást kell folytatni, be kell olvasni az adatot a memóriából, és be kell tenni a cachebe. Ha benne van a keresett adat, a Word rész 3 bitje megcímzi a 4-es mezőt, szót. Általában jellemző hogy az utolsó két bit 0, mert 4 bájtokat olvasok a cacheből. Tehát a példánkban a B tartalma 0. Ha bájt szerint szeretnék címezni, az alsó kettő bit mondaná meg, hogy a 4 bájtból melyiket szeretném olvasni.

A közvetlen leképezés egy elég gyors megoldás, mert lehet párhuzamosítani a szókiolvasást, továbbítást, címek összehasonlítását. Probléma: 64 K a cache-nek a tartalma. A 32-es és a 65568-as cím két különböző cím, de egy dolog egyforma mindkettőben a Line rész. Ez azt jelenti, hogy a 32-es és a 65568-as címről az adatok ugyan abban a sorban lehetnek. Tehát a 32-es és a 65568-as cím megfelelő helye a cacheben ugyan az. A kettőből egy időben mindig csak az egyik lehet bent. Tehát a 64K-nként ismétlődő címekből mindig csak 1 lehet bent a cacheben. Összeütközés álhat elő, de ez ritkán fordul elő. Erre megoldást a csoport asszociatív tár jelent.

67. oldal


Csoportos asszociatív

Az, ami idáig volt, abból veszek 4-et. Az adatokat párhuzamosan tárolom. 4 rész van, ezért 4 utasnak hívják. 4 utas csoport asszociatív cache tár. 1 cache line 4 szóból áll, 1 szó továbbra is 4 bájt. Azaz a cache kapacitása 4K. Működés: A teszt adatok az alsó címből kiolvashatók. Először a line rész minden egyes helyen kicímzi a 3-as indexű elemet a cacheből. Majd ezt követően maga a cache összehasonlítja ezeket a bejegyzéseket a tag résszel. Mielőtt összehasonlítja, megnézi a V-t. Ez által kiesik a jobb felső bejegyzés. A tag a jobb alsó bejegyzésnél egyezik, tehát ott lesz a kért adat. Innentől kezdve az adat kicímzése úgy működik mint előbb. A W rész kicímzi a másodikat, a B=3 miatt pedig ezen belül a 3dik bájtot fogja elérni. Asszociatív, mert tartalom alapján választom ki a 4ből azt, amelyik megfelel a kitételnek. A módszer bonyolultabb, mert 4 címet kell egyszerre vizsgálni, kezelni. Melyiket kell eldobni, kiválasztani? – LRU-t kell használni.

Szervezés, példák • •

•

•

Direct Mapped (közvetlen leképezésű) – szuperskalár processzorok Alpha 21064A, 21064, 21164 (Compaq/DEC) UltraSparc I, II (Sun). 2 way – 2 utas cache o Pentium o Pentium Pro o Athlon (Amd) 4 way – 4 utas cache o UltraSparc III o Pentium 2 o Pentium 3 8 way o PowerPC 620 (PowerPC) 68. oldal


Cache Line szerkeztete, példák Directed Mapped - Alpha 21064A Két részből áll: • Directory Entry o Valid:1 bit – hogy érvényes-e a bejegyzés o Adat paritás szavanként (4 bájt): 8 bit. 32 bájtos az adatrész, 8 db 4 bájtos szó található benne, mindegyikhez tartozik egy paritás bit. o TAG o TAG paritás: 1 bit. • Data o 32 bájt N-way set associative – Pentium Pro (2 utas) • Az adatrész 2xer 32 bájt: Data0 – 32 bájt, Data1 – 32 bájt • Dir0, Dir1 – mindegyik 32 bájthoz tartozik egy directory bejegyzés. o TAG: 24 o Nem paritás van, ECC (Error Correction Code) o T-ECC: 6 (TAG) o D-ECC: 10 (Data) o MESI: 2 bit (Modified Exclusive Shared Invalid) A CPU és a Cache kapcsolata •

•

Off-chip: o Rendszerbuszon keresztül csatlakozik a cache a CPU-hoz – korai skalárprocesszorok, nagy hozzáférési idő, kicsi sávszélesség o Dedikált buszon keresztül történik a hozzáférés. Olyan busz, ami közvetlenül összeköti a cache-t a processzorral – gyorsabb. (HP PA8200) On-chip: o A CPU lapkán – a CPU belső buszát használja, szuperskalár processzoroknál találkozhatunk ilyennel. Ez a leggyorsabb megoldás.

Cache méret (On-chip) Nagy méret

nagy találati arány

nagy teljesítmény

Nagy méret hátránya: különböző geometriai méretekből adódó késleltetések, a chip méret fizikai korlátja. Értékek: • 8K: Alpha21064, Pentium, PPro, P4 (L2 256K/512K) • 16K: PII, PIII • 32K: K6 • 64K: Athlon • 1M: HP PA 8500

69. oldal


Cache Line mérete Illeszkedik a CPU által használt adattípusokhoz (integer méretéhez) • 32 bájt: Pentium, PII, PIII, PPro • 64 bájt: Pentium 4, Alpha 21264 • 128 bájt: Power 3, Power 4 Adatszélesség a CPU és a Cache között

A processzorban benne van a CPU és bele van integrálva az L1 adatcache. Ez után jön az L2 cache ha van, és végül maga a memória. A processzor és az L1 cache között mindig portokon keresztül történik a kapcsolat, lehet 1 vagy több, de mindig 8 bájt az átbocsájtó képessége. Az L1 és a memória illetve az L1 és L2 cache között szűk a keresztmetszett, mert meglehetősen nagy az adatforgalom. Az egyes processzorok értékei az ábrán. Cache tárak alakulása a CPU-ban

70. oldal


System Controll – rendszervezérlő egység. A Bus Interface Unit magát a processzort illeszti a külvilághoz. A 386-os processzorban nem volt cache tár, egy külső cache-t lehetett használni, ennek semmi köze nem volt a processzorhoz (L1 cache)

A 486-osnál az L1 cache rákerült a processzorlapkára, és megjelent az L2 cache mint külső cache tár.

Ketté vált az L1 cache

külön van az utasításnak és külön van az adatoknak cache.

71. oldal


Az L2 cache dedikált buszon keresztül kapcsolódik a processzorhoz, nem a rendszerbuszon keresztül. gyorsabb, de nem olyan gyors, mintha a processzor lapkán helyezkedne el.

A processzor lapkába bekerült az L2 cache. Két cache-ről beszélünk, egyik osztott (L1), a másik nem (L2).

72. oldal


Megjelent az L3 cache. On-die L2 cache, direct coupled L3 cache

Az L3 cache is dedikált buszon csatlakozik a processzorhoz. Cache fejlődése, tendenciák

A cache tárak egyre nagyobbak, egyre közelebb kerülnek a processzorhoz, rákerülnek a processzor lapkára hatékonyabban, gyorsabban tud hozzá férni a CPU az adatokhoz. Manapság több cache tárat már nem tudnak bele tenni a lapkára, ezért inkább több magot tesznek bele.

73. oldal

Megszakítási rendszer

Recommend Documents