Dr. Várady Géza: Számítógép-architektúrák II

TÁMOP-4.1.1.F-14/1/KONV-2015-0009„A GÉPÉSZETI ÉS INFORMATIKAI ÁGAZATOK DUÁLIS ÉSMODULÁRIS KÉPZÉSEINEK KIALAKÍTÁSA A PÉCSITUDOMÁNYEGYETEMEN „

Várady Géza

Számítógép-architektúrák II.

Pécs2015

A tananyag a TÁMOP-4.1.1.F-14/1/KONV-2015-0009 azonosító számú,

„A gépészeti és informatikai ágazatok duális és moduláris képzéseinek kialakítása a

Pécsi Tudományegyetemen” című projekt keretében valósul meg.


Számítógép-architektúrák II.

Várady Géza

Szakmai lektor: Sári Zoltán

Nyelvi lektor: Veres Mária

Kiadó neve

Kiadó címe

Felelős kiadó:

ISBN szám

Pécsi Tudományegyetem

Műszaki és Informatikai Kar

Pécs, 2015© Várady Géza


TARTALOMJEGYZÉK

Tartalom

1. Alapvető digitális áramkörök............................................................................. 7

1.1. Kombinációs áramkörök........................................................................................................ 14

1.2. Szekvenciális áramkörök ....................................................................................................... 22

1.3. CPU lapkák............................................................................................................................. 32

1.4. Számítógépes sínek ............................................................................................................... 33

1.5. Pentium 4 CPU lapka ............................................................................................................. 43

1.5.1. Számítógépes sínek ....................................................................................................... 48

2. A processzor belső működése ..........................................................................62

3. A párhuzamosítás lehetőségei ..........................................................................88



Előszó

A jegyzet a Számítógép-architektúrák című tárgy első félévéhez készült. A tantárgy A. S.Tanenbaum, Számítógép-architektúrák című könyvének 2. kiadása (PANEM, 2006) alapjánhalad, de egyéb témákra is kitér. A jegyzet váza az oktatói tapasztalat és a hallgatóivisszajelzések alapján készült. A könyvben tárgyalt részek kicsit más megvilágításban,másképp is magyarázva, példákkal, ábrákkal egészültek ki. Ez bővült a tárgyban mégfontosnak tartott fejezetekkel, információkkal. Olyan adatok is bekerültek, melyek a könyvkiadása óta újnak számítanak és tárgyalni, említeni érdemes őket. A fenti magyar nyelvűkönyvet dr. Máté Eörs lektorálta, aki a kötethez készült magyar nyelvű ábrákat sajáttárgyainak fóliáiként is használja. Ezeket, illetve a könyvhöz kiadott digitális mellékleteket ishasználtam a jegyzet illusztrációihoz.

A jegyzetet informatikus hallgatóknak ajánlom, de jó szolgálatot tehet a kapcsolódószakirányok hallgatói számára is.



1. Alapvető digitális áramkörökA számítógépek digitális áramkörökből épülnek fel. A digitális áramkör két logikai értékkeldolgozik, a 0-val és az 1-gyel. Ezeket a logikai értékeket az elektronikusan működő gépekbenjellemzően feszültségértékekkel reprezentálják. Az egyértelműség kedvéért a feszültségeketegy tartományon belül tekintjük megengedettnek, pl. a 0-át a 0–1V feszültség, az 1-et pedig a2–5V közötti feszültség jelentheti. A kettő között érdemes egy biztonsági sávot hagyni, amiegyértelműen elválaszthatóvá teszi a mért jelet.

A kapuk kis elektromos eszközök (áramkörök), melyek függvényei kétértékű jelekkeldolgoznak. A logikai kapuk logikai alapműveleteket valósítanak meg. A kapuktranzisztorokból épülnek fel, melyeket leginkább gyors bináris kapcsolóknak tekinthetünk.

A tranzisztorok felépítését a következő ábra (a) pontján (1. ábra) láthatjuk. A tranzisztoroknakhárom kapcsolata van a külvilággal: kollektor, bázis, emitter.

1. ábra (NPN) Tranzisztor felépítése és kötéseii


2. ábra Az (a), (b), (c) kötésekhez tartozó bemenetek és kimenetek i

Ha a bázison mint bemeneten (Vin) bizonyos határfeszültségnél kisebb feszültség van (azazlogikai 0), akkor a kollektorfeszültség, ami a kimeneti feszültség, megegyezik az egyszerűáramkör Vcc tápfeszültségével (ez kívülről beállított, tipikusan 5V), azaz logikai 1. Amikor abemenet feszültsége egy határértéknél nagyobb, azaz logikai 1, a tranzisztor kinyit, és mintegy vezeték, összeköti az emittert és a kimenetet. Ekkor Vout nulla, azaz logikai 0. Ezt alogikai síkon megfogalmazva úgy írhatjuk le, hogy 0 bemenetre a kimenet 1, 1 bemenetre akimenet 0. Ez pedig egy inverter működését írja le, így az egyetlen tranzisztor inverterként (éserősítőként) működik.

Két tranzisztort sorba kötve (1. ábra (b)), bármelyik bemenet logikai 0 esetében a kimenet 1.A kimenet viszont 0, ha mindkét bemenet 1. Ez pontosan az ÉS logika inverz működése. Ez akéttranzisztoros felépítés így NAND (NEM ÉS) kapu. A párhuzamos kötés hasonlóanbelátható módon a NOR (NEM VAGY) logikai kaput alkotja (1. ábra (c)).

Az áramkörök és kapuk működését a bemenetek és kimenetek összes kombinációjánakmegadásával egyértelműen meghatározhatjuk. Ezeket az adatokat táblázatos formábanigazságtáblának hívjuk. A logikai kapuk jelöléseit és igazságtábláikat a következő ábrán (3.ábra) láthatjuk.

3. ábra Logikai kapuk jelölése és igazságtábláii


A kis kört a NOT, NAND és NOR kapuk kimeneti oldalán inverziós gömbnek hívjuk. Látszik,hogy az OR, NOR és AND, NAND kapuk között ez az inverz működés látszik a jelölésben is.

A NAND és NOR kapuk két tranzisztorból épülnek fel, míg az AND és OR kapuk háromból.Emiatt a gyártáskor a NAND és NOR kapukat preferálják.

A kapukból épülő áramkörök leírására alkalmas a Boole-algebra. Változói és függvényei csak0 és 1 értéket vehetnek fel. Az igazságtáblákkal való függvényleírás sok változó eseténkényelmetlen. Ennek egy tömör formája az algebrai forma, ahol azon bemenetekkombinációit tüntetjük fel, ahol a kimenetünk igaz lesz. A bemenetek ÉS és VAGYkapcsolatban állnak, melyeket szorzással (AB = A ÉS B) és összeadással (A+B = A VAGYB) jelölünk.

Az alábbi igazságtábla többségi függvényt valósít meg, ami akkor ad IGAZ kimenetet, ha abemenetei között többségben vannak az IGAZ értékek. Az igazságtábla tömör formája:

M = ABC + ABC + ABC + ABC (a felülvonás itt alulvonás, a szerkesztés miatt).

4. ábra Többségi függvény igazságtáblájai

Az áramkör (5. ábra) megrajzolásának lépései:

1. igazságtábla felírása,

2. komplemensek felrajzolása,

3. M = 1-ek esetében ÉS rajzolása,


4. ÉS-ekbe a bemeneteket kötni,

5. ÉS-ek kimenete VAGY-ba.

5. ábra Többségi függvény megvalósításai

A NAND és NOR kapuk teljesek, azaz bármely Boole-függvény kiszámítható velük. Gyakrankényelmesebb egy fajta kapuból építkezni, és gyártástechnikailag a kevesebb tranzisztorbólmegvalósítható NAND és NOR kapuk célra vezetőek. A NEM, ÉS, VAGY kapukmegvalósításai a következő ábrán szerepelnek (6. ábra).


6. ábra NEM, ÉS, VAGY kapuk megvalósításaii

A tervezésben és gyártásban a fő cél a kapuszám csökkentése. Ez azonnal árcsökkenést,lapkaméret-csökkenést, ill. fogyasztáscsökkenést jelent. Az egyszerűsítéskor ekvivalensáramköröket használunk. Akkor mondjuk két áramkörre, hogy ekvivalens, ha ugyanazonbemeneti kombinációra pontosan ugyanolyan kimenetet ad. Ekkor a két áramkör egymássallecserélhető. A Boole-algebra segítségével ilyen ekvivalens áramköröket kereshetünk, ill.cserélhetünk le, így azonos funkció mellett olcsóbb megoldásokat kapunk.

Az átalakításokhoz a Boole-algebra pár azonosságát használhatjuk fel (7. ábra).

7. ábra Boole-azonosságoki


A De-Morgan szabályból adódik, hogy VAGY és ÉS közötti átalakítást lehet véghezvinni (9.ábra).

Az alábbi egyszerű példában azt látni, hogy egy XOR (kizáró VAGY) megvalósítást milyenalternatív módokon tehetünk meg.

8. ábra XOR működés és megvalósítások i

9. ábra ÉS – VAGY átmeneteki


A mai áramköröket már nem kapuszinten alakítják ki, hanem modulárisan. Az egyes moduloktermészetesen kapukból, végső soron tranzisztorokból állnak, de valamilyen nagyobbegységként kezeljük őket.

Az integrált áramkör (Integrated Circuit – IC) kb. 5x5 mm-es szilíciumlap, néhány kapuval.Ez többnyire műanyag vagy kerámiatokozással, két él menti lábakkal szerelt (DIP – DualInline Package). A kapuszámtól függően osztályozzuk őket. Az 1–10 kapuszámú IC-k az SSI(Small Scale Integrated) osztályba tartoznak, a 10–100 kapuszámúak az MSI (Medium ScaleIntegrated), a 100–100 000 kapuszámúak LSI (Large Scale Integrated), a 100 000 felettikapuszámmal rendelkezőket pedig VLSI (Very Large Scale Integrated) osztályba soroljuk.Mivel az integráltság folyamatosan nő, újabb kategóriák jelennek meg. Az 1,5 millió kaputvagy többet tartalmazó osztály neve a VVLSI (Very Very Large Integrated) osztály. Az ábránegy SSI IC látható (10. ábra), 4 NAND kapuval.

10. ábra SSI IC 4 NAND kapuvali

Az IC-ken látható egy bevágás (notch), ami az orientációt teszi egyértelművé. A tápellátáshozszükséges lábak bekötéseit nem szoktuk külön jelölni, de a kivezetések természetesenszükségesek. Egy ilyen kapu jelterjedési, késleltetési ideje az 1–10 ns-es tartományba esik. Azegyes kapuk lábai az IC kivezetésein érhetőek el. Ha az osztályokban feljebb és feljebblépünk, könnyen beláthatjuk, hogy a százezres, milliós kapuszám összes lábkivezetését egyIC-n nem lehet megoldani (km-es méretek jönnének ki a kivezetések miatt). Ebből fakadóanaz IC-k fejlődésével egy természetes igény, hogy nagy legyen a kapu/láb arány, azaz sokhasznos funkciót valósítson meg az IC, kevés láb segítségével.


1.1. Kombinációs áramkörök

A kombinációs áramkörök olyan áramkörök, melyeknek többszörös bemeneteik, többszöröskimeneteik vannak, és a pillanatnyi bemenetek határozzák meg az aktuális kimeneteket, tehátnincs memóriaelem az áramkörben.

Egy ilyen áramkör a multiplexer. A multiplexernek n vezérlőbemenete van, egy adatkimeneteés 2n adatbemenete. A funkció pedig, hogy a vezérlőbemenetekkel kiválasztott bemenetet akimenetre tegyük. Ez a funkció például egy párhuzamos-soros konverzióhoz lehet szükséges.

11. ábra 8 bites multiplexer felépítése és sematikus ábrájai

A multiplexer példán (11. ábra) jól látható a felépítés. Az adatokhoz tartozó egyes ÉS kapukataz A, B, C bemenetekkel vezéreljük, mindig csak egy van nyitva. Az ÉS-ek kimeneteit egyVAGY kapu gyűjti össze. A multiplexer párja a demultiplexer, amely hasonlóan működik,egyetlen bemenetét a vezérlőbemenetek által kiválasztott kimenetére (D0-D7) teszi (12. ábra).


12. ábra 8 bites demultiplexeri

Sokszor a kész áramköröket bizonyos speciális kötésben más feladatokra is felhasználhatjuk.A multiplexerből pl. többségi függvényt is készíthetünk. A többségi függvény azt adja meg,hogy a bemenetein többségben vannak-e az 1-esek. Ha igen, a kimenete 1, ha nem, a kimenete0. A multiplexer adatbemeneteit fix logikai 0-ra vagy 1-re állíthatjuk attól függően, hogy avezérlőbemenetek kombinációjában az 1-esek vannak-e többségben. Innentől kezdve, ha ezteljesül, a kimeneten 1, ha nem, 0 jelenik meg (13. ábra).

13. ábra Multiplexerből többségi függvényi


Egy további, gyakran alkalmazott áramkör a dekódoló. Működését tekintve egy kapcsoló,amely az n-bites bemenete által kiválasztott 2n-kimenet közül aktivál egyet. Ez azt jelenti,hogy itt 1 lesz a kimenet, az összes többi kimeneten pedig 0. Ezt funkciókiválasztáshoz,memóriák esetében több chip együttes használatához és címzéséhez használják. Az alábbiábrán (14. ábra) egy 8-3 dekódoló látható. Észrevehető a hasonlóság a demultiplexerrel. Megis lehet építeni demultiplexerből, csak a demultiplexer bemenetét kell fix 1-re állítani.

14. ábra 8-3 dekódoló felépítései

Az összehasonlító vagy komparátor két bináris számot vizsgál, hogy megegyezőek-e. Ismerveaz XOR kapu igazságtábláját, beláthatjuk, hogy ideális a feladathoz (15. ábra). Bármelyikhelyi értéken meglévő eltérés 1-es kimenetet ad a VAGY-ba, ami a végén 0-ra fordul azinverziós gömbnek köszönhetően. Ha sehol nincs eltérés, minden XOR kimenet 0, így aVAGY kimenete is, ami 1-be fordul az inverziós gömb miatt, jelezve, hogy IGEN, a két számmegegyezik.


15. ábra 4 bites komparátor, XOR igazságtáblai

A fenti pár áramkörben észrevehető, hogy hasonlóképpen épülnek fel. Tetszőlegesfüggvények (igazságtáblázatok) építhetők úgy, hogy ÉS kapukkal logikai szorzatokatképzünk, majd ezek kimeneteit VAGY-oljuk. Ebből kiindulva létrehozható olyanprogramozható logikai tömb (PLA – Programable Logical Array), amelyben ezek akapcsolatok előre ki vannak alakítva minden bemeneti kombinációra. Ekkor mindenmindennel összeköttetésben van, aminek önmagában sok értelme nincs (pl. negált jel sajátmagával). Viszont az egyes összeköttetéseken található kis olvadó biztosítékok kiégetésévelmeghatározhatjuk, hogy mely összeköttetések maradjanak meg. Ezzel felprogramozhatjuk ahálózatunkat. Erre az alábbi ábrán (16. ábra) láthatunk példát, ahol egy 12 bemenetes (negáltbemenetekkel 24) és 6 kimenetes elrendezést vázolunk.


16. ábra 12-6-os PLA felépítései

Ez a módszer nagyon hasznos a prototípusgyártáskor, a fejlesztés fázisában. Amikor márkiforrott az elrendezés, nagy tételben érdemes legyártatni a hagyományos módszerrel azáramkört.

Aritmetikai áramkörök nélkül elképzelhetetlen a számítógép. Egy egyszerű funkciót lát el aléptető, azaz shifter (17. ábra). A bemenő adatbiteket a vezérlőbiten jelzett irányba egy bitteleltolva kapjuk. A bejövő oldalon nullák jelennek meg, a kimenő oldalon elveszítjük a kihullóbiteket.

17. ábra 8 bites shifteri


Egy számítógép egyik alapvető művelete az összeadás. Ezt félösszeadók (18. ábra)segítségével végzik el a gépek. A félösszeadó azért fél, mert nem kezeli az előző helyiértékről érkező átvitel (carry) bitet. Ehhez két félből egy teljes összeadót kell építenünk (19.ábra).

18. ábra Félösszeadó és működései

19. ábra Teljes összeadó és működései

A maradékos összeadáshoz ideális kapu az XOR. A maradékot egy ÉS kapuval kezelhetjük.A teljes összeadásnál az összeadás végén még a maradékot (carry in) is hozzá kell adni azeredményhez és újabb maradékot számolni (mindkét félösszeadóban nem lehet egyszerremaradék).


Több összeadót sorba kötve tetszőleges bitszélességű összeadót kaphatunk. Ez jól is működik,csak sajnos lassan. A maradékok kiszámításához helyi értékenként kell elvégezni azösszeadásokat, ami a növekvő bitszélességekkel egyre tovább tart. Ezt a felépítést hívjukátvitelt továbbterjesztő összeadónak – ripple carry adder). Egy lehetséges gyorsítási módszertaz ún. átvitelt kiválasztó összeadóban – carry select adder) láthatunk (20. ábra). Abitszélesség adott pontjától (érdemes mindig felezni) két, külön összeadó sort használunk,melyek fix 0-s és 1-es maradékokkal számolnak. Mire kiderül, hogy itt valóban mennyi lesz amaradék, már csak két verzióból kell választanunk, az eredmények már megvannak. Ezzelpárhuzamosíthatjuk a számolást.

20. ábra Átvitelt továbbterjesztő és átvitelt kiválasztó összeadóki

Az eddigi áramkörökből már építhetünk egy aritmetikai-logikai egységet (Arithmetic LogicUnit – ALU). Ez az egység végzi a legtöbb számítógépben a logikai és összeadásiműveleteket. Egy 1 bites ALU-ra nézünk példát, amiből persze tetszőleges bitszélességű ALUépíthető.

Az ALU-nk (21. ábra) F0, F1 vezérlőbemenetei egy dekóder segítségével adják meg, hogy anégy lehetséges műveletből melyiknek az eredménye jelenjen meg a kimeneten (output). Abemenet az A és B, illetve ezeket ENA és ENB-vel nullára állíthatjuk. A négy művelet ahárom logikai művelet (ÉS, VAGY, NEM), valamint az összeadás lehet. Az ALU-nk az Abemenetét INVA-val invertálni tudjuk. A maradékok be- (Carry in) és kimenete (Carry out) atöbb bites számok összeadásához lesz majd szükséges (több-bites ALU-építésnél).


21. ábra 1 bites ALU felépítései

Az 1 bites ALU-kból tetszőleges bitszélességű ALU-t építhetünk (22. ábra).

22. ábra 8 bites ALU sematikus ábrájai

Az első helyi érték INC bemenete a Carry in-re van bekötve. Ezzel egy tetszőleges számértékét lehet növelni eggyel, azaz inkrementálni lehet.

A digitális áramkörökben sokszor az események sorrendje kritikus, azaz kell egymechanizmus, ami biztosítja, hogy amikor szükséges egymást megelőzően, vagy épp pont


egyszerre történjenek meg események. A szinkronizálást az órával tehetjük meg. Az óra(clock) egy áramkör, mely pontosan meghatározott szélességű pulzusok sorozatát bocsátja ki,pontosan meghatározott időközönként. A két pulzus élei közötti idő a ciklusidő (clock cycletime). Egy 500 MHz-es sebesség 500 millió pulzust jelent másodpercenként. Itt a ciklusidő 2ns. Ha ennél finomabb felbontás kell, ezt is elő lehet állítani. Ha az órajelet saját magávaleltolva logikai ÉS kapcsolatba hozzuk, az alábbi ábrán szereplő aszimmetrikus órát kapjuk(23. ábra). Itt a 0 állapot időben tovább tart, mint a kis időkre beálló 1 állapot.

23. ábra Óra rekombinációja és a kapott aszimmetrikus óra (C) i

1.2. Szekvenciális áramkörök

Az áramkörök egy másik nagy csoportja a nem kombinációs áramkörök (szekvenciális,sorrendi áramkörök). Itt a kombinációs áramkörökkel ellentétben nemcsak az aktuálisbemenetektől, hanem előző állapotoktól is függ a kimenet, azaz van a hálózatnak belsőállapota, van memóriája. A memória fontos alkatrésze a számítógépeknek, a Neumann ésHarvard elvű gépeknek is fő alkatrésze. A digitális áramkörökben alapvetően bitállapotokatkell megjegyeznünk. 1 bit tárolásához használhatunk egy egyszerű eszközt, az SR-tárolót (SetReset Latch). Az alábbi példában ezt NOR kapukból fogjuk megvalósítani (24. ábra). A kétNOR kapu speciálisan van kötve, kimeneteik a másik kapu egyik bemenetét képzik. Ezzel kétbemenete lesz a kétkapus hálózatunknak. Az S (set) és az R (reset). A kimenetekből is kettőlesz, Q és Q (Q negált – az ASCII kódolás miatt sokszor #Q-ként írják).


24. ábra NOR kapukból épített SR-tároló stabil és instabil állapotaii

A beállítás után Q-ban kialakul az eredmény. Stabil állapotban ez a tápfeszültség megtartásáigvagy a lenullázásig (reset) meg is marad. Az instabil állapot egy lehetetlen állapot, amiből azáramkör kiugrana egy stabil állapotba.

Ha a tároló (Q) 1-es értéken van és S-et 1-re állítjuk, semmi nem történik, marad az érték 1.Ha Q 0-n volt és S-et 1-re állítjuk, Q értéke 1-re vált. Hasonlóképp, ha Q értéke 0 volt és R-relreseteljük a tárolót, semmi nem történik. Ha Q értéke 1 volt és resetelünk, Q 0-ba fordul (25.ábra).


25. ábra SR-tároló átállításai

Gyakran van arra szükség, hogy a tároló állapotváltozásai adott pillanatban történjenek. Afentiek kis módosításával időzített SR-tárolót (clocked SR latch) hozhatunk létre. Ebben akiépítésben S és R állásai csak akkor jutnak be a hálózatba, ha az óra magas állásban van (26.ábra). Az órabemenet jelét szokták még kapuzójelnek (strobe) hívni.

26. ábra Időzített SR-tárolói

Ha az S és R bemenetek egyszerre 1-es értéken vannak, beállítani és resetelni is akarjuk ahálózatot. Ekkor Q vagy Q beugrik 1-re, míg a másik 0 marad. A baj csak az, hogy ezt nemdeterminisztikusan teszik, azaz nem tudjuk, mi történik (27. ábra).


27. ábra S = R = 1 – nem determinisztikus viselkedési

Erre a problémára adhat megoldást, ha nem engedjük, hogy S és R értéke egyszerre legyen 1.Ezt egyszerűen elérhetjük. Egyetlen bemenetet kell definiálni, amely S-be megy, negáltjapedig R-be. Így S és R nem lehetnek egyformák (0 sem, bár ez nem okoz zavart). Ezzel amódszerrel kapjuk az időzített D-tárolót (28. ábra).

28. ábra Időzített D-tárolói

Amikor egy adott pillanatban (akár az óraidőktől eltérő pillanatban) akarunk mintát venni,(eltárolni) egy jelet, más megoldást kell választanunk. A billenőkör (flip-flop) élvezérelt, azazaz óra felfutó vagy lefutó élén tárolja el a bemeneten lévő értéket. Az órajel hossza nemlényeges. A következőkben pulzusgenerátoros flip-flop megoldást láthatunk. Apulzusgenerátor első ránézésre értelmetlennek tűnhet, mivel a bemenetet saját negáltjávalvezetjük egy ÉS kapuba. Ha figyelembe vesszük, hogy a negálás kis időkésleltetéssel történikmeg, kiderül, hogy pont ekkora időre tudunk egy pulzust létrehozni (29. ábra).


29. ábra (a) – pulzusgenerátor, (b) – jelértékeki

A pulzusgenerátort az óra helyére illesztve kapjuk a D-flip-flopot (30. ábra).

30. ábra D-flip-flopi

A D-flip-flopok (élvezérelt) és tárolók (óravezérelt) sematikus ábrái a következő ábrán (31.ábra) láthatóak.


31. ábra Óravezérelt tároló (óra 1-re és óra 0-ra ír) és D-flip-flopok (felfutó élre, lefutó élre ír) sematikusábráii

A valóságban persze nem 1-1 bitet szoktunk tárolni, hanem többet egyszerre (pl.memóriarekesz méretűt vagy regiszternyit). A következő két ábra egy független (2 D-flip-flop) és egy szinkronban működő (8 bitet egyszerre kezelő) elrendezést mutat.

32. ábra 2 független D-flip-flop a chipeni

A 8 bites elrendezésben a 11-es láb az óra, ez közös. Az 1-es láb is közös, ami mindent töröl.Több ilyen chip használatával nx8 bitnyi adatot tudunk egyszerre tárolni (1-es és 11-eslábakat össze kell kötni a szinkron miatt).


33. ábra Nyolcbites D-flip-flop a chipeni

Az eddigi példák megmutatták, milyen lehetőségünk van bitek tárolására. Korábban azonbantettünk utalást arra, hogy a lapkák bonyolultságának és funkcióinak növekedésével alábszámok növekedése nem kívánt hatás. Ezt a memóriák esetében is, ahol a kapacitásoknövelése a cél, kijelenthetjük. Még közös órajel és reset-lábak esetén is bitenként két lábszükséges a használathoz, ami a mai memóriakapacitásokat tekintve milliárdos lábszámotadna. Nyilvánvalóan lehetetlen ennek a megoldása, más módszerrel kell dolgozni. Az ötlet aszavak címezhetősége, azaz a pár bitnyi adatot, ami a bemeneten megjelenik, valamilyen címmegadásával írhatjuk célzottan a helyére a memóriában. Ez az a koncepció, amit a memóriákkapcsán említettünk korábban: az adott címen érjük el a rekeszt, amit írni vagy olvasniakarunk. A következő egy ilyen módon működő, 4 címből és 3 bites rekeszekből állómemóriaszervezést mutat (34. ábra).


34. ábra 4 darab 3 bites szóból álló memóriai

A CS (Chip Select) bemenet a lapkaválasztáshoz kell. Ha ez aktív, akkor működik ez a chip.Ebből a felépítésből többet is lehet párhuzamosan használni, amelyik chip CS vonala aktív(pl. egy dekódoló választhat, aminek az inputjai az eredetileg megadott teljes memóriacímegyes bitjei lehetnek), az tárol. Ha CS nem aktív, egyik tároló sem kap órát, így nem lehet írnibele, bármi is jelenik meg az inputon. Az RD (ReaD) bemenet 1-es állapotban olvasást, 0-sállapotban írást fog jelenteni. Belátható, hogy CS ÉS RD együttes aktiválásánál van lehetőségórajelet adni. Az OE (Output Enable) bemeneti érték engedélyezi a kimenetet, e nélkül nemolvasható a tartalom. A három bemeneti vonal (Input I0,I1,I2) a három bemenő adatvonal, azA0,A1 vonalak (address) a címvonalak, amelyek egy dekódoló segítségével megadják, melyikrekeszt (sort) akarjuk írni vagy olvasni. A fenti vezérlőbemenetekkel együtt a címbemenetpontosan egy write gate-et (író kaput) fog aktiválni. A három kimenet (output): O0,O1,O2 azadott rekesz adatait jeleníti meg, ha olvasás történik és OE engedélyezett. Olvasáskor a címek


által aktivált dekódersor és a Q kimenetek kerülnek ÉS kapukra, melyeket minden sorralVAGY kapuk gyűjtenek össze és tesznek a kimenetre. További lábcsökkentési lehetőség, ha abemeneteket (I-k) és a kimeneteket (O-k) közös vonalakra teszik. Az OE által vezérelt kisháromszögek nem invertáló pufferek. Ezek aktív állapotban rövidzárként, nem aktiváltállapotban szakadásként működnek.

A fenti 4x3-as elrendezést könnyen bővíthetjük pl. 4x8-as elrendezésre, csak a megfelelőtároló oszlopokat kell berajzolni. A címzés marad, hiszen ahogy azt a korábbiakbantárgyaltuk, a címszélesség és a rekeszek nagysága független. A rekeszméret bármekkora lehet(fenti példánkban 3 bites volt), a címszélességet viszont kettő hatványának érdemes választania legnagyobb hatékonyság kedvéért. Az áramköri technológia nagyon alkalmas arra, hogyismétlődő struktúrákat állítson elő. A kétdimenziós minták felfedezhetők a fenti kialakításbanis.

A memórialapkák fejlesztési iránya a nagyobb kapacitások felé halad. Ez akár a sebességkárára is megy. Az alábbi ábrán két memóriaszervezési példát láthatunk (35. ábra). Azegyikben a fentihez hasonlóan 8 bites rekeszeket címzünk sorrendben. A 19 bitesadatlábakkal 219 címet, azaz 512 K-nyi címet tudunk megadni. Ez 512 K x 8 bitnyi, 4 Mbit-nyi adat. Az elrendezésben 19 + 8 + 3 = 30 lábat használunk. A másik elrendezésben 2048 x2048-as mátrixot képzeljünk el. Itt sorokat és oszlopokat címzünk meg, két lépésben. A RAS(Row Address Strobe) a sorcím beadását jelöli, a CAS (Collumn Address Strobe) pedig azoszlopcím beadását. Az így címzett cellában 1 bit adat van, ezt kapjuk (vagy írjuk) a D (Data)vonalon keresztül. Ebben az elrendezésben 11 + 1 + 5 = 17 lábat használunk. Igaz, a 8 bitnyiadat eléréséhez 8 alkalommal kell 2 címet megadnunk. Ez némileg gyorsítható azzal, hogy asorcím után egysorozatnyi oszlopcímet fogadunk. A sebesség így is kisebb, mint a fentiesetben. A kapacitások növekedésével mégis ilyen lépésekre kényszerülünk a lábszámkezelhető mennyiségben tartása érdekében.


35. ábra 4 Mbites memóriáki

Az 1 bites olvasás a nagy memóriakapacitások mellett kezd kényelmetlenné válni, így sokgyártó 1, 4, 8, 16 vagy magasabb bitszélességű memórialapkát gyárt.

A következő ábra (36. ábra) két 512 Mbit-es lapkát mutat, melyek 16 bites és 4 bitesrekeszekkel dolgoznak.

36. ábra 512 Mbites memóriáki

Mindkét verzión 128Mbites modulok vannak, ezeket a két modulválasztó vonallal (Bank 0,Bank 1) lehet kiválasztani. Az első verzióban 32 M x 16-os kialakítást látunk, azaz a


címvonalakból 13-at a RAS, 10-et a CAS jelhez használva 223 8 M címet adhatunk megmindegyik modulon (213+10+2 cím). Ezen címek mindegyike (32 M) egy 16-os rekeszt címez.A másik kialakításban minden hasonlóan megy, csak a CAS jelekhez nem 10, hanem 12vonalat használunk. Ez végül 27 címvonalat jelent, amiből kijön a 227, azaz 128 M cím,egyenként 4 bites rekeszeket címezve. A végső kapacitás ugyanaz, 512 Mbitnyi memória.

1.3. CPU lapkák

A CPU-k a számítógépeink fő komponensei. A modern CPU-k egy lapkán helyezkednek el éslábkészletükön keresztül tartják a kapcsolatot a külvilággal. A lábaikat három fő csoportbaoszthatjuk:

cím,

adat,

vezérlés.

Az egyes csoportok lábai párhuzamos vonalakon, síneken kapcsolódnak a többi egység(memória, I/O stb.) hasonló lábaihoz. A síneken való kommunikációra példa lehet egyutasítás betöltése:

1. CPU sínhasználati jogot kér.

2. Utasítás címét a címlábakra teszi.

3. Vezérlővonalakon értesíti a memóriát, hogy olvasni akar.

4. Memória a kapott címről kiolvassa az adatot és az adatvonalakra teszi.

5. Memória jelez a CPU-nak, hogy az adatot feltette.

6. CPU olvassa az adatot, végrehajtja az utasítást.

A cím- és adatlábak száma lényeges kérdés. Ahány láb van, annyi bites címzést, illetveadatátvitelt lehet megvalósítani. Ha m vonalas a címbusz, 2m rekeszt címezhetünk meg. Hanagyobb adatot vagy címtartományt akarunk olvasni, az is megoldható persze, de többlépésben.

A CPU-k egyéb lábai az óra, a tápellátás, földelés feladatokhoz rendeltek.

A vezérlőlábak egyik feladata a sínvezérlés (bus control). Itt dől el, hogy mi történik a sínen.Ehhez tartoznak a sínütemezéssel kapcsolatos lábak. Egy további lábcsoport amegszakításokkal foglalkozik. A lassabb eszközök ezen keresztül kérik a CPU-t, hogy amikor


adatot tudnak szolgáltatni, a CPU foglalkozzon velük. Addig a CPU egyéb hasznos feladatotcsinál.

37. ábra CPU lábcsoportoki

Külön lábcsoport foglalkozik a segédprocesszorokkal. Amikor több processzor van arendszerben, kommunikálniuk kell egymással. Vannak állapotinformációs lábak is, illetvekompatibilitás miatt megtartott lábcsoportok.

1.4. Számítógépes sínek

A sínekről a számítógépek kapcsán általában kevés szó esik, pedig fontos építőelemei agépeknek. A sínek (bus) a különböző eszközök közötti elektronikus pályák. Sebességükön ésparamétereiken múlik a kommunikáció, így a számítógép sebessége is. A CPU-n belülibuszon az ALU és a CPU-n belüli további komponensek kommunikálnak (regiszterek,vezérlőegység). A CPU-n kívüli buszokon a számítógép egységeivel zajlik kommunikáció(I/O eszközök, memória).

A korai gépeknek egy külső sínje volt, a rendszersín (system bus). Ez tipikusan 50–100párhuzamos rézvezeték volt, az alaplapra integrálva, szabvány csatlakozási lehetőségekkel. Amodern számítógépekben legalább 2 busz van (38. ábra):

CPU – memória közötti speciális busz

CPU – I/O közötti busz (néha buszok).


38. ábra CPU-n belüli és kívüli síneki

A sínekre vonatkozó szabályok a sínprotokollok (bus protocol). Ezek írják le a mechanikaiszabványokat (méretek, csatlakozók) és az elektronikus definíciókat (áramok, feszültségek,időzítés). A számítástechnika történetében számos sínrendszer megfordult már, ha csak a PC-ket tekintjük, ott is több sín váltotta egymást, illetve futott párhuzamosan (pl. ISA, PCI, AGP,PCIe). Sajnos a sínrendszerek többsége nem kompatibilis egymással és nem valószínű, hogy1-2 sínre szűkül a kínálat a jövőben. A síneken lévő eszközök alapvetően kétféle módonviselkedhetnek:

aktív (mester – master) módban, amikor átvitelt tud kezdeményezni,

passzív (szolga – slave) módban, amikor csak kiszolgálni képes a kéréseket.

Az eszközök többsége mindkét módon tud viselkedni, például egy CPU és lemezvezérlőközött a CPU mesterként kérhet adatot a vezérlőtől, de a memória és lemezvezérlő között azutóbbi kezdeményezhet írást a memóriába. A memória soha nem lehet mester. Az egyesegységek, pl. a jelerősítés miatt, sínvezérlőn (bus driver) kapcsolódnak a sínhez. A szolgáksínvevőn (bus receiver), a mester-szolgák sín adóvevőn (bus transceiver) kapcsolódnak. Acsatlakozás fizikailag háromállapotú eszközökkel (tri-state device) történik meg. Ezeket azeszközöket szakadásnak és rövidzárnak tudjuk állítani, így a buszrendszerről leválaszthatóakaz épp nem aktív egységek. A másik csatlakozási megoldás a nyitott kollektoros (opencollector) kimeneti kapcsolás, ahol huzalozott vagy kapcsolatban vannak az egyes eszközökmegfelelő lábai. (Ha csak egy eszköz beszél, nincs probléma.)

A sínszélesség megadja, hány jelet tudunk párhuzamosan továbbítani. A szélesség növeléseazonban költségekkel jár, mert több hely kell, és nagyobb csatlakozókat kell kialakítani. Ha


viszont csak a költségek minimalizálására törekszünk, rövidlátóan tervezhetünk, ami megintcsak a költségek növekedését okozhatja. Erre egy példa az Intel PC-kbe szánt sínrendszerénektörténete (39. ábra).

39. ábra Intel sínrendszerek bitszélességének alakulása i

Az IBM PC-kben használt 8088-as processzoros gépek sínrendszere 20 bites volt. Acímezhető 1 MB memória kevésnek bizonyult, így a 286-os architektúrában +4 bittelmegnövelték a címszélességet (ami 16x-os szorzót jelent). Hamar kiderült azonban, hogy a 16MB-nyi címezhető memória is kevés, így 32 bitesre növelték a címszélességet a 386-osarchitektúrában. A kompatibilitás miatt azonban a régi szabványt csak bővíteni lehetett,teljesen újratervezni nem.

Digitális rendszereknél a sávszélességen a maximális információátvitelt érthetjük. Asávszélesség növelését alapvetően két módon érhetjük el. Az egyik, hogy csökkentjük a sínciklusidejét. Ez felveti a kompatibilitás problémáját, illetve a sínaszimmetriát (skew). Ezutóbbi abból adódik, hogy a párhuzamos vonalakon a késleltetések különbözőek lehetnek. Eza nagy átviteli frekvenciák esetén már olyan mértékű lehet, hogy nem eldönthető, egy jellemaradt vagy túl korán érkezett-e a többiekhez képest. Egy másik megoldás az adatszélességnövelése. Ez ismét kompatibilitási problémákat vethet fel, illetve növeli a költségeket.

Egy kompromisszumos megoldás lehet a sokszorozott (multiplexelt) sín. Ekkor az adat- éscímvonalakat együtt használjuk. Először minden vonalon címet, majd minden vonalon adatotküldünk. A szükséges sínszélesség növelhető extra vonalak hozzáadása nélkül. A sebességviszont csökkenhet, illetve maga a sínprotokoll bonyolultabb lehet.


A síneket az eszközök közösen használják a CPU-val együtt. Ha egyszerre többen akarjákhasználni, el kell dönteni, kié az elsőbbség. Ezt a sínütemező lapka teszi meg. Általában azI/O eszközök előnyt élveznek, mert ezeket nagyon sok időbe kerül újra kiolvasni (mozgóalkatrészek, felpörgetés). Ha tehát szabad a sín és a CPU használni kezdi, de közben egy I/Oeszköz engedélyt kér, megkapja. Ez a cikluslopás. A nagyobb átviteli igények és bővülőeszközök mellett a sínrendszerekkel szemben támasztott követelmények is nőttek. Zártrendszerben viszonylag szabad keze van a fejlesztőknek, teljesen új megoldásokat ishozhatnak. Egy PC kategóriájú gépben azonban nagyon fontos szempont a kompatibilitásmegőrzése. A vásárlók tovább akarják használni az eszközeiket, amiket megvettek (kiegészítőkártyák pl.). A gyártók is megbízható környezetet szeretnének, így senkinek nem érdeke,hogy túl gyakran gyökeresen változzanak a sínrendszerek. Fejlődni azonban kell. Egyalkalmazott megoldás az lehet, hogy a régi és új rendszereket párhuzamosan, egymás melletthasználjuk és az igények monitorozása mellett folyamatosan kivezetjük a régi megoldásokat.Erre jó példa volt a PC-k esetében az ISA mellett megjelenő EISA, majd az ISA eltűnése és aPCI megjelenése, ami mellől lassan kikopott az EISA és megjelent a PCIe.

40. ábra Korai PCI és ISA buszrendszeri

A fenti ábrán (40. ábra) egy PCI buszrendszerre kapcsolt lassabb, ISA buszrendszertláthatunk. A kapcsolatot az ISA-híd (ISA bridge) adja.

Az IBM PC sín a 8088-as gépek de facto szabványa volt. 62 jelvezetékén 20 cím, 8 adat ésvezérlővonalak futottak.


41. ábra IBM PC sín és bővítés alaplaponi

A 286-os megjelenésekor a busz bitszélességét bővítették. A kompatibilitás megőrzése miatt ahagyományos élcsatlakozók mögé került egy rövid élcsatlakozó-sor, az extracsatlakozásokkal. Így a régi és új kártyák is bekerülhettek ugyanarra a csatlakozásra (41.ábra).

Az IBM a PS/2 új sorozatával új sínrendszert is kidolgozott, MCA (MicroChannelArchitecture) néven, melyet erősen levédett. Ez hibás döntésnek bizonyult, az ipar jó részeelfordult a szabványtól és egy másikat támogatott, amely az ISA (Industrial StandardArchitecture) lett. Ez egy 8,33 MHz-es, a régi eszközökkel kompatibilis sínrendszer volt.Később ez EISA (Extended ISA) néven újult meg. Utóbbi egy 32 bites verzió volt (16 2032).

A síneket időzítésük alapján két nagy kategóriába soroljuk. Az első a szinkron sínek(synchronous bus), a második pedig az aszinkron (asynchronous bus) sínek. A szinkron sínekegy vezetékén kristályoszcillátor négyszögjele halad. Egy jelet sínciklusnak (bus cycle)hívunk. Minden síntevékenység egész számú sínciklusig tart. Az aszinkron sínek sínciklusaibármekkorák lehetnek, még eszközönként is eltérhetnek.

Egy szinkron sín órajele legyen 100 MHz. Ekkor a sínciklus 10 ns (a PCI sín 33, ill. 66 MHz-es). A memóriaolvasás 15 ns-ig tart. Ebben az esetben a memóriaolvasás menetét a következőábrán láthatjuk (42. ábra).


42. ábra Szinkron sín memóriaolvasásának időzítései

T1 órajel kezdete a felfutó élen van. T1 idő alatt a CPU a címvezetékre felteszi az olvasandómemória címét (TAD idő). Amint fent van a cím, a CPU beállítja a MREQ# jelet, jelezve, hogya memória felé akar kommunikálni. Az RD# jel beállításával (alacsonyra) megadja, hogyolvasni akar. Eddig újabb TML idő telik el. Mivel a memóriának 15 ns idő kell az adatszolgáltatásához, de egy ciklus csak 10 ns hosszú, a protokoll szerint a memória mindenképpWAIT jelet küld a CPU-nak. Ezzel azt jelzi, hogy a CPU ne számítson a következő ciklusvégéig adatra, csinálhat mást, ha akar. Amint megvan az adat, a WAIT vezetéket negálja amemória, és felteszi az adatot az adatvezetékre. A CPU a WAIT negálására reagálva a T3lefutó élén beteszi az adatokat egy regiszterébe, majd negálja az MREQ# és RD# jeleket,alapállapotba hozva a kommunikációt. A protokoll előre rögzíti, mi mennyi ideig tart, ezeketaz időket eleve ki kell várni. Ha valami tovább tart, egész számú ciklusokkal hosszabbodik aművelet. Az egész tevékenység is egész számú ciklusig tarthat, hiába végződne pl. 2,3 ciklusalatt el valami, erre akkor 3 ciklusidőt kell szánni. A protokoll várakozásait a leglassabbeszközhöz kell igazítani. A rögzített várakozások miatt hiába gyorsulnak fel az eszközök, aprotokoll változásáig marad a sebesség.

Erre megoldást nyújt az aszinkron sín. Ebben az esetben nincs órajel, nincsenek kötelezővárakozások, nincs is WAIT jel. Szinkron óra híján azonban szükség van két extra jelre: azMSYN#-re (kérés – master sync.) és a SSYN#-re (kész – slave sync.). Amikor SSYN# negált,akkor jöhet újabb kérés. Ebben a rendszerben gyors és lassú eszközök a saját sebességükön


dolgozhatnak, ha az eszközök javulnak, a sebesség is nő. A fenti memóriaolvasási példát akövetkező ábra mutatja (43. ábra).

43. ábra Memóriaolvasás menete aszinkron sínen i

A sínmester felteszi a címet a címsínre, majd beállítja az MREQ#, RD# végül MSYN#jeleket. Erre a szolga reagál, a kapott címről kiolvassa az adatot, felteszi az adatsínre ésbeállítja az SSYN# jelet. Erre a mester beolvassa az adatokat, majd törli a címvezetéket, ésnegálja az MREQ#, RD# és MSYN# jeleket. MSYN# negálására a szolga SSYN# negálásávalreagál, így alapállapotba kerül minden. A mester és szolga jelek fenti felhasználását teljeskézfogásnak (full handshake) nevezzük. Ez független az időzítésektől, minden eseményt egyelőző vált ki, nem az órajel.

A szinkron sínrendszereket egyszerűbben és olcsóbban lehet kiépíteni, így azok jobbanelterjedtek. Ha több eszköz verseng a sínért, valamilyen módon el kell dönteni, kihasználhassa, azaz sínütemező (bus arbitration) mechanizmusra van szükség. Ez két nagykategóriára bontható. Az első a centralizált, ahol egy dedikált ütemező hozza meg a döntést,illetve decentralizált, ahol a döntés közös elhatározás alapján születik meg, nincs dedikáltütemező. Az egyik legegyszerűbb centralizált sínütemező mechanizmus az egyszintű láncolt(daisy chaining). Ez az ütemezés egyszintű, az eszközök sorba vannak kötve az ütemezőmellett. Két vonal él, a kérés vonal, amelyen az eszközök jelzik az ütemezőnek, hogyengedélyt kérnek, és az engedély vonal, amelyen az ütemező sínhasználati jogot küld. Azengedély végigmegy a sorba fűzött eszközökön, és az első olyan eszköznél, amely sínt kért,fennakad. Ez az eszköz elkezdi a sínhasználatot, a későbbi eszközök pedig hoppon maradnak(44. ábra).


44. ábra Egyszintű centralizált láncolt sínütemezés

Ha túl sok eszközünk van felfűzve, az ütemezőtől távoli eszközök szinte soha nem jutnakszóhoz. Az ütemezést finomítani lehet, ha prioritási szinteket vezetünk be a kérő és engedélyvonalakon. Erre példa a következő ütemezés, a többszintű – prioritásos láncolt (daisychaining) ütemezés. A működés hasonló, a kéréseket és engedélyvonalakat az ütemező aprioritások szerint kezeli. Egy fizikailag távolabbi, de magasabb prioritású eszköz előbbkaphatja meg a sínhasználat jogát (44. ábra).

45. ábra Többszintű centralizált, láncolt ütemezési

A láncolt ütemezésnél egy további nyugtavezetékkel az eszközök jelezhetik, hogy megkaptákaz engedélyt. Ekkor, párhuzamosan a kommunikáció ideje alatt, el lehet dönteni a következősínhasználati jogot. Az állandó versenyben a CPU gyakran vetekedik a priorizált I/Oeszközökkel. A CPU-t érdemes kivenni ebből a versenyből, mégpedig úgy, hogy saját buszavan a memória felé, míg a többi eszköz a hagyományos buszrendszeren kommunikál. Afejlődés az unibusztól az eszközönkénti dedikált kommunikáció irányába halad.

A decentralizált sínütemezésnek is több megoldása van. Az egyik, amikor az eszközök magukdöntik el, kié lehet a sín. Tegyük fel, hogy 16 eszközt illeszthetünk a rendszerbe. Ekkor a 16prioritásos kérésvezeték minden eszközhöz be van kötve, azaz mindenki látja a többiekkéréseit. Ismerve a saját prioritását, minden eszköz eldöntheti, hogy van-e nagyobb prioritású


kérés a vonalakon, mint a sajátja. Ha igen, nem használhatja a sínt. Ha nincs, akkor ezé azeszközé a sínhasználat joga. Itt az extra vezetékekkel megspórolhatjuk a sínütemezőt. Egymásik megoldás lehet, amikor a láncolt ütemezéshez hasonló felállásban (46. ábra) azütemező helyett az óra van az engedélyvonalra kötve. Ekkor engedélyek sorozata megy végigaz eszközökön, az engedélyvonalon. Amelyik eszköznek szüksége van a sínre, ezt a vonalatmegszakítja és beállítja a foglalt vonalat (ez egy extra vonal a láncolt elrendezéshez képest).Ebből a többiek tudni fogják, hogy nem beszélhetnek (mivel vagy nem kaptak azengedélyvonalon jelet, vagy kaptak, de tovább engedték). Csupán egyetlen eszköz lesz,amelyik kapott engedélyt, de nem engedte tovább. Ez az eszköz használhatja a sínt.

46. ábra Decentralizált láncolt sínütemezés

A fenti sínciklusokban adatokat kért vagy küldött a mester a szolgának. Egyébsíntevékenységek is léteznek, pl.:

Blokkos átvitel.

Versenyhelyzet-kezelés (pl. több CPU-s rendszerben adatelérés).

Megszakítás (lassú I/O eszközök végeztek pl. az olvasással, kezelni kell őket).

A blokkos átvitelt (47. ábra) már említettük korábban, a cache kapcsán. Ez az átvitelegybefüggő adatok esetén gyorsabb, mint az egyes szavak egyenkénti átvitele. Emiatt jó, hanem egyesével érjük el a memóriát. A korábbi memóriaolvasási időzítési példához hasonlóantörténik az adatátvitel. Megjelenik egy BLOCK# vezérlővonal, amellyel jelezhetjük, hogyblokkos átvitel következik. Az olvasás első fázisában az adatvonalra feltesszük adarabszámot, hogy hány szó kerüljön a blokkba, és az eddigiek mellett beállítjuk a BLOCK#vonalat is. Ebből a memória tudni fogja, hogy a kapott címtől hány szót küldjönsorfolytonosan a CPU felé. Az első szó olvasása ugyanúgy 3 időegységbe kerül, mintkorábban, de a blokk további szavai már 1-1 időegység múlva érkeznek. Ezzel nagyadatmennyiségek esetén közel háomszoro gyorsulás érhető el.


47. ábra Memóriaolvasás blokkos átvitelleli

A kölcsönös kizárásra akkor van szükség, amikor pl. több CPU van a rendszerben és ugyanaztaz adatot akarják elérni. Ha ezt nem szabályozzuk, nem lehet tudni, ki, mit módosított azadaton, előbb vagy utóbb adatvesztés, hiba történik. A felügyeletre bevezethetünk mindenadatblokkhoz egy bool változót, amit az a CPU, amelyik dolgozni akar az adattal, megvizsgál,és ha 0, akkor 1-re állít. Ekkor ez a CPU dolgozhat az adattal és a többi vizsgálatnál a változó1-es értéke miatt a többi CPU nem nyúl az adathoz. Ez jól hangzik, de mi van, ha pontosanegyszerre olvassa be a két CPU az adott változót? Mindketten 0-t látnak, 1-re állítják, éselkezdenek egyszerre dolgozni ugyanazon adattal. Ez nem megengedhető. Ilyen esetekbenmár a változó olvasását is kizárólagosan kell biztosítani, azaz, ha kérés érkezik a változóállapotának olvasására, akkor további olvasásokat sem szabad engedni. Az „olvasás–módosítás–visszaírás” sínműveletnek nem megbonthatónak kell lennie.

A megszakítás akkor következik be, ha egy lassú (többnyire I/O) eszközre a CPU nem vár,hanem más értelmes feladattal foglalkozik, majd a lassú eszköz elkészül és kéri a CPU-t, hogyszakítsa meg aktuális tevékenységét és térjen vissza a lassú eszköz kezelésére. Ezt a CPUmegtagadhatja (várakoztatva a lassú eszközt), illetve több megszakítási kérelmet prioritásokalapján kezelhet (ütemezési feladat). Ezt a kommunikációt is a síneken kell bonyolítani. Azidőkritikus eszközöknek (ahol a mechanikai működésből adódóan nagyon nagy időköltséggeljárhat egy újraolvasás) többnyire magasabb prioritást szoktak adni.

Az IBM PC és ezt követő PC-rendszereken elterjedt megszakítás-vezérlő lapka az Intel8259A (48. ábra). Bemeneteire 8 I/O lapka kapcsolható. A bejövő megszakításkérések ezekenérkeznek (IR0-IR7). A lapka az INT vonalán kér megszakítást a CPU-tól, amely az INTAvonalon jelzi a hajlandóságát. A megfelelő, kiválasztott eszközhöz tartozó pointer alapján a


megszakításvektor táblából lefut a megfelelő kód – azaz a CPU lekezeli a megszakítást kérőeszközt. A lapka 8 bemenetére újabb megszakításvezérlők kerülhetnek, ezzel akár 64 eszközmegszakításait lehet kezelni.

48. ábra Intel 8259A megszakításvezérlő kapcsolata a CPU-val és eszközökkeli

1.5. Pentium 4 CPU lapka

Az Intel P4-es processzora a korai 8088-as processzor egyenes ági leszármazottja. Míg a8088-as processzor 29000 tranzisztorból állt, addig a P4-ben 55 millió tranzisztor van(Northwood). Egy mai Core i7 Haswell 4 magos processzorban 1,4 milliárd tranzisztor vanintegrálva, az IBM 12 magos POWER8 processzorában 4,2 milliárd, egy IBM z13 StorageController chipen pedig 7,1 milliárd tranzisztor van.

A P4-es processzor teljesen kompatibilis a 8088-cal, így ugyanazon bináris programokfuttathatók a P4-en is. Szoftver szempontból 32 bites gép, hardver szempontból részben 64bites (memóriaolvasások/írások 64 bitesek, de ezt a programozói oldalról nem lehet látni).

A P4 mikroarchitektúrája más, mint az előd processzoroknak. Ennek a mikroarchitektúrának aneve: NetBurst. A csővezetékben 2 ALU van, mindkettő az órajel kétszeresével megy, így 1ciklusban két műveletet tud végrehajtani. A P4 hiperszálas, azaz két regiszterkészlete van, ésközöttük nagyon gyorsan tud váltani (kontextusváltás), így két szál virtuálisan egyszerrehajtódik végre. A P4 szuperskaláris számítógép, mert 2 utasítást tud párhuzamosanvégrehajtani. A P4-es széria processzorai 2 vagy 3 szintű gyorsítótárral rendelkeznek. Az elsőszintű (L1), 8KB méretű cache mikroutasításokra konvertált utasításokat tartalmaz, azaz adekódolás része már készen van ezen utasításoknak. A második szintű (L2) cache maximum


256KB – 1MB méretű és byte-szintű utasításokat és adatot tartalmazhat. A P4 ExtremeEdition példányok L3 cache-sel is rendelkeztek, melyek 2 MB nagyságúak voltak.

A többszintű cache használata multiprocesszoros környezetben újabb problémát vet fel. Ha azegyik processzor egy memóriaterületet akar elérni, ami a másik processzor cache-ben van,nem érvényes adatot kap az első, hiszen az már módosulhatott a másik processzor cache-ben.Erre a megoldás a szimatolás (snooping), ami vizsgálja a memóriahivatkozásokat, és ha olyancímre történik hivatkozás, ami valahol cache-ben van, azt a cache-elt értéket adja, mielőtt amemóriából olvasnánk be elavult értéket. A P4-es architektúra két sínt használ. Az egyik aCPU-memória közötti memóriasín, a másik pedig a CPU és I/O eszközök közötti PCI-sín.Ahogy azt korábban is láttuk, a rendszersínhez egy korábbi, hagyományos sín (legacy bus) iskapcsolódhat, hogy a régebbi eszközökkel megmaradjon a kompatibilitás. A P4 lapkának 478lába van. Ebből

85 az energiaellátás,

180 földelés (zaj mérséklése miatt),

a többi pedig adat, cím és vezérlőjelek számára van fenntartva.

A 26 x 26 lábnyi tömbből belül hiányzik 14 x 14, illetve az egyik sarokban 2 láb (49. ábra).így a CPU-t csak egyféleképpen lehet behelyezni a foglalatba. A P4 fogyasztása elég magas,63–82 W között mozog. Ez nagy hőtermelést is jelent, a P4-es CPU-k aktív hűtést igényeltek.A fogyasztás mérséklése miatt a P4-ek öt fokozatban tudnak készenléti állapotba váltani.

49. ábra P4-es CPU lábelrendezései


A P4-es logikai lábkiosztása követi a korábban bemutatott általános CPU lábkiosztásokfelépítését. Az ábrán (50. ábra) a párhuzamos vonalak egy áthúzott vonallal és a vonalakszámát jelentő számmal szerepelnek. Az ASCII kódolás miatt bevett szokás a negált jeleket #-el jelölni felülvonás helyett (vagy alulvonással, amit sok szerkesztő támogat).

50. ábra P4 lábcsoportjaii

Az egyes csoportok balról, fentről indulva, a sínütemezés (bus arbitration), amely asínhasználat kéréséhez kell. A #BR0 (Bus Request, a nyíl helyesen két irányba mutat) vonal anormál prioritású sínkérés, a #BPRI (Bus Priority Request) a magas prioritású vonal lehetővéteszi, hogy a normál kérésekhez képest magasabb prioritású igényt támasszon az eszköz.Amíg ez a vonal beállított, a normál kéréseket nem szolgálja ki, hacsak nem egy futó#LOCK-olt kéréshez tartoznak. A #LOCK vonal lehetővé teszi, hogy több ciklusra foglalja aCPU a buszt. Amint a CPU megszerezte a sínhasználat jogát, a kérés (Request) csoportsegítségével. Az #A vonalak a címvonalak (36 bit, alsó 3 bit fix nulla, így 33 vonalra vanszükség), az #ADS beáll, ha a cím a címbuszon van (gondoljunk a korábbi memóriaolvasásospéldára a sínidőzítéseknél). A #REQ vonalegyüttes mondja meg a sínciklus típusát, azaz,hogy mit szeretnénk csinálni (pl. szavas olvasás, blokkos írás stb.). A kétvonalas paritás pedig


védi az #A (cím) és #REQ (tevékenység) jeleket. A hiba (Error) öt vonalán különböző hibákjelzése történik (lebegőpontos, belső, hardver, egyéb). A válaszcsoport (Response) vonalaintud a szolga a mester felé visszajelzéseket küldeni. Az RS# státuszkódot, a TRDY#adatfogadásra való készséget jelez. A BNR# vonallal a következő busztranzakciót tilthatjuk.A vonalak paritásinformációit a Parity# vonal viszi. Az utolsó nagy csoport az adat (data)csoport, amelynek vonalai az adatátvitelt szolgálják. A D# adatvonal 64 bites, azaz 8 byte-osadatokat tud egyszerre átvinni. DRDY#jelzi, hogy az adatok a sínen vannak, DBSY# jelzi,hogy a sín foglalt. Az adatátvitelt is védik paritásbitek. További pár vonalon pedig azadatértékek jelentését és pár egyéb paramétert kommunikálhatunk. A RESET# vonalon leheta CPU-t alapállapotba helyezni. További vonalakon a megszakításkérelmek, az energiaellátásfelügyelete, hőmérséklet felügyelete, órajel, diagnosztikai adatok, inicializálás, szimatolás(snooping) és egyéb tevékenységek valósulnak meg. A P4-es processzor tud 8088-as módbanműködni, ekkor a megszakításokat is ugyanúgy kezeli, de az újabb APIC (AdvancedProgrammable Interrrupt Controller) megszakításrendszert is használhatja. A P4-esprocesszor különböző tápfeszültségekről is képes működni, ehhez többféle lábat használ. Ahőmérséklet felügyelete egy fontos tevékenység, a P4-es CPU-k 3 GHz felett is üzemeltek,amely komoly hődisszipációval járt. A nem megfelelő hűtés túlmelegedést és a CPU hibásműködését, akár meghibásodását is okozhatja. Ennek érdekében a P4-es processzorok 130 °C-s belső hőmérséklet felett jelzést adnak egy kivezetésen. Ez lehetőséget ad a beavatkozásra(végső megoldásként a CPU resetelésére). Az órajel csoport vonalai a rendszersínfrekvenciájának meghatározásában játszanak szerepet (lásd később PCI-frekvenciák). Adiagnosztikai vonalakon tesztelés és nyomkövetés történhet, az inicializálási csoport vonalaipedig a rendszer betöltésénél játszanak szerepet. Végül a további vonalak több egyéb feladatotlátnak el, például a 8088-as emulációban van szerepük.

A P4 memóriasín csővezetékezett működésű. Ezzel egyszerre akár 8 síntranzakciót isvégezhet. Erre azért van szükség, mert a processzor sokkal gyorsabb működésű, mint aDRAM memória, amit használ. Ha nem tudjuk a CPU-t elég gyorsan kiszolgálni, adathiánymiatt sokat várakozna. A csővezetékezett működésről már korábban olvashattunk. Hasonlótlehet megoldani a memóriával is. A memóriaigények, más néven tranzakciók (transaction)hat különböző állapotát különböztetjük meg:

1. Sínütemezési fázis:

Eldől, ki következik a mesterek közül?

2. Kérési fázis:

A cím a sínre kerül, ezután kérjük az adatot.

3. Hibajelzési fázis:

Szolga jelezheti, ha paritáshiba van a címben v. más hiba merül fel.

4. Szimatolási fázis (többprocesszoros rendszerekben):


Egyik CPU figyeli a többit (mit írnak/olvasnak, nem azt kell-e éppmódosítani).

5. Válaszfázis:

Mester megtudhatja, hogy megkapja-e a kért adatokat vagy sem.

6. Adatfázis:

Megérkeznek a CPU által kért adatok.

A P4 memóriasínjén minden fázis különböző sínvezérlő jeleket használ, így ezekpárhuzamosan tudnak működni. A szükséges jelek a korábban tárgyalt P4 lábcsoportokbanvannak (sínütemezés, kérés stb.).

A következő ábrán (51. ábra) az egyes ciklusokban induló fázisok párhuzamos működésétlehet nyomon követni.

51. ábra P4 memóriasín-csővezeték fázisaii

A használt jelek a fenti fázisok alapján: Req – kérési fázis, Error – hibajelzési fázis, Snoop –szimatolási fázis, Resp – válaszfázis, Data – adatfázis. A sínütemezési fázis nem szerepel,mert erre nem mindig van szükség. Ha a mester új tranzakciót akar indítani, ezt újabb sínkérés


nélkül is megteheti. Látható, hogy a csővezetékezett működés az első két tranzakcióbanzavartalan. A harmadik tranzakció adatküldési fázisa nem fejeződik be egy ciklus alatt, ígyátcsúszik a következő ciklusra is. Ebből az következik, hogy a négyes tranzakcióban nemindulhat el az adatfázis a T8 időpillanatban. Ezt a DBSY# jel beállítása jelzi. Amikor végzett aharmadik tranzakció adatfázisa, indulhat a négyesé. Az ötös fázisban a válasz tart tovább, ígya hatos fázis válasza késlekedik. A késlekedések miatti elcsúszások (buborékok)megmaradnak, mert egy időpontban (oszlopban) nem lehet több tranzakció ugyanabban afázisban. Mivel a tranzakciók nem folyamatosan, órajelenként indulnak, ezek a buborékoknem tartanak sokáig.

1.5.1. Számítógépes sínek

A P4-es gépek idején a rendszerbusz a PCI (Peripheral Component Interconnect) volt. APCI-t már korábban elkezdték fejleszteni. Az ok az volt, hogy a multimédiás alkalmazásokegyre nagyobb sávszélességet követeltek, megterhelték az akkori rendszersínt (PC-n az EISA-t, ill. MCA-t). Egy egyszerű számításból adódik, milyen adatforgalmakra kell gondolnunk.Egy, az akkori időben nagyfelbontásúnak számító, 1024 x 768 pixel felbontású, 3 byte/pixel(TrueColor ~ 16Mill. szín) színmélységű, 30 fps (Frame Per Second) multimédiás videó vagy3D-s alkalmazás 67,5 Mbyte adatforgalmat jelent másodpercenként. Ezt a médiáról amemóriába, a memóriából pedig a grafikus vezérlőbe kell juttatni, azaz összesen 135 MBpsadatmozgatást kell megoldani. Az ISA sín maximális sávszélessége ehhez képest 16,7 MBps,az EISA síné 33,3 MBps. Könnyen belátható, hogy ezek a sínrendszerek elavultak az újabbkihívások mellett. Egy mai alkalmazás jellemzően Full HD felbontásban (1920*1080), 3byte/pixel, 60 fps sebességgel futó adatfolyamot generál. Ez a fenti számítások alapján többmint 700 MBps-es sávszélességet igényel. Manapság nem ritka, hogy ennél nagyobbfelbontás (4K esetleg), nagyobb fps (100+) és akár 3D-s technológia (2x-es szorzó) mellettdolgozunk multimédiás alkalmazásokkal. Látszik, hogy a sávszélesség növekedésrefolyamatosan szükség van.

Az Intel 1990-ben szabadalmaztatta a PCI sínrendszert. A szabadalmat mindenki számáramegnyitotta. Ez nagy lendületet adott a szabványnak, hamar népszerű lett.


52. ábra Korai Pentium architektúrai

A fenti ábrán (52. ábra) egy korai Pentium architektúra látható. Az új, gyors sínrendszermellett a régi (legacy) sínrendszernek is működnie kell a kompatibilitás megőrzése miatt. Eztaz új rendszerre egy hídvezérlő segítségével csatolhatjuk.

A PCI első verziója 133 MBps-es átvitelt tudott. Ez a fenti példában hozott multimédiásalkalmazáshoz kevésnek is bizonyult volna. 1993-ban jött a 2.0-ás szabvány, majd 1995-ben a2.1-es, 1998-ban a 2.2-es, 2002-ben a 2.3-as, 2004-ben pedig 3.0-ás szabvány. Mindenverzióváltásnál javítottak a funkcionalitáson, de voltak szolgáltatások, melyek lassan eltűntek.Ennek köszönhetően nem minden PCI-kártya kompatibilis minden alaplappal, még ha afizikai csatlakoztatás lehetséges is.

A PCI-frekvencia 33 MHz-en indult, de a 2.1-es szabványtól 66 MHz-es működésre islehetőség volt. Ezen kívül a kettes verziótól megjelentek a 64 bites átvitelt kezelni képeseszközök. Ebből adódik is a maximális átvitel (66MHz * 64 bit = 4224 Mbps, ami 528 MBps-nek felel meg, ez azonban csak egy közelítő elvi maximum).

A grafikai programok adatigénye gyors ütemben nőtt, az 528 MBps-es átvitel már kevésnekbizonyult. 1998-tól az Intel a grafikuskártyák számára nagyobb sávszélességet biztosító AGP(Accelerated Graphics Port) buszrendszert támogatta. Az első verzió 264 MBps sebességűvolt, ami lassúbb, mint a PCI, viszont dedikált sín a grafikuskártya számára. A későbbiverziók pedig felsokszorozták ezt a sebességet (ez felelt meg az 1x-es sebességnek, és jöttekaz AGP2x, AGP4x, AGP8x-os kártyák is). Az utolsó verzió maximális átviteli sebessége 2,1GBps feletti. Ennek megfelelően egy modernebb P4-es gép felépítését láthatjuk a következőábrán (53. ábra).


53. ábra Modernebb P4 felépítései

A CPU-t, memóriát, videokártyát és I/O eszközöket a csatoló lapka (Bridge Chip) köti össze.Ez további két alegységből épül fel. A CPU-t és a memóriát, valamint a CPU-t és a grafikuskártyát az északi híd (north bridge), az I/O eszközöket ezekkel pedig a déli híd (south bridge)köti össze. A két áramkör egy nagyon nagy sebességű csatolóval kapcsolódik egymáshoz.

A PCI egy szinkron sín, a mester a PCI dokumentációban Initiator, a szolga pedig Target. APCI-cím és adatvezetékei multiplexeltek, így a 64 vonal hol címeket, hol adatokat közvetít. Amester az első ciklusban a címet teszi a sínre, a másodikban eltávolítja, fordul a sínirány (eztmondjuk akkor is, ha írunk), a harmadikban pedig a szolga küldi az adatot (ha írás történik, amester küldi). Ha egy ciklus alatt nem történik meg az adatátvitel, várakozásokat kellbeiktatni. A kommunikáció előtt azonban az eszköznek le kell foglalnia a sínt. A PCIcentralizált sínütemezést használ. Az ütemezés vizsgálatához nézzük meg a következő ábrát(54. ábra).


54. ábra PCI sínütemezés

Az eszközök a REQ# vonalon kérik a sínhasználat jogát és a GNT# vonalon kapják meg azt.A PCI ütemezésre nincs pontos algoritmus megszabva a szabványban, csak irányelvek, amialapján az implementációnak működnie kell. Lehet az ütemezés körkörös, prioritásvezéreltvagy egyéb. Arra kell törekedni, hogy igazságos és kiegyensúlyozott legyen az engedélyekkiosztása. A jogot az ütemező egy tranzakcióra adja, ennek hossza azonban nem korlátozott.Amennyiben nincs más kérés, további tranzakciókat folytathat le az eszköz. Ha egy hosszúadás közben az ütemező negálja a GNT# jelet, a következő ciklusban meg kell szakítani atevékenységet. Ezekkel a szabályokkal hosszú átviteleket is meg lehet oldani, de az újkéréseket is gyorsan lehet kiszolgálni.

A PCI sín jelei a következő táblázatban szerepelnek (1. táblázat).

1. táblázat PCI sín jeleii


A CLK jel az óra, lemenő élein indulnak a tranzakciók. Az AD vonalak szolgálnak a címvagy adatátvitelre (32 bites kommunikáció, ez később 64-re egészül ki az új verziókban). APAR paritás vonalak védik az adatvonalakat. A C/BE vonalakon az első ciklusban asínparancs szerepel (mi történjen: szóolvasás, blokkírás stb.). A második ciklustól azonbanmár egy bittérkép-adatot tartalmaz, ami azt mondja meg, hogy az adatok közül melyik byte-ok érdekesek (érvényesek). A FRAME# vonalat a sínmester állítja be tranzakció kezdetekor.Az IRDY# vonal olvasáskor azt jelenti, hogy a mester fogadni tud, íráskor azt, hogy az adataz adatvonalon van. Az IDSEL vonal abban játszik szerepet, hogy az adott eszközkonfigurációs adatait tudjuk elérni. A PCI eszközök egy 256 byte-os területen tudják sajátbeállításaikat tárolni. A DEVSEL# vonalat a szolga állítja be, ha várja az adatokat, amikorfelismeri, hogy megszólította a mester. Ha ezt nem teszi meg, egy idő után a mester úgy veszi,hogy meghibásodott. A TRDY# vonalat a szolga állítja. Olvasáskor azt jelzi, hogy az adatokaz adatvonalon vannak, íráskor azt, hogy a szolga kész az adatok fogadására. A STOP#vonalon hiba esetén a szolga megszakíthatja a tranzakciót. A PERR# vonalon az előzőciklusban történt paritáshibát (hibás átvitelt) jelezhetjük. Olvasásnál a mester, íráskor a szolgaállítja be. A hibakezelés lépései a fogadóeszközön múlnak. A SERR# vonal cím- vagyrendszerhiba jelzésére való. A REQ# és GNT# vonalak a korábban tárgyalt ütemezésbenvesznek részt, a RST# vonallal pedig alapállapotba lehet állítani a rendszert (a gép újra indul).A 64 bitesre való bővülés további jeleket igényelt. Ezeket a következő táblázat tartalmazza (2.táblázat).

2. táblázat PCI 64 bites kiegészítő jeleki

A REQ64# jellel kérhet a sínmester 64 bites tranzakcióra engedélyt. Ezt a szolga az ACK#jellel nyugtázhatja. Az AD, PAR64 és C/BE# jelek az előzőek 64 bites kiegészítései. ALOCK#, SBO#, SDONE jelek a többprocesszoros rendszerekkel kapcsolatosak. A sínt lehettöbb tranzakció erejéig lefoglalni, illetve a szimatolással (snooping) kapcsolatos jelek. AzINT x 4 jel a megszakítások kezeléséhez kell. Egy PCI egység 4 különböző logikai egységbőlállhat, külön megszakítás-igénylő vonalakkal. A JTAG jel az IEEE 1149.1 tesztelési


eljárásnak van fenntartva, az M66EN jel pedig a 66MHz-es működést jelzi. Ez utóbbi akkormehet, ha minden eszköz támogatja. Menet közben nem változtatható meg.

A PCI tranzakciókra egy példát a következő időzítési diagramon láthatunk (55. ábra). Egyolvasás–üres járat–írás tranzakció-hármast vizsgálunk.

55. ábra 32 bites PCI síntranzakcióki

T1 lefutó élén a mester az adatokat az AD vonalra, a sínparancsot a C/BE# vonalra teszi (ezmost olvasás – READ). Ezek után FRAME#-et állítja be, ezzel indul a tranzakció. T2-ben acímsínt elengedi a mester (irányváltás), valamint C/BE#-re teszi a maszkot (melyik byte-okkellenek az adatvonalon). T3-ban a szolga beállítja a DEVSEL# vonalat, amivel jelzi, hogyvette a kérést és jelen van. A szolga AD-re teszi a kért adatokat, majd TRDY#-vel jelzi, hogyott vannak. Ha az adatokat nem tudja azonnal szolgáltatni, a TRDY# elmarad. T4-ben együres ciklus történik. A tranzakciók között gyakran egy-egy üres ciklus fut le. T5-ben kezdődikegy írási ciklus. AD-re felkerülnek az adatok, C/BE#-re a sínparancs (most írás), ésFRAME#-et beállítva indul a tranzakció. T6-ban nincs valós irányváltás (csak így nevezik),mert az adatokat a mester küldi. T7-ben a memória fogadja az adatokat.

A PCI sínrendszer sokáig és jól működött, de sávszélessége kezdett az egyéb perifériákszámára is kevésnek bizonyulni. További kényelmetlenség volt, hogy a PCI-csatlakozások túlnagyok, a hordozható gépekbe nem voltak illeszthetőek. Egyes tervezési elvek szerint adesktop gépek házait is ketté bontották volna. A fix alkatrészek (CPU, grafikus kártya stb.)egy dobozba, a cserélhető tárak (optikai, mágneses, külső eszközökhöz a csatlakozó felületek)pedig a monitor köré, elérhető helyre kerültek volna. Ezt a PCI távolságszabványa mellettnem lehetett megvalósítani.


A PCI Express (PCIe) sínrendszer 2004-es megjelenése mögött ismét az Intel állt és a cél azelavulóban lévő PCI sínrendszer leváltása volt. Bár a PCI-hoz nem sok köze van az újmechanizmusnak, a jól csengő nevet nem akarták elhagyni. A PCI Expressz valójában nem issín, inkább hasonlít a LAN-okhoz. Az egyes eszközök soros módon kapcsolódnak akapcsolóhoz. A vezérlőinformációk a csomag fejlécében vannak. Az eddigi sínkoncepcióktólnagyban eltér ez (56. ábra).

56. ábra PCI Expressz felépítései

A CPU és memória a hagyományos módon kapcsolódik egymáshoz, a csatoló lapkához az I/Oeszközök pedig egy kapcsolón (switch) keresztül. A nagysebességű soros kapcsolat, melynekelőnyeit korábban kifejtettük, föld- és adatvonalakból áll, zajtűrése nagy. A PCI-hoz képest akövetkező fontos különbségek élnek:

1. A PCI több leágazású közös sín

o PCIe esetén egyedi kapcsolat él minden eszközzel.

2. A PCI széles, párhuzamos kapcsolat (32/64 bit)

o PCIe keskeny, soros kapcsolat (1 bit).

3. A PCI mester/szolga kommunikációt valósít meg, egész sínt lefoglalva

o PCIe csomagkapcsolt kommunikációt folytat.

Pár kisebb különbség még, hogy a PCIe-nél hibaellenőrző kódolás van, a lapka és a kapcsolóközött akár 50 cm távolság is lehet, az eszközök helyére újabb kapcsolókat is lehet kötni


fastruktúrát kialakítva ezzel, a HotPlug megengedett, azaz menet közben lehet eszközöket le-és felcsatlakoztatni, valamint a PCIe csatlakozók kisebbek.

A PCIe a hálózati protokollokhoz hasonló réteges kapcsolati protokollrendszerrel rendelkezik(57. ábra).

57. ábra PCIe rétegeii

Az alsó réteg, a fizikai réteg (Physical layer), biteket továbbít a küldőtől a fogadónak.Minden kapcsolat egy vagy több szimplex (egyirányú) sávpárból (csatornapárból) áll. Alapesetben egy pár van mindkét irányban, de lehet 2, 4, 8, 16, 32 pár is. A sávok száma mindkétirányban azonos. Egy irányban minimum 2,5 Gbps a sebesség (effektív 2 Gbps, lásd később).A PCIe 4.0-s változatában ez a sebesség már 15,7 Gbps (effektív) csatornánként. A buszonnincs óra, az eszközök azonnal adnak, amint van mit. Ha nincs szinkron, nehéz a kapottbitfolyamban nyilvántartani, hogy hány 0 vagy 1 jött egymás után, ha sok egyforma jel jön.100 volt, vagy 101? Óra nélkül másra kell szinkronizálni. A PCIe 1.0 és 2.0-ban ún. 8b/10bkódolással oldják ezt meg. A 8 bites kombinációkhoz olyan 10 bites kombinációkatrendelünk, melyekben kellő rendszerességgel váltakoznak a 0-k és 1-ek. Ezzel a módszerrelnem eshet meg, hogy túl sok egyforma jel jöjjön egymás után. Ez viszont azt is jelenti, hogy avalós adatmennyiség 10:8 arányban van a hasznos adattal (2,5 Gbps 2 Gbps). A PCIe 3.0és 4.0 szabványokban hasonló, 128 b/130 b kódolást használnak (kisebb veszteséggel). Akövetkező réteg a kapcsolati réteg (Link layer). Ez a csomagok átvitelével foglalkozik, atranzakciós rétegtől kapott csomaghoz fejlécet generál, illetve CRC hibajelző kódot állít elő.Az átvitel után ezt ellenőrzi, és ha egyforma a két adat, nyugtázó csomagot küld. Ha ilyennyugta nem jön, a fogadó újra kéri a csomagot. A kapcsolati réteg oldja meg afolyamatvezérlést is. Meggátolja, hogy gyors eszköz elárassza kérésekkel a lassú eszközt. Afogadó egy pufferméretet küld a küldőnek, amibe a küldő tetszőleges sebességgel írhat. Hamegtelt, várnia kell, míg a küldő feldolgozza az adatokat. Ezzel a módszerrel asebességkülönbség miatt nem vesztünk adatot. A tranzakciós réteg (transaction layer) asíntevékenységeket kezeli. Egy szó kiolvasásához a memóriából például két tranzakcióra vanszükség. A CPU (DMA) kezdeményez és adatokat kér, illetve a céleszköz kezdeményezi azadatok küldését. Ez a réteg a kapcsolati réteg szolgáltatásait kiegészíti azzal, hogy a sávokatvirtuális áramkörökre tudja osztani. Minden sávot 8 külön virtuális áramkörre, melyek más-más jellegű adatforgalmat bonyolíthatnak. Ezeket prioritási szintekkel (címkékkel) tudja


ellátni, a kapcsoló pedig ezek figyelembevételével dönthet arról, hogy melyik címkévelellátott csomagot kézbesítse. A tranzakciók négy címtartományt használnak:

1. Memóriaterület (a hagyományos memóriába történő írás vagy onnan történő olvasásesetén).

2. I/O terület (a csatlakoztatott eszközök regisztereinek címzésénél).

3. Konfigurációs terület (a rendszer inicializálásakor, pl. PnP-megvalósításhoz).

4. Üzenetterület (vezérjelek átvitelekor, megszakítások esetén. A PCI vezérlőjeleihelyett).

A szoftver réteg (software layer) a PCIe operációs rendszerhez való kapcsolódásáért felelős.A PCI sín emulálására is képes, így a régebbi operációs rendszerek is együtt tudnak működnia PCIe-vel (és mint PCI-t kezelik). Ez a visszafelé való kompatibilitás miatt nagyon fontos éskihagyhatatlan elem. Az ilyen kompromisszumok nélkül a felhasználói kör nagyon nehezen,vagy sehogy nem fogadná el az újabb technológiákat.

A rétegek tevékenységeit az alábbi ábra mutatja (58. ábra).

58. ábra PCIe-rétegek és feladataiki

A szoftverréteg a parancsot a tranzakciós rétegnek adja, amely fejlécre és adatra bontja azt. Akapcsolati réteg hibajavító kódot és számozást illeszt hozzá. A fizikai réteg pedig keretet tesza csomag két végére és elküldi azt.

A PCIe csomagkapcsolt működése hardveres, az operációs rendszer számára láthatatlan. Aszámítógép-hálózatok esetében a rétegek megvalósítása szoftveres és az operációs rendszerebben közrejátszik.

A PCI csatolóméretét és az új PCIe-csatolókat a következő ábrán tekinthetjük meg (59. ábra).


59. ábra PCIe-csatolók (4, 16, 1, 16 sávos) és PCI-csatolóii

A PCIe-sebességek (3. táblázat) a hasznos adatátvitelre értve a következőképp alakulnak:

3. táblázat PCIe verzióinak sebességeiPCIe

verzióvonal

kódolásátvitel egy irányba

(GT - Gigatransfer – gigaátvitel)1x-es sávszélesség 16x-os sávszélesség

1.0 8b/10b 2.5 GTps 2 Gbps (250 MBps) 32Gbps (4 GBps)

2.0 8b/10b 5 GTps 4 Gbps (500 MBps) 64Gbps (8 GBps)

3.0 128b/130b 8 GTps ~7.9 Gbps (~985 MBps) ~126Gbps (~16 GBps)

4.0 128b/130b 16 GTps ~16 Gbps (~1970 MBps) ~252Gbps (~32 GBps)

A számítógép rendszerbuszánál a fő kérdés a sávszélesség, a sebesség. Vannak azonban olyanperifériák, ahol emellett egyéb szempontok fontosak. Vannak olyan eszközök, melyeknélnincs szükség ekkora sebességre, így a költséges sínrendszer használata pazarlás lenne. Ilyeneszköz pl. egy billentyűzet vagy egér, ahol az adatok mennyisége nem változik sokat a gépekfejlődésével és viszonylag kis sávszélesség elegendő a kommunikációra. A számítógépekhezaz I/O eszközök mindig is egyedi módon csatlakoztak, többnyire bővítőkártyákat kellett azISA- vagy PCI-sínre illeszteni, amik kezelték a külső eszközt. Ez problémás, szereléssel,konfigurálással jár, ami újabb problémákat hordozhat. Ráadásul a bővítő helyek számakorlátos. Ennek újragondolásával, több cég közös munkájával született meg 1993-ban egy új,lassúbb eszközök számára tervezett szabvány, az USB (Universal Serial Bus – univerzálissoros sín). A tervezéskor a következő alapelvek érvényesültek:


Ne kelljen a beállításokkal vesződni (jumperek állítása, miniswitchek állítása, többikártyához való konfigurálás).

Ne kelljen a gépben szerelni, a gépet kinyitni (ezt nem mindenki meri megcsinálni,illetve nem minden környezetben van erre lehetőség).

Egy fajta kábel legyen (ez végül nem teljesen sikerült).

Az energiát is ez a kábel szolgáltassa (ne kelljen külön tápellátással, külön kábelekkelbajlódni).

Sok eszköz kapcsolható legyen (a 8–10 bővítő hely néha nem elég, túl lehessen lépni,ha kell).

Valós idejű eszközökkel is jó legyen (pl. telefónia, hangszórók, mikrofon,webkamera).

Menet közben lehessen telepíteni az eszközöket, újraindítás nélkül (néha csak rövidideig van szükség az eszközre, az újraindítások sok időt visznek el és nem is lehetmindig megtenni futó folyamatok miatt).

Költségek ne legyenek magasak (tipikusan olcsó eszközöknél elfogadhatatlan a drágacsatolófelület beépítése az árba).

Az 1996-os USB 1-es (1.0, 1.1) lassú üzemmódban (low speed) 1,5 Mbps átvitelt tudottmegvalósítani, míg gyors üzemmódban (full speed) 12 Mbps-t, ami billentyűzet-,egérkommunikációra elegendő volt, de szkennerek, webkamerák adatait is át lehetett vinniígy. 2000-ben jött a mai, széles körben elterjedt USB 2.0 szabvány, ami a megnövekedettadatátviteli igényekhez igazodva már 480 Mbps-es sebességen üzemelt. 2008-tól létezik azUSB 3.0, ami újabb nagy ugrás volt a sebességekben, 5 Gbps-es sebességével, amit 2013-banaz USB 3.1 (USB 3.0 Gen2) szabvány 10 Gbps-re emelt.

Az USB-rendszer a központi csomópontból (root hub-ból) és az ehhez csatlakozó USB-eszközökből vagy újabb csomópontokból áll. A csatlakozásokat maximum ötszintűfastruktúrában lehet kialakítani, aminek a gyökere a root hub. Ez a rendszersínre csatlakozik(53. ábra). Az eszközöket négyeres kábelek kötik össze, ahol két adatér, egy tápfeszültség ésegy földelés ér fut. Az adatvonalon a feszültségátmenet jelenti a logikai 0-t, afeszültségátmenet hiánya pedig a logikai 1-t. Ha új eszközt csatlakoztatunk, a központicsomópont érzékeli, és megszakítást kér (az USB-eszközök nem tudnak megszakítást kérni).Az operációs rendszer ilyenkor megnézi, milyen eszköz csatlakozott, és eldönti, mekkorasávszélességet kell biztosítani a számára (tároló, audioeszköz vagy egyéb). Ha rendelkezésreáll a kívánt sávszélesség, az operációs rendszer megadja ezt, az eszköznek egyedi azonosítótés címet ad. Ezek után az adatokat a konfigurációs regiszterbe tölti. Innentől a rendszer tud azeszközről, az eszköz használható.


Az USB-eszközök és a központi csomópont között bitcsatornák épülnek fel, ezeket azeszközök további 16 alcsatornára oszthatják (egy USB-s csatlakozás többfunkciós eszközt isköthet). Az adatfolyamnak minden esetben át kell mennie a központi csomóponton, afastruktúrában két USB-eszköz nem kommunikálhat direktben, a root hub kihagyásával. Aközponti csomópont 1,00±0,05 ms-enként új üzenetváltási kérelmet (frame) küld ki. Ezbiztosítja az eszközök számára a szinkronizációt. Egy keret egy bitcsatornához kötődik,csomagokból áll, melyekből az elsőt mindig a központi csomópont küldi ki, utána az irányokváltozhatnak. Egy négy keretből álló sorozatot a következő ábrán láthatunk (60. ábra).

60. ábra Négy keretből álló sorozati

A 0-ás és 2-es keretben nincs kommunikáció, így csak egy SOF (Start Of Frame) csomagotkell küldeni a szinkronizáció miatt. Az 1-es keretben egy lekérdezés (IN) történik egyeszközről, a 3-as keretben pedig egy írás (OUT) valamelyik eszköz felé. Az USB négykerettípust különböztet meg:

1. Vezérlési keret:

Ez az eszköz konfigurálására szolgál. Parancsokat küldhetünk, állapotot kérhetünk levele.

2. Izoszinkron keret:

Valós idejű eszközök használják (telefon, mikrofon, hangszóró), melyeknek pontosidőközönként adatot kell küldeniük vagy kapniuk. Hiba esetén nincs ismétlés, mert azidőveszteséget jelentene, azaz csúszna a hang vagy kép. Egy-egy sercenést vagy hibáspixelt jobban elviselünk, mint a csúszást.

3. Tömeges adatkeret:

Nem valós idejű, byte-pontos átvitelhez. Itt az adatnak pontosan kell átérnie, akárhosszabb idő alatt (pl. file-ok átvitele).


4. Megszakítási keret:

Az USB-eszközök nem tudnak megszakítást kérni. Egy USB-s billentyűzet gombjaitlenyomva például nem megszakítást generálunk, hanem egy pufferbe írunk, amit azoperációs rendszer (ismerve a csatlakoztatáskor egyeztetett eszköztípust és adatokat)50 ms-onként kiolvas.

Egy keret egy vagy több csomagot tartalmazhat. A TOKEN csomagok a központi vezérlőbőlaz eszközök felé mennek és vezérlik azt. Például az ábrán is látható SOF (Start Of Frame)csomaggal indul minden keret, akkor is, ha mást nem is tartalmaz (szinkronizáció!). Az INcsomag az eszköztől kér adatot. A csomag mezői azonosítják a bitalcsatornát, így az eszköztudja, milyen adatokra van szükség. Az OUT csomag jelzi, hogy az eszköz számára érkeznekadatok. Az adatcsomag (DATA) maximum 64 byte küldésére alkalmas csomag, amely 8 bitesszinkronizációs mezőből (SYN), 8 bites csomagtípusból (PID), hasznos adatból (PAYLOAD)és 16 bitnyi CRC-kódból áll. A kézfogás csomagokból három létezik: ACK, ami azt jelzi,hogy rendben megérkezett az előző csomag, a NAK, ami azt jelzi, hogy CRC-hiba történt azátvitelben, illetve a STALL, ami azt jelzi, hogy az eszköz foglalt és várakozni kell rá.

Az USB gyökércsomópont és a vezérlő közötti interfész eredetileg kétféle lehetett. Az UHCI-t (Universal Host Controller Interface) az Intel tervezte (hardveres cég) és a feladatok zöméta szoftverre bízza. Ezzel ez egy olcsóbb, de a CPU-t terhelő megoldás. Az OHCI-t (OpenHost Controller Interface) a Compaq és a Microsoft tervezte (szoftveres cégek), ahol afeladatok zömét hardveresen kell megoldani. Ez így egy drágább megoldás, de nem terheli aCPU-t. Az USB 2.0-val megjelent az EHCI (Enhanced Host Controller Interface). Csak eztudja a gyors, 480 MBps-es átvitelt megvalósítani, de kompatibilitási okokból tud OHCI ésUHCI üzemmódban is működni. Az USB 3-mal megjelent az xHCI (eXtensible HostController Interface) is. Ez utóbbi esetben mélyebbre nyúltak az újratervezésben. Nemcsak asebesség növelése, hanem a mobil eszközökkel megjelent energiatakarékos működés igényeis előtérbe került. Ennek megfelelően az állandó kereteket küldő szemlélet helyett egymegszakításokhoz hasonló rendszert dolgoztak ki, természetesen a visszafelé valókompatibilitás megőrzése mellett.

Az USB-csatlakozók kialakításánál a fenti célokat vették figyelembe. A csatlakozóknakrobusztusnak, olcsónak, könnyen használhatónak kellett lennie. A kábelcsatlakozókkialakítása nem teszi lehetővé a körkörös csatlakoztatást, illetve kis erőkkel köthetők ésbonthatók. A külső fémkeret a statikus töltések elvezetésére alkalmas, bár a méret miatt egyeseszközökön (tárolók pl.) ezt lehagyják.

Sajnos az egységes csatlakozóforma nem valósult meg, több típus is a piacon van. Ezeket azalábbi ábrán láthatjuk (61. ábra).


61. ábra USB-csatlakozók: USB A, USB B, USB MINI5A, USB MINI5B, USB MICRO B

Az USB-vel párhuzamosan fejlődő csatoló felület az IEEE 1394, más néven FireWire. Ezutóbbi a videózás szabványa volt sokáig és párhuzamosan fejlődik az USB-vel.


2. A processzor belső működése

A számítógép-architektúrák digitális logikai szintje felett a mikroarchitektúra szintjekövetkezik. Ez lényegében a processzor belső működését írja le. A felettes szint ISA(Instruction Set Architecture) szól a gép által értelmezett parancsokról, ezeknek afeldolgozása és végrehajtása pedig a mikroarchitektúra szintjén történik.

A RISC gépek utasításai többnyire egy ciklus alatt lefutnak. Az összetett utasításokat istartalmazó, modern ISA-k (pl. P4 vagy az erre a magra épülő Core architektúra) számáraviszont egy-egy utasítás végrehajtásához akár több ciklusra is szükség lehet. Ez az utasításkomplexitásából ered és részben ez az ára a kényelmes programozhatóságnak. Az ilyenkomplex architektúráknak nincs általános tervezési elve, az aktuális célok és lehetőségekmellett minden eset egyedi. Példának a Java Virtual Machine (JVM), JAVA virtuális gép egyalrészét, az egész számokkal dolgozó Integer JVM (IJVM) gépet vizsgáljuk. A korábbanvizsgált alapvető áramköröket fogjuk használni a fizikai megvalósítás tervezésénél. Apéldában célravezető az a szemlélet, hogy az ISA-utasításokat mint függvényhívásokattekintjük, ahol az egyes utasításhoz tartozó tevékenységeket (alaplépéseket,mikroutasításokat) egy főprogram hívja, ami az ISA-utasításokon lépked végig. Ezt apéldában tekinthetjük úgy, mintha egy végtelen ciklusban futna a gép, amelyben az ISA-utasításokat dolgozza föl.

A mikroprogram változói a regiszterek, ezekkel dolgozik. A regiszterek definiálják aszámítógép állapotát. Azt, hogy mi történik a számítógép processzorában, a regiszterektartalma határozza meg. Például a PC regiszter határozza meg, melyik ISA-utasítás lesz akövetkező, amit végrehajt a processzor. Amíg az utasítás végrehajtódik, a PC-t frissíteni kell,hogy már a következő utasítást mutassa. Az IJVM utasításai tömörek. Minden utasításnak vanegy műveleti kódja (művkód – Operation code – Opcode), amely az utasítást azonosítja.Ehhez tartozhat egy opcionális operandus (operand), amely megmondja, hogy mivel végezzeaz utasítás a tevékenységét. Ez lehet egy lokális változóra való mutató, vagy akár egy direktérték is. A korábban említett betölt–végrehajt (fetch-execute) ciklusnak megfelelően az IJVMgépünk is ezt a tevékenységet végzi el. Azt, hogy ehhez mit kell pontosan elvégezni, hogyműködik a mikroarchitektúra, mit csinálnak a mikroutasítások, a következőkben tárgyaljuk.

Az adatút a processzor azon része, ami tartalmazza az ALU-t, a bemeneteivel és kimeneteivelegyütt. A példagépünk adatútján 32 bites regiszterek vannak, ALU-ja 32 bites egészértékekkel dolgozik (62. ábra).


62. ábra IJVM adatúti

A regiszterek nevei arra utalnak, hogy mire használjuk őket. A regisztereket amikroarchitektúra-szinten lehet elérni, az ISA-szinten viszont hasonló néven utalhatunk rájuk.A regiszterek többségét a B sínre lehet irányítani, ami az ALU B bemenetéhez vezet. Az ALUkimenete a C sínre vezet, ami a legtöbb regiszterhez vissza van vezetve, azaz az eredménytezekben a regiszterekben lehet tárolni. Az ALU mögött egy léptető (shifter) is van, ami azALU eredményével még egy léptető műveletet tud végezni. Az ALU-ból egy N és Z vonal iskijön. Ezek az eredmény függvényében állítódnak be: N értéke lesz 1, ha az eredménynegatív, Z értéke lesz egy, ha az eredmény nulla. Az ALU 6 vezérlő bemenete ismerős lehet akorábban épített 1 bites ALU-nkból. Ezek a már ismert ENA, ENB, F0, F1, INC és INVAjelek. Az alábbi táblázatban ezeknek a vezérlőjeleknek a kombinációit láthatjuk, ameghatározott funkcióval együtt (63. ábra).


63. ábra Az ALU funkcióii

Az ALU bal (A) bemenete a holding (H) regiszterből jön, és csakis innen. A jobb oldalibemenet 9 regiszterből érkezhet. Ahhoz, hogy tetszőleges regiszterekkel tudjunk műveletetvégezni, a H-ba az ALU-n kell a B bemenetről értéket átmozgatni. Ezt olyan műveletteltudjuk megtenni, ami nem módosítja az adatot. Pl. lehet a művelet az A+B, de ENA-t negálva.Ekkor 0+B lesz a művelet, azaz marad B az eredmény, ami H-ba kerül. A léptetőnek kétvezérlőbemenete van. Ezek az SLL8 (Shift Left Logical), ami 8 bittel balra lépteti az értéket,illetve az SRA1 (Shift Right Arithmetic), ami 1 bittel jobbra lépteti az értéket. A léptetéskor abejövő bitek 0-k, a kihulló bitek pedig elvesznek.

Az adatokat a síneken mozgatjuk, az ALU-n, a léptetőn haladnak át. Mindezek a műveletekbizonyos időbe telnek. Hogyan tervezzük az időzítéseket? Ugyanazt a regisztert egy ciklusonbelül olvasni és írni is lehet (pl. SP = SP + 1). Hogyan lehetséges, hogy nem keverednek összeadatok? Az egyes részműveletek a cikluson belül, de valójában különböző időpontokbantörténnek. Az előző példánál maradva (SP = SP + 1), amikor kiválasztódik, hogy SP-velakarunk műveletet végezni, akkor SP értéke a B sínre kerül, és ott is marad a ciklus idejére.Az ALU megkapja azt az utasítást, amivel a B+1 műveletet hajtja végre. Az eredmény aléptetőn keresztül (ami most semmit nem csinál) a C sínre kerül, ahonnan a jel tovább terjed aregiszterekhez és beíródik a célregiszterbe (ami most SP). Ezek a részlépések időben egymásután történnek meg a valóságban, de az egész befér egy ciklusnyi időbe.

Az időzítést a következő ábrán követhetjük nyomon (64. ábra).


64. ábra Az adatút időzítései

A ciklus elején, az óra impulzusának indulásakor a lefutó élen beállítódnak a kapuirányítóbitek. Ezek mondják meg, hogy melyik buszra melyik regiszter kerüljön (jelenleg SP a B-re).Ez Δw idő alatt történik meg. A kiválasztott regiszter a B sínre kapcsolódik, és Δx idő múlvastabil az érték a sínen. Az ALU és a shifter végzi a dolgát, és újabb Δy idő múlva stabil akimeneten az eredmény. További Δz idő múlva a C sínen az eredmény elér a célregiszterbe, akövetkező impulzus felfutó élén pedig betöltődik a regiszterbe. Ez azt jelenti, hogyha aciklusidőbe, azaz két impulzus közé beférnek ezek a részidők, akkor egy ciklus alattlejátszódik ez a tevékenység. A gyártástechnológia, a felhasznált anyagok, távolságok,méretek mind befolyásolják a jelterjedési sebességeket. A ciklusidőt annak megfelelően kellmeghatározni, hogy a fenti tevékenységek az adott technológia mellett beférjenek a két felfutóél közé, sőt kicsit előbb befejeződjenek.

Az IJVM gépünk két módon tud a memóriával kommunikálni. Az egyik mód, amikoradatokat ér el a memóriában. Ezt az MAR (Memory Address Register) 32 bites címregiszterrelés az MDR (Memory Data Register) 32 bites adatregiszterrel teszi meg. A MAR által mutatottcímről tudunk adatot olvasni az MDR-be, vagy a MAR által mutatott helyre tudjuk MDRtartalmát kiírni. A másik mód, amikor utasítást olvasunk be a memóriából. Ezt a 32 bites PC(Program Counter) regiszter által mutatott helyről tehetjük meg, és az utasítást a 8 bites MBR(Memory Byte Register) fogja tartalmazni. Ez utóbbi regiszter egy 32 bites regiszter alsó 8bitjét használja. Ahogy azt az adatút ábráján (62. ábra) is láthattuk, a regisztereket 1 vagy 2vezérlőjel irányítja, amit kis tömör és üres nyilacskák jelölnek. Az üres nyíl jelöli a B sínrevaló töltés engedélyezését, a tömör nyíl pedig a C sínről való betöltés engedélyezését. MARnem kapcsolódik a B sínre, hiszen mi adjuk meg, hogy hova vagy honnan akarunk adatotmozgatni (a memória nem lehet mester, nem kezdeményezhet!). Az MBR pedig nemkapcsolódik a Csínre, hiszen az utasításokat csak a memóriából kaphatja, a gépünk csakolvasni és értelmezni akarja azokat. A 32 bites MDR és 8 bites MBR azt is meghatározza,hogy mi az egység a megfelelő címregisztereken. Az MDR-hez tartozó MAR szavakban


gondolkodik (32 bit – 4 byte), tehát MAR + 2 az MAR-hez képest 2 szóval, 64 bittel eltoltértéket jelent. Az MBR-hez tartozó PC viszont byte-okat olvas, így az MBR + 2 itt két byte-nyi, azaz 16 bitnyi távolságot jelent az MBR-hez képest.

A valódi fizikai memória byte-os szervezésű. A szavas címzés esetén a címeket a címsínreeltolva kell felhelyezni. Kettővel való eltolás a bináris értékeken pont néggyel való szorzásteredményez, így a MAR-címeket a fizikai címvonalra kettővel balra tolva kell kötni (65.ábra).

65. ábra MAR-címek fizikai címekre kötése, 2 bites eltolássali

A memóriából való olvasás az MBR-be egy 8 bites porton keresztül történik. Két módontudunk MBR-be olvasni: előjel nélkül, ekkor a 8 bites érték MBR alsó 8 bitjére kerül és atöbbi bit nulla, illetve előjelesen, amikor a 8 bit legmagasabb helyi értékű bitje másolódik a32 bites MBR maradék helyeire. Ekkor az előjelet jelentő legmagasabb bit a 8 bitből (7-essorszámú) kiterjed az MBR maradék 24 bitjére. Ez a folyamat az előjelkiterjesztés. A két módközül két vezérlőjellel választhatunk, ezt a két nyilacskát láthatjuk az MBR alatt az adatúton(62. ábra).

Az adatút vezérlőjeleit vizsgálva 26 nyilacskát találunk. Három vezérlőjel nincs jelölve,amiből kettő a memóriaírást/olvasást szabályozza MAR/MDR-en keresztül, egy pedig azutasítás betöltést PC/MBR-en keresztül. Így összesen 29 jel vezérli az adatutat:

9 jel – adatírás C sínről regiszterbe,

9 jel – adatírás regiszterekből B sínre,

8 jel (6+2) – vezérlőjel ALU és léptető felé,

3 jel memóriaolvasáshoz/íráshoz.

A B sínre 9 regiszter közül pontosan csak 1 írhat, így egy dekóder beiktatásával a 9 jeletcsökkenthetjük 4-re. Ekkor ugyan 16 kimenet között kapcsolhatnánk, de ebből csak 9-ethasználunk fel. A 3 bites dekóder csak 8 kimenet közül tudna választani, ami sajnos nem elég.


Ezzel a lépéssel a 29 jelet 24-re csökkentettük. Ezt a C sínről való regiszterbe íráskor nemtehetjük meg, mert ott lehetséges az eredményt egyszerre több regiszterbe is beírni. További 9jelre van szükség a következő ciklus tevékenységének a meghatározásához. (Ezt akövetkezőkben fogjuk kifejteni.) Végül további 3 jel szükséges a következő mikroutasításkiválasztódási módjának meghatározásához (JAM mező). A következő ábrán (66. ábra)ezeknek a jeleknek az összességét tekinthetjük meg.

66. ábra 36 bites mikroutasítási

A kapott 36 bit pontosan meghatározza, mi történjen aktuálisan a processzorban, ígykimondhatjuk, hogy ez a 36 bit a mikroutasítás, aminek a végrehajtása éppen történik.

A jelek sorrendje tetszőleges, de a most választott sorrend segíteni fog abban, hogy akövetkező ábra átlátható maradjon.

A ciklus alatt szükséges vezérlőjeleket az ún. sorbaállító adja. Az épp beolvasott ISA-utasításvégrehajtásához szükséges mikroutasítás sorozaton való végigléptetését tehát a sorbaállítóirányítja. A feladat kettős. Minden ciklusban elő kell állítania a rendszer összes vezérlőjelét,illetve meg kell határoznia a következő mikroutasítás címét (Addr). Úgy is fogalmazhatunk,hogy a sorbaállító mondja meg, melyik eszköznek mit kell csinálnia az adatúton, illetvemagában a sorbaállítóban. A példagépünket, amit elkezdtünk felvázolni, Mic-1-nek nevezzükel (67. ábra).


67. ábra Mic-1 blokkdiagram – adatút + sorbaállítói

A sorbaállítót vezérlőegységnek is hívhatjuk. Ennek a legnagyobb és legfontosabb része azábrán szürkés vezérlőtár (control store). Ez egy memória, de nem az operatív memória, ígyinkább vezérlőtárként hivatkozzuk továbbra is. Ebben, az operatív tár ISA-utasításaihozhasonlóan, mikroutasítások vannak, példánkban 512 darab 36 bites szó. Egy fontos eltérés azoperatív tárhoz képest, hogy míg ott az utasítások többnyire címsorrendben vannak (kivéveelágazások esetén), addig itt ez nem alapértelmezett, sőt az egyes mikroutasításoknak megkell adniuk, hogy hol található a következő mikroutasítás (Addr mező!). A vezérlőtár csakolvasható, innen mindig a soron következő mikroutasítást olvassuk (hasonlóan az operatívtárból való olvasáshoz). Így szükség van egy memóriacím-regiszterre, amit MPC-nek(MicroProgram Counter), és egy memóriaadat-regiszterre, amit MIR-nek (Micro InstructionRegister) hívunk. A MIR fogja tartalmazni a következő érvényes mikroutasítást, azaz az újabb36 bitet, mely meghajtja az adatutat.


Minden óraciklus kezdetén MIR feltöltődik MPC által mutatott helyről a vezérlőtárból. MIRfelöltési ideje Δw. Amint a mikroutasítás MIR-ben van, jelek futnak az adatútra, melyekkiválasztják a B sínre kerülő regisztert, és beállítják az ALU tevékenységét. Ez újabb Δx időtvesz igénybe, így Δw + Δx idő múlva az ALU bemenetei stabilak. További Δy idő elteltével azN, Z bitek, illetve az ALU és a léptető kimenetei stabilak. Az N és Z értékek eltárolódnakegy-egy flip-flopban, végül Δz idő elteltével a léptető kimenete eléri a C sínen a regisztereketés az eredmény beíródik a megfelelő regiszterekbe. Ha volt adatkérés az előző ciklusban,MDR és MBR megkapja az adatokat. Ezek után MPC új értéke kialakul, így a következőmikroutasítás címe megvan. Az új memóriaciklus, ha van, ekkor indul.

Az adatút meghajtása mellett a mikroprogramnak meg kell határoznia a következőmikroutasítást. Ezt a folyamatot a MIR feltöltődése és stabilizálódása után lehet indítani. Azelső lépés, hogy a 9 bites ADDR mező az MPC-be töltődik. Eközben a JAM mezőkiértékelésre kerül, és ha a tartalma 000, nincs további teendő a címkiválasztássalkapcsolatban. Ha viszont a JAM mező bármelyik bitje 1, további tevékenység szükséges. Ha aJAMN-érték 1, akkor az N-flip-flop értéke VAGY kapcsolatba kerül az MPC legmagasabbbitjével. Ha JAMZ értéke 1, akkor a Z-flip-flop értéke kerül VAGY kapcsolatba az MPClegmagasabb bitjével. Ezt a számítást és beállítást a magas bit (High Bit) nevű logika végzi el.A flip-flopok használatára azért van szükség, hogy az ALU aktuális N és Z kimeneteitőlfüggetlenül megmaradjon N és Z előző ALU-tevékenységnél beállított értéke. A JAM mezőtovábbi bitje a JMPC, ami, ha nullától eltérő, akkor MBR alsó 8 bitje és MPC alsó 8 bitjeVAGY kapcsolatba kerül. Ezt a tevékenységet az ábrán az O-doboz végzi. Amikor JMPC 1,akkor a NEXT_ADDRESS alsó 8 bitje általában nulla. A JAMN, JAMZ, JMPC mezőksegítségével a NEXT_ADDRESS mezőt tudjuk változtatni, azaz azt, hogy mi legyen akövetkező mikroutasítás. Ha pl. a legnagyobb helyi értéken lévő kilencedik bitet VAGY-oljukN-el vagy Z-vel, fix 255-el eltolhatjuk a címet. Ez azt jelenti, hogy feltételhez kötöttelágazásokat tudunk hatékonyan megvalósítani.

A következő táblázatban a fenti adatút és vezérlőegység-időzítéseket követhetjük végigpárhuzamosan (4. táblázat).


4. táblázat Mic-1 időzítések, adatúton és vezérlőbeniii

A mikroarchitektúra működésének megértése szempontjából érdemes egy rövid időre az ISAszintre visszatérni. Ezt szoktuk makroarchitektúrának is hívni.

A programozási nyelvek mind támogatják az eljárásokat (metódusokat). Az eljárásoknaklokális változóik vannak, melyek az eljárás futásáig élnek, az eljárásból elérhetőek, de kintrőlnem. Hol érdemes tartani ezeket a változókat? Egy egyszerű megoldás kínálkozik, tároljuk aváltozókat fix memóriacímeken. Ez azért nem jó, mert egy eljárás lehet rekurzív is, azaz sajátmagát hívhatja meg. Ha fix helyre teszi a lokális változóit, akkor az újabb és újabb rekurzívanindított eljárás felülírja az előzőek letárolt változóit. Ez nyilvánvalóan hibához vezet. Egy jóstratégia lehet a verem (stack) adatstruktúra. Itt egy külön memóriaterületet foglal a rendszer,ahol a verem lesz. A veremben a tárolás úgy zajlik, hogy amit utoljára tettem be, azt tudomelőször kivenni. Ezzel az újabb és újabb beírt adatok nem egymásra, hanem egymás melléíródnak ki. A lokális változók memóriaterületét az LV (Local Variables) regiszterben lévőpointer mutatja. A stack pointer (SP) a legfelső változó helyét mutatja. A következő ábrán(68. ábra) A, B, C és D eljárások futása és a verem alakulása követhető nyomon.


68. ábra Veremhasználat eljárások számáraiii

Az A eljárás meghívja B-t, amely meghívja C-t. Miután C lefut, B is lefut, A pedig meghívjaD-t. Közben az LV mindig az aktuálisan futó eljárás elejére mutat, az SP pedig mindig averem tetejére. A vermek operandusok tárolására is alkalmasak, az aritmetikai kifejezésekkiszámolása közben. Vegyünk például egy összeadást:

a1 = a2 + a3

Az SP által mutatott területre a következőképp kerülnek be az operandusok. Először a2, majda3, az összeadás elindul, ami kiveszi a verem tetejéről a két elemet, majd összeadja ésvisszateszi az eredményt (a2 + a3) (69. ábra).

69. ábra Összeadás menete a verembeniii

Az IJVM gépünk memóriamodellje kicsit eltér a legtöbb gép memóriamodelljétől. Míg azokISA-szintű közvetlen címeket is létrehoznak, az IJVM utasításai implicit címekből létrehozottmutatókat használnak, ezeket lehet indexelve elérni. Az IJVM példagépünkben a következőnégy memóriaterületet használjuk:

1. Konstans mező

o a CPP regiszter mutatja a helyét,


o nem módosítható adatokat, például konstansokat tartalmaz, mérete ezért nemváltozik, nem írható.

2. Lokális változók mezője

o metódushíváskor foglalódik,

o metódusváltozói itt tárolódnak,

o LV-regiszter mutatja az alját (ahonnan indexelve érjük el a tartalmat).

3. Operandusverem

o SP mutatja a tetejét,

o lokális változók közvetlen felső szomszédja (tekinthetjük részének).

4. Metódus mező

o programot tartalmazó mező,

o PC mutatja az aktuális utasítást,

o Nem szavas, hanem byte-os elérésű.

A fizikai memóriában három elkülönülő részben szerepelnek ezek a mezők, az alábbi ábraszerint (70. ábra).

70. ábra IJVM memóriaterületekiii

Az IJVM utasításkészlete hasonló utasításokból áll, mint más számítógépeké. Minden utasításegy műveleti kódból és néha operandusokból áll. A következő táblázatban (5. táblázat) azutasítások hexadecimális kódja, az assembly alak, a mnemonic és egy rövid leírás található.


5. táblázat IJVM utasításkészleteHexadecimális kód Mnemonic Rövid leírás

0x10 BIPUSH byte Byte elhelyezése a verembe.

0x59 DUP A verem legfelső tartalmát (szavát) duplikálja, azaz mégegyszer beteszi a verembe.

0xA7 GOTO offset Feltétel nélküli elágazás.

0x60 IADD Összeadás. A verem felső két elemét veszi ki, adja össze éshelyezi vissza az eredményt a verem tetejére.

0x7E IAND Logikai ÉS. A verem felső két elemét veszi ki, logikai ÉSkapcsolatba hozza őket és visszahelyezi az eredményt averem tetejére.

0x99 IFEQ offset A verem tetején lévő szót kiveszi, vizsgálja, és ha az nulla,elágazik, egyébként pedig nem.

0x9B IFLT offset A verem tetején lévő szót kiveszi, vizsgálja, és ha az kisebbmint nulla, elágazik, egyébként pedig nem.

0x9F IF_ICMPEQ offset A verem tetején lévő két szót kiveszi, vizsgálja, hogyegyenlők-e. Ha igen, elágazik, egyébként pedig nem.

0x84 IINC varnumconst

Konstanst ad egy lokális változóhoz.

0x15 ILOAD varnum A verembe helyezi az operandusként megadott lokálisváltozót.

0xB6 INVOKEVIRTUALdisp

Ezzel az utasítással lehet metódust meghívni.

0x80 IOR Logikai VAGY. A verem felső két elemét veszi ki, logikaiVAGY kapcsolatba hozza őket és visszahelyezi azeredményt a verem tetejére.

0xAC IRETURN Metódusból való visszatérés egy egész értékkel (ami averem tetejére kerül).

0x36 ISTORE varnum A verem tetején lévő szót kiveszi és a lokális változóbateszi (azaz a lokális változók területére, a megfelelőhelyre).

0x64 ISUB Kivonás. A verem felső két elemét veszi ki, vonja kiegymásból és helyezi vissza az eredményt a verem


tetejére.

0x13 LDC_W index A konstans mezőről egy konstans értéket tesz a verembe.

0x00 NOP No OPeration – nem csinál semmit.

0x57 POP A verem felső szavát eldobja.

0x5F SWAP A verem felső két értékét (szavát) kicseréli egymással.

0xC4 WIDE Speciális prefix utasítás. Ezután egy másik utasításkövetkezik és jelezzük, hogy annak nem 8, hanem 16 bitesindexe (operandusa) lesz.

Az aritmetikai, logikai műveletek a verem tetején lévő értékekkel történnek. Utasításokvannak arra, hogy a verem tetejére a konstansok vagy a lokális változók mezejéről értékekkerülhessenek be, ill. vissza. Az elágazásokhoz négy utasítást használhatunk. A GOTOfeltétel nélküli elágazás (más nyelvekben szokás JMP-vel jelölni, ami a jump – ugrás szóbóljön), az IFEQ, IFLT, IF_ICMPEQ pedig bizonyos feltételek teljesülése mellett ágazik el. Azelágazási műveletek után 16 bites előjeles (a memóriában előre és hátra is ugorhatunk) eltolásszerepel. Ezzel az értékkel kell az aktuális helyzetünkhöz képest ugranunk a memóriacímben(PC-t módosítani). A veremutasítások, a SWAP, POP, PUSH, a verem tetején lévő szavakmenedzselésében segítenek. A WIDE prefix utasítás segítségével néhány utasítást rövid éshosszú formában is használhatunk. Az alapból rövid forma 8 bites eltolást használ, de WIDE-dal hosszú, 16 bites eltolásos formaként értelmezhetjük. Az INVOKEVIRTUAL ésIRETURN utasításpáros a metódushíváshoz és visszatéréshez szükséges. A hívás lépései akövetkezők: A hívó a verembe tesz egy hivatkozást, ami a meghívni kívánt metódusra mutat(egy cím). A hívó a metódus paramétereit is beteszi a verembe. Ez után a hívó futtatja azINVOKEVIRTUAL utasítást, ami a verem tetején lévő adatokat felhasználva az aktuálisveremre egy új vermet épít (LV módosítása), illetve elteszi a visszatéréshez szükséges, híváspillanatában vett címet (link ptr – link pointer). A lefutott metódus utolsó utasítása azIRETURN, ami az eredeti állapotokat állítja vissza úgy, hogy az eredeti verem tetején avisszatérési érték szerepel. Ezt a folyamatot a hívó fél úgy fogja érzékelni, hogy a veremtetejére beadott metódushivatkozás és paraméterei a hívás után eltűnnek és helyükre a kívánteredmény kerül. Az új verem (stack) felépítését és lebontását láthatjuk a következő két ábrán(71. ábra, 72. ábra).


71. ábra Hívás előtti és utáni állapot, az új verem felépítései

72. ábra Visszatérés előtti és utáni állapot, a verem visszaállítása i

A nyelvi szinteket, a fordítás eredményét és a műveletekhez használt verem részleteit akövetkezőkben vizsgáljuk (73. ábra). Az alábbi JAVA, magasszintű nyelven írt kódból (a) afordító assembly nyelvű (a fenti ISA-szintű utasításokat használó) kódot állít elő (b). Ennekvan gépi kódú (a valóságban ez futtatható) megfelelője, ami hexadecimális számok sorozata(c).


73. ábra JAVA-kódrészlet, assembly megfelelő, gépi kódi

A JAVA-kód első sorában két lokális változó (j és k) értékeit adjuk össze és helyezzük egyharmadik lokális változóba (i). A fentiek értelmében a két változót a verembe kell helyezni,előkészítve az összeadást. Ezt a két ILOAD utasítással tesszük meg. Az IADD utasításelvégzi a verem felső két elemével az összegzést és az eredményt a verembe helyezi. Innen azISTORE utasítással kerül az érték a megfelelő változóba. A következő feladat a feltételvizsgálata. Az i változót vizsgáljuk, hogy egyenlő-e 3-mal. Ilyen egyenlőséget vizsgálófeltételes elágazást valósít meg az IF_ICMPEQ utasítás. Ehhez i-t is a verembe kell tenni(ILOAD) és a 3, direkt byte értéket is (BIPUSH). Az összehasonlításon alapuló elágazásnakegy címkeparamétert (amit a rendszer eltolásnak számít át a gépi kód szinten) is kell adni. Haa feltétel teljesül, ide történik meg a vezérlésátadás (a példában ez L1). Ha a feltétel nemteljesül, az ugrás nem valósul meg, így a soron következő utasítás indul el, ami az else ágtevékenységét kezdi. Ez egy kivonás lesz, aminek az értékét egy lokális változóba kell tenni.A kisebbítendő (j) és a kivonandó (1) értékeket is a verembe kell helyezni az ISUBvégrehajtása előtt. Az eredményt a veremből a megfelelő változóba kell tenni az ISTOREutasítással. Utána az L1 címkéhez tartozó sorokat átugorva, L2-re kell adni a vezérlést. Ha afeltétel teljesül, L1-nél folytatódik az elágazás. Ekkor k változóba kell 0-t tenni, azaz a nulláta verembe kell tenni és a verem felső értékét a k változóba eltárolni. A rövid példában az islátható, hogy mennyivel egyszerűbb a tevékenységet magasszintű nyelven megfogalmazni.

Az egyes lépések közben a vermet is használjuk. A verem tartalmát az egyes sorokhozrendelve (pl. 6-os sor: BIPUSH 3) láthatjuk az alábbi ábrán (74. ábra).


74. ábra Veremtartalmak a JAVA-kódrészlet futása alatti

A fenti példaprogram JAVA nyelvű megvalósítását az architektúra ISA-szintű nyelvén isvizsgáltuk. Tudjuk azonban, hogy az egyes ISA-utasítások további felbontásra kerülnek, aholis mikroutasítások sorozatai fogják a valós tevékenységet elvégezni. Ahhoz, hogy eztvizsgálni tudjuk, egy olyan leíró nyelvet kell meghatároznunk, amely a mikroarchitektúraszintű tevékenységeket átláthatóan reprezentálja. Tudjuk, hogy a mikroutasítások (36 bitesszavak) tartalmaznak egy NEXT_ADDRESS mezőt, amiben a következő utasítás címe van.Ahhoz, hogy a műveletekre tudjunk koncentrálni, a választott leíró nyelvünkben e címekpontos kialakulását nem követjük nyomon. A jelölési rendszerben fontos szerepe van aciklusoknak, így rögzíthetjük, hogy az egy ciklusban történő tevékenységeket egy sorbafogjuk írni. Ezzel nyomon követhető, hogy melyik tevékenység hány ciklus alatt hajthatóvégre, illetve jól követhető lesz az is, hogyha bizonyos számú ciklusnyi várakozásokat kellbeiktatni. Kiszúrhatjuk a szűk keresztmetszeteket, és amikor megpróbálunk majd javítani azarchitektúrán, azt is nyomon követhetjük, mennyi időt tudtunk spórolni az egyesátalakításoknak köszönhetően. Egy 3 ciklusos tevékenységen spórolni 1 ciklust hatalmasfejlődés, 33%-os sebességnövekedést jelent. Ebben a rendszerben a tiltott műveleti sorrendetis tetten érhetjük, vannak tevékenységek, melyeket az architektúrából adódóan nem lehet egyciklusban elvégezni.

Tegyük fel, hogy az elvégzendő műveletek az adott ciklusban a következők:

SP növelése 1-gyel,

memóriaolvasás kezdeményezése,

a következő mikroutasítás meghatározása (ami a 122-es helyen van).

Ezeket rögzíthetnénk a következő módon:

ReadRegister = SP; ALU = INC; Write SP; Read; NExtAddress = 122;

Ez egy lehetséges jelölés, de hosszú, nehezen átlátható. Helyette érdemes a műveleteket és azegyéb tevékenységeket úgy megjeleníteni, hogy intuitív módon olvasható, tömör, de átláthatóformát kapjunk:

SP = SP + 1;rd


Ez már egy sokkal jobban olvasható jelölésmód. Ahogy említettük, a következőmikroutasítás-címeket nem kell számszerűen követnünk most, az bonyolítaná a megértést, ezta mikroassemblerre bízhatjuk, ami ezt a feladatot megoldja helyettünk. A leíró nyelvünketnevezzük el MAL-nak (Micro Aseembly Language). A MAL tükrözi a mikroarchitektúrajellegzetességeit, minden ciklus alatt bármelyik regiszter írható (jellemzően egy), az ALU Bbemenetére csak egy regiszter kerülhet, az A oldalra csak a H regiszter vagy fix –1, 0, 1 értékmehet. Az értékadás az egyenlőségjellel történik, például:

MDR = SP,

de az ALU-műveletet is jelezhetjük, például egy összeadás esetén:

MDR = H + SP.

Mivel az összeadás kommutatív, így az

MDR = SP + H

forma is megengedett.

A nem megengedett utasításokra azonban ügyelni kell. A következő művelet látszólag jó:

MDR = SP + MDR,

de ez hibás. Mivel egy sor egy ciklust jelent, és az architektúránkon csak H lehet az egyikbemenete az ALU-nak, a helyes leírás két sorban történhet meg:

H = MDR;

MDR = H + SP;

Egy hasonló hiba a következő:

H = H – MDR,

mert a kivonandó csak a H lehet. A többszörös értékadást megengedjük, hiszen azarchitektúránkban a C sín akár az összes regiszterhez szállíthat egyszerre adatot:

SP = MDR = SP + 1.

A memóriaolvasást az adatok esetében az rd; az írást a wr; szavakkal jelezzük, az utasításokbeolvasására pedig a fetch; parancsot használhatjuk. Az adat- és utasításvonalakpárhuzamosan mennek, így ezeket az utasításokat egy sorban is szerepeltethetjük. Amemóriaolvasások időzítéseire is figyelni kell. A következő olvasás például hibás:

MAR = SP;rd;

MDR = H;


mert MAR címről egy olvasást indítunk rd-vel, aminek az eredménye MDR-be fogmegérkezni. Ezért a következő ciklusban nem szabad MDR-be értéket tennünk, mert nemlehetünk benne biztosak, hogy megtörténik-e a felülírás.

Az elágazásokat a jelölési rendszerünkben a

goto label

módon írhatjuk le. Ezt az ugrást jellemzően minden mikroutasítás-sorozat végén megtesszük,hiszen, ahogy említettük, a mikroprogramokat egy főciklus hívogatja folyamatosan, amihezmindig vissza kell térni: goto Main1. Az architektúra képességeihez igazodva a megengedettműveleteket az alábbi táblázat (6. táblázat) tartalmazza. Ezeket, a fenti összeadáshozhasonlatosan, a B és C sínek kapcsolatait figyelembe véve adott regiszterekkel végezhetjük el.

6. táblázat Mic-1 megengedett műveleteii

Minden utasítás kiterjeszthető még az ALU után kötött léptető egy műveletével. Ezen azALU-eredmény minden esetben átmegy és a cikluson belül maradunk akkor is, hatevékenységet végez, így a két léptető műveletet is betehetjük egy MAL utasítássorba. Aműveletek a „<<8” és a „>>1”. Például a

H = MDR << 8;

Művelet megengedett és MDR a 8 bittel balra tolt értékét teszi H-ba.

A korábbi feltétel nélküli elágazás mellett feltételhez kötött elágazásokat is végezhetünk aMAL-ban. A JAMN és JAMZ mezők az N és Z bitek alapján működnek. Az N és Z bitek az


ALU-művelet alapján állnak be. Ha egy regisztert meg akarunk vizsgálni, hogy például nulla-e, át kell engednünk az ALU-n, hogy a Z bit beálljon. Ezt a MAL-ben jelölhetnénk példáulígy is:

TOS = TOS;

De ez, mivel nem derül ki pontosan, mi a cél, értelmetlennek is tűnhet. Valamilyen módon aztis érdemes lenne egyben jelölni, hogy melyik bitet mi alapján szeretnénk beállítani. A MAL-ban hasznosnak tűnhet a következő jelölés (TOS vizsgálata, hogy nulla-e):

Z = TOS;

Ez persze N-t és Z-t is beállítja, de így a MAL-ban látszik a tevékenység célja és ez egyfontos szempont.

A feltétel vizsgálata és az elágazás a következő módon jelölhető:

if (Z) goto L1; else goto L2

Itt az L1 és L2 címkéknek 255 byte távolságra kell lenniük (címek alsó 8 bitje megegyezik –emlékezzünk: Z beállítása esetén MPC 9. bitje változhat). Ennek a kiosztása amikroassembler feladata. Ezt kiegészíthetjük a Z beállításával:

Z = TOS; if (Z) goto L1; else goto L2

A JMPC kezeléséhez (MBR-el kerül VAGY kapcsolatba az MPC alsó 8 bitje, ha ez él) akövetkező jelölést használhatjuk:

goto (MBR OR value)

A value gyakran nulla, ekkor elég a

goto (MBR)

használata.

Most, hogy van már egy MAL leíró nyelvünk, tárgyalni tudjuk a Mic-1 architektúrautasításainak mikroprogramjait. A TOS (Top Of Stack) regiszterhez meg kell jegyeznünk,hogy praktikus okokból ebben mindig a verem tetején lévő értéknek kell szerepelnie. Eztmajd a mikroprogramban nekünk kell biztosítani.A lenti táblázatok három oszlopot tartalmaznak. Az első oszlopban az utasítás szimbolikusneve van, a másodikban a mikrokód, a harmadikban pedig egy megjegyzés, hogy mi istörténik az adott sorokban. Az első táblázatban a főciklus (Main1) után jönnek rendre azutasítások, egészen a SWAP utasításig.


7. táblázat Mic-1 mikroprogramoki

A Main1 főciklus indulásakor a PC-ben a végrehajtandó utasítás címe van, MBR-ben pedigmaga az utasítás. Az első utasítás után a PC növekedik, az utasítás utáni byte-ra mutat, ezlehet egy újabb utasítás vagy operandus. A növelést Main1-ben elvégezzük, a fetch-sel amemóriaciklus indul, ez a program következő byte-ját olvassa MBR-be (a következőmikroutasítás végén lesz MBR-ben a byte). A goto (MBR) elugrik az utasításhoz tartozómikroprogram elejére. Ez a kezdő utasítássorozat minden utasítás elején lefut, fontos, hogygyors legyen.

Minden utasítás feldolgozását végző függvény első mikroutasítása az utasítási kódnakmegfelelő címen van a mikroprogramtárban. Pl. POP-utasítás kódja 0x57, mivel amikroprogram tár 0x57 címénél kezdődik a mikroprogram, ami ilyenkor lefut. A DUPparancs pedig a 0x59 címen kezdődik. Mivel a POP három mikroutasításból áll, ezek nemállhatnak egymás mögött, mert akkor „belelógnának” DUP mikroutasításaiba. Ezért láncoltlistaszerűen helyezkednek el a mikroutasítások a mikroporgramtárban, azaz mindegyiknekmeg kell adnia a NEXT_ADDRESS mezőben, hogy hol helyezkedik el a következőmikroutasítás. Tehát a mikroutasítások sorozata egymás után hajtódik végre, aNEXT_ADDRESS mező segítségével. A sorozat mindig a műveleti kóddal megegyező címenkezdődik.


A NOP1 szimplán megegyezik azzal, hogy visszaugrunk Main1-re, azaz nem csinálunksemmit (No Operation).

Ha a főciklus az IADD-ra ágazik el, iadd1-en indul a munka. A TOS már rendelkezésre áll(TOS-utasítások elején a TOS tartalmazza az SP által mutatott hely tartalmát, azaz a veremlegfelső szavát), de a verem teteje alatti szót be kell tölteni a memóriából:

MAR = SP = SP-1;rd(ez lesz az új veremtető, így SP-be is beírjuk).

MPC-be NEXT_ADDRESS-ből iadd2 címe bekerül közben, így ezen a soron következőutasítás végrehajtása következik. A TOS-t hozzá kell adni a frissen betöltött szóhoz. Ezt azösszeadást elő kell készíteni:

H = TOS

Az ALU bal bemenete a H (TOS), mivel összeadni csak H-t és regisztert lehet. Mielőtt aziaddr3 sorra jutunk, a MAR-ban megadott címről MDR-be kerül az érték (az SP mutatta szó).Az iaddr3 soron az eredmény a verembe kerül. MAR oda mutat, wr-el pedig MDR bekerülMAR címére, azaz a verem tetejére:

MDR = TOS = MDR + H;wr;goto Main1

A fentiekhez nagyon hasonló történik az ISUB mikroprogramjában, azzal a különbséggel,hogy itt a harmadik soron nem összeadás, hanem kivonás történik. Ugyanez mondható el azIAND és IOR utasításokra is, de itt a harmadik soron logikai AND és OR műveletektörténnek.

A DUP parancs esetén a verem felső tagjáról kell másolatot készíteni a verembe. Mivel azérték, mint minden utasítás elején, most is már TOS-ban van, így elegendő SP-t növelni és SPúj értékére TOS-t beírni.

A POP egyszerűen eldobja a verem tetején lévő szót, de TOS-t karban kell tartanunk, így azúj értéket be kell töltenünk TOS-ba. MAR-ba beadva az olvasandó címet, várnunk kell egyciklust, amíg az adat MDR-be kerül, és csak utána lehet TOS-ba beírni ezt az értéket.

A SWAP felcseréli a verem felső két szavát. A felső már TOS-ban van, az alsót kiolvassukMAR címről MDR-be, majd H-ba és MAR (SP) címre mentjük. Ekkor felső és alsó szóugyanaz, a régi felső pedig a TOS-ban van. Ezt SP-1-re, azaz az alsó helyre írjuk. A végénTOS-t beállítjuk a felső szóra.

A következő táblázatban (8. táblázat) folytatódnak a Mic-1 architektúra mikroprogramjai.


8. táblázat Mic-1 mikroprogramok folytatása BIPUSH-tóli

A BIPUSH utasítás lépései már kicsit bonyolultabbak, mert a műveleti kódot egy byte követi(előjeles egész). Main1-ben ezt már MBR-be töltöttük. Ezt a háttérben 32 bitessé kellkiterjeszteni, hogy a 32 bites regiszterekben tudjuk kezelni. Ezen túl be kell másolni MDR-be(majd így MAR = SP címre írni). PC-t közben növelni kell, hogy a főprogramba visszatérve akövetkező műveleti kód végrehajtható legyen, mert a Main1-ben történt PC-növelést„elhasználtuk” a paraméter kiolvasásánál.

Az ILOAD (lokális változót tesz a verembe) utasításnak is van egy műveleti kódot követőoperandus byte-ja. Ez egy előjel nélküli index a lokális változók mezőjén. Ez az indexazonosítja azt a szót, melyet a verembe kell rakni. Mivel az index 256 címet enged, így alokális változók mezejének első 256 tagját lehetséges így a verembe tenni. ILOAD közbenkell egyszer olvasni a lokális változók mezejéről, és írni is, a verembe.

A H-ba a lokális változók kezdete, LV kerül, MBRU-ban a paraméter van (Main1-benolvastuk be), előjel nélkül. MAR segítségével kiolvassuk az LV+MBRU-t, ami a lokálisváltozók mezejének eleje eltolva a paraméterben megadott indexszel. Másképpmegfogalmazva, ez maga a lokális változónk értéke. MAR-t már az új, növelt SP-re állítjuk,hiszen a verembe új érték kerül. PC-t növelnünk kell, mert mire Main1-be visszaugrunk, az újutasításnak MBR-be kell kerülnie. A fetch-sel egy sorban wr-rel az új veremtetőbe beírjuk


MDR-t, azaz a lokális változónkat. A végén a Main1-be ugrás előtt TOS-t beállítjuk az újértékre.

Az ISTORE az ILOAD ellenkezője. A paraméterindexű lokális változót vesszük ki averemből és tároljuk az LV+index helyre, pont fordítva, mint az előbb.

A következő utasítás a WIDE. Ez egy prefix utasítás, azaz önmagában nincs értelme,módosítja a mögötte következő utasítást. A WIDE az ISTORE és ILOAD prefixuma lehet.

Például, az

ILOAD index

forma helyett, 2 x 8 bites indexet használva:

WIDE ILOAD index1 index2

formát is használhatunk. A WIDE mikroprogram első sorában PC-t növeljük, hogybeolvashassuk a művkód utáni első byte-ot. Maga a művkód már MBR-ben van, ezt Main1-ben kezdtük beolvasni. WIDE második sorában (wide2) a műveleti kód címet VAGY-oljuk0x100-zal és oda is ugrunk. A VAGY miatt a műveleti kódcím módosul, pl. az ILOAD 0x15-ös címe helyett a WIDE_ILOAD 0x115-ös címét kapjuk. Emiatt fontos, hogy a WIDE-dalhasználható utasítások mikroprogramcímei pontosan 0x100 távolságba legyenek egymástól.Maradva a WIDE_ILOAD példánál, tekintsük az ottani első sor tevékenységét. Rögtön újabbPC-növeléssel és beolvasással kezdődik a mikroporgram. Ezzel a második indexet kezdjükolvasni. Az időközben megérkezett első indexet, ami MBRU-ba jött meg, 8 bittel eltoljukbalra. Ezzel az első indexet a 16 bites értékünk felső 8 bitjére, azaz magas helyi értékéretoljuk. A következő sorban az MBRU-ba frissen megérkezett második indexet ORkapcsolatba hozzuk H-val, azaz az előzőleg kapott 16 bites értékkel. Ezzel a felső és alsó 8biteket egy darab 16 bites értékké olvasztjuk és H-ba helyezzük. Az utolsó sorban MAR-behelyezzük a 16 bites indexszel indexelt lokális változót és a kapott címről megkezdjük azolvasást. A megszokottakkal szemben most nem a Main1-re ugrunk, hiszen még nincs kész atevékenység, pusztán a 2 x 8 bites indexből készítettünk egy 16 bitest, valamint elkezdtük azolvasást a segítségével. Viszont innentől ugyanaz a feladat, mint a sima ILOAD-ban, ígyannak a harmadik sorára (iload3) adva a vezérlést, nem kell ugyanazokat a sorokat kétszerbeírni a mikroprogramtárba. Ott a verembe való beírás, valamint a következő utasításbeolvasása Main1 számára van hátra, majd ugorhatunk Main1-re.

A WIDE_ISTORE pontosan követi a WIDE_ILOAD logikáját, csak az irány itt is fordított.Ugyanúgy, mint az ILOAD–ISTORE páros esetén.

Az LDC_W konstans mezőről olvas a lokális mező helyett, így az LV helyett a CPP-tindexeli. Ennek az utasításnak is két 8 bites indexe van, ugyanazokat a lépéseket kellvégrehajtani, mint a WIDE_ILOAD esetén.


9. táblázat Mic-1 mikroprogramok folytatása IINC-tőli

Az IINC utasítás konstanst ad egy lokális változóhoz. Két paramétere van:

IINC index const

A const előjeles, így csökkenteni is tud. A lokális változók címét (LV) növeljük indexszel, aharmadik sorban pedig fetch-sel MBR-be beolvassuk const értékét. A második sorba olvasottváltozót megkapva a negyedik sorban H-ba tesszük azt. Az ötös sorban beolvassuk akövetkező utasítást. A hatos sorban pedig a MAR címre (ugyanoda, ahonnan olvastunk)visszaírjuk a lokális változó + konstanst (H + MBR). A végén ugrunk a Main1-re.

A GOTO utasítás egyetlen tevékenysége, hogy a PC-t módosítja. A GOTO paraméterében, afentiekhez hasonlóan két, 8 bites paraméter van. Ezt egyrészt 16 bites előjeles eltolássá kellalakítani, másrészt ahhoz a PC-pozícióhoz kell adni, ami a GOTO indulásakor voltérvényben. Mivel a Main1 automatikusan növeli a PC-értéket, a GOTO első sorában OPC-be(Old PC) az eggyel csökkentett értéket kell tenni. Ehhez fogjuk majd a 16 bites eltolásthozzáadni. A következő sorokban PC-t növeljük és beolvassuk a második indexet. Az elsőtMain1 kezdte beolvasni, ezt 8 bittel eltoljuk a magas helyi értékre és H-ba tesszük. Ez után aközben megérkezett második 8 bittel összeolvasztjuk ezt (MBRU OR H). A Main1 számáraPC-t növelve ki kell olvasnunk a következő utasítást, ami most az OPC+H címen lesz, ésugorhatunk Main1-be.

A következő mikroprogramunk egy feltételes elágazás megvalósításával foglalkozik.

Az IFLT utasítás kivesz a verem tetejéről egy szót és elágazik, ha a szó kisebb, mint nulla(IFLT – IF Less Than). Az első sorban a veremmutatót csökkentenünk kell, hiszen kiveszünka veremből, és a csökkentett értékről adatot kell olvasnunk. A második sorban TOS értékét


átmenetileg elmentjük OPC-be. Ezt azért tesszük, mert a korábbi memóriaolvasás miattamúgy is egy üres sor következne, TOS értéket pedig majd karban kellene tartani később. Aharmadik sorban a megérkezett MDR-rel beállítjuk TOS új értékét és a negyedik sorbanteszteljük az eredeti, legfelső veremértéket (TOS volt, de már OPC-ben van). Ha N értékeigaz, akkor a T-címkére ugrunk, egyébként pedig az F-címkére.

A T-címke (True) egyetlen sorból áll. Beállítja OPC-t PC-1-re és ugrik a goto2 sorra. Ezlogikus is, hiszen a feltételes elágazás feltétele teljesült, így ezen az ágon már egy feltételnélküli utasítást kell végrehajtanunk.

Az F-címke (False) első sorában PC-t növeljük, a másodikban pedig PC-t növeljük ésbeolvassuk a következő utasítást. Itt várva az eredményt, a következő sorban ugrunk Main1-re. A PC növelése, illetve újra növelése azt a célt szolgálta, hogy a feltételes elágazásunkfeltételének nem teljesülésekor a két, 8 bites indexet átugorjuk, és onnan folytassuk azutasítások beolvasását.

Az IFEQ (IF Equal) utasítás pontosan úgy zajlik, mint az IFLT utasítás, csak nem az N,hanem a Z bitet teszteli.

10. táblázat Mic-1 mikroprogramok folytatása IF_ICMPEQ-tóli

A következő feltételes elágazásutasítás az IF_ICMPEQ. Hasonlóan működik, mint az előzőfeltételes utasítások, csak nem az N vagy Z bitet teszteli, hanem a verem felső két eleménekaz egyenlőségét. Az első sorban a verem második szavát olvassuk, SP csökkentése is


megtörtént (az első elem TOS-ban van). A második sorban a verem harmadik elemének azolvasását készítjük elő, ez a TOS karbantartása miatt lesz szükséges. A harmadik sorbanmegérkezik a verem második szava, ezt MDR-be tesszük, és indítjuk a harmadik szóolvasását. Ez után az első szót, ami TOS-ban van, OPC-be tesszük, mert TOS-t karban kelltartanunk az új felső (eredetileg harmadik) szóval (ötödik sor). Ebben a pillanatban TOS az újfelső elem, SP ide mutat, már csak az eredeti első (OPC-ben) és második (H-ban) elemkülönbségét kell tesztelnünk. Ezt a hatodik sorban meg is tesszük.

11. táblázat Mic-1 mikroprogramok folytatása INVOKEVIRTUAL-tóli

Az INVOKEVIRTUAL és IRETURN mikroprogramok a metódushívás elején és végén építikfel, ill. bontják el az új vermet. A visszatéréskor a régi verem tetejére kerül a visszatérésiérték.

A Mic-1 architektúra jó példa arra, hogy a számítógépek, akár a mikroarchitektúra tervezése,tele van kompromisszumokkal. A CPU-tervezés egyik nagy kérdése az ár–sebesség aránymeghatározása. A Mic-1 architektúrát lehet javítani, pár példát fogunk is nézni rá. Ez azonbanlegtöbbször olyan extra megoldásokat kíván, ami mind felfelé tornázza az árat.


3. A párhuzamosítás lehetőségei

Adott áramköri technológia és ISA mellett alapvetően három lehetőségünk van a sebességnövelésére:

1. Egy utasítás végrehajtásához szükséges óraciklusok számának csökkentése.

2. Felépítés egyszerűsítése, amivel az óraciklus hosszát csökkenthetjük.

3. Átlapolni az utasítások végrehajtását (párhuzamosítás).

Azon óraciklusok számát, amelyek egy utasításhalmaz végrehajtásához szükségesek, úgyhívjuk, hogy úthossz. Ezt lehet speciális hardverrel rövidíteni, például növelő (INC)hozzáadásával. Így a növeléshez nem kell az ALU-t használni, és ciklusokat spórolunk. Itt asebességért a pluszhardver árával fizetünk. Egy növelő azonban általában nem segít annyit,mint várjuk, mivel a növelések körül memóriaolvasások is vannak, és ezek miatt amúgy isvárni kell.

A jelentős gyorsulást a harmadik módszer, azaz a párhuzamosítás adhatja. Egy nagyonhatékony lehetőség, amikor a mikroarchitektúra utasításbetöltéssel foglalkozó részétleválasztjuk a fő adatút elemeiről. Így a betöltést a többi lépéstől függetlenül teheti meg. Azutasítások egyik legidőigényesebb szakasza a 16 bites eltolások kezelése. Itt a két, 8 bitesértéket külön-külön be kell olvasni, léptetni, összeépíteni, H-ba helyezni. A memóriaport 16bitesre való kiterjesztése túl bonyolult lenne. A memória valójában 32 bites szavakban érhetőel, a 16 bites olvasások átnyúlhatnának két, 32 bites olvasásra is (8 bitet még az egyik 32-esrészből, 8-at meg már a következőből fedne le a 16 bit). Ekkor két, 32 bites olvasásra lenneszükség. Amikor nem nyúlna át, akkor meg csak egy, 32 bites olvasásra lenne szükség. Erreezért más megoldást fogunk választani.

Az utasításbetöltés és -végrehajtás szétválasztása már önmagában is jelentős gyorsulásthozhat. A modern számítógép-tervezés kérdései pont az átlapolásokról, a párhuzamosításrólszólnak.

Egy további lényeges szempont az ár. Az alkatrészek manapság már integráltan vannak jelena lapkákon, ezért nem is érdemes darabszámban számolni az árat. Inkább a lapkán elfoglaltfelület az új mértékegység. A bonyolultabb, nagyobb tudású áramkörök több helyet isfoglalnak el. Egyes funkciókat többféle módon lehet megvalósítani. Ezek között vannakegyszerű és nagyon bonyolult megoldások is, melyek között az ár és sebesség szerint atervezőnek kell döntenie. Az egyes alkatrészeket a lehető leggyorsabban akarjuk üzemeltetni,ehhez kell az órajelet is igazítani. A korábbi időzítési vizsgálatoknál láthattuk, hogy vannakfeladatok, melyeket egy cikluson belül érdemes elvégezni. Ez adott technológia mellettmeghatározza a ciklus lehetséges hosszát is.


A dekódolás sebessége az egész rendszerre kihat. A Mic-1 architektúránkban például a 9regiszter B sínre kapcsolását egy dekóder segítségével 9 jel helyett 4-gyel meg tudjuk oldani.Ezzel a mikroprogramtárban helyet spórolunk, mikroutasításonként 5 bitet. A dekódernekviszont fix késleltetése van, ami az egész adatút működésére kihat. Ez a késedelem az órajelciklus hosszát befolyásolja, így kimondhatjuk, hogy itt kompromisszum van a sebesség(órajel lassabb) és az ár (kisebb mikroprogramtár kell) között. Egy gyors gépbe nem érdemesa dekóder késleltetését betervezni.

Az IJVM Mic-1 architektúra közepesen egyszerű és gyors, vannak javítási lehetőségek,ezekből párat meg is vizsgálunk.

Az egyik lehetőségünk az értelmező ciklus és a mikrokód összefűzése. A Mic-1-ben mindenutasítás kezdetén végre kell hajtani a Main1 címen lévő utasítást (PC növelése, fetch; és(MBR)-re való ugrás). Ezeket a tevékenységeket minden mikroprogram végéhezhozzáfűzhetjük. Nem mindenhol tudunk ezzel javulást elérni, de sok helyen igen. Különösenott, ahol vannak olyan meddő ciklusok, amikor az ALU nem végez tevékenységet. Ezeket aciklusokat kitölthetjük értelmes feladattal.

Vegyük például a POP utasítás ciklusait (75. ábra).

75. ábra Mic-1 POP mikroprogram és javításai

A Main1 tartalma megjelenik a POP kódja mögött, majd az egyes tevékenységeketbeilleszthetjük a POP eddigi soraiba. Ezzel a 4 ciklusos utasításból 3 ciklusos lett. Perszeehhez némileg nagyobb mikroprogramtár kell.

További lehetőség a végrehajtási hossz csökkentésére, ha az ALU mindkét bemeneténlehetővé tesszük az összes szükséges regiszter bekötését. Ez egy további sín betervezésétjelenti, így háromsínessé tehető az architektúra. Ezzel megszűnik a kényszer, hogy Hregiszterbe kelljen egyes műveletek előtt tartalmat áttölteni, ahogy ezt a következő ábránláthatjuk is (76. ábra).


76. ábra Mic-1 és a háromsínes architektúra különbsége az ALU használatában i

Ezek a módszerek már hoznak gyorsulást, de az igazi áttörés az utasításbetöltés gyorsításalenne. Szerencsére erre is van megoldás. Minden utasításban előfordulnak a következőlépések:

PC átmegy az ALU-n, növeljük.

PC-t az utasításfolyam következő byte-jának kiválasztásához használjuk.

Operandusokat olvasunk a memóriából.

Operandusokat írunk a memóriába.

Az ALU műveletet végez, és az eredményt eltároljuk.

Az utasítás operandusát, ha van, be kell olvasni, illetve, ha több mezőből (több 8 bitesegységből) áll, össze is kell illeszteni a mezőket. Minden byte olvasása egy ciklusnyi időbekerül. Az indexek léptetése és összeillesztése további 1-1 ciklus. Ez már arányaiban túl sokadminisztratív feladat a többi számításhoz képest (egy-egy mikroprogram 1–10 ciklusból áll).Ezeket az adminisztratív lépéseket le lehet venni az ALU válláról. Akár egy második ALU-tis beiktathatunk, de ez túl nagy pazarlás lenne, ezekhez a feladatokhoz nem szükséges egyteljes ALU. A betöltéseket és feldolgozást rábízhatjuk egy ALU-tól független egységre. Eztaz egységet IFU-nak (Instruction Fetch Unit – utasításbetöltő egység) hívjuk. Az IFU képes aPC-t függetlenül növelni, byte-okat betölteni a byte-folyamból és a 8 vagy 16 bitesoperandusokat is előkészítheti. Mindehhez nincs szükség másra, csak egy növelőre, amilényegesen egyszerűbb, mint egy ALU vagy egy összeadó. Az operandusok előkészítésénekkét módja is lehetséges. Az egyik, hogy a műveleti kód értelmezésével meghatározzuk, hogylesz-e, és ha igen, hány bites lesz az operandus. A másik lehetőség, hogy vizsgálat nélkülelőkészítjük a 8 bites, illetve a 16 bites operandus használatának a lehetőséget is. Mi ezt azutóbbi megoldást mutatjuk be az alábbi ábrán (77. ábra).


77. ábra IFU működései

A jelölt területen látható, hogy az eddigi MBR helyett most két ilyen regiszterünk van, MBR1és MBR2. Ezeken keresztül 8 bitet vagy helyesen fűzött 16 bitet tudunk kiolvasni. Ha 8 bitetolvasunk, a léptetőregiszterben 8 bittel csúsznak jobbra az értékek. Ha 16 bitet olvasunk ki,értelemszerűen 16 bitet csúsznak jobbra az értékek. A léptetőregiszter 6 byte (6 x 8 bit)nagyságú. Amikor a jobbra csúsztatásokkal felszabadul 4 byte-nyi hely a bal oldalon, akkoraz IFU beolvas ide egy 32 bites szót (immáron 32 bites memóriaolvasással). Azt, hogy holtartunk ezen beolvasásokkal a memóriában, IMAR tárolja és a beolvasáskor ez az érték a sajátnövelője segítségével növekedik. MBR1-et és MBR2-t is lehet előjelesen vagy előjel nélkülolvasni, ezt az ábrán is látható szokásos 2-2 kis nyilacska mint vezérlő bemenetek jelölik.Amikor a programban PC értékét megváltoztatjuk, akkor IMAR-t is változtatni kell, hiszenPC mondja meg, hol tartunk a programban, IMAR csak kisegítő tevékenységet végez. MivelPC nem biztos, hogy szóhatáron van, IFU-nak a szükséges szót (amibe esik PC) kellbeolvasnia és a léptetőt hozzá igazítania. PC-be, ha van IFU-egységünk, csak azelágazásoknál kell írni, ahol az utasításfolyam soros jellege megváltozik (mert elugrunk másikmemóriacímre a végrehajtásban). IMAR szavas, PC byte-os számlálású, így IMAR 2 biteseltolással kerül a címsínre (0. bitje a címsin 2. bitjéhez).

A fenti módosításokkal új mikroarchitektúra-verziónk van: Mic-2.

Az IFU nagyon lecsökkenti az átlagos utasítás hosszat. Nincs főciklusunk, minden utasításvégén már megvan a következő címe (Mic-1-ben Main1-ben növeltük PC-t). Nem az ALU-nak kell PC-t növelnie. A 16 bites operandusokat is összerakja az IFU. Az újabb architektúraadatútját az alábbi ábrán (78. ábra) láthatjuk.


78. ábra Mic-2 adatúti

A háromsínes Mic-2 architektúra IFU egysége drasztikus gyorsulást hozhat egyes utasításokesetén. Például a következő ábrán (79. ábra) bemutatott LDC_W utasítás esetén, ahol azarchitektúra sajátosságai miatt 8 ciklusról 3 ciklusra csökkenhetett az úthossz.

79. ábra Mic-1 és Mic-2 LDC_W utasításainak mikroprogramjaii


Persze a fenti változtatások nem minden utasítás mikroprogramjára vannak ekkora hatással,de azt kimondhatjuk, hogy valamennyit mindenhol tudtunk spórolni. A javításilehetőségeknek viszont még nincs vége.

Egy lehetőség a ciklusidő gyorsítása. Ezt alapvetően a lapkatechnológia határozza meg, atranzisztorok mérete és távolsága szab határt az óra sebességének. Ahogy eddig is, most is apárhuzamosítás irányába érdemes lépni. Az IFU és az ALU már külön, egymássalpárhuzamosan dolgoznak, de a többi egység még mindig szekvenciális működésű:regisztertartalom a sínekre kerül, várunk az ALU-ra és a léptetőre, majd az eredményekvisszaíródnak valamely regiszterekbe. Az óraciklust az adatút jeltovábbítási ideje határolja be.Az adatútciklusban a késleltetési idők a következőkből állnak:

1. a kiválasztott regiszterek A és B sínekre való vezetésének ideje,

2. az ALU és a léptető munkájának ideje,

3. az eredmények regiszterekhez vezetése és tárolása.

Az alábbi ábrán egy új, Mic-3-nak nevezett architektúrát mutatunk be (80. ábra).

80. ábra Mic-3 adatútjai

A három beszúrt regiszter, A, B, C, rendre az A, B és C sínekre kerültek és az adatút háromrészét, melyeket színekkel jelöltünk, tagolják. Elsőre az extra regiszterek beiktatása csak ronta helyzeten, hiszen késleltetést visznek a jelterjedésbe. Az adatútrészek rövidülésével azórajelet emelhetjük, mivel a jelterjedési távolságok hozzávetőlegesen harmadolódtak. Pl. a


regiszterekből az A és B sínen a jeleknek csak A és B regiszterekig kell eljutniuk. Így az órajelháromszoros lehet. Ez önmagában még nem túl nagy előrelépés, viszont van még egy hasznaa tagolásnak. Az egyes szétválasztott részeket párhuzamosan használhatjuk. Ezek aváltoztatások ismét sebességnövekedéshez vezetnek. Tekintsük a Mic-2 architektúra SWAPmikroprogramját (81. ábra).

81. ábra Mic-2 SWAP mikroprogrami

Látható, hogy itt 6 ciklus alatt végez a korábbi Mic-2 architektúra a művelettel. Rendezzük áta SWAP mikroprogramot a Mic-3 architektúra végrehajtási időzítéséhez illesztve (82. ábra).

82. ábra Mic-3 SWAP mikroprogrami

Látható, hogy a SWAP mikroprogram egyes korábbi soraihoz oszlopokat soroltunk és azegyes részlépéseket ezekbe az oszlopokba írtuk be. Látható az is, hogy minden óraciklusbanadunk ki parancsot, de a párhuzamosan futtatott parancsok függetlenek. Ott, ahol függőséglenne, várni kell a párhuzamos parancskiadással (pl. 5-ös sor). A Mic-3 11 ciklus alatt végez aSWAP utasítással, míg Mic-2-nek 6 ciklusra van szüksége. Ez utóbbi azonban harmad olyangyorsan megy, így ez a 11-hez képest 3x6, azaz 18 új ciklusnak felel meg. Így az arány már11:18, a párhuzamosított Mic-3 javára. A swap3 lépésnél az 5. ciklusig várni kell, mert MDR-rel szeretnénk dolgozni, ami az előző adatolvasás hatására érkezik (swap1 3. ciklus: rd és 4.ciklus: MDR = Mem). Itt egy valódi függőség (RAW – Read After Write) alakul ki. Az ilyenkényszerű várakozásokat elakadásnak is hívjuk.


Az egyes részegységek működését az egymást követő ütemekben a lenti ábra (83. ábra)mutatja.

83. ábra Mic-3 párhuzamosan működő részegységeii

Látható, hogy a negyedik ciklusban már minden részegység dolgozik, mindegyik másik utasításon. Eza fajta párhuzamosság a csővezetékezett (pipeline) működés, amit korábban az utasításszintűpárhuzamosságnál megismertünk. A Mic-3 egy négyszakaszú (négyfázisú) csővezetékezett megoldás.

A Mic-3 már sokkal gyorsabb működésre képes, mint az előző architektúrapéldáink. Mégis van egyolyan probléma, amit meg kellene oldani. A fenti Mic-3 SWAP végrehajtási ciklusokban a GOTO(MBR) mikroutasítás egy elágazás. Ez a csővezetéket eldugítja, mert nem lehet tudni, hogy mit kellezek után az IFU-nak betölteni? Melyik ágon fut majd tovább a program? Ezt a problémát a Mic-4mikroarchitektúrában kezeljük. Számos részletet nem tárgyalunk a mikroarchitektúrában, így mégátlátható marad a működés. Az újabb felépítés a következő ábrán látható (84. ábra).


84. ábra Mic-4 fő alkatrészeii

A felépítésben láthatjuk az IFU-t, a háromutas adatutat, de új egységeket is. Az IFU a bejövőbyte-folyamot a dekódoló egység (Decoding unit) felé adja. Ebben az egységben egy belsőROM található, amit az ISA-utasítások értékével indexelünk. Az indexelt adatok két értékettartalmaznak: az utasítás hossza (van-e, és ha igen, hány byte-nyi a paramétere?), illetve egytovábbi index, ami a mellette lévő egység mikroműveleti ROM-ját (Micro-operation ROM)indexeli. Ez az egység a sorba állító egység (Queueing unit). Az egységnek van egy ROM ésegy RAM része. A ROM-ban vannak a mikroműveletek (Micro-operation) egymás utánsorban. A teljes sorozatok egymás után következnek, nincs olyan lehetőség, hogy azegyforma részeket ugrásokkal megspóroljuk (mint korábban pl. a nem wide és wideutasításpároknál). Ennek megfelelően NEXT_ADDRESS mezeik sincsenek amikroműveleteknek, illetve JAM mezeik sem. Az A sín miatt van azonban A sínt vezérlő Ajelük és két új jelük: Final és Goto. A Final bit minden mikroművelet-sorozat utolsóműveleténél van beállítva, ez jelzi, hogy vége a sorozatnak. A Goto bit a feltételes elágazásokjelölésére szolgál. Ezeknek a mikroműveleteknek kicsit más a formája, itt van JAM mező és


van egy RAM-ot címző indexmező is. A mikroelágazásokat az előzőekhez képest máshogykell kezelni.

Először azonban nézzük meg, hogyan is működik a sorba állító egység. A dekódoló küld egyindexet. Ez alapján a ROM-ból elkezdődik egy mikroművelet-sorozat RAM-ba másolása afinal bit ellenőrzésével. Ha nem volt goto bit beállítva és van még hely a RAM-ban, a sorbaállító nyugtát küld a dekódolónak, hogy küldheti a következő indexet. Ezzel a két egységfeltölti a RAM-ot, ahonnan a mikroműveletek sora érkezik a MIR felé. Egész pontosan aMIR-ek felé. A csővezetékezett működés miatt ugyanis a mikroműveletek egyesvezérlőbitjeinek időben máskor és máskor van szerepe. Ezt úgy lehet kezelni, hogy több MIRhelyezkedik el egymás után, és mindegyik MIR-nek csak a megfelelő vezérlőkivezetéseivannak bekötve az egyes egységekhez. Ilyen módon, az időben először szükségestevékenység az A és B vonalakra kapcsolandó regiszterek kiválasztása. A MIR1-ben ezek avezérlővonalak vannak bekötve, a többi nincs. A következő ciklusban a mikroműveletátmásolódik MIR2-be, ahol az ALU (és léptető) tevékenységvonalak vannak élesben bekötve.Ez az előbb beállított bemenetekkel elvégzi a most beállított műveletet, miközben MIR1-bemár a következő mikroművelet kerül, ami épp a következő A és B vonalakra engedi amegfelelő regisztereket. Amikor vége a ciklusnak, a mikroművelet MIR3-ba másolódik, aholbeállítjuk, melyik regiszterek kapják meg a C sínen az eredményt. Mindezzel párhuzamosan aMIR1 tartalma MIR2-be másolódik, MIR1-be pedig újabb mikroművelet kerül. A MIR3-bólMIR4-be kerül a mikroművelet, ahol a memóriaműveletek történnek meg.

Az ábrán minden egység funkciója megvan, de az elágazások részleteit még tisztázni kell. Haegy feltételes elágazásnál teljesül a feltétel, elágazunk, az utasításokat másikmemóriaterületről kell tovább olvasnunk. Ha sorba állító egység olyan mikroműveletet talál,ahol a goto bit be van állítva, nem küld nyugtát a dekódolónak. Ezzel felfüggeszti a RAMfeltöltését, azaz nem kerül be újabb mikroművelet az elágazás utáni részből. A nyugtát csakakkor küldi ki, ha az elágazás kimenete eldől, és megvan, hogy honnan kell a következőutasításokat beolvasni. Ekkorra a dekódolóban már lehet, hogy van olyan utasítás, ami azelágazás mögötti, azaz a nem teljesült feltétel ágáról származik. Bonyolult műveletek ésspeciális hardver kell, hogy ezt szükség szerint kiürítsük onnan, illetve bizonyostevékenységeket visszavonjunk, de ennek a részleteit nem vizsgáljuk.

Látható, hogy a kiindulási alaparchitektúra, Mic-1, jelentősen gyorsítható és ennek a főcsapása a tevékenységek párhuzamosítása. Ez bonyolultabbá és szükségszerűen drágábbá isteheti a hardvert. Egy jelentős kompromisszumot ezen a ponton kell hozni az ár ésteljesítmény között.

A fentiekben példát láthattunk arra, hogy milyen módon működhet egy mikroarchitektúra,milyen lépésekkel lehet a sebességet növelni és ez milyen extra költségekkel járhat. A maiprocesszorarchitektúrák a példa architektúránkhoz képest sokkal bonyolultabbak, mégis, az


alapelveik hasonlóak. Amikor pedig a technológiai korlátok nem engedik, hogy egyprocesszoron belül oldjuk meg a párhuzamosítás maximalizálását, a processzorok vagyprocesszormagok sokszorozásával, illetve több számítógép együttes használatával érhetjük elcélunkat, mint ahogy azt a harmadik fejezetben tárgyaltuk.

i Andrew S. Tanenbaum, Számítógép Architektúrák, Panem, 2006

ii Snickerdo, English Wikipedia, https://commons.wikimedia.org/wiki/File:PCIExpress.jpg

iii Máté Eörs, SZE, Számítógép Architektúrák, Online tananyag, ábrák

Documents

Dr. Várady Géza: Számítógép-architektúrák II