szar_tetelek

5/12/2018 szar_tetelek - slidepdf.com

http://slidepdf.com/reader/full/szartetelek 1/133

Számítógép architektúra

k idolgozott tételsor

Szegedi Tudományegyetem

Szeged, 2007.



2.

Tartalomjegyzék

1. Fordítás, értelmezés ........................................................................................................................ 4

2. Numerikus adatok ábrázolása: fixpontos ábrázolás, konverzió számrendszerek között. Negatív

számok ábrázolásai. ......................................................................................................................... 5

3. Lebegőpontos számok. IEEE 754 szabvány. ..................................................................................... 8

4. Hamming távolság. Hibaészlelő, hibajavító kódok. ....................................................................... 10

5. Digitális logikai szint. Kapuk. Boole algebra. Boole függvények megvalósítása, áramköri

ekvivalenciája. A Boole algebra legfontosabb azonosságai, dualitás............................................ 12

6. Kombinációs áramkörök, multiplexer, demultiplexer, dekódoló, összehasonlító, programozható

logikai tömbök. .............................................................................................................................. 15

7. Aritmetikai áramkörök. Léptető, fél és teljes összeadó, ALU, átvitel továbbterjesztő és kiválasztó

összeadás....................................................................................................................................... 17

8. Nem kombinációs áramkörök. Óra, tárolók, flip-flop-ok............................................................... 20

9. Processzor szintű párhuzamosítás................................................................................................. 24

10. Gyorsító tár (cache). Találati és hiba arány. Közös és osztott gyorsító tár. Direkt leképezésű és

halmaz kezelésű gyorsító tár. Memóriába írás.............................................................................. 26

11. Operandus megadás módjai. Közvetlen operandus, direkt, regiszter, regiszter-indirekt, indexelt,

bázis-index címzés ......................................................................................................................... 29

12. Sínek. Sín Protokoll. Master – szolga. Sín vezérlő, vevő, adóvevő. Sín szélessége. Sokszorozott

sín. Sín időzítés: szinkron, aszinkron sín, teljes kézfogás. Sín ütemezés. Sín műveletek. ............. 31

13. Általános soros sín ......................................................................................................................... 34

14. PCI Express ..................................................................................................................................... 37

15. A CPU részei, feladatai. CPU, adatút. Három, kettő, egy és nulla címes utasítások. ..................... 41

16. Mikroarchitektúra szint. Az ALU-val végezhető műveletek. Memória műveletek. ALU és az adatút

vezérlése. Mikroutasítások: Mic-1. Mic-1 működése.................................................................... 43

17. A Mic-1 memória ciklusa. .............................................................................................................. 47

18. MPC új értékének kialakulása Mic-1-en. ....................................................................................... 48

19. A WIDE utasítás hatása és működése Mic-1-en. ........................................................................... 49

20. Parallel Input/Output (PIO), valódi és memória leképezett I/O eszközök. Teljes és részleges

címdekódolás. Programozott és megszakítás vezérelt I/O. DMA. ................................................ 50

21. Utasítás szintű párhuzamosítás, csővezeték (pipelining). ............................................................. 52

22. Utasítás betöltő egység. Mic – 2. ................................................................................................... 54

23. Csővonalas terv: a Mic-3 ................................................................................................................ 5624. Egy hétszakaszú szállítószalag: a Mic-4 csővezetéke..................................................................... 57



3.

25. Elágazás, eltolási rés, statikus és dinamikus elágazás jövendölés................................................. 60

26. Sorrendtől eltérő végrehajtás, szuperskaláris architektúra, függőségek, regiszter átnevezés,

feltételezett végrehajtás................................................................................................................ 62

27. Feltételes végrehajtás, predikáció................................................................................................. 64

28. A Pentium 4, az UltraSPARC III és az I-8051 mikroarchitektúrája. ................................................ 65

29. A Pentium 4, az UltraSPARC III és az I-8051 mikroarchitektúrájának összehasonlítása................ 70

30. Gépi utasítási szint. Memória modellek, memória szemantika. A Pentium 4, az UltraSPARC III és

az I-8051 regiszterei ....................................................................................................................... 71

31. A Pentium 4, az UltraSPARC III, az I-8051 utasítás formátumai, címzési módjai........................... 75

32. Veremcímzés. Fordított lengyel (postfix) jelölés. Dijkstra algoritmusa. Postfix alakú formulák

kiértékelése ................................................................................................................................... 79

33. Vezérlési folyamat. Szekvenciális vezérlés, elágazás, ciklus szervezés, eljárás, rekurzív eljárás,

korutinok, megszakítás, csapda ..................................................................................................... 81

34. Operációs rendszer szintje. Virtuális memória. Lapméret, elaprózódás. Szegmentálás. A Pentium

4 és az UltraSPARC III virtuális memóriája..................................................................................... 84

35. Terminál. Modemek, jelzési, adatátviteli sebesség....................................................................... 90

36. ADSL, kábeles internet. .................................................................................................................. 93

37. Az Intel 8086/88 utasításai (adatmozgató, aritmetikai, logikai, string-kezelő, bitléptető/forgató,

vezérlésátadó, processzor-vezérlő, input/output utasítások, program megszakítás, szemafor). 97

38. Pszeudo operátorok. Egyszerű adatdefiníciós utasítások. Struktúra, rekord (definíció, hívás,

mezőre hivatkozás)...................................................................................................................... 103

39. Eljárás (deklaráció, hívás). Paraméter átadás/átvétel különböző módjai................................... 106

40. Lokális adatterület, rekurzív és reentrant eljárások.................................................................... 108

41. Feltételes fordítás........................................................................................................................ 109

42. Makró (definíció, hívás), blokk ismétlés ...................................................................................... 110

43. Címkék, változók, konstansok, kifejezések .................................................................................. 115

44. Szegmens definíció, szegmens csoport, aktív szegmensek kijelölése, globális szimbólumok..... 119

45. Egyszerûsített lexikális elemzõ .................................................................................................... 121

46. Két menetes assembler fordító ................................................................................................... 125

47. Az include utasítás. Az include utasítás feldolgozása a fordítás során........................................ 127

48. Makró generátor.......................................................................................................................... 128

49. Szerkesztő.................................................................................................................................... 129

50. Time sharing (időosztás). binding (cím hozzárendelés), dinamikus szerkesztés ......................... 131

51. Programok hangolása .................................................................................................................. 133



4.

1. Fordítás, értelmezés

A probléma két oldalról is megközelíthető. Mindkettő az ember számára a gépi nyelvnél

kényelmesebben használható új utasításrendszer tervezésére épül. Az új utasítások együttese is egy

nyelvet alkot – nevezzük ezt L1-nek -, ugyanúgy, ahogy a beépített utasítások nyelvet alkotnak – legyen ez utóbbi L0. A kétféle megközelítés abban különbözik egymástól, hogy a számítógép hogyan

hajtja végre az L1 nyelven írott porgramokat, miközben csak a saját, L0 gépi nyelvén írt programokat

képes végrehajtani.

Az L1 nyelvű program végrehajtásának egyik módja az, hogy először minden utasítását

helyettesítjük az L0 nyelv utasításainak egy vele ekvivalens sorozatával. Az így nyert program teljes

egészében az L0 utasításaiból áll. Ekkor az eredeti L1 nyelvű program helyett a számítógép ezt az L0

nyelvű programot hajtja végre. Ezt a módszert fordításnak nevezzük.

A másik módszer szerint megírunk egy L0 nyelvű programot, amely az L1 nyelvű programokatbemenő adatokként kezeli, és úgy hajtja végre azokat, hogy minden utasításukat elemzi, és a vele

ekvivalens L0 nyelvű utasítássorozatot azonnal végrehajtja. Ez a módszer nem igényli, hogy először

egy új, L0 nyelvű programot állítsunk elő. A módszert értelmezésnek, a végrehajtó programot pedig

értelmezőnek nevezzük.

A fordítás és az értelmezés módszere hasonló. Végül is mindkettő az L1 utasításait az L0

utasításaiból álló sorozatok végrehajtásával teljesíti. A különbség csak az, hogy a fordítás esetében

először az egész L1 nyelv programot átírjuk L0 nyelvűvé, majd az L1 programtól megszabadulunk, és

az L0 programot töltjük a számítógép memóriájába, és azt hajtjuk végre. A végrehajtás során az

újonnan előállított L0 program az, ami fut, és ami a számítógépet vezérli.

Az értelmezés esetében L1 minden utasításának elemzését és dekódolását az utasítás

azonnali végrehajtása követi. Nem keletkezik lefordított program. A számítógépet az értelmező

vezérli, számára az L1 nyelvű program csak adat. Mindkét módszert – és egyre gyakrabban a kettő

kombinációját is – széles körben alkalmazzák.



5.

2. Numerikus adatok ábrázolása: fixpontos ábrázolás, konverziószámrendszerek között. Negatív számok ábrázolásai.

A legtöbb számítógép egy szám tárolására szóló memóriája fix méretű, rögzítették a

számítógép tervezésekor. Bizonyos erőfeszítésekkel a programozó tudja a számokat ábrázolni azeredeti fix méretnél kétszer, háromszor, sőt többször nagyobb helyen is, de ez nem változtatja meg a

probléma természetét. A számítógépes erőforrásnak ez a véges természete csak azokkal a számokkal

enged foglalkozni, amelyek fix számú számjeggyel ábrázolhatók. Ezeket a számokat véges pontosságú

számoknak hívjuk.

Fixpontos számok például az előjeles, kétjegyű decimális számok.

Ábrázolási tartomány: -99 ; +99

Pontosságuk (két szomszédos szám különbsége): 1

Maximális hiba: (az ábrázolási tartományba eső) tetszőleges valós szám, és a hozzá

legközelebb lévő ábrázolható szám maximális különbsége: 1/2.

Az ember általában tízes számrendszert használ, de a számítógépek használatánál

kényelmesebb nem tízes alapú, hanem más rendszereket használni. A legfontosabb alapszámok a 2, a

8 és a 16. Ezen alapszámokra épülő számrendszereket sorrendben kettesnek (bináris), nyolcasnak

(oktális) és tizenhatosnak (hexadecimális) nevezzük.

A decimális számok 10 decimális jegyből épülnek fel: 0 1 2 3 4 5 6 7 8 9.

Szemben a bináris számokkal, amelyek nem tíz jegyet használnak, hanem 2 jegyből

szerkeszthetünk meg: 0 1.

Az oktális számok 8 oktális jegyből épülnek fel: 0 1 2 3 4 5 6 7.

A hexadecimális számoknál 16 jegy szükséges. Így 6 új szimbólum bevezetésére van szükség.

Kényelmes bevezetni az A-tól F-ig nagybetűket, amelyek a 9-et követő hat számjegy számára

szolgálnak. Így a számok a következő jegyekből épülnek fel: 0 1 2 3 4 5 6 7 8 9 A B C D E F.

Az alábbi táblázat a 4 számrendszerbeli megfelelőket mutatja be:

Decimális Bináris Oktális Hexadecimális 0 0 0 0

1 1 1 12 10 2 2

3 11 3 3

4 100 4 4

5 101 5 5

6 110 6 6

7 111 7 7

8 1000 10 8

9 1001 11 9

10 1010 12 A

11 1011 13 B

12 1100 14 C

13 1101 15 D

14 1110 16 E

15 1111 17 F



6.

Nagyon fontos az egyes számrendszerek közötti konverzió.

Bináris ->Oktális:

Osszuk hárombites csoportokra a számot. Az első 3 bit közvetlenül balról (vagy jobbról) a

decimális pont után (ezt gyakran bináris pontnak hívjuk) alkot egy csoportot, a tőlük balra eső 3 bit akövetkező csoportot és így tovább. Minden egyes ilyen hárombites csoportot direkt módon

konvertálhatunk egy egyszerű oktális számjegyre 0-tól 7-ig.

Lehet hogy szükséges egy vagy két kezdő vagy záró 0-val kitölteni a hárombites sorozatokat.

Pl.: 0 001 100 101 001 000 . 101 101 100

1 4 5 1 0 . 5 5 4

Oktális -> Bináris:

Minden oktális számjegyet cseréljünk le egy vele ekvivalens hárombites számra.

Hexadecimális -> Bináris:

Hasonló az oktálisból binárisba történő konverzióhoz, kivéve, hogy minden hexadecimális

jegy megfelel egy négybites csoportnak az előzőekben használt három bit helyett.

Pl.: 7 B A 3 . B C 4

0111 1011 1010 0011 . 1011 1100 0100

Bináris -> Hexadecimális:

Mint a binárisból oktálisba, csak 3 helyett 4 bites csoportokat kell létrehozni.

Decimális -> Bináris:

Pl.: 23,375 átszámítása kettes számrendszerbe.

Egész rész: Tört rész:

/2 marad egész *2

23 1 0.37511 1 0 .750

5 1 1 .500

2 0 1 .000

1 1

101112 0,0112

23,375 = 10111,0112

Véges tizedes tört nem biztos, hogy binárisan is véges!



7.

Bináris -> Decimális:

A legegyszerűbb módszer, amikor összegezzük a kettő azon hatványait, ahol 1-es volt a kitevőben.

Pl.: 10110 = 24 + 22 + 21 = 16 + 4 + 2 = 22.

A negatív számok megjelenítésére négy különböző módszert is használnak.

1. Előjeles nagyság (signed magniture)

Ebben a rendszerben a legbaloldalibb bit az előjelbit (a 0 , és az 1 -), és a maradék bitek

jelzik a szám abszolút értékét.

2. Egyes komplemens (one’s complement) Az egyes komplemensnek is van előjelbitje, amelynél a 0 jelenti a pozitív, 1 a negatív számot.

Azért, hogy negáljuk ezt a számot, minden 1-est 0-ra cseréljük, és minden 0-t 1-esre. Ez

természetesen az előjelbitre is vonatkozik. Az egyes komplemens képzése elavult rendszer.

Pl.: +25 =00011001,

- 25 =11100110.

Jellemzők:

a nulla kétféleképpen ábrázolható,

a legkisebb szám -127, a legnagyobb 127.

3. Kettes komplemens (two’s complement) A kettes komplemens szintén tartalmaz előjelbitet, amely 0 a pozitív, 1 pedig a negatív

számok esetében. Egy szám átváltásánál negálni kell az eredeti számot, valamint hozzá k ell adni

egyet.

Pl.: +25 =00011001

-25 =11100110 egyes komplemens,

-25 =11100111 kettes komplemens.

Jellemzők:

a nulla egyértelműen ábrázolható,

a legkisebb szám -128, a legnagyobb 127.

4. Többletes

A negyedik rendszer, amit m bites szám esetében 2m-1-többletesnek hívunk, úgy tárol egy

számot, mint saját magának és a 2m-1

-nek az összegét. Például egy 8 bites számra m = 8, a rendszert128 többletesnek nevezzük, és egy számot úgy tárolunk, mint a valódi számot plusz 128. Így a -3

megfelelője: -3 + 128 = 125, azaz a -3-at egy nyolcbites számként ábrázolva 125-öt jelent (01111101).

A -128-tól 127-ig elhelyezkedő számokat így meg tudjuk feleltetni 0-tól 255-ig terjedő számoknak,

amelyeket 8 bites pozitív számként fejezhetünk ki. Érdekességképpen igaz, hogy ez a rendszer azonos

a kettes komplemenssel fordított előjelbittel.

Pl.: +25 = 10011001 25 + 128 = 153

- 25 = 01100111 - 25 + 128 = 103

Jellemzők (128 többlet esetén):

a nulla egyértelműen ábrázolható, a legkisebb szám -128, a legnagyobb 127.



8.

3. Lebegőpontos számok. IEEE 754 szabvány.

A lebegőpontos számok:

A nagyság és a pontosság szétválasztásának módja, hogy a számokat a jól ismert tudományos jelöléssel fejezhetjük ki:

e f n 10* ahol az f a törtrész (fraction), vagy mantissza (mantissa) és az e egy pozitív vagy

negatív szám, amelyet kitevőnek vagy exponensnek (exponent) hívunk. Ennek a jelölésnek a

számítógépes verzióját lebegőpontos számnak (floating point) hívjuk.

Pl.: 3,14 = 0,314 x 101 vagy 0,000001 = 0,1 x 10-5 = 1,0 x 10-6

A kitevő nagysága a nagyságrendet tartalmazza, a pontosságot pedig a törtrész jegyeinek a

száma határozza meg. Mivel különböző módon fejezhetünk ki egy adott számot, az egyik formát

általában szabályosnak nevezzük a sok forma közül. A leggyakrabban a törtrész első számjegye az

adott szám első, nullától különböző számjegye (normalizált alak).

Pl.: 254 = 0,0254 x 104

= 0,254x103

(= 2,54x102)

Megjegyzések:

A nulla ábrázolásához külön megállapodásra van szükség (általában csupa nulla számjegybőláll).

A lebegőpontos ábrázolásoknál is meghatározható a legkisebb és a legnagyobb ábrázolhatószám, továbbá a legkisebb és legnagyobb hiba.

Máté: Architektúrák 1. előadás 43

Feladat: Ábrázoljuk nyolcas számrendszerben 25410-et: elő jelbittel kezdve, a kitevő legyen 1 jegyű(3 bites), 4-többletes, a törtrész 4 jegyű.

Megoldás: 254/8 6

31/8 7

3/8 3

3768, normalizált alak: 0,376x83,

a megoldás: 0 111 011 111 110 0002

= 0737608

+ törtrész

4-többletes kitevő



9.

Az IEEE 754-es lebegőpontos szabvány:

Körülbelül 1980-ig minden számítógépgyártónak saját lebegőpontos formája volt,

természetesen mindegyik más és más. Ennél is rosszabb, hogy néhányan valóban rosszul kezdték a

lebegőpontos számítási módszereket, amelyeknek néhány finomságát az átlag hardvertervező nem

ismeri. Ezért az 1970-es évek végén az IEEE felállított egy bizottságot a lebegőpontos számításokszabványosítására. Ez a munka vezetett el az IEEE 754-es szabványhoz. A szabvány 3 formát

(pontosságot) definiál, az egyszeres pontosságot (32 bit), a dupla pontosságot (64 bit) és a

kiterjesztett pontosságot (80 bit). A kiterjesztett arra szolgál, hogy csökkentse a kerekítési hibákat.

Ezt főleg a lebegőpontos aritmetikai egységben használják. Mind az egyszeres, mind a dupla

pontosságú forma a kettes alapot használja a törtrészben, és a többletes jelölést a kitevőben.

Mindkét forma egy előjelbittel kezdődik, ahol a 0 a pozitívat, 1 a negatívat jelöli. Ezután következik a

kitevő, amely 127-többletes kitevőt használ a szimpla pontosságban és 1023-többletest a dupla

pontosságban. A minimum (0) és a maximum (255 és 2047) kitevőket nem használjuk a normalizált

számoknál, ezek használata speciális. Végül a törtrészek következnek, 23 illetve 52 biten.


IEEE 754 standard

single 32 bites, double 64 bites (, extended 80 bites).

single: Ha 0 < a kitevőrész < 255, a szám normalizált.

Normalizált tört vezető 1-es bitje nincs ábrázolva!

52 bit11 bit

1023-többletes1 bitdouble

23 bit8 bit

127-többletes1 bitsingle

| törtrész |kitevőrészelő jeltípus


Normalizált számok (IEEE 754, single)

0 < kitevőrész < 255

kitevőrész = kitevő + 127, 127 többletes.

Lehetséges kitevők: -126, -125, ... , +127.Közvetlenül a törtrész elé kell képzelni egy 1-est

(implicit bit) és a bináris pontot.

Az ábrázolt szám: ± (1 + törtrész) * 2kitevő

Pl.: 1 0011 1111 1000 ... 00002 = 3F80 000016

0,5 0011 1111 0000 ... 00002 = 3F00 000016

-1,5 1011 1111 1100 ... 00002 = BFC0 000016

± kitevőrész 1. törtrész


Normalizálatlan számok (IEEE 754, single)

Ha a kitevőrész = 0A bináris pontot 0 előzi meg (nincs ábrázolva).Az ábrázolt szám: ± (törtrész) * 2-127

Pl.: 2-128 = 2-127 * 0,100 ... 00002 == 0000 0000 0100 ... 0000

2= 0040 0000

16- 2-150 = - 2-127 * 0,000 ... 00012 == 1000 0000 0000 ... 00012 = 8000 000116

2-127 = 2-127 * 1,000 ... 00002 = 0000 0000 0111 ... 11112 = 007F FFFF16

± kitevőrész 0. törtrész


Normalizálatlan számok (IEEE 754, single)

Ha a kitevőrész = 255

Túl nagy számok (túlcsordulás):

• (végtelen): pl. 1/0,

• NaN (Not a Number): pl. /



10.

4. Hamming távolság. Hibaészlelő, hibajavító kódok.

Az elektromos hálózatban keletkező áramlökések és egyéb okok miatt a számítógépek

memóriái néha hibáznak. Ezeknek a hibáknak a kiszűrésére bizonyos memóriák hibafelismerő vagy

hibajavító kódot alkalmaznak. Ezek használata esetén minden memóriabeli szót kiegészítenekspeciális bitekkel. Egy szó kiolvasása során a kiegészítő biteket ellenőrzik, hogy a hiba kiderüljön.

Tegyük fel, hogy egy memóriabeli szó m adatbitből áll, ehhez adunk még r redundáns vagy

más néven ellenőrző bitet. A teljes hossz legyen n (vagyis n = m + r). Egy n bites (m adatbitet és r

ellenőrző bitet tartalmazó) egységet gyakran n bites kódszónak neveznek.

Ha adott két szó, mondjuk 10001001 és 10110001, akkor megállapíthatjuk, hogy hány

bitpozíción térnek el. Az ellenőrző kódszavak 3 bitpozíción különböznek. Az eltérő bitpozíciók

számának megállapításához egy egyszerű logikai KIZÁRÓ VAGY műveletet kell végezni a két kódszón,

majd megszámolni az eredmény 1-es bitjeit. Az eltérő bitpozíciók számát a két kódszó Hammingtávolságának nevezzük. Ennek az a jelentősége, hogy ha 2 kódszó távolsága d, akkor d darab

egyszeres bithibának kell előfordulnia, ahhoz hogy az egyik kódszó a másikba alakulhasson. Például

az 11110001 és a 00110000 Hamming távolsága 3, mert 3 egyszeres bithiba szükséges ahhoz, hogy az

egyik a másikba alakulhasson.

Egy m bites memóriaszó esetén mind a 2m bitminta előfordulhat, de a redundáns bitek

kiszámításának szabálya miatt a 2n kódszó közül csak 2

m érvényes. Ha egy memóriaolvasás

érvénytelen kódot ad, akkor a számítógép azonnal tudja, hogy memóriahiba lépett fel. Az ellenőrző

biteket kiszámító algoritmus ismeretében meghatározható az összes érvényes kódszó listája, majd

ebben a listában meg lehet keresni azt a két kódszót, amelynek a Hamming távolsága minimális. Ezaz érték a teljes kódolás Hamming távolsága.

Egy kódolás hibafelismerő és hibajavító képessége a Hamming távolságtól függ: d egyszeres

bithiba felismeréséhez d1 távolságú kódolás kell, mert ebben az esetben d egyszeres bithiba

semmiféleképpen nem alakíthat át egy érvényes kódszót egy másik érvényes kódszóvá.

Hasonlóképpen, d egyszeres bithiba javításához 2d1 távolságú kódolás kell, mert így az érvényes

kódszavak olyan távol vannak egymástól, hogy még d egyszeres bithiba esetén is az eredeti kódszó

minden más kódszónál közelebb van, így egyértelműen meghatározható. Egyszerű hibafelismerő

kódolásra példaként tekintsük azt a kódolást, amikor az adatbitekhez egyetlen paritásbitet adunk. A

paritásbit értékét úgy határozzuk meg, hogy a kódszóban páros (vagy páratlan) számú 1 -es legyen.Ennek a kódolásnak a távolsága 2, mert minden egyes bithiba hibás paritású kódot eredményez.

Egyetlen bithiba felismeréséhez lehet használni. Ha hibás paritású szó kerül kiolvasásra a

memóriából, akkor hibaüzenetet kapunk.



11.

Egy hibát javítani képes, kódoláshoz szükséges ellenőrző bitek száma:

Szó hossza Ellenőrző bitek Teljes hossz Hozzáadott bitek %a

8 4 12 50

16 5 21 31

32 6 38 1964 7 71 11

128 8 136 6

256 9 265 4

512 10 522 2

Tetszőleges hosszúságú memóriaszavak hibajavító kódolására használt Hamming algoritmus,

mellyel az elméleti alsó korlát számolható ki:

A kódolás során r redundáns bitet adunk egy m bites szóhoz, így a kódszó teljes hossza n = m + r bit lesz. A biteket nem 0-val, hanem 1-gyel kezdődően sorszámozzuk, a legnagyobb helyi

értékű lesz az 1-es sorszámú. Minden olyan bit paritásbit lesz, amelynek sorszáma 2 hatványa; a többi

adatbit. Például egy 16 bites kódszóhoz 5 paritásbitet adunk. Az 1, 2, 4, 8, 16 pozíción vannak a

paritásbitek, a többi mind adatbit. A memóriaszó összesen 21 bites. Ebben a példában páros paritást

fogunk használni.

Minden paritásbit meghatározott bitpozíciókat ellenőriz; a paritásbit értékét úgy állítjuk be,

hogy az ellenőrzött pozíciókon lévő 1-esek száma páros legyen. Az egyes paritásbitek által ellenőrzött

bitpozíciók:

1.bit: 1, 3, 5, 7, 8, 9, 11, 13, 15, 17, 19, 21

2.bit: 2, 3, 6, 7, 10, 11, 14, 15, 18, 19

4.bit: 4, 5, 6, 7, 12, 13, 14, 15, 20, 21

8.bit: 8, 9, 10, 11, 12, 13, 14, 15

16.bit: 16, 17, 18, 19, 20, 21



12.

5. Digitális logikai szint. Kapuk. Boole algebra. Boole függvények megvalósítása, áramköri ekvivalenciája. A Boole algebralegfontosabb azonosságai, dualitás.

A digitális logikai szint a számítógép hierarchiáját bemutató táblázat legalján található, ezalkotja a számítógép igazi hardverét. Az alapelemek, amelyekből minden digitális számítógép felépül,

meglehetősen egyszerűek. Digitális áramköröket készíthetünk néhány nagyon egyszerű elem

különböző kombinálásával.

A digitális áramkör egy olyan áramkör, amelyben csak két logikai érték van jelen. Tipikusa n a

0 és az 1 Volt közötti jel reprezentál egy értéket (bináris 0) és a 2 és 5 Volt között ábrázol egy másik

értéket (bináris 1). Más feszültségek nem megengedettek. A pici elektromos eszközök, amelyeket

kapuknak hívunk, kétértékű jelek különböző függvényeit tudják kiszámítani. Ezek a kapuk alkotják azt

a hardverbázist, amelyből minden digitális számítógép felépül. Minden modern digitális logika végül

is azon a tényen alapul, hogy egy tranzisztor úgy tud működni, mint egy nagyon gyors bináris(kétállapotú) kapcsoló.

Az alábbi ábrán bemutatunk

egy bipoláris tranzisztort (a kör), mely

be van ágyazva egy egyszerű

áramkörbe. A tranzisztornak három

kapcsolata van a külvilággal: a

kollektor, a bázis és az emitter. Amikor

a bemenő feszültség, V be bizonyos érték

alatt van, a tranzisztor zárt állapotban

van, és úgy viselkedik mint egy végtelen

ellenállás. Ez azt okozza, hogy az

áramkör outputja, V ki közel van a V cc

értékéhez, ami egy külsőleg vezérelt

fezültség, tipikusan 5 Volt az ilyen

típusú tranzisztoroknál. Amikor V be meghaladja a kritikus értéket, a tranzisztor kinyit, és úgy

viselkedik, mint egy vezeték, és ezzel azt okozza, hogy a V ki -t lehúzza a földhöz (lecsökkenti a

megállapodás szerinti 0 Voltra). Nagyon fontos dolog, hogy amikor a V be alacsony, akkor a V ki magas,

és fordítva. Ez az áramkör így egy fordító (inverter), amely a logikai 0 -t logikai 1-gyé konvertálja, és alogikai 1-et pedig logikai 0-vá.

Az ábrán két tranzisztor van

egymás után sorba kötve. Ha V1 és

V2 is magas, mindkét tranzisztor

vezetni fog, és V ki alacsony lesz. Ha

valamelyik bemenet alacsony, a

megfelelő tranzisztor zárva lesz, és a

kimenet pedig magas. Tehát a V ki

akkor és csak akkor lesz alacsony, hamind a V1, mind a V2 magas.

Máté: Architektúrák 2. eloadás 29

NEM ( NOT ) kapu (3.1. ábra).

Emitter

BázisKollektor

+ Vcc

Vbe

Vki+ Vcc

0 + Vcc

0

Tranzisztor

0110XAIgazság

tábla:

Szimbolikus jelölése:A X

NEM (NOT) kapu, inverter

erosíto Inverziós gömb

+ Vcc+ Vcc


NEM-ÉS ( NAND) kapu

110101

1

0B

01

10XAIgazság

tábla:+ Vcc

V1

Vki

V2

Szimbolikus jelölése

A

BX



13.

Az alábbi ábra két tranzisztor

párhuzamos kapcsolását tartalmazza a

soros helyett. Ebben a felépítésben, ha

valamelyik bemenet magas, akkor a

megfelelő tranzisztor vezet, és a

kimenetet levezeti a földbe. Ha a két

bemenet alacsony, akkor a kimenet

magas marad.

Ez a három áramkör vagy azonos megfelelőik alkotják a három legegyszerűbb kaput. Neveik

rendre: NEM (NOT), NEM-ÉS (NAND) és NEM-VAGY (NOR) kapuk.

Az ÉS (AND) és VAGY (OR) kapuk működését nem részletezem, a fentiekhez nagyon hasonló.

A kapuk kombinációjából felépíthető áramkörök leírásához egy új típusú algebra szükséges,

amelynek változói és függvényei vannak, és csak 0 és 1 értéket vesznek fel. Egy ilyen algebrát Boole-

algebrának hívnak, felfedezőjéről George Boole, angol matematikusról elnevezve. Csakúgy mint ahagyományos algebrában, itt is függvényeket értelmezünk. A Boole függvényeknek egy vagy több

bemeneti változója van és egy eredmény keletkezik, amely csak ezen változó(k) értékétől függ. Mivel

az n változós Boole függvénynek csak 2n lehetséges kombinációja van, a függvényt teljesen leírhatjuk

egy 2n sorral rendelkező táblázattal, ahol egy-egy sor megmondja a bemeneti értékek különböző

kombinációja mellett a függvény értékét. Ezt a táblázatot igazságtáblázatnak nevezzük.


NEM-VAGY ( NOR) kapu

+ Vcc

Vki

010

0011

0B

01

10XAIgazság tábla:

V1 V2


A

BX


ÉS kapu

010

001 1

0B

11


Szimbolikus jelöléseA

BX


VAGY kapu

110

101

1

0B

11


Szimbolikus jelöléseA

BX



14.


Pl. 3 változós többségi függvény (3.3. ábra):értéke 1, ha legalább két operandus 1

1111

1011

11010001

1110

0010

0100

0000

MCBA

ABC C ABC B A BC A M

Igazság tábla:

Bool algebrai alakja:

A fölülvonás a NEM (negáció),

az egymás mellé írás az ÉS,

a + a VAGY muvelet jele.


Boole függvény megvalósításának lépései:• igazságtábla,• negált értékek,• ÉS kapuk bemenetei,• ÉS kapuk,• VAGY kapu, kimenet.

11111011110100011110 0010

01000000MCBA

A

B

C

M

A B C A B C

ABC C ABC B A BC A M


NAND és NOR elonye: teljesség (3.4. ábra).

NOT

AND OR


Definíció: Akkor mondjuk, hogy két boole függvényekvivalens, ha az összes lehetséges bemenetre a kétfüggvény azonos kimenetet ad.

Két boole függvény ekvivalenciája könnyenellenorizheto az igazság táblájuk alapján.

Pl.: AB + AC és A(B + C) ekvivalens (3.5. ábra).

Az elso függvény megvalósításához két ÉS és egyVAGY kapura van szükség, a másodikhoz elegendoegy ÉS és egy VAGY kapu.


Néhány azonosság (3.6. ábra)

A+B=ABAB=A+BDe Morgan

A+AB=AA(A+B)=AAbszorpciós

A(B+C)=AB+ACA+BC=(A+B)(A+C)Disztribúciós

(A+B)+C=A+(B+C)(AB)C=A(BC)Asszociatív

A+B=B+AAB=BAKommutatív

A+A=1AA=0Inverz

A+A=AAA=AIdempotens

1+A=10A = 0Null0+A=A1A = AIdentitás

VAGY forma ÉS formaSzabály


Disztribúciós szabály:

A+BC=A+(BC)=(A+B)(A+C)

Jelölje az ÉS muveletet 8 , a VAGY muveletet 7 ,akkor

A 7 (B 8 C) = (A 7 B) 8 (A 7 C)



15.

6. Kombinációs áramkörök, multiplexer, demultiplexer, dekódoló,összehasonlító, programozható logikai tömbök.

A digitális technika nagyon sok alkalmazása megkívánja, hogy egy áramkör többszörös

bemenettel és többszörös kimenettel rendelkezzen, és benne a kimeneteket csak a pillanatnyibemenetek határozzák meg. Az ilyen áramkört kombinációs áramkörnek hívjuk. Most vizsgáljunk meg

néhány gyakran használt kombinációs áramkört.

A digitális logika szintjén a multiplexer egy olyan áramkör, amely 2nadatbemenettel, 1

adatkimenettel és n darab vezérlőbemenettel rendelkezik, az utóbbiak kiválasztanak egy

adatbementet. A kiválasztott adatbemenetre azt mondjuk, hogy útképzéssel irányított vagy

„kapuzott” (gated) a kimenetre.

Az alábbi ábra egy nyolc

bemenetes multiplexer vázlatos ábrájátmutatja. A három vezérlővonal, az A, B

és C egy hárombites számot kódol,

amely meghatározza, hogy a nyolc

bemenő vonal közül melyiket kapuzzuk

a VAGY kapukra és ennek megfelelően

a kimenetre. Bármilyen értékek vannak

a kontroll vonalakon, hét ÉS kapunak

mindig 0 lesz a kimenete, egy kapunak

pedig vagy 0 vagy 1 lesz a kimenete a

kiválasztott bemeneti vonal értékétőlfüggően.

Az n vezérlőbemenetű

multiplexerekkel könnyedén lehet

megvalósítani n változós bool

függvényeket. Egy másik alkalmazásuk:

párhuzamosból sorosba történő

adatkonverterként való használat. A 8

bites adatot elhelyezzük a bemeneti

vonalakon, és ezután avezérlővonalakkal sorban lépegetünk

000-tól 111-ig , ezzel a 8 bitet egymás

után helyeztük el az egyetlen

kimenetre.

A demultiplexer a multiplexer inverze, amely egy egyedi bemenő jelet irányít a 2n kimenet

valamelyikére az n vezérlővonal értéktől függően.


• Multiplexer: 2 n adatbemenet, n vezérlo bemenet,1 kimenet. Az egyik adatbemenet kapuzott (gated) akimenetre (3.11. ábra).D0

D1

D2

D3

D4

D5

D6

D7

A B C

F

C

D0

D1

D2

D3

D4

D5

D6

D7

A B

F

Sematikus rajza


n vezérlo bemenetu multiplexerrel tetszés szerinti nváltozós bool függvény megvalósítható az adatbemenetekmegfelelo választásával. Pl. a 3 változós többségi függvény:

11111011110100011110001001000000MCBA

Vcc

C

D0

D1

D2D3D4

D5D6D7

A B

F

3.12. ábra

Igazság tábla:

Párhuzamos-soros átalakítás:vezérlo vonalakon rendre: 000, 001,… 111.



16.

Dekódolónak nevezzük azt az áramkört, amely n bites számot használ bemenetként, és ki

tudunk vele választani (be tudjuk állítani 1-re) pontosan egyet a 2n kimenet közül.

Egy másik hasznos áramkör az összehasonlító, amely két bemeneti szót hasonlít össze. Az

alábbi ábrán ábrázolt egyszerű összehasonlító két bemenettel dolgozik, A és B, mindegyik 4 bit

hosszú, és 1-et ad eredményül, ha a bemenetek azonosak, és 0-t ha különbözők. Az áramkör KIZÁRÓ

VAGY kapun alapul (a kizáró vagy tagadása).

Egy nagyon általános lapka a programozható logikai tömb, vagy PLA szolgál a szorzat-

összeg képzésére. A fenti ábra egy egyszerű példát mutat be, ennek a lapkának 12 változó számára

van bemeneti vonala, és 6 kimeneti vonala is van. A kis négyzetek a biztosítékokat tartalmazzák,

amelyek kiégetésével meghatározható a végrehajtandó funkció. Az olvadóbiztosítékokat két

mátrixban helyezték el: a felső az ÉS kapuk, az alsó a VAGY kapuk számára.


D0

D1

D2

D3

D4

D5

D6

D7

D0

D1

D2

D3

D4

D5

D6

D7

multiplexer demultiplexer

• Demultiplexer: egy egyedi bemenetet irányít az n vezérlobemenet értékétol függoen a 2 n kimenet egyikére


D0

D1

D2

D3

D4

D5

D6

D7

dekódoló

D0

D1

D2

D3

D4

D5

D6

D7

demultiplexer

• Dekódoló: n bemenet, 2 n kimenet. Pontosan egy kimenetenlesz 1 (3.13. ábra). Demultiplexerrel: a bemenetet igazraállítjuk.


KIZÁRÓ VAGY kapu

110101

1

0

B

01

00

XA

Igazság tábla:


A

BX

• Összehasonlító (comparator): (3.14. ábra).

A0

B0

A1

B1

A2

B2

A3

B3

A = B

4 bites összehasonlító


• Programozható logikai tömbök: PLA (3.15. ábra)(Programmable Logic Array).

0

1

49

0 1 5

A B L

12 bemeno jel

Ha ezt a biztosítékot kiégetjük,akkor nem jelenik meg #B az1-es ÉS kapu bemenetén

Ha ezt a biztosítékotkiégetjük, akkor az 1-es ÉSkapu kimenete nem jelenikmeg az 5-ös VAGY kapu

bemenetén

24 bemenovonal

50 bemenovonal

6 kimenet



17.

7. Aritmetikai áramkörök. Léptető, fél és teljes összeadó, ALU,átvitel továbbterjesztő és kiválasztó összeadás.

Aritmetikai áramkörök

ezek már kombinációs MSI áramkörök, aritmetikai műveleteket lehet velük végezni

Léptetőregiszter

8 bites (8 bemenet, 8 kimenet) egyszerű léptető

D0,…,D7: bemenő bitek

S0,…,S7: kimenő bitek

C: vezérlővonal

a kimenő bitekben a bemenő bitek pontosan 1 bittel vannak eltolva

a vezérlővonal határozza meg a léptetés irányát, 0: balra, 1: jobbra

minden bithez ÉS kapupárok tartoznak, kivéve a végeken ( S0, D7)

amikor C=1, minden kapupár jobb oldala aktivizálódik, és a megfelelő bemenő bitet küldi akimenetre. (D0 > S1, D1 > S2, D2 > S3, …)

mivel a jobb oldali ÉS kapu kimenete össze van kötve a tőle jobbra eső VAGY kapu bemenetével, jobbra léptetés hajtódik végre.

C=0 esetén az ÉS kapupár baloldali tagja kapcsolódik be és bal oldali léptetés megy végbeugyanezen a módon

Fél összeadó áramkör (half adder)

Az „Összeg” kimenethez A és B KIZÁRÓ-VAGY (XOR) eredménye kerül

Az „Átvitel” kimenethez pedig A és B ÉS (AND) ereménye kerül



18.

Teljes összeadó áramkör (full adder)

Két „fél összeadó” áramkörből épül fel Azért van szükség erre, mert ha pl. két darab 1 báj tos (8 bites) bemenő értéket akarnánk

összeadni, akkor az alsó biteken való összeadást még jól elvégezné, de amikor a felső bitekbe lépaz összeadás (felső 4-be), akkor ott nem kezeli az alsó bitekből érkező átvitelt. Olyankor

újrakezdené az összeadást ezzel elveszítve egy lehetséges átviteli értéket, vagyis a 2x4 bitet (alsóés felső) külön-külön adja össze, a köztük levő átvitelt pedig nem kezelné (alsó bitekbenkeletkezőt nem vinné át a felső bitekbe).

Átvitelt kezelő / továbbterjesztő összeadó áramkör (ripple carry adder)

Ahhoz viszont, hogy pl. két szavas (= word = 2 byte = 16 bit) bemenő értéket adjunk össze a fenti(Teljes összeadó) áramkört 16-szor meg kell ismételnünk.

Ez úgy néz ki, hogy a fenti ábra 16-szor egymás mellé van pakolva, az egész balról-jobbra halad, a

bal oldali áramkör a jobb oldalihoz úgy kapcsolódik, hogy a bal oldali „Átvitel ki” a tőle jobbra levő„Átvitel be” részhez van kapcsolva, a legjobboldalibb (a legutolsó) áramkörnél pedig az „Átvitelbe” bitet 0-nak vesszük.

Átvitel-kiválasztó összeadó áramkör (carry select adder)

Az előző áramkörnél legrosszabb esetben, ha pl. 1b-t és 1111 1111b-t hozzáadjuk egymáshoz,akkor látjuk, hogy az átvitelt folyamatosan át kell adnia a következő bitnek, és a legfontosabb,hogy az alsó és felső bitek között is az áramköröknek, hogy ne vesszen el sehol az átvitel.



19.

Az átvitel-kiválasztó áramkör ennél a megoldásnál 2-szer gyorsabb, ugyanis ha pl. egy 32 bites

összeadót nem 1 felső 16 bitesre és 1 alsó 16 bitesre bontunk, hanem 1 alsó 16 bitest és 2 felső 16

bitest csinálunk (ezzel megduplázva a felső összeadó hardverét) megtehetjük azt, hogy egy időbenelindítjuk mind a 3 összeadót, mert ugye a sima átvitelt kezelő áramkörnél először végig kell futniaaz alsó 16 bitesnek, hogy meglássuk van-e átvitel, amit a felső 16 bitesbe át kell adni. E helyett a 2

felső 16 bitest elindítjuk egyszerre az alsó 16 bitessel együtt, az egyik felső 16 bites összeadót„Átvitel be” = 1 értékkel, a másikat pedig „Átvitel be” = 0 értékkel. Amikor pedig lefutott mind a 3áramkör, az alsó 16 bites összeadás végeredménye már ismert lesz, azaz ilyenkor már ki tudjuk

választani, hogy melyik felső 16 bites összeadás végeredményét használjuk fel, attól függően,hogy volt-e átvitel vagy nem. Ezzel megfelezve a végrehajtási időt az átvitelt kezelő áramkörhöz

képest.

Aritmetikai-logikai egység (ALU)

Ez a példa a következő funkciók bármelyikét végre tudja hajtani: ÉS, VAGY, NEGÁCIÓ, (összeadás), ez F0, F1 bemenő értékeitől függ (00, 01, 10, 11).

Dekódoló: 2 bites, a négy művelet számára létrehozza az engedélyező jeleket

Logikai egység: (szaggatott négyzet) a négy művelet itt végződik el, közülük csak egy haladhat át alegutolsó VAGY kapun.

Mivel pontosan egy dekódolókimenet értéke lehet 1, így ezért a 4 ÉS kapuból csak pontosan egy

fog működni, a többi 3 kimenete 0 lesz, függetlenül A és B értékétől.

Normál esetben az ENA és ENB értéke 1, hogy engedélyezze a bemeneteket, INVA pedig 0. Ebbenaz esetben A és B a logikai egységbe módosítás nélkül kerülnek be.

Teljes összeadó: A és B összegét számolja ki átvitellel együtt.

Ezek az áramkörök Bitszeletek néven ismertek (bitslices) Ezek segítségével bármilyen hosszúságú ALU-t lehet építeni, pl. egy 8 bites ALU:



20.

8. Nem kombinációs áramkörök. Órák, tárolók, flip-flop-ok.

Óra

Célja, hogy a digitális áramkörökben az események történésének sorrendjét felügyelje.

Az óra ebben az értelemben egy áramkör, amely a pulzusok egy sorozatát bocsá jtja ki egy

pontosan meghatározott pulzusszélességgel, és két egymás utáni pulzus közötti időintervallummalrendelkezik.

A ciklusidő két egymást követő pulzus élei közötti időintervallum.

A pulzus frekvenciája általában 1 és 500 MHz közöt van, ennek megfelelően az órajel 1000 ns-tól 2ns-ig terjedhet.

Az óra frekvenciáját általában egy kristályoszcillátor vezérli. Ha több eseménynek kell lefutnia egy órajel alatt egy adott sorrendben, akkor az órajelet

alciklusokra kell osztanunk. Lényege, hogy az alapáramkört megcsapoljuk, és beszúrunk egyáramkört ismert késleltetéssel, így készíthetünk másodlagos órajelet, amely fáziseltolással

keletkezik az elsődlegesből.

SR-Tároló

Ahhoz, hogy legalább 1 bites memóriát készítsünk, szükségünk van egy áramkörre ami valahogyan

visszamelékszik az előző bemeneti értékre.

Egy ilyen áramkört 2 NEM-VAGY kapuból építhetünk.

S: Set (bemenet)

R: Reset (bemenet)

Q, #Q: két kimenet, amelyek egymás fordítottjai

Stabil állapot: a két kimenet 1,0 vagy 0,1



21.

Az ilyen tárolókat SR-tárolóknak (Set Reset latch) hívjuk.

A fenti két ábrán látható, hogy milyen két értéke lehet Q -nak és #Q -nak, ha S = R = 0; ha viszont

S = 1 és R = 0, akkor az S utáni NOR kapu vagy 1,0 vagy 1,1 lesz Q -tól függően, de amint atáblázatból látjuk az eredményen ez nem változtat.

Ha S = 0, R = 1, akkor az R utáni NOR kapu vagy 0,1 vagy 1, 1 #Q-tól függően, amelyek kimenete a

NOR kapuból szintén ugyanaz. Tehát a Q, #Q értékeitől függetlenül működnek a beállító bemeneti értékek: ha S = 1, akkor Q = 1

lesz, ha R = 1, akkor Q = 0 lesz. Az áramkörnek pedig mint tudjuk két stabil állapota is van, amikor

S = R = 0, azaz a két fajta beállítási értékre emlékezni fog.

Időzített SR-Tároló

Módosított SR-tároló, az állapotváltozás csak egy bizonyos időpillanatban fog töténni. Az áramkör további bemenete: órajel, ami alaphelyzetben 0.

Amikor óra = 0, az ÉS kapuk kimenete 0 lesz, tehát a stabil állapotban marad az áramkör; amikoróra = 1, az ÉS kapuk kimenete már S és R bemeneti értékétől függnek majd. (pl: S = 1, óra = 1,

R = 0, akkor a fenti kapu 1,1, tehát 1 megy tovább, a lenti ÉS kapu 1,0, tehát 0 megy továbbkimenetnek).

Időzített D-Tároló

Módosított SR-tároló, lényege, hogy az SR-tároló bizonytalanságát kiküszöböli, ugyanis van egyeset, amikor S = R = 1, ilyenkor az SR-tárolóban a Q, és #Q értékét 0,0-ra kényszeríti ez a kétbemenet, ezután az áramkör automatán átáll valamelyik stabil pozicióra, de ezt nem tudhatjukpontosan, hogy melyikre.

Lényege, hogy csak 1 bemenete van, D így a NEM kapuval kiküszöbölhető a problém a, mindig

ellentétes értékek lesznek a két ÉS kapunál. Ez már egy igazi 1 bites memória, a tárolt érték Q -ban lesz elérhető.

Flip-flop

Célja: egy meghatározott időpontban vegyünk mintát az áramkör egy adott vonaláról.

Akkor nem fordul elő, amikor az órajel állása 1, csak akkor , amikor 0-ból 1-be (felfele él) vagy 1-

ből 0-ba (lefele él) megy.



22.

A flip-flop és a tároló közti különbség, hogy az előző élvezérelt (edge triggered), míg az utóbbiszintvezérelt (level triggered).

A fenti áramkörnek lényege, hogy létre tudunk vele hozni egy rövid impulzust az órajel felmenőrészénél.

a, b, c, d pontoknál mérjük a feszültséget, amikor a-nál a hosszú órajel impulzus megérkezik, akkorc-be is eljut, valamint b-be is, de ott már egy NEM kapun keresztül.

a NEM kapuk (más fajta NEM kapu is van) sajátossága, hogy miután megérkezik az órajel hozzájukegy kicsit késleltetve (1-10 ns) váltanak át az inverzzé. Tehát, amikor a-n van órajel, akkoregyidöben eljut c-hez és a NEM kapuhoz. Mivel a NEM kapu késleltetve vált át, abban a pici

időben még a b-n is lesz órajel, de amint letelt az a késleltetési idő, átvált az inverzre, vagyis 0-ra

és akkor már nem fog működni az ÉS kapu.

És ezt az értéket le tudjuk tárolni egy D-tárolóban, ezért hívják a fenti áramkört D-flip-flop-nak.

Tárolók és flip-flop-ok.

CK: clock / órajel

(a) CK=1 (c) CK emelkedő élénél

(b) CK=0 esetén írja be D-t (d) CK lefelé menő élénél

(a,b: tároló) (c,d: flip-flop)



23.

A következő ábrán látható két függtlen D-flip-flop:

Következő ábra: közös CK-val vezérelt 8 bites D flip-flop

S: set PR: preset

R: reset CLR: clear



24.

9. Processzor szintű párhuzamosítás

Bevezető

A számítógép-tervezők ma már ahelyett, hogy a processzorok órajelét növelnék vagy a lapkákgyorsaságát növelnék a számítógép teljesítménye növelésének érdekében, inkább apárhuzamosságban látják a teljesítmény növekedésének a kulcsát (vagyis hogy több műveletetegyszerre eltudjunk végezni, ne pedig egyet-egyet nagyon gyorsan).

Processzorszintű párhuzamosság

Lényege, hogy több processzor dolgozik egyszerre ugyanazon a feladaton.

Tömbszámítógépek:

Egy tömbprocesszor nagyszámú egyforma processzorból áll, ezek ugyanazt a műveletet végzik elkülönböző adathalmazokon.

A lenti képen egy 8x8 –as processzor/memória párból álló négyzetháló látható.

Itt a processzorok az alattuk levő memóriából olvassák ki az utasításokat, amiket egy előzőlegesinicializációs fázisban töltöttek fel.

Vektorprocesszor

Vektorregisztereket használ, ezek több hagyományos regiszterből állnak.

Ezeket egymás után sorosan tölti fel a memóriából, majd páronként úgy adja őket össze, hogy egyszállítószalagos összeadóba irányítja őket a vektorregiszterekből.

Multiprocesszorok

Egy tömbprocesszor feldolgozóegységei nem függetlenek egymástól, mert közös vezérlőegységükvan.

Ezekben viszont több teljes processzor van, közösen használják a memóriát, együttműködésüket

viszont szoftveresen kell megoldani. Többféle implementációjuk is létezik:



25.

(a) (b)

a: egy sínre vannak csatlakoztatva a processzorok (gond vele: ha több processzor egyszerrepróbálja elérni a közös memóriát, akkor ütközések keletkezhetnek).

b: saját lokális memóriával rendelkeznek a processzorok, ide azokat az adatokat tárohatják,amelyeket nem kell megosztaniuk a többi processzorral.

Multiszámítógépek

Kisebb számú processzorokból álló gépek gyártása még megoldható (<=64), de nagyobb

számúaknál már a processzorok és a memória összeköttetése nehéz.

E nehézségek miatt inkább nagyszámú összekapcsolt számítógépek rendszerét építettek,amelyeknek csak lokális memóriája van. Ezek a multiszámítógépek.

E számítógépek processzorai üzenetekkel kommunikálnak. Összeköttetésük csak ritkán „mindengépet mindennel” kötésben van, inkább 2 és 3 dimenziós hálókat, fákat, gyűrűket terveznek.

Ma már a multiprocesszor és a multiszámítógép hibrid keverékén dolgoznak.



26.

10. Gyorsító tár (cache). Találati és hiba arány. Közös és osztott gyorsító tár. Direkt leképezésű és halmaz kezelésű gyorsító tár.Memóriába írás.

Gyorsító tár / Cache

A gyorsító tárra alapvetően azért van szükség, mert a processzorok gyorsabbak, mint a memóriák,ennek oka: a fejlesztők tudnának építeni olyan gyors memóriákat , mint a processzorok, de azok

jóval nagyobb helyet foglalnának (lapkák mérete és száma), valamint sokkal drágábbak lennének.

A cél (amit a cache megvalósít): a kis méretű, gyors memória.

A cache a központi memória egy kisebb része, amit a CPU lapkájára helyeztek.

Lényege, hogy a leggyakrabban használt memóriaszavakat a gyorsító tárban tartjuk, s amikor aprocesszornak szüksége van egy szóra, akkor először a gyorsító tárban keresi, ha ott nincs, akkor

történik csak memóriaolvasás. Ha a szavak jelentős része a gyorsító tárban van, akkor az elérésiidő nagymértékben csökkenhet.

Lokalitási elv: Ha egy hivatkozás a memória A címére történik, akkor a következő valószínűlegvalahol A közelében lesz. (Ugyanis a programok a futásidejük nagy részében egymás utánimemóriacímekről dolgoznak, kivéve a vezérlésátadó utasítások és eljáráshívások.) Ha A nincs a

gyorsító tárban, akkor az A-t tartalmazó (adott méretű) blokk (gyorsító sor – cache line) kerülbeolvasásra a memóriából a gyorsító tárba.

Találati és hibaarány

Jelöljük c-vel a gyorsító tár elérési idejét, m-mel a központi memória elérési idejét! Találati arány (h): az összes hivatkozás mekkora hányadát lehetett a gyorsító tárból kielégíteni. Hibaarány (1-h): az összes hivatkozás mekkora hányadát nem lehetett a gyorsító tárból kielégíteni. Átlagos elérési idő: c + (1 – h) m

Gyorsító tár és gyorsító sor mérete

Gyorsító sor: gyorsító táron belüli blokkok. A gyorsító sorokat azért alkalmazzák, mert ha keresünk egy szót a memóriában , sokkal

hatékonyabb egy n hosszú sort beolvasni, mint n-szer beolvasni egy szót. A gyorsító tár mérete minél nagyobb, annál jobb, de egyben sokkal drágább is.

A gyorsító sor mérete is szintén annál jobb, minél nagyobb, de itt viszont a beolvasási időt növelimeg nagyban.

A kettő összhangja a legfontosabb.

Osztott és közös gyorsító tár

Az adatok és az utasítások közös (egyesített) vagy külön (osztott) tárban vannak.

Az közös gyorsító tár (az utasítások és az adatok ugyanazt a gyorsító tárt használják) egyszerűbbszerkezetű és automatikusan egyensúlyban tartja az utasítások és az adatok mozgatását.

Ma mégis az osztottat használjuk, ezt Harvard-architektúrának nevezzük.

Az osztott gyorsító tár lehetővé teszi az utasítás előolvasó és az operandus-beolvasó párhuzamosműködését, a közös nem.

Mivel az utasításokat általában nem módosítják végrehajtás közben, az utasításokat tárológyorsító tár tartalmát soha nem kell visszaírni a memóriába.



27.

Direkt leképezésű gyorsító tár

Legegyszerűbb gyorsító tár

A fenti gyorsító tárnak 2048 bejegyzése (sora), gyorsító tár vonala van.

Valid : jelzi, hogy ebben érvényes adat van-e vagy nem. Amikor boot-olunk, mindenérvénytelennek van jelölve.

Tag: egyedi 16 bites érték, ami a megfelelő memóriavonalat azonosítja, ahonnan az adat jött.

Data (bejegyzés): 32 bájtos gyorsító vonal, a memóriában levő adat másolata.

A gyorsító tárban az adatok tárolásához és kinyeréséhez 4 alkotóelemre tagoljuk a címet:

Tag: a gyorsító tárban tárolt Tag megfelelője. Line: jelzi, melyik gyorsító tár bejegyzés tartalmazza a megfelelő adatokat.

Word : megmondja, hogy egy vonalon belül melyik szóra történt hivatkozás.

Byte: ha csak egyetlen bájtra érkezik kérés, megmondja hogy a szón belül melyik bájtra vanszükség.

Amikor a CPU előállít egy memóriacímet, a hardver kiveszi a címből a 11 Line bitet, és felhasználjaindexelésre a gyorsító tárban, hogy megtalálja a 2048 bejegyzés egyikét. Ha a bejegyzés érvényes,akkor a memóriacím Tag mezője és a gyorsító tár bejegyzésének Tag mezője összehasonlításrakerül. Ha megegyeznek, akkor a gyorsító tár bejegyzés tartalmazza a keresett szót. Ezt gyorsító tár

találatnak nevezzük. Ha a gyorsító tár bejegyzése érvénytelen, vagy a címkék nem egyeznek meg, akkor a keresett

bejegyzés nincs a gyorsító tárban, ez a gyorsító tár hiány .

Halmazkezelésű gyorsító tár

Ha egy program erősen használja a 0-65536 címeken levő szavakat, állandó összeütközésbe kerülamiatt, hogy minden hivatkozás feltételezhetően kilöki a másikat a gyorsító tárból.

Ennek a megoldása az, ha két vagy több vonalat is megengedünk minden gyorsító tár bejegyzésen.

Egy olyan gyorsító tárat, amelynek minden egyes címhez n lehetséges bejegyzése van, n utas

halmazkezelésű gyorsító tárnak nevezünk.



28.

A fenti kép egy 4-utas gyorsító tár. Ha a gyorsító tár vonal által mutatott sorban A, B, C, D bejegyzés egyikében V = 1 és a hozzá

tartozó Tag megegyezik a címben levő Tag-gel akkor az adat a gyorsító tárban van. Amikor új bejegyzést hozunk létre, a bent lévő tételek közül az LRU (Least Recently Used)

algoritmust használva a legrégebben használt elemet dobja el.

Memóriába írás

Stratégiák:o Írás áteresztés: az írás a memóriába történik. Ha a cím a gyorsítóban van, oda is be kell írni,

különben el kellene dobni a gyorsító sort.o Késleltetett írás: (write deferred, write back) ha a cím bent van a gyorsító tárban, akkor csak

a gyorsító tárba írunk, a memóriába csak gyorsító sor cserénél.o Írás allokálás: (write allocation) ha a cím nincs a gyorsító tárban, akkor előtte betölthetjük –

többnyire ezt alkalmazzák késleltetett írás esetén.



29.

11. Operandus megadás módjai. Közvetlen operandus, direkt,regiszter, regiszter-indirekt, indexelt, bázis-index címzés

A legtöbb utasításnak van operandusa, ezért kell valamilyen módszer az operandus helyének

megadására. Ezt nevezzük címzésnek, és ezt fogjuk a következőkben viszgálni.

Közvetlen operandus megadás

Az operandus specifikációjának a legegyszerűbb módja, ha az operandust közvetlenül az

utasításban adjuk meg, nem pedig a címét vagy más információt, amely leírja, hogy az operandus hol

található. Az ilyen operandust közvetlen operandusnak nevezzük, mert automatikusan betöltődik az

utasítással, tehát azonnal hozzáférhető felhasználásra.

A közvetlen címzésnek az a lényege, hogy nem kíván külön memóriahivatkozást az operandus

kiolvasására. A hátránya, hogy ily módon csak konstanst lehet megadni. Továbbá, az értékek száma

korlátozott a mező méretével. Mégis sok architektúra használja ezt a technikát kis egész

konstansokkal.

Pl. MOV AL, 14h

Direkt memória címzés

A memóriabeli operandus megadása egyszerűen teljes címének megadásával megtehető. Ezt

a módot direkt címzésnek nevezzük. Mint a közvetlen címzés, a direkt címzés használata is

korlátozott: az utasítás minden végrehajtása ugyanazt a memóriamezőt érinti. Tehát amíg az érték

változhat, a hely nem, vagyis a direkt címzés csak olyan globális változók elérésére használható,

amelyek címe fordításkor ismert. Azonban sok program használ globális változókat, így ez a módszer

széles körben használatos.

A címrészen az operandus logikai címe (eltolás, displacement) szerepel.

Pl. MOV AX, Szam

ahol Szam egy változó, mivel nem adtuk meg a szegmens nevét, így az alapértelmezett szegmenset

fogja használni, azaz DS:Szam.

Fontos még, hogy úgy címezzünk hogy a két operandus mérete összhangban legyen.

Regiszter címzés

A regiszter címzés alapvetően azonos a direkt címzéssel, azzal a különbséggel, hogy

memóriacím helyett regisztert határoz meg. Mivel a regiszterek (a gyors elérés és a rövid cím miatt)

nagyon fontosak, a legtöbb számítógépen ez a címzési mód a leggyakoribb. Sok fordítóprogram

alaposan megnézi, hogy mely változókat használják a legtöbbet (pl. ciklusváltozók), és ezeket

regiszterekbe tölti.

A címzés során az átmásolni kívánt adat egy általános célú regiszterben van.

Pl. MOV AX, BX



30.

Regiszter indirekt címzés

Ebben a címzési módban is a memóriából olvassuk a specifikált operandust, vagy oda írjuk,

mint a direkt címzés esetén, de nem közvetlenül a címe van adva az utasításban. Helyette a címet egy

regiszter tartalmazza. Ha egy cí met ilyen módon adunk meg, mutatónak hívjuk. A regiszter-indirekt

címzés nagy előnye, hogy úgy hivatkozik a memóriára, hogy annak címét nem kell az utasításban

tárolni. Továbbá, az utasítás különböző végrehajtása más-más memóriamezőre hivatkozhat.

Az indexelt címzés azon speciális esete, amikor nem adunk meg displacement-et. Ennél a címzési

módnál az SI, DI és a BX regiszter használható.

Pl. MOV AX, [BX]

MOV AX, [SI]

Indexelt címzés

Gyakran jól használható, ha ismerjük egy memórai címét egy regiszter tartalmához képest.Láttunk már erre példát az IJVM esetén, ahol a lokális változókat az LV regiszterhez képest címzik. Azt

a címzési módot, amikor a hivatkozott memória címét egy regiszter értéke és egy konstans határozza

meg, indexelt címzésnek nevezzük.

Az operandusban lévő 8 vagy 16 bites számot (eltolás) hozzáadja SI vagy DI tartalmához, ez lesz az

operandus logikai címe.

Pl. MOV AX, 10h[SI]

Bázis-index címzés

Néhány gép rendelkezik olyan címzési móddal, amely úgy határozza meg a hivatkozott

memória címét, hogy összeadja két regiszter tartalmát, és (esetleg) ehhez hozzáad egy eltolási

értéket. Ezt a módot bázis-index címzésnek nevezik. Az egyik regiszter a bázis, a másik az index.

A bázis-index címzés a legösszetettebb adatcímzési mód.

BX, SI vagy DI regiszter valamelyikét használhatjuk.

Pl. MOV AX, 10h[BX][SI]

MOV AX, [BX+SI+10h]



31.

12. Sínek. Sín Protokoll. Master – szolga. Sín vezérlő, vevő, adóvevő.Sín szélessége. Sokszorozott sín. Sín időzítés: szinkron,aszinkron sín, teljes kézfogás. Sín ütemezés. Sín műveletek.

Sínek

A sín (bus) egy közös elektronikus pálya a különböző eszközök között, amelyek összekötik a

CPU-t a memóriával és a B/K berendezésekkel. A korai személyi számítógépeknek egyetlen sínje

(system bus) volt, míg a mai számítógépekben már egy speciális sín áll rendelkezésre a CPU és a

memória, és legalább egy másik sín a B/K berendezések számára. Ahhoz, hogy a különböző kiegészítő

kártyákat csatlakoztatni tudjuk a rendszerhez, nagyon jól definiált szabályokat kell meghatározni a sín

működéséről, amelyeket sín protokollnak nevezünk. Számos sínt széles körben használnak a

számítástechnika világában: Omnibus (PDP-8), Unibus (PDP-11), Multibus (8086), IBM PC (PC/XT), ISA

(PC/AT), EISA (80386), Microchannel (PS/2), PCI (sok PC –nél), SCSI (sok PC –nél és munkaállomásnál),

NUBUS (Macintosh), Universal Serial Bus (modern PC-knél), FireWire (szórakoztató elektronikában),VME (fizikai laboratóriumi berendezéseknél), Camac (nagy energiájú fizikában).

Néhány sínhez csatlakoztatott berendezés aktív (master) és ezáltal kezdeményezni tudja a

sínátviteleket, míg mások passzívak (slave) és várják a kéréseket. Amikor a CPU megrendel a

lemezvezérlőtől egy blokkolvasást vagy írást, a CPU úgy viselkedik, mint egy mester, a lemezvezérlő

pedig, mint egy szolga. Azonban később a lemezvezérlő mesterként viselkedhet, amikor kiad egy

parancsot a memóriának, hogy fogadja el azt a szót, amelyet a lemezmeghajtóból olvasott be. A

bináris jelek, amelyeket a számítógép berendezései kibocsátanak, gyakran nem elég erősek, hogy

elegendő áramot adjanak a sínnek, ezért a legtöbb sínmester összekapcsolódik a sínen egy lapkával,

amelyet sín vezérlőnek (bus driver) hívnak – ez lényegében egy digitális erősítő. Hasonlóan a legtöbb

szolga egy sínvevőn (bus receiver) keresztül kapcsolódik a sínre.

Azoknál a berendezéseknél, amelyeknél mind a mester, mind pedig a szolga tevékenységére

szükség van, egy kombinált lapka áll a rendelkezésünkre, amelyet sín adóvevőnek (bus transceiver)

nevezünk. Ezek a sínhez kapcsolódó lapkák gyakran háromállapotú (tri-state) berendezések, azért

hogy le tudjanak kapcsolódni a sínről, ha már nem szükségesek, vagy némiképp eltérő módon

rákapcsolódjanak – ezt nyitott gyűjtőnek (open collector) hívjuk.

Sínszélesség

A sín szélessége az egyik legnyilvánvalóbb tervezési paraméter. Minél több címvezetéke van

a sínnek, annál nagyobb memóriát tud a központi egység közvetlenül megcímezni. Ha egy sínnek van

n címvezetéke, akkor azt a CPU 2n különböző memóriarekesz megcímzésére tudja használni. Nagy

memória használatához a sínek sok címvezetéket igényelnek.

A szélesebb sínek több vezetéket igényelnek, mint a keskenyek. Ezenkívül több fizikai helyet

is folglalnak, valamint nagyobb csatlakozókra van szükségük. Mindezek a tényezők egyre

költségesebbé teszik a síneket.



32.

Két módon tudjuk egy sín sávszélességét megnövelni: vagy csökkenteni kell a sínciklus idejét

(több adatátvitel/s), vagy növelni kell a szélességet (több bitet kell átvinni egyszerre). Ugyan egy sínt

fel is lehet gyorsítani, de ez nehéz, mivel az egyes vezetékeken a jelek kissé eltérő sebességgel

haladnak – ez a probléma sínasszimetriaként (bus skew) ismert. Minél gyorsabb egy sín, annál

nagyobb az asszimetria.

Az idők folyamán mind a címvezetékek, mind az adatvezetékek száma is megnőtt, de

mindezek némi kompatibilitási problémákat okoztak. Hogy megkerüljék a túl széles sínek

problémáját, elkezdték alkalmazni a multiplexelt sínt (multiplexed bus). Ennél a konstrukciónál nincs

külön cím és adatvezeték hanem mindezt egyetlen vezetékkel oldották meg.

Sínek időzítése

A sínek két diszjunkt kategóriába csoportosíthatók, az időzítésüktől függően. A szinkron

sínnek van egy vezetéke, amelyre egy kristályoszcillátor van kapcsolva. Ezen a vezetéken általában 5

Mhz és 100 Mhz közé eső frekvenciájú négyszög hullámokból álló jel halad. Minden síntevékenységezeknek a négyszög hullámoknak a többszöröséig tart, ezeket hívják sín c iklusoknak (bus cycles). Az

aszinkron sínnek ilyen fő órajel generátora nincs. A sínciklusok igény szerint bármilyen hosszúságúak

és nem kell, hogy minden lehetséges eszközpár között azonosak legyenek. Ahhoz hogy ne csak a CPU

legyen a sínmester, hanem bármely eszköz lehessen sínmester egy sínütemezési (bus arbitration)

mechanizmusra van szükség, hogy elkerülhessük a káoszt.

Szinkron sín

Andrew S. Tannenbaum: Számítógép architektúrák - 198. o.

Aszinkron sín

Andrew S. Tannenbaum: Számítógép architektúrák - 201. o.

Sínütemezés

A sín ütemezési mechanizmus lehet centralizált vagy decentralizált. Sok CPU–ba be van

építve egy ütemező, de gyakran egy külön lapkára van ehhez szükség. Az ütemező számára nincs

semmilyen mód arra, hogy megtudja hány eszköz kéri a sínt. Az egyetlen dolog amit meg tud

különböztetni, az hogy van kérés vagy nincs. Amikor az ütemező egy sínkérést észlel, a sínhasználatra

egy használati engedélyezés jelet ad ki. Ez az utasítás keresztül fut az összes B/K eszközön sorban,

amikor az ütemezőhöz legközelebb álló eszköz észleli az engedélyezést, ellenőrzi hogy ő adta-e ki a

kérést. Ha igen akkor átveszi a kérést és nem továbbítja tovább az engedélyezést a többi eszköz

számára. Viszont ha nem ő adta ki a kérést akkor továbbítja az engedélyt a következő eszköz

számára. Ezt a módszert láncolásnak (daisy chaining) nevezzük.

Annak érdekében, hogy elkerüljük az ütemezőtől számított távolságon alapuló implicit

prioritásokat, sok sínnek több prioritási szintje van. Minden egyes szint tartalmaz egy sínhasználat

kérése és egy sínhasználat engedélyezése vezetéket. Ha több prioritási szinten is érkezik be kérés, az

ütemező a sínhasználati engedélyt a legnagyobb prioritásúnak fogja adni, az azonos prioritású

eszközök között pedig a láncolás működik. Bizonyos ütemezőknek van egy harmadik vezetéke,

amelyet egy eszköz akkor állít be, ha fogadta az engedélyt, és átvette a sínt. Amint ezt a nyugtázó



33.

vezetéket beállították, a kérés- és engedélyezés vezetékeket már lehet negálni. Ennek következtében

további eszközök kérhetik a sínt, mialatt az első eszköz már használja. Mire az aktuális adatátvitel

befejeződik, a következő sínmester már ki van választva. Amint a nyugtázás vezetéket negálták,

azonnal el is kezdhet dolgozni, ekkor egy újabb ütemezési forduló kezdődik. Annak érdekében, hogy

a CPU-nak ne kelljen versenyeznie a sínen lévő B/K eszközökkel, a memóriát egy a B/K eszközöktől

elkülönített sínre teszik.

A decentralizált sínütemezés esetében minden eszköz minden kérésvezetéket figyel, így

minden sín ciklus végén minden eszköz tudni fogja, a kérő eszköz volt-e a legnagyobb prioritású és

hogy megkapja-e a sínhasználat engedélyezését a következő ciklusban. Ez az ütemezési módszer több

vezetéket igényel, viszont megtakarítható az ütemező várható költsége, ezen kívül az eszközök

számát korlátozza a kérési vezetékek számára.

Sínműveletek

Rendszerint egyszerre egy szót visz át a sín, azonban amikor gyorsítótárat használnak, egyegész sor beolvasása lenne szükséges. Ebben az esetben a blokkátvitel hatékonyabb lehet, mint az

egyes szavak átvitele. Amikor egy blokkátvitel megkezdődik, a sínmester megadja a szolgának az

átvinni kívánt szavak számát és ezután minden egyes órajel-periódusban vissza fog adni egy szót,

amíg csak a számláló el nem fogy.

Egy többprocesszoros rendszerben, amelyben két vagy több CPU van rákapcsolva ugyanarra

a sínre, biztosítani kell, hogy egy időben csak egy CPU használhasson valamilyen kritikus

adatstruktúrát a memóriából. Egy tipikus megoldás erre a célra az, ha van a memóriában egy olyan

változó, amely 0, ha egyik CPU sem használja az adatstruktúrát és 1, ha használatban van. Ha viszont

mindkét CPU azt látja, hogy a kontrollváltozó értéke 0, akkor mindegyik átállítja 1-re, és azt gondolja,hogy ő az egyetlen CPU, amely használja. Egy ilyen eseménysorozat káoszhoz vezethet.

A többprocesszoros rendszerekben gyakran alkalmazunk ún. módosítás-visszaírás sínciklust,

amely lehetővé teszi, hogy bármely CPU beolvasson egy szót, megvizsgálja, és visszaírja a memóriába

anélkül, hogy lekapcsolódna a sínről. Ez a fajta sínciklus megelőzi azt, hogy egy konkurens CPU

használni tudja a sínt, és így befolyásolhassa az első CPU működését.

Létezik egy speciális sínművelet, amely a megszakítások kezelésére szolgál. Amikor a CPU

utasít egy B/K eszközt, hogy tegyen meg valamit, általában egy megszakítást vár visszajelzésként,

amikor a feladat elkészült. A megszakításkérés jelzéséhez szükség van a sínre. Mivel több eszköz

kérhet megszakítást egyszerre, ezért ütemezési problémák merülnek fel. Szokásos megoldás az, hogy

az egyes eszközökhöz prioritásokat rendelünk és egy központi ütemező használatával pedig a

leginkább kritikus eszközök számára magas prioritást adunk.



34.

13. Általános soros sín

A PCI sín és a PCI Express kiválóan alkalmazható nagy sebességű perifériák számítógéphez

kapcsolásához, azonban túlságosan drágák az alacsony sebességű perifériák, például az egér vagy a

billentyűzet számára. Történelmileg minden szabványos B/K eszköz egyedi módon kapcsolódott aszámítógéphez, amelyben az új eszközök számára volt néhány szabad ISA vagy PCI-csatlakozó. Ez a

megoldás már a kezdetektől problémás volt.

Például az új perifériák gyakran saját ISA vagy PCI kártyával kaphatók. Általában a felhasználó

felelős a kártyán lévő kapcsolók és vezetékáthidalások (jumper) helyes konfigurálásáért, valamint

azért, hogy e beállítások ne kerüljenek konfliktusba más kártyákkal. Azután a felhasználónak fel kell

nyitnia a számítógép házát, gondosan behelyezni az új kártyát, visszazárni a házat, majd újraindítani a

számítógépet. Sok ember számára ez az eljárás nehézkes és hibalehetőségeket rejt magában.

Ráadásul az ISA- és PCI-csatlakozások száma meglehetősen korlátozott (általában kettő vagy három).

A „csatlakoztasd és működik” kártyák ugyan kiküszöbölik a vezetékáthidalásokkal való vesződést,azonban továbbra is a felhasználónak kell felnyitnia a számítógépet, és betennie a kártyát, valamint a

síncsatlakozások száma is korlátozott.

1993-ban hét vállalat – a Compaq, DEC, IBM, Intel, Microsoft, NEC és a Northern Telecom –

képviselői összeültek, hogy megvitassák a problémát, és a számítógépek és az alacsony sebességű

perifériák összekapcsolásának jobb módját dolgozzák ki. Azóta már cégek százai csatlakoztak

hozzájuk. Az eredményül kapott szabványt, az USB-t hivatalosan 1998-ban jelentették be, és már

széles körben alkalmazzák személyi számítógépekben.

Néhány cél azok közül, amelyeket az USB-t eredetileg kidolgozó és a munkát elindító cégekfogalmaztak meg:

A felhasználóknak ne kelljen minikapcsolókat (switch), vezetékátkötéseket (jumper)beállítaniuk sem a bővítőkártyákon, sem a készülékekben.

A felhasználóknak ne kelljen felnyitniuk a számítógép házát, hogy egy új perifériátcsatlakoztathassanak.

Egyetlen fajta kábel legyen, amely az összes készülék számára alkalmas. A perifériák az elektromos energiát is ezen a kábelen keresztül kapják. Egyetlen számítógéphez legalább 127 eszközt lehessen csatlakoztatni.

A rendszer ki tudjon szolgálni valós idejű perifériákat is (hang, telefon).

A készülékeket úgy is lehessen telepíteni, hogy a számítógép közben működik. Ne kelljen újraindítani a számítógépet a készülék csatlakoztatása után. Az új sín és a rajta lévő eszközök előállítási költsége ne legyen magas.

Az USB-szabvány kielégíti mindezeket az elvárásokat. Olyan alacsony sebességű eszközök

számára tervezték, mint a billentyűzet, egerek, állóképkamera, fényképszkenner, digitális telefon stb.

Az USB 1.0-ás verziójának sávszélessége mintegy 1,5 MB/s, amely elegendő a billentyűzet és az

egerek számára, az 1.1-es verzió pedig 12 MB/s sebességgel működik, amely elegendő a nyomtatók,

digitális fényképezőgépek és sok más eszköz számára. Ezeket a viszonylag alacsony határértékeket a

költségek alacsony szinten tartása miatt választották.



35.

Egy USB-rendszer egy központi csomópontból (root hub) áll, amely a rendszersínre

csatlakozik. Ez a csomópont több csatlakozót tartalmaz a külső B/K eszközök vagy újabb

csomópontok számára, amelyek további csatlakozási lehetőségeket biztosíthatnak, így az USB-

rendszer topológiája egy olyan fa, amelynek a gyökere a számítógép belsejében lévő központi

csomópont. A kábelek végén két különböző csatlakozó van, egyik csak a B/K eszközbe, a másik csak

az elosztóba dugható be, ezzel meggátolható, hogy véletlenül két csomópont két csatlakozója legyen

összekötve a kábellel.

A kábel négy vezetékszálat tartalmaz: kettőt az adatok, egyet a tápfeszültség (5 V) és egyet

a föld számára. A jeltovábbító rendszer a 0-kat feszültségátmenetként, az 1-eket pedig a

feszültségátmenet hiányaként továbbítja, így egy hosszú 0 sorozat szabályos impulzusfolyamot

generál.

Egy új eszköz csatlakoztatásakor a központi csomópont érzékeli az eseményt és megszakítást

kezdeményez. Ezután az operációs rendszer lekérdezi, milyen eszközről van szó, valamint hogy

mekkora USB-sávszélességre van szüksége. Ha az operációs rendszer úgy dönt, hogy van elegendősávszélesség az eszköz számára, akkor az eszköznek címet, egyedi azonosító számot (1-127) ad, majd

ezt a címet és más paramétereket tölt a B/K eszközben lévő konfigurációs regiszterekbe. Ilyen módon

az új eszközök menet közben csatlakoztathatók a számítógéphez anélkül, hogy a felhasználónak

bármit is konfigurálnia kellene, vagy új ISA vagy PCI kártyákat kellene a számítógépbe helyeznie. A

még konfigurálatlan eszköz címe kezdetben 0, tehát megcímezhető. A kábelezés megkönnyítése

érdekében sok USB-eszköz beépített csomópontot tartalmaz, amelybe további USB-eszközök

dughatók. Például egy USB-monitor rendelkezhet két csatlakozóval: a bal, illetve a jobb oldali

hangszóró számára.

Logikailag az USB-rendszer úgy tekinthető, mint bitcsatornák halmaza a központicsomóponttól az eszközökig. Minden eszköz legfeljebb 16 alcsatornára oszthatja fel a csatornáját a

különböző jellegű adatok számára (például hang, video). Minden egyes csatornán vagy alcsatornán az

adatok a központi csomópontból az eszköz felé vagy fordított irányban áramolnak. Két B/K eszköz

között nincs adatforgalom.

Pontosan 1,00 +- 0,05 ms-ként a központi csomópont egy új üzenetváltási keretet (frame)

küld szét, amelynek segítségével minden B/K eszközt szinkronizál. Egy üzenetváltási keret mindig egy

bitcsatornához kapcsolódik, és csomagokból áll, amelyekből az elsőt minden esetben a központi

csomópont küldi az eszköznek. A keretben lévő többi csomag iránya lehet ugyanilyen vagy az

eszköztől a központi csomópont felé haladó.

Az USB négyféle keretet különböztet meg: vezérlési, izoszinkron, tömeges adat és

megszakítási kereteket. A vezérlési keret az eszközök konfigurálására szolgál, parancsok küldésére

vagy az eszközök állapotának lekérdezésére. Az izoszinkron kereteket a valós idejű eszkzök

használják, például a mikrofonok, hangszórók és telefonok, amelyeknek pontosan meghatározott

(időnként feltétlenül) adatokat kell küldeniük vagy fogadniuk, bár a jeleknek jól kiszámítható

késleltetése van. Hiba esetén az adatokat nem kell megismételni. A tömeges adatkeretek nagy

tömegű adat átvitelére szolgálnak a számítógéptől az eszközhöz, például a nyomtatókhoz, vagy

fordítva, de valós idejű továbbításra nincs szükség. Végül, a megszakítási keretekre azért van szükség,

mert az USB nem támogatja a megszakításokat. Például ahelyett, hogy a billentyűzet minden



36.

billentyű lenyomásakor megszakítást okozna, az operációs rendszer le tudja kérdezni 50 ms-ként és

össze tudja gyűjteni a billentyűlenyomásokat.

Egy keret egy vagy több csomagot tartalmaz, valószínűleg mindkét irányúból néhányat. Négy

különböző csomag van: token, adat, kézfogás és speciális. A token csomagok a központi csomópont

felől érkeznek az eszközökhöz, és a feladatuk a rendszer irányítása. A keret kezdete csomag (SOF) azelső minden keretben; ez jelzi a keret kezdetét. Ha nincs teendő, a SOF lehet az egyetlen csomag a

keretben. Az IN token csomag egy lekérdezés, az eszköztől kér bizonyos adatokat. Az IN csomagban

lévő mezők azonosítják a bitalcsatornát, így az eszköz tudja, milyen adatokat kell visszaküldenie (ha

több adatfolyama is van). Az OUT token csomag azt jelzi, hogy utána adatok következnek az eszköz

számára. A negyedik token csomagtípus a SETUP, és az eszközök konfigurálására használják.

A token csomagon kívül még háromfajta csomag van. Ezek a DATA, a kézfogás és a speciális

csomag. Egy 8 bites szinkronizációs mezőből, egy 8 bites csomagtípusból (PID) és a hasznos adatból,

valamint egy 16 bites CRC kódból áll, a hibás átvitel detektálására. Háromfajta kézfogás csomag van:

az ACK, a NAK és a STALL.

Miután az USB-szabványt 1998-ban véglegesítették, az USB tervezőinek további feladatuk

már nem volt, így az USB egy új, nagy sebességű, USB 2.0-nak nevezett verzióján kezdtek el dolgozni.

A szabvány hasonlít a régebbi 1.1-es verzióhoz és visszafele kompatibilis is vele, azonban egy új,

harmadik sebességet (480 Mbps) vezet be a két meglévő mellé. Vannak még további kisebb

különbségek is, mint például az interfész a központi csomópont és a vezérlő között. AZ USB 1.1-ben

kétféle interfész volt. Az elsőt, az UHCI-t, az Intel tervezte és a terhek zömét a szoftverkészítőkre

hárította. A másikat, az OHCI-t a Microsoft tervezte, és a terhek zömét a hardverfejlesztőkre

hárította. Az USB 2.0-nál megegyeztek egyetlen új interfészben, amelynek a neve EHCI.

Most, hogy az USB 480 Mbps sebességgel működik, nyilvánvalóan versenytársa az IEEE 1394

szabványú sínnek, amelyet közismerten FireWire-nek neveznek, és ami 400 Mbps sebességgel

működik. Bár majdnem minden új Pentium rendszer az USB 2.0-val kapható, mégsem valószínű, hogy

az IEEE 1394 eltűnik, mert a szórakoztató-elektronikai ipar támogatja. A kézi kamerákat, DVD-

lejátszókat és más hasonló eszközöket a belátható jövőben ezután is ellátják majd 1394 -es

interfésszel, mivel az eszközök gyártói nem akarják vállalni egy olyan szabványra történő áttérés

költségeit, amely alig valamivel jobb, mint amijük jelenleg van. A vásárlók szintén nem szeretnek

áttérni másik szabványra.



37.

14. PCI Express

Bár a PCI sín megfelelően működik a legtöbb napi alkalmazásban, a nagyobb B/K sávszélesség

iránti igény beleszemetelt az egykor szép, tiszta belső PC-architektúrába. A 3.53. ábrából világosan

látszik, hogy ma már nem a PCI sín az a központi elem, amely a PC részeit összekapcsolja. A csatolólapka vette át ezt a szerepet.

A probléma lényege, hogy egyre nagyobb számú B/K eszköz van, amely túl gyors a PCI sínhez.

A sín órajel-frekvenciájának megbütykölése nem jó megoldás, mivel akkor megjelennek a

sínaszimmetria problémái, az áthallás a vezetékek között és a kapacitáshatások, és csak még rosszabb

lesz a helyzet. Minden olyan esetben, amikor egy B/K eszköz túl gyors kezd lenni a PCI sínhez, az Intel

egy újabb speciális portot ad a csatoló lapkához, lehetővé téve, hogy ez az eszköz kikerülje a PCI sínt.

Nyilvánvaló azonban, hogy ez nem egy hosszú távra szóló megoldás.

A másik probléma a PCI sínnel az, hogy a bővítőkártyák mérete elég nagy. Nem férnek be egyhordozható asztali számítógépbe (laptopba) vagy egy tenyér számítógépbe (palmtopba), a gyártók

pedig még kisebb eszközöket szeretnének előállítani. Ezenkívül, néhány gyártó újra szeretné

strukturálni a PC-t: a CPU-t és a memóriát egy lezárt dobozba tennék, a mágneslemezegységet pedig

a monitor belsejébe. PCI kártyákkal ez lehetetlen.

Több megoldást is bejelentettek már, a legvalószínűbb nyertes azonban a PCI Express. Nem

sok köze van a PCI sínhez, valójában egyáltalán nem is sín, de a piaci szakemberek nem szeretnék a

jól ismert PCI nevet elveszíteni. Már egy ideje kaphatók olyan PC-k, amelyek ilyet tartalmaznak. Most

nézzük meg, hogyan működik.

A PCI Express architektúra

A PCI Express megoldás lényege, hogy szabaduljunk meg a párhuzamos síntől, annak sok

sínmesterétől és szolgájától, és térjünk át jól megtervezett, nagy sebességű közvetlen soros

kapcsolatokra. Ez a megoldás gyökeresen szakít az ISA/EISA/PCI síntradícióval. Sok üzletet a lokális

hálózatok világából, különösen a kapcsolt Ethernet-hálózatoktól kölcsönöztek. Az alapötlet a

következő: a PC legbelül CPU, memória- és B/K vezérlőlapkákból áll, amelyeket össze kell kapcsolni. A

PCI Express egy általános célú kapcsolót biztosít a lapkák összekötéséhez soros kapcsolat

segítségével. Egy tipikus ilyen konfigurációt mutat be a 3.57. ábra.

Ahogyan az a 3.57. ábrán is látszik a CPU, a memória és a gyorsítótár hagyományos módonkapcsolódik a csatoló lapkához. Ami új, az a kapcsoló, amely a csatoló lapkához kapcsolódik.

Mindegyik B/K lapkának saját egyedi összeköttetése van a kapcsolóhoz. Mindegyik kapcsolat két

egyirányú csatornából álló pár; az egyik csatorna a kapcsolóhoz, a másik pedig a kapcsolótól szállít

adatokat. Mindegyik csatorna két vezetéket jelent, egyik a jel, a másik a föld számára, amely így nagy

zajtűréssel rendelkezik a nagy sebességű átvitel során. Ez az architektúra a jelenlegit egy sokkal

egységesebb modellel váltaná fel, amelyben minden eszközt azonos módon kezelnek.



38.

A PCI Express a régi PCI sín architektúrától három fontos dologban tér el. Kettőt már láttunk:

a központosított kapcsoló a több leágazású sín helyett, valamint a keskeny közvetlen soros kapcsolat

a széles, párhuzamos sín helyett. A harmadik ennél kifinomultabb. A PCI sín mögött rejlő elképzelés

az, hogy a sínmester parancsot ad a szolgának, ha egy szót vagy egy adatblokkot be akar olvasni. A

PCI Express modellje ezzel szemben az, hogy egyik eszköz egy adatcsomagot küld a másik eszköznek.

A csomagfogalom, amely egy fejlécből és a hasznos adatból áll, a hálózatok világából származik. A

fejléc vezérlési információt tartalmaz, így nincs szükség arra a sok vezérlőjelre, mint a PCI sínnél. A

hasznos adat tartalmazza az átvinni kívánt adatot. Valójában egy PC a PCI Express-szel egy kicsi

csomagkapcsolt hálózat.

E három fő területtel szakítottak, ezeken kívül azonban vannak még kisebb különbségek is. A

negyedik különbség az, hogy hibajelző kódot használnak a csomagoknál, amellyel a PCI sínnél

nagyobb fokú megbízhatóságot biztosítanak. Az ötödik, hogy a kapcsolat egy lapka és a soros

kapcsoló között hosszabb lehet, elérheti az 50 cm-t; ez megengedi a rendszer áttervezését. A hatodik,

hogy a rendszer bővíthető, mivel egy eszköz lehet akár egy másik soros kapcsoló is, amellyel a

kapcsolók fastruktúráját hozhatják létre. A hetedik különbség, hogy az eszközök melegen

csatlakoztathatók, azaz csatlakoztathatók és eltávolíthatók a rendszerből, mialatt az tovább működik.

Végül, a soros csatlakozók sokkal kisebbek, mint a régi PCI -csatlakozók, így az eszközök és a

számítógépek sokkal kisebbek lehetnek. Mindent egybevéve, mindez jelentős eltávolodást jelent a

PCI síntől.

A PCI Express protokollrendszer

Maradva a csomagkapcsolt hálózati modellnél, a PCI Express réteges kapcsolati

protokollrendszerrel rendelkezik. A protokoll a két fél között párbeszédet irányító szabályok egy

halmaza. A protokollrendszer protokollok hierarchiája, amelyben az egyes problémákkal különrétegekben foglalkoznak. Példának vegyünk egy üzleti levelet. Vannak megállapodások a levél

fejrészének tartalmáról és elhelyezkedéséről, a címzett adatairól, a dátumról, az üdvözlésről, a levél

szövegéről, az aláírásról és így tovább. Vehetjük úgy, hogy ez a levél egy protokoll. Vannak további

megállapodások a borítékról, például a méretéről, hogy hová kerül a feladó címe, és mi a formája,

hová kerül a címzett és milyen formában, hová kerül a bélyeg és így tovább. Ez a két réteg és a

hozzájuk tartozó két protokoll független. Például teljesen újraformázhatjuk a levelet, de ugyanazt a

borítékot használjuk, vagy fordítva. A réteges protokollok a hatékony, moduláris tervezést szolgálják

és évtizedek óta széles körben elterjedtek a hálózati szoftverek világában. Ami újdonság, hogy most a

sínhardverbe is beépítésre kerültek.

Vizsgáljuk meg az egyes rétegeket alulról felfelé. A legalsó réteg a fizikai réteg. Azzal

foglalkozik, hogy biteket továbbít a küldőtől a fogadónak egy közvetlen kapcsolaton keresztül.

Minden egyes kapcsolat egy vagy több szimplex (azaz egyirányú) csatornapárból áll. A legegyszerűbb

esetben egy pár van, egy-egy csatorna mindkét irányban, de 2, 4, 8, 16 vagy 32 pár is megengedett.

Egy-egy csatornát sávnak neveznek. A sávok számának mindkét irányban azonosnak kell lennie. Az

első generációs termékeknek bármely irányban legalább 2,5 Gbps sebességet kell biztosí taniuk, de

azt remélik, hogy a sebesség hamarosan mindkét irányban eléri a 10 Gbps-t.

Az ISA/EISA/PCI sínekkel ellentétben a PCI Expressnek nincs fő órajel-generátora. Az eszközök

azonnal elkezdhetnek adni, amint van elküldeni való adatuk. Ez a szabadság gyorsabbá teszi a

rendszert, de egyúttal problémához is vezet. Tegyük fel, hogy az 1-es bit +3 V-tal kódolódik, a 0-s bit



39.

pedig 0 V-tal. Ha az első néhány bájt mind 0 bitekből áll, honnan tudja a fogadó, hogy adatok

érkeznek. Elvégre egy 0 bit sorozat pontosan úgy néz ki, mint egy megszakadt kapcsolat. Ezt a

problémát az úgynevezett 8b/10b kódolással oldották meg. A megoldás az, hogy 1 bitet használnak

egyetlen hasznos bájt kódolására egy 10 bites szimbólumban. Az 1024 lehetséges 10 bites értékből

kiválasztották azokat a megengedhető szimbólumokat, amelyek elegendő jelváltást tartalmaztak

ahhoz, hogy bithatárra szinkronizálják a küldőt és a fogadót fő órajel-generátor nélkül is. A 8b/10b

kódolás következményeként a kapcsolat teljes 2,5 Gbps kapacitása csupán 2 Gbps hasznos

adatmennyiség átvitelére elegendő.

Amíg a fizikai réteg a bitek átvitelével foglalkozik, addig a kapcsolati réteg a csomagok

átvitelével. Fogja a tranzakciós rétegtől kapott fejlécet és hasznos adatot, egy sorszámot és egy CRC-

nek nevezett hibajelző kódot ad hozzá. A CRC egy bizonyos algoritmusnak a fejlécre és a hasznos

adatokra történő futtatásával számítható ki. Amikor a csomag megérkezik, a fogadó is elvégzi

ugyanezt a számítást a fejlécre és a hasznos adatokra, és összehasonlítja az eredményt a csomaghoz

csatolt CRC-vel. Ha megegyeznek, egy rövid nyugtázó csomagot küld vissza, ezzel jelzi a csomag

hibátlan megérkezését. Ha a két eredmény nem egyezik, a fogadó kéri a csomag újraküldését. Ezen a

módon az adatintegritás jelentősen javult a PCI sínhez képest, amely nem biztosított lehetőséget a

sínen átküldött adatok ellenőrzésére és újraküldésére.

Annak elkerülésére, hogy egy gyors küldő eszköz olyan mennyiségű csomaggal árasszon el

egy lassú fogadó eszközt, amelyet az nem tud kezelni, egy folyamatvezérlő mechanizmust

használnak. A mechanizmus lényege, hogy a fogadó eszköz elküld a küldőnek egy bizonyos kredit

értéket, a beérkező csomagok tárolására rendelkezésre álló puffer méretét. Amikor a kredit elfogy, a

küldőnek be kell fejeznie a küldést, amíg új kreditet nem kap. Ezt a sémát elterjedten használják

mindenféle hálózatban, hogy megakadályozzák a küldő és a fogadó eltérő sebességéből eredő

adatvesztést.

A tranzakciós réteg kezeli a síntevékenységeket. Egy szó beolvasása a memóriából két

tranzakciót kíván: az egyiket a CPU vagy egy DMA csatorna kezdeményezi, és kér bizonyos adatokat,

a másikat az adatokat szolgáltató céleszköz. Azonban a tranzakciós réteg több annál, mint egyszerű

olvasások és írások kezelése. A kapcsolati réteg által biztosított nyers csomagküldést további

szolgáltatásokkal egészíti ki. Először is, minden egyes sávot feloszthat nyolc virtuális áramkörre,

amelyek mindegyike különböző jellegű forgalmat bonyolít le. A tranzakciós réteg meg tudja címkézni

a csomagokat, aszerint, hogy a nyolc forgalmi osztály melyikéhez tartoznak, a címkében lehetnek

olyan attribútumok, mint a magas prioritás, alacsony prioritás, szimatolás tiltása, soron kívüli

kézbesíthetőség és még sok egyéb. A kapcsolólapka használhatja ezeket a címkéket, amikor arról

dönt, melyik lesz a legközelebb továbbítandó csomag.

Minden tranzakció az alábbi négy címtartomány egyikét használja:

1. Memóriaterület 2. B/K terület 3. Konfigurációs terület 4. Üzenetterület



40.

A memória- és a B/K terület hasonló a jelenlegi rendszerekben lévőkhöz. A konfigurációs

terület olyan szolgáltatások megvalósítására szolgál, mint a plug-and-play. Az üzenetterület a

rengeteg létező hardvervezérlőjel szerepét veszi át. Valami ilyesmire szükség van, mivel a PCI sín

vezérlőjelei közül egy sincs meg a PCI Expressnél.

A PCI Express rendszer a szoftverrétegen keresztül csatlakozik az operációs rendszerhez.Képes a PCI sín emulálására, így a létező operációs rendszerek változtatás nélkül tudnak működni a

PCI Express rendszert alkalmazva. Természetesen ez a módszer nem hasznosítja a PCI Express minden

erejét, azonban a visszafelé kompatibilitás szükséges rossz, amit nem hagyhatunk figyelmen kívül,

amíg az operációs rendszereket nem módosítják úgy, hogy teljesen használatba vegyék a PCI

Expresst. A tapasztalatok szerint ez eltarthat egy darabig.

Az információáramlást a 3.58. (b) ábra mutatja. Amikor a szoftverréteg parancsot kap, azt

továbbadja a tranzakciós rétegnek, amely átalakítja a parancsot fejléc és hasznos adat alakúra. Ezt a

két rész azután a kapcsolati réteghez kerül, amely egy sorszámot kapcsol a csomag elejéhez, és

hibajelző kódot a végéhez. Az így bővített csomag kerül azután a fizikai réteghez, amely kerettel zárjale a csomag mindkét végét, hogy egy fizikai csomagot hozzon létre, amelyet aztán ténylegesen elküld.

Évtizedek óta nagy sikerrel használják a hálózatok világában azt az elképzelést, hogy miden

réteg a protokoll rétegeiben egyre mélyebbre haladva további kiegészítő információt ad az

adatokhoz. A hálózatok és a PCI Express között az a nagy különbség, hogy a hálózatok esetében a

különböző rétegekben lévő kód majdnem mindig szoftver, amely az operációs rendszer része. A PCI

Expressnél ez mind az eszközben lévő hardver része.



41.

15. A CPU részei, feladatai. CPU, adatút. Három, kettő, egy és nullacímes utasítások.

CPU és részei, feladatai

Egy egyszerű sínalapú számítógép felépítése látható a 2.1 ábrán. A CPU a számítógép „agya”.

Feladata az, hogy a központi memóriában tárolt programokat végrehajtsa úgy, hogy a programok

utasításait egymás után beolvassa, értelmezi és végrehajtja. Az egyes részegységeket egy sín köti

össze, amely címek, adatok és vezérlőjelek továbbítására szolgáló párhuzamos vezetékköteg. A sín

lehet a CPU-t tekintve külső, amely összekapcsolja azt a memóriával és a B/K egységekkel, illetve

lehet belső, ahogy azt hamarosan látni fogjuk.

A CPU több különálló részegységből áll. A vezérlőegység feladata az utasítások beolvasása a

központi memóriából és az utasítások típusának megállapítása. Az aritmetikai-logikai egység a

program utasításainak végrehajtásához szükséges műveleteket végez, mint például az összeadás vagya logikai ÉS.

A CPU egy kisméretű, gyors memóriát is tartalmaz, amelyben részeredményeket és bizonyos

vezérlőinformációkat tárol. Ez a memória több regiszterből áll, mindegyiknek meghatározott mérete

és funkciója van. Legtöbbször az összes regiszter azonos méretű. Minden regiszter képes tárolni egy

számot, amelynek az értéke kisebb a regiszter mérete által meghatározott maximumnál. A

regisztereket nagy sebességgel lehet olvasni és írni, mivel a CPU-n belül vannak.

A legfontosabb regiszter az utasítás- vagy programszámláló, amely a következő

végrehajtandó utasítás címét tartalmazza. Az „utasításszámláló” név kissé félrevezető, mert semmit

sem számlálunk meg vele, ennek ellenére az elnevezés általánosan elterjedt. Fontos még az

utasításregiszter , amely az éppen végrehajtás alatt levő utasítást tartalmazza. A legtöbb számítógép

még számos egyéb regisztert is tartalmaz, ezek némelyike általános célú, míg mások speciális célúak.

A CPU felépítése

Egy tipikus Neumann-elvű számítógép egy részének belső felépítése a 2.2 ábrán látható

részletesebben. Ez a rész az ún. adatút, amelynek részei a regiszterek, az aritmetikai-logikai egység

és az ezeket összekötő néhány sín. A regiszterek két ALU bemeneti regisztere csatlakoznak, ezeket az

ábrán A-val és B-vel jelöltük. Ezek a regiszterek tárolják a bemeneti adatokat, amíg az ALU más

számításokon dolgozik. Az adatút minden számítógépben nagyon fontos, ezért hosszasan fogjuktárgyalni a könyv f ejezeteiben.

Maga az ALU a bemenő adatokon összeadást, kivonást és egyéb egyszerű műveleteket végez,

és az eredményt a kimeneti regiszterbe teszi. Ennek a kimeneti regiszternek a tartalma visszaírható

egy regiszterbe. Később, ha szükséges, a regiszter tartalma beírható a memóriába. Nem minden

számítógép terve tartalmazza az A, B és a kimeneti regisztert. Az ábrán az összeadást mutattuk be.

A legtöbb utasítás a következő két kategória egyikébe sorolható: regiszter-memória vagy

regiszter-regiszter. A regiszter-memória utasítások segítségével tölthetünk át szavakat a memóriából

regiszterekbe, ahol a soron következő utasítások például az ALU bemeneteként használhatják. Másregiszter-memória utasítások segítségével a regiszterek tartalmát írhatjuk vissza a memóriába.



42.

A másik csoportba tartoznak a regiszter-regiszter utasítások. Egy tipikus regiszter-regiszter

utasítás vesz két operandust a regiszterekből, elhelyezi őket az ALU bemeneti regisztereibe, az ALU

elvégez rajtuk valamilyen műveletet – például összeadást vagy logikai ÉS-t -, majd az eredményt

tárolja az egyik regiszterbe. A két operandusnak az ALU-n történő átfuttatásából és az eredmény

regiszterbe tárolásából álló folyamatot adatútciklusnak nevezzük, ez a legtöbb CPU lelke. Jelentős

mértékben ez határozza meg, hogy a gép mire képes. Minél gyorsabb az adatútciklus, annál

gyorsabban dolgozik a gép.

Utasításformátumok

Minden utasítás tartalmaz egy műveleti kódot és általában valamilyen kiegészítő információt,

mint hogy hol vannak az operandusok, és az eredmény hova kerül. Azt az általános módszert, amely

meghatározza az operandusok helyét (tehát a címüket), címzésnek nevezzük.

Az utasítás mindig tartalmaz műveleti kódot, amely megmondja, hogy mit csinál az utasítás.

Ezenkívül tartalmazhatja 0, 1, 2 vagy 3 operandus címét.

Vannak gépek, amelyeknél minden utasítás azonos hosszúságú, mások esetén több,

különböző hosszúságú utasítás lehet. Az utasítások hossza lehet a szóhosszal azonos, rövidebb vagy

hosszabb is. Ha minden utasítás azonos hosszúságú, akkor könnyebbb a dekódolás, de pazarló a

tárolás, mert a közös hossz megegyzeik a leghosszab szó hosszával.



43.

16. Mikroarchitektúra szint. Az ALU-val végezhető műveletek.Memória műveletek. ALU és az adatút vezérlése.Mikroutasítások: Mic-1. Mic-1 működése.

Mikroarchitektúra szint

A digitális logikai szint felett helyezkedik el a mikroarchitektúra szintje. Feladata a felette

lévő utasításrendszer-architektúra szint (ISA-szint) megvalósítása. Ennek a szintnek a tervezése függ

az ISA-szint megvalósításától, valamint a számítógép ár és teljesítmény kitűzéseitől.

A mikroarchitektúrának tartalmaznia kell egy mikroprogramot a ROM-ban, melynek feladata

betölteni, dekódolni és végrehajtani az IJVM utasításokat. Ez a mikroprogram hatékonyan vezérli az

egyedi kapukat az aktuális hardverben.

Az ALU-val végezhető műveletek

Az ALU tevékenységét 6 vezérlővonal határozza meg. Közülük F0 és F1 határozza meg az ALU-

műveletet, ENA és ENB egyedileg engedélyezi a bemeneteket, INVA invertálja a bal oldali bemenetet,

és INC a legalacsonyabb helyiértékű biten az „átvitel be” bemenet. INC beállítása gyakorlatilag 1-et

hozzáad az eredményhez. Azonban az ALU vezérlővonalaknak nem mind a 64 kombinációja csinál

valami hasznosat. (A 4.2. ábrán található néhány érdekesebb kombináció és a hozzá tartozó

tevékenység.) ALU műveletek pl.: negálás, komplementer-képzés, összeadás, kivonás, inkrementálás,

dekrementálás, logikai műveletek, stb.

Az ALU-nak két adatbemenetre van szüksége: a bal oldalira (A) és a jobb oldalira (B). A bal

oldali bemenet a H (Holding) tartó regiszterhez kapcsolódik. A jobb oldali bemenet pedig a B sínhez,

amelyik képes betölteni a kilenc forrás bármelyikét.

A H úgy tölthető fel, hogy választunk egy olyan ALU-tevékenységet, amelyik a jobb oldali

bemenetet (a B sínről) csupán átengedi az ALU kimenetére. Az egyik ilyen tevékenység az ALU

bemeneteit összeadja, csak negált ENA-val, ami a bal oldali bemenetet nullává teszi. Nullát adva a B

sín értékéhez, éppen a B sín értékét kapjuk. Ezt az eredmnéyt azután módosítás nélkül küldjük

tovább a léptetőn, és H-ban tároljuk.



44.

A fenti függvényeken kívül két másik vezérlővonal használható egymástól függetlenül az ALU

kimenetének irányítására. Az SLLB (Shift Left Logical, léptetés balra logikailag) a tartalmat 1 bájttal

balra lépteti, feltöltve nullával a legalacsonyabb helyértékű 8 bitet. SRA1 (Shift Right Arithmetic,

aritmetikai léptetés jobbra) a tartalmat 1 bittel jobbra lépteti, változatlanul hagyva a legmagasabb

helyértékű bitet.

Hangsúlyozzuk, hogy lehetséges olvasni és írni ugyanazt a regisztert egy cikluson belül.

F0 F1 ENA ENB INVA INC Tevékenység

0 1 1 0 0 0 A

0 1 0 1 0 0 B

0 1 1 0 1 0 A

1 0 1 1 0 0 B

1 1 1 1 0 0 A + B

1 1 1 1 0 1 A + B + 1

1 1 1 0 0 1 A + 11 1 0 1 0 1 B + 1

1 1 1 1 1 1 B – A

1 1 0 1 1 0 B – 1

1 1 1 0 1 1 -A

0 0 1 1 0 0 A AND B

0 1 1 1 0 0 A OR B

0 1 0 0 0 0 0

1 1 0 0 0 1 1

1 1 0 0 1 0 -1

Memória műveletek

Gépünk 2 módon kommunikálhat a memóriával, egy 32 bites, szócímzésű memóriaporton, és

egy 8 bites bájtcímzésű memóriaporton. A 32 bitest 2 regiszter vezérli, a MAR (Memory Address

Register) és az MDR (Memory Data Register). A 8 bitest 1 regiszter, a PC vezérli, ez 1 bájtot olvas be

az MBR alsó 8 bitjébe. Ez utóbbi csak adatot olvasni képes a memóriából, adatot írni nem.

Ezeket a regisztereket egy vagy két vezérlőjel irányítja. Mival a MAR nem kapcsolódik a B

sínre, nincs engedélyező jele sem. A H-nak sincs egyikből sem, mert mindig engedélyezett, hiszen ez

az ALU egyetlen lehetséges bal oldali bemenete.

Mivel az MBR nem tölthető a C sínről, ezért nincs írójele se (bár van két másik engedélyező

jele). Egy memória olvasás vagy írás kezdeményezéséhez a megfelelő memóriaregisztereket fel kell

tölteni, majd egy olvasó vagy író jelet kell kibocsátani a memória felé.

A MAR szó címeket tartalmaz, úgy, hogy a 0, 1, 2… értékek egymást követő szavakra

hivatkoznak, a PC pedig bájt címeket tartalmaz, úgy, hogy a 0, 1, 2… értékek egymást követő bájtokra

hivatkoznak. Tehát pl. 2-t téve a PC-be, és elindítva egy memóriaolvasást, ki fogjuk olvasni a memória

2. bájtját, és az MBR alsó 8 bitjére tesszük. 2-t téve a MAR-ba, és elindítva egy olvasást, kiolvassa a

memória 8-11. bájtjait (vagyis a 2. szót), és az MDR-be teszi.



45.

A valódi fizikai megvalósításban csak 1 tényleges memória van, és az bájtszervezésű.

Megengedi a MAR-nak, hogy szavakban számláljon, mialatt a fizikai memória bájtokban számlál. Ez

úgy küszöbölhető ki, hogy a MAR 0. bitje a címsín 2. vonalához kötődik, az 1. bit a 3. vonalhoz és így

tovább.

Az MBR előjeltelenül vagy előjelesen másolható a B sínre. Amikor előjeltelen értékre vanszükségünk, akkor a B sínre kerülő 32 bites szó tartalmazza az MBR értékét az alsó 8 biten, és 0 -kat a

magasabb 24 biten.

A másik lehetőség, hogy a 8 bites MBR-t 32 bites szóvá konvertáljuk, úgy, hogy egy -128 és

127 közötti előjeles értéknek tekintjük, és generálunk egy 32 bites szót. Ez valójában az MBR

előjelbitjének a B sín felső 24 bitjére történő másolását jelenti, és előjel-kiterjesztésnek nevezzük.

Ilyenkor a felső 24 bit vagy mind 0, vagy mind 1 lesz, attól függően, hogy a 8 bites MBR bal szélső

bitje 0 vagy 1.

Az ALU és az adatút vezérlése

Lásd:

Máté: Architektúrák 5. előadás

Andrew S. Tanenbaum: Számítógép architektúrák 261-265. o.

Mikroutasítások: Mic-1

Lásd:



Mic-1 működése

Lásd:





46.

Az adatút sok 32 bites regiszterből, sínekből, ALU-ból és léptetőből áll. Az SLL8 (Shift Left

Logical) 8 bittel balra léptet, az SRA1 (Shift Right Arithmetic) pedig 1 bittel jobbra. Az ALU bemenetei

a H (Holding - tartó) és a B sín. Egy adatút cikluson belül lehetséges egy regiszterből olvasni és az

eredményt akár ugyanoda visszaírni. Az adatút vezérléséhez 29 jelre van szükség. Ezek közül 9 jel

szolgálja a B sínre írást a regiszterekből, 6 az ALU és 2 a léptető vezérlésére kell, 9 jel a C sínről a

regiszterekbe íráshoz, valamint 3 a memória eléréséhez. Utóbbiból 2 jel a szó íráshoz/olvasáshoz kell,

1 pedig bájt olvasáshoz. Összesen tehát 29 jel szükséges, azonban a B sínre csak 1 regiszter írhat

egyszerre, ezért 9 helyett elég 4 jel, vagyis összesen 24 jel is elegendő.

Minden mikroutasítás 36 bites. Ebből 24 bitet az adatút vezérléséhez, 9 bitet a következő

utasítás címének megadásához, 3 bitet pedig a következő utasítás kiválasztásának módjára

használunk. A Mic-1 többek között tartalmaz egy 512x36 bites vezérlőtárat a mikroprogramnak, egy

MPC-t (MicroProgram Counter – mikroprogram-utasításszámláló) és egy MIR-t (MicroInstruction

Register – mikroutasítás-regiszter).

Az adatút ciklus elején MIR feltöltődik a vezérlőtár MPC által mutatott szavával, kialakul a B

sín tartalma, ALU és a léptető megtudja, mit kell csinálnia. ALU és a léptető elvégzi a feladatát, a C

sín, N (Negativ) és Z (Zero) megkapja az új értékét. A regiszterek feltöltődnek a C sínről. Ha az előző

ciklus adatot kért a memóriából, akkor MBR/MDR megkapja az értékét. Kialakul MPC új értéke.

Ezután kezdődik a memóriaciklus.

A memóriaciklus MAR illetve PC feltöltése után kezdődik, ezért ha a memória címet

módosította ez a mikroutasítás, akkor a memória cím a módosított MAR illetve PC regiszter értéke

lesz. Olvasásnál az eredmény csak 2 ciklussal később használható, mert MDR illetve MBR csak a

következő adatút ciklus vége felé töltődik fel a memóriából.

MPC új tartalmának kialakítása úgy történik, hogy a 9 bites következő cím (Addr) az MPC-be

kerül. JAMN vagy JAMZ esetén MPC legmagasabb bitjének és az N vagy Z bitnek logikai vagy

kacsolata képződik MPC legmagasabb helyértékével. Ez egy feltételes ugrás (elágazás) a

mikroprogramban. JMPC esetén MPC 8 alacsonyabb helyértékű bitjének és MBR 8 bitjének

bitenkénti vagy kapcsolata képződik MPC-ben az adatút ciklus vége felé. Ilyenkor Addr 8 alacsonyabb

helyértékű bitje általában 0. Ez egy feltétlen ugrás az MBR-ben tárolt címre.

Ezután kezdődik az újabb mikroutasítás végrehajtása.



47.

17. A Mic-1 memória ciklusa.

Lásd:

Máté: Architektúrák 5. előadás Andrew S. Tanenbaum: Számítógép architektúrák 261-265. o.



48.

18. MPC új értékének kialakulása Mic-1-en.

Lásd:

Máté: Architektúrák 5. előadás Andrew S. Tanenbaum: Számítógép architektúrák 261-265. o.



49.

19. A WIDE utasítás hatása és működése Mic-1-en.

A WIDE utasítás egy prefix utasítás, a következő utasításnak 16 bites indexe van.

A WIDE a szokásos módon dekódolódik, amely a wide 1-hez vezet, ami kezeli a WIDE opcode-t. Bár a „kiszélesítendõ” opcode már közvetlenül elérhetõ az MBR-ben, wide 1 elhozza az opcode

utáni elsõ byte-ot, mert a mikroprogram logikája mindig elvárja azt, hogy ott legyen. Ezután egy

második többirányú elágazás történik, ezúttal a WIDE-ot követõ byte-ot használva elküldésre.

Mindazonáltal, mivel a WIDE ILOAD különbözõ mikrokódot követel, mint az ILOAD és a WIDE ISTORE

különböző mikrokódot követel, mint az ISTORE stb. ez a második többirányú ág nem használhatja az

opcode-t, mint célterület címet, mint ahogy azt a Main 1 teszi.

Ehelyett a wide 1 VAGY mûvelettel összekapcsolja 0x100- t az opcode-dal, mialatt az MPC-be

teszi. Eredményképpen a WIDE ILOAD megvalósítása 0x115-ön kezdõdik (0x15 helyett), a WIDE

ISTORE megvalósítása pedig a 0x136-on kezdõdik (0x36 helyett) stb. Ez alapján minden WIDEutasításkód 256-tal (azaz 0x100-zal) magasabb címen kezdõdik a vezérlõ tárban, magasabban mint a

megfelelõ reguláris opcode. A mikroutasítások kezdeti sorozata, mind az ILOAD -ra, mind a WIDE

ILOAD-ra a 4-20-as ábrán láthatók.

Amint a kód elér a WIDE ILOAD megvalósításához (0x115) a kód a normális ILOAD -tól

mindössze annyiban különbözik, hogy az indexet két egymás utáni index byte összefûzésével kell

megkonstruálni, ahelyett, hogy csak egy byte-on végeznénk „elõjel-kiterjesztést”. Az összefûzést és a

rákövetkezõ összeadás mûveleteket részletekben kell végrehajtani, elõször az INDEX BYTE 1-et H-ba

másolva és 8 bittel balra tolva. Mivel az index elõjel nélküli egészet reprezentál, az MBR-en nulla-

feltöltést hajtunk végre, MBRU-t használva. Ezután az index második byte- ját hozzáadjuk (azösszeadás itt megfelel a konkatenáció (összefûzés) mûveletének, mivel a H alsó byte - ja nulla, így

garantálva van, hogy nincs átvitel (carry) a byte-ok között) és az eredmény H-ban marad. Innentõl

kezdve a mûvelet pontosan ugyanúgy folytatódhat, mint ha egy standard ILOAD -ról lenne szó.

Ahelyett, hogy duplán végrehajtanánk az ILOAD záró utasításait (iload 3-tól iload 5-ig) egyszerûen

leágazunk wide-iload 4-tõl az iload 3-hoz. Figyeljük meg azonban, hogy PC-t kétszer kell

megnövelnünk az utasítás végrehajtása során, hogy az a következõ utasítás kódjára mutathasson. Az

ILOAD megnöveli azt egyszer; a WIDE-ILOAD is megnöveli egyszer.

Ugyanez a szituáció a WIDE-ISTORE-ral, miután az elsõ 4 mikroutasítás végrehajtódik

(wide_istore 1-tõl 4-ig) a folytatás ugyanaz a sorozat, mint az ISTORE elsõ két utasítása után, így awide-istore 4 leágazik az istore 3-hoz.



50.

20. Parallel Input/Output (PIO), valódi és memória leképezett I/Oeszközök. Teljes és részleges címdekódolás. Programozott ésmegszakítás vezérelt I/O. DMA.

Egy kis és közepes számítógéprendszer központi egysége lapkákból, memórialapkákból, ésnéhány B/K vezérlőből áll, amelyeket mind egy sí n köt össze. A számítógép ezeken a lapkákon

keresztül tartja fenn a kapcsolatot a külvilággal. Számos B/K lapka kapható és egyre újabbakat hoznak

forgalomba. A leggyakoribbak az UART, az USART, a képernyőmeghajtó, a diszkvezérlő és a PIO

lapkák.

Az UART egy olyan lapka, amely egy bájtot tud olvasni az adatsínről, és bitenként továbbítja

azt egy soros vonalon egy terminál felé, és soros adatokat tud fogadni a terminálról.

Az USART lapkák egyrészt különböző protokollok felhasználásával szinkron átvitelt, másrészt

azon felül az UART lapkák minden funkcióját meg tudják valósítani.

Egy tipikus PIO (Parallel Input and Output, párhuzamos B/K) lapka az Intel 8255A, amellyel

bármilyen TTL kompatibilis eszköz tud kapcsolódni (billentyűzethez, kapcsolókhoz, fényforrásokhoz

vagy nyomtatókhoz). A legegyszerűbb módja a 8255A felhasználásának, hogy három teljesen

független 8 bites porta osztjuk (A-ra, B-re és C-re). Mindegyik port egy 8 bites tárolóregiszterrel van

kapcsolatban. Ahhoz, hogy a port kimenő vonalait beállíthassuk, a központi egység beírja a megfelelő

8 bites számot a megfelelő regiszterbe, és a 8 bites szám megjelenik a kimenő vonalakon és ott meg

is marad mindaddig, amíg a regiszterbe ismételten nem írnak. Amikor a portot bemenetként

használjuk, akkor a központi egység csupán a megfelelő tárolót olvassa ki. Más működési módjai

közvetlen kapcsolatot is tudnak biztosítani a külső eszközökkel. Pl. Ha olyan eszköz számára küldadatokat, amely nem mindig tudja azokat fogadni, a 8255A megjeleníti az adatokat az egyik port

kimenetén, majd vár egy impulzusra az eszköztől, amely így üzen vissza, hogy fogadta az adatot és

szeretne még további adatokat fogadni. Az a logikai áramkör, ami ahhoz szükséges, hogy ilyen

impulzusokat tárolni tudjon, és a központi egység számára hozzáférhetővé is tudja tenni, be van

építve a 8255A-ba.

A PIO lapka használata a következő két módszer valamelyikével történhet:

valódi B/K eszköz

memória egy területe

Ha valódi B/K eszközként szeretnénk használni, akkor egy külön sínvezetékre van szükség,

amellyel jelezni tudjuk, hogy egy B/K eszközt szeretnénk használni, nem pedig a memóriát.

Ha a memória leképzett B/K módszert szeretnénk használni, akkor a memória 4 bájtját ki kell

jelölnünk, három bájtot a három port számára és egy bájtot a vezérlőregiszter számára. Az EPROM 2

KB címterületet igényel, a RAM szintén 2 KB területet és a PIO 4 bájtot. Az EPROM a 2 KB-ig terjedő

címterületet foglalja el, a RAM a 32 KB-tól 34 KB-ig terjedő területet, valamint a PIO a memória

legfelső 4 bájtját 65532-től 65535-ig. Ha a másik módszert választottuk volna a PIO megcímzésére, a

külön B/K címterületet, akkor az semmilyen memória címtartományt nem igényelt volna (viszont 4

bájt területet igényelt volna a B/K címtartományból).



51.

Minden olyan cím, amelynek a felső 5 bitje 0, a memória alsó 2 KB területére esik, tehát az

EPROM területére. Az EPROM lapka kiválasztó vezetékét egy 5 bites összehasonlító áramkör

bemenetére kell kötni, az egyik bementét pedig a 00000-ra.

Ugyanezt az elvet használják a RAM esetében is, azonban a RAM az olyan bináris címekre kell,

hogy válaszoljon, amelyek 1000 0xxx xxxx xxxx alakúak binárisan, ezért még egy inverterre is szükségvan.

Címdekódolás:

A PIO címdekódolás kissé bonyolultabb. A PIO-t akkor kell használni, ha a cím 1111 1111 1111

11xx alakú. Ha azonban a számítógép csak a központi egységet, két memórialapkát, és a PIO -t

használja, akkor nagy mértékben egyszerűsíthető a címdekódolás feladata, mivel csak és kizárólag az

EPROM címeinek esetében fordul elő az, hogy a legfelső címvezeték az 0.

A RAM kiválasztása történhet az alapján, hogy csak az 10xx xxxx xxxx xxxx alakú érvényes

címek lehetnek a RAM-ban, ezért a kiválasztás céljára elegendő a felső 2 bit. Minden cím, ami 11-gyel

kezdődik az a PIO címe lesz.

A részleges címdekódolás esetében nem teljes címeket használunk fel a dekódolásra.

Megvan az a tulajdonsága, hogy ha olvasunk a 0001 0000 0000 0000, 0001 1000 0000 0000 vagy a

0010 0000 0000 0000 címekről, ugyanazt az eredményt kapjuk.

Minden olyan címzés esetében, amely a memória alsó felére mutat, az EPROM lesz

kiválasztva. A részleges címdekódolást el kell kerülni, mert túlságosan nagy címterületet köt le.

Teljes címdekódolás megvalósítására 8 darab 8 KB x 8 bájtos RAM-ot használunk fel. Egyolyan számítógép számára, amelyben 8 darab 2 KB x 8 bájtos memória van, egyetlen ilyen dekóder

szintén elegendő, feltéve, hogy a lapkák mind a memóriatartomány különböző 8 KB méretű

címterületén vannak.

DMA:

Ha nagyobb adatmennyiségeket kívánunk a memória egyes részei között mozgatni, vagy egy

perifériális eszközrõl a memóriába beolvasni, akkor a DMA vezérlőt használja fel a számítógép ennek

gyors lebonyolítására. Erre a feladatra egy "cél-processzort" kell használni, amelyik az írási és olvasási

címeket automatikusan és igen gyorsan egyesével növeli, és a beolvasott adatot késlekedés nélkül

írja a cél-helyre. Természetesen ezen folyamat alatt az "igazi" processzornak hallgatnia kell, nehogy a

cím- vagy adatbuszon helyrehozhatatlan keveredés álljon elõ. Ezen túlmenõen van még egy igen

fontos feladata: a DMA vezérlõ végzi a dinamikus RAM memória felfrissítését. Az idõzítõ 1. csatornája

kb. 15 microsec.-ként jelzést küld a DMA vezérlõnek. A DMA vezérlő ezt továbbítja a DMA RQ (DMA

REQEST) vezetéken a processzornak. A processzor ekkor befejezi az elkezdett processzorciklust, majd

visszaüzen a DMA vezérlõnek, hogy az átveheti a buszok vezérlését. A DMA 5 processzorciklus idejéig

kezeli a vonalakat. A DMA egység által végrehajtott látszólagos adatblokk-mozgások a memória egy-

egy részének felfrissítésével járnak. 512 ilyen felfrissítõ ciklus az egész memóriát "felújítja", a teljes

memória tehát mintegy milisecundumonként felfrissítésre kerül. Ez bõven elegendõ a megbízható,

hibamentes mûködéshez.



52.

21. Utasítás szintű párhuzamosítás, csővezeték (pipelining).

Utasításszintű párhuzamosság

A számítógép fejlesztők mindig arra törekszenek, hogy növeljék az általuk tervezett gépekteljesítményét. Az egyik módszer a chipek gyorsítására, hogy megnövelik a belső óra sebességét. Ámminden új technikának megvan a maga határa, amit a kor pillanatnyi szintje határoz meg.Összefoglalva a legtöbb computer-fejlesztő a párhuzamosság felé törekszik (két vagy több dologegyidejű elvégzése). Ez az a módszer, amely még inkább növeli a teljesítményt egy adott óra-

sebesség mellett.

A párhuzamosságnak két fontos fajtájáról beszélhetünk: az utasítás-szintű, és a processzorokszintjén levő párhuzamosságról. Az előbbiben a gép azt hasznosítja, hogy a párhuzamosság miattmásodpercenként több utasítás adható ki. Az utóbbiban pedig összekapcsolt CPU-k dolgoznak együttugyanazon a problémán. Mindkét megközelítésnek megvan a maga érdeme. Ebben a részben az

utasítás-szintű paralellizmussal foglalkozunk.

Csővezeték

Évek óta ismert, hogy a memóriából aktuálisan előkerülő utasítások nagy torlódást idéznekelő, s ezzel lassítják a végrehajtási sebességet. Hogy kezelni tudják ezt a problémát, a computereknekvissza kell térnie legalább az IBM-Kibővitésig (1959), amikor még meg volt az a tulajdonság, hogy azutasítások előre fel voltak hozva a memóriából, így kéznél voltak amikor csak szükség volt rájuk. Ezeka parancsok egy regiszterblokkba - az előtárba - voltak behelyezve. Így, amikor szükség volt egyutasításra, rendszerint elő lehetett venni az előtárból - inkább, mint arra várni, hogy feljöjjön amemóriából.

Ennek eredményeképp az utasítások "származása" alapján történő csoportosítás avégrehajtást két részre bontja: előhozási és aktuális végrehajtás. A csővezeték koncepciója mégtovább viszi ezt a stratégiát. A parancsok végrehajtásának két részre osztása helyett gyakran sokrészre osztották, s mindegyiket a hardver meghatározott része irányította. Mindet ami képespárhuzamosan futni.

Ötszakaszos pipeline:

utasítást lekérdező egység -> utasítást dekódoló egység -> operandus lekérdező egység ->

utasítást végrehajtó egység -> visszaíró egység

Gondoljunk ki egy analógiát, hogy a pipelineok fogalmát tisztábbá tegyük. Képzeljünk el egy

tortagyárat, ahol a sütés és a szállítás el van különítve. Tegyük fel, hogy a szállító részlegnek van egy

hosszú futószalagja, mellette sorban 5 munkással (feldolgozó egységek). Minden 10 másodpercben (a

ciklus) az 1. munkás egy üres dobozt rak a szalagra. Ezután a doboz a 2. munkáshoz kerül, aki belerak

egy tortát. Egy kicsivel később a doboz megérkezik a 3. munkáshoz, aki lezárja. Utána folytatja útját a

4. munkáshoz, aki rak egy címkét a dobozra. Végül az 5. munkás leveszi a dobozt a szalagról és egy

nagyobb tárolóegységbe rakja az áruházba történő későbbi szállításához. Alapvetően így működik a

számítógépnél a pipeline: mindegyik utasítás (torta) végigmegy néhány feldolgozó lépésen, mielőtt

végrehajtva kijut a végén.



53.

Visszatérve a pipelinera a 2-4. ábrához feltételezzük, hogy a ciklusidő 2 nsec volt. Így 10 nsec-

be kerül egy utasításnak, hogy végighaladjon az ötszakaszos pipelineon. Első pillantásra ha egy

utasításnak 10 nsec-ig tart, akkor úgy tűnik, hogy a gép 100 MIPS-el fut, de valójában ennél sokkal

jobb. Minden ciklusban (2 nsec) egy új utasítást hajt végre, így a feldolgozás mértéke 500 MIPS, nem

pedig 100 MIPS.

A pipeline megengedi, hogy a "lappangást" (mennyi ideig tart az utasítást végrehajtani) és a

processzor sávszélességét (a CPU MIPS teljesítménye) felváltva használja. Egy T nsec -es ciklusidővel

és n szakaszos pipeline-nal a lappangási idő nT nsec és a sávszélesség 1000/T MIPS. (logikus, mivel az

időt nsec-ban mérjük, így a CPU sávszélességét BIPS-ben vagy GIPS-ben kellene mérni, de mivel ezt

senki sem teszi, így mi sem fogjuk)

Szállítószalag elv

Ez az elv azt a problémát enyhíti, miszerint olyan gyorsan hajthatunk végre egy-egy utasítást,

amilyen gyorsan azt fel tudjuk dolgozni / végrehajtani (utasítás beolvasás, dekódolás, operandusbeolvasás, utasítás végrehajtás, visszaírás). Már régóta használatos az előolvasási puffer (prefetch buffer), ami képes előre beolvasni

utasításokat, hogy rendelkezésre álljanak, amikorra végre kell őket hajtani, ahelyett hogy mindigvárni kelljen egy-egy memóriából való beolvasásra.

Ez a módszer az utasítás végrehajtását két részre osztja: beolvasás és a végrehajtás.

A szállítószalag elv ezt az elvet viszi tovább, miszerint a végrehajtás fázist még több elemre osztjaszét, s minden külön részt egy-egy másik hardver elem végez egymással párhuzamosan.

(5 fázisú szállítószalag)

Működés: A számítógép számára rengeteg feladatot elküldtünk, hogy végezze el, ilyenkor az elsőlépése, hogy az S1 hardver elem az első utasítást beolvassa (órajel: 1) mikor kész, a következőórajelnél (2) egy másik hardverelem, S2 már az elöbb beolvasott adatot dekódolja, ugyanebben azidőben (órajel: 2) S1 beolvassa a következő utasítást párhuzamosan. Órajel: 3 –nál S1 már akövetkező utasítást olvassa be, S2 az előzőleg beolvasott utasítást dekódolja, S3 pedig az előzőlegdekódolt utasításhoz beolvassa az operandusokat ugyanabban az órajelben (3). És így továbbhalad, lényege, hogy egyszerre 5 fázist tud végezni…



54.

22. Utasítás betöltő egység. Mic – 2.

Utasítás betöltő egység

Ha egy utasításnak további mezői vannak (operandusok számára), minden mezőthatározottan be kell tölteni, egyszerre csak egy bájtot, és mielőtt felhasználnánk , össze kell rakni

őket. Egy mező betöltése és összerakása bájtonként legalább egy ciklusra leköti az ALU –t, hogy

megnövelje a PC-t, és azután ismét, hogy összerakja a keletkező indexet vagy eltolást. Az ALU-t szinte

minden ciklusban sokféle műveletre használjuk az utasításbetöltéssel és az utasításon belüli mezők

összerakásával kapcsolatban, az utasítás „valódi” munkáján felül.

Annak érdekében, hogy a főciklust átlapoljuk, szükséges, hogy az ALU-t felszabadítsuk a fenti

feladatok némelyikéből. A Mic-1 –ben sok betöltés eltávolítható az ALU-tól egy független egység

megalkotásával, amely betölti és feldolgozza az utasításokat. Ez az egység, amit IFU-nak (Instruction

Fetch Unit, utasításbetöltő egység) nevezünk, amely képes függetlenül növelni a PC-t és betölteni abájtokat a bájtfolyamból, még mielőtt szükség lenne rájuk.

Az IFU felelős egy bájtfolyam betöltéséért. Ezt azzal éri el, hogy a hagyományos 4 bájtos

memóriaportot használja idő előtt betöltve teljes 4 bájtos szavakat, és az egymást követő bájtokat

egy léptetőregiszterbe tölti, ami egyesével vagy kettesével szolgáltatja azokat a betöltés

sorrendjében. A léptetőregiszternek az a szerepe, hogy fenntart egy bájtsort a memóriából, és tölti

MBR1-be és MBR2-be. Valahányszor az MBR1 kiolvasódik, a léptetőregiszter jobbra léptet egy bájtot.

Valahányszor az MBR2 kiolvasódik, jobbra léptet 2 bájtot. Ezután az MBR1 és MBR2 újratöltődik a

legrégebbi bájtból, illetve bájtpárból. Ha most elegendő hely marad a léptetőregiszterben egy másik

teljes szó számára, akkor az IFU elkezd egy memória ciklust a beolvasásra.

Hogy helyesen dolgozzunk, az IFU-nak le kell blokkolnia, amikor arra kérik, hogy tegyen meg

valamit, amit nem tud, úgy mint szolgáltassa MBR2 értékét, amikor csak 1 bájt van a

léptetőregiszterben és a memória még el van foglalva egy új szó betöltésével. Ezenkívül egyszerre

csak egy dolgot tud csinálni, így a beérkező eseményeket sorba kell állítania. Végül valahányszor a PC

megváltozik, az IFU-t frissíteni kell.

Az IFU-nak saját memóriacím-regisztere van, az IMAR, melyet a memória címzésére

használunk, amikor egy új szót kell betölteni. Ennek a regiszternek saját tulajdonú növelője van, így a

fő ALU-ra nincsen szükség, amikor a következő szó eléréséhez növeljük azt. Az IFU-val a fő

végrehajtási egység csak akkor ír a PC-be, amikor meg kell változtatni az utasításbájt folyamának

soros jellegét.

Mivel a mikroprogram már nem közvetlenül növeli a PC-t a műveleti kódok betöltésénél, az

IFU-nak kell a PC-t időszerűen tartani. Ezt azzal éri el, hogy érzékeli, amikor az utasításfolyamból 1

bájt felhasználásra kerül, vagyis, amikor MBR1-et vagy MBR2-t (vagy az előjeltelen verziókat)

kiolvassák. A PC-hez kapcsolódik egy önálló növelő, amelyik attól függően képes 1 vagy 2 bájttal

növelni, hogy hány bájtot használtunk fel. Így a PC mindig a még fel nem használt első bájt címét

tartalmazza. Minden egyes utasítás kezdetén az MBR tartalmazza az ehhez az utasításhoz tartózó

műveleti kód címét.



55.

Mic-2

Az IFU nagyon lecsökkentheti az átlagos utasítás úthosszát:

Először is, teljesen eltávolítja a főciklust, mivel minden egyes utasítás vége egyszerűen

közvetlenül ágazik el a következő utasításra. Másodszor, elkerüli, hogy az ALU-t a PC növelésére kössük le.

Harmadszor, csökkenti az úthosszt valahányszor egy 16 bites indexet vagy eltolást számítunk

ki, mert összerakja a 16 bites értéket és ezt, mint egy 32 bites értéket, közvetlenül

szolgáltatja az ALU-nak, elkerülve, hogy H-ban kelljen összerakni.

Az IADD művelet betölti a veremben lévő második szót és elvégzi az összeadást. Amikor az

IFU észleli, hogy az IADD-ban hivatkozunk MBR1-re, a belső léptetőregisztere mindent jobbra tol és

újratölti MBR1-et és MBR2-t. Végrehajt egy átmenetet is a jelenlegi állapotából az eggyel

alacsonyabba. Ha az új állapot 2, az IFU elkezd betölteni egy szót a memóriából. Mindez a hardverben

történik, a mikroprogramnak semmit sem kell tennie, ezért csökkenthető az IADD öt mikroutasításrólhárom mikroutasításra.

A Mic-2 néhány utasítást jobban feljavít, mint másokat, és ebből következik, hogy nagyobb

nyeresége van. Az LDC_W kilenc mikroutasításról csupán háromra változik, harmadolva a

végrehajtási időt. Másrészről, a SWAP csak nyolcról hat mikroutasításra változik. Átlagos

teljesítménynél valójában a gyakoribb utasításoknál kapott nyereség számít. Ezek közé tartozik az

ILOAD (6 volt, most 3), az IADD (4 volt, most 3) és az IF_ICMPEQ (sikeres esetben 13 volt, most 10;

sikertelen esetben 10 volt, most 8). Ahhoz, hogy megmérjük a gyorsítást, választanunk és futtatnunk

kellene egy tesztágyat, de világos, hogy itt nagy a nyereség.



56.

23. Csővonalas terv: a Mic-3

A Mic-3 a Mic-2 továbbfejlesztése. Még gyorsabbá úgy tudnánk tenni, ha megpróbálnánk

csökkenteni a ciklusidőt. Jelentékeny méretékben a ciklusidőt a lapkatechnológia határozza meg.

Minél kisebbek a tranzisztorok és minél kisebb a köztük lévő fizikai távolság, annál gyorsabban tud azóra futni. Egy adott technológia számára az idő, amely egy teljes adatút művelet végrehajtásához

szükséges, állandó. A másik választás a gyorsabbá tételre, ha párhuzamosságot viszünk a gépbe.

Mint az előbb említettük, az óraciklust behatárolja az idő, amelyik szükséges a jel

tovaterjedéséhez az adatúton. Három fő alkotóelem van a folyamatban levő adatút ciklushoz:

Az idő a kiválasztott regiszterek rávezetéséhez az A és D sínekre. Az idő, amíg az ALU és a léptetőregiszter elvégzi a munkáját. Az idő, amíg az eredményeket visszaküldjük a regiszterekbe és eltároljuk.

A Mic-3 csővonalas modell, háromsínes architektúrából áll, hozzávéve az IFU-t, és háromtovábbi tárolót (regisztert), melyeket minden egyes sín közepére illesztünk. A tárolókat minden egyes

ciklusban írjuk. Végeredményben a regiszterek szétválasztják az adatutat különböző részekre,

amelyek most egymástól függetlenül működhetnek. Most három óraciklus kell az adatút

használatához.

A tárolók beillesztésének értelme kétszeres:

Gyorsítjuk az órát, mert a maximális késleltetés most rövidebb. Minden egyes ciklus alatt az adatút minden részét használhatjuk.

Az adatút három részre osztásával a maximális késleltetés csökken annak

eredményeképpen, hogy az órafrekvencia növekedhet. Tegyük fel, hogy az adatút három

időintervallumra osztásával mindegyik körülbelül harmad olyan hosszú, mint az eredeti, így az óra

sebességét megháromszorozhatjuk.

Az adatút most három ciklust igényel a működéséhez: egyet az A és B betöltéséhez, egyet a

művelet elvégzéséhez és a C feltöltéséhez, és egyet az eredmény visszaírására a regiszterekbe.

Minden egyes ilyen darabot mikrolépésnek hívunk.

Ahol egy mikrolépés nem tud indulni, mert egy eredményre vár, amit az előző mikrolépés

még nem hozott létre, valódi függőségnek vagy RAW függőségnek nevezzük. A függőségekre gyakran

úgy hivatkozunk, hogy akadályok. A RAW egy rövidítés a Read After Write számára, és azt jelenti,hogy egy mikrolépés olvasni akar egy regisztert, melybe még nem írtunk. Elakadásnak nevezzük,

amikor megállunk, hogy egy szükséges értéket megvárjunk.

Habár a Mic-3 több ciklust igényel, mint a Mic-2 program, mégis gyorsabban fut. Ha a Mic-3

ciklusidejét t ns-nak vesszük, akkor a Mic-3 11t ns-ot igényel a SWAP végrehajtásához. Ellenben, a

Mic-2 6 ciklust igényel, melyek mindegyike 3t, összesen 18t. A csővezeték gyorsabbá teszi a gépet,

még akkor is, ha egyszer le kellett állni, hogy elkerüljünk egy függőséget.

A csővezeték egy kulcsmódszer minden korszerű CPU-ban. Még egy fontos részlet, hogy bár

egy egydülálló utasítás négy óraciklust igényel a végrehajtáshoz, minden egyes óraciklusban egy újutasítás kezdődik és egy régi utasítás fejeződik be.



57.

24. Egy hétszakaszú szállítószalag: a Mic-4 csővezetéke.

Miden egyes mikroutasítás kiválasztja a rákövetkezőjét. A legtöbbjük éppen a következőt

választja ki a folyamatban lévő sorozatban, de az utolsó, mint amilyen swap6, gyakran egy többutas

elágazást csinál, ami eldugaszolja a csővezetéket, mert utána lehetetlen folytatni az előre betöltést.A kérdés kezelésének egy jobb módszerére van szükségünk.

A következő (és egyben utolsó) mikroarchitektúránk a Mic-4. A fő alkotóelemeit a 4.35. ábrán

mutatjuk be, de egy tekintélyes mennyiségű részlet el van nyomva az érthetőség kedvéért. Mic-3-hoz

hasonlóan van egy IFU, amelyik előre betölt szavakat a memóriából, és kezeli a különböző MBR-eket.

Az IFU a bejövő bájtfolyamot egy új alkatrésznek, a dekódoló egységnek adagolja. Ennek az

egységnek van egy belső ROM- ja, amit az IJVM műveleti kódjával indexelünk. Minden egyes

bejegyzés (sor) két részből áll: ennek az IJVM-utasításának a hossza és egy index egy másik ROM-ba, a

mikroműveletek ROM- jába. Az IJVM-utasítás hosszát arra használjuk, hogy hozzájáruljunk: adekódoló egység felismerje a bejövő bájtfolyamatban az utasításokat, í gy az mindig tudni fogja, hogy

melyek a műveleti kód bájtok és melyek az operandusok. Ha éppen egy utasítás hossza 1 bájt (pl.

POP), akkor a dekódoló egység tudja, hogy a következő bájt egy műveleti kód. Ha azonban a jelenlegi

utasításhossz 2 bájt, akkor a dekódoló egység tudja, hogy a következő bájt egy operandus, melyet

közvetlenül egy másik műveleti kód követ.

Amikor a WIDE előtag feltűnik, a következő bájtot egy különleges széles műveleti kódra

alakítjuk át, pl. WIDE ILOAD átalakul WIDE_ILOAD-dá.

A dekódoló egység elküldi a mikromüveletek ROM- jához azt az indexet, amit a saját

táblázatában talált, a következö alkatrész, a sorba állító egység számára. Ez az egység néhány logikát

és két belső táblázatot tartalmaz, egyet ROM-ban és egyet RAM-ban. A ROM azt a mikroprogramot

tartalmazza, ahol minden egyes IJVM-utasításnak néhány egymást követő bejegyzése van, amit

mikroműveletnek nevezünk. A bejegyzéseknek sorrendben kell elhelyezkedniük, így olyan trükk,

mint WIDE_ILOAD2 ugrása ILOAD2-re a Mic-2-ben, nem megengedett. Minden egyes IJVM-sorozatot

pontosan és teljes terjedelmében meg kell határozni, megismételve a sorozatokat bizonyos

esetekben.

A mikroműveletek hasonlítanak a 4.5. ábra mikroutasításaihoz, kivéve, hogy a NEXT_ADRESS

és JAM mezők hiányoznak, és egy új kódoló mező szükséges az A sín bemenet elöírásához. Két új bit

is kell: a Final és a Goto. A Final bit be van állítva minden egyes IJVM-mikroművelet sorozat utolsó

mikroműveleténél, megjelölve azt. A Goto bit ezért van beállítva, hogy megjelölje azokat a

mikroműveleteket, amelyek feltételes mikorelágazások. Ezeknek a közönséges mikroművelettől

különbözö formája van, amely tartalmazza a JAM biteket és egy indexet a mikromű velet ROM- jába.

Azokat a mikroutasításokat, amelyek előzőleg valamit csináltak az adatúttal és végrehajtottak egy

feltételest mikroelágazást is (pl. iflt4), most két mikroműveletre kell szétdarabolnunk.



58.

A sorba állító egység a következöképpen müködik. Átvesz egy indexet a mikromüvelet ROM-

jához a dekódoló egységtöl. Ezután kikeresi a mikromüveletet és bemásolja azt egy belsö sorba. Majd

a következö mikromüveletet is bemásolja a sorba, és ezután a következöt is. Ezt addig folytatja, amig

talál egy olyat, ahol a Final bit egy. Ezt is átmásolja, és megáll. Feltéve, hogy nem talált olyan

mikromüveletet, amelyben a Goto bit egy, és maradt még elegendö hely a sorban, a sorba állító

egység ezután egy nyugtázó jelet küld vissza a dekódoló egységnek. Amikor a dekódoló egység

felfogja a nyugtázást, a következö IJVM-utasítás indexét elküldi a sorba állító egységnek.

Ilyen módon a memóriában lévö IJVM-utasítások sorozata alapvetöen átalakul

mikromüveletek egy sorozatára egy sorban. Ezek a mikromüveletek táplálják a MIR-eket, amelyek

jeleket küldenek az adatút vezérléséhez. Azonban, van egy másik tényező amit most figyelembe kell

vennünk: a mezök az egyes mikromüveletben nem ugynabban az idöben hatnak. Az A és B mezök az

elsö ciklus alatt hatékonyak, az ALU mezö a második ciklus alatt hatékony, a C mezö a harmadik ciklus

alatt hat, és bármelyik memoria müvelet a negyedik ciklusban kerül sorra.

Hogy teljessé tegyük ezt a munkát, négy független MIR-t vezetünk be a 4.35. ábrára. Mindenegyes ora ciklus kezdetekor (a 4.3. ábrán a Δw idö), MIR3 átmásolodik a MIR4-be, MIR2 átmásolodik

MIR3-ba, MIR1 átmásolodik MIR2-be, és MIR1-böl az A és B mezöket arra használjuk, hogy

kihasználjuk azokat a regisztereket, amelyeket az A és B tárolokhoz vezetünk, de az ALU mezöt a

MIR1-ben nem használjuk és nincs semmi máshoz hozzákapcsolva az adatútban.

Egy oraciklussal késöbb, ez a mikromövelet átmegy MIR2-be, és azok a regiszterek,

amelyeket kiválasztott, most biztonságosan az A és B tárolokban helyezkednek el; várva a kalandok

eljövetelét. Az ALU mezöjét most arra használjuk, hogy az ALU-elvezessük. A következö ciklusban a C

mezöje fogja az eredményeket visszaírni a regiszterbe. Azután átmegy MIR4 -be, és elinditja

valamelyik szükséges memoria müveletet, felhasználva a most betöltött MAR-t (és MDR-t egy

iráshoz).

A Mic-4 egy utolso szempontja most némi megbeszélést igényel: mikroelágazások. Néhány

IJMV-utasítás, mint amilyen az IFLT, megkívánja, hogy a feltételes elágazás, mondjuk az N biten

alapuljon. Amikor egy mikroelágazás megtörténik, a csövezeték nem folytatódhat. Hogy ezt kezelni

tudjuk, hozzávettük a Goto bitet a mikromüvelethez. Amikor a sorba állító egység talál egy olyan

mikromüveletet, amelyiknek ez a bitje be van állítva, miközben átmásolja azt a sorba, ráébred, hogy

nehézségek következnek, és tartozkodik a nyugtázás elküldésétöl a dekódoló egységnek.

Eredményként a gép elakad ezen a ponton, amíg a mikroelágazás meg nem oldódik.

Elképzelhetően, néhány IJVM-utasítás az elágazáson túl már a dekódoló egységbe be lett

táplálva (de a sorba állító egységbe nem), mivel nem küldött vissza nyugtázo (vagyis folytató) jelet,

amikor megtalált egy Goto bittel beállított mikromüveletet. Különleges hardver és mechanizmusok

szükségesek, hogy az össze-visszaságot tisztázzák és visszatáncoljanak, de ezek már túlmutatnak

ennek a könyvnek a témakörén. Amikor Edsger Dijkstra megírta híres levelét „ GOTO Statement

Considered Harmful” („ A GOTO utasítást károsnak tartják”) (Dijkstra, 1968 ), sejtelme se volt, hogy

mennyire igaza volt.

Hosszú utat jártunk be a Mic-1 óta. A Mic-1 egy nagyon egyszerü hardverdarab volt, szinte

teljes szoftvervezérléssel. A Mic-4 egy erösen csövezetékezett terv hét szakasszal és sokkal bonyolúltabb hardverrel. A csövezetéket vázlatosan a 4.36. ábrán mutatjuk be, azzal, hogy a



59.

bekarikázott a 4.35. ábra alkotóelemeire hivatkoznak. A Mic-4 önmüködöen elöre betölt egy

bájtfolyamota memoriábol, dekódolja azokat IJVM-utasításokká, átalakitja azokat mikromüveletek

egy sorozatává egy ROM-ot használva, és sorba állítja azokat felhsználásra, amint szükséges. A

csövezeték elsö három szakasza az adatút orájához köthetö, ha szükséges, de nem mindig van

elvégezendö munka. Például, az IFU biztosan nem képes táplálni egy új IJVM müveleti kódot a

dekódoló egységben minden oraciklusnál, mert az IJVM-utasítások különbözö ciklusokat igényelnek a

végrehajtáshoz, és a sor gyorsan túlcsordúlna.

Minden egyes ora ciklusban, a MIR-ek elöre lépnek, és a sor alján levö mikromüvelet

bemásolodik MIR1-be, hogy elkezdje a végrehajtást. A négy MIR-böl jövö vezérlö jelek ekkor

kiterjednek az adatút felé, tevékenységek bekövetkezését okozva. Minden egyes MIR az adatút

különbözö részeit vezérli és ennek következtében különbözö mikrolépéseket.

Ebben a tervben egy mélyen csövezetékezett CPU-nk van, amelyik megengedi, hogy az egyes

lépések nagyon rövidek és ennélfogva az ora frekvencia magas legyen. Számos CPU alapvetöen ilyen

módon van tervezve, különösen azok, melyeknek egy régebbi (CISC) uatsításhalmazt kelletmegvalósítaniuk. Például, a Pentium II megvalósítás elviekben hasonló a Mic-4-hez bizonyos

szempontból, ahogy azt késöbb látni fogjuk ebben a helyzetben.



60.

25. Elágazás, eltolási rés, statikus és dinamikus elágazás jövendölés

Elágazás, eltolás rés

A modern számítógépek magas szinten vannak csővezetékkel ellátva. A csúcsteljesítményűgépeknek néha 10 vagy még több szakaszos csővezetéke van. A csővezetékek legjobban lineáris

kóddal dolgoznak, de a programok nem lineáris kódsorozatok. Teli vannak elágazási utasításokkal. Az

utasítás-dekódoloás a második szakaszban történik /4.35. ábra/. Így a betöltő egységnek kell

eldöntenie, hogy honnan töltse be a következőt, még mielőtt tudná, milyen utasítást kapott éppen.

Csak egy ciklussal később tudhatja meg, hogy pont egy feltétel nélküli elágazási utasítást kapott, és

akkorra már elkezdte a feltétel nélküli elágazást követő utasítást betölteni. Ennek következtében a

csővezetéket alkalmazó gépek (pl. UltraSPARC III) tekintélyes részének megvan az a tulajdonsága,

hogy egy feltétel nélküli elágazást követő utasítás végrehajtódik, annak ellenére, hogy logikusan nem

kellene. Az elágazás utáni állapotot eltolás résnek nevezzük.

A feltételes elágazások nem csak eltolás réseket hoznak létre, hanem a betöltő egység még

azt sem tudja, hogy sokkal később honnan olvasson a csővezetékbe. A korai csővezetékes gépek

csaknem bedugultak, amíg nem derült ki, hogy lesz elágazás vagy nem. Következésképpen a legtöbb

gép, amikor talál egy feltételes elágazást, megjövendöli, hogy végre fogjuk hajtani vagy nem.

Különféle módszereket gondoltak ki a jövendölésre. Egy nagyon egyszerű mód a következő.

Tételezzük fel, hogy minden visszafelé történő feltételes elágazást végre fogunk hajtani, és az összes

előreirányulót nem. Az első rész mellett az az érv, hogy a visszafelé elágazások gyakran egy ciklus

végén helyezkednek el. A legtöbb ciklust többször hajtjuk végre, így az a feltevés, hogy egy visszafelé

elágazás a ciklus tetejére végre lesz hajtva, általában jó fogadás.

A második rész rázósabb. Néhány előreelágazás akkor fordul elő, amikor hibafeltételeket

észlelünk a szoftverben. A hibák ritkák, így a legtöbb velük összefüggő elágazást nem hajtjuk végre.

Természetesen sok olyan előreelágazás van, ami nem kapcsolódik hibakezeléshez, így a siker aránya

közel sem olyan jó, mint a visszafelé elágazásnál.

Ha egy elágazást pontosan megjósoltunk, akkor semmi különös tennivaló nincs. A végrehajtás

éppen a célcímnél folytatódik. A nehézség akkor jön, amikor rosszul jósoltunk meg egy elágazást.

Kigondolni, hogy hova kell menni nem nehéz. A nehéz rész, visszacsinálni azokat az utasításokat,

amelyeket már végrehajtottunk, de nem kellett volna.

Dinamikus elágazás jövendölés

Világos, hogy nagyszámú pontos jövendölés teszi lehetővé a CPU-nak, hogy teljes sebességgel

haladjon. Ennek következtében a jelenlegi kutatások nagy része az elágazást jövendölő algoritmusok

javítását célozza. Egy közelítés az, hogy a CPU fenntart egy előzmények táblát, amelyben feljegyzi a

feltételes elágazásokat, amint előfordulnak, így azok kikereshetők, ha ismét előfordulnak. Számos

módszer van az előzmények tábla szervezésére. Valójában ezek pontosan ugyanazok a módszerek,

mint amelyeket a gyorsítótár szervezésénél használunk. Tekintsünk egy gépet 32 bites utasításokkal,

amelyek szóhatáron kezdődnek, vagyis minden memóriacím alsó 2 bitje 00. Egy direkt leképezésű 2

az n-ediken bejegyzést tartalmazó előzmények tábla esetén egy elágazási utasítás alsó n2 bitjétkivehetjük, és 2 bittel jobbra léptethetjük. Az n bites számot indexként használhatjuk az előzmények



61.

táblához, ahol egy ellenörzést végzünk annak megállapítására, hogy az ott tárolt cím megegyezik-e az

elágazás címével. Úgy mint a gyorsítótárnál nincs szükség az alsó n2 bit tárolására, így mellözhetjük

azokat. Ha találat van, a jövendölö bitet használjuk az elágazás jóslására. Ha rossz cimke van ott vagy

a bejegyzés érvénytelen, akkor hiány lép fel, épp úgy, mint a gyorsítótárnál. Ebben az esetben az

elöre/visszafelé elágazási szabályt alkalmazhatjuk.

Ha elég nagy a táblaméret és elegendö az asszociativitás, akkor ez az elrendezés a legtöb

esetben jól müködik. Viszont egy rendszeres probléma mindig elöfordul. Amikor a ciklus végül kilép, a

végén az elágazás tévesen lesz megjövendölve, és a rossz jövendölés megváltoztaja az elözmények

táblát úgy, hogy "nincs elágazás"-nak jelöli a következö jövendölést. Amikor legközelebb a ciklusba

lépünk, az elsö ismétlés végén az elágazás rosszul lesz megjövendölve. Ha a ciklus egy külsö ciklus

belsejében van, vagy egy gyakran meghívott eljárásban, akkor ez a hiba gyakran elöfordulhat. Hogy

kiküszöböljük ezt a téves jövendölést, adhatunk a táblázat bejegyzésének egy második lehetöséget.

Ezzel a modszerrel a jövendölés csak két egymás utáni helytelen jövendölés után változik meg. Ez a

megközelítés két jövendölö bit meglétét követeli meg az előzmények táblában, egyet arra, hogy az

elágazás "feltehetöleg" mit fog csinálni, és egyet arra, hogy mit csinált legutóbb.

Mindeddig feltételeztük, hogy minden feltételes elágazás célpontja ismert, jellemzöen vagy

egy határozott cím, ahova el kell ágazni, vagy mint egy relatív eltolás a jelenlegi utasításhoz képest.

Gyakran ez a feltételezés indokolt, de néhány feltételes utasítás a célcímet regisztereken végzett

aritmetikai müveletekkel számolja ki, és azután megy oda. Az olyan jövendölésnek nincs haszna,

amelynél a célcím ismeretlen. Egy modszer ennek a helyzetnek a kezelésére, hogy tároljuk az

elözmények táblában azt a tényleges címet, ahová legutóbb elágaztunk. Egy másik megközelítése az

elágazás jövendölésnek, hogy nyomon követjük. hogy az utolsó k feltételes elágazás, ami elöfordul,

vége lett-e hajtva, függetlenül attól, hogy az melyik utasítás volt. Ezt a k bites számot, amelyet az

elágazási előzmények blokkos regiszterében tárolunk, összehasonlítjuk párhuzamosan az

elözmények tábla minden bejegyzés egy k bites kulcsával, és ha egy találat előfordul, akkor az ott

talált jövendölést használjuk.

Statikus elágazás jövendölés

Minden eddig tárgyalt elágazásjövendölési modszer dinamikus, azaz futásidöben hajtjuk

végre, mialatt a program fut. Alkalmazkodik a program érvényes viselkedéséhez, ami jo dolog. A rossz

oldal az, hogy szakosított és drága hardvert igényel, és nagyszámú lapka bonyolult összességét.

Néhány gép, mint az UltraSPARC III, rendelkezik egy második feltételes elágazási utasításhalmazzal, a szokásoson felül. Az új tartalmaz egy bitet, amelyben e fordítoprogram

meghatározhatja, hogy úgy gondolja, hogy az elágazás végre lesz hajtva, vagy nem. Ha ezek egyike

elöfordul, a betöltö egység pontosan azt teszi, amit mondanak neki. Továbbá, nem szükséges értékes

helyet pazarolni az elágazási elözmények táblában ezekre az utasításokra, így csökkennek itt az

öszzeütközések.

Végül az utolsó elágazásjövendölési modszerünk a metszetben ábrázoláson alapszik Ez szintén

egy statikus módszer, de ahelyett, hogy a fordítoprogramnak kelljen megprobálni kiszámolni, hogy

melyik elágazást hajtjuk végre, és melyiket nem, a program valójában fut, és az elágazás viselkedését

megfigyeljük. Ezt az információt betápláljuk a fordítoprogramba, amely azután felhasználja az egyedielágazás utasításokat arra, hogy a hardvernek megmondja, mit csináljon.



62.

26. Sorrendtől eltérő végrehajtás, szuperskaláris architektúra,függőségek, regiszter átnevezés, feltételezett végrehajtás

Sorrendtől eltérő végrehajtás, függőségek, regiszter átnevezés

Világos, hogy a számítógép-tervezés legegyszerűbb akkor, ha minden utasítást abban a

sorrendben hajtunk végre, ahogyan betöltöttük azokat (pillanatnyilag feltételezve, hogy az elágazás-

jövendölő algoritmus soha nem ad rossz tippet). Mégis, a sorrend szerinti végrehajtás nem mindig

eredményez optimális teljesítményt az utasítások közötti függőség miatt. Ha egy utasításnak egy

olyan értékre van szüksége, amit az előző utasítás számit ki, akkor a második nem tudja elkezdeni a

végrehajtást, amíg az első nem állítja elő a szükséges értéket. Ebben az esetben (RAW függőség) a

második utasításnak várnia kell. A függőségnek más fajtái is léteznek:

A RAW függőség az, ami akkor fordul elő, amikor egy utasításnak szüksége lenne egy olyan

eredményt használni forrásként, amit az előző utasítás még nem állított elő. A két másik függőségkevésbé súlyos. Alapvetően forrás-összeütközések. A WAR függőségben (Write After Read; olvasás

után írás) egy utasítás megpróbál felülírni egy regisztert, amelynek olvasását az előző utasítás még

lehet, hogy nem fejezte be. A WAW függőség (Write After Write; írás utáni írás) hasonló. Ezek

gyakran elkerülhetők, ha a második utasítás az eredményt valahova máshova teszi (esetleg

ideiglenesen). Ha a fenti három függőség egyike sem áll fenn, és a szükséges működési egység

elérhető, az utasítás kiosztható.

Tekintsünk egy alternatív elgondolást: a sorrendtől eltérő végrehajtást. Ebben az

elgondolásban az utasításokat sorrendtől eltérően lehet kiosztani, és ugyanígy sorrendtől eltérően

lehet befejezni. Pl. bár I4 elakadt, dekódolhatjuk és kioszthatjuk I5-öt, mivel ez nem ellenkezik egyikfüggőben lévő utasítással sem. Mindamellett, utasítások átugrása egy új problémát okoz. Tegyük fel,

hogy I5 használt egy olyan operandust, amelyet az átugrott utasítás, I4 számol ki. Ilyenkor ki kell

bővítenünk az eredményjelzőt úgy, hogy nyomonkövesse azokat a tárolásokat, amelyeket az átugrott

utasítások végeznek. Ezt egy második, regiszterként egy bites bittérkép hozzáadásával tudjuk

megtenni, hogy nyomon tudjuk követni az elakadt utasítások által végrehajtott tárolásokat. Az

utasítás kiosztás szabályát most ki kell terjeszteni, hogy megakadályozzuk minden olyan utasítás

kiosztását, amelynek operandusa ütemjelzés szerint egy olyan utasítással tárolódik ami előtte jött, de

átugrottuk.

A 4.44 ábrán egy új módszert vezettünk be, a regiszterátnevezést. Az előrelátó dekódolóegység az R1 használta az I6-ban és I7-ban egy titkos regiszterre, S1-re váltja, ami nem látható a

programozó számára. Most az I6-ot kioszthatjuk I5-tel párhuzamosan. A modern CPU-k gyakran titkos

regiszterek tucatjait használják regiszter átnevezéssel. Ez a módszer gyakran kiküszöböli a WAR és a

WAW függőségeket.



63.

Feltételezett végrehajtás

A számítógépes programok alapblokkolókra bonthatók szét, ahol minden alapblokk egy

lineáris kódsorozatból áll, a tetején egy belépési ponttal az alján egy kilépéssel. A gond az, hogy a

legtöbb alapblokk rövid és nincs elegendő párhuzamosság bennük, hogy azt hatékonyan

kihasználhassuk. Tehát a következő lépés az hogy megengedjük: az átrendezés az alapblokkokhatárain átnyúljon, megkísérelve ezzel minden kiosztási hely feltöltését. Egy kód végrehajtását ,

mielőtt még tudnánk, hogy egyáltalán szükség lesz-e rá feltételezett végrehajtásnak nevezzük.

Ennek a módszernek az alkalmazása támogatást vár a fordítóprogramtól és a hardvertől is, néhány

kibővítéssel az architektúrában. A legtöbb esetben az utasítások átrendezése az alapblokk határokon

keresztül meghaladja a hardver képességeit, így egyértelműen a fordítóprogramnak kell az utasítást

mozgatni. A feltételezett végrehajtás néhány érdekes problémát vet fel: Pl.: alapvető, hogy egyik

feltételezett végrehajtásnak sincsenek visszavonhatatlan eredményei, hiszen később kiderülhet, hogy

nem kellet volna azokat végrehajtani. Bonyolultabb kódsorozatoknál gyakori módszer annak

megelőzése, hogy a feltételezett végrehajtás felülírja a regisztereket, mielőtt még kiderül, kívánatos-

e, hogy átnézzük az összes célregisztert, amit a feltételezett végrehajtás használ.

Szuperskaláris architektúra

Egy két szállítószalagos CPU-nál az egyetlen utasítás-elolvasó egység két darab utasítást olvasbe egyszerre, majd ezeket az egyik, ill. a másik szállítószalagra teszi. A szállítószalagoknak saját ALU-ja

van, így párhuzamosan tudnak működni, feltéve, hogy a két utasítás nem használja ugyanazt azerőforrást, és egyik sem használja fel a másik eredményét.

A szállítószalagok számának emelése négyre még elképzelhető, de ekkor már túl sok

hardverelemet kell megduplázni. Ehelyett a nagy teljesítményű más megoldást alkalmaznak. Az

alapötlet az, hogy csak egy szállítószalagot használnak de több funkcionális egységgel. A

szuperskaláris architektúra kifejezés ennek az elrendezésnek a jelölésére 1987-ben született.

A szuperskaláris processzor elvében implicit módon benne van az a feltételezés, hogy az S3

lényegesen gyorsabban tudja előkészíteni az utasításokat, mint ahogy az S4 fázis végrehajtja őket. Ha

az S3 fázis 10 ns-ként produkál egy utasítást, és az összes funkcionális egység végezni tud 10 ns alatt,

akkor mindig csak legfeljebb egy fog dolgozni, így az egésznek nincs semmi haszna. Valójában a

negyedik fázis funkcionális egységeinek egy órajelnél jóval több időt igényel feladata elvégzéséhez, a

memóriához fordulók vagy a lebegőpontos műveleteket végzők legalábbis biztosan. Lehet több ALU

az S4 fázisban.



64.

27. Feltételes végrehajtás, predikáció

Az IA-64 másik fontos jellemzője az a módszer, amellyel a feltételes elágazásokat kezeli. Ha

mód lenne arra, hogy a legtöbbjüktől megszabaduljunk, a CPU sokkal egyszerűbb és gyorsabb lenne.

Első ránézésre lehetetlen megszabadulni tőlük, mert a programok tele vannak if utasításokkal.Azonban, az IA-64 olyan technikát használ, az ún. predikációt, amely használatával nagymértékben

csökkenthető a számuk.

A jelenlegi számítógépek minden utasítása feltétel nélküli abban az értelemben, hogy amikor

a CPU eléri, akkor feltétel nélkül végrehajtja. Nincs helye belső kérdésnek: "Tenni vagy nem tenni?"

Ezzel ellentétben a predikációs architektúrákban az utasítások feltételt tartalmaznak (predikátum),

amely megmondja, hogy végre kell-e hajtani az utasítást, vagy sem. Ez a paradigma, amely

elmozdulást jelent a feltétel nélküli utasításoktól a predikációs utasítások felé, lehetővé teszi, hogy

(sok) feltételes elágazástói megszabaduljunk. Ahelyett hogy két, feltétel nélküli utasítássorozat között

kellene választani, valamennyi utasítást egyetlen predikációs utasítássorozatba fésülnek össze,különböző predikátumot alkalmazva különböző utasításokban.

A predikáció működésének bemutatását kezdjük egy egyszerű példával Ez a feltételes

végrehajtás (feltételes utasítás), a predikáció előd je. Az (a) ábra az if utasítást mutatja, a (b) ábrán

pedig ennek három utasítássá való lefordítása látható: összehasonlítás, feltételes elágazás és

mozgató utasítás. A (c) ábrán megszabadultunk a feltételes elágazástói, bevezetve egy új utasítást, a

feltételes mozgatást. Ez megvizsgálja az Rl regiszter tartaimát, ha 0, akkor R3-at átmásolja R2-be, ha

nem 0, akkor nem tesz semmit.

(a) if(R1==0)

R2=R3;

(b) CMP R1, 0

BNE L1

MOV R2, R3

L1:

(c) CMOVZ R2, R3, R1



65.

28. A Pentium 4, az UltraSPARC III és az I-8051 mikroarchitektúrája.

A Pentium 4 CPU mikroarchitektúrája

Kívülrő1 a Pentium 4 hagyományos CISC gépnek tűnik, nagy és nehezen kezelhetőutasításrendszerrel, amely támogatja a 8, 16 és 32 bites egész műveleteket, valamint a 32 és 64 bites

lebegőpontos műveleteket is. Csupán 8 látható regisztere van, és nincs két o lyan, amely teljesen

megegyezne. Az utasítások hossza 1 és 17 bájt között változik. Röviden, olyan örökölt architektúra,

ami látszólag mindent rosszul csinál.

Belülről azonban a Pentium 4 egy modern, egyszerű, mélyen csővezetékezett RISC-magot

tartalmaz, mely különlegesen gyors órafrekvencián fut, és ez valószínűleg a következő években

tovább növelhető. Egészen bámulatos, hogy az Intel mérnökei képesek voltak egy régi architektúrára

korszerű processzort építeni.

A NetBurst mikroarchitektúra áttekintése

A Pentium 4 mikroarchitektúrája, melyet NetBurst mikroarchitektúrának neveznek, teljesen

elszakad a Pentium Pro, Pentium II és Pentium IlI-nál használt korábbi P6 mikroarchitektúrától, és

alapját képezi annak, amire az Intel a következő néhány évben építeni fog. A Pentium 4 négy fő

részből áll: a memória-alrendszer, a bemeneti rész, a sorrenden kívüliséget vezérlő és a végrehajtó

egység.

A memória-alrendszer tartalmazza az egyesített L2 (2. szintű) gyorsítótárat és a küls6 RAM-

nak a memóriasínen való eléréséhez szükséges logikát. Az L2 az első generációs Pentium 4 -ben 256

KB volt, a másodikban 512 KB, a harmadikban pedig 1 MB. Az L2 gyorsítótár 8 utas halmazkezelésűgyorsítótár, mely 128 bájtos gyorsítósoron alapszik. Ha egy keresett bejegyzés nem található meg az

L2 gyorsítótárban, két 64 bájtos átvitelt kezdeményez a főmemóriából, hogy betöltse a szükséges

blokkokat. Az L2 gyorsítótár egy visszaíró szervezésű gyorsítótár. Ez azt jelenti, hogy sor

módosulásakor az új tartalom nem kerül vissza a memóriába, amíg a sor a memóriába nem töltődik.

A gyorsítótárhoz kapcsolódik egy előre betöltő egység, amely megpróbálja előre betölteni az

adatokat a főmemóriából az L2 gyorsítótárba, még mielőtt arra szükség lenne. Az L2 gyorsítótárból az

adatok nagy sebességgel áramolhatnak más gyorsítótárakba. Egy új L2 gyorsítótár betöltése minden

második óraciklusban kezdődhet, így például 3 GHz-es órajel mellett, elméletileg az L2 gyorsítótár

akár 1,5 milliárd 64 bájtos blokkot is szolgáltathat másodpercenként a többi gyorsítótárnak, ami 96GB/s sávszélességet jelent.

A memória-alrendszer alatt a bemeneti rész található, amelyik betölti az utasításokat az L2

gyorsítótárból, és dekódolja a programnak megfelelő sorrendben. Minden Pentium 4 ISA -utasítást

lebont RISC-szerű mikroműveletek sorozatára. Az egyszerűbb utasításokhoz a betöltő/dekódoló

egység határozza meg, mely mikroműveletek szükségesek. A bonyolultabbaknál a mikroművelet

sorozatot a mikro-ROM-ból keresi ki. Akár így, akár úgy, minden Pentium 4 ISA-utasítás

mikroműveletek sorozatává konvertálódik a lapka RISC magja számára. Ezzel a mechanizmussal

hidalták át az ősi CISC-utasításhalmaz és a modern RISC-adatút közötti szakadékot.



66.

A dekódolt mikroműveletek bekerülnek a nyomkövető gyorsítótárba, amely az 1. szintű

utasítás-gyorsítótár. Azáltal, hogy a dekódolt mikroműveleteket gyorsítótárazza, és nem a

feldolgozatlan utasításokat, egy nyomkövető gyorsítótárbeli utasítás végrehajtásakor nincs szükség

másodszori dekódolásra. Ez a megközelítés az egyik kulcsfontosságú különbség a NetBurst

mikroarchitektúra és a P6 között (az utóbbi csak a Pentium 4 utasításokat tároIta az 1. szintű utasítás-

gyorsítótárban). Az elágazásjövendölésre is itt kerül sor.

Az utasítások a nyomkövető gyorsítótárból a program által előírt sorrendben kerülnek az

ütemezőbe, de onnan nem feltétlenül a program szerinti sorrendben kerülnek tovább. Ha egy nem

végrehajtható mikroművelet következik, az ütemező tárolja, de folytatja az utasításfolyam

feldolgozását, és a rákövetkező utasítások közül is kioszt olyanokat, melyek mindegyikének

erőforrásai (regiszterek, működési egységek stb.) elérhetők. A regiszterátnevezés is itt történik, hogy

késedelem nélkül továbbengedjük a WAR és WAW függőséggel rendelkező utasításokat.

Habár az utasításokat sorrenden kívül is ki lehet osztani, a Pentium 4 architektúrának pontos

megszakításokra vonatkozó követelménye azt jelenti, hogy az ISA utasításoknak sorrendben kellbefejeződni (azaz elérhetővé tenni az eredményüket). Ezt a feladatot a befejező egység kezeli. Az

ábra jobb felső negyedében találhatók a végrehajtó egységek, amelyek az egész, a lebegő pontos, és

a speciális műveleteket hajtják végre. Több végrehajtó egység is létezik, és ezek párhuzamosan

futnak. Adataikat a regiszterekből és az Ll adat gyorsítótárból kapják.

Az UltraSPARC III Cu CPU- jának mikroarchitektúrája:

Az UltraSPARC-sorozat a SPARC architektúra 9. változatának Sun megvalósítása. A felhasználó

vagy a programozó szemszögéből (azaz ISA-szinten) a különböző modellek eléggé hasonlók, főleg

teljesítményben és árban különböznek. A mikroarchitektúra szintjén azonban jelentősek akülönbségek. A megnevezésben lévő Cu, a lapka vezetékeinél használt rézre utal, ellentétben az

alumíniumvezetékezéssel, amit elődjénél használtak. A réznek kisebb az ellenállása, mint az

alumíniumnak, ami vékonyabb vezetékeket és gyorsabb működést tesz lehetővé.

Az UltraSPARC III Cu egy teljesen 64 bites gép, 64 bites regiszterekkel és 64 bites adatúttal,

bár a 8. változatú (vagyis 32 bites) SPARC-okkal való visszafelé kompatibilitás miatt 32 bites

operandusokat is tud kezelni, és valóban változtatás nélkül futtat 32 bites SPARC -szoftvert. Bár a

belső architektúra 64 bites, a memóriasín 128 bit széles, a Pentium 4 -hez hasonlóan, amelynek 32

bites architektúrája és 64 bites memóriasínje van, de mindkét esetben a sín egy generációval

későbbi, mint maga a CPU.

A Pentium 4-gyel ellentétben az UltraSPARC egy valódi RISC-architektúra, ami azt jelenti,

hogy nincs szüksége arra a bonyolult mechanizmusra, ami a végrehajtáshoz átalakítja a régi CISC-

utasításokat mikroműveletekre. A gépi utasítások maguk a mikroműveletek. Azonban az utóbbi

években grafikai és multimédia-utasításokkal egészítették ki a processzort, melyek végrehajtása

speciális hardverberendezéseket igényel.



67.

Az UltraSPARC III Cu mikroarchitektúrájának áttekintése:

Egészében véve, sokkal egyszerűbb, mint a Pentium 4 NetBurst mikroarchitektúrája, mert az

UltraSPARC-nak egyszerűbb ISA-architektúrát kell megvalósítania. Mindemellett néhány lényeges

komponens hasonlít a Pentium 4-nél használtakhoz. Ezeket a hasonlóságokat többnyire a

technológia, illetve a gazdaságosság vezérelte. Például, amikor ezeket a lapkákat tervezték,ésszerűnek számított a 8-16 KB méretű L1 adatgyorsítótár, ezért lettek ekkorák. Ha valamikor a

jövőben technológiai és gazdasági szempontból egy 64 MB-os L1 gyorsítótár számít majd ésszerűnek,

akkor minden CPU-ban az lesz. Ezzel ellentétben a különbségek többnyire a régi CISC utasításhalmaz

és a modern RISC-mag közötti különbségek áthidalásából, illetve ennek hiányából adódnak.

A 32 KB-os 4 utas halmazkezelésű utasítás-gyorsítótár 32 bájtos gyorsítósort hasznáL Mivel a

legtöbb UltraSPARC-utasítás 4 bájtos, így körülbelül 8K utasításnak van itt hely, ami valamivel kisebb,

mint a NetBurst nyomkövető gyorsítótára.

Az utasításkiosztó egység négy utasítást is elő tud készíteni óraciklusonként.

Ha gyorsítótárhiány lép fel az L1 gyorsítótárban, kevesebb utasítást fog kiosztani. Ha egy

feltételes elágazó utasításba ütközik, utánanéz a 16K bejegyzést tartalmazó ugrótáblában, hogy az a

következő utasítást jövendöli, vagy a célcímen szereplőt. Ezen felül, az utasítás -gyorsítótárban lévő

szavakhoz kapcsolt extrabit is segíti az elágazás jövendölést. Az előkészített utasítások átkerülnek egy

16 elemű utasítás pufferbe, amely kisimítja az utasítások csővezetékekbe áramlását.

Az utasítás puffer kimenete bekerül az egész, a lebegőpontos és a betöltő/tároló egységekbe.

Az egész aritmetikájú végrehajtó egység tartalmaz két ALU-t és egy rövid csővezetéket is az elágazó

utasításokhoz. Az ISA-regiszterek és néhány firkáló regiszter is itt található. A lebegőpontos egység 32

regisztert és három külön ALU-t tartalmaz rendre az összeadás/kivonás, a szorzás és az osztás

számára. A grafikai utasítások is itt kerülnek végrehajtásra. A betöltő/tároló egység kezeli a

különböző betöltő és tároló utasításokat.

Adatúttal rendelkezik három különböző gyorsítótárhoz is. Az adatgyorsítótár egy

hagyományos 64 KB-os 4 utas halmazkezelésű L1 adatgyorsítótár, mely 32 bájtos gyorsítósort

használ. A 2 KB-os előre betöltő gyorsítótár azért van jelen, mert az UltraSPARC ISA tartalmaz előre

betöltő utasításokat, melyek lehetővé teszik a fordító számára, hogy adatszavakat töltsenek be,

mielőtt még szükség lenne rájuk. Ha a fordító úgy gondolja, szüksége lehet egy bizonyos szóra, előre

betöltő utasítást adhat ki, aminek eredményeképpen a megcímzett gyorsítósor idő előtt bekerül az

előre betöltő gyorsítótárba, felgyorsítva ezzel a szó elérését, amikor néhány utasítás múlva szükség

lesz rá. Bizonyos körülmények között hardveres előre betöltés is történik, hogy fokozódjon az olyan

örökölt programok teljesítménye, amelyek nem végeznek előre betöltést. A tárolási gyorsítótár egy

kisméretű (2 KB) gyorsítótár, melyet arra használunk, hogy összekapcsoljuk az eredmények írását, és

jobban kihasználjuk az L2 gyorsítótárba menő 256 bit széles sínt. Egyedüli feladata a teljesítmény

növelése.



68.

A lapka tartalmaz memóriavezérlő logikát is. Ez a logika három részre oszlik: a

rendszerinterfészre, az L2 gyorsítótár-vezérlőre és a memóriavezérlőre.

A rendszerinterfész 128 bit széles sínen keresztül kapcsolódik a memóriához. A külvilághoz

érkező összes kérés, az L2 gyorsítótárat kivéve, ezen a felületen halad keresztül. A 43 bites fizikai

memóriacímmel elméletben a főmemória egészen 8 TB-ig terjedhet, de az a nyomtatott áramkör,amire a processzort szerelték, 16 GB-ra korlátozza a memóriát. Az interfészt úgy tervezték, hogy több

UltraSPARC-ot is lehessen ugyanahhoz a memóriához kapcsolni, hogy ezek multiprocesszort alkos-

sanak.

Az L2 gyorsítótár-vezérlő tartja a kapcsolatot az egyesített L2 gyorsítótárral, mely a CPU

lapkáján kívül helyezkedik el. Azáltal, hogy az L2 gyorsítótár kívül van, 1, 4 és 8 MB is lehet a mérete.

A gyorsítósor mérete függ a gyorsítótár méretétől, ami az 1 MB-os gyorsítótárra vonatkozó 64 bájttól

a 8 MB-os gyorsítótárra vonatkozó 512 bájtig terjedhet. Összehasonlításul, a Pentium 4 L2

gyorsítótára a lapkán található, viszont helyhiány miatt 1 MB-ra korlátozódik. Két ellentétes nézet: az

UltraSPARC jóval magasabb találati arányt érhet el az L2 gyorsítótárban, mint a Pentium 4 (mertnagyobb lehet a mérete), viszont az L2 gyorsítótár hozzáférése lassabb (mert nincs rajta a lapkán).

A memóriavezérlő képezi le a 64 bites virtuális címeket 43 bites fizikai címek re. Az

UltraSPARC támogatja a virtuális memóriát, ahol a lapok mérete 8 KB, 64 KB, 512 KB vagy 4 MB lehet.

A leképezés gyorsítására speciális táblázatok, ún. TLB-k (Translation Lookaside Buffer, lapkezelő

segédpuffer) állnak rendelkezésre, hogy össze lehessen hasonlítani az éppen hivatkozott virtuális

címet a nemrégiben hivatkozottakkal. Három ilyen táblázat áll rendelkezésre az adatokhoz, hogy

kényelmesen lehessen kezelni a különböző lapméreteket, és kettő az utasítások leképezéséhez.

A 8051 CPU mikroarchitektúrája:

Ez jóval egyszerűbb a Pentiumnál és az UltraSPARC-nál. Az egyszerűség oka, hogy a lapka

nagyon kicsi (60000 tranzisztor), és még a csővezetékek elterjedése előtt tervezték. Továbbá az, hogy

az elsődleges tervezési szempont az volt, hogy a lapka olcsó legyen, és nem az, hogy gyors. Az

olcsóság és egyszerűség egymás jó barátai, míg az olcsóság és gyorsaság nem azok.

A 8051-es lelke a fősín. Számos regiszter kapcsolódik hozzá, melyek többségét a programok

képesek írni és olvasni. Az ACC regiszter az akkumulátor (ACCumulator), a fő aritmetikai regiszter,

melyben a legtöbb számítás eredménye keletkezik. A legtöbb aritmetikai utasítás ezt használja. A B

szorzás és osztás esetén kap szerepet, valamint ideiglenes eredmények tárolására is használható. Az

SP regiszter a veremmutató, és mint a legtöbb gépben a verem tetejére mutat. Az IR regiszter az

utasításregiszter. Az éppen végrehajtás alatt álló utasítást tartalmazza.

A TMPl és TMP2 regiszterek az ALU tárolói. Egy ALU-művelet végrehajtásakor az operandusok

először ezekbe a tárolókba kerülnek, az ALU csak ezután kezd működni. Az ALU kimenete bármelyik

írható regiszterbe bekerülhet a fősínen keresztül. A PSW (Program Status Word, programállapotszó)

-regiszterbe kerülnek a feltételkódok, melyek jelzik, ha az eredmény nulla, negatív stb.



69.

A 8051-es külön memóriával rendelkezik az adatok és a kód számára. Az adat RAM 128

(8051) vagy 256 bájtos (8052), így a 8 bites RAM ADDR regiszter elegendően széles a címzésre. A

RAM címzéséhez a kívánt bájt címét a RAM ADDR regiszterbe kell tenni, és elindítani a

memóriaműveletet. A kódmemória 64 KB lehet (ha lapkán kívüli memóriát használunk), így a

címzéséhez használt ROM ADDR 16 bit széles. Ugyanúgy a ROM ADDR regiszter a programkódot címzi

a ROM-ban.

A DPTR (Double PoinTeR, dupla szélességű mutató) 16 bites regiszter a 16 bites címek

kezelésére és összeállítására. A PC regiszter a 16 bites utasításszámláló, ami a következőnek

betöltendő és végrehajtandó utasítás címét tartalmazza. A PC NÖVELŐ regiszter egy speciális

hardver, amely pszeudoregiszterként működik. Ha belemásolják a PC-t, majd kiolvassák, az érték

automatikusan növekszik. Sem a PC, sem a PC NÖVELŐ nem érhető el a fősínről. Végül, a PUFFER egy

újabb 16 bites regiszter. Mindegyik 16 bites regiszter tulajdonképpen két 8 bites regiszterből áll,

melyeket függetlenül is lehet kezelni, de a hatásuk 16 bites regiszterként érvényesül.

A 8051 rendelkezik még a lapkán elhelyezett három 16 bites időzítővel, melyeknélkülözhetetlenek valós idejű alkalmazások esetén. Van még négy 8 bites B/K portja, melyek

lehetővé teszik a 8051 számára, hogy akár 32 külső gombot, lámpát, érzékelőt, indítókart stb.

vezérelhessen. Éppen az időzítők és a B/K portok teszik lehetővé, hogy a 8051 kiegészítő lapkák

nélkül is használható legyen beágyazott alkalmazások esetén.

A 8051 szinkronprocesszor, melynek legtöbb utasítása egy óraciklust igényel, bár némelyik

többet. Minden óraciklust fel lehet osztani hat részre, melyeket állapotoknak nevezünk:

1. Betöltődik a következő utasítás a ROM-ból, rákerül a fősínre és az IR regiszterbe.

2. Dekódolódik az utasítás és növekszik a PC. 3. Az operandusok előkészítése történik.

4. Az egyik operandus rákerül a fősínre, általában azért, hogy TMP1-en keresztül az ALU

felhasználhassa. Az ACC regisztert is ebben az állapotban lehet átmásolni TMP2-be, így

az ALU mind a két bemenete készen áll.

5. Az ALU végrehajtja a műveletet.

6. Végül az ALU kimenete visszakerül a fősínen keresztül a rendeltetési helyére. Eközben a

ROM ADDR regiszter előkészül a következő utasítás betöltésére.

A 8051 egyetlen fősínnel rendelkezik (a lapka területének csökkentése miatt), regisztereinek

halmaza heterogén, valamint három időzítő és négy port kapcsolódik a fősínre, továbbá van mégnéhány extra regisztere a lokális sínen. Minden adatút-ciklusban két operandus fut keresztül az

ALU-n, és az eredmény visszakerül egy regiszterbe, ahogy az a korszerűbb számítógépeken is

történik.



70.

29. A Pentium 4, az UltraSPARC III és az I-8051

mikroarchitektúrájának összehasonlítása

A három példánk nagyon különböző, de mégis van bennük némi közös. A Pentium 4-nek van

egy régi CISC-utasításhalmaza, amelyet az Intel mérnökei legszívesebben bedobnának a SanFranciscó-i öbölbe, ha ezzel nem szegnék meg Kalifornia vízszennyezési törvényeit. Az UltraSPARC III

tiszta RISC-elképzelés, szegényes és egyszerű utasításhalmazzal. A 8051 egyszerű 8 bites processzor a

beágyazott alkalmazások számára. Mégis mindegyik lelke a regiszterkészlet, és az egy vagy több ALU,

amely elvégzi az egyszerű aritmetikai és logikai műveleteket a regisztereken.

Ezen nyilvánvaló külső különbségek ellenére a Pentium 4-nek és az UltraSPARC III-nak nagyon

hasonlók a végrehajtó egységei. Mindkét végrehajtó egység olyan mikroműveleteket fogad el,

amelyek egy műveleti kódot, két forrásregisztert és egy célregisztert tartalmaznak. Mindkettő végre

tud hajtani egy mikroműveletet egy ciklus alatt. Mindkettőnek nagy tudású csővezetékei, elágazásjö-

vendölése, valamint osztott I- és D-gyorsítótára van.

Ez a belső hasonlóság nem véletlen, és nem a Szilikon-völgy mérnökeinek végtelen

munkaszeretetének köszönhető. Mint azt a Mic-3 és Mic-4 példákban láttuk, könnyű és természetes

olyan csővezetékes adatutat építeni, amelyik vesz két forrásregisztert, átfuttatja az ALU-n, és az

eredményt egy regiszterbe tárolja. A jelenlegi technológiával ez a leghatékonyabb kivitelezés.

A fő különbség a Pentium 4 és az UltraSPARC III között az, ahogy ISA -utasításaikat a

végrehajtó egységhez juttatják. A Pentium 4-nek szét kell bontania a CISC-utasításait, hogy - a

végrehajtó egység elvárásainak megfelelően - háromregiszteres formátumúvá alakítsa őket. Nagy

utasítások szétszedése csinos, formás mikroműveletekre. Az UltraSPARC III-nak nem kell semmittennie, mert eredeti utasításai már csinos, formás mikroműveletek. Ezért van az, hogy a legtöbb új

ISA RISC típusú - így könnyebb a megfeleltetés az ISA utasításhalmaz és a belső végrehajtó motor

között.

Tanulságos, ha végső tervezésünket, a Mic-4-et összehasonlítjuk ezzel a két valóságos

példával. A Mic-4-hez leginkább a Pentium 4 hasonlít. Mindkettőnek az a feladata, hogy egy nem

RISC ISA-utasításhalmazt értelmezzen. Ezt mindkettő úgy csinálja, hogy az ISA-utasításokat egy

műveleti kóddal szétbontja mikroműveletekre, két forrásregiszterrel és egy célregiszterrel. Mindkét

esetben a mikroműveleteket lerakjuk egy sorba, későbbi végrehajtásra. A Mic-4 elgondolás szigorú

sorrend szerinti kiosztást, sorrend szerinti végrehajtást és sorrend szerinti befejezést követel, míg aPentium 4-nek sorrend szerinti kiosztás, sorrendtől eltérő végrehajtás és sorrend szerinti befejezés a

vezérelve.

A Mic-4 és az UltraSPARC III valójában egyáltalán nem hasonlíthatók össze, mert az

UltraSPARC III-nak RISC-utasításai vannak (vagyis háromregiszteres mikroműveletek), mint a saját

ISA-utasításhalmaza. Ezeket nem kell szétbontani. Végrehajthatók úgy, ahogy vannak, mindegyik

egyetlen adatút ciklussal. A Pentium 4-gyel és az UltraSPARC III-mal szemben a 8051 igazán egyszerű

gép. Inkább RISC, mint CISC típusú, hiszen legtöbb utasítása egyszerű és szétbontás nélkül

végrehajtható egy óraciklusban. Nincs csővezetéke és gyorsítótára, van viszont sorrend szerinti

kiosztása, sorrend szerinti végrehajtása és sorrend szerinti befejezése. Egyszerűségében főleg a Mic-l-gyel rokon.



71.

30. Gépi utasítási szint. Memória modellek, memória szemantika. APentium 4, az UltraSPARC III és az I-8051 regiszterei

Gépi utasítási szint (ISA szint)

Alapvetöen az ISA szint azt jelenti, ami a gépi szintű programozó számára látszik a gépből

(mondjuk azt, hogy ami a fordítóprogramok kimete). ISA szintű kód készítése céljából a

fordítóprogram írójának ismernie kell a memóriamodellt, hogy milyen regiszterek vannak, hogy

milyen adatokat és utasításokat használhat, és í gy tovább. Mindezen információk összegződése

alkotja az ISA szintet.

E definíció szerint minden olyan kérdés, ami arra vonatkozik, hogy a mikroarchitektúra

mikroprogramozott-e, csővezetékes-e, szuperskaláris-e, és így tovább, nem része az ISA szintnek,

mert a fordítóprogram készítője számára nem látható. A szuperskaláris végrehajtás részletei láthatók

az ISA szinten, í gy a szintek elválasztása nem is olyan egyszerű, mint elsőre látszik.

Néhány architektúra ISA szintjét formális dokumentum definiálja, amelyet gyakran ipari

konzorciumok készitenek. Mások esetén ilyen dokumentum nem létezik. Pl. mind a V9 SPARC (SPARC

9-es verzió), mind a JVM rendelkezik hivatalos dokumentációval (Weaver és Germond, 1994;

valamint Lindholm és Yellin, 1997). Az a célja az ilyen definiáló dokumentumnak, hogy lehetővé

tegye, hogy különböző megvalósítók olyan gépeket építsenek, amelyek ugyanazon szoftvert futtatják

ugyanolyan eredményt produkálva.

Az ISA szint egy másik fontos tulajdonsága, hogy a legtöbb gép legalább két módban

működhet. A kernel mód az operációs rendszer futtatására szánt mód, amikor is minden utatsítás

végrehajtható. A felhasználói mód a felhasználói programok futtatását célozza és nem teszi lehetővé

bizonyos érzékeny utasítások végrehajtását (mint amelyek közvetlenül manipulálják a gyorsítótárat).

Memória modellek

Minden számítógép memóriája cellákra van osztva, és a cellák címei összefüggő tartományt

képeznek. A leggyakoribb cellaméret napjainkban 8 bit, de régebben alkalmaztak 1-60 bites

cellaméretet is (lásd 2.10 ábrát). Egy 8 bites cella neve bájt. A 8 bites cellaméret oka az, hogy az ASCII

kód karakter 7 bit, így a paritásbittel együtt éppen belefér egy bájtba.

A bájtok általában 4 bájtos vagy 8 bájtos (64 bit) csoportokba, szavakba vannak rendezve,lehetövé téve, hogy az utasítások teljes szavakon végezzenek műveletek. Sok architektúra

megköveteli, hogy a szavak természetes határokhoz legyenek igazítva, pl. a 4 bájtos szavak címe

0,4,8,…stb kell legyen.

Az igazítást gyakran azért követelik meg, mert a memória így hatékonyabban működhet. A

Pentium 4 például, amely 8 bájtot olvas ki a memóriából, 36 bites fizikai címet használ, de csak 33 bit

címe van.

A legtöbb gép egyetlen lineáris címtartományt alkalmaz, ami 0-tól valami maximumig terjed,

ami gyakran 232 vagy 264 bájt. Azonban néhény gép külön címtartománnyal rendelkezik az adatok, és

külön az utasítások számára. Így a 8 címről történő utasítás kiolvasása más címtartományra



72.

vonatkozik, mint a 8 címről történő adat kiolvasása. Ez a séma bonyolultabb, mint amikor csak

egyetlen címtartomány van, azonban két előnye is van. Először, lehetséges 232 méretü program és

232 adatok csak 32 bites címzést használva. Másodszor, mivel minden írás automatikusan az adat -

címtartományra vonatkozik, nem lehet a programot ily módon felülírni, ami egy programozási

hibaforrás kiküszöbölését jelenti.

Memória szemantika

Még egy aspektusa van az ISA szintű memória-modellnek – ez a memória szemantika.

Természetes elvárás, hogy egy LOAD utasítás, amely ugyanazon címre vonatkozó STORE utasítás lett

végrehajtva, éppen eltárolt adatot eredményez. Azonban, a mikroutasítások sorrend je

átrendeződhet. Tehát valós a veszély, hogy a memória nem az elvárt módon viselkedik. A probléma

még rosszabbá válhat multiprocesszor esetén, amikor a különböző CPU-k (esetleg átrendezett)

olvasási szorzatot bocsátanak ki osztott memőriára vonatkozóan.

Egy szélsőséges megoldás, ha minden memóriahivatkozást szekvencializálnak, így mindegyikelőbb befejeződik, mint egy másik elkezdődne.

Másik szélsőséges megoldás esetében semmi garancia nincs általánosan biztosítva. A

memórihivatkozások sorrendjének kikényszerítésére SYNC utasítást kell a programnak végrehajtania,

amely blokkolja minden memóriaművelet kibocsátását mindaddig, amíg az összes eddig kiadott

memóriaművelet be nem fejeződött.

Közbülső megoldás is lehetne a memóriamodellre, amikor is a hardver automatikusan blokkol

bizonyos memóriahivatkozásokat (többek között a RAW és WAR szükséget tartalmazókat), de nem

mindet.

A Pentium 4 regiszterei

A Pentium 4 regisztereit az 5.3. ábra mutatja. Az első négy, EAX, EBX, ECX és EDX többé-

kevésbé általános célú regiszterek, bár mindegyiknek van sajátossága. Az EAX a fő aritmatikai

regiszter, az EBX jól használható mutató (memóriacím) tárolására, az ECX-nek a ciklusszervezésben

van szerepe. Az EDX a szorzás és osztás utasításoknál kell, amikor is az EXC-vel együtt tartalmazzák a

64 szorzatot, illetve osztandót. A felsorolt regiszterek mindegyikének első 16 bitje egy 16 bites, első 8

bitje pedig egy 8 bites regisztert alkot. Ezek lehetővé teszik 8 és 16 bites adatok, műveletek egyszerű

elvégzését. A 8088 és 80286 csak 8, illetve 16 bites regisztert tartalmazott. A 32 bites regisztereket a

80386-tal vezették be, az E betüvel jelölve azokat, ami Extendedet jelent.

A következő három szintén valamelyest általános célú regiszter, de több különlegességgel. Az

ESI-t és EDI-t memóriába mutató mutatók tárolására szánták, különösen a hardveres karakterlánc

műveletek esetén, amikor is az ESI a forrás (Source) karakterláncra, az EDI pedig a cél (Destination)

karakterláncra mutat. Az EBP helyett is mutató-regiszter, tipikusan az aktuális veremkeret címét

tartalmazza, mint az IJVM esetén az LV regiszter. Ha egy regiszter (mint az EBP) tartalma a lokális

veremkeretet tartalmazza, akkor azt mondjuk, hogy keretmutató. Végül az ESP a veremmutató.



73.

A regiszterek köv. csoportja a CS és a GS nagymértékben elektronikus őskövületek, amelyeket

a 8088 esetén a 220 méretű memória 16 bittel történő címzésére használtak. A következő az EIP, ami

a programszámláló (Extended Istruction Pointer / kiterjesztett utasításmutató). Végül az EFLAGS

regiszter látható, ami a PSW.

Az UltraSPARC III regiszterei

A UltraSPARC III regiszterek két csoportját tartalmazza: 32 darab 64 bites álatános célú

regiszter és 31 darab lebegőpontos regiszter. Az általános célú regiszterek jelei: R0,….,R31, bár

bizonyos környezetben más elnevezések is elöfordulnak.

A globális változók olyan konstansok, változók és mutatók, amelyeket minden eljárás használ,

bár szükség esetén elmenthetők és visszatöltheőök eljárásba való belépéskor, illetve kilépéskor. Az Ix

és az Ox regisztereket paraméterek átadására használják, hogy elkerüljék a memóriahivatkozást.

Három dedikált regisztert speciális célra használnak. Az FP és az SP regiszterek az aktuális

keret határait tartalmazzák. Az FP regiszter az aktuális keret kezdőcímét tartalmazza és a lokális

vátozók címzésére szolgál. Az SP az aktuális verem tetejére mutat és a verembe (push), illetve

veremből (pop) műveletek hatására változik. Ezzel ellentétben az FP csak eljáráshíváskor és

visszatéréskor változik A harmadik speciális célra használt regiszter az R31, ami az aktuális eljárás

visszatérési címét tartalmazza.

Az UltraSPARC ténylegesen 32-nél több általános regisztert tartalmaz, de csak 32 látszik a

programozó számára egy adott pillanatban. Ezt a tulajdonságot regiszterablaknak nevezik.

Regiszterablak technika: Andrew S. Tanenbaum: Számítógép architektúrák 363-365. o.

Az UltraSPARC III 32 lebegőpontos regiszterrel rendelkezik, amelyek mindegyike vagy 32

bites, vagy 64 bites számot tartalmazhat. Lehetséges két regiszterben tárolni egy 128 bites számot is.

Az UltraSPARC architektúrája töltés/tárolás architektúra. Ez azt jelenti, hogy csak a

regiszterek és a memória közötti adatátvitelt megvalósító betöltő LOAD és tároló STORE utasítá sok

hivatkoznak közvetlenül memóriára. Az összes többi utasítás operandusa mindig valamelyik

regiszterben van (nem memóriában), vagy az utasításban van és az eredmény is mindig regiszterbe

kerül.

Az I-8051 regiszterei

A 8051-es regiszterkezelése szokatlan. A legtöbb 8051-es program úgy készül, hogy nyolc

darab 8 bites regisztert használ. Ez a természetes használata a CPU-nak, mert a legtöbb utasítás egy 3

bites mezőn határozza meg a használt regisztert. A regiszterekre R0,…,R7 nevekkel hivatkozunk.

Mindamellett négy regiszterkészlete van, de egyszerre csak az egyik használható. A PSW 2 bites

mezője mondja meg, éppen melyik készlet az aktuális. A több regiszterkészlet célja az, hogy lehetővé

tegye a nagyon gyors megszakításfeldolgozást. Ha megszakítás keletkezik, a feldolgozó programnak

nem kell elmentenie az összes reigisztert, hanem csak átvált egy másik készletre. A 8051 -esnek ez a

tulajdonsága lehetővé teszi, hogy másodpercenként nagyon nagy számú megszakítást tudjon

feldolgozni, ami nagyon fontos tulajdonsága minden olyan processzornak, amelyet beágyazott valós

idejű rendszerben akarnak használni.



74.

Egy másik sajátossága a 8051 regisztereinek, hogy a memóriában vannak. A memória 0. bájtja

a 0. regiszterkészlet R0 regisztere, hasonlóan az 1. bájt az R1 regiszter és így tovább.

A 8051 a négy általános regiszterkészleten kívül tartalmaz néhány speciális célú regisztert is.

A PSW-ben balról jobbra haladva van az átvitelbit, kiegészítő átvitelbit, a használt regiszterkészletre

utaló bitek, a túlcsordulásbit és a paritásbit. A használt regiszterkészletre utaló bitek kivételévelminden bitet az arimetikai utasítások állítanak be.

Az IE regiszter a megszakítások egyedi és kollektív engedélyezését és tiltását kezeli. Ha az EA

bit 0, akkor minden megszakítás tiltott. Ezen bit törlése lehetővé teszi minden további megszakítás

tiltását egyetlen utasítással. Az EA bit 1-re állítása engedélyez minden olyan megszakítást, amelynek

egyedi bitje 1. Az E2, E3 és E0 bitek engedélyezik vagy tiltják a három időzítő csatornát. Legfeljebb

három csatornához tartozó számláló futhat egyszerre, és ezek mindegyike megszakítást válthat ki, ha

letelt az ideje. Az ES bit engedi vagy tiltja a soros vonali megszakítást. A további két bit a külső

eszközök megszakítását engedi vagy tiltja.

Az IP regiszter határozza meg a megszakítások prioritási szintjét. Két szint van: alacsony és

magas. Ha alacsony prioritási szintű megszakítás kiszolgálása közben magas prioritású keletkezik,

akkor az alacsony feldolgozása felfüggeszthető, de fordítva nem.

A TCON regiszter vezérli a 0. és az 1. időzítőt, ezek a fő időzítők. Az O1 és O0 biteket hardver

állítja be, ha a hozzá tartozó időzítő túlcsordul. Az R1 és R0 bitek a futásvezérlő bitek, amelyek

lehetővé teszik, hogy a program szoftveresen ki- vagy bekapcsolja az időzítőt. A többi bit a két időzítő

él- vagy szintvezérlésével kapcsolatos.

Az utolsó regiszter, a TMOD az időzítők üzemmódját határozza meg (8, 13 vagy 16 bites),

hogy valódi időzítő avagy számláló, továbbá a fokozatot, hogy mely hardverjelek vezérlhetik az

időzítőt.

Az összes eddig említett speciális regiszter és még néhány, mint az akkumulátor, a B/K

portok, mind a 128-255 memóriatartományban vannak. Ezek ugyanúgy címezhetők, mint bármely

memóriacella, ahogy az R0-R7 regiszterek is. Például az akkumulátor, amely szerepel szinte minden

aritmetikai utasításban, a 240-es címen található. A 8052 esetén, amely valódi memóriát tartalmaz a

128-255 tartományban, a speciális regiszterek átlapolják a memóriateret. Direkt címzés esetén a

8052-es a speciális regisztereket címzi, míg indirekt hivatkozáskor (regiszterben lévő mutatóval) a

RAM-on.



75.

31. A Pentium 4, az UltraSPARC III, az I-8051 utasítás formátumai,címzési módjai.

A Pentium 4 utasításformátumai

A Pentium 4 utasításformátumai nagyon bonyolultak és szabálytalanok, hatféle változó

hosszúságú mezővel, amelyek közül öt opcionális. Ez a helyzet azért alakult ki, mert az architektúra

több generáción keresztül fejlődött, és a korai fázisban nem éppen jó döntéseket hoztak. Továbbá, a

visszafelé kompatibilitás kényszere miatt később nem lehetett változtatni. Általánosan érvényes,

hogy ha egy kétoperandusú utasítás egyik operandusa a memóriában van, akkor a másik nem lehet a

memóriában (csak regiszterben). Tehát léteznek utasítások, amelyek regiszter-regiszter, regiszter-

memória, memória-regiszter operandusokon dolgoznak, de nincs olyan utasítás, amelynek mindkét

operandusa a memóriában lenne.

A korai Intel-architektúrákban minden utasítás műveleti kódja 1 bájtos volt, bár utasításokmódosítására intenzíven használták az úgynevezett prefix bájt módszert. Ez azt jelenti, hogy van egy

extra bájt az utasítás elején, ami módosítja a jelentését. A prefix bájtra példa a WIDE utasítás az IJVM

esetén. Szerencsétlen módon a fejlődés során egyszer csak az Intel kifogyott a műveleti kódokból, és

bevezette a 0xFF kiter jesztő kódot (escape code), hogy lehetővé tegyen egy második műveletikód-

bájtot.

A Pentium 4 egyedi bitjei nem sok információt adnak magáról az utasításról. Az egyetlen

szerkezet a műveleti kód mezőjében bizonyos utasításoknál, hogy a szélső bit jelzi, hogy bájt vagy szó

az operandus, egy másik bit pedig azt, hogy a memóriába vagy regiszterbe kerül a művelet

eredménye. Tehát a műveleti kódot teljesen dekódolni kell annak meghatározásához, hogy milyenosztályba tartozik a végrehajtandó utasítás, vagy hogy mekkora a hossza. Ez megnehezíti a nagy

hatékonyságú megvalósítást, mivel még ahhoz is intenzív dekódolást kell végrehajtani, hogy

meghatározzák a következő utasítás címét.

Sok memóriára hivatkozó utasításban a műveleti kód bájtot a következő bájt adja meg

ténylegesen az utasítást. Ez a 8 bit egy 2 bites MOD és két 3 bites REG és R/M mezőkre oszlik. Néha

az első 3 bit a műveleti kódhoz tartozik, így összesen 11 bites a kód. Azonban a 2 bites mód mező

csak négyféle operanduscímzési módot határozhat meg, és az egyik operandusnak regiszternek kell

lennie. Logikusan az EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP regiszterek mindegyike megadható lenne,

de a módszer miatt néhány kombináció tiltott, és speciális esetekre használják. Néhány mód továbbibájtokat igényel, ezek az SIB (Scale, Index, Base - skála, index, bázis). Ez a séma nem ideális, de

kompromisszumot képez a visszafelé kompatibilitás kényszere és az új lehetőségek bevezethetősége

között. Mindezekhez vegyük még hozzá, hogy néhány utasítás 1, 2 vagy 4 további bájtot tartalmaz

memóriacím (eltolás) megadására, és további 1, 2 vagy 4 bájtot a konstans számára.

Az UltraSPARC III utasításformátumai

Az UltraSPARC III ISA minden utasítása pontosan 32 bit és szó határra igazított. Az utasítások

általában egyszerűek, és csak egy akciót határoznak meg. A tipikus aritmetikai utasítás két regisztert

specifikál a bemenő operandusok és egyet az eredmény számára. Van olyan változat, amikor az egyik



76.

regiszter helyett egy 13 bites előjeles konstanst lehet megadni. A LOAD utasítás összeadja két

regiszter (vagy egy regiszter és egy 13 bites konstans) tartalmát, így képezve a betöltendő cella címét.

Az eredeti SPARC nagyon korlátozott utasításformákat tartalmazott. Később új formák

keletkeztek. E könyv írásának idején 31 a számuk, és ez növekszik. (Mikor áll elő vajon egy cég, hogy a

világ legösszetettebb RISC gépét reklámozza?) A legtöbb új változat úgy keletkezett, hogy bizonyosmezőkből néhány bitet elhagytak. Például az eredeti elágazó utasítás a 3. formát használta 22 bites

eltolással. Amikor a jövendölő elágazást bevezették, a 22 bitből 3-at levágtak, egyet a jövendölésre

használtak (lesz/nem lesz elágazás), kettőt pedig a feltételkód megadására alkalmaztak. Így maradt

19 bit az eltolásra. Egy másik példa erre a sok adattípus-konvertáló utasítás (például egészből

lebegőpontosba). Sok ezek közül az 1b formájú variánsa: az IMMEDIATE mezőt felbontották egy 5

bites részre (a forrásregiszter specifikálására) és egy 8 bites részre (további műveleti kódokra).

Minden utasítás első két bit je segít meghatározni az utasítás formáját, és megadja a

hardvernek, hol találja a műveleti kód maradék részét, ha van egyáltalán. Az 1a formában regiszter

mind a két forrás; az 1b-ben az egyik forrásregiszter, a másik egy -4096 és 4095 közötti konstans. A13. bit a két forma közül választ (a jobb szélső bit a 0.). Mindkét esetben regiszter acél. 64 utasítás

kódolásához elegendő hely van az 1a formában; ezek pillanatnyilag későbbi felhasználásra foglaltak.

32 bites utasítás esetén nem lehet 32 bites konstanst megadni az utasításban. A SETHI

utasítás 22 bitet ad meg, a maradék 10 bitet másik utasítás adja meg. Ez az egyetlen utasítás,

amelynek ez a formája.

A nem jövendölő ugró utasítások 3-as formájúak, ahol a FELT mező mondja meg, hogy melyik

feltételt kell ellenőrizni. Az A bit hivatott megakadályozni a késleltetési rés létrejöttét bizonyos

feltételek esetén. A jövendölő ugrások formája ugyanilyen, kivéve a 19 bites eltolást, amelyet máremlítettünk.

Az utolsó forma a CALL utasításé, amely eljáráshívást végez. Ez az utasítás speciális, mert ez

az egyetlen, amelyben 30 bit kell a cím megadására. Erre az ISA-ban csak 2 bites a műveleti kód. A

célcím a megadott cím négyszerese, ami azt eredményezi, hogy az adott utasítás helyétől

(közelítőleg) ± 231 bájt tartományt lehet címezni.

A 8051 utasításformátumai:

A 8051-es processzornak hatféle egyszerű utasításformája van. Az utasítások hossza 1, 2 vagy

3 bájt. Az első forma csak egyetlen műveleti kódot tartalmaz. Például az akkumulátor tartalmátnövelő utasítás használja ezt a formátumot. A 2. formátum hossza szintén egy bájt, amely 5 bites

műveleti kódot és 3 bites regisztercímet tartalmaz. Ilyen formátumú sok utasítás, amely az

akkumulátor és egy regiszter tartalmán végez valamilyen műveletet (például regiszter és akkumulátor

tartalmának összeadása, adatmozgatás regiszter és akkumulátor között). A 3. formátumnak egy 1

bájtos operandusa van. Az operandus lehet közvetlen konstans, például amit akkumulátorba tölt,

lehet eltolás, például az ugrás távolsága, vagy lehet bitsorszám, például az n. bitet beállító, törlő vagy

ellenőrző utasításban. A 4. és 5. formátum ugró és szubrutinhívó utasítások formája. A 11 bites válto-

zat akkor használható, ha nincs külső memória, tehát minden programcím 4096 alatti (8051) vagy

8192 alatti (8052). 8 KB-nál nagyobb külső memória esetén a 16 bites forma szükséges. A 6.



77.

formátumú utasításoknak két 8 bites operandusa van. Sokféle utasítás ilyen formátumú, például egy

8 bites közvetlen operandusnak a lapkán lévő memóriacellába töltése.

A Pentium 4 címzési módjai:

A Pentium 4 címzési módjai nagyon szabálytalanok, és attól is függnek, hogy 16 vagy 32 bitesaz utasítás. A továbbiakban eltekintünk a 16 bites módtól, a 32 bites is eléggé rossz. A támogatott

módok: közvetlen, direkt, regiszter-, regiszter-indirekt, indexelt címzés és még egy speciális mód

tömb elemek címzésére. Az a gond, hogy nem minden mód alkalmazható minden utasításban, és

nem minden regiszter használható minden módban. Ez nagyon megnehezíti a fordítóprogram -készí -

tők dolgát, és gyenge kódot eredményez.

Az 5.14. ábrán a MODE bájt vezérli a címzési módot. Az egyik operandust a MOD és az R/M

mezők határozzák meg. A másik operandus mindig regiszter, hogy melyik, azt a REG mező

tartalmazza. Az 5.27. ábra felsorolja azt a 32 kombinációt, amelyet a 2 bites MOD és 3 bites R/M

mező szolgáltat. Például, ha mindkét mező 0, akkor az operandust a memóriából olvassa, amelynekcíme az EAX regiszterben van.

A 01 és 10 oszlopok tartalmazzák azokat a módokat, amelyekben 8, illetve 32 bites eltolást

lehet megadni a (gépi) utasítás végén. Ha 8 bitest választunk, akkor a hozzáadás előtt előjelesen

kiterjeszti 32 bitesre. Például az ADD utasítás az R/M=011, MOD=01 és 6 eltolás esetén kiszámít ja az

EBX és 6 összegét, és az így kapott címről veszi az egyik operandust. Az EBX nem módosul.

A MOD=11 oszlopnál két regiszter közül választhatunk. Szavas utasítások az első változatot, a

bájtos utasítások pedig a második változatot használják. Megjegyzendő, hogy a táblázat nem teljesen

szabályos. Például nem lehet az EBP indirekt és az ESP relatív címzés.

Megéri ez a mód a fáradságot? Nehéz válaszolni a kérdésre. Kétségtelen, hogy ha jól

használják, akkor ezzel a móddal több ciklus megtakarítható. Használatának gyakorisága függ a

fordítóprogramtól és az alkalmazástól. Az a gond, hogy ennek a módnak a megvalósítása a lapka egy

részét elviszi, amelyet másra is lehetne használni, ha nincs ez az utasítás. Például az 1. szintű

gyorsítótár nagyobb lehetne, vagy a lapka mérete kisebb, ami nagyobb órajelsebességet engedne.

Ezek azok a kompromisszumok, amelyekkel a tervezők állandóan szembesülnek. Általában

intenzív tesztelést végeznek mielőtt szilikonba öntenék a tervet. Azonban nagyon jól megalapozott

elképzeléssel kell rendelkezni a szimulációhoz, figyelembe véve a várható terhelést. A 8088 tervező i

biztosan nem teszteltek webböngészővel. Mindazonáltal, nem sok számítógép elődjét használtákwebböngészésre, így a 20 évvel ezelőtti döntések teljesen hamisak lehetnek a mai alkalmazások

szempontjából. Azonban a visszafelé kompatibilitás kényszere miatt nehéz kidobni azt, ami egyszer

már bekerült.

Az UltraSPARC III címzési módjai:

Az UltraSPARC ISA minden utasítása közvetlen vagy regisztercímzést használ, kivéve azokat,

amelyek memóriára hivatkoznak. Regisztermódban 5 biten van adva a regiszter. A közvetlen módban

13 bites (előjeles) adat lehet a konstans. Nincs más módú aritmetikai, logikai vagy hasonló utasítás.

Háromféle utasítás hivatkozik memóriára: a betöltő (LOAD), a tároló (STORE) és egy multiprocesszor-szinkronizáló utasítás. A LOAD és STORE utasítások kétféle módban dolgozhatnak. Az egyik módban



78.

két regiszter tartalmának összege adja a címet. A másik a hagyományos indexelés 13 bites eltolási

értékkel.

A 8051 címzési módjai:

A 8051 címzési mód ja nagyon szabályos. Öt alapvető címzési módja van. A legegyszerűbb azimplicit mód, amely az akkumulátort használja. Sok utasítás végez műveletet egy operandus és az

akkumulátor tartamán, ilyen az összeadás, kivonás, ÉS, VAGY. Az akkumulátort használó

utasításokban nincs speciális bit, amely azt jelezné, hogy az akkumulátort kell használni. Ezt a

műveleti kód magába foglalja. A másik a regisztermód, amikor az egyik operandus regiszter. Regiszter

lehet akár forrás, akár cél. A harmadik mód a direkt címzés, amikor az operandus a memóriában van,

amelynek címe az utasítás része. A negyedik mód a regiszter-indirekt címzés, amikor az operandus

címe regiszterben van. Mivel minden normál regiszter 8 bites, ezért az operandusnak a memória alsó

256 címén kell lennie. Az ötödik mód a közvetlen mód, amikor az operandus magában az utasításban

van megadva.

A 8051 speciális címzési módot tartalmaz néhány olyan utasításban, amely memóriaelérést

végez. Emlékeztetünk, hogy a 8051-nek lehet 64 KB külső program és 64 KB külső adatmemóriája is.

Ezért szükség van valamilyen címzési módra, amely lehetővé teszi ezek elérését. A külső memória

elérését két utasítás biztosítja, a LJMP, amely 16 bites eltolási értéket tartalmaz, így lehetővé tesz

bármely memóriacímre ugrást, és az LCALL, amely szintén 16 bites eltolást tartalmaz, így bármely

memóriacímen lévő eljárást tud hívni.

A külső adatmemória elérése más módszerrel történik. A 8051 rendelkezik egy 16 bites

mutató regiszterrel, ez a DPTR, amely 16 bites memóriacímet tartalmazhat. Ezt a programok

betölthetik, aztán a betöltött érték indirekt címzésre használható, így elérhető a teljes 64 KB-ostartományt.



79.

32. Veremcímzés. Fordított lengyel (postfix) jelölés. Dijkstra

algoritmusa. Postfix alakú formulák kiértékelése

Veremcímzés

Már korábban megjegyeztük, mennyire kívánatos, hogy a gépi utasítás annyira rövid legyen,

amennyire csak lehet. A végsőkig redukálva a cím hosszát, eljutunk a 0 címes utasításhoz. Mint már

láttuk, 0 címes utasítás lehetséges a veremmel kapcsolatban, például ilyen az IADD. Ebben a

szakaszban alaposabban megvizsgáljuk a veremcímzést.

Fordított lengyel jelölés

A matematikában régi hagyomány, hogy a művelet jelét az operandusok közé írják, mint

x + y, nem pedig azok után, mint x y . Ha a műveleti jel az operandusok között van infix jelölésről

beszélünk. Ha a műveleti jel az operandusok után áll, akkor postfix vagy fordított lengyel jelölés az

elnevezés, a lengyel logikatudós J. Lukasiewicz után, aki kimutatta ennek a jelölésnek a jó

tulajdonságait.

A fordított lengyel jelölésnek számos előnye van az infix jelöléssel szemben algebrai

kifejezések esetén. Először is, minden formula kifejezhető zárójel nélkül. Másodszor, kényelmesen

kiértékelhetők a formulák számítógéppel verem használatával. Harmadszor, az infix operátorokra

elsőbbségi szabály vonatkozik, amely tetszőleges és nem kívánatos. Például tudjuk, hogy az a * b + c

jelentése (a b) + c és nem a (b c), mivel a szorzás nagyobb prioritású, mint az összeadás. Vajon

nagyobb prioritású-e a balra léptetés, mint a logikai AND? Ki tudja. A fordított lengyel jelölés

kiküszöböli ezt a kellemetlenséget.

Számos algoritmus ismert infix formulák fordított lengyel jelölésre konvertálására. Az itt

következő algoritmus E.W Dijkstra ötletén alapszik. Tegyük fel, hogy a formula a következő jeleket

tartalmazhatja: változók, bináris (kétoperandusú) operátorok: - /, továbbá bal és jobb zárójelek. A

formula végeinek jelzésére a formula elé és után a jelet tesszük. Példa rajzzal együtt a könyv 386.

oldalán.

A változók sorrendje az infix és prefix jelölésben megegyezik. A műveleti jelek sorrendje

azonban nem mindig azonos. A fordított lengyel jelölésben a műveleti jelek olyan sorrendben

szerepelnek, amilyen sorrendben azok végrehajtódnak a kifejezés kiértékelésekor.

Infix Fordított lengyel jelölés

A + B * C ABC * +

A * B + C AB * C +

A * B + C * D AB * CD * +

(A +B)/(C - D) AB + CD - /

((A + B ) * C + D) / (E + F + G) AB + C * D + EF + G + /



80.

Fordított lengyel jelölésű formulák kiértékelése

A fordított lengyel jelölés ideális formulák számítógépes kiértékelésére verem használatával.

A formula n jelből áll, mindegyik vagy operandus, vagy műveleti jel. A fordított lengyel jelölésű

formulának veremmel való kiértékelése egyszerű algoritmus. Olvassuk a formulát balról jobbra. Ha az

operandushoz érünk, akkor rakjuk a verembe. Ha az aktuális jel műveleti jel, akkor hajtsuk végre amegfelelő műveletet.

Az ábra a

(8 + 2 * 5) / (1 + 3 * 2 - 4)

formula kiértékelését mutatja JVM-ben. Az ennek megfelelő fordított lengyel jelölés a

következő:

8 2 5 * + 1 3 2 * + 4 - /

Az ábrán bevezettük az IMUL és IDIV utasításokat, amelyek a szorzás illetve az osztás

műveletet végzik. A verem tetején lévő operandus a jobb és nem a bal operandus. Ez fontos

az osztás (és kivonás) esetén, mivel az operandusok sorrendje lényeges (nem úgy, mint az

összeadásnál és szorzásnál). Más szóval az IDIV utasítást körültekintően definiálták, először

az osztandót kell a verembe tenni, majd az osztót, és ez után kell elvégezni a műveletet,

hogy helyes eredményt kapjunk. Vegyük észre, hogy milyen egyszerű kódot generálni az

(I)JVM-re fordított lengyel jelölésből: csak olvassuk balról jobbra a formulát, és jelenként

kiadunk egy utasítást. Ha a jel konstans vagy változó, akkor olyan utasítást kell kiadni, amely

azt a verembe teszi. Ha a jel műveleti jel, akkor a műveletet megvalósító utasítást kell kiadni.

Lépés A maradék formula Utasítás Verem

1 8 2 5 * + 1 3 2 * + 4 - / BIPUSH 8 8

2 2 5 * + 1 3 2 * + 4 - / BIPUSH 2 8, 2

3 5 * + 1 3 2 * + 4 - / BIPUSH 5 8, 2, 5

4 * + 1 3 2 * + 4 - / IMUL 8, 10

5 + 1 3 2 * + 4 - / IADD 18

6 1 3 2 * + 4 - / BIPUSH 1 18, 1

7 3 2 * + 4 - / BIPUSH 3 18, 1, 3

8 2 * + 4 - / BIPUSH 2 18, 1, 3, 29 * + 4 - / IMUL 18, 1, 6

10 + 4 - / IADD 18, 7

11 4 - / BIPUSH 4 18, 7, 4

12 - / ISUB 18, 3

13 / IDIV 6



81.

33. Vezérlési folyamat. Szekvenciális vezérlés, elágazás, ciklusszervezés, eljárás, rekurzív eljárás, korutinok, megszakítás,csapda

A vezérlési folyamat

A vezérlési folyamat azt a sorrendet jelenti, amelyben az utasítások végrehajtódnak

dinamikusan, tehát a program végrehajtása során. Általában elágazás és eljáráshívás nélkül, egymást

követő memóriahelyekről kiolvasott utasítások a kiolvasás sorrendjében hajtódnak végre.

Eljáráshívás hatására a végrehajtási sorrend megváltozik, az éppen végrehajtás alatt lévő eljárás

felfüggesztődik, és a hívott eljárás végrehajtása elkezdődik. A korutinok hasonlóak az eljárásokhoz,

ezek is hasonlóan térítik el a végrehajtási sorrendet. A korutinok hasznosak a párhuzamos eljárások

szimulálásánál. A csapdák és a megszakítások speciális feltételek bekövetkezésekor térítik el a

végrehajtási sorrendet.

Szekvenciális vezérlés és elágazás

Miután egy utasítás végrehajtódott, a memóriában őt követő utasítás olvasódik és hajtódik

végre. Minden utasítás után a programszámláló értéke megnövelődik a végrehajtott utasítás

hosszával. A programszámláló értéke hozzávetőleg az idő függvényében lineárisan növekszik, az

átlagos utasításhossz / átlagos utasítási idő mértékével.

Ha a program tartalmaz elágazást, akkor ez az egyszerű kapcsolat az utasítások memóriabeli

sorrendje és a végrehajtásuk sorrendje között nem áll fenn. Ha van elágazás, akkor a

programszámláló értéke nem lineáris függvénye többé az időnek.

Eljárások

A programok strukturálásának legfontosabb technikáját az eljárások adják. Bizonyos

szempontból az eljáráshívás ugyanúgy eltéríti a végrehajtási sorrendet, mint az ugrás, csak amikor

befejezte a feladatát az eljárás, a vezérlés visszatér a hívást követő utasításra.

Más szempontból azonban az eljárás törzse úgy tekinthető, mint egy magasabb szinten

definiált utasítás. Ebből a szempontból az eljáráshívás egyetlen utasításnak tekinthető, még akkor is,

ha az eljárás meglehetősen bonyolult.

Különösen érdekes az eljárások egy speciális fajtája, a rekurzív eljárás, amely önmagát hívja

vagy közvetlenül, vagy más eljárásokon keresztül.

Eljárás-prológusnak nevezzük azt a tevékenységet, amely a régi veremkeret-mutató

elmentését, az új veremkeret-mutató megadását és a veremmutatónak a lokális változók befogadása

miatti növelését tartalmazza. Az eljárásból való visszatéréskor a vermet ki kell takarítani, ezt

nevezzük eljárás-epilógusnak. Minden számítógépnek egyik legfontosabb jellemzője, hogy a

prológust és az epilógust milyen gyorsan és röviden tudja elvégezni. Ha ez hosszú és lassú, akkor az

eljáráshívások költségesek. A Pentium 4 ENTER és LEAVE utasításait azért tervezték, hogy a prológus

illetve az epilógus nagy részét hatékonyan elvégezzék.



82.

Korutinok

Néha hasznos, ha két eljárás, A és B egymást eljárásként hívja, oly módon, hogy ha B visszatér

A-hoz, akkor a végrehajtás a B-t hívó utasítás után folytatódik. Ha a vezérlés A-tól B-hez kerül, akkor a

végrehajtás (kivéve az első alkalmat) a legutolsó B-ből való visszatérést követő, vagyis az utolsó A-t

hívó utasítással folytatódik. Az olyan két eljárást, amelyek ilyen módon működnek, korutinnaknevezzük.

Korutinokat általánosan alkalmaznak párhuzamos feldolgozás szimulálására olyan gépeken,

amelyekben csak egy CPU van. Mindegyik korutin peszeudo-párhuzamosan fut a másikkal, mintha

saját processzora lenne. Ez a programozási stílus megkönnyíti bizonoys alkalmazások megvalósítását,

továbbá hasznos olyan szoftver tesztelésénél, amelyet később többprocesszoros gépen futtatnak.

Sem a hagyományos eljáráshívó CALL, sem a visszatérő RETURN nem alkalmazható

korutinoknál. Mivel az ugrás helyének a címe veremből jön, mint a visszatérés esetén, de a korutin

maga is eltárolja a címet a későbbi visszatérés végett.

Csapdák

A csapda olyan automatikusan hívott eljárás, amelyet valamely, a program által előidézett

feltétel vált ki, amely fontos, de ritkán fordul elő. Jó példa erre a túlcsordulás. Sok számítógépen, ha

az aritmetikai művelet eredménye olyan nagy lenne, amit nem lehet a gépen ábrázolni, akkor csapda

keletkezik, ami azt jelenti, hogy a vezérlés egy meghatározott memóriacímre adódik, nem folytatódik

normálisan. Azt az eljárást, amelyre ilyenkor a vezérlés adódik, csapdakezelőnek hívják, amely

valamely megfelelő tevékenységet végez, például hibaüzenetet ír ki. Ha az aritmetikai művelet

eredménye az ábrázolási tartományban marad, akkor csapda nem keletkezik.

Alapvető jellemzője a csapdának, hogy a program maga okoz valamilyen kivételes helyzetet,

amit a hardver, vagy a mikroprogram fedez fel. A túlcsordulás lekezelésének egy alternatív módja az,

amikor a túlcsordulás egy 1 bites regisztert állít 1-re. A programozó, ha kezelni akarja a túlcsordulást,

minden aritmetikai utasítás után le kell kérdeznie ezt a bitet. Ez azonban lassú és tárpazarló

megoldás. A csapda időt és memóriát takarít meg a programvezérelt megoldáshoz képest.

A csapda megvalósítható a mikroprogram (hardver) által végzett tényleges ellenőrzéssel. Ha a

csapda bekövetkezett, akkor a csapdakezelő rutin címe töltődik a programszámlálóba. Ami csapda

egy adott szinten, az programvezérelt lehet alacsonyabb szinten. Ha mikorprogrammal végeztetjük az

ellenőrzést, még mindig időt takarítunk meg a program által végzett teszthez képest, mert könnyenátlapolható más tevékenységgel. Memóriát is megtakarítunk, mert csak egy helyen, a mikroprogram

fő ciklusában kell elhelyezni.

Néhány kivételes helyzet, amely csapdával lekezelhető: lebegőpontos túlcsordulás,

lebegőpontos alulcsordulás, egész túlcsordulás, védelem megsértése, definiálatlan műveleti kód,

veremtúlcsordulás, nem létező B/K eszköz indítása, szóolvasási kísérlet páratlan memóriacímről, 0-val

való osztási kísérlet.



83.

Megszakítások

A megszakítás olyan eltérítése a vezérlési folyamatnak, amelyet nem a program okoz, hanem

valami más, általában B/K: például, a program utasíthatja a lemezegységet, hogy kezdje el az

adatátvitelt és annak befejeztekor megszakítást küldjön. Ugyanúgy, mint a csapda, a megszakítás

bekövetkeztekor is megáll a program végrehajtása és a vezérlés a megszakításkezelőre adódik, amelyelvégzi a kívánt tevékenységet. Ha ez befejeződött, a megszakításkezelő visszaadja a vezérlést a

megszakított programnak. A megszakított processzusnak pontosan azt az állapotát kell helyreállítani,

mint ami akkor volt, amikor a megszakítás történt.

Alapvető különbség a csapdák és a megszakítások között a következő: a csapdák a

programmal szinkronban vannak, a megszakítások pedig aszinkronban. Ha egy programot milliószor

megismétlünk ugyanazzal a bemenettel, a csapda mindig pontosan ugyanott keletkezik, de a

megszakítás nem, függhet például attól, hogy a gépkezelő mikor nyomja le a return gombot. A

csapdák reprodukálhatóságának az az oka, hogy közvetlenül a program okozza, míg a

megszakításokat nem, azokat csak közvetetten okozza a program.

A megszakításokkal kapcsolatos kulcsfogalom az átlátszóság. Amikor megszakítás következik

be, bizonyos műveletek végrehajtódnak, bizonyos kód végrehajtódik, de amikor ennek vége a

számítógép ugyanabba az állapotba kerül, mint amelybe a megszakítás előtt volt. Az ilyen módon

működő megszakítási rutint átlátszónak nevezzük. Az átlátszóság miatt sokkal egyszerűbb megérteni

a megszakításokat.

A 8088 óta az Intel CPU-nak két megszakítási szintje van (elsőbbségi értéke): maszkolható és

nem maszkolható. A nem maszkolható megszakítások általában csak a katasztrófa közeli állapotokra

használatosak, mint memóriaparitás-hiba. Minden B/K eszköz maszkolható szinten dolgozik.



84.

34. Operációs rendszer szintje. Virtuális memória. Lapméret,elaprózódás. Szegmentálás. A Pentium 4 és az UltraSPARC III

virtuális memóriája.

Virtuális memória

Az első számítógépek idejében a memória kevés és drága volt. A probléma hagyományos

megoldása másodlagos memória, például lemez igénybevétele. A programozó olyan átfedéseknek

(overlays) nevezett kisebb részekre osztotta fel programját, amelyek külön-külön már elfértek a

memóriában. A program futásakor először az első rész töltődött be és futott egy darabig. Amikor

befejezte működését, beolvasta és elindította a következő részt és így tovább. A programozónak

kellett gondoskodni a program átfedésekre darabolásáról, az egyes részek elhelyezéséről a

másodlagos memóriában, a memória és a lemez közti mozgatásukról, és általában az átfedéses

rendszer kezeléséről. A gép ehhez semmi segítséget nem adott.

Az átfedések automatikus kezelésére, melynél a programozónak nem is kell tudnia az egész

rendszerről (Fotheringham, 1961): ez a módszer, amely ma virtuális memória (virtual memory) néven

ismeretes.

Lapozás

A címtartomány és a memóriarekeszek fogalmának szétválasztása. A címtartomány és a

memóriacímek elkülönítésének az elve a következő. Bármely időpillanatban közvetlenül 4096 szó

érhető el a memóriából, de ezek nem feltétlenül a 0 és 4095 közti memóriacímeknek felelnek meg.

„Megmondjuk” a gépnek, hogy mostantól kezdve például a 4096 címre való hivatkozás esetén a

memória 0 című szavát kell használni. Ha a 4097 címre hivatkozunk, ez jelentse az 1 memóriacímet, a

8191 a memória 4095 címén található szót, stb. Ha a címtartományt a tényleges memóriarekeszekbe

az ábrán megadott séma szerint képezzük le mondhatjuk, hogy egy 4KB-os, virtuális memória nélküli

gép esetén fix leképezésünk van a 0-s 4095 közti címek, valamint a memória 4096 szava között. Ezek

után feltehetjük azt az érdekes kérdést, hogy mi történik akkor, ha a program végrehajtása során

8192 és 12287 közti címekre ágazik el. Virtuális memória nélküli gépen az futási hibát okozna,

melynek hatására „Nem létező memóriacímre hivatkozás” vagy hasonló durva hibaüzenet után

befejeződne a program végrehajtása. Virtuális memóriával rendelkező gépen a következő lépések

hajtódnak végre:

1. a memória tartalmának lemezre mentése

2. a 8192 és 12287 közti szavak megkeresése a lemezen

3. a 8192 és 12287 közti szavak betöltése a memóriába

4. a végrehajtás folytatása, mintha mi sem történt volna.

Az átfedések automatikus kezelésének ezen technikáját lapozásnak (paping), a lemezről

beolvasott programrészeket lapoknak (pages) nevezzük. A címtartományhoz tatozó címeknek a

valódi memóriacímekre való leképezését kifinomultabban is kezelhetjük. A nyomaték kedvéért azon

címeket, amelyekre a program tud hivatkozni, virtuális címtartománynak (virtual addres space), míg a

tényleges „hardveres” címeket fizikai címtartománynak (physical addres space) fogjuk nevezni. Amemóriatérkép (memory map) vagy laptábla (page map) a virtuális címeket kapcsolja össze a fizikai



85.

címekkel. Feltesszük, hogy a lemezen van elég hely a teljes címtartomány (vagy legalábbis a

használatban lévő része) számára. A programok úgy írhatók meg, mintha a teljes címtartomány

számára elegendő memória lenne a gépben, még ha a valóságban nem is ez a helyzet. A program

betölthet tetszőleges virtuális címről, írhat oda, a végrehajtás elágazhat a virtuális címtartomány

tetszőleges helyén található utasításra, tekintet nélkül arra, hogy nincs is elegendő fizikai memória.

Valójában a programozónak nem is kell tudnia a virtuális memória létezéséről. Egyszerűen úgy látja,

mintha a gépen rengeteg memória lenne.

A lapozási mechanizmust transzparensnek hívjuk, hiszem a programozó úgy írhat kódot,

mintha nem is lenne lapozás.

A lapozás megvalósítása

A virtuális memória egyik alapkövetelménye az egész program és az összes adat tárolására

szolgáló lemezegység.

A virtuális címtartományt azonos méretű lapokra szokás felosztani. A ma szokásos

lapméretek 512 bájt és 64 KB közé esnek, bár alkalmanként használnak akár 4 MB-os lapokat is. A

lapméret mindig 2 valamelyik hatványa. A fizikai címtartományt hasonlóan osztják fel. A darabok

mérete a lapmérettel megegyező, így mindegyikük pontosan egy lap tárolására alkalmas. Ezeket a

memóriadarabokat, melyekbe lapokat töltünk be, lapkeretnek (page frames) fogjuk nevezni.

Minden virtuális memóriával ellátott számítógép tartalmaz a virtuálisról fizikai címre való

leképezést megvalósító eszközt. Ennek neve MMU (Memory Management Unit, memóriakezelő

egység). Elhelyezkedhet magán a CPU lapkán vagy külön lapkán, amely szorosan együttműködik a

CPU-val. Az általunk példaként felhozott MMU a 32 bites virtuális címeket 15 bites fizikai címekre

képezi le; ehhez 32 bites bemeneti és 15 bites kimeneti regiszterre van szüksége.

A kérésre lapozás és a munkahalmaz modell

Az olyan hivatkozás, amely nem a memóriában lévő lapon található címre vonatkozik,

laphibát (page fault) okoz. Laphiba felléptekor az operációs rendszernek be kell olvasnia lemezről a

kért lapot, be kell írnia új fizikai helyét a laptáblába, és meg kell ismételnie a hibát okozó utasítást.

A virtuális memória használatának ezt a módszerét kérésre lapozásnak (demand paging)

nevezzük, annak a jól ismert gyereketetési algoritmusnak analógiájára, melynél ha sír a baba

megetetjük, szemben a precíz napirend szerinti etetéssel. A kérésre lapozásnál a lapok nemtöltődnek be előre, hanem csak akkor ha ténylegesen kérik őket.

Ha a gépben időosztást használunk, tehát processzusok mondjuk 100 ms futás után

cserélődnek, futása során minden program rengetegszer lesz újraindítva. Mivel minden programhoz

egyedi memóriatérkép tartozik, s programváltáskor ez is változik, időosztásos rendszerekben

kritikussá válhat a helyzet. Az alternatív megközelítés azon a megfigyelésen alapul, hogy a legtöbb

program nem egyenletesen hivatkozik a címtartományra, hanem néhány lap körül „sűrűsödnek

össze” a hivatkozások. Egy memóriahivatkozás utasítást tölthet be, adatokat olvashat, vagy tárolhat.

Bármely t időpillanatban tekinthetjük a legutóbbi k memóriahivatkozásban szereplő lapok halmazát.

Denning (1968) nyomán ezt munkahalmaz (woking set) néven fogjuk emlegetni. Mivel munkahalmazidőben lassan változik, a legutóbbi megállításkori halmaz alapján elfogadható becslések adhatók arra,



86.

hogy a program újraindításkor mely lapokra lesz szükség. Ezek a lapok már a program indítása előtt

betölthetők (feltéve, hogy beférnek a memóriába).

Lapkezelési eljárások

Ha a program olyan lapra hivatkozik, amely nincs a memóriában, a szükséges lapot be kelltölteni lemezről. Legtöbbször azonban először „helyet kell csinálni”, bizonyos lapokat vissza kell írni a

lemezre. Szükségünk van tehát ez eltávolítandó lapokat megadó algoritmusra. A legtöbb operációs

rendszer megpróbálja megjósolni, hogy melyek a memóriában levő „leghaszontalanabb” lapok abban

az értelemben, hogy eltávolításuk a legkisebb mértékben zavarná a futó programot. Ennek egyik

módja az lehet, hogy minden lapra megjósolja a várható legközelebbi hivatkozás időpontját, s azt a

lapot távolítja el, aminél ez a legtávolabbi jövőbeni időpont. Más szóval ahelyett, hogy egy

nemsokára szükséges lapot mentenénk ki, próbáljunk olyat választani, ami még sokáig nem fog

kelleni. Az egyik népszerű algoritmus a legrégebben nem használt lapot veszik mivel nagy a

valószínűsége, hogy ez nincs benne a munkahalmazban. A módszer neve LRU (Least Recently Used,

legrégebben használt) algoritmus. Általában jól használható, bár vannak olyan patologikus esetek,

amikor csúnya kudarcot vall.

Ha azonban a rendelkezésre álló memória nagyobb a munkahalmazénál, az LRU várhatóan

minimalizálni fogja a laphibák számát. A másik lapkezelő elv a FIFO (First-In First-Out, először be -

először ki). A FIFO módszer a legrégebben betöltött lapot távolítja el, függetlenül attól, mikor

hivatkoztak rá utoljára. Minden lapkerethez egy számláló tartozik, melyeket kezdetben 0-ra állítunk.

Az éppen a memóriában tartózkodó lapokhoz tartozó számlálók értékét minden laphiba után eggyel

növeljük, az újonnan betöltött lapét pedig nullával inicializáljuk. Ha lapot kell eltávolítani, azt

választjuk, amelynek számlálója a legnagyobb értéken áll. Mivel az ő számlálója a legnagyobb, ez a

lap „élte túl” a legtöbb laphibát. Ez azt jelenti, hogy korábban lett betöltve a memóriában levő összeslapnál, és így (remélhetőleg) komoly esélye van annak, hogy nem is lesz rá szükség a továbbiakban.

Azt a jelenséget, amikor egy program gyakran, szinte folyamatosan laphibákat generál,

vergődésnek (trashing) fogjuk nevezni. Talán fölösleges megemlítenünk, hogy nemkívánatos

jelenségről van szó.

Ha egy eltávolítandó lapon nem módosítottunk semmit a beolvasás óta (ami nagyon

valószínű, ha nem adatot hanem programkódot tartalmaz), szükségtelen visszaírni a lemezre, hiszen

ott már létezik egy pontos másolata. Ha a beolvasás óta módosítottuk, a lemezen lévő példány már

nem pontos, ezért ki kell írni a mostanit. Amennyiben meg tudjuk mondani valahogyan, hogy abeolvasás óta a lap változatlan maradt (tiszta, clean) vagy pedig írtunk rá (szennyezett, dirty),

elkerülhető a tiszta lapok újraírása. Ezzel egy csomó időt spórolunk meg. Sok gépen az MMU-ban

minden laphoz tartozik egy bit, amelyet betöltéskor 0-ra állít, és a hardver vagy a mikroprogram 1-re

módosít, ha a lap szennyezetté válik (ráírtunk valamit). Az operációs rendszer ennek a bitnek

vizsgálatával el tudja dönteni, hogy a lap tiszta vagy szennyezett, tehát vissza kell-e másolni a lemezre

lapcsere esetén.



87.

Lapméret és elaprózódás

Ha véletlenül úgy adódik, hogy a felhasználó programja és adatai valahány lapon pontosan

elférnek, a memóriába való betöltésükkor nem pocsékolunk el helyet. Ellenkező esetben az utolsó

lapon valamennyi hely kihasználatlan marad. Ha egy 4096 bájtos lapméretű gépen például a program

és az adatok összesen 26000 bájtot igényelnek, akkor megtellik az első 6 lap (6x4096= 24576 bájt), ésaz utolsó lapra marad még 26000-24576=1424 bájt. Mivel laponként 4096 bájt számára van hely,

elpocsékolunk 2672 bájtot. Ahányszor csak betöltjük a hetedik lapot a memóriába, ezek a bájtok

teljesen haszontalanul foglalnak le helyet. Az elvesztegetett bájtokkal kapcsolatos fönti problémára

belső elaprózódás (interal fragmentation) néven fogunk hivatkozni (a kihasználatlan hely valamelyik

lap belsejében található).

Szegmentálás

Sok esetben előnyösebb, ha egyetlen virtuális címtér helyett kettő vagy több

címtartományunk van. Az egyik nyilvánvaló megoldás: sok, teljesen független címtartomány, ún.szegmensek (segments) bevezetése. A szegmenscímek 0-tól valamely maximális értékig terjedő

lineáris sorozata. Az egyes szegmensek hossza 0-tól a megengedett maximumig bármekkora lehet. A

különböző szegmensek lehetnek eltérő hosszúságúak, rendszerint ez is a helyzet. A szegmensek

hossza még változhat is a végrehajtás során. Például valahányszor a verembe beleteszünk valamit, a

veremszegmens mérete nőhet, ha kiveszünk belőle, csökkenhet. Mivel minden szegmens külön

címtartományt alkot, a különböző szegmensek egymástól függetlenül nőhetnek vagy

zsugorodhatnak. Amikor az egyik szegmensben elhelyezkedő veremnek a növekedéséhez nagyobb

címtartományra van szüksége, nyugodtan megkaphatja, mert semmi más nincs a címtartományban,

amivel összeütközésbe kerülhetne. A szegmensek természetesen betelhetnek, de általában olyan

nagyok szoktak lenni, hogy ez csak ritkán fordulhat elő. Ilyen szegmentált vagy kétdimenziósmemória esetén a programok két részből álló címmel adják meg a tényleges címet. Az első rész a

szegmens száma, a második a szegmensen belüli cím. Hangsúlyozzuk, hogy a szegmens olyan logikai

egység, ami a programozó számára is látható, s amelyet ő is egyetlen logikai egységként kezel. A

változó méretű adatstruktúrák egyszerűbb kezelése mellett a szegmentált memóriának más előnyei

is vannak. Ha az egyes eljárások 0 kezdőcímtől más-más szegmensekben helyezkednek el, a külön

lefordított eljárások összelinkelése után az n. szegmensben lévő eljárás hívása a 0. szó (belépési pont)

megcímzésére az (n, 0) kétrészes címet fogja használni.

A szegmentálás megvalósítása

A szegmentálás kétféle módon valósítható meg: cseréléssel (swapping) vagy lapozással. Az

első módszernél minden időpillanatban szegmensek bizonyos halmaza van a memóriában. Ha olyan

szegmensre történik hivatkozás, amely pillanatnyilag nincs bent, akkor betöltődik. Ha nincs elég hely

számára, először egy vagy több szegmenst lemezre kell kiírni (kivéve, ha ezekből már van a lemezen

tiszta példány; ekkor a memóriában található másolat eldobható). A szegmensek cserélése bizonyos

értelemben hasonló a kérésre lapozáshoz: a szegmensek szükség szerint mozognak a lemez és a

memória között. A szegmentálás megvalósítása azonban lényegesen eltér a lapozásétól: míg a

lapméret rögzített, a szegmensek mértéke változó. Külső elaprózódás (external fragmentation), mivel

az elpocsékolt hely a szegmenseken kívül, a köztük lévő lyukakban van. A külső elaprózódást néha

lyukacsosodás (checker-boarding) néven is emlegetik.



88.

A külső elaprózódás elkerülésének egyik lehetséges módszere a következő. Valahányszor lyuk

keletkezik, a lyuk mögötti szegmenseket toljuk el a 0 memóriacím felé, úgy, hogy ezt a lyukat

megszüntessük. Ekkor persze a memória végén keletkezik egy nagyobb lyuk. Esetleg várhatunk is

addig, míg a külső elaprózódás egy komolyabb szintet nem ér el (például a teljes memória adott

százaléka fölé nem kerül a lyukak összege) és csak ekkor kezdjük el a memória „összepréselését”. Egy

népszerű algoritmus, a legjobb illesztés (best fit), azt a legkisebb lyukat választja, amibe még belefér

a kért szegmens. Emögött az az ötlet áll, hogy a lyukat és a szegmensek összepárosításánál lehetőleg

ne „törjünk le” darabokat olyan nagy lyukakból, amelyeket fel lehetne használni a későbbi nagy

szegmensekhez. A másik kedvelt eljárás, az első illesztés (fist fit) körbemegy a listán, és azt az első

lyukat választja, amely elég nagy a szegmens tárolására. Ehhez nyilvánvalóan kevesebb idő kell, mint

az egész lista átnézéséhez a legjobb illesztés megkeresésénél. Meglepő, hogy az általános

hatékonyság szempontjából is jobb az első illesztés algoritmusa a legjobb illesztésnél. Az utóbbi

hajlamos arra, hogy rengeteg kicsiny, teljesen haszontalan lyukat hozzon létre. Amikor olyan

szegmenseket távolítunk el a memóriából, amelynek mindkét közvetlen szomszédja lyuk volt, az

egymás utáni lyukak egy nagy lyukká olvadnak össze. A szegmentálás másik megvalósításánál aszegmenseket fix méretű lapokra osztjuk, és ezeket lapozzuk a kérések szerint. Lehetséges, hogy

valamelyik szegmens lapjainak egy része a memóriában, a többi meg a lemezen van, ha ezt a

megoldást választjuk. A lapozáskor minden szegmenshez külön laptábla kell. Mivel miden szegmens

csupán egy lineáris címtartomány, az összes eddig megismert lapozási technika alkalmazható a

szegmensekre. Az egyetlen új sajátosság az, hogy minden szegmens saját laptáblát kap.

A Pentium 4 virtuális memóriája

A Pentium 4-nek olyan kifinomult virtuálismemória-rendszere van, amely egyaránt támogatja

a kérésre lapozást, a tiszta szegmentálást és a lapozással kombinált szegmentálást. A Pentium 4

virtuális memóriájának legfontosabb része két tábla, az LDT (Local Descriptor Table, lokális

leírótábla) és a GDT (Global Descriptor Table, globális leírótábla). Minden programnak saját LDT-je

van, de a gépen futó összes program egyetlen megosztott GDT -t használ. Míg a GDT

rendszerszegmenseket ír le, ideértve magát az operációs rendszert is, addig az LDT a programra

nézve lokális szegmenseket ad meg (kód, adat, verem stb). Mihelyt megtudja a hardver, hogy melyik

szegmens-regisztert kell használni, belső regisztereiben rögtön megtalálja a szektorhoz tartozó teljes

leírót. Ha nemlétező szegmensről van szó (a szelektor 0) vagy a szegmens pillanatnyilag nincs a

memóriában (P értéke 0), csapda keletkezik.

Ezután azt vizsgálja, hogy az offset a szegmens határain belül van-e; ha nem, ez ismét csapdát

okoz. Ha a szegmens a memóriában van, és az offset is a megengedett határok közé esik, akkor a

Pentium 4 a leíró 32 bites BASE mezőjét az offsethez hozzáadva a 6.14. ábrál látható lineáris címet

(lineal address) alakítja ki. Ha a lapozás tiltott (a globális vezérlőregiszter egy bitjével), akkor a lineáris

cím fizikai címként értelmeződik, és egyből továbbítódik a memória felé. Így lapozás nélküli tiszta

szegmentálással állunk szemben. Ha viszont engedélyezett a lapozás, akkor a lineáris cím virtuális

címként értelmeződik, és laptáblák használatával képeződik le a fizikai címre. Minden futó

programhoz tartozik egy lapkönyvtár (page directory), amely 1024 darab 32 bites bejegyzést

tartalmaz, erre a lapkönyvtárra egy globális regiszter mutat. A könyvtár minden bejegyzése szintén

1024 darab 32 bites bejegyzést tartalmazó laptáblákra mutat. A laptáblák bejegyzései lapkeretekre

mutatnak.



89.

Az UltraSPARC III virtuális memóriája

Az UltraSPARC III 64 bites virtuális címeken alapuló lapszervezési virtuális memóriát

támogató 64 bites gép. Tervezési és költségszempontok miatt azonban a programok nem használják

a teljes 64 bites virtuális címtartományt. Csak 44 bit érhető el, emiatt a programok nem lehetnek

1,8x1013 bájtnál hosszabbak. A megengedett virtuális memória két darab, egyenként 243 bájt fizikaihosszúságú zónára van felosztva. Az egyik a virtuális címtartomány legalján, a másik a legtetején

helyezkedik el. A köztük levő résbe elő virtuális címek nem érhetők el, használatuk hibát okoz. A

rendkívül nagy virtuális címtartomány miatt a Pentium 4-hez hasonló direkt laptábla nem volna

praktikus. Az UtraSPARC MMU- ja ehelyett egészen más megközelítést használ. Tartalmaz egy TLB

(Translation Lookaside Buffer) nevű hardvertáblát, ez képezi le a virtuális lapokat fizikai lapkeretekre.

A TLB csak a legutóbb használt virtuális lapok sorszámát tárolja. A kód- és az adatlapokat külön

kezeli, mindkét kategóriából a legutóbbi 64 lapszámot őrzi meg. Minden TLB-bejegyzés egy virtuális

lapsorszámból és a neki megfelelő fizikai lapkeret sorszámából áll. Amikor az MMU egy

processzusszámot vagy másképp környezetet (context) és egy ebbe a környezetbe tartozó virtuális

címet kap, speciális áramkörök segítségével egyből összehasonlítja az adott környezethez tartozó

összes TLB-bejegyzéssel. Ha valahol egyezést talál, a megfelelő TLB-bejegyzésben szereplő lapkeret

sorszámot a virtuális címben szereplő offsettel összekombinálva képezi a 41 bites fizikai címet és

néhány egyéb jelzőbitet (védelem stb).

Ha nem talál egyezést, TLB-hiány (TLB miss) keletkezik, amit csapdáz az operációs rendszer. A

hiány kezelése az operációs rendszeren múlik. TLB-hiány még akkor is előfordulhat, ha a hivatkozott

lap a memóriában van. A kért virtuális lapra vonatkozó új TLB-bejegyzés beírasakor az operációs

rendszer elméletileg bárhogyan eljárhatna. A hardver azonban némi segítséget is ad ennek a kritikus

tevékenységek minél gyorsabban elvégzéséhez - már ha a szoftver hajlandó vele együttműködni.

Elsősorban elvárjuk, hogy az operációs rendszer készítsen a gyakran használt TLB-bejegyzésekről egy

szoftveres gyorsítótárat a TSB (Translation Storage Buffer) nevű táblázatban. Ez a táblázat virtuális

lapok direktleképezett gyorsítótáraként épül fel. TLB-hiány esetén az operációs rendszer

megvizsgálja, hogy megfelelő TSB-bejegyzés a szükséges lapot tartalmazza-e. Az MMU kellemes

szolgáltatása a bejegyzés címének automatikus kiszámítása és az operációs rendszer által elérhető

belső MMU-regiszterbe helyezése. TSB-találat esetén valamelyik TLB-bejegyzés törlődik, és helyére

bemásolódik a kért TSB-bejegyzés. A kitörlendő TLB-bejegyzés kiválasztását a hardver 1 bites LRU-

algoritmusa támogatja.

Ha a TSB-keresés sikertelen volt, a virtuális lap nincs a gyorsítótáblán, az operációs rendszer egy

másik táblázatban keresi a lapra vonatkozó információkat. A végső megoldásként használt tábla neve

fordítótábla (translation table).



90.

35. Terminál. Modemek, jelzési, adatátviteli sebesség.

Terminálok

A számítógépes terminálok két részből állnak: billentyűzet és monitor. A nagygépes világbanez a két rész gyakran egybe van építve, és soros vonalon vagy telefonhálózaton keresztül van a

központi géphez kapcsolva. A személyi számítógépek világában a billentyűzet és a monitor különálló

egység.

Háromfajta terminált használnak széles körben: a karaktertérképes terminálokat, bittérképes

terminálokat és RS-232-C terminálokat. Ezek mindegyike használhat bármilyen billentyűzetet, de

különbség van a számítógéppel való kommunikációban és a megjelenítés módjában.

Egy személyi számítógépben a képernyőn való megjelenítés kétféle lehet: karaktertérképes

és bittérképes.

Karaktertérképes terminálok

A karakterek úgy kerülnek megjelenítésre, hogy a CPU a videomemóriába másolja őket,

minden második bájtba egyet. Minden karakterhez tartozik egy attribútumbájt, ami meghatározza,

hogy az adott karaktert hogyan kell megjeleníteni. Attribútum lehet szín, fényesség, villogás stb. Így

egy 2580 karakterből álló képernyő 4000 bájtnyi videomemóriát igényel, 2000 bájtot a

karaktereknek és 2000 bájtot az attribútumoknak. A legtöbb kártyán több képernyőre elegendő

memória van.

A videokártyának az a feladata, hogy folyamatosan olvassa a videomemóriát és a monitormeghajtásához szükséges jeleket generáljon. Az előállított jel egy nagy frekvenciájú analóg jel, amely

karaktereket kirajzoló elektronsugár mozgását vezérli.

Bittérképes terminálok

A képernyőt nem 2580-as karaktertömböknek tekintjük, hanem olyan tömbnek, amely

képpontokból, úgynevezett pixelekből áll. Minden pixel ki- vagy bekapcsolt állapotban lehet. A

karaktertérkép helyett bittérképet használó terminálokat bittérképes termináloknak nevezzük.

Minden mai videokártya tud karaktertérképes és bittérképes módban is működni, a kettő között

szoftveres úton válthatunk.

A karaktereket úgy lehet megjeleníteni hogy mondjuk egy 914-es téglalapot tartunk fenn

minden karakter számára, és ezeket a megfelelő bitmintákkal feltöltjük. Ezzel a módszerrel különböző

típusba tartozó karakterek is megjeleníthetők egymással keverve. A hardver csak annyit csinál, hogy

megjeleníti a bittömböt. A színes képernyők esetén minden pixelnek 8, 16 vagy 24 bit van fenntartva.

A bittérképes terminálok gyakran ablakokat jelenítenek meg.

A bittérképes terminálok nagyon rugalmasak, de két nagy hátrányuk is van. Először is

nagyméretű videomemóriára van szükségük, a leggyakoribb felbontások manapság a 640480 (VGA),

800*600 (SVGA), 1024*768 (XVGA) és az 1280768-as képernyő. A szélesség és magasság arányamindegyiknél 4:3. a legjobb színeket úgy kaphatjuk, ha mindhárom elsődleges színhez 8 bitet



91.

használunk, vagyis 3 bájtot pixelenként. Tehát egy 1024768-as képernyő 2,3 MB videomemóriát

igényel.

A bittérképes terminálok másik hátránya a teljesítményük. A mozgás folyamatosságához

legalább 25 képkockát kell vetíteni másodpercenként, tehát a szükséges adatátvitel 57,6 MB/s

1024*768-as felbontás esetén. Ez a terhelés sokkal nagyobb, mint amire az (E)ISA sín képes, ezért azIBM PC-k nagy teljesítményű videokártyái szükségképpen PCI kártyák.

Egy kapcsolódó probléma a képernyő gördítése. Ez rendkívül terheli a CPU-t, ezért sok

videokártya speciális hardvert tartalmaz, amelynek segítségével bázisregiszterek átállításával,

másolás nélkül lehet képernyőrészeket mozgatni.

RS-232-C terminálok

Az RS-232-C szabványos számítógép-terminál interfész. A termináloknak egy szabványos 25

tűs csatlakozójuk van. Az RS-232-C szabvány meghatározza a csatlakozó méreteit és formáját, a

feszültség szinteket és az egyes vonalak jeleinek jelentését.

Ha a számítógép és a terminál messze van egymástól, akkor gyakran az egyetlen praktikus

összeköttetési lehetőség a telefonkapcsolat. Sajnos a telefonrendszer nem képes az RS-232-C

szabványnak megfelelő jelek továbbítására, ezért egy modemnek nevezett jelátalakító eszközt kell a

számítógép és a telefon, illetve a telefon és a terminál közé beiktatni.

Hogy kommunikálni tudjanak, a számítógép és a terminál is tartalmaz egy UART (univerzális

aszinkron vevő és továbbító) lapkát, valamint a sín eléréséhez szükséges áramköröket. Egy karakter

megjelenítéséhez a számítógép beolvassa azt a központi memóriából, átadja az UART-nak, ami aztán

bitenként küldi őket az RS-232-C kábelre. Az UART tulajdonképpen egy párhuzamos-soros átalakító,mert egy egész karaktert kap, majd meghatározott ütemben egyenként adja ki a biteket. Egy start- és

egy stopbitet is ad minden karakterhez, hogy a kezdetét és a végét fel lehessen használni.

A terminálban egy másik UART fogadja a biteket és összeállítja a karaktert, amit aztán

megjelenít a képernyőn. A terminál billentyűzetén bevitt adatok átesnek egy párhuzamos-soros

átalakításon a terminálban, és a számítógép UART- jában kerülnek újra összeállításra.

Az RS-232-C szabvány majdnem 25 jelet definiál. A 2. és a 3. vonal az adatok küldésére és

fogadására szolgál. Minden vonal egy egyirányú bitfolyamot kezel, ellentétes irányokban. Amikor a

terminál vagy a számítógép adatot akar küldeni, akkor a Request to send vonalon jelzi a szándékát.Ha a modem képes az adat fogadására, akkor a Clear to send vonalon jelez vissza. A többi vonal

különféle állapotlekérdező, tesztelő és időzítési feladatokat lát el.

Modemek

A sima telefonvonal nem alkalmas a számítógép jeleinek továbbítására, mivel utóbbiak

általában a 0-kat 0 volttal, az 1eseket 3-5,5 volt közötti feszültséggel reprezentálják. A kétszintű jelek

jelentős torzulást szenvednek a hangátvitelre tervezett vonalon, ami átviteli hibákat eredményez. Egy

1000 és 2000 Hz közötti, vivőhullámnak nevezett tiszta szinuszos hullámjel azonban aránylag kis

torzulással átvihető.



92.

Mivel a szinuszjel hullámzása tökéletesen kiszámítható, egy tiszta szinuszjel nem hordoz

semmilyen információt. Az amplitúdó, a frekvencia vagy a fázis változtatásával azonban átvihetjük 1-

esek és 0-k sorozatát. Ezt a folyamatot modulációnak nevezik.

Az amlplitúdómoduláció két feszültségszintet használ.

A frekvenciamoduláció esetén a feszültségszint állandó, de a vivőhullám frekvenciája eltérő

1-esek és 0-k esetén. Gyakran frekvenciaeltolásos kódolásnak is evezik.

Az egyszerű fázismodulációnál az amplitúdó és a frekvencia nem változik, de a vivőhullám

fázisa 180 fokkal eltolódik minden 0-1 vagy 1-0 váltásnál. A vivőhullám fázisa minden oszthatatlan

időintervallum kezdetén hirtelen eltolódhat 45, 135, 225 vagy 315 fokkal, ezzel az úgynevezett

kétbites fáziskódolással 2 bitet lehet intervallumonként átvinni. Az időintervallumok száma a baud.

Mivel a telefonvonal csak egy csatornát szolgáltat, a biteket sorosan, egymás után kell elküldeni. Az

az eszköz, amelyik kétszintű jelek formájában, bitenként karaktereket fogad el a számítógéptől és a

biteket egyesével vagy kettesével amplitúdó-, frekvencia- vagy fázismodulációt használva továbbítja:a modem.

A küldö modem az egy karakterhez tartozó biteket egyenlő időközönként küldi el. Például a

9600 baud 104 milliomod másodpercenkénti jelváltást jelent. A fogadó oldalon egy másik modem

konvertálja a modulált jelet bitsorozattá. Mivel a bitek szabályos időközönként érkeznek, ha a fogadó

meghatározta a karakter elejét, akkor már csak az órajelét kell figyelnie, hogy mikor vegyen mintát a

következő bitek meghatározásához. A mai modemek 28800 bit/másodperc és 57600 bit/másodperc

sebességgel működnek, általában ennél jóval alacsonyabb baud értékek mellett. Majdnem mindegyik

full-duplex (egyszerre mindkét irányba tud kommunikálni). A fél-duplex modem egyszerre csak egy

irányba tud kommunikálni. A szimlpex csak az egy irányba működő vonalak neve.



93.

36. ADSL, kábeles internet.

Azokat a szolgáltatásokat, amelyek a normál telefonvonalnál nagyobb sávszélességet

biztosítanak, időnként szélessávúnak nevezik, bár ez a meghatározás inkább piaci, mint speciális

technikai fogalom.

ADSL

Kezdetben több egymást átfedő ajánlat jelent meg, amelyek az xDSL általános terminológia

alá tartoznak. A továbbiakban ismertetjük, hogy valószínűleg mivé válik majd ezek közül a

legnépszerűbb, az ADSL. Mivel az ADSL jelenleg is fejlődik, ezért a szabvány nem minden eleme van

teljesen a helyén, az alábbiakban ismertetett néhány részlet idővel megváltozhat, az alapelképzelés

azonban érvényes marad.

A modemek lassúságának az az oka, hogy a telefont az emberi hang továbbítására találták ki,

és a teljes rendszert erre a feladatra optimalizálták. Az adattovábbítás mindig is mostohagyermek

volt. Az előfizetőktől a telefontársaság központjába futó vezetéket, amelyet lokális huroknak

neveznek, tradicionálisan egy 3000 Hz-es szűrővel korlátozzák a telefontársaságnál. Ez az a szűrő,

amely behatárolja az adattovábbítás sebességét. Szűrő nélkül a lokális huroknak a gyakorlatban

elérhető sávszélessége függ a vezeték hosszától, de általában néhány kilométer távolságon elérheti

az 1,1 MHz-et.

Az ADSL-kínálat legelterjedtebb megközelítését a 2.38 ábra mutatja be. Lényegében, azt

teszik, hogy eltávolítják a szűrőt, és az elérhető 1,1 MHz spektrumot 256 független, egyenként 4312,5

Hz szélességű csatornára osztják fel. A 0-s csatornát az egyszerű régi telefonszolgáltatás céljaira

használják. Az 1-5. csatornát nem használják, azért hogy megelőzzék a telefonhang és az adatjelek

interferenciáját. A fennmaradó 250 csatornából egyet a felmenő, egyet a lejövő adatfolyam

vezérlésére használnak. A többi csatorna pedig a felhasználók adatait továbbítja. Az ADSL olyan,

mintha 250 modemünk lenne.

Elvileg minden fennmaradó csatorna egy-egy full-duplex adatfolyam megvalósítására

alkalmas, de a felharmónikusok, az áthallás és más effektusok a gyakorlati rendszereket jóval az

elméleti korlát alatt tartják. A szolgáltató határozza meg, hogy hány csatornát lehet feltöltésre és

hányat letöltésre használni. Az 50-50% is megvalósítható lenne a felmenő és a lejövő csatornák

számára, de a legtöbb szolgáltató a sávszélesség 80-90%-át a letöltésre allokálja, hiszen a legtöbb

felhasználó inkább letölt adatokat, mint fel. Emiatt került az „A” betű az ADSL rövidítésbe. Egy

gyakori megosztás: 32 csatorna a feltöltésre, és az összes többi pedig a letöltésre.

Az egyes csatornákon állandóan figyelik a vonalminőséget, és ha szükséges, megváltoztatják

az adatsebességet, így a különböző csatornákon különböző lehet az átviteli sebesség. Az adatokat a

valóságban az amplitúdó- és fázismoduláció kombinációjával továbbítják, így elérhetik a 15 bitet

baudonként. Mondjuk, 224 lejövő csatornánál és 15 bit/baudnál, 4000 baud esetén a lejövő teljes

sávszélesség 13,44 Mbps. A gyakorlatban a jel-zaj viszony sosem elég jó ahhoz, hogy ezt a sebességet

el lehessen érni, de 4-8 Mbps elérhető, jó minőségű hurkokkal és rövid vezetékszakaszokkal.



94.

Egy tipikus ADSL-elrendezés látható a 2.39 ábrán. A diagram azt mutatja be, hogy a

felhasználó vagy a telefontársaság szerelőjének egy hálózati interfészt kell felszerelnie az előfizető

telephelyén. Ez a kis műanyag doboz jelöli a telefontársaság birtokának a végét és az előfizető

birtokának a kezdetét. A hálózati interfészhez közel található a szétválasztó; ez egy analóg szűrő,

amely leválasztja az adathálózatról a 0-4000 Hz-es sávot a POTS számára. A POTS jelet egy meglévő

telefonra vagy telefaxra, az adatjeleket pedig egy ADSL-modemre irányítják. Az ADSL-modem

tulajdonképpen egy digitális jelfeldolgozó eszköz, amely úgy van összekapcsolva, mintha 250 modem

működne párhuzamosan különböző frekvenciákon. Mivel a legtöbb ADSL-modem külső, ezért a

számítógépeket nagy sebességgel kell hozzákapcsolni. Általában ezt úgy oldják meg, hogy egy

Ethernet-hálózati kártyát tesznek a számítógépbe, és egy két állomásból álló, nagyon kis hálózatot

hoznak létre, amely csak a számítógépből és az ADSL-modemből áll. Néha USB portot használnak

Ethernet-hálózat helyett. A jövőben belső ADSL-modemkártyák is lesznek, ehhez kétség sem férhet.

A vezeték másik végén, a telefontársaság végpontján egy megfelelő szétválasztót kell

felszerelni. A jel, hang részét itt is ki kell szűrni, és a normál telefonközpontba küldeni. A 26 KHz

feletti jeleket egy újfajta készülékbe, a DSLAM-ba irányítják, ami ugyanolyan digitális jelfeldolgozó

egység, mint az ADSL-modem. Amint a digitális jelekből a bitsorozatokat előállították, csomagokat

alakítanak ki belőlük, és az itnernetszolgáltatóhoz küldik tovább.

Kábeles internet

Sok kábeltévé-társaság kínál manapság internet-hozzáférést kábelein keresztül. A

kábelszolgáltatók minden városban fő telephellyel rendelkeznek, valamint rengeteg, elektronikával

zsúfolt dobozzal szerte a működési területükön, amelyeket fejállomásoknak neveznek. A

fejállomások nagy sávszélességű kábelekkel vagy üvegkábelekkel kapcsolódnak a fő telephelyhez.

Minden fejállomásról egy vagy több kábel indul el, otthonok és irodák százain halad

keresztül. Minden előfizető ehhez a kábelhez csatlakozik, ahol az átlépi az előfizető telephelyének

határát. Így felhasználók százai osztoznak egy a fejállomáshoz vezető kábelen. Rendszerint a kábelek

sávszélessége 750 MHz körül van. Bár a gyakorlatban egy saját 1,1 MHz sávszélességű csatorna nem

nagyon különbözik a fejállomáshoz vezető kábel 200 MHz-es részének 400 felhasználó számára

történő felosztásától, akiknek a fele nem használja a rendszert az adott pillanatban. Ez azonban azt

jelenti, hogy hajnali 4 órakor jobb a kiszolgálás, mint délután 4-kor, míg az ADSL egész nap állandó.

Azok, akik optimális kábeles internetszolgáltatásra vágynak, meggondolhatják, hogy gazdag vagy

szegény környékre költözzenek.

Amikor a kábeles internetet bevezették, a társaságoknak két problémát kellett megoldaniuk:

1. Hogyan bővítsék a rendszerüket az internetszolgáltatással úgy, hogy a tévéműsorok vételét ezne befolyásolja?

2. Hogyan valósítsanak meg kétirányú forgalmat, amikor az erősítők alapvetően egyirányúak?

A kiválasztott megoldás a következő. A modern kábelek jóval 550 MHz felett is működnek,

gyakran 750 MHz-ig vagy még tovább. A feltöltésre szolgáló csatornák az 5-42 MHz sávban vannak, a

letöltésre szolgáló csatornák forgalma a frekvenciatartomány felső részére esik, ahogyan az a 2.40

ábrán látszik.



95.

Vegyük észre, hogy a televíziójelek mind lejövő jelek, ezért lehetőség van arra, hogy a

felmenő sáv erősítői pedig csak az 54 MHz-nél magasabb frekvenciákon, ahogyan ez az ábrán is

látszik. A felmenő és a lejövő adatfolyam sávszélességében aszimmetria van, mivel a TV-sáv felett

nagyobb frekvenciatartomány áll rendelkezésre, mint alatta. Másfelől viszont a forgalom nagyobb

része valószínűleg letöltés, ezért a kábeltársaságok nem vették zokon ezt a körülményt. Ahogyan

korábban láttuk, a telefontársaságok is aszimmetrikus DSL-szolgáltatást kínálnak, pedig ennek igazán

nincs technikai indoka. Az internet-hozzáféréshez egy kábelmodemre van szükség, amelyben két

interfész van, egyik a számítógéphez, a másik a kábeltévé-hálózathoz. A számítógép és a

kábelmodem közötti interfész kézenfekvő. Ez általában egy Ethernet-kártya, mint az ADSL-nél. A

jövőben lehetséges, hogy az egész modem a számítógépbe dugott kisméretű kártya lesz, éppúgy,

mint a V9.x belső modemeknél.

A kábelszabvány nagyobb része rádióelektronikával foglalkozik, ami jóval túlmutat e könyv

keretein. Az egyetlen említésre méltó részlet, hogy a kábelmodemek ugyanúgy, mint az ADSL-

modemek állandóan be vannak kapcsolva. Akkor veszik fel a kapcsolatot, amikor bekapcsolják, és

folyamatosan kapcsolatban maradnak, amíg ki nem kapcsolják, mivel a kábeltársaságok nem a

kapcsolat fennállásának ideje alapján számítják a díjat.

A modem végigellenőrzi a lejövő csatornákat, és olyan speciális csomagokat keres,

amelyeket a fejállomás periodikusan küld, és a rendszerparamétereket tartalmazzák az újonnan

bekapcsolódó modemek számára. Amint a modem megtalálta ezt a csomagot, jelzi a jelenlétét az

egyik felmenő csatornán. A fejállomás azzal válaszol, hogy kijelöli a modem felmenő és lejövő

csatornáit. Ez a kijelölés később megváltozhat, ha a fejállomás a terhelés kiegyenlítése miatt

szükségesnek ítéli.

Ezután a modem meghatározza a fejállomástól mért távolságát egy speciális csomagküldésével, úgy, hogy leméri, mennyi ideig tart a válasz megérkdezése. Ezt a folyamatot

távolsághatárolásnak hívják. A modem számára fontos, hogy tudja távolságát, hogy ehhez tudja

igazítani a felmenő csatornák működtetését, és az időzítését helyesen állítsa be. Az adatforgalmat

rövid idejű szeletekre, ún. minislotokra osztják. Minden lefelé haladó csomagnak egy vagy több

minislotba kell beleférnie. A fejállomás ad jelet egy újabb minislot-periódusra, azonban a

startpisztolyt nem egyszerre hallja meg minden modem a kábel mentén mért terjedési idő miatt. A

modemek – ha tudják, milyen messze vannak a fejállomástól – ki tudják számítani, hogy valójában

mennyi ideje indult el az előző minislot-periódus. A minislot hossza a hálózattól függ. A hasznos

méret jellemzően 8 bájt.

Az inicializálási fázisban a fejállomás minden egyes modem számára biztosít egy

minislotot, amellyel felmenő sávszélességet kérhetnek. A szabály az, hogy több modemet is

rendelhetnek ugyanahhoz a minislothoz, ami versenyhelyzetet teremt. Amikor a számítógép

csomagot szeretne küldeni, a csomagot elküldi a modemhez, amely megkéri a szükséges számú

minislotot a továbbításához. Ha a kérést a fejállomás elfogadta, nyugtázást küld a lejövő csatornán,

és megadja, hogy mely minislotokat foglalta le a modem számára. Azután a modem elküldi a

csomagot, kezdve az első lefoglalt minislottal. További csomagokat a fejlécben lévő mező

használatával lehet kérni.



96.

A lejövő csatornákat a felmenő csatornáktól eltérően irányítják. Az első dolog, hogy csak egy

küldő van, így nincs versenyhelyzet, és nincs szükség minislotokra, ami tulajdonképpen statisztikai

alapú időosztásos multiplexelés. A másik, hogy a lejövő adatforgalom általában sokkal nagyobb, mint

a felmenő, így rögzített, 204 bájt méretű csomagokat használnak. Ennek egy része egy Reed-

Solomon-féle hibajavító kód, és más járulékos dolgok, így a felhasználó számára 184 bájt hasznos

adatmennyiség marad. Ezeket a számokat a MPEG-2 szabványú digitálistelevízió-szabvánnyal való

kompatibilitás miatt választották, így a tévé és a lejövő csatornák formátuma azonos. A logikai

kapcsolatokat a 2.41 ábra mutatja be.

Visszatérve a modem inicializáláshoz, amint a modem behatárolta a távolságát, megkapta a

felmenő és lejövő csatornáit, valamint a minislot-kiosztását, elkezdheti a csomagok küldését. Ezek a

csomagok a fejállomáshoz futnak be, amely továbbítja egy dedikált csatornán a kábeltársaság fő

telephelyére, majd az internetszolgáltatóhoz. Az internetszolgáltató felé menő első csomag a

hálózaticím-kérés, amelyet dinamikusan osztanak ki. Le szokták kérdezni, és megküldik a napi pontos

időt is.

A következő lépés a biztonsághoz kötődik. Mivel a kábel osztott kommunikációs lehetőség,

bárki bajba kerülhet azáltal, hogy valaki más elolvassa a rajta keresztülhaladó forgalmat. Annak

megakadályozására, hogy mindenki a szomszédjai után szimatoljon, a forgalom mindkét irányban

titkosított.

Végül, a modemnek be kell jelentkeznie, és meg kell adnia saját egyedi azonosítóját a titkos

csatornán. Ekkor az inicializálás véget ér. A felhasználó bejelentkezhet az ISP-hez, és elkezdhet

dolgozni.



97.

37. Az Intel 8086/88 utasításai (adatmozgató, aritmetik ai, logikai,

string-kezelő, bitléptető/forgató, vezérlésátadó, processzor-

vezérlő, input/output utasítások, program megszakítás,szemafor).

Adatmozgató utasítások

Az adatmozgató ut. értékadásra valók. Nem változtatják a flagek értékét, kivéve a POPF.

MOV op1, op2 op1 = op2 értékadás

XCHG op1, op2 op1 és op2 értéke kicserélődik

XLAT ugyanaz, mint MOV AL, [BX + AL]

LEA reg, mem ugyanaz, mint MOV reg, OFFSET mem

LES reg, mem MOV reg, *mem+ és MOV ES, *mem 2+ LDS reg, mem MOV reg, [mem+ és MOV DS, *mem 2+

PUSH reg SP = SP -2, MOV [SP], reg

PUSHF SP = SP -2, SR (FLAGS) bekerül a verembe

POP reg a verem felső szavát teszi reg-be, SP = SP + 2

POPF a verem felső szavát teszi SR-be, SP = SP + 2

Aritmetikai utasítások

Az aritmetikai utasítások egyszerű számolási műveleteket hajtanak végre. Ahol lehetséges,

célszerű az AX regiszterrel számolni, mivel az gyorsabb, mint a többi. Az ún. aritmetikai flageket(C, Z, S, A, O, P) beállítják ezek a műveletek.

ADD op1, op2 op1 = op1 + op2

ADC op1, op2 op1 = op1 + op2 + C(arry)

SUB op1, op2 op1 = op1 – op2

SBB op1, op2 op1 = op1 – op2 – C(arry)

MUL op1 AX = AL · op1 ha op1 8-bites elő jel nélküli érték

DX:AX = AX · op1, ha op1 16-bites előjel nélküli érték

IMUL op1 ua. mint MUL, csak előjeles értékekkel számol

DIV op1 AL = AX / op1, ha op1 8-bites előjel nélküli egész

AX = DX:AX / op1, ha op1 16-bites előjel nélküli egész

IDIV op1 ua. mint DIV, csak előjeles értékekkel számol

INC op1 op1 = op1 + 1 (nem változtatja a Carry flaget)

DEC op1 op1 = op1 – 1 (nem változtatja a Carry flaget)

NEG op1 op1 = – op1, kettes komplemens képzése

CMP op1, op2 flagek beállítása op1 – op2 értéke alapján

CBW AX = AL, kiterjesztés 16-bitre előjellel együtt

CWD DX:AX = AX, kiterjesztés 32-bitre előjellel együtt



98.

Vezérlésátadó utasítások

A vezérlésátadó utasításokkal feltételes vagy feltétel nélküli ugrást, eljárás- és függvényhívást

tudunk kezdeményezni. Az ugrás tulajdonképpen nem más, mint a CS:IP regiszter párnak a következő

utasítás címére beállítása. Háromféle ugrást különböztetünk meg attól függően, hogy az operandus

milyen hosszú. A SHORT ugrásnál IP új értéke az IP – 128 és IP 127 között változhat, CS változatlan

(8 bites, elő jeles operandus). NEAR ugrásnál IP értéke tetszőlegesen változhat, CS változatlan (16

bites operandus). FAR ugrásnál mind CS, mind az IP értéken tetszőlegesen változhat (2x16 bites

operandus, far pointer).

JMP op1 feltétel nélküli ugrás a megadott címre (short, near, far)

Jxx short ptr feltételes ugrás a megadott flag értéke szerint (short)

Lehetséges feltételek: Flag = 1 Flag = 0

C flag szerint: JC ≡ JB ≡ JNAE JNC ≡ JNB ≡ JAEZ flag szerint: JZ ≡ JE JNZ ≡ JNE

S flag szerint: JS JNS

O flag szerint: JO JNO

P flag szerint: JP ≡ JPE JNP ≡ JPO

CMP A, B utasítás után:

A > B esetén: JA ≡ JNBE (C = 0 és Z = 0), előjel nélküli számoknál

A ≤ B esetén: JNA ≡ JBE (C = 1 vagy Z = 1), előjel nélküli számoknál

A > B esetén: JG ≡ JNLE (Z = 0 és S = O), elő jeles

A < B esetén: JL ≡ JNGE (S ≠ O flag), elő jeles

A ≥ B esetén: JGE ≡ JNL (S = O flag), elő jeles

A ≤ B esetén: JLE ≡ JNG (Z = 1 vagy S ≠ O), elő jeles

JCXZ címke feltételes ugrás, ha CX = 0

CALL címke eljáráshívás: PUSH IP majd JMP címke (near)

ill. PUSH CS, PUSH IP, JMP címke (far)

RET visszatérés közeli eljárásból: POP IP-vel egyenértékő

RETF visszatérés távoli eljárásból: POP IP, POP CS

Ciklus-szervező utasítások

A ciklus-szervező utasítások minden esetben CX értékét veszik figyelembe. Mindegyik

utasítás csökkenti eggyel CX értékét, és ha az eredmény nulla, akkor vége a ciklusnak. Nagyjából

egyenértékű a for(CX;CX>1;CX--) utasítással. Az operandusban megadott ugrás SHORT lehet csak

(-128…127).

LOOP címke CX = CX – 1, ha CX ≠ 0 ugrás a címkére

LOOPZ cí mke CX = CX – 1, ha CX ≠ 0 és Z flag = 1 ugrás a címkére

LOOPNZ címke CX = CX – 1, ha CX ≠ 0 és Z flag = 0 ugrás a címkére

LOOPE címke ua. mint LOOPZLOOPNE címke ua. mint LOOPNE



99.

Logikai utasítások

A logikai utasítások az operandusok között bitenkénti szabványos logikai műveletek

megvalósításai. Az eredmény az első operandusba kerül a TEST utasítás kivételével, ahol értékük

változatlan. Emellett természetesen mindegyiknél a megfelelő aritmetikai flagek is beállítódnak.

AND op1, op2 op1 = op1 & op2, logikai ÉS művelet

TEST op1, op2 op1 & op2 értéke alapján beállítja a flageket

OR o1p, op2 op1 = op1 | op2, logikai VAGY művelet

XOR op1, op2 op1 = op1 op2, logikai KIZÁRÓ VAGY művelet

NOT op1 op1 = ≦op1, logikai negáció (egyes komplemens)

String-kezelő utasítások

Ezek az utasítások a memóriában bájtsorozatokkal (stringekkel) kapcsolatos műveleteketvalósítanak meg (másolás, kiolvasás, beírás, keresés). Mindig DS:SI által mutatott címről olvasnak, és

az ES:DI címre írnak. Az utasítástól függően SI ill. DI regiszterek értéke 1 (Byte) ill. 2 (Word)-vel

változik. Ha D (Direction = irány) flag 1, akkor növekszik, ha 0, csökken ennyivel. Létezik mindegyik

utasításnak típus nélküli változata is (nincs a végén B vagy W), ekkor a megadott operandus mérete

mondja meg, hogy melyik változatot kell használni. Ha ez nem dönthető el egyértelműen, akkor az

assembler fordítási hibát ad, emiatt ill. az átláthatóság érdekében ezek használata kerülendő!

Az ismétlő prefixumokat string-kezelő utasítások előtt használhatjuk, azokkal együttesen.

Segítségükkel gyorsan végigmehetünk egy teljes stringen, minden elemre végrehajtva a kívánt

műveletet. Az összes ismétlés CX-szer hajtódik legfeljebb végre, hasonlóan a LOOP utasításhoz, annyi

különbséggel, hogy itt előbb megnézi a processzor, hogy CX = 0 teljesül-e, és csak az utasítás

végrehajtása után csökkenti eggyel (azaz CX = 0 esetén egyszer sem hajtódik végre az utasítás). Ebből

az is következik, hogy ha szabályosan végigfut egy ismétlési ciklus, akkor CX = 0 lesz.

MOVS op1 nem szerencsés, ua. mint MOVSB vagy MOVSW

MOVSB MOV ES:*DI+, DS:*SI+, és SI = SI ± 1, DI = DI ± 1

MOVSW MOV ES:*DI+, DS:*SI+, és SI = SI ± 2, DI = DI ± 2

LODS op1 nem szerencsés, ua. mint LODSB vagy LODSW

LODSB MOV AL, DS:[SI], és SI = SI ± 1 (D flagtől függően)LODSW MOV AX, DS:*SI+, és SI = SI ± 2 (D flagtől függően)

STOS op1 nem szerencsés, ua. mint STOSB vagy STOSW

STOSB MOV ES:[DI], AL és DI = DI ± 1 (D flagtől függően)

STOSW MOV ES:[DI], AX és DI = DI ± 2 (D flagtől függően)

CMPS op1 nem szerencsés, ua. mint CMPSB vagy CMPSW

CMPSB CMP DS:*SI+, ES:*DI+ és SI = SI ± 1, DI = DI ± 1

CMPSW CMP DS:*SI+, ES:*DI+ és SI = SI ± 2, DI = DI ± 2

SCAS op1 nem szerencsés, ua. mint SCASB vagy SCASW

SCASB CMP AL, ES:[DI] és SI = SI ± 1 (D flagtől függően)

SCASW CMP AX, ES:*DI+ és SI = SI ± 2 (D flagtől függően)REP fenti 5 féle utasítás ismétlése legfeljebb CX-szer



100.

REPZ ismétlés legfeljebb CX-szer, ha Z flag értéke 1

REPNZ ismétlés legfeljebb CX-szer, ha Z flag értéke 0

REPE ua. mint REPZ

REPNE ua. mint REPNZ

Bitforgató utasítások

Az érték vagy konstans 1, vagy a CL regiszter (286-os géptől felfelé megadhatunk 1-nél

nagyobb konstanst is).

RCL reg, érték forgatás balra, reg minden bitje eggyel balra tolódik,

0. bitbe C íródik, C felveszi a legmagasabb bit értékét

RCR reg, érték forgatás jobbra, reg minden bitje eggyel jobbra tolódik,

legmagasabb bitbe C íródik, C felveszi a 0. bit értékét

ROL reg, érték forgatás balra, reg minden bitje eggyel balra tolódik, 0. bitbe és C flagbe a legmagasabb bit értéke kerül

ROR reg, érték forgatás jobbra, reg minden bitje eggyel jobbra tolódik,

legmagasabb bitbe és C flagbe a 0. bit értéke kerül

SHR reg, érték eltolás jobbra, reg minden bitje eggyel jobbra tolódik,

legmagasabb bitbe 0 érték kerül, 0. bit a C flagbe íródik

SHL reg, érték eltolás balra, reg minden bitje eggyel balra tolódik,

0. bitbe 0 érték kerül, legmagasabb bit a C flagbe íródik

SAR reg, érték eltolás jobbra, reg minden bitje eggyel jobbra tolódik,

legmagasabb bit nem változik, 0. bit a C flagbe íródik

SAL reg, érték ua. mint SHL

Processzor-vezérlő utasítások

A processzor-vezérlő utasítások egy része a flageket állítja direktben, másik részük egyéb

közvetlen utasítást ad a CPU részére. A flageket, a leírt hatáson kívül nem változtatják.

CLC C flaget törli (C = 0)

STC C flaget beállítja (C = 1)

CMC C flaget negálja (C = 1 – C)CLD D flaget törli (D = 0), csökkenı irányú string-műveletek

STD D flaget beállítja (D = 1), növekvő irányú string-műveletek

CLI I flaget törli (I = 0), megszakítások tiltása

STI I flaget beállítja (I = 1), megszakítások engedélyezése

NOP CPU nem csinál semmit egy ideig ( ≡ XCHG AL, AL)

WAIT CPU várakozik, amíg a koprocesszor kész nem lesz

HLT CPU leáll, amíg hardveres megszakítás jelet nem kap



101.

Input/Output utasítások

Külső eszközökkel kommunikálhat a CPU, az ún. portokon keresztül. A port értéke egy 0-255

közé eső konkrét szám lehet. Ha ennél nagyobb sorszámú portot akarunk elérni, akkor a port helyére

DX regisztert kell beírni (a port sorszáma természetesen ekkor DX-ben van). A művelethez kizárólag

AX és AL regiszterek használhatóak, attól függően, hogy 2 vagy 1 bájtot mozgatunk.

IN accum, port beolvas 1 vagy 2 bájtot AL/AX-be a megadott portról

OUT port, accum kiírja az AL/AX-ben lévő értéket a megadott portra

Program-megszakítás

A (program)-megszakítás azt jelenti, hogy az éppen futó program végrehajtása átmenetileg

megszakad – a processzor állapota megőrződik, hogy a program egy késöbbi időpontban

folytatódhassék – és a processzor egy másik program, az úgy nevezett megszakító rutin végrehajtását

kezdi meg. A megszakító rutin, miután elvégezte munkáját, gondoskodik a processzor

megszakításkori állapotának visszaállításáról, és visszaadja a vezérlést a megszakító programnak.

Általánosítás:

A központi egységnek több állapota van, és bizonyos utasítások csak a központi egységnek

bizonyos kitüntetett (privilegizált) állapotában hajthatók végre, alap állapotban nem.

Megoldás:

Szoftver megszakítás. Az utasítások bizonyos csoportja, a memória meghatározott részei, a

hardver egyes elemei csak a processzor kitüntetett állapotában érhetők el. A processzor (szoftver)

megszakítást eredményező utasítással juttatható a kívánt állapotba. Ilyenkor az operációs rendszer

egy meghatározott programja kapja meg a vezérlést. Ennek módjában áll a kívánság „jogosságának”

ellenőrzése. Jogtalan kívánság, vagy nem kitüntetett állapotban történő kísérlet esetén – ami szintén

megszakítást eredményezhet, tehát szintén az operációs rendszer kapja meg a vezérlést – az

operációs rendszernek módjában áll a program további működését beszüntetni.

Több ok okozhat megszakítást. Az Intel 8088 processzor esetén a megszakítási okokat 0 és

255 közé eső i számmal jellemezhetjük. Az i. megszakítási okhoz tartozó megszakító rutin FAR címe a

memória 4i címén található. A megszakítás esetén a hardver egység installáláskor adott száma,

szoftver megszakítás esetén az operandus rész szolgáltatja.

Interrupt utasítások:

Az interrupt (megszakítás) kezelő utasításokkal saját, vagy beépített eljárásokat hívhatunk

meg. Ezek egy része akkor fut le, ha egy hardver eszköz megszakítás- jelet küld a CPU-nak (pl.

leütöttek egy billentyűt), más részüket a rendszer és mi használjuk programon belül (pl. BIOS

rutinok). A megszakítások sorszáma 0 – 255 között lehet, és a 0000h:*4sorszám+ helyen lévő távoli

címen vannak megvalósítva.



102.

INT sorszám megszakítás hívása, interrupt táblában lévő cím szerint:

PUSHF, CALL far ptr 0000h:[4*sorszám+ egymás után

INTO INT 4 hívása, ha az O flag értéke 1

IRET visszatérés megszakításból (RETF, POPF egymás után)

Szemafor

Multiprogramozásos környezetben gyakran előfordul, hogy ugyanazt az erőforrást (pl.nyomtató) egyidejüleg több program is szeretné használni. Erre természetesen nincs lehetőség, ezértbiztosítani kell, hogy egyidejüleg legfeljebb egy program használhassa az illető erőforrást.Szemafornak nevezzük azt a jelzést, amely megmutatja, hogy az erőforrást használja-e pillanatnyilag

valamely program.

Legyen az S szemafor egy olyan word típusú változó, amely mindegyik program számára

elérhető. Jelentse S=0 azt, hogy az erőforrás szabad, és S≠0 azt, hogy az erőforrás foglalt.

Próbáljuk meg a szemafor kezelését!

A megoldás a következő:

ujra: MOV CX,0FFFH

XCHG CX,S ;már foglaltat jelez a szemafor!

JCXZ szabad ;ellenőrzés S korábbi tartalma szerint

… ;foglalt volt az erőforrás, várakozás

jmp ujra

szabad: … ;szabad volt az erőforrás, ;de a szemafor már foglalt

Több processzoros rendszer esetén elképzelhető, hogy az egyik processzor éppen

végrehajtotta az első mikroutasítást, amikor egy másik processzor is ugyanezt az utasítást kívánja

végrehajtani. Ekkor ugyanúgy, mint az előző kísérletnél a LOCK prefixum segítségével tudjuk

megadni.

ujra: MOV CX,0FFFFH

LOCK XCHG CX,S ;S már foglaltat jelez

JCXZ szabad ;ellenőrzés S korábbi tartalma szerint

… ;foglalt az erőforrás, várakozás

jmp ujra

szabad … ;használható az erőforrás, ;de a szemafor már foglalt

Ha a programnak nincs szüksége tovább a korábban lefoglalt erőforrásra, akkor ezt a

szemafor szabadra állításával jelezheti. A szemafor szabadra állítása a közönséges

MOV S, 0

utasítással történhet.



103.

38. Pszeudo operátorok. Egyszerű adatdefiníciós utasítások.Struktúra, rekord (definíció, hívás, mezőre hivatkozás)

A pszeudo utasítások nem valódi utasítások, abban az esetben, hogy ezeket a lefordított

program a futás során nem fogja végrehajtani (ilyenek pl. az adatdefiníciós utasítások), bizonyosesetekben nem is kerülnek bele a lefordított programba. A pszeudo utasításokat a fordítóprogram

hajtja végre. Ez a végrehajtás fordítás közbeni tevékenységet vagy a fordításhoz szükséges információ

gyűjtést jelenthet.

Adatdefiníciós utasítások

Az adatokat általában külön szegmensben szokás és javasolt definiálni. A kezdőértékkel

ellátott változók a program betöltésekor a megadott értékkel rendelkeznek, de a program futása

során változhatnak. Erre különösen akkor kell tekintettel lennünk, ha a programot egyszeri betöltés

után többször is el akarjuk indítani. Az adatdefiníciós utasítások elé általában azonosítót (változó név)írunk, hogy hivatkozhassunk az illető adatra. Egy-egy adatdefiníciós utasítással több azonos típusú

adatot is definiálhatunk. A kezdő érték tetszőleges konstans (szám, szöveg, cím...) kifejezés lehet. Ha

nem akarunk kezdőértéket adni, akkor ?-et kell írnunk. A szöveg és a karakter konstansokat "-k vagy

'-k között adhatjuk meg.

Egyszerű adatdefiníciós utasítások

Define Byte (db): Az operandus lehet numerikus, karakter vagy szöveg. Pl.:

Adat1 db 25 ;1 byte, kezdőértéke decimális 25

Adat2 db 1,2 ;2 byte (nem egy szó) Adat3 db 5 dub (?) ;5 inicializálatlan byte

Kar db ’a’,’b’,’c’ ;3 ASCII kódú karakter

Szoveg db ’Ez egy szöveg’,13,OAH ;ASCII kódú szöveg, és 2 szám

Szoveg1 db ’Ez is ”szöveg”’,”és ez is ’szöveg’”

Vegyesen is előfordulhatnak egy utasításban.

Define Word (dw): Az operandus lehet numerikus, cím, karakter vagy 2 karakteres szöveg. Pl.:

Szo dw 0742H, 452

Szo_cime dw szo ;szo OFFSET címe

Define Double (dd): Az oprandus lehet numerikus, távoli cím (segment és offset cím), karakter vagy

maximum 4 karakteres szöveg. Tipikus alkalmazásai: Távoli címek tárolására a stringkezelő utasítások

előkésítéséhez az LDS és az LES utasítás operandusként, vagy távoli eljárások indirekt hívásához. Pl.:

Szo_f dd szo ;szo távoli (segmentoffset) címe

Define Quadword (dq): Dupla pontosságú (4 szavas) lebegőpontos számok, változók számára történő

helyfoglalásra használatos.

Define Ten bytes (dt): 10 byte-on tárolt 10 jegyű pakolatlan vagy 20 jegyű pakolt decimális számok,

változók számára történő helyfoglalásra használatos.



104.

Összetett adatdefiníciós utasítások

Programozás során sokszor előnyös, ha több – esetleg eltérő típusú – adatot egységesen

tudunk kezelni. Assembly-ben ezt a lehetőséget a struktúra és a rekord biztosítja. A struktúra ill

rekord elemi részeit mezőknek (field) nevezzük.

Struktúra

Csak a struktúra típusát definiálja a későbbi struktúra-hívások számára, ezért a memóriában

nem jár helyfoglalással.

Str_típus STRUC ;struktúra (típus) definíció

... ;mező (field) definíciók, egyszerű adatdefiníciós utasítások

Str_típus ENDS ;struktúra definíció vége

A mező (field) definíció csak egyszerű adatdefiníciós utasítással történhet, ezért a struktúra

mező nem lehet másik struktúra vagy rekord. A mezők definiálásakor megadott értékek kezdőértékülszolgálnak a későbiekben történő struktúra hívásokhoz. A definícióban megadott kezdőértékek közül

azoknak a mezőknek a kezdőértéke híváskor felülbírálható, amelyek csak egyetlen adatot

tartalmaznak (a szöveg konstans annak minősül). Pl.:

S STRUC ;struktúra (típus) definíció

F1 db 1,2 ;nem lehet felülírni F2 db 10 dup(?) ;nem lehet felülírni F3 db 5 ;felülírható

F4 db ’a’,’b’,’c’ ;nem lehet felülírni F5 db ’abc’ ;felülírható

S ENDS

Struktúra hívás

A struktúra definíciójánál a megadott str_típus névnek a műveleti kód részen történő

szerepeltetésével hozhatunk létre struktúra változókat. A kezdőértékek fölülbírálása a kívánt érték <>

közötti felsorolásával történik. A egyes mezők kezdőértékeit vesszővel választjuk el. Ha egy mezőnek

a kezdőértékét nem kívánjuk megadni vagy nem adhatjuk meg akkor is ki kell írjuk a vesszőt, kivéve

ha egyiknek sem kívánunk eltérő kezdőértéket adni.

S1 S ;kezdőértékek a def -ből S2 S<,,7,,’FG’> ;F3 kezdőértéke 7, F5-é ’FG’ S3 S<,,’A’> ;F3 kezdőértéke ’A’, F5-é a definícióból

Struktúra mezőre hivatkozás

A struktúra változó névhez tartozó OFFSET cím a struktúra OFFSET címét, míg a mező név a

struktúrán belüli címet jelenti. A struktúra adott mezejére úgy hivatkozunk, hogy a struktúra és mező

néve közé pontot írunk. Pl.: MOV AL,S1.F3

A mezőnevek szükségképpen egyedi nevek, tehát sem másik struktúra definícióban, sem

közönséges változóként nem szerepelhet.



105.

Rekord

Rekordon olyan 1 vagy 2 byte-os összetett adatot értünk, melynek meghatározott

szomszédos bitsorozatai logikai egységet alkotnak. Ezeket a logikai egységeket mezőknek (field)

nevezzük. Olyan esetben válhat hasznunkra a rekord, amikor egy vagy két byte-os adatokat

bitcsoportonként kell kezelnünk, ami leggyakrabban driver-ek írásakor fordul elő.

Rekord definíció

Csak a rekord típusát definiálja a későbbi rekordhívások számára.

Rec_típus RECORD mező specifikáció

ahol az egyes mező specifikációkat vesszővel választjuk el. Maga a mező-specifikáció:

mező_név: szélesség=kezdőérték

a szélesség a mező bitjeinek száma. A kezdőérték el is maradhat, pl.:

R RECORD x:3,y:4=15,z:5

Az R rekord szavas (12 bit), a következőképpen helyezkedik el egy szóban:

x x x y y y y z z z z z

Rekord hívás

A rekord definíciójánál megadott Rec_típus névnek a műveleti kód részén történő

szerepeltetésével hozhatunk létre rekord változókat. A kezdőértékek fölülbírálása a kívánt értékek <>közötti felsorolással történik. Az egyes mezők kezdőértékeit vesszővel választjuk el. Ha egy mezőnek

a kezdőértékét nem kívánjuk megadni, akkor is ki kell írjuk a vesszőt, kivéve, ha egyiknek sem

kívánunk eltérő kezdőértéket adni.

R1 R < > ;01E0H, kezdőértékek a def -ből R2 R <,,7> ;01E7H,x,y kezdőértéke a def -ből, z-é 7

R3 R <1,2> ;0240H,x kezdőértéke 1, y-é 2, z-é a def -ből

Rekordból vektort is előállíthatunk. Pl.:

R_vektor R 5 dup (<1,2,3>) ;0243H, 5 elemű rekord vektor

Rekordmezőre hivatkozás

A mezőnév olyan konstansként használható, amely azt mondja meg, hány bittel kell jobbra

léptetnünk a rekordot, hogy a kérdéses mező az 1-es helyértékre kerüljön. További segítség a MASK

operátor, melyet a mező név elé írva olyan konstanst kapunk, amely az illető mezőhöz tartozó biteket

1, a többi biten 0. NOT MASK ennek a bitenkénti negáltja.



106.

39. Eljárás (deklaráció, hívás). Paraméter átadás/átvétel különbözőmódjai.

Tegyük fel hogy például egy olyan programot szeretnénk csinálni, amely két vektor skaláris

szorzatát számolja ki. Ez még nem is tűnik annyira bonyolultnak. De ha többször is el szeretnénk eztvégeztetni, akkor a többszöri utasítássorozat begépelése helyett eljárásokkal oldhatjuk meg.

Eljárás deklaráció

Az eljárásnak a program egy

Elj_név PROC típus

pszeudo utasítással kezdődő (ez az eljárás belépési pontja), és

Elj_név ENDP

utasítással végződő szakaszt értjük. Az Elj_név az eljárás neve, típus az eljárás típusa, amely lehet

NEAR vagy FAR. Eljárás hívására a CALL utasítás szolgál. Ilyenkor verembe helyezi az IP ill. ha FAR

akkor IP és CS tartalmát, és átadja a vezérlést a meghívott eljárásnak. Az eljárásból a RET utasítással

térhetünk vissza a CALL utasítás mögé. Ilyenkor a RET kiolvassa a veremből az IP ill. IP és CS tartalmát

és visszatér a hívás utáni utasításhoz.

A paraméterek regiszterekben történő átadása

A skaláris adatokat szokásos érték szerint átadni, az összetett adatokat pedig cim szerint.

mov cl,n

xor ch,ch

mov si,OFFSET a

mov di,OFFSET b

Ahol

n db 3

a db 1,2,3

b db 3,2,1

Az érték szerinti paraméter átadásnál a hívott program nem tudja módosítani a paraméter

értékét. Ez részben előny, mert nem tudja elrontani, de részben hátrány is, mert néha jó lenne, ha

módosítani tudná. Ilyenkor cím szerint kell átadni a paramétert.

A paraméterek veremben történő átadása

A regiszeterekben történő paraméter átadásnál erősen kihasználtuk azt, hogy elegendő

regiszter áll rendelkezésünkre. Ez általában nem tejesül. Ilyenkor a verembe tároljuk adatainkat. Ezt

persze olyankor is megtehetjük, amikor elegendő regiszterünk lenne a paraméterek átadására. Ekkor

ez igy nézne ki:



107.

mov al,n

xor ah,ah

push ax

mov ax,OFFSET a

push ax

mov ax,OFFSET bpush ax

call ...

Ilyenkor a verem így fog kinézni

(SS:SP) visszatérési cím

+2 b címe

+4 a címe

+6 n értéke

Az eljárás elején általában célszerű a regiszterek verembe tárolása, és a végén onnan veló

kivétele (persze fordított sorrendben). Erre azért van szükség, hogy ne veszítsük el semmi adatot

amivel dolgoztunk a programban.

A paraméterek kiürítését a veremből például a

ret 6

utasítással oldhatjuk meg, ahol az eljárásból való kilépéskor 6 -tal megnöveli az SP-t és a veremben a

visszatérési cim utánni 3 paramétert kivesz.

Ez még úgy is megoldható, hogy a hívás után

add sp,6

utasítást írunk. Ez is szimplán megnöveli az SP-t 6-tal és kivesz 3 paramétert.



108.

40. Lokális adat terület, rekurzív és reentrant eljárások.

Lokális adatterület

Ha egy eljárás működéséhez lokális adatterületre, munkaterületre van szükség, és a működésbefejezetével a munkaterület tartalma felesleges, akkor a munkaterületet célszerűen a veremben

alakíthatjuk ki. A munkaterület lefoglalásának ajánlott módja:

. . . proc . . .

PUSH BP ; BP értékének mentése

MOV BP,SP ; BP SP,

; a stack relatív címzéshez

SUB SP,n ; n a munkaterület byte- jainak száma

. . . ; további regiszter mentések

A munkaterület negatív displacement érték mellet stack relatív címzéssel érhető el.

(A verembe elhelyezett paraméterek ugyancsak stack relatív címzéssel, de pozitív displacement érték

mellet érhetőek el.) A munkaterület felszabadítása visszatéréskor a

. . . ; visszamentések

MOV SP,BP ; a munkaterület felszabadítása

POP BP ; BP értékének visszamentése

ret . . . ; visszatérés

utasításokkal történhet.

Rekurzív és reentrant eljárások

Egy eljárás rekurzív, ha önmagát hívja közvetlenül, vagy más eljárásokon keresztül.

Egy eljárás reentrant, ha többszöri belépést tesz lehetővé, ami azt jelenti, hogy az eljárás még

nem fejeződött be, amikor újra meghívható.

A rekurzív eljárással szemben a különbség az, hogy a rekurzív eljárásban „programozott”,

hogy mikor történik az eljárás újrahívása, reentrant el járás esetén az esetleges újrahívás ideje a

véletlentől függ. Ez utóbbi esetben azt, hogy a munkaterületek ne keveredjenek össze, az biztosítja,

hogy újabb belépés csak másik processzusból képzelhető el, és minden processzus saját vermet

használ.

Ha egy eljárásunk készítésekor betartjuk, hogy az eljárás a paramétereit a vermen keresztül

kapja, kilépéskor visszaállítja a belépéskori regiszter-tartalmakat – az esetleg eredményt tartalmazó

regiszterek kivételével –, továbbá a fenti módon kialakított munkaterületet használ, akkor az

eljárásunk rekurzív is lehet, és a többszöri belépést is lehetővé teszi (reentrant).



109.

41. Feltételes fordítás

Feltételes fordításra az assembler is képes. Ez tulajdonképpen ugyanaz, mint amit

ProgAlapon tanultunk. El tudjuk érni, hogy a programkód egyes részeit a forditóprogram (jelen

esetben az assembler) ne forditsa le. Ez különösen akkor lehet előnyös, ha pl. hibajakeresés céljából aprogramban több helyen elhelyeztünk egy parancsot, amely kiirja az eredményt a képernyőre vagy a

nyomtatóra. Természetesen a végleges programban ezek a kiirások nem szerepelnek, vagyis valahogy

el kell érnünk, hogy a forditóprogram ne forditsa le. Ez lehetséges úgy, hogy egyenként kitöröljük

őket (akár mind a 432 darabot), ezzel azonban az a baj, hogy ha véletlenül továbbra is hibás a

program, egyenként kell őket visszairni. Ugyanez a helyzet a kommentezéssel is. Ehelyett inkább

olyan megoldást kell keresnünk, amely lehetővé teszi, hogy az általunk kiválasztott dolgokról a

forditáskor megmondjuk, benne legyenek-e a forditott kódban, vagy sem. Ez a feltételes forditás.

A feltételes forditás általános szerkezete:

IFxx feltétel

... ; lefordul, ha a feltétel igaz

ELSE ; ez az ág nem kötelező

... ; lefordul, ha a feltétel hamis

ENDIF

A fenti példában xx-t helyettesitve a megfelelő kulcsszavakkal megkapjuk a következő táblázatot:

IF kifejezés ; igaz, ha a kifejezés nem 0

IFE kifejezés ; igaz, ha kifejezés 0

IF1 ; igaz a forditás első menetében IF2 ; igaz a forditás második menetében

IFDEF Szimbólum ; igaz, ha Szimbólum definiált IFNDEF Szimbólum ; igaz, ha Szimbólumnem definiált IFB <arg> ; igaz, ha arg üres (blank) IFNB <arg> ; igaz, ha arg nem üres

IFIDN <arg1>,<arg2> ; igaz, ha arg1=arg2

IFDIF <arg1>,<arg2> ; igaz, ha arg1=arg2 nem teljesül



110.

42. Makró (definíció, hívás), blokk ismétlés

Makró

Az eljárások előnye, hogy csak egyszer kell megírnunk az illető részfeladatot megoldó eljárást,a továbbiak során elegendő a paraméterek megfelelő beállítása után felhívnunk ezt az eljárást. Maga

az eljárás csak egyszer szerepel a programban.

Kimutatkozik az eljárások hátránya, ha az eljárás maga egyszerű, de sok paramétert használ,

mert ilyenkor a paraméterek átadása összemérhető magával az eljárás végrehajtásával. A

paraméterek átadása minden hívásnál terheli a memóriát és a futási időt is. Többek között ilyen

esetekben nyújt hatékony megoldást a makró.

Makrók használatával kapcsolatban meg kell különböztessük a makró definíciót és a makró

hívást.

Makró definíció:

M_név MACRO *fpar1+,*fpar2+… ;makró fej (kezdet) … ;makró törzse

ENDM ;makró vége

A makró fejben megadott *fpar1+,*fpar2+…-t formális paramétereknek, vagy egyszerűen

paramétereknek szokás nevezni. A makró definíció nem lesz része a lefordított programnak, csupán

azt határozza meg, hogy később mit kell a makró hívás helyére beírni (makró kifejtés, helyettesítés).

A makró törzsén belül előfordulhat makró hívás és makró definíció is.

Makró hívás:

M_név *apar1+,*apar2+…

A makró hívásában megadott *apar1+,*apar2+…-t aktuális paramétereknek vagy

argumentumoknak szokás nevezni. A műveleti kód helyére írt M_név hatására a korábban megadott

definíció szerint megtörténik a makró helyettesítés, más néven makró kifejtés. Ez a makró törzs

bemásolását jelenti, miközben az összes paraméter összes előfordulása a megfelelő argumentummal

helyettesítődik. A helyettesítés szövegesen történik, azaz minden paraméter – mint szöveg – helyére

a megfelelő argumentum – mint szöveg – kerül. A helyettesítés nem rekurzív, és argumentuma sem

lehet makró hívás, csak egyszerű szöveg, de az argumentumnak megfelelő formális paraméternek

lehet olyan előfordulása, amely a későbbiekben makró hívást eredményez.

Példaként legyen a programban gyakran előforduló részfeladat a dupla szavas összeadás.

Makró definíció: MDADD MACRO

ADD AX,BX

ADC DX,CX

ENDM

Makró hívás: MDADD



111.

Fordítás közben MDADD definíciója szerint, megtörténik a makró helyettesítése, és a program-szövegrészévé válik:

ADD AX,BX

ADC DX,CX

Futás közben csak ez a két utasítás kerül végrehajtásra.

Paraméter nemcsak operandus részen fordulhat elő a makró törzsében, hanem másutt is, pl.:

PL MACRO P1,P2

MOV AX,P1

P2 P1

ENDM

makró definíció esetén a

PL Adat, INC

makró hívás a

MOV AX,Adat

INC Adat

utasításokra cserélődik.

A &, %, ! karakterek továbbá a <> és ;; speciális szerepet töltenek be makró kifejtéskor.

&: Előfordulhat, hogy azt szeretnénk, hogy makró kifejtéskor a paraméter – helyettesített – értéke

része legyen egy szónak. Ezt a & karakterrel oldhatjuk meg. A makró generátor az & karakter mindkét

oldalát megvizsgálja, hogy ott paraméter szerepel-e. Ha igen, elvégzi a paraméter helyettesítését, és

mindenképpen elhagyja az & jelet. Pl.:

UGRIK MACRO Felt, Címke

J&Felt Felt&Címke

ENDM

A hívás, pl.:

UGRIK Z,Alfa

Ennek kifejtése:

JZ Zalfa

%: Az utána szereplő paraméter értékének számjegyek sorozatává alakítását írja elő.

S = 0

ErrMsg MACRO textS = s+1

MSG %s,text



112.

ENDM

Msg MACRO sz,str

Msg&sz db str

ENDM

Az

ErrMsg ’syntax error’

makró hívás hatására az

msg1 db ’syntax error’

adatfoglaló utasítás

!: Az utána következő karakter változatlanul kerül bemásolásra. Lehetőséget ad arra, hogy pl. az &

jelet a kifejtett makró szövegében szerepelhessen.

<>: Ha aktuális paraméterként olyan szöveget kívánunk megadni, amely pl. ,-t tartalmaz, akkor ezt <>

jelek között tehetjük meg. Pl az

adat macro p

db p

endm

makró definíció esetén az

adat <’abc’,13,10,0>

hívás kifejtve:

db ’abc’,13,10,0

míg ezzel szemben az

adat ’abc’,13,10,0

kifejtve

db ’abc’

;;: A makró definíció megjegyzéseinek kezdetét jelzi. A ;; utáni megjegyzés nem jelenik meg a

programlistában.

Ha makró egyes részeihez címkét szeretnénk rendelni, és a makró többször is meghívjuk, akkor

hibajelzést kapunk. Az ilyen hiba elkerülésére használjuk a LOCAL utasítást.

LOCAL c1*,c2…+



113.

c1*,c2…+ minden makró hívásnál más, ??xxxx alakú szimbólumra cserélődik, ahol xxxx a makró

generátor által meghatározott hexadecimális szám. A LOCAL operátort közvetlenül a makró fej utáni

sorba kell írni.

Makró definíció belsejében meghívható az éppen definiálás alatt lévő makró is (a makró hívás ezáltal

rekurzívvá válik). Pl. a

PUSHALL MACRO reg1,reg2,reg3,reg4,reg5,reg6

IFNB <reg1> ;;ha a paraméter nem üres

Push reg1 ;;az első regiszter mentése

PUSHALL reg2,reg3,reg4,reg5,reg6 ;;rekurzió

ENDIF

ENDM

Makró lehetővé teszi, hogy egy felhívással akárhány (legfeljebb 6) regiszter tartalmát a verembe

mentsük, pl.: a

PUSHALL ax,bx,cx

hatására a

PUSH ax

PUSH bx

PUSH cx

utasítás sorozat generálódik.

Blokk ismétlés

A makróhoz hasonló lehetőséget biztosít: a blokk egy definíciója alapján a blokk többszöri kifejtését.

Lényeges különbség azonban, hogy ezek az operátorok nemcsak a blokk definíciójának kezdetét

jelölik ki, hanem a kifejtést (hívást) is előírják. A program más részéről nem hívhatók ezek a

definíciók.

Blokk ismétlés kifejezés-szer:

REPT kifejezés

… ;ez a rész ismétlődik

ENDM



114.

A kifejezés nem lehet változó, a fordítási időben ismert kell legyen az értéke!

Blokk ismétlés argumentum lista szerint:

IRP par,<arg1,*,arg2…+>

… ; ez a rész kerültöbbször bemásolásra úgy, … ; hogy par rendre felveszi az

… ; arg1*,arg2…+ értéket

ENDM

Pl.: IRP x,<1,2,3>

Db x

ENDM

hatása: db 1

db 2

db 3

Blokk ismétlés string alapján:

IRPC par,string

… ; ez a rész kerül bemásolásra úgy, … ; hogy par rendre felveszi a string karaktereit

ENDM

A stringet nem kell idéző jelek közé tenni, ez csak újabb ismétlést jelentene.

A makró definíció is tartalmazhat blokk ismétlést és blokk ismétlés is tartalmazhat makró definíciót

vagy makró hívást.



115.

43. Címkék, változók, konstansok, kifejezések

Címkék

Leggyakoribb definíciója, hogy valamelyik utasítás előtt a sor első pozíciójától :-tal lezártazonosítót írunk. Az így definiált címke NEAR típusú. A LABEL és a PROC pszeudo utasítások további

lehetőséget nyújtanak.

ALFA: ... ;NEAR típusú

BETA LABEL FAR ;FAR típusú

Az eljárás deklarációt a PROC utasítással nyitjuk meg. A címke rovatba írt azonosító az eljárás

neve és egyben a belépési pontjának címkéje. Az eljárás végén az eljárás végét jelző ENDP pszeudo

utasítás előtt meg kell ismételnünk ezt az azonosítót, de ez már nem minősül címkének.

A PROC NEAR ;NEAR típusú (a NEAR elhagyható) ...

B PROC FAR ;FAR típusú

...

Címkére vezérlés átadó utasítással hivatkozhatunk, NEAR típusra csak az adott szegmensből,

FAR típusra más szegmensből

Változók

Definíciója ada definíciós utasításokkal történik. Néha (adat) címkének is nevezik.

Adatdefiníciós utasítások

Az adatokat általában külön szegmensben szokás és javasolt definiálni. A kezdőértékkel

ellátott változók a program betöltésekor a megadott értékkel rendelkeznek, de a program futása

során változhatnak. Erre különösen akkor kell tekintettel lennünk, ha a programot egyszeri betöltés

után többször is el akarjuk indítani. Az adatdefiníciós utasítások elé általában azonosítót (változó név)

írunk, hogy hivatkozhassunk az illető adatra. Egy-egy adatdefiníciós utasítással több azonos típusú

adatot is definiálhatunk. A kezdő érték tetszőleges konstans (szám, szöveg, cím...) kifejezés lehet. Ha

nem akarunk kezdőértéket adni, akkor ?-et kell írnunk. A szöveg és a karakter konstansokat " -k vagy

'-k között adhatjuk meg.

Egyszerű adatdefiníciós utasítások

Define Byte (db): Az operandus lehet numerikus, karakter vagy szöveg. Pl.:

Adat1 db 25 ;1 byte, kezdőértéke decimális 25

Adat2 db 1,2 ;2 byte (nem egy szó) Adat3 db 5 dub (?) ;5 inicializálatlan byte

Kar db ’a’,’b’,’c’ ;3 ASCII kódú karakter

Szoveg db ’Ez egy szöveg’,13,OAH ;ASCII kódú szöveg, és 2 szám

Szoveg1 db ’Ez is ”szöveg”’,”és ez is ’szöveg’”

Vegyesen is előfordulhatnak egy utasításban.



116.

Define Word (dw): Az operandus lehet numerikus, cím, karakter vagy 2 karakteres szöveg. Pl.:

Szo dw 0742H, 452

Szo_cime dw szo ;szo OFFSET címe

Define Double (dd): Az oprandus lehet numerikus, távoli cím (segment és offset cím), karakter vagymaximum 4 karakteres szöveg. Tipikus alkalmazásai: Távoli címek tárolására a stringkezelő utasítások

előkésítéséhez az LDS és az LES utasítás operandusként, vagy távoli eljárások indirekt hívásához. Pl.:

Szo_f dd szo ;szo távoli (segmentoffset) címe

Define Quadword (dq): Dupla pontosságú (4 szavas) lebegőpontos számok, változók számára történő

helyfoglalásra használatos.

Define Ten bytes (dt): 10 byte-on tárolt 10 jegyű pakolatlan vagy 20 jegyű pakolt decimális számok,

változók számára történő helyfoglalásra használatos.

Összetett adatdefiníciós utasítások

Programozás során sokszor előnyös, ha több – esetleg eltérő típusú – adatot egységesen

tudunk kezelni. Assembly-ben ezt a lehetőséget a struktúra és a rekord biztosítja. A struktúra ill

rekord elemi részeit mezőknek (field) nevezzük.

Konstansok

Egy művelet operandusa lehet konstans, szimbólum vagy kifejezés. A konstans lehet

numerikus vagy szöveg konstans. A numerikusak lehetnek decimálisak, hexadecimálisak, oktálisak

vagy binárisak. A számrendszert a szám végére írt D, H, O ill B betűvel választhatjuk ki. Ha nem írunk

betűt a végére, akkor az alapértelmezett számrendszert kell érteni(általában decimális). Az

alapértelmezett számredszert a

.radix n

pszeudo utasítással állíthatjuk be, és n a számrendszer alapszáma. A hexadecimális számok

számjeggyel kell hogy kezdődjenek, különben a fordító azonosítónak fogja tekinteni. A szöveges

konstansokat a DB utasításban " vagy ' jelek között adhatjuk meg.

Kifejezések

A kifejezés szimbólumokból és konstansokból épül fel az alábbi műveletek segíségével.

Értékét a fordítóprogram határozza meg, és a kiszámított értéket használja operandusként.

Szimbólumok értékén konstansok esetében természetesen a konstansok értékét, címkék, változók

esetében a hozzájuk tartozó címet értjük. Az érték nemcsak számérték lehet, hanem minden, ami az

utasításokban megengedett címzési módok valamelyikénak megfelel. Pl *BX+ is kifejezés és értéke a

BX regiszterrel történő indirekt hivatkozás, és ehhez a fordítóprogramnak nem kell ismernie BX

értékét. De előfordulhat, hogy egy kifejezés egyik szintaktikus helyzetben megengedett, másikban

meg nem.

mov ax,[BX] ;[BX] megengedett

mul [BX] ;*BX+ hibás, de WORD PTR *BX+ megengedett



117.

A műveletek csökkenő precedencia szerinti sorrendben: (nem feltétlen tartozik a tételhez)

1.

( ) zárójel pár a kifejezésben a műveletek sorrendjét befolyásolja, * + az indirekció előírásra

szolgál. Ha * +-en belüli kifejezésre nem használható indirekció, akkor( )-lel egyenértékű

. (pont): struktúra mezőre hivatkozásnál használatos

LENGTH változó: a változó-hoz tartozó adat terület elemeinek száma

SIZE változó: a változó-hoz tartozó adat terület hossza byte-okban

WIDTH R/F: az R rekord vagy az F (rekord) mező szélessége bitekben

MASK F: az F (rekord) mező bitjein 1, másutt 0

Pl. v dw 20 dup (?)

rec record x:3, y:4

esetén:

mov ax,LENGTH v ;ax 20

mov ax,SIZE v ;ax 40

mov ax,WIDTH rec ;ax 7

mov ax,WIDTH x ;ax 3

mov ax,SIZE rec ;ax 1mov ax,MASK x ;ax 70H

2. Explicit szegmens megadása (segment override prefix). Az automatikus szegmens regiszter helyett

más szegmens regiszter használatát írja elő.

Pl. mov ax,ES:[BX] ; ax (ES:BX) címen levő szó

Nem írható felül az automatikos szegmens regiszter az alábbi esetekben:

CS program memória címzésnél SS stack referens utasításokban (PUSH,POP,...) ES string utasításban DI mellett, de az SI-hez tartozó DS átírható

3.

típus PTR cím: (típus átdefiniálás) ahol a típus lehet BYTE, WORD, DWORD, QWORD, TBYTE, ill

NEAR és FAR. Pl mul BYTE PTR [BX] ;a *BX+ címet byte-osan kell kezelni

OFFSET szimbólum: a szimbólum OFFSET címe (a szegmens kezdetétől számított távolságabyte-okban)

SEG szimbólum: a szimbólum szegmens címe (abban az értelemben, ahogy a szegmensregiszterben szokásos tárolni, tehát valós üzemmódban a szegmens tényleges kezdőcímének16-oda)

TYPE változó: a változó elemeinek hossza byte-okban

... THIS típus: a program szöveg adott pontján adott típusú szimbólum létrehozása

Pl

ADATB EQU THIS BYTE ;BYTE típusú változó, helyfoglalás nélkül ADATW dw 1234H ;ez az adat ADATB-vel byte-osan érhető el



118.

definíció esetén:

mov al,BYTE PTR ADATW ;al 34H, helyes

mov al,ADATB ;al

mov ah,ADAT+1 ;ah

4.

LOW változó: egy szó alsó (alacsonyabb helyértékű) byte-ja

HIGH változó: egy szó felső (magasabb helyértékű) byte-ja

5. Multiplikatív műveletek

: szorzás

/ : osztás

MOD: (modulo) a legkisebb nem negatív maradék, pl. mov al,20 MOD 16 ;al

kifejezés SHL lépés: kifejezés bitenkénti léptetése balra lépés bittel

kifejezés SHR lépés: kifejezés bitenkénti léptetése jobbra lépés bittel

A kifejezésben előforduló műveleti jelek (SHL, SHR, és az alacsonyabb prioritású NOT, AND, OR,

és XOR) nem tévesztendők össze a velük azonos alakú műveleti kódokkal: az előbbieket a fordító

program, az utóbbiakat a futó program hajtja végre.

6. Additív műveletek

: összeadás

- : kivonás vagy negatív előjel

7. Relációs operátorok: általában feltételes fordítással kapcsolatban fordúlnak elő

EQ: =

NE:

LT: <

LE: ≤

GT: >

GE: ≥

8. NOT: bitenkénti negálás

9. AND: bitnkénti és művelet

10. Bitenkénti vagy és kizáró vagy művelet

OR: bitenkénti vagy művelet

XOR: bitenkénti kizáró vagy művelet

11. SHORT: 8 bites IP relatív címzés kikényszerítése



119.

44. Szegmens definíció, szegmens csoport, aktív szegmensek kijelölése, globális szimbólumok

A szegmens definícióban a szegmens egyes szeleteit írhatjuk meg a szegmens kezdő:

sz_név SEGMENT align_type combine_type ’osztály’

és a szegmens vége:

sz_név ENDS

utasítások között.

A sz_név a szegmens (szelet) neve. Ez lehet egyedi név is, de több SEGMENT utasítás előtt is

szerepelhet ugyanaz a név. A fordító az azonos nevű szeleteket úgy tekinti, mintha egyetlen

szegmens szeletbe írtuk volna. Az azonos nevű szeletek paraméterei egy modulon belül nemváltozhatnak.

A szerkesztő egy memória szegmensbe szerekeszti az azonos nevű szegmenseket. A szegmens név és

az osztály tetszés szerinti lehet. Az osztály legtöbbször CODE, DATA, CONSTANT, STACK, MEMORY.

Az align_type (illesztés típusa) azt mondja meg, hogy – amennyiben a szegmens szelet egy már

megkezdett szegmens folytatása, akkor – milyen ”határon” kezdődjön a szelet. Az align_type lehet

BYTE, WORD, DWORD, PARA, PAGE, ami rendre 1-gyel, 2-vel, 4-gyel, 16-tal, és 256-tal osztható címet

jelent.

A combine_type (kombinációs típus) az azonos nevű szegmensek kezelésére vonatkozó üzenet aszerkesztőnek. Lehet:

PUBLIC: (alapértelmezés) – az azonos nevű szegmes szeletek egymás folytatásaként szerkesztődnek

össze.

STACK: a szegmens szelet a stackt részekén szerkesztendő, egyébként megegyezik a PUBLIC-kal.

COMMON: az azonos nevű szegmens szeletek azonos címre szerkesztendők, tehát ugyanarra a

memória tartományra kerülnek. Az így keletkező terület hossza megegyezik a leghosszabb szegmens

szelet hosszával. Így elérhető, hogy ugyanazt a memória területet eltérő beosztás szerint tudjuk

címezni.

MEMORY: a szerkesztő ezt a szegmenst az összes többi szegmens fölé (magasabb címre) fogja

szerkeszteni, mindig a program legmagasabb címre kerülő része.

AT kif : a kif sorszámú paragrafusra kerül a szegmens szelet.

Az assemblert informálnunk kell arról, hogy melyik szegmens regiszter melyik szegmensnek a címét

tartalmazza (melyik szegmensre mutat). Erre szolgál az ASSUME pszeudo utasítás:

ASSUME sz_reg1:sz_név1 * , sz_reg2:sz_név2 . . . +



120.

Az ASSUME utasításban felsorolt szegmenseket „aktív”-aknak nevezzük. Az utasítás hatása egy-egy

szegmens regiszterre vonatkozóan mindaddig érvényes, amíg egy másik ASSUME utasítással mást

nem mondunk az illető regiszterről.

A GROUP utasítással csoportosíthatjuk a szegmenseket:

G_név GROUP S_név1 * , S_név2 . . . +

Az egy csoportba sorolt szegmensek a memória egy szegmensébe kerülnek. Ha ilyenkor az ASSUME

utasításban a csoport nevét adjuk meg, és ennek megfelelően állítjuk be a bázis regisztert, akkor a

csoport minden szegmensének minden elemére tudunk hivatkozni. Azonban vigyázni kell arra, hogy

pl. egy változó OFFSET- je továbbra is annak a szegmensnek az elejétől számított távolsága, amelyben

a változót definiáltuk, az effektív címe viszont a változónak a szegmens csoport elejétől (a memória

szegmens elejétől) számított távolsága.

Ha egy programot több modulban írunk meg, előfordul, hogy ugyanazt a szimbólumot, (pl. változót,

címkét) több modulból is el akarunk érni. Az ilyen több modulból is elérhető szimbólumokat globális

szimbólumoknak nevezzük.

Ha egy szegmens valamelyik szimbólumát globálissá szeretnénk tenni, akkor PUBLIC-ká kell

nyilvánítanunk annak a modulnak az elején, amelyben a szimbólumot definiáltuk. Ez a PUBLIC

pszeudo utasítással lehetséges:

PUBLIC szimb1 [ , szimb2 . . . ]

Azokban a modulokban, amelyekben más modulban definiált szimbólunokat is használni szeretnénk,

az ilyen szimbólumokat EXTERN-né kell nyilvánítanunk. Mivel az assemblernek a szimbólum típusát isismernie kell, ezért az EXTERN pszeudo utasítás a következő alakú:

EXTERN szimb1:típus1 * , szimb2:típus2 . . . +

A globális szimbólumok lehetővé teszik, hogy a programokat modulokra bontva készítsük el. Az egyes

blokkok közötti kapcsolatot a globális szimbólumok jelentik.



121.

45. Egyszerûsített lexikális elemzõ

Fordítóprogramokban szokásos, hogy a lefordítandó programot olyan elemzésnek vetik alá,

amely felismeri a programban elõforduló nyelvi elemeket (kulcsszavak, azonosítók, …), és ez alapján a

fordítás további részéhez átalakítja a program szövegét. Ezt a feladatot a lexikális elemzõ végzi.

Most egy rendkívüli mértékben leegyszerûsített lexikális elemzõ programját láthatjuk. Az

elemzõnek legyen az a feladata, hogy felismerje a szövegben elõforduló azonosítókat, számokat,

speciális jeleket és a program vége jelet, és ezek elõfordulását rendre A, 0, , és . karaktert írjon a

képernyõre. Az esetleges hibákat ? jelezze.

A programot az adatszegmenssel kezdjük. A lehetséges szintaktikus helyzetekhez ugró

táblákat definiálunk. Az ugró táblához igazodva átkódoló táblát készítünk.

DATA segment para public 'DATA'

;ugró táblák a szintaktikus helyzetnek megfelelõen:

;kezdetben, speciális és hibás karakter után

t_S dw hiba ;hibás karakter: ;áttérés speciális jel szintre

dw lev_a ;betû

dw lev_n ;számjegy

dw lev_s ;speciális jel dw vege ;szöveg vége: program vége

;azonosító szint t_a dw hiba ;hibás karakter:

dw OK ;betû:nincs teendõ

dw OK ;számjegy:nincs teendõ

dw lev_s ;speciális jel, azonosító vége

dw vege ;szöveg vége: program vége

;szám szint t_n dw hiba ;hibás karakter:

;áttérés spec. jel szintre

dw hiba ;betû:hiba, ;áttérés spec. jel szintre

dw OK ;számjegy:nincs teendõ

dw lev_s ;speciális jel: szám vége

level dw ? ;ide kerül az aktuális ugrótábla címe

c_h db 0 ;hibás karakter kódja

c_b db 2 ;betû kódja

c_n db 4 ;számjegy kódja

c_s db 6 ;speciális jel kódja

c_v db 8 ;végjel kódja



122.

specjel db ' ,.;+-()',13,10 ;a speciális jelek

vegjel db '$' ;vége jel, kihasználjuk, hogy itt van!

table db 256 dup (?) ;átkódoló tábla (256 byte)

text db 'a,tz,fe&a 21 a12; 12a $' ;elemzendõ szöveg

DATA ends

;==============================================================

CODE segment para public 'CODE'

assume CS:code, DS:DATA, ES:DATA, SS:STACK

Lex proc far

push ds

xor ax,ax

push ax

mov ax,DATA

mov ds,axmov es,ax ;assume miatt

call prepare ;az átkódoló elkészítése

mov si,offset text ;az elemzendõ szöveg kezdõcíme

call parsing ;elemzés

ret ;vissza az Op. rendszerhez

Lex endp

;--------------------------------------------------------------prepare proc ;az átkódoló tábla elkészítése

;az eljárás rontja AX, BX, CX, DI, SI tartalmát, ezért elmentjük a verembe

push AX

push BX

push CX

push DI

push SI

cld ;a string mûveletek iránya pozitív

mov bx, offset table

mov di,bxmov al,c_h ;hibás karakter kódja

mov cx,256 ;a tábla hossza

REP stos table ;table <= minden karakter hibás

mov al,c_b ;betû kódja

mov di,'A' ;az elsõ nagybetû ASCII kódja

add di,bx ;az A betû helyének offset címe

mov cx,'Z'-'A'+1 ;a nagybetûk száma

;kihasználjuk, hogy a betûk ASCII kódja folyamatos

REP stosb



123.

mov di,'a' ;az elsõ kisbetû ASCII kódja

add di,bx ;az a betû helyének offset címe

mov cx,'z'-'a'+1 ;a kisbetûk száma

REP stosb

mov al,c_nmov di,'0' ;az elsõ nagybetû ASCII kódja

add di,bx ;az 0 helyének offset címe

mov cx,'9'-'0'+1 ;a számjegyek száma

;kihasználjuk, hogy a számjegyek ASCII kódja folyamatos

REP stosb

mov si,offset specjel ;speciális jelek feldolgozása

xor ah,ah ;ki fogjuk használni, hogy AX=AL

pr1: lods specjel ;speciális jelek olvasása

mov di,axcmp al,vegjel ;vegjel közvetlenül a speciális jelek után!

je pr2;az már végjel mov al,c_s ;speciális karakter kódja

mov [BX+DI],al ;elhelyezés a táblában

loop pr1 ;ciklus vége

pr2: mov al,c_v ;a végjel kódja

mov [BX+DI],al ;elhelyezés a táblában

;a regiszterek visszamentése

pop SIpop DI

pop CX

pop BX

pop AX

ret

prepare endp

;-------------------------------------------------------------------

parsing proc ;elemzés

push AX

push BX

push CXpush DI

push SI

cld ;a string mûveletek irány pozitív

mov bx,offset table

mov di,offset t_s ;kezdetben is spec. jel szint

lv1: mov level,di ;szint beállítás

xor ah,ah ;kihasználjuk hogy AX=AL

OK: lods text ;a következõ karakter

XLAT ;AL <= 0, 2, 4, 6 vagy 8

mov di,level ;DI <=az akt. ugrótábla címe add di,ax ;di <= a megfelelõ elem címe

jmp [DI] ;kapcsolódó utasítás



124.

hiba: mov di,offset t_s ;hibás karakter, spec. jel szint

mov al,'?'

lv2: mov ah,14 ;BIOS hívás elõkészítése

int 10h ;BIOS hívás: karakter írás a képernyõre

jmp lv1

lev_a: mov di,offset t_a ;azonosító kezdõdik

mov al,'A'

jmp lv2

lev_na: mov di,offset t_n ;szám kezdõdik

mov al,'0'

jmp lv2

lev_s: mov di,offset t_s ;speciális jel

mov al,',' jmp lv2

vege: mov al,'.'

mov ah,14 ;BIOS hívás elõkészítése

int 10h ;BIOS hívás, karakter kiírása képernyõre

ret ;elemzés vége, vissza a hívóhoz

pop SI

pop DI

pop CX

pop BX

pop AX

parsing endp

;------------------------------------------------------------------

CODE ends

;==================================================================

STACK segment para stack 'STACK'

dw 100 dup (?) ;100 word legyen a verem

STACK ends

end Lex ;modul vége, start cím: Lex



125.

46. Két menetes assembler fordító

Az assembly nyelvű programok egysoros utasításokból állnak, így természetesnek tűnik az

elgondolás, hogy az assembler az utasításonként lefordított gépi nyelvű kódot egy fájlba helyezze el,

a megfelelő listarészeket pedig (ha van ilyen) egy másik fájlba. Azonban ez különböző nehézségekbe

ütközik, és így nem megvalósítható.

Egy ilyen lehetséges probléma az előre hivatkozási probléma. Ez akkor lép fel, amikor egy

olyan L szimbólumra hivatkozunk, amelyet eddig még nem definiáltunk (pl egy címke, amely a

program végére ugrik, így a definíció a program végéhez van közel). Így az assembler nem ismeri a

szimbólum címét.

Ezt a problémát két módon lehet lekezelni:

Az assembler a forrásprogramot kétszer olvassa. Egy olvasási folyamatot menetnek

nevezünk. A fordítók, amelyek kétszer olvassák a forrásprogramot, a kétmenetes fordítók.

Az assembler a programot csak egyszer olvassa, és egy közbülső formába transzformálja, eztpedig memória egy táblázatába helyezi. Csinál egy második menetet is, de ez már atáblázaton megy végig. Így B/K idő takarítható meg. Ha van listaigény, az egész forráskódottárolni kell a megjegyzésekkel együtt.

A kétmenetes fordítók működése:

Első menet:

Ennek fő feladata az ún. Szimbólumtábla felépítése, amely tartalmazza az összes szimbólum

értékét. Egy szimbolikus névnek értékül adható címke vagy konstans. A fordítás alatt létezik egy

utasításszámláló nevű változó, amely nyomon követi annak az utasításnak a futtatáskori címét,

amelyet éppen fordít. Az első menet kezdetekor ez 0, utána pedig minden utasítás feldolgozásakor az

utasítás hosszával növekszik.

Az első menetben legalább 3 táblázat jön létre: Szimbólumtábla, pszeudoutasítások táblázata

és a műveleti kódtábla. Esetleg még egy konstans táblázat.

A szimbólumtábla tartalmazza a szimbólumot(vagy egy mutatót rá), a numerikus értéket,

valamint egyéb információkat(a szimbólumhoz tartozó adatmező hossza; áthelyezési bitek=>változik-

e a szim. étéke, ha a progi más cimre töltődik be, mint az assembler feltételezi;vajon elérhető-e aszimbólum más eljárásból?)

A szimbólumtábla az asszociatív memória működését szimulálja: A szimbólum ismeretében megadja

a hozzá tartozó értéket.

A szimbólumtábla lehet tömbös felépítésű, a párok első komponense a szimbólum, a második pedig

az érték(vagy az ezekre mutató mutató). A szimbólumtáblában kereshetünk lineárisan(egyszerű, de

lassú módszer, az elemeket át kell vizsgálni sorban egyenként, amig meg nem lesz a keresett

szimbólum), és bináris keresőalgoritmus segítségével, ha a tömb rendezett. Ilyenkor megnézzük a

középső elemét, ha az a keresett elem, vége a keresésnek, ha ennél nagyobb, akkor a felső fél



126.

táblázatban csináljuk ugyanezt, ha kisebb, az alsóban (mindig a középső értéket nézzük meg először).

Így a legrosszabb esetben log2n lépésre van szükség n elem esetén.

Az asszociatív memória szimulálásának teljesen más módja a tördelő kódolási módszer.

A művelettábla nyit egy bejegyzést minden mnemonic (szimbolikus műveletkód) részére. Abejegyzésnek (vegyük úgy, mint egy táblázat egy sora) a következő mezői vannak (a tábláza oszlopai):

szimbolikus kód, a két operandus, az utasítás hossza, és egy típusszám(operandusaik szerint

csoportosítja az utasításokat). Pl.:

Müv.Kód Első op Második op Müv.Kód Hexában Hossz Típusszám

ADD EAX immed32 05 5 4

Egyes assemblerek lehetővé teszik a közvetlen címzés használatát. Ilyenkor az assembler

automatikusan memóriát foglal a konstansnak. Ezeket a konstansokat literáloknak nevezzük. Az első

menetben az összes literálból táblázat készül. A fordító minden literált felvesz ide, de a menet végénaz ismétlődőeket kitörli.

Második menet:

Ennek feldata a tárgyprogram előállítása és lehetőleg a fordítási lista kinyomtatása. Itt jön

létre a .obj fájl. A második menet kiad még néhány információt, amelyekre a szerkesztőnek lesz

szüksége a későbbiekben.

Ez is egyesével olvassa a sorokat és dolgozza fel azokat. Egy sor egy -egy utasítás, amely a

típusára, a műveleti kódra és a hosszra vonatkozó információval kezdődik (az ideiglenes fájlban), így a

második menet ezt egyszerûen beolvassa, nem kell elemezgetnie. Az utasításhoz generált bináris

kódot a code váltózóban adja vissza, amely aztán kiírásra kerül, és az utasítások bináris kódjaiból

létrejön az object file. Ez hexadecimális alakú.

A forrasprogramban azonban hibák is előfordulhatnak. Az egyszerûbbeket, mint például az

elgépelésből eredő definálatlan szimbólumok, az assembler megpróbálja kijavítani a hozzá legjobban

hasonlító szimbólum használatával. Azonban általában a fordítóprogram tehetetlen a legtöbb hibával

szemben. Pl.

Még nem definiált szimbólum alkalmazása

Többszörösen definiált szimbólum alkalmazása A műveleti kódmezőben lévő kód nem megendegett műveleti kód

A műveleti kódnak túl kevés vagy túl sok operandus van megadva

Egy oktális számban előfordul pl. a 9-es számjegy

Jogtalan regiszterhasználat Hiányzó END utasítás



127.

47. Az include utasítás. Az include utasítás feldolgozása a fordítássorán.

Az assembler képes kezelni a több fájlra darabolt programokat is, a nyomkövetővel történő

használathoz az egész programnak egyetlen, egy „$” kiterjesztéssel rendelkező fá jlban kellelhelyezkedni. Ezen belül fájlok beillesztését a #include fájlnév paranccsal lehet kérni. Ebben az

esetben a kívánt fájl szintén a kombinált „$” fájlba íródik a kérés helyétől kezdődően. Az assembler

ellenőrzi, hogy a beillesztendő fájlt már feldolgozta-e, és csak egy példányt tölt be. Ez különösen

hasznos, ha több fájl ugyanazokat a fejlécfájlokat használja. Ilyenkor a kombinált forrásfájlba csak egy

példány kerül beillesztésre. A fájl beillesztéséhez szükséges, hogy a #include a sor első tokenje legyen

vezető szóközök nélkül, a fájl útvonalát pedig idézőjelek között kell megadnunk.

Ha csak egyetlen forrásfájlunk van, mondjuk a pr.s, akkor feltételezzük, hogy a projekt neve

pr, a kombinált fájl pedig a pr.$ lesz. Ha egynél több forrásfájlunk van, akkor az assembler az első fájl

nevének tövét tekinti a projekt nevének, és használja a .$ fájl definiálásához, amelyet utána aforrásfájlok összemásolásával állít elő. Ez a viselkedés felülbírálható a parancssoron az első forrásfájl

megadását megelőzően megadott „-o projname” kapcsolóval, amikor is a kombinált fájl a projname.$

lesz.

Megjegyezzük azonban, hogy a beillesztett fájlok, és egynél több forrásfájl használatánakvannak hátrányai is. A címkéknek, változóknak és konstansoknak az összes forrásban különbözőnekkell lenni. Ezen kívül, a ténylegesen fordításra kerülő fájl a projname.$, tehát arra vonatkoznak azassembler által a hibák és figyelmeztetések jelzésekor kiírt sorszámok. Nagyon kis projektek eseténnéha az a legegyszerűbb, ha az egész programot egyetlen fájlban helyezzük, és elkerüljük a #includehasználatát.



128.

48. Makró generátor

A makró generátor feladata a makró definíciók megjegyzése (pl. makró táblába helyezése) és

a makró hívások kifejtése. A makró generátor általában az assembler első menetében működik.

Az assembler sorról sorra megy végig a forrásprogramon. Ha eközben makródefiníciót talál (a

műveleti kód részen lévő MACRO szóról ismerhető fel), akkor a makró teljes szövegét (a makró végét

az ENDM szó jelzi) elhelyezi a makró táblában.

Amikor a makró a makrótáblába kerül, az assembler egy különleges jellel megjelöli a formális

paramétereket, ez az & jel. Igy majd a makróhívások során használhatunk paramétereket, amelyekkel

a meghívott makró dolgozni fog.

A makróhívások kifejtése során az assembler felismeri, hogy makrót talált a

forrásprogramban, megkeresi a makrót a makrótáblában, betölti egy pufferbe, majd a puffer

tartalmát beleilleszti a program szövegébe a megfelelő helyre.

A makrókifejtést a következő programrészlet ciklikus ismétlésével lehet illusztrálni:

EgySzoOlvasasaAMakroTorzsbol;

if FormalisParameter then

AmegfeleloSorszamuAktualisParameterAtmasolasa;

else

AszoAtmasolasa;

ElvalasztojelFeldolgozasa;

A makróhívásokkor jelentős probléma, hogy a makrón belüli címkék minden makróhíváskor

megjelennek a programban, és ezáltal címkeduplázódás (triplázódas stb, szóval ismétlés) jön létre,

ami fordítási hibát eredményez. Ezért a makrók fejléce után, a címke neve elé oda kell irni a LOCALpszeudoutasítást (a pszeudoutasítások egy másik tétel témaját képezik), ezzel azt érjük el, hogy a

makrógenerátor a címkét egy '??xxxx' alakú azonosítóval helyettesíti (xxxx változó, egy hexadecimális

szám), és minden szimbólum feldolgozása után a változót (vagyis xxxx-et) 1-gyel növeli. Így nem lép

majd fel címkeismétlés.



129.

49. Szerkesztő

Különböző operációs rendszerekben a szerkesztő elnevezései: Link, Linker, Linkage Editor,

Linkage Loader, stb. Alapvető feladata, hogy a programhoz tartozó object file-okat (modulokat)

egyetlen futtatható file-ba, a load modulba szerkessze. Eközben 4 feladatot kell megoldania:

az azonos nevű és osztályú szegmens-szeletek egymáshoz illesztése a szegmens-szeletek

definíciójában megadott módon,

a GROUP pszeudo utasítással egy csoportba sorolt szegmensek egymás után helyezése,

a relokációk elvégzése,

a külső hivatkozások (extern) feloldása.

A szerkesztő két menetben dolgozik: az első menetben táblázatokat készít, a második

menetben a táblázatokba elhelyezett információk alapján elvégzi a szerkesztést. Az egyik táblázat a

szegmens-szeletekre vonatkozó térkép (map), a másik a globális szimbólumok táblázata.

Az első menetben a szerkesztő beolvassa az összeszerkesztendő modulokat és közben kitölti

a map-et a kezdőcím és a relokációs konstans kivételével. Az összes modul beolvasása után a kívánt

szempontok (szegmens név, osztály, kombinációs típus, és a szerkesztő opcióiban előírt szempontok)

szerint rendezi a táblázat sorait, majd a kezdőcím és a relokációs konstans rovatot is ki tudja tölteni.

A legelső kezdőcím az operációs rendszertől függ (betöltési cím). Az egyes szegmens-szeleteknek és a

szegmens első szeletének a kezdőcíme közötti különbség lesz a relokációs konstans. Ezt az illető

szegmens-szeletben definiált szimbólumokra történő hivatkozások esetén hozzá kell adni a fodító

által előállított relokálandó címhez.

A globális szimbólumok kezeléséhez a fordítóprogram minden object modulban információt

ad át a modulban PUBLIC-ká és EXTERN-né nyilvánított változókról. A szerkesztő az első menetben a

PUBLIC változókból egy közös globális szimbólum táblát készít.

A PUBLIC utasítás nem tartalmazza a típust és a szegmens nevét, de az assembler ismeri, és el

tudja helyezni az object modulban. A modul nevét a szerkesztő is ismeri. A cím a táblázat

összeállításakor még relokálatlan címet jelent. Az első menetben ebben a táblázatban elvégezhető a

relokáció.

Az assembler az EXTERN utasítás alapján újabb táblázatot készít. Az első menetben kigyűjti a

szimbólumokat a hozzájuk tartozó típussal együtt, és ez alapján az első menet végén ellenőrzi, hogy

minden szimbólum előfordul-e közös globális szimbólum táblában. Ha nem, akkor definiálatlan külső

hivatkozások maradtak, ilyenkor az első menet további programkönyvtárbeli modulok hozzávételével

folytatódhat.

A szerkesztő a második menetben a rendezett térkép sorainak megfelelő sorrendben

beolvassa és elhelyezi a szegmens szeleteket, elvégzi a szükséges relokációt és feloldja a külső

hivatkozásokat. Utóbbi feladathoz egy-egy modul betöltésének végén a szerkesztő az EXTERN

szimbólumokat sorra megkeresi a közös public táblában. Ha megtalálta, akkor sorra veszi a

hivatkozásokat, és mindegyik hivatkozáshoz elhelyezi a PUBLIC táblában található címet. Ha az illető

szimbólum nem található meg a közös PUBLIC táblában, akkor „feloldatlan címkonstans” hibajelzést

ad.



130.

A szerkesztő lehetővé teszi, hogy egy nagyobb programot több modulban, esetleg különböző

programozási nyelveken írjunk meg. Segítségével lehetővé válik, hogy részfeladatok megoldásához

már korábban elkészített object modulokat használjunk fel.



131.

50. Time sharing (időosztás). binding (cím hozzárendelés),dinamikus szerkesztés

Egy időosztásos (time sharing) rendszerben (nagyobb léptékben nézve) egyidejűleg több

program fut. A program-kiválasztó (scheduler) feladata, hogy gondoskodjon arról, hogy mindegyikprogram elég sűrűn kapjon egy rövid CPU-időt. Egy program elindításakor többek között a következő

feladatokat kell végrehajtani: betöltés, indítás, felfüggesztés, kimentés; a program folytatásakor:

visszamentés, futtatás, felfüggesztés, kimentés. A kimentés – viszamentésre azért van szükség, mert

általában nem biztosítható hogy a visszamentett program a memóriának ugyanarra a területére

kerüljön vissza, ahol korábban futott. Ha pl. a programunk egy JMP L ugró utasítást tartalmaz, akkor

L-hez valamikor hozzá kell rendelnünk a konkrét címet, ez címhozzárendelés (binding).

A címhozzárendelés különböző időpontokban történhet. Ez alapján történhet:

Program írásakor Fordításkor

Szerkesztéskor

Betöltéskor

A címhez használt bázisregiszter kitöltésekor

Utasítás végrehajtásakor

Program írásakor: A számítástechnika kialakulásakor ez volt a helyzet, a programot bináris számokkal

kellett megadni. Manapság ez a módszer már ritka, de a lehetősége fellelhető a szegmens

definicióban alkalmazható AT kifejezés kombinációs típusban.

Fordításkor: Ma már ezt a módszert is igen ritkán alkalmazzák, pl. szintén az AT kifejezés kombinációs

tipussal kapcsolatban, ha a szegmensben szimbolikus címzést használnak. A címhozzárendelés ilyen

módjának a legnagyob hátránya hogy alkalmazása nehézzé, időnként lehetelenné teszi az így

elkészített program részek különböző programokban való felhasználását.

Szerkesztéskor: Ma ez a címhozzárendelás egyik legelterjedtebb módja.

Betöltéskor: Az assembly nem ezt a címhozzárendelési mószert használja. Ha ezt használná , a

programban nem szerepelhetne egyetlen FAR típusú címkonstans se, hiszen ennek az értéke a

betöltés helyétől függ.

A címhez használt bázisregiszter kitöltésekor: Ez a módszer már biztosítja az időosztásos

rendszerben futtatható programok elkészítését. Alkalmazása még komolyabb megszorításokat jelent.

A betöltések esetén is gondoskodni kell a FAR címeket tartalmazó változók helyes értékéről, sőt,

távoli eljárás hívás esetén FAR cím kerül a verembe, és természetesen ezzel is foglalkozni ke ll.

Megfelelően kialakított hardver sokat segíthet a probléma megoldásában.

Az utasítás végrehajtásakor: Ehhez a címhozzárendelést két lépésben valósítják meg, Először a

szimbolikus címzést virtuálissá alakítják, majd ezt fizikai címzéssé. A virtuális címhozzárendelés

történhet pl. szerkesztési időben, a fizikai cím hozzárendelés a lap (page) tábla kitöltésekor, ami

valóban gyakran az utasítás végrehajtásának megkezdése után történik.



132.

Dinamikus szerkesztés

Előfordulnak olyan nagyméretű programok, amelyekben bizonyos eljárások csak nagyon

ritkán szükségesek. Ha ezeket az eljárásokat is hozzászerkesztjük a programhoz, akkor a program

memóriaigénye nagyon nagy lehet. Ennek elkerülésére szolgál a dinamikus szerkesztés.

A dinamikus szerkesztés egy lehetséges megoldás, hogy a programban létrehozzunk egy

táblázatot (Linkage segment), amely minden esetleg szükséges eljáráshoz egy csatoló blokkot

tartalmaz. Minden blokk elején egy virtuális cím, a további részén az eljárás neve található

karaktersorozat formában. A virtuális cím lehet egy csatolóprogram címe vagy egy lehetetlen cím

(invalid adress). Az utóbbi esetben gondoskodnunk kell arról, hogy a létrejövő megszakítás hatására a

csatoló program kapja meg a vezérlést.

Multics dinamikus szerkesztése: minden programhoz egy úgynevezett kapcsolószegmenst társít,

amiben a hívható eljárások mindegyikének van egy információs blokkja. Az információs blokk elején

egy szó van fenntartva az eljárás virtuális címe számára, ezt az eljárás neve követi, amikarakterláncként tárolt.

A Windows dinamikus szerkesztése: a dinamikus szerkesztéshez egy speciális fájlformátumot

használ, amit DLL-nek (Dynamic Link Library) hívnak. A DLL-ek tartalmazhatnak eljárásokat, adatokat,

vagy mindkettőt. Rendszerint arra használják, hogy lehetőséget biztosítsanak két vagy több folyamat

számára a könyvtár ejárásainak és adatainak megosztott alkalmazására.

A UNIX dinamikus szerkesztése: lényegében hasonló a Windows DLL-es koncepciójához. Az általa

használt speciális fájlt megosztott könyvtárnak hívják. Egy megosztott könyvtár, a DLL fájlhoz

hasonlóan egy archivált fájl, ami megosztott eljárásokat vagy adatmodulokat tartalmaz, amelyek

futási időben vannk jelen a memóriában és a folyamatok számára egyidejűleg elérhetők.



51. Programok hangolása

Programhangoláson azt a folyamatot értjük, amikor megállapítjuk a kritikus programrészeket,

és ezek gyorsításával az egész program futását felgyorsítjuk. Bizonyított tény, hogy a nagyobb

programokban a program 1%-a felelős a program futási idejének kb. 50%-áért, 10%-a pedig a 90%-áért. A legritkább esetben célszerű egy feladatot teljes egészében assemblyben programozni, de ha a

program gyakran fut, akkor célszerű lehet a hangolás során bizonyos részeket assemblybe átírni.

A kritikus részek felderítésére használható a következő módszer. Miközben a hangolandó

programot nagy méretű feladaton vagy feladatokon futtatjuk, rövid, véletlen időnként, időzítés

szerinti megszakításokat kérünk. A megszakítások címét egy file-ban rögzítjük. Később a

megszakítások címét és a szerkesztő által összeállított memóriatérképet összevetve,

megállapíthatjuk, hogy mely eljárásokban történt a legtöbb megszakítás, ezekben az eljárásokban

tartózkodott legtöbbet a program. Ezeket az eljárásokat, eljárás részeket kell felgyorsítani pl.

Assembly betétekkel, vagy az egész eljárás assemblybe való átírásával.

A programhangolás hatásának szemléltetésére tételezzük fel, hogy ugyanannak a feladatnak

a megoldásához assemblyben 5-ször annyi utasításra (és időre) van szükség, mint probléma orientált

nyelv esetén, és az elkészült program 3-szor olyan gyors. A probléma orientált nyelven készült

változatának kritikus 10%-át assemblyben újraprogramozzuk. Egy kis számolás után beláthatjuk, hogy

a program problémaorientált nyelven történő elkészítésének és hangolásának ideje (és költsége) kb.

harmada annak, mintha az egészet assemblyben készítenénk, ugyanakkor a sebessége csak 20%-al

lassabb.

szar_tetelek

Documents