HARDVERKÖZELI PROGRAMOZÁS 1 Dr. Varga Imre Debreceni Egyetem Informatikai Rendszerek és Hálózatok Tanszék 2015.05.11
Követelmények Gyakorlat (aláírás) Óralátogatás (maximum hiányzás: 3) C programozási beugró (1 javítási lehetőség) 2 gyakorlati ZH • Mindegyik legalább 50% • A 2 ZH átlaga legalább 60%
1 javítási lehetőség (teljes féléves anyag)
Elmélet (kollokvium) Írásbeli vizsga (gyakorlati aláírás esetén) Jegy: 75% elméleti vizsga + 25% gyakorlati eredmény Hardverközeli programozás 1
2
Mérnökinformatikus képzés Döntéstámogató rendszerek absztakció, logikai szint
Mesterséges intelligencia alapjai Bevezetés a LabView programozásba Magas szintű programozási nyelvek 1-2 Hardverközeli programozás 1-2 Digitális technika Elektronika 1-2 Fizika 1-2 Hardverközeli programozás 1
3
Tematika Számábrázolás, adattípus implementáció Digitális elektronika alapjai CPU felépítése és működése Assembly programozás Magas szint leképezése alacsonyra
Modern processzorok A programozás operációsrendszerhez kapcsolódó aspektusai Konkrét processzor architektúrák Utasításkészletük, programozásuk Hardverközeli programozás 1
4
A tárgy célja Összeköttetés teremtése Az ’absztrakt’ és az ’alapozó’ ismeretek között A ‚program’ és az ‚elektronika’ között
Hardver ismeretek átadása Magas szintű programozás mélyebb megértése Hatékonyabb programozás
Az assembly programozás bemutatása Szemléletformálás Átfogó kép kialakítása a számítógép rendszerekről Hardverközeli programozás 1
5
Számábrázolás, adattípusok Fixpontos számábrázolás Lebegőpontos számábrázolás A C nyelv típusainak reprezentációja
Mi az outputja a programnak?
Hardverközeli programozás 1
7
Adatszervezés Adategységek Bit: két állapot (0, 1) Nibble (fél byte): 4 bit Byte: 8 bit Félszó: 16 bit Szó: (többnyire) 32 bit Dupla szó: 64 bit 18.446.744.073.709.551.616
4.294.967.296
Hardverközeli programozás 1
65.536
256 16 2
8
Adattípus Megadás Reprezentáció Tartomány Műveletek A C nyelv aritmetikai (egyszerű) típusai [unsigned|signed] char [unsigned|signed] [short|long|long long*] int float [long*] double *ISO C99 Hardverközeli programozás 1
9
Fixpontos számábrázolás Egész értékek reprezentálása Előjel nélküli eset ábrázolandó szám kettes számrendszerben adott számú biten
Példa (1 byte esetén) 4110 1010012 0 0 1 0 1 0 0 1 N biten ábrázolható legkisebb szám: 0 Legnagyobb szám: 2N-1 Hardverközeli programozás 1
10
Fixpontos számábrázolás Előjeles eset Nem negatív érték esetén: előjel nélküli logika Negatív érték esetén: kettes komplemens • Bitek invertálása (egyes komplemens) • A kapott érték növelése 1-gyel
Példa (1 byte esetén) -4110 -1010012 N biten ábrázolható
1 1 0 1 0 1 1 1 meghatározza az előjelet
legkisebb szám: -(2N-1) Legnagyobb szám: 2N-1-1 Hardverközeli programozás 1
11
Aritmetikai túlcsordulás Két féle hibalehetőség Előjel nélkül: több bit lenne szükséges (carry) 01011010 90 +11110001 +241 101001011 331 >255 Előjeles: nem várt előjelváltás (overflow) 01011010 90 +01110001 +113 11001011 -53 ≠203 Hardverközeli programozás 1
12
Kiterjesztés Néha szükség van egy adatot a korábbinál több biten ábrázolni úgy, hogy az értéke ne változzon Nulla kiterjesztés Rövid előjel nélküli értékből hosszú előjelnélküli 8 bit: 01101001 16 bit: 0000000001101001 8 bit: 11010010 16 bit: 0000000011010010
Előjel tartó kiterjesztés Rövid előjeles értékből hosszú előjeles 8 bit: 01101001 16 bit: 0000000001101001 8 bit: 11010010 16 bit: 1111111111010010 Hardverközeli programozás 1
13
BCD ábrázolás Binárisan kódolt decimális Minden számjegy 4 biten ábrázolva Vannak kihasználatlan bitkombinációk Pakolatlan BCD 1 számjegy - 1 byte: 0000 vagy (0011*) bevezető 1395
00000001 00000011 00001001 00000101
Pakolt BCD 2 számjegy – 1 byte: nibble alapú 1395
00010011 10010101 Hardverközeli programozás 1
*ASCII miatt 14
Egész típus Ábrázolás Fixpontos számábrázolás Előjeles vagy előjel nélküli
BCD Bájtsorrend Little-endian: LSB elől (gazdagép bájtsorrend) Big-endian: MSB elől (hálózati bájtsorrend) Megadás különböző módokon Pl. C nyelven: 30=30u=30l=036=0x1E=0b11110* *ISO C99 Hardverközeli programozás 1
15
Karakter típus Értékei karakter kódok Fixpontos számábrázolás C: ASCII (1 byte, előjeles/előjel nélküli, egészként használható) Java: Unicode (2byte, előjel nélküli)
ASCII ⊂ ISO-8859-1 (Latin 1) ⊂ Unicode ASCII kódtábla 0x00-0x1F: vezérlő karakter 0x30-0x39: számjegy 0x41-0x5A: angol nagy betű 0x61-0x7A: angol kis betű Hardverközeli programozás 1
16
Felsorolásos típus Alacsony szinten int-ként reprezentált C nyelven a két kód assembly szinten azonos
Hardverközeli programozás 1
17
A C egész típusai típus
méret
tartomány
[signed] char unsigned char
[signed] long unsigned long
255
-32.768
32.767
0
65.536
-2.147.483.648
2.147.483.647
0
4.294.967.296
-9.223.372.036.854.775.808
9.223.372.036.854.775.807
4 byte 8 byte (4 byte)
[signed] long long unsigned long long
0
2 byte
[signed] int unsigned int
127
1 byte
[signed] short unsigned short
-128
0 18.446.744.073.709.551.615 -9.223.372.036.854.775.808
8 byte
9.223.372.036.854.775.807
0 18.446.744.073.709.551.615 Hardverközeli programozás 1
18
Lebegő pontos számábrázolás Valós számok ábrázolása Alapja a normalizálás: 123,45 = 1,2345 · 102 Minden (2 számrendszerbeli) szám felírható így: (-1)S · M · AK ahol a mantissza (M) „1.H” alakú, azaz 12 ≤ M < 102 karakterisztika (K) pozitív és negatív is lehet
Nem tároljuk: alap (A=2), rejtett bit, K előjele E=K+B adott számú biten nem negatív (B: nulla pont)
Tárolandó: S, H, E Hardverközeli programozás 1
19
Lebegő pontos szabvány IEEE 754/1985 szabvány (ISO/IEC/IEEE 60559:2011) Előjel Pozitív: 0; Negatív: 1
Formátumok méret
S hossz
E hossz
H hossz
B
Egyszeres pontosság
32 bit
1 bit
8 bit
23 bit
127
Dupla pontosság
64 bit
1 bit
11 bit
52 bit
1023
Kiterjesztett pontosság
80 bit
1 bit
15 bit
63(+1) bit
16383
Hardverközeli programozás 1
20
Lebegő pontos számábrázolás Példa: -13.8125 egyszeres pontossággal -13.812510 = -1101.11012 = -11 · 1.1011101 · 23 Előjel: S = 1 Karakterisztika: K = 310 = 112 Mantissza: M = 1.1011101 Hasznos bitek: H = 10111010000000000000000… Eltolt karakterisztika: E = 310+12710 = 100000102 1 1 0 0 0 0 0 1 0 1 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S
E
H Hardverközeli programozás 1
21
Kerekítési hiba Ok: hasznos bitek tárolás véges számú biten Túl sok hasznos bit esetén kerekítés szükséges Ha az utolsó tárolható hasznos bit után ’0’ áll, akkor a további biteket levágjuk Különben felfelé kerekítünk
Kerekítési hiba: nem pontos ábrázolás Példa: 0.3 ábrázolása egyszeres pontossággal hasznos bitek: 00110011001100110011001100110… tárolt bitek: 00110011001100110011010 0.3 0.300000011920929 Hardverközeli programozás 1
22
Speciális lebegőpontos értékek +0 és -0 előjel bit ’0’ (+) vagy ’1’ (-), minden más bit ’0’ Pl.: 0.0/-1.0, -1.0*0.0
±végtelen (Inf) karakterisztika csupa ’1’, mantissza csupa ’0’ Pl.: 1.0/0.0, inf+1.0
„nem szám” (NaN) karakterisztika csupa ’1’, mantissza nem csupa ’0’ Pl.: 0.0/0.0, inf-inf, NaN+1.0
denormalizált szám (subnormal) karakterisztika csupa ’0’, mantissza nem csupa ’0’ Hardverközeli programozás 1
23
A C nyelv valós típusai Valós típusú konstansok formátuma .751f 0.751L 0.751 75.1e-2 0.0751E+1 +.75100 Valós típusok paraméterei méret
minimum
maximum
pontosság
float
4 byte
1.18 · 10-38
3.40 · 10+38
≈7 számjegy
double
8 byte
2.23 · 10-308
1.80 · 10+308 ≈15 számjegy
long double*
10 byte 3.36 · 10-4932 1.19 · 10+4932 ≈19 számjegy Hardverközeli programozás 1
24
Mutató típus Indirekt hivatkozásra szolgálnak Tartományának elemei tárcímek A mutató típusú változónak is van saját címe A C nyelvben Előjel nélküli egész reprezentáció (32 vagy 64 bit) NULL: csupa nulla bit Értéke adatcím és kódcím (!) is lehet Aritmetikai műveletek is végezhetőek velük
Hardverközeli programozás 1
25
Rekord típus Különböző típusú területek együtt Mindegyik mező a saját reprezentációjával Nem biztos, hogy folytonos memóriaterületen A.a
A.b
A.c A.d
sizeof(A)==16
B.d
B.a
sizeof(B)==24 Hardverközeli programozás 1
B.c
B.b
nem használt byte 26
Tömb típus Azonos típusú elemek folytonosan tárolva Minden elem az adott reprezentációval A tömb neve C nyelven: az első elemre mutató nevesített konstans Egyes nyelveken: az összes elemre hivatkozás
Egydimenziós tömb i. elemének a címe (Ai) 1 ahol E egy adatelem mérete és A1 a tömb kezdőcíme Hardverközeli programozás 1
27
Több dimenziós tömbök Sorfolytonos tárolás ,
,
,
,
,
,
,
→
,
,
,
,
,
,
Az i. sor j. elemének címe (Ai,j) egy NxM-es mátrixban , 1 j 1 E , ahol E egy adatelem mérete és A1,1 a mátrix első elemének címe Hardverközeli programozás 1
28
Sztring típus Karakterek sorozata Elemei a megfelelő belső reprezentációban (pl. C: 1byte, ASCII; Java: 2 byte, Unicode) Hossza Fix hosszúságú Változó hosszúságú • A sztring elején hossz tárolás (pl. Pascal) • A sztring végén speciális lezárójel (pl. C) • Kombinált (pl. Delphi)
Hardverközeli programozás 1
29
A C nyelv tömbje Tömb index 0-tól (db-1)-ig Csak egydimenziós tömb van, viszont van tömbök tömbje Sztring: karaktertömb Lezáró karakter ’\0’ (ASCII kód: 0)
A tömb neve az első elemre mutató nevesített konstans (mutatóorientáltság erős) egyenértékű utasítások Hardverközeli programozás 1
30
Digitális elektronikai alapok Félvezető Dióda, tranzisztor Logikai kapu Flip-flop Multiplexer, címdekódoló Összeadó áramkör
Félvezetők atomban elektron energia
„Rossz vezető, rossz szigetelő” Ok: szilárdtestek sávszerkezete 4 vegyérték elektron (Si, Ge) Kvantumfizika Bohr-féle atommodell
vezető
elektron energia
elektron energia
elektron energia
szilárdtestben
félvezető Hardverközeli programozás 1
vezetési sáv tiltott sáv vegyérték sáv
szigetelő 32
Szennyezett félvezető n-szennyező (elektron) elektron energia
5 vegyérték elektron (As, Sb)
p-szennyező (’lyuk’) 3 vegyérték elektron (Ga, In)
Új energiaszint a tiltott sávban Si Si Si
Si As Si
Si
-
Si
+
-
Si Si
-
+
+
Si Si
n-típus
Si Ga
Si
Si
+
+
-
Si
+
-
-
Si
p-típus Hardverközeli programozás 1
33
p-n átmenet Félvezető egykristály eltérően szennyezett részei között található Szabad töltéshordozók átáramlanak a másik rétegbe, rekombinálódhatnak. n
- - + + + + + - - + + + + + - - + + + + + - - + + +
töltéssűrűség
+ +
+
+ + + - - - + + + - - - + + + - - - + + + - - - -
-
kiürített réteg p
-
elektrosztatikus potenciál
potenciálgát Hardverközeli programozás 1
34
Dióda Záró irányú előfeszítés -
+
-
+ + + + + - + + + + + - + + + + + - + + + + +
-
- -
- -
-
+ + + - - + + + - - + + + - - + + + - - + + +
Nyitó irányú előfeszítés - -
-
+ + + - - + + + - - + + + - - + + +
-
+
- -
+ + + + - - - - + + + + - - - - + + + + - - - - + + + + - - - - -
+ + - + + + - + + - + + +
Dióda: egyenirányításra képes Jele: Speciális: LED Hardverközeli programozás 1
35
Tranzisztor 2 darab p-n átmenet („összefordított diódák”) p n n p Kapcsoló, erősítő Bipoláris tranzisztor E
Unipoláris tranzisztor
B C
D
p n p
G
S
p n p
C
S G
B
D
E n-csatornás JFET Hardverközeli programozás 1
36
A logikai NAND kapu 2 bemenetű logikai kapu („nem és”) Jele: Felépítése, működése: Vcc
A Q B
TTL NAND kapu
GND Hardverközeli programozás 1
A
B
Q
0
0
1
0
1
1
1
0
1
1
1
0
37
További logikai kapuk Felépíthetőek NAND kapukból OR NOT AND
XOR
A
Q
A
B
Q
A
B
Q
A
B
Q
0
1
0
0
0
0
0
0
0
0
0
1
0
0
1
0
0
1
1
0
1
1
1
0
0
1
0
1
1
0
1
1
1
1
1
1
1
1
1
0
Hardverközeli programozás 1
38
Flip-flopok Szekvenciális digitális elektronikai áramkör 1 bit információ tárolására képes Alkalmazás: regiszter, számláló, frekvenciaosztó adat kimenet
D
Q
_
CLK
Q
CLK adat bemenet
D flip-flop
4 bites regiszter Hardverközeli programozás 1
39
Multiplexer Kombinációs hálózat N jelből 1-et kiválaszt a vezérlőjelek alapján D K darab vezérlőjel 2K darab bemenő C jelet tud azonosítani
Z
B
S0
S1
Z
0
0
A
0
1
B
1
0
C
1
1
D
A
S0 Hardverközeli programozás 1
S1
4:1 multiplexer 40
Címdekódoló Kombinációs hálózat A címbemenetre adott jel alapján kiválasztja a kimenő jelek egyikét D0 N bites címbemenetre adott D1 N érték a 2 darab kimeneti D2 vonal közül 1-et aktivál A0
A1
D0
D1
D2
D3
0
0
0
0
0
1
0
1
0
0
1
0
1
0
0
1
0
0
1
1
1
0
0
0
Hardverközeli programozás 1
D3
A0
A1 2 bites címdekódoló 41
Összeadó áramkör AB
Félösszeadó: 2 bit összeadására képes C
Teljes összeadó: 3 bit összeadására képes (2 félösszeadó)
A
B
Ci
Co
S
0
0
0
0
0
0
1
0
0
1
1
0
0
0
1
1
1
0
1
0
0
0
1
0
1
0
1
1
1
0
1
0
1
1
0
1
1
1
1
1
S
A B C
S
0
0
0
0
0
1
0
1
1
0
0
1
1
1
1
0
AB
Cout
Cin
S Hardverközeli programozás 1
42
Ripple-carry összeadó Több bites adatok összeadására képes Láncba fűzött teljes összeadók A3 B3 A2 B2 A1 B1 A0 B0 C
+
+
+
+
S3
S2
S3
S2
0
teljes összeadó
A3 A2 A1 A0 c
+
B3 B2 B1 B0 +
+
+
S3 S2 S1 S0 „primitív 4 bites ALU kezdemény” Hardverközeli programozás 1
43
A processzorok felépítése Számítógép architektúra CPU Regiszterek Fetch-execute ciklus RISC / CISC processzorok
Számítógép rétegmodell 0. szint: digitális logikai áramkörök (logikai kapu, flip-flop) 1. szint: mikro-architektúra (konkrét ALU, buszok) 2. szint: utasításkészlet architektúra (ISA) 3. szint: operációs rendszer (ütemezés, tárkezelés) 4. szint: programozási nyelvek (alkalmazások) Hardverközeli programozás 1
45
Neumann architektúra Princeton architektúra (Neumann János) Neumann elvek (1945): Elektronikus működés Kettes számrendszer használata Tárolt program elve Adat és program tárolás ugyanott/ugyanúgy
Soros programvégrehajtás Univerzális felhasználhatóság Hardverközeli programozás 1
46
Harvard architektúra Külön adat és program memória Eltérő felépítés, címtartomány, típus is lehet
Párhuzamos adat és utasítás elérés miatt nagyobb teljesítmény Főként mikrokontrollerekben használt Első alkalmazás: Mark I (1944) Módosított Harvard architektúra Külön adat/utasítás gyorsítótár, közös memória Modern CPU-k esetén elterjedt Hardverközeli programozás 1
47
A számítógép alapvető felépítése Processzor Memória Input-Output interfész Buszrendszer Perifériák Processzor
Memória
Perifériák
I/O interfész
Buszrendszer Hardverközeli programozás 1
48
Buszrendszer Busz (sín): vezetékek egy csoportja, amelyeken digitális jelet lehet továbbítani Buszrendszer logikai részei Címbusz: a címek bitsorozatának átvitelét biztosítja Adatbusz: adatok átviteléért felelős Vezérlő busz: részegységek működésének összehangolását segítő vezérlő jelek továbbítása Processzor
Memória
I/O interfész
címbusz adatbusz vezérlő busz Hardverközeli programozás 1
49
Processzor Központi feldolgozó egység (CPU) A számítógép „agya” Vezérlés, utasítás végrehajtás
Részei: Vezérlő egység (CU)
Végrehajtó Aritmetikai és logikai egység (ALU) egység (EU)
Címző egység (AU) és Busz illesztő egység (BIU) Regiszterek Belső gyorsítótár Hardverközeli programozás 1
50
Regiszterek Kis méretű (flip-flop-szerű) tároló áramkör Mérete általában az adatbusz szélességével egyenlő Általában 8-512 bit
Gyors hozzáférésű (elérési idő < 1ns) Darabszámát a processzor határozza meg (10-100) Gyakran regisztertömböket alkot Néha átnevezhetőek 3 kategória: Rendszer- , általános célú- és speciális célú regiszter Hardverközeli programozás 1
51
Regiszterek Programszámláló regiszter (PC vagy IP) A következő utasítás memóriacímét tartalmazza Az utasítás végrehajtása során (általában) átáll a következő utasítás címére, azaz az aktuális utasítás méretével növekszik Szekvenciális végrehajtás eszköze Értékét egyes utasítások is állíthatják (vezérlés átadás) Vezérlőegységhez (CU) kapcsolódik Hardverközeli programozás 1
52
Regiszterek Utasítás regiszter (IR) A memóriából beolvasott utasítás műveleti kódját tartalmazza A vezérlőegységhez kapcsolódik A CU ez alapján dönti el milyen műveletet kell végeztetni milyen adaton kell dolgozni (és az hol van)
A programozó által nem hozzáférhető Hardverközeli programozás 1
53
Regiszterek Akkumulátor (ACC, W, AX) Általános munka regiszter az ALU-ban Aritmetikai és logikai műveletek operandusait tartalmazza legtöbbször Általában az ilyen műveletek eredménye is itt tárolódik Újabb processzorokban több hasonló regiszter ugyanerre a célra (kevesebb memória művelet) Általában egész típusú adatokat tartalmaznak Hardverközeli programozás 1
54
Regiszterek Állapot regiszter (SR, FLAGS) Processzor állapottal, művelet eredményével kapcsolatos jelző/vezérlő biteket tartalmaz Feltételes vezérlésátadásnál (is) nagyon fontos Átvitel (CF) Nibble átvitel (AF) Túlcsordulás (OF) Előjel (SF)
Megszakítási maszk (IF) Nulla (ZF) Paritás (PF) …
Hardverközeli programozás 1
55
Regiszterek Verem mutató regiszter (SP) A hardveres rendszerverem használatához A verem tetejének memóriacímét tartalmazza Általában a verem előrefelé nő Általában SP a legutóbb betett elemet címzi (Intel)
Speciális célú regiszter A „push” és „pop” művelet automatikusan változtatja az SP értékét Hardverközeli programozás 1
56
Regiszterek Címzéssel kapcsolatos speciális regiszterek Operandusok címének meghatározásánál egy alap címhez képesti relatív cím (eltolás) megadásához használható Az AU-hoz kapcsolódnak Tömbök, sztringek és lokális változók esetén hasznos Például: BP, X, SI, DI, CS, DS, SS, ES Hardverközeli programozás 1
57
Regiszterek Memória cím regiszter (MAR) Összeköti a külső és belső címbuszt Azt a címet tartalmazza, amelyhez legközelebb hozzá kell férni (írásra vagy olvasásra) A címző egység hajtja meg Címbusz szélességű
Hardverközeli programozás 1
58
Regiszterek Memória adat regiszter (MDR) Összeköti a külső és belső adatbuszt Azt az adatot tartalmazza amelyet legközelebb ki kell írni a memóriába vagy amely legutóbb be lett olvasva a memóriából
Kétirányú regiszter Adatbusz szélességű
Hardverközeli programozás 1
59
Aritmetikai és logikai egység Számítási műveleteket végez Tartalmaz: fixpontos összeadót, komplemens képzőt, léptető regisztereket, bitenkénti logikai művelet végző, stb. áramköröket A operandus
utasítás
B operandus
ALU
állapot
eredmény Hardverközeli programozás 1
60
Vezérlő egység Az IR-ben lévő érték alapján irányítja, szabályozza a többi egység (pl. ALU) működését Fontos regiszterei: IR, PC, SR A vezérlés történhet Huzalozott logikával (közvetlenül) Minden utasításhoz létrehozott bonyolult digitális elektronika segítségével Mikroprogramozott (közvetett) módon Minden műveleti kód elindít egy apró (ROM-ban tárolt) mikroprogramot Hardverközeli programozás 1
61
Címző egység Addressing Unit (AU), Address Generation Unit (AGU) Az utasítások sokféle címzési mód segítségével határozhatják meg hol található az operandus Az AU az operandus címét állítja elő és helyezi el az MAR-ban Az utasításban található címet képezi le fizikai memóriacímre Tárolóvédelmi hibák felismerése Kapcsolat: BIU Hardverközeli programozás 1
62
Órajel Periodikus négyszög hullám Órajel generátor (oszcillátor) állítja elő Szinkronizálja az egységek működését Arányos a CPU által disszipált hővel Periódusidő nagyobb, mint a jelterjedési idő 1 MHz – 3 GHz Gyakran változtatható (turbo, powersave) Egyéb sebesség jellemzők: MIPS, FLOPS Hardverközeli programozás 1
63
CISC processzor Komplex utasításkészletű számítógép Sok, összetett utasítás Sokféle címzési mód Változó hosszúságú utasítások Utasítás több gépi ciklust igényel Mikroprogramotott Kevés regiszter Utasítások elérhetik közvetlenül a RAM-ot Hardverközeli programozás 1
64
RISC processzor Csökkentett utasításkészletű számítógép Kevés, egyszerű utasítás Kevés címzési mód Állandó hosszúságú utasítások Utasítás egy gépi ciklust igényel Huzalozott vagy mikroprogramotott Sok regiszter Csak a Load/Store utasítás éri el a RAM-ot Hardverközeli programozás 1
65
Fetch-Execute ciklus 1.
2.
Utasítás beolvasása A PC-ben található érték megmondja, hol található a memóriában a következő utasítás. Ezt be kell olvasni az IR-be. Dekódolás A beolvasott műveleti kódot értelmezni kell. Milyen művelet? Milyen adatokon? Eredmény hová kerül? Utasításkészlet architektúra (ISA) definiálja Lehet huzalozott vagy mikroprogramozott Hardverközeli programozás 1
66
Fetch-Execute ciklus 3.
4.
5.
6.
Operandus beolvasása Az operandus címének meghatározása és onnan beolvasása a megfelelő regiszterbe Művelet végrehajtása például az ALU által, az eredmény egy átmenti regiszterbe kerül Eredmény tárolás regiszterbe vagy memóriacímre Következő utasítás címének meghatározása Hardverközeli programozás 1
67
Olvasási ciklus DIY Calculator esetén
C. Maxfield, A. Brown: The Official DIY Calculator Data Book Hardverközeli programozás 1
68
Írási ciklus DIY Calculator esetén
C. Maxfield, A. Brown: The Official DIY Calculator Data Book Hardverközeli programozás 1
69
Assembly programozás Assembly nyelv Utasítás készlet Címzési módok Fordítás-szerkesztés-betöltés Gépi kód
Assembly programozás Alacsony absztrakciós szint Programozói szabadság Feladatra optimalizálható kód Nagyobb program teljesítmény Hardverismeret szükség Nehezebben átlátható kód PC, mikrokontroller
Magasszintű programnyelvek Assembly programozás Gépi kód
Hardverközeli programozás 1
71
Utasítás szerkezet 4 címes utasítás Műveleti kód
1. Operandus cím
2. Operandus cím
Eredmény cím
2. Operandus cím
Eredmény cím
Következő utasítás cím
3 címes utasítás Műveleti kód
1. Operandus cím
2 címes utasítás Műveleti kód
1. Operandus cím
2. Operandus + eredmény cím
1 címes utasítás Műveleti kód
1. Operandus cím
Hardverközeli programozás 1
72
Program és utasítás felépítés Forrás fájl utasítás_1 utasítás_2 utasítás_3
Címke
Művelet
Operandus(ok)
Megjegyzés
.L1:
mov
ax, 0
# zero to ax
utasítás_4 utasítás_5 …
Címke
Azonosító, általában kettősponttal zárul
Művelet
Az elvégzendő művelet mnemonic-ja
Operandus(ok) Adat(ok) vagy adat(ok)ra hivatkozás(ok) Megjegyzés
Sor végéig a fordító figyelmen kívül hagyja
Hardverközeli programozás 1
73
Utasításkészlet architektúra ISA (Instruction Set Architecture) A számítógép programozáshoz kötődő részletei Bitszélesség (buszok és regiszterek) Regiszter készlet Gépi utasítások Címzési módok Memória architektúra Megszakítás kezelés Hardverközeli programozás 1
74
Utasítás típusok Adatmozgató utasítások (Egész) aritmetikai utasítások Bitenkénti logikai utasítások Bitléptető utasítások Vezérlésátadó utasítások Sztringkezelő utasítások BCD és valós aritmetikai utasítások Fordítási direktívák Egyéb utasítások Hardverközeli programozás 1
75
Utasítás típusok Adatmozgató utasítások Regiszter-regiszter (mov, xchg) Regiszter-memória (mov) Regiszter-I/O port (in, out) Regiszter-verem (push, pop) Kiterjesztés (bitszélesség fontos) (cbw, cwd) Státusz bit állítás (sti, cli)
Hardverközeli programozás 1
76
Utasítás típusok Aritmetikai utasítások Összeadás (átvitel nélkül/átvitellel) (add, adc) Kivonás (átvitel nélkül/átvitellel) (sub, sbb) Inkrementálás, dekrementálás (inc, dec) Kettes komplemens (neg) Előjeltelen/előjeles szorzás (mul, imul) Előjeltelen/előjeles osztás (div, idiv) Összehasonlítás (cmp) Hardverközeli programozás 1
77
Utasítás típusok Bitenkénti logikai utasítások ÉS művelet (and) VAGY művelet (or) KIZÁRÓ VAGY művelet (xor) Egyes komplemens (not) Bit tesztelés (test)
Hardverközeli programozás 1
78
Utasítás típusok Bitléptető utasítások Logikai/előjeltelen balra léptetés (shl) Logikai/előjeltelen jobbra léptetés (shr) Aritmetikai/előjeles balra léptetés (sal=shl) Aritmetikai/előjeles jobbra léptetés (sar) Jobbra/balra forgatás (ror, rol) Jobbra/balra forgatás carry-n keresztül (rcr, rcl)
Hardverközeli programozás 1
79
Utasítás típusok Vezérlésátadó utasítások Feltétel nélküli ugrás (jmp) Feltételes ugrás (ja, jae, jb, jbe, je, jne, jc, jo, …) Ciklusszervező (loop, loopz, loopnz, …) Hívó utasítás (call) Szubrutinból visszatérés (ret) Szoftveres megszakítás kérés (int) Megszakítás-kezelőből visszatérés (iret) Hardverközeli programozás 1
80
Utasítás típusok Stringkezelő (byte-sorozat kezelő) utasítások Sztring mozgató (movs, movsb, movsw) Sztring összehasonlító (cmps) Keresés sztringben (scas) Egyéb utasítások Koprocesszor vezérlő (wait, esc) Rendszervezérlő (hlt) Üres utasítás (nop) Hardverközeli programozás 1
81
Utasítás típusok Fordítási direktívák: gépi kód nincs mögöttük, a fordítás menetét befolyásolják Forrásfájl lezárása (end) Szegmens definiálás (segment, ends) Egyszerűsített szegmensdefiníció (stack, .data) Helyfoglalás (db, dw, dd) Helyettesítő szimbólum létrehozás (equ) … Hardverközeli programozás 1
82
Címzési módok Adat vagy utasítás hogyan érhető el. Rejtett (implicit, implied) Közvetlen adat megadás (immediate) Közvetlen cím (direct, absolute) Regiszteres cím (register direct) Közvetett cím (indirekt) Regiszter indirekt Indexelt cím Bázis relatív cím … Hardverközeli programozás 1
83
Címzési módok Rejtett címzés Nincs igazi cím megadás Pl. ha nincs operandus
500 501 Op.kód1 502 Op-kód2 503
Hardverközeli programozás 1
84
Címzési módok Közvetlen adat megadás Műveleti kód után közvetlenül található adat Ez lesz az operandus
500 501
Op.kód
502
Adat
503
Hardverközeli programozás 1
85
Címzési módok Regiszteres címzés A műveleti kód hivatkozik egy regiszterre A regiszterben található az operandus értéke regiszter 500 501
Adat Op.kód
502 503
Hardverközeli programozás 1
86
Címzési módok Közvetlen cím Műveleti kód után található egy memóriacím Itt helyezkedik el az operandus
500 501
Op.kód
730 731
502
731
732
503
Adat
733
Hardverközeli programozás 1
87
Címzési módok Közvetett cím A műveleti kód után található egy cím Ezen a címen található az operandus igazi címe
500 501
Op.kód
730 731
502
731
732
945
733
946
503
945
Hardverközeli programozás 1
943 944 Adat
88
Címzési módok Regiszter indirekt A műveleti kód hivatkozik egy regiszterre A regiszterben található címen helyezkedik el az operandus memóriacíme regiszter 500 501
731 Op.kód
730 731
502
732
503
733
Adat
Hardverközeli programozás 1
89
Címzési módok Indexelt A műveleti kód után található egy cím, ehhez hozzáadva az index regiszterben található értéket megkapjuk az operandus memóriacímét index reg. 31
500 501
Op.kód
730 731
502
700
732
503
Adat
733
Hardverközeli programozás 1
90
Címzési módok Bázis relatív A műveleti kód után található egy eltolási érték, ehhez hozzáadva a bázis regiszterben található kezdőcímet megkapjuk az operandus címét bázis reg. 720
500 501
Op.kód
730 731
502
11
732
503
Adat
733
Hardverközeli programozás 1
91
Gépi kód Az egyetlen nyelv, amit a processzor megért Bináris formátum Processzoronként változó lehet Példa: assembly: SUB EAX, EBX # eax = eax-ebx gépi kód: 0x29 0xD8 0
0
1
0
1
OpKód SUB művelet
Regiszter a forrás
0
0
1
1
d
s
MOD
32 bites regiszter
1
0
1 REG
Regiszteres címzés
Hardverközeli programozás 1
1
0
0
0
R/M Forrás: EBX
Cél: EAX 92
Programozás Editor Szövegszerkesztőben forráskód létrehozása Forrás kód: háttértárolón tárolt szöveges file Esetleg nyelv érzékeny eszközrendszer Fordító (compiler, assembler) Előfeldolgozás, lexikai/szintaktikai/szemantikai elemzés, optimalizálás, kódgenerálás Eredmény: tárgykód (ojbect file) Nem interpreter! Hardverközeli programozás 1
93
Programozás Kapcsolatszerkesztő (linker) A tárgykódban nem igazi címek, csak hivatkozások vannak (több fájl, könyvtári függv.) Linker feloldja a hivatkozásokat: futtatható fájl Betöltő (loader) Az op. rendszer része: létrehozza a folyamatot RAM-ba tölti a gépi kódot Inicializál: regiszterek, verem Átadja a vezérlést Hardverközeli programozás 1
94
Magasszintű programozás leképezése assembly-re 1. Programozás alapjai Kifejezéskiértékelés Elágaztatás Ciklusszervezés
Gondolatébresztő kérdések Melyik értékadás fut le rövidebb idő alatt? int a, b=2, c=3, d=4, e=1, f=2; a=(b+c)*(d-e)%f; a=(2+3)*(4-1)%2; a=5; Mi az alábbi kifejezés értéke? (!3+8==2*4)+-1 Mi az alábbi kifejezés típusa? 5/(short)2==.5+’2’ Hardverközeli programozás 1
96
Gondolatébresztő kérdések Ki/mikor/hogyan végzi a kifejezés kiértékelést? Van címe a konstansnak? Van-e különbség a #define és a const között? Kétirányú elágaztatásnak minősül-e az if (a==0) b=0; utasítás? Hányszor fut le az alábbi ciklus magja? for(a<1,b=1;c++;d=1) e=1;
Hardverközeli programozás 1
97
Karakterkészlet Lexikális egység Szintaktikai egység Utasítás Programegység Fordítási egység Program
Komplexitás nő
A forráskód alkotórészei
Hardverközeli programozás 1
98
Konstans (literál) Közvetlen adat megadás (immediate) Kódba épített adat 8, 16, 32, 64 bit szélességű Fix vagy lebegőpontos ábrázolás Magas szinten: 123, 1.25f, ’a’ Alacsony szinten: 0x0000007b, 0x3fa00000, 0x61 Hardverközeli programozás 1
99
Nevesített konstans Komponensei: név, típus, érték #define abc 123 Előfordító kicseréli a nevet az értékre Kódba épített adat Assembly szinten egyszerű konstans const int abc=123; A fordító nem engedi a változtatást Assembly szinten egyszerű változó Hardverközeli programozás 1
100
Változó Komponensei: név, attribútum, cím, érték Hatáskör: statikus, dinamikus Deklaráció: explicit, implicit, automatikus Élettartam: statikus, dinamikus, programozó által vezérelt Értékadás: kezdőértékadás (automatikus, explicit), értékadó utasítás, paraméterátadás, input utasítás Hardverközeli programozás 1
101
Változó Alacsony szinten Adott méretű lefoglalt memóriaterület Ha van cím komponens mindig van érték is Érték: bitsorozat (tetszőleges értelmezéssel) Értékadás: memóriacímre adat mozgatás Statikus változó adat szegmensben Dinamikus változó verem szegmensben Programozó által vezérelt a heap-ben Mutató: előjel nélküli egész változó C-ben Hardverközeli programozás 1
102
Kifejezés Komponensei: típus, érték Formálisan: operátor, operandus és zárójel Operátor: uniáris, bináris, ternáris Alak: infix (2+3)*4 perfix *+234 postfix (RPN) 23+4* Infix alak esetén nem egyértelmű kiértékelés: precendencia és kötésirány kell Típusegyenértékűség vagy típuskényszerítés Hardverközeli programozás 1
103
Kifejezés kiértékelés A kifejezés értékének, típusának meghatározása Konstans kifejezést a fordító értékel ki Nem konstans infix kifejezést a fordító postfix alakra hozza (figyelembe véve a zárójeleket, precedenciát és a kötésirányt) és az alapján állítja elő a gépi kódot imul ebx, ecx eax + ebx * ecx & edx add eax, ebx and eax, edx Hardverközeli programozás 1
104
Utasítások Deklarációs utasítás Nem áll mögötte gépi kód A fordítóprogramnak szól Végrehajtható utasítás Egy magas szintű utasításból több gépi kódú utasítást is előállíthat a fordító Csoportjai: üres, értékadó, ugró, elágaztató, ciklusszervező, hívó, egyéb Hardverközeli programozás 1
105
Elágaztató utasítás Kétirányú elágaztató utasítás C nyelven: if (kifejezés) utasítás1; [else utatsítás2;]
Többirányú elágaztató utasítás C nyelven: switch(kifejezés){ case egész_konstans_kif_1: [utasítás1;] [case egész_konstans_kif_2: [utasítás2;]] [default: utasítás3;] } Hardverközeli programozás 1
106
A feltételes utasítás alacsony szinten if (feltétel) utasítás1; utasítás2; if (feltétel) utasítás1; else utasítás2; utasítás3;
cmp jne mov .L0: add cmp jne mov jmp .L2: mov .L3: add Hardverközeli programozás 1
eax, ebx .L0 ecx, 1 edx, 1 eax, ebx .L2 ecx, 1 .L3 ecx, 2 edx, 1 107
A switch utasítás alacsony szinten cmp je cmp je jmp .L3: mov .L4: mov .L2: mov add
switch (kifejezés){ case kifejezes1: utasítás1; case kifejezes2: utasítás2; default: utasítás3;} utasítás4;
Hardverközeli programozás 1
eax, 1 .L3 eax, 2 .L4 .L2 ebx, 1 ebx, 2 ebx, 3 edx, 1 108
A break hatása alacsony szinten switch (kifejezés){ case 1: utasítás1; break; case 2: utasítás2; break; default: utasítás3;} utasítás4;
.L3: .L4: .L2: .L5: Hardverközeli programozás 1
cmp je cmp je jmp mov jmp mov jmp mov add
eax, 1 .L3 eax, 2 .L4 .L2 ebx, 1 .L5 ebx, 2 .L5 ebx, 3 edx, 1 109
Ciklusszervező utasítások Felépítés: fej + mag + vég Működés szempontjából: üres, ‘normál’, végtelen Fajtái: Feltételes Kezdőfeltételes Végfeltételes
Előírt lépésszámú Előltesztelő Hátultesztelő
Felsorolásos Végtelen Hardverközeli programozás 1
110
A C nyelv ciklusai Kezdőfeltételes (nem 0 feltétel esetén ismétel) while (feltétel) utasítás; for ([kif1]; [kif2]; [kif3]) utasítás; Végfeltételes (nem 0 feltétel esetén ismétel) do utasítás; while (feltétel); Hardverközeli programozás 1
111
A while és for ciklus alacsony szinten mov jmp .L3: sub .L2: cmp jne add
utasítás0; while (feltétel) utasítás1; utasítás2;
eax, 10 .L2 eax, 1 eax, 0 .L3 ebx, 1
A for és a while ciklus assembly szinten egyenértékű. Hardverközeli programozás 1
112
A do-while ciklus alacsony szinten mov eax, 10
utasítás0; do utasítás1; while (feltétel); utasítás2;
.L3: sub cmp jne add
eax, 1 eax, 0 .L3 ebx, 1
A do-while ciklus nem lehet üres ciklus. Hardverközeli programozás 1
113
Magasszintű programozás leképezése assembly-re 2. Eljárás, függvény Lokális változó Paraméterátadás
Gondolatébresztő kérdések Hol vannak az hívott eljárás utasítási? Mi a kezdő memória címük? Hova kell átadni a vezérlést? Melyik utasítással kell folytatni a végrehajtást ha végeztünk az eljárással? Mi a címe a következő utasításnak? Hova kell átadni a vezérlést? Hol tárolódik a visszatérési cím? Hol van eltárolva a hívási lánc? 115
Gondolatébresztő kérdések Hogyan kerülnek át a paraméterek az alprogramba? Hogyan kerül vissza a hívóhoz a visszatérési érték? Ismersz-e változó paraméterszámú függvényt? Hol van tárolva a lokális változó? A memória melyik részén helyezkedik el? Miért dinamikus az ‚alap’ változó élettartama? Miben különbözik a static változótól? 116
Gondolatébresztő kérdések Melyik program a gyorsabb? Miért? #include<math.h> int main(){ int a,b=-23; a=abs(b); return 0;} #define abs(x) ((x)<0)?(-1*(x)):(x) int main(){ int a,b=-23; a=abs(b); return 0;} 117
Gondolatébresztő kérdések Mit ír az alábbi program a képernyőre? #include<stdio.h> int b=2; void one(int a){ a=a+1;} int main(){ one(b); printf(”%d %d\n”,a,b); return 0;}
118
Gondolatébresztő kérdések Hányszor fut le az eljárás? #include<stdio.h> void one(int a){ if(a>0) one(a-1); } int main(){ one(1000000); return 0; }
119
Gondolatébresztő kérdések Mit csinál a program? #include<stdio.h> void one(){ int T[10000000]; T[12345]=67; printf(”%d”,T[12345]); } int main(){ one(); return 0; } 120
Gondolatébresztő kérdések Mit ír az alábbi program a képernyőre? #include<stdio.h> void one(){ int a=-43;} void two(){ int b; printf(”%d\n”,b);} int main(){ one(); two(); return 0;} 121
Alprogram Az újra felhasználhatóság és a procedurális absztrakció eszköze Komponensei: Név Formális paraméterlista Törzs Környezet Fajtái: Eljárás Függvény 122
Eljárás Tevékenységet hajt végre Aktivizálás utasításszerűen lehet Befejezés a törzs végére érve vagy befejeztető utasítással Folytatás a hívás utáni utasítással void procedure(int a, char b){ printf(”%d %c”,a,b); } // C nyelven nincs eljárás …
procedure(3,’A’); … 123
Függvény Értéket határoz meg Aktivizálás kifejezésben Befejezés általában befejeztető utasítás révén visszatérési érték megadásával Folytatás a kifejezés kiértékelésnél int function(int a, char b){ return a+b; } …
x=2*function(3,’A’)+1; … 124
A verem Last In First Out tároló Tetejének a memóriacímét a verem mutató regiszter (SP) tárolja Push és Pop művelet A verem mérete korlátos Veremhez gyakran hozzá kell férni Általában gyorsítótárazott (cache) Adat kivétele nem fizikai törlés Külön memóriaszegmensben van 125
Eljárás hívás alacsony szinten RAM:
PC
1 2 3 12
… hívó_utasítása_1
6
hívó_utasítása_2 eljárás_hívás hívó_utasítása_3
7
…
8
hívott_utasítása_1
9
hívott_utasítása_2 befejeztetés
4
SP
…
10 5 0 11
old_PC 126
Hívási lánc Az alprogramok hívhatnak újabb alprogramokat, azok továbbiakat, … A visszatérési címek folyamatosan a verem tetejére kerülnek (A verem mérete nő.) A hívási lánc dinamikusan épül fel, bomlik le A lánc miden tagja aktív, de csak a legutóbbi működik Rekurzió: egy aktív alprogram meghívása 127
Lokális változók Az programegységben deklarált nevek (változók) a programegység lokális nevei (változói). C nyelvnél (alapesetben): Statikus hatáskörkezelés Dinamikus élettartam kezelés Nincs automatikus kezdőérték
128
Lokális változó alacsony szinten Az alprogramba lépéskor a verem tetején a visszatérési cím található A verembe mentjük a bázis regiszter értékét A veremmutató (SP) értékét átmásoljuk a bázis regiszterbe (BP) Átállítva a veremmutató értékét hagyunk helyet a lokális változók számára a veremben A verem nem csak FIFO módon kezelhető A lokális változók ‚bázis relatív’ címzéssel elérhetőek 129
Lokális változó alacsony szinten void eljar(){ int a=1; int b=2; int c=3; … * }
* A RAM tartalma: 730 734
???
738
a=1
[ebp-12]
742
b=2
[ebp-8]
746
c=3
[ebp-4]
750 régi ebp 754 ret. cím
Hardverközeli programozás 1
esp=734
ebp=750
130
Lokális változó alacsony szinten eljar: push ebp mov ebp, esp sub esp, 16 mov DWORD PTR [ebp-12], 1 mov DWORD PTR [ebp-8], 2 mov DWORD PTR [ebp-4], 3 … mov esp, ebp pop ebp ret Hardverközeli programozás 1
131
Paraméter kiértékelés Formális- és aktuális paraméter összerendelés Sorrendi kötés Név szerinti kötés
Számbeli egyeztetés Azonos paraméterszám Eltérő paraméterszám
Típusegyeztetés Típusegyezés Típus konverzió 132
Paraméterátadás Érték szerinti Cím szerinti Eredmény szerinti Érték-eredmény szerinti Név szerinti Szöveg szerinti Az adatmozgás iránya fontos C nyelvben: csak érték szerinti paraméterátadás 133
Érték szerinti paraméterátadás Formális paraméternek van címkomponense a hívott területén. Aktuális paraméternek van érték komponense. Az aktuális paraméter értéke átkerül a hívott alprogram területén lefoglalt címkomponensre. Az információátadás egy irányú. Az alprogram a saját területén dolgozik. A hívott alprogram nem tudja hol van a hívó. 134
Függvényhívás alacsony szinten 1.
2. 3. 4.
A hívó a verembe teszi az aktuális paramétereket fordított (!) sorrendben. (sorrendi kötés, számbeli egyeztetés) A verembe bekerül a visszatérési cím (PC aktuális értéke). PC megkapja a hívott alprogram kezdőcímét. Szekvenciálisan lefutnak a hívott utasításai. Hívott alprogram felhasználja a veremben lévő paramétereket (bázis relatív, lokális változó). Meghatározódik a visszatérési érték. 135
Függvényhívás alacsony szinten 5.
6.
7.
8. 9. 10.
Verembe visszatérési érték betétele (a visszatérési cím alá). Veremből visszatérési cím (hívást követő utasítás címe) kivétele. Vezérlés visszaadása a megadott címre (lásd 5. pont). Visszatérési érték kivétele a veremből. Paraméterek kitakarítása a veremből. Végrehajtás folytatása a következő utasítással. 136
Függvényhívás alacsony szinten Egyes esetekben… … a paraméterek meghatározott sorrendben regiszterekbe kerülnek, itt adódnak át. (El kell menteni a korábbi tartalmat) … a visszatérési értéket az egyik regiszteren keresztül adjuk vissza A paraméterek kitakarítása a veremből lehet a hívó vagy a hívott feladata is
Hardverközeli programozás 1
137
Példa C nyelven * A RAM tartalma:
int fuggv(int c){ int a; a=c+1; * return a; } int main(int argc, char *argv[]){ int a, b; a=argc; b=fuggv(a); return b; } Hardverközeli programozás 1
esp=726
726 fuggv: c
[ebp-8]
730 fuggv: a 734 régi ebp 738
[ebp-4]
742 visszatér. cím 746 750 param.
[ebp+8]
754
[ebp+20]
ebp=734 [ebp+4] [ebp+12] [ebp+16]
758 main: a 762 main: b 766 ősi ebp 770 138
Példa assembly-ben #1 fuggv:
push mov sub mov mov mov add mov mov mov mov pop ret
rbp rbp, rsp rsp, 8 eax, DWORD PTR [rbp+16] DWORD PTR [rbp-8], eax eax, DWORD PTR [rbp-8] eax, 1 DWORD PTR [rbp-4], eax eax, DWORD PTR [rbp-4] DWORD PTR [rbp+16], eax rsp, rbp rbp
Hardverközeli programozás 1
139
Példa assembly-ben #2 main:
push mov sub mov mov push call pop mov mov mov pop ret
rbp rbp, rsp rsp, 8 DWORD PTR [rbp-8], edi eax, DWORD PTR [rbp-8] rax fuggv rax DWORD PTR [rbp-4], eax eax, DWORD PTR [rbp-4] rsp, rbp rbp
Hardverközeli programozás 1
140
Cím szerinti paraméterátadás Formális paraméternek nincs címkomponense a hívott területén. Aktuális paraméternek van cím komponense a hívó területén. Az aktuális paraméter címe átkerül a hívott alprogramhoz, aki itt dolgozik. Az információátadás két irányú. Az alprogram a hívó területén dolgozik. Gyorsabb, de veszélyesebb. 141
Megszakítási rendszer és input/output Megszakítás, kivétel Megszakításkezelés Input/output Buszrendszerek, perifériák
Szükségesség Az általános célú számítógépek fontos képessége, hogy kölcsön hat az I/O eszközökkel (billentyűzet, egér, hálózati interfész, monitor). Ezek ez eszközök azonnali választ várnak a processzortól, függetlenül attól mivel foglalkozik éppen. Váratlanul bekövetkező eseményekre a CPU-nak reagálnia kell. A megszakítás szolgál a CPU figyelmének felhívására. Hardverközeli programozás 1
143
Megszakítás Speciális jelzés a CPU számára Egy esemény bekövetkeztét jelzi Azonnal reagálni kell rá A „normál” végrehajtást meg kell szakítani Később tudni kell folytatni
Forrás Hardver Processzor Szoftver Hardverközeli programozás 1
144
Megszakítás típusok Aszinkron Külső forrásból (például I/O eszköz) származik Független az aktuálisan végrehajtott utasítástól Szinkron (másként „kivétel”) Processzor által érzékelt kivétel Hiba: „kijavítható” probléma, újra próbálkozás Csapda: pl. nyomkövetésnél Elvetés: jelentős, „javíthatatlan” (hardver) hiba
Programozott kivétel (rendszerhívás) Hardverközeli programozás 1
145
Fogalmak Megszakítási vonal Egy (vagy több) CPU vezérlő busz vezeték Megszakítási kérelem (IRQ) A megszakítások egész számokkal (0-255) azonosíthatók Lehet prioritásuk Programozható megszakítás vezérlő (PIC, APIC) Azonosítja a megszakítás forrását, aktiválja a megszakítási vonalat, kezeli prioritásokat Hardverközeli programozás 1
146
Fogalmak Megszakítási rutin (ISR) Az a programrész, amely megszakítási kérelem esetén aktiválódik, kezeli a speciális helyzetet „Hívás nélküli” alprogramhoz hasonlít Kontextus Ahhoz, hogy folytatni tudjuk a „normál” végrehajtást a kivételkezelés után először el kell menteni, majd vissza kell állítani az eredeti környezetet, regisztertartalmakat Hardverközeli programozás 1
147
Fogalmak Maszkolás Egyes megszakítási kérelmek figyelése kikapcsolható Egyszerre, globálisan, processzorban Külön-külön, a PIC-ben lévő IMR segítségével
Vannak nem maszkolható megszakítások (NMI) Nested interrupt („fészkelt megszakítás”) Megszakítási rutint megszakító újabb IRQ Megszakítás megszakítása Hardverközeli programozás 1
148
Megszakításkezelés Utasítás beolvasás
nem
Utasítás dekódolás
Kontextus mentés
Utasítás végrehajtás
Eszköz azonosítás Rutin (ISR) keresés
Megszakítás?
igen NMI?
igen
nem igen
Maszk tilt?
Rutin (ISR) végrehajtás Kontextus visszaállítás
nem Hardverközeli programozás 1
149
Megszakításkezelési technikák Vektoros megszakításkezelés Megszakítási vonal aktiválás A megszakítás kérő azonosítja magát Adatbuszon egyedi kódot/címet küld
Lekérdezéses (polling) megszakításkezelés Megszakítási vonal aktiválás A CPU sorozatos lekérdezésekkel kideríti kinek van megszakítási igénye Hardverközeli programozás 1
150
Megszakításkezelési technikák Vektoros megszakításkezelés
IRQ
ISR 1 címe … ISR n címe
vektor
IRQ n
Lekérdezéses megszakításkezelés
…
megszakítás lekérdező eljárás programkódja
…
…
ISR 1 programkódja
ISR 1 programkódja
…
…
ISR n programkódja
ISR n programkódja
…
… Hardverközeli programozás 1
151
Input/Output Kapcsolat a külvilággal Hardveres I/O interfészek Szoftver interfész (device driver) Perifériás eszközök Periféria 1
Periféria 2
buffer
buffer
Külső buszok
Processzor
Memória
I/O interfészek
Rendszer busz Hardverközeli programozás 1
152
Input/output interfészek Kapcsolat a CPU és a perifériák között Címezhető eszközök Memóriára leképezett I/O (MMIO) Portra leképezett I/O (PMIO)
Különböző adatsebesség Különböző fizikai jelek Soros átvitel Párhuzamos átvitel
Az eszközvezérlés nem a CPU feladata Hardverközeli programozás 1
153
I/O technikák Programozott I/O (PIO) Speciális I/O utasításokkal (in, out) A program írja le mikor kell a perifériához fordulni (függetlenül annak állapotától) Utasításonként csak egy szó átvitele az I/O buffer és a CPU regiszterei között I/O adat és címregiszterek a CPU-ban Sok CPU időt felemészt az eszközök állapotának sorozatos elkérdezése Hardverközeli programozás 1
154
I/O technikák Megszakítás vezérelt I/O A periféria megszakításokkal jelez a CPU-nak Ha van új input vagy Ha kész van az outputtal
A CPU nem figyel folyamatosan Közben tud mással foglalkozni
Az adatmozgás a CPU és az I/O modul között történik
Hardverközeli programozás 1
155
I/O technikák Direkt memória hozzáférés (DMA) Külön vezérlő révén közvetlen RAM-I/O kapcsolat (RAM-RAM, RAM-I/O) A CPU kéri fel a DMA vezérlőt a műveletre Ha a DMA vezérlő kész van megszakítást kér CPU nem vesz részt az adatmozgatásban Blokkos átviteli mód I/O processzor (IOP) DMA kiterjesztése nagyobb önállósággal Hardverközeli programozás 1
156
Buszrendszerek Párhuzamos ISA PCI ATA (ATAPI, UATA, IDE) VESA Local Bus (VLB) SCSI AGP …
Soros I2C PCI Express Serial ATA USB Serial Attached SCSI FireWire …
Hardverközeli programozás 1
157
PCI busz Peripheral Component Interconnect Párhuzamos belső busz Sínszélesség: 32 vagy 54 bit Átviteli sebesség: 133-533 MB/s Fejlesztés: 1992-2002 Külön vezérlőáramkör szükséges
Forrás: en.wikipedia.org/wiki/Conventional_PCI Hardverközeli programozás 1
158
PCIe busz Peripheral Component Interconnect Express Soros belső busz 1 link 1, 2, 4, 8, 16 vagy 32 sávból áll Átviteli sebesség: 4000-31500 MB/s Fejlesztés: 2003Minden eszköznek külön link (nem osztoznak) Forrás: en.wikipedia.org/wiki/PCI_Express Hardverközeli programozás 1
159
(Parallel) ATA busz (Parallel) AT Attachment Párhuzamos belső busz „Szinonimák”: PATA, ATAPI, UATA, IDE, EIDE Átviteli sebesség: 3,3-166 MB/s Fejlesztés: 1986-2003 HDD, FDD, CD és DVD meghajtó csatlakoztatás
Forrás: en.wikipedia.org/wiki/Parallel_ATA
Hardverközeli programozás 1
160
SATA busz Serial ATA Soros belső busz Pont-pont kapcsolat Átviteli sebesség: 150-2000 MB/s Fejlesztés: 2003HDD, SSD, CD és DVD meghajtó csatlakoztatás
Forrás: hu.wikipedia.org/wiki/Serial_ATA
Hardverközeli programozás 1
161
USB busz Universal Serial Bus Soros külső busz Plug-and-Play, elosztható (hub) Átviteli sebesség: 0,18-1250 MB/s Fejlesztés: 1996Csatlakozók: standard-A, standard-B, mini-A, mini-B, micro-A, micro-B
Forrás: en.wikipedia.org/wiki/USB
Hardverközeli programozás 1
162
Vezérlő hub-ok Az alaplap fontos chip-jei Northbridge (memóriavezérlő hub) Southbridge (I/O vezérlő hub) CPU
AGP
Northbridge
RAM
Southbridge BIOS
PCI
IDE
USB
Hardverközeli programozás 1
LAN
I/O 163
Eszközmeghajtó Device Driver Eszköztípusok Karakteres, blokkos, hálózati, egyéb
A programok hardvertől független rendszerhívásokat alkalmaznak open, read, write, close, …
Az eszközmeghajtók „töltik meg” ezt konkrét hardver specifikus tartalommal
Hardverközeli programozás 1
164
Perifériák Input
Output
Billentyűzet Egér Szkenner Kamera
Monitor Nyomtató Projektor Audio rendszer
Tároló
Hálózat
Háttértár (HDD, SSD) CD/DVD/Blu-ray USB tároló Memória kártya Hardverközeli programozás 1
Ethernet kártya Wi-Fi kártya
165
Adattárolás Operatív memória Cache Háttértárak
Tárolók osztályzása Írhatóság szempontjából Csak olvasható, olvasható-írható
Hierarchiabeli helye szerint Elsődleges, másodlagos, harmadlagos
Tárolási közeg szerint Félvezető, mágneses, optikai
Adatmegőrzés szerint Megmaradó, nem megmaradó
Elérés szerint Soros elérésű, tetszőleges elérésű Hardverközeli programozás 1
167
Elsődleges memória A processzor és a futó programok által aktívan használt tároló Gyors elérésű Nem maradandó memória Méret erősen korlátos Ide tartoznak Regiszterek Gyorsítótárak Operatív memória Hardverközeli programozás 1
168
Másodlagos memória Háttértároló Az elsődleges memória „kiterjesztése” Nagy tároló kapacitás Kisebb elérési sebesség Maradandó tárolás Ide tartoznak HDD, SDD CD-, DVD-meghajtó Memóriakártya Hardverközeli programozás 1
169
Harmadlagos memória Többnyire eltávolítható adathordozókra épít Robotikus eszközök csatlakoztatják a kívánt tároló médiumot („wurlitzer”) Ritka hozzáférés Óriási tároló kapacitás Cél hosszú távú archiválás Ide tartoznak Mágnesszalagos tárolók Optikai tárolók Hardverközeli programozás 1
170
Félvezető memóriák Read-Only Memory (ROM) Gyártás során kerül bele a tartalom, ami később nem változtatható Tartalmat sokáig megőrzi, tápfeszültség hiányában is Programable Read-Only Memory (PROM) Gyártás után „üres”. Speciális eszközzel egyszer „beégethető” a tartalom Az írás folyamata lassú (a RAM-hoz képest) Hardverközeli programozás 1
171
Félvezető memóriák Erasable Programable ROM (EPROM) Erős UV fénnyel (lassan) törölhető a tartalom Majd ismét újraírható Electrically Erasable Programable ROM (EEPROM) Elektronikusan, bájtonként törölhető tartalom Flash memória Speciális továbbfejlesztett EEPROM Blokkonként (gyorsabban) törölhető Hardverközeli programozás 1
172
Félvezető memóriák Random Access Memory (RAM) Véletlen elérés Elérési idő nem függ az elhelyezkedéstől
Írható/olvasható tetszőleges számban Elveszti a tartalmát tápfeszültség hiányában Nagy írási/olvasási sebesség Static Random Access Memory (SRAM) Frissítés nélkül is megtartja a flip-flipokban a tartalmat a tápellátás megszűnéséig (pl. cache) Hardverközeli programozás 1
173
Félvezető memóriák Dynamic Random Access Memory (DRAM) Rendszeresen frissíteni kell, hogy a kondenzátor révén tárolt információ megmaradjon SRAM-nál lassabb (pl. operatív tár) Olyan gyorsan válaszol ahogy tud Syncronous Dynamic RAM (SDRAM) Órajellel szinkronizált válasz Gyorsabb az aszinkron DRAM-nál (pipeline működés) Hardverközeli programozás 1
174
Félvezető memóriák Double Data Rate (DDR) Gyorsított SDRAM Az órajel fel és leszálló élére is szinkronizál DDR2, DDR3, DDR4 Egyre nagyobb sebesség Egyre nagyobb adatsűrűség Egyre kisebb feszültség
Nem kompatibilis DIMM (SDRAM, DDR, DDR2, DDR3, DDR3) Hardverközeli programozás 1
175
Gyorsítótár Egyes eszközök rendszeresen adatot cserélnek Az eszközök adatátviteli sebessége nagyon eltér A lassú eszköz miatt a gyors is „lelassul” Pl. a CPU kb. 10-szer gyorsabb a RAM-nál Megoldási ötlet Köztes tároló beiktatása (cache) Gyorsabb, mint a lassú eszköz (SRAM, közeli) Magas ára miatt teljesen nem helyettesíti a lassút Létjogosultság: lokalitási elvek Hardverközeli programozás 1
176
Gyorsítótár Térbeli lokalitás elve Ha egy program hivatkozik egy memóriacímre (adat vagy utasítás), akkor nagy valószínűséggel hamarosan hivatkozik a szomszédos címekre is Szekvenciális végrehajtás, tömbök
Időbeli lokalitás elve Ha egy program hivatkozik egy memóriacímre, akkor nagy valószínűséggel hamarosan ismét hivatkozik rá Ciklusok Hardverközeli programozás 1
177
Gyorsítótár Leggyakrabban használt adatok tárolása Kisebb tárolókapacitás, gyorsabb elérés (SRAM), mint az operatív memória esetén Átlátszóak a felhasználó számára Asszociatív (CAM) memóriát tartalmaz CPU cache, GPU cache, Web cache, DNS cache CPU cache Többszintű: L1, L2, L3 cache On-chip vagy off-chip Hardverközeli programozás 1
178
Gyorsítótár felépítése A tárolás egysége a „Sor” A Sor részei a „Tag” (toldalék) és a „Blokk” A Tag tartalmazza a Blokk főtárbeli címét és egyéb vezérlő információkat A Blokk a főtár egy részének a másolata RAM
Cache
CPU Tag 128
…
Blokk
ABC
127
DEF
DEF
128
GHI
129
JKL
130
MNO
131
131
…
MNO
129
…
GHI
Hardverközeli programozás 1
… 179
A cache működése A processzor a szükséges adatot a cache-ben keresi (átadja a tárcímet a cache vezérlőnek) Ha az adott cím el van tárolva a Tag-ben (cache hit), akkor válaszol a Blokk tartalma alapján Ha a cím nincs eltárolva (cache miss), akkor beolvassa a megfelelő területet a főtárból, dönt arról, melyik sorba mentse és elmenti (felülírva valamelyik cache sort), majd válaszol a Blokk tartalma alapján Hardverközeli programozás 1
180
A cache működése Az írás művelete során figyelni kell a főtár és a gyorsítótár tartalmának konzisztenciájára Megoldások Közvetlen írás Visszaírás
Közvetlen írás Gyorsítótár írásával egyidejűleg a főtár is íródik Az írást a cache nem gyorsírja Hardverközeli programozás 1
181
A cache működése Visszaírás (write back) Gyorsítótár minden írás esetén módosul A Tag vezérlő részében ezt jelezzük („dirty”) Ha a cache adott sorát felül kell írni újabb olvasási művelet miatt, és a sor „dirty” visszaírjuk a tartalmát a főtárba Majd megtörténik a sor felülírása az újjal Többprocesszoros rendszerekben probléma a külön cache-ek miatt!!! Hardverközeli programozás 1
182
A cache működése olvasás
Cache hit? nem
Igény?
írás
igen
igen
Cache hit? nem
Felülírandó sor keresés „Dirty”? nem
Felülírandó sor keresés igen
Felülírandó sor visszaírása
Felülírandó sor visszaírása
igen
„Dirty”? nem
Alsóbb memória olvasás a választott sorba
Alsóbb memória olvasás a választott sorba Státusz: nem „dirty”
Új adat írása a választott blokkba Státusz: „dirty”
Válasz az adattal Hardverközeli programozás 1
183
A cache jellemzői A gyorsítótár mérete A Blokk mérete Egy Blokk kikeresésének ideje Aktualizálási idő (visszaírásnál) Helyettesítési stratégia (sor felülírásnál) Találati arány (hit rate) Általában 90% feletti Méretfüggő Hardverközeli programozás 1
184
Cache hierarchia processzor core L1 utasítás
processzor core
L1 adat
L1 utasítás
L2
core L1 adat
L1 utasítás
L2
core L1 adat
L1 utasítás
L2
L3
L2 L3
Fő memória
Hardverközeli programozás 1
L1 adat
>10kB >100kB >1MB
>1GB
185
Cache hatása a programokra ... ARRAY = (double*)malloc(SIZE*sizeof(double)); N_Rep = 1000000000/SIZE; for(j=0; j
Ha az adat elfér a cache-ben, akkor a program gyorsabb!
Hardverközeli programozás 1
186
Háttértár Problémák Az operatív tár nem elég nagy Kikapcsoláskor a RAM tartalma elvész Megoldás Háttértár: lassabb elérés, de nagyobb kapacitás Tárolási elv Mágneses: merevlemez (HDD) Elektronikus: szilárdtest-meghajtó (SSD) Optikai: CD, DVD, Blu-ray Hardverközeli programozás 1
187
Merevlemez Winchester, Hard Disc Drive (HDD) Mágnesezhető, forgó lemezeken tárolt adat Lemezenként 2 író/olvasó fej Tulajdonságai Tárolókapacitás: <2TB Írási/olvasási sebesség: 100MB/s - 1GB/s Fordulatszám: 5400 - 15000 rpm Csatoló felület: ATA, SATA, SCSI, USB Lemez gyorsítótár mérete: 1MB – 64MB Hardverközeli programozás 1
188
Adattárolás merevlemezen A HDD több tároló lemezt tartalmazhat A lemezek felülete koncentrikus sávokra osztott Az egymás alatti lemezeken lévő azonos sugarú sávok alkotják a cilindert A sávok szektorokra vannak osztva Ez az adattárolás legkisebb egysége
Klaszter a szektorokból álló folytonos terület Minden író/olvasó fej egyszerre mozog egy adott pillanatban egy cilinderen helyezkednek el Hardverközeli programozás 1
189
Szektor Hagyományos szerkezet 512 bájtos szektor rés
szinkron
cím
hibajavító 512 bájt adat
sáv
szektor
szektor
szektor
szektor
szektor
szektor
szektor
szektor
Advanced Format (AF) 4K native 4096 bájt adat
Hardverközeli programozás 1
190
Szektor hatása programokra ... #define SIZE 2048 char BUFFER[SIZE]; out=open("output.txt",O_WRONLY); write(out, BUFFER, SIZE); close(out); ...
Szektor méretnél kevesebbet fájlba írni nem hatékony!
Hardverközeli programozás 1
191
Bufferelt adatfolyam Az output adatfolyamokat gyakran a rendszer buffereli és csak később blokkosan írja ki. Kevesebb rendszerhívás, kevesebb lemez művelet, gyorsabb program … while(i<100000){ fprintf(f,”x”); sleep(t); i++; } … Hardverközeli programozás 1
192
Adatelérés merevlemezen Hogyan hivatkozható egy terület a HDD-n? CHS cilinder-fej-szektor hármassal (régi) LBA logikai blokk címzéssel (lineáris, új) Konverzió: LBA = (C*Nfej+H)*Nszektor+(S-1) Lemezvezérlő foglalkozik a logikai és fizikai cím leképezéssel Hardverközeli programozás 1
193
Sávok szektorszáma Régi HDD esetén Minden sávban azonos számú szektor Külső szektorok adatsűrűsége sokkal kisebb, mint a belsőké (kihasználatlanság) Modern HDD esetén Zone Bit Recording (ZBR) Szektorok adatsűrűsége közel azonos Külső sávokban több szektor, mint a belsőkben Címzés bonyolultabb Hardverközeli programozás 1
194
HDD magasabb szinten Formázás Alacsony szintű (szektor szerkezet kialakítás) Magas szintű (fájlrendszer)
Particionálás HDD kisebb logikai egységre bontása MBR, GPT kialakítás
Fájlrendszerek FAT32, NTFS ext2, ext3, ext4 Hardverközeli programozás 1
195
MBR és GPT Master Boot Record (MBR) LBA 0 Boot kód + Partíciós tábla Max 4 partíció és egyenként max 2,2 TB GUID Partition Table (GPT) MBR megőrzés LBA 1: GPT header UEFI szabvány (BOIS lecserélés) Max 128 partíció és egyenként max 9,4 ZB Hardverközeli programozás 1
196
FAT file rendszer Merevelemez 0
MBR
1
FAT 1
2
FAT 2
3
Gyökér
4
„gyümölcs ”
5
„állat.”
6
„Az alma ”
7
„finom ”
8
„szerintem.”
File Allocation Table 0 1 2 3
4
5
6
7
8
8
EOF
7
4
EOF
9
10 5
Gyökérkönyvtár bejegyzései Fájlnév
Attribútumok Kezdő klaszter
Alma.txt
Bla-bla
6
Kutya.txt
Bla-bla
10
9 10
„Emlős ” Hardverközeli programozás 1
197
Linux file rendszerek Pl.: Ext2, Ext3, Ext4 Fájl tárolása könyvtári bejegyzés
inode
file név inode ID
attribútumok mutató
adat blokk file tartalom a lemezen
Könyvtár tárolás könyvtári bejegyzés
inode
könyvtár név inode ID
attribútumok mutató
adat blokk file1 inode ID 1 file2 inode ID 2 file3 inode ID 3 file4 inode ID 4
Hardverközeli programozás 1
198
Linux file rendszerek Könyvtár hierarchia könyvtári bejegyzés
inode
file adat
partíció MBR cilinder csop. cilinder csop. cilinder csop. cilinder csop. cilinder csop. cilinder csop.
sys inode tábla
adat szektorok Hardverközeli programozás 1
199
inode inode
adat blokkok méret
attribútumok
eszköz felhasználó csoport fájl mód időbélyegek
adatblokk mutatók
linkszám direkt mutatók (12 db) simpla indirekt dupla indirekt tripla indirekt Hardverközeli programozás 1
200
RAID Redundant Array of Independent Disks Adateloszlás vagy replikálás több lemezen A technológia célja Adatbiztonság növelés Adatátviteli sebesség növelés
Több „szint” (RAID 0-6) Akár hierarchikusan is (RAID 1+0)
Szoftveres vagy hardverrel támogatott megvalósítás Hardverközeli programozás 1
201
RAID példák RAID 0 (összefűzés)
RAID 1 (tükrözés)
A1 A3 A5 A7
A2 A4 A6 A8
A1 A2 A3 A4
A1 A2 A3 A4
Lemez 1
Lemez 2
Lemez 1
Lemez 2
RAID 4 (paritás lemez) A1 B1 C1 D1
A2 B2 C2 D2
RAID 5 (forgó paritás)
AP BP CP DP
A1 B1 CP D1
Lemez 1 Lemez 2 Lemez 3
A2 BP C1 D2
AP B2 C2 DP
Lemez 1 Lemez 2 Lemez 3
Hardverközeli programozás 1
202
SSD Szilárdtest-meghajtó (Solid State Disk) Mozgó alkatrész nélküli félvezető memória Blokkos adatelérés SATA, SCSI, USB csatlakozás Előnyei a HDD-vel szemben Gyorsabb adatelérés Egyenletes adathozzáférés Kisebb zaj, fogyasztás és hőtermelés Mechanikai megbízhatóság Hardverközeli programozás 1
203
Memória hierarchia Elérési idő
Regiszter L1 cache
s
L2 cache
ms
L3 cache
µs
Memória
ns
Lemez Harmadlagos tár
Hardverközeli programozás 1
204
Memória hierarchia Regiszter
EB
L1 cache
TB
L2 cache
GB
L3 cache
MB
Memória
Tároló kapacitás
kB B
Lemez Harmadlagos tár
Hardverközeli programozás 1
205
A programozás és az operációs rendszer Rendszerhívás Folyamatok Szignál Ütemezés Virtuális memória
Duál-módú működés Kernel mód Magas CPU jogosultság A processzor minden utasítást végre tud hajtani Minden memóriarekesz megcímezhető User mód Alacsony CPU jogosultság Processzor korlátozott utasításkészletet használ Nem minden memóriarekesz hozzáférhető Hardverközeli programozás 1
207
Rendszerhívás Interfész a felhasználói program és az operációs rendszer között A program egy szolgáltatást igényelhet az operációs rendszer kerneltől Tipikus megvalósítás szoftver interrupt-tal Kernel módú működés Például Folyamatok kezelése Fájlok kezelése Eszközök kezelése Hardverközeli programozás 1
208
Rendszerhívás Példa: Egy USB meghajtón lévő file írása Saját C program fprintf() standard könyvtári függvény write rendszerhívás USB driver USB drive Hardverközeli programozás 1
Felhasználói program Könyvtári függvény Szoftver Rendszerhívás Kernel Eszköz meghajtó Hardver eszköz Hardver
209
Folyamat Process, processzus Végrehajtás alatt álló program Erőforrásokkal rendelkezik CPU-idő, memória, állományok, I/O eszközök
A folyamatokhoz kapcsolódó információkat a folyamatvezérlő blokkban (PCB) tartalmazza Kommunikálhatnak egymással Inter-process communication (IPC)
Hardverközeli programozás 1
210
Folyamat Egyedi azonosítóval rendelkezik (PID) Minden folyamatnak egy szülő- és több gyermek folyamata lehet Multi-programozott környezetben egynél több folyamat is lehet egyszerre Egy vagy több szálból állhat a folyamat Különböző állapotokban lehetnek Az állapotok között különböző állapotátmenetek
Hardverközeli programozás 1
211
Folyamat ütemezés Multi-programozott környezet (több folyamat) Ütemező: választ a futásra kész folyamatok közül, ki kapja meg a CPU-t Algoritmusok: FCFS, RR, SJF, EDF
Preemptív ütemezés Pl. hardveres időzítő lejár és megszakítást kér Aktuális folyamat megszakad, majd aktiválódik az ütemező kódja Választ egy folyamatot, beállítja az időzítőt és átadja a vezérlést a választott folyamatnak (PCB-t módosít). Hardverközeli programozás 1
212
Folyamat állapotátmenetek Új
Befejezett leállás Futó ütemezés
eseményre várás
időtúlfutás Futásra kész kilapozás
esemény bekövetkezés
belapozás
Várakozó kilapozás
belapozás
Várakozó felfüggesztett
Hardverközeli programozás 1
lapozó file
Futásra kész felfüggesztett
operatív memória
befogadás
213
Folyamatok közötti kommunikáció Néha a folyamatoknak szükségük van információcserére egymás között Fájl: több folyamat által közösen használt fájl Pipe: pl. input/output átirányítás Szignál: értesítés eseményről bekövetkeztéről Szemafor: osztott erőforrás szinkronizációjához Shared memory: közösen használt RAM terület Socket: hálózati protokollokon keresztül … Hardverközeli programozás 1
214
Szignál Egy folyamatnak küldött jelzés Esemény bekövetkeztét jelzi, aszinkron módon Üzenet/adat csere nincs Ha egy folyamat kap egy szignált a normál működés megszakad végrehajtódik a definiált szignálkezelő kód, majd a folyamat folytatódik Gyakori szignálok: SIGINT (2), SIGKILL (9), SIGALRM (14), SIGTERM (15), SIGCHLD (18), SIGSTOP (23), SIGCONT (25) Hardverközeli programozás 1
215
Virtuális memória A fizikai memória korlátainak transzparens átlépését teszi lehetővé a háttértár segítségével Fizikai memória keretekre osztva Logikai memória lapokra osztva (fix méret: 4kB) Külön virtuális- és fizikai címzés Virtuális cím leképezése fizikai címre: laptábla A nem használt lapok kilapozhatóak a HDD-re A Memory Management Unit (MMU) irányít Hardverközeli programozás 1
216
Virtuális memória Hivatkozás RAM-ban nem lévő lapra (lap hiba) Lapcsere szükséges
Lapcserélési stratégia fontos (FIFO, LRU, …) HDD elérés ideje kb. 100 000-szerese a RAM elérési időnek Gyakori lapozás lassítja a programot
Megvalósítás Linux: swap partíció Windows: C:\pagefile.sys fájl Hardverközeli programozás 1
217
Virtuális memória kezelése 1. 2.
3. 4.
5.
CPU logikai memória igény (lap# + offset). Laptábla ellenőrzés: ha a lap a RAM-ban folytasd a 9. lépésnél, különben 3. lépésnél! Válassz a RAM-ban egy keretet a beolvasáshoz! Szükség esetén indítsd el a keretben lévő lap kiírását a HDD-re, majd indítsd el a szükséges lap beolvasását a keretbe! Közben a folyamat várakozó állapotba kerül, az ütemező indítson egy futásra kész folyamatot! Hardverközeli programozás 1
218
Virtuális memória kezelése 6.
7. 8.
9.
A háttérben a DMA vezérlő (kiírja) beolvassa a RAM-ba a HDD-ről a lapot és ha kész küld egy „I/O kész” megszakítást. A folyamat futásra kész állapotba kerül. Amint az ütemező újra futóvá teszi a folyamatot ismételd meg a memória igényt! A laptábla alapján fizikai cím (keret# + offset) előáll. A RAM válaszol a keresett adattal.
Hardverközeli programozás 1
219
Virtuális memória kezelése Logikai cím
2 lap#
virtuális címtér (folyamat A) 0
A0
1
A1
2
A2
3
A3
4
A4
5
A5
6
A6
7
A7
8
A8
9
A9
157
Fizikai cím
?
?
Adat
keret# offset
offset
laptábla (folyamat A) 0 1 2 3 4 5 6 7 8 9
1 1 0 0 1 0 1 0 0 0
4 2 1 5 -
?
fizikai címtér (RAM) 0
B1
1
A4
2
A1
3
B9
4
A0
5
A6
szabaddá tehető
háttértár 67
Hardverközeli programozás 1
220
Virtuális memória kezelése Logikai cím
2 lap#
virtuális címtér (folyamat A) 0
A0
1
A1
2
A2
3
A3
4
A4
5
A5
6
A6
7
A7
8
A8
9
A9
157
Fizikai cím
?
?
Adat
keret# offset
offset
laptábla (folyamat A) 0 1 2 3 4 5 6 7 8 9
0 1 0 0 1 0 1 0 0 0
2 1 5 -
?
fizikai címtér (RAM) 0
B1
1
A4
2
A1
3
B9
4 5
szabaddá tehető
A6
háttértár 67
Hardverközeli programozás 1
221
Virtuális memória kezelése Logikai cím
2 lap#
virtuális címtér (folyamat A) 0
A0
1
A1
2
A2
3
A3
4
A4
5
A5
6
A6
7
A7
8
A8
9
A9
67
157
Fizikai cím
4
157
Adat 67
keret# offset
offset
laptábla (folyamat A) 0 1 2 3 4 5 6 7 8 9
0 1 1 0 1 0 1 0 0 0
2 4 1 5 -
fizikai címtér (RAM) 0
B1
1
A4
2
A1
3
B9
4
A2
5
A6
67
háttértár
Hardverközeli programozás 1
222
Modern architektúrák Futószalag végrehajtás Párhuzamos végrehajtás Szuperskalár és vektor processzorok
Flynn-féle osztályozás Osztályzás párhuzamosság szempontjából SISD (Single Instruction Single Data) pl. klasszikus korai egyprocesszoros PC-k
SIMD (Single Instruction Multiple Data) pl. vektroprocesszorok, GPU
MISD (Multiple Instruction Single Data) pl. hibatűrő rendszerek (űrrepülőgép)
MIMD (Multiple Instruction Multiple Data) pl. többmagos- és szuperskalár processzorok Hardverközeli programozás 1
224
„Klasszikus” architektúrák In-order (soros) végrehajtás (Neumann) A hagyományos SISD architektúrán alapuló rendszerek teljesítmény növelésének lehetőségei Órajel frekvencia növelés Közvetlen memória hozzáférés (DMA) Gyorsítótár (cache) használat Gyorsabb buszrendszer Társprocesszor alkalmazás (FPU) … Hardverközeli programozás 1
225
Dinamikus órajel szabályozás Az órajel frekvencia növelés több hő termelését és magasabb fogyasztást jelent (korlátozó tényező) Intel Turbo Boost és AMD Turbo Core Egy mag kaphat gyorsabb órajelet ha a többi mag nem terhelt (azaz határon belüli a hőtermelés) Intel SpeedStep és AMD PowerNow! Ha a mag „üresjáratban” van az órajele és a mag feszültsége csökken (energiatakarékosság)
Hardverközeli programozás 1
226
Lebegő pontos egység Floating-Point Unit (FPU), matematikai társproc. Pl. Intel x87
Az egész és a lebegőpontos műveletek architekturálisan eltérnek Régen társprocesszor, ma CPU-ba integrált Külön verem struktúrájú regiszter készlet ST(0)-ST(7)
Külön utasításkészlet Pl. FADD, FMUL, FDIV, FSQRT, … Hardverközeli programozás 1
227
Utasítás-szintű párhuzamosság Utasítás-szintű párhuzamosság (ILP) technikái Futószalag-elvű végrehajtás (pipeline) Sorrenden kívüli végrehajtás (OoOE) Regiszter átnevezés
Spekulatív végrehajtás Elágazás becslés
Szuperskalár végrehajtás Nagyon hosszú utasításszó (VLIW) használat Hardverközeli programozás 1
228
Egy utasítás végrehajtás Fetch-execute ciklus Minden egyes utasítás végrehajtása több fázisra bontható: Utasítás beolvasás (IF) Utasítás dekódolás (ID) Operandus beolvasás (OF) Végrehajtás (EX) Eredmény visszaírás (WB)
Egy utasítás több órajel alatt hajtódik végre Hardverközeli programozás 1
229
Pipelining Futószalag-elvű utasítás végrehajtás Több utasítás végrehajtási is folyamatban lehet egyszerre, csak legyenek különböző fázisban Egyes processzoroknál akár 30 fázis/utasítás Egy utasítás végrehajtási ideje nem csökken Viszont az egységnyi idő alatt végrehajtott utasítások száma (áteresztőképesség, throughput) növekszik A program gyorsabban lefuthat Hardverközeli programozás 1
230
Pipelining pipeline fázis
CPU idő [órajel]
IF
1.
utasítás 1
2.
utasítás 2
utasítás 1
3.
utasítás 3
utasítás 2
utasítás 1
4.
utasítás 4
utasítás 3
utasítás 2
utasítás 1
5.
utasítás 5
utasítás 4
utasítás 3
utasítás 2
utasítás 1
6.
utasítás 6
utasítás 5
utasítás 4
utasítás 3
utasítás 2
7.
utasítás 7
utasítás 6
utasítás 5
utasítás 4
utasítás 3
8.
utasítás 8
utasítás 7
utasítás 6
utasítás 5
utasítás 4
ID
OF
EX
WB
Elméleti utasítás végrehajtási idő: 5 órajel / utasítás Elméleti áteresztőképesség: 1 utasítás / órajel Hardverközeli programozás 1
231
Hazárd A Neumann-féle szekvenciális végrehajtási elv feltételezi, hogy minden utasítás végrehajtás befejeződik a következő megkezdése előtt
Pipeline processzorokra ez nem igaz Hazárd: az a helyzet amikor ez problémát jelent Típusai Adat hazárd Strukturális hazárd Vezérlési hazárd Hardverközeli programozás 1
232
Adat hazárd Végrehajtás alatt álló utasítások ugyanazt az adatot használják/módosítják RAW (Read After Write, adat függőség) • R3 • R4
R1 + R2 R3 + R2
WAR (Write After Read, név függőség) • R3 • R2
R1 + R2 R1 + R4
WAW (Write After Write, név függőség) • R3 • R3
R1 + R2 R4 + R1 Hardverközeli programozás 1
233
Strukturális és vezérlési hazárd Strukturális hazárd Ha a processzor hardvere nem képes az utasításokat egyszerre végrehajtani Pl. az egyik utasítás IF fázisban a másik OF fázisban egyszerre címezné a memóriát Vezérlési hazárd Elágazásnál a processzor nem tudja előre hol kell folytatni a vezérlést, azaz melyik utasítást olvassa be a futószalagra Hardverközeli programozás 1
234
Hazárdok kezelése Adat hazárd kezelése Pipeline buborék Operandus/eredmény továbbítás (bypassing) Sorrenden kívüli végrehajtás (OoOE) Regiszter átnevezés
Strukturális hazárd Pipeline buborék
Vezérlési hazárd Pipeline buborék Elágazásbecslés Hardverközeli programozás 1
235
Pipeline buborék Az IF fázis után ha a vezérlő egység hazárdot észlel beszúr egy NOP utasítást, azaz késlelteti a következő utasítás futószalagra helyezését Közben az utasítás előállítja az eredményt, amit a következő utasítás a késleltetés után már be tud olvasni Buborék a pipline-ban Nő a futásidő (de még mindig gyorsabb, mint pipeline nélkül) Hardverközeli programozás 1
236
Pipeline buborék pipeline fázis
CPU idő [órajel]
IF
1.
ADD r1,r2,r3
2.
SUB r4,r5,r1
3.
ID
OF
EX
WB
ADD r1,r2,r3 SUB r4,r5,r1
ADD r1,r2,r3
4.
SUB r4,r5,r1
ADD r1,r2,r3
5.
SUB r4,r5,r1
(buborék)
ADD r1,r2,r3
6.
SUB r4,r5,r1
(buborék)
(buborék)
SUB r4,r5,r1
(buborék)
7. 8.
SUB r4,r5,r1
Az adatfüggőség két órajelnyi késlekedést okozott Hardverközeli programozás 1
237
Eredmény továbbítás Ez egyik utasítás EX fázisának outputját közvetlenül (a visszaírással egy időben) kössük rá a másik utasítás EX fázisának inputjára pipeline fázis
CPU idő [órajel]
IF
1.
ADD r1,r2,r3
2.
SUB r4,r5,r1
3.
ID
OF
EX
WB
ADD r1,r2,r3 SUB r4,r5,r1
ADD r1,r2,r3
4.
SUB r4,r5,r1
ADD r1,r2,r3
5.
SUB r4,r5,r1
(buborék)
ADD r1,r2,r3
SUB r4,r5,r1
(buborék)
6. 7.
SUB r4,r5,r1 Hardverközeli programozás 1
238
Sorrenden kívüli végrehajtás Out-of-Order Execution (OoOE) Az utasítások nem a programban szereplő felírás sorrendjében hajtódnak végre Az az utasítás hajtódik végre először amelyiknek hamarabb állnak elő a bemeneti adatai A processzor próbálja elkerülni az üresjáratot az utasítások átrendezésével Hardveresen gyorsított újrafordítás Viszonylag nagy utasítás ablak Hardverközeli programozás 1
239
Sorrenden kívüli végrehajtás Utasítás beolvasása a memóriából Az utasítás beáll egy utasítás sorba és vár Az utasítássorból az távozik először, akinek elérhetőek az input operandusai A távozó utasítás végrehajtásra kerül Az eredmény bekerül egy eredmény sorba, vár Az adott utasítás eredménye csak akkor kerül ki a sorból (és íródik be a regiszterfájlba), ha minden idősebb utasítás eredménye már kikerült Hardverközeli programozás 1
240
Regiszter átnevezés A név függőség (WAR és WAW hazárd) esetén egy utasítás eredménye felülírna egy még szükséges értéket, mivel nincs korlátlan számú „üres” regiszter A regiszter átnevezés révén ez elkerülhető Az utasításkészlet az architekturális regiszterfájl elemeire hivatkozik Ezt egy speciális áramkör leképezi egy nagyobb méretű hardveres regiszterfájlra Hardverközeli programozás 1
241
r1 r2 r3 r4 r5 r6 r7 r8
Eredeti kód: ADD r3, r1, r2 LDR r4, [r3] SUB r3, r5, r6 STR [r7], r3 RAW hazárd
WAR hazárd
r3
átnevező logika
hw8
Átnevezés utáni kód: ADD hw3, hw1, hw2 LDR hw4, [hw3] SUB hw8, hw5, hw6 STR [hw7], hw8 WAR hazárd mentes Hardverközeli programozás 1
hw1 hw2 hw3 hw4 hw5 hw6 hw7 hw8 hw9 hw10 hw11 hw12
Hardveres regiszterek
Architekturális regiszterek
Regiszter átnevezés
Átrendezés utáni kód: ADD hw3, hw1, hw2 SUB hw8, hw5, hw6 LDR hw4, [hw3] STR [hw7], hw8 Hazárd mente 242
Spekulatív végrehajtás Olyan műveletek végrehajtása, amely lehet hogy nem is szükséges Ha később kiderül, hogy a művelet nem volt szükséges, akkor az eredményt eldobjuk Nincs üresjárat pipeline processzor esetén Változatok Mohó végrehajtás (pl. elágazásnál mindkét ág végrehajtása, ha kiderül melyik szükséges azt megtartjuk)
Jósló végrehajtás (pl. elágazás becslés) Hardverközeli programozás 1
243
Elágazás becslés Feltételes ugró utasításnál melyik a következő utasítás amit be kell tenni a pipeline-ba? Külön áramkör próbálja megbecsülni melyik ágat kell majd végrehajtani Elkezdődik a jósolt ág végrehajtása Ha kiderül, hogy a jóslat hibás a műveletek eredménye visszavonódik, egyébként időt spóroltunk (nem kellett várakozni) A pipeline hosszával (akár 30 is lehet) nő az igény a jó elágazásbecslésre Hardverközeli programozás 1
244
Szuperskalár processzorok Több utasítás végrehajtása egy órajel alatt Egy processzor magban több műveleti egység ILP és OoOE szekvenciális program esetén CPU idő [órajel] 1. 2. 3. 4. 5.
IF utasítás 1 utasítás 2 utasítás 3 utasítás 4 utasítás 5 utasítás 6 utasítás 7 utasítás 8 utasítás 9 utasítás 10
ID
pipeline fázis OF
EX
WB
utasítás 1 utasítás 2 utasítás 3 utasítás 4 utasítás 5 utasítás 6 utasítás 7 utasítás 8
utasítás 1 utasítás 2 utasítás 3 utasítás 4 utasítás 5 utasítás 6
utasítás 1 utasítás 2 utasítás 3 utasítás 4
utasítás 1 utasítás 2
Hardverközeli programozás 1
245
Vektor processzorok A CPU egy utasítást hajt végre egyszerre adatok egydimenziós tömbjén (SIMD) Nagy méretű regiszterek használata (több önálló adatot is tárol egyszerre) Újabb utasítások bevezetése ezek kezelésére Példák MMX (Intel) 3DNow! (AMD) SSE AVX Hardverközeli programozás 1
246
Vektor processzorok Skalár processzor logika Ismételd 10-szer! Olvasd be a következő utasítást! Olvasd be ezt és azt a számot! Add össze őket! Mentsd el az eredményt! Ciklusvég
Vektor processzor logika Olvasd be Olvasd be Add össze Mentsd el
az utasítást! ezt a 10 és azt a 10 számot! őket! az eredményeket! Hardverközeli programozás 1
247
Vektor processzorok MultiMedia eXtension (MMX) 64 bites regiszter (int: 1x64, 2x32, 4x16, 8x1) 8 darab (MM0-MM7) Alias-ok FPU regiszterekre (konkurenciát okoz) 3DNow! (AMD továbbfejlesztés) float-ot is használ Streaming SIMD Extensions (SSE) 128 bites regiszter (float: 4x32) 8 vagy 16 darab (XMM0-XMM15) 70 új utasítás Hardverközeli programozás 1
248
Vektor processzorok SSE2 128 bites regiszter (float: 2x64, 4x32; int: 2x64, 4x32, 8x16, 16x8) SSE3, SSE4 Újabb utasítások (+13, +47) Advanced Vector eXtensions (AVX) 256 bites regiszter (float) 8 vagy 16 darab (YMM0-YMM15) Hardverközeli programozás 1
249
Vektor processzorok AVX2 int és float adatokra is Új utasítások AVX-512 512 bites regiszter (int, float) 32 darab (ZMM0-ZMM31) AVX-512 512 bit
AVX 256 bit
ZMM0
YMM0
Hardverközeli programozás 1
MMX SSE 128 bit 64 bit
XMM0
MM0
250
VLIW processzorok Very Large Instruction Word Olyan speciálisan fordított programot igényel, amely explicit módon jelzi a párhuzamosan végrehajtható utasításokat Egy „utasítás” (ún. köteg) több kisebb, de egyszerre végrehajtható utasítást tartalmaz Szuperskalár ILP és OoOE Egyszerűbb hardver bonyolultabb fordító Utód: Explicitly Parallel Instruction Computing Hardverközeli programozás 1
251
Többmagos processzorok Egy integrált áramköri lapon több önálló feldolgozó egység kap helyet N mag esetén jobb teljesítmény és kisebb fogyasztás mint N darab egymagos CPU esetén Általában saját L1 (esetleg L2) cache, de közös L3 Cache koherencia probléma
Párhuzamos szál/folyamat futtatás (MIMD) Taszk-szintű párhuzamosság Az operációs rendszernek támogatnia kell Hardverközeli programozás 1
252
Hyper-threading Az Intel SMT (Simultaneous MultiThreading) megvalósítása Több szál kezelése magon belül Több „állapottároló” processzor elem Egy „végrehajtó” elem
Ha egy szálnak várnia kell, addig fusson a másik Minden „fizikai” mag két „logikai” magként viselkedik Az operációs rendszernek támogatás fontos Hardverközeli programozás 1
253
Többprocesszoros rendszerek Számítógép rendszer több processzorral Megosztott (shared) vagy szétosztott (distributed) memória Többmagos processzor: speciális megosztott memóriás többprocesszoros rendszer Programozás OpenMP (shared memory model) Open MPI (message passing) OGE / SGE (cluster computing) Hardverközeli programozás 1
254
NUMA architektúra
CPU
CPU busz
összeköttetés
busz RAM
RAM Hardverközeli programozás 1
csomópont 2
csomópont 1
Non-Uniform Memory Access (nem egységes memória hozzáférés) Processzorokhoz saját memória tartozik, de elérheti másik processzor memóriáját is A memóriaelérés ideje függ a memória helyétől Egyszerre több memóriaművelet is végezhető
255
Amdahl törvénye N darab processzor (szál) használata nem eredményez N-szeres gyorsulást egy folyamat végrehajtásában
ahol S a gyorsulás, T a futásidő és A a futásidő soros végrehajtású hányada 0≤A≤1
gyorsulás (S)
A=0,1
Írja be az egyenletet ideHardverközeli programozás 1
A=0,2 A=0,5 processzor szám (N) 256
Grafikus feldolgozó egység Graphics Processing Unit (GPU) Feladat: textúrák kezelés, képek renderelés, 3D grafika gyorsítás, videó kódolás, … Integrált vagy külön videokártya Gyártók: nVIDIA és ATI (AMD) Egyszerű, kis utasításkészlet Nagy számítási kapacitás (párhuzamos, SIMD) Saját memóriája lehet Csatlakozás: AGP, PCIe VGA, DVI, HDMI Hardverközeli programozás 1
257
Általános célú GPU General-Purpose GPU (GPGPU) A GPU átvesz számításokat a CPU-tól Programozás OpenCL CUDA MATLAB
Accelerated Processing Unit (APU) CPU és GPU elemekből felépülő processzor
Hardverközeli programozás 1
258
FPGA Field-Programmable Gate Array Programozható logikai áramkör Újrakonfigurálható rendszer Speciális nyelvek: VHDL, Verilog Természeténél fogva párhuzamos működés Létezik processzorba integrált FPGA Szoft processzor FPGA-n implementált processzor architektúra Hardverközeli programozás 1
259
Intel x86 architektúra Processzor felépítés Memóriakezelés Assembly nyelv
Kezdetek Az Intel 1976-78 között fejlesztette ki az „új” Intel 8086 névre hallgató processzorát Később ezt fokozatosan tovább fejlesztették Intel 80186 (1982) Intel 80286 (1982) Intel 80386 (1986) Intel 80486 (1989) …, a folyamat máig tart Az új processzorok visszafelé kompatibilisek
Ma a processzorcsaládra x86 néven hivatkozunk Hardverközeli programozás 1
261
Memória szegmentáció A memória részekre van osztva Kód szegmens Adat szegmens Verem szegmens Extra szegmens
A címzést külön regiszterek segítik (CS, DS, SS, ES) Címzés: szegmens kezdőcím + eltolás Memóriakezelés Valós-, védett-, virtuális-, hosszú mód Hardverközeli programozás 1
262
Memória szegmentáció Valós mód 8086-ban csak ez van 20 bites címbusz (1MB) Szegmens méret 64kB (16 bit) Minden memóriacím elérhető korlátozás nélkül Ilyen módban indul a processzor Lineáris cím = szegmenscím*16 + offset Lineáris cím = fizikai cím Szegmens kezdőcím (16 bit)
+
Eltolási cím (16 bit) Lineáris kezdőcím (20 bit)
Hardverközeli programozás 1
263
Memória szegmentáció Védett mód 80386 vezeti be Korlátozott memóriahozzáférés Címtér 32 bites (<= 4GB) Virtuális memória támogatás Lineáris cím (32) = szegmenscím (32) + offset (16/32) Lineáris cím lapozás fizikai cím
Virtuális mód (látszólagos valós mód 80386-tól) Hosszú mód (64 bites, nincs szegmentálás) Hardverközeli programozás 1
264
x86 regiszterkészlet AX 31
15
AH
7
AL
0
EAX EBX ECX EDX SI DI BP SP
ESI EDI EBP ESP CS DS SS
ES FS GS
EIP
IP
EFLAGS
FLAGS Hardverközeli programozás 1
265
x86 regiszterkészlet Fő regiszterek (általános célú regiszterek, GPR) EAX Elsődleges akkumulátor, szorzás, osztás
EBX Akkumulátor, bázis mutató DS-ben
ECX Akkumulátor, (ciklus)számláló
EDX Akkumulátor, input/output, szorzás, osztás Hardverközeli programozás 1
266
x86 regiszterkészlet Index regiszterek (általános célú regiszterek, GPR) ESI Sztring műveletek forrás indexe, DS regiszterrel
EDI Sztring műveletek cél indexe, ES regiszterrel
ESP Verem tetején lévő elemet címzi, SS regiszterrel
EBP Lokális változókhoz, paraméterekhez, SS regiszterrel Hardverközeli programozás 1
267
x86 regiszterkészlet Szegmens regiszterek CS Kód szegmens kezdőcíme, IP ebben címzi az utasítást
DS Adat szegmens kezdőcíme (statikus változók)
SS Verem szegmens kezdőcíme, ESP és EBP használja
ES, FS, GS Extra adat szegmens, EDI alap szegmense az ES Hardverközeli programozás 1
268
x86 regiszterkészlet EFLAGS regiszter Állapot bitek Vezérlő bitek Rendszer bitek 31
30
29
28
27
26
25
24
0
0
0
0
0
0
0
0
23
22
21
20
19
18
17
16
0
0
ID
VIP
VIF
AC
VM
RF
15
14
13
12
11
10
9
8
0
NT
OF
DF
IF
TF
7
6
5
4
3
2
1
0
SF
ZF
0
AF
0
PF
1
CF
IOPL
Hardverközeli programozás 1
269
x86 regiszterkészlet Utasítás számláló IP (Instruction pointer) CS regiszter révén a kód szegmensben található utasításokat címzi Minden „fetch-execute” ciklus során inkrementálódik az adott utasítás hosszával (kivéve vezérlésátadás)
Egyéb regiszterek Vannak további működést segítő regiszterek Programozó elől rejtettek Hardverközeli programozás 1
270
X87 regiszterkészlet Lebegőpontos egység (matematikai társprocesszor) 8 darab 64 bites regiszter (ST(0)-ST(7)) Veremszerű működés Dupla pontosságú lebegőpontos reprezentáció Regiszterenként 2 további bit 00 érvényes, 01 nulla, 10 speciális (Inf, NaN), 11 üres
16 bites állapot regiszter (pl. OE, UE, ZE, TOS, B, DE) 16 bites vezérlő regiszter (pl. RC, PC) 48 bites programszámláló és adat mutató Hardverközeli programozás 1
271
x86-64 architektúra Visszafelé kompatibilis az x86 (IA-32) architektúrával 64 bites általános célú regiszterek (RAX, RBX, RCX, RDX, RBP, RSP, RIP, RSI, RDI, R8-R15) 64 bites virtuális címek (implementációban 48) 48 bites fizikai címzés (256TB) (bővíthető 52 bitig) Nincs memória szegmentáció Működési módok Long mode, Legacy mode (real, protected, virtual) Hardverközeli programozás 1
272
Input-Output Portra leképezett I/O (PMIO) 16 bites I/O címek (0h-FFFFh) Külön utasítások (in, ins, out, outs,stb.) Egy eszközhöz több port is tartozhat Adat, Utasítás, Állapot
I/O porton elérhető fontosabb eszközök: DMA vezérlő, programozható megszakítás kezelő (8259A), időzítő (8254), billentyűzet (8042), valós idejű óra, matematikai társprocesszor, PATA vezérlő, stb.
Linux: /proc/ioports Hardverközeli programozás 1
273
Szintaxis Intel szintaxis
AT&T szintaxis
.intel_syntax noprefix .globl main main: push ebp mov ebp, esp sub esp, 16 mov DWORD PTR [ebp-16], 2 mov DWORD PTR [ebp-12], 3 cmp DWORD PTR [ebp-16], 4 jne .L2 mov eax, DWORD PTR [ebp-12] mov DWORD PTR [ebp-8], eax jmp .L3 .L2: mov DWORD PTR [ebp-8], 4 .L3: mov eax, DWORD PTR [ebp-8] add esp, 16 pop ebp ret
.att_syntax .globl main main: pushl movl subl movl movl cmpl jne movl movl jmp .L2: movl .L3: movl addl popl ret
Hardverközeli programozás 1
noprefix %ebp %esp, %ebp $16, %esp $2, -16(%ebp) $3, -12(%ebp) $4, -16(%ebp) .L2 -12(%ebp), %eax %eax, -8(%ebp) .L3 $4, -8(%ebp) -8(%ebp), %eax $16, %esp %ebp
274
Utasítások 8086: 114 utasítás 80186: +15 (új és bővített) 80286: +17 80386: +66 80486: +6 8087: +83 80287: +1 80387: +12 +Pentium, +MMX, +SSE, +AVX, +egyéb (∞) Hardverközeli programozás 1
275
Operandusok Operandusok Regiszter (8, 16, 32 bites) Konstans (8, 16, 32 bites) Memória tartalom
Memória cím és méret kényszerítés mov mov mov
al, BYTE PTR [ebx] ax, WORD PTR [ebx] eax, DWORD PTR [ebx]
Hardverközeli programozás 1
276
Címzési módok Regiszteres Közvetlen adat Közvetlen cím Közvetett regiszteres Regiszter relatív Bázisos indexelt Bázis+index relatív Skálázott Szegmens előtag
mov ax, bx mov ax, 7Fh mov ax, [1234] mov ax, [bx] mov ax, [bx + 100h] mov ax, [bx + si] mov ax, [bp + di + 123] mov ax, [si * 4 +10h] mov ax, [es:bx]
Hardverközeli programozás 1
277
Címzési módok Effektív cím (EA) megadás alakjainak összegzése , : : . : : / : 0 : 12 34 5 Szegmens szelektor
6 76 ,6 .6 8 .8 79 9 12 34 5 Bázis
6 76 ,6 .6 ∗ 8 .8 79 12 34 5 Index
1 2 4 8 12 34 5 Skálázó faktor
>?@>á4 4 55
Eltolás
Példa: mov EAX, [DS:EBP+EDI*4+10h]
vagy ugyanaz más írásmódban: mov EAX, DS:10h[EBP][EDI*4] Hardverközeli programozás 1
278
Alprogram hívási konvenció Hívó szabályai Paraméterek fordított sorrendben verembe helyezése (esetleg az alábbi sorrendben regiszterekbe: edi, esi, edx, ecx, …) Alprogram hívás (visszatérési cím a verembe kerül, programszámláló átáll az alprogram kezdőcímére) Visszatérés után veremből paraméterek kivétele Visszatérési érték az eax regiszterben van Hardverközeli programozás 1
279
Alprogram hívási konvenció Hívott szabályai Bázis pointer verembe mentés Verem mutató mentése bázis pointerbe Helyfoglalás lokális változóknak a veremben Használandó regiszterek mentése a verembe Visszatérési érték az eax regiszterbe tétele Mentett regiszterek és verem visszaállítás Visszatérés (a veremben lévő címre) Hardverközeli programozás 1
280
A C nyelv és az assembly Inline assembly C-ben asm(” mov eax, 10 ”); C forráskód fordítás assembly-re gcc-vel gcc -S -masm=intel prog.c Kimenet: prog.s Assembly forráskód fordítás gcc-vel gcc prog.s Kimenet: a.out Hardverközeli programozás 1
281
Képernyőre írás lehetőségei .TEXT:.string
"This is a text.\n"
...
# printf("This is a text.\n"); mov eax, 0 mov edi, OFFSET FLAT:.TEXT call printf # puts("This is a text.\n"); mov edi, OFFSET FLAT:.TEXT call puts # write(1,"This is a text.\n",16); mov edi, 1 mov esi, OFFSET FLAT:.TEXT mov edx, 16 call write # interrupt mov eax, 4 mov ecx, OFFSET FLAT:.TEXT mov edx, 16 int 0x80 Hardverközeli programozás 1
282
Intel 8086 Megjelenési év 1978 16 bites regiszterek 20 bites fizikai cím (1MB) 5-10 MHz órajel 3000nm technológia 29 000 tranzisztor 40 tűs DIP tokozás DMA támogatás Hardverközeli programozás 1
283
Intel 80386 Megjelenési év 1986 32 bites regiszterek 4GB-os címtér 12-40 MHz órajel 1500-1000nm technológia 275 000 – 855 000 tranzisztor 132 tűs PGA tokozás Cache, virtuális memória kezelés, pipeline Hardverközeli programozás 1
284
Intel Pentium Megjelenési év 1993 32 bites regiszterek 4GB-os címtér 60-300 MHz órajel 800-250nm technológia 3 100 000 – 4 500 000 tranzisztor 273 tűs Socket 4; 321 tűs Socket 7 aljzat Szuperskalár, MMX, L2 cache, integrált FPU Hardverközeli programozás 1
285
Intel Pentium 4 Megjelenési év 2000 32 bites regiszterek Mikroarchitektúra: NetBurst 1300-3800 MHz órajel 180-65nm technológia 42 – 188 millió tranzisztor Socket 423 vagy Socket 478 aljzat SSE3, 20-31 szintű futószalag, elágazásbecslés, HyperThread Hardverközeli programozás 1
286
Intel Core i7 Megjelenési év 2008 64 bites regiszterek (x86-64) Mikroarchitektúra: Nehalem, Sandy Bridge, Ivy Bridge, Haswell, Broadwell 45-14nm technológia 2-6 mag LGA aljzat (1000-2000 kontaktus) L3 cache, integrált GPU, AVX-512, integrált NorthBridge Hardverközeli programozás 1
287
Más architektúrák ARM 32/64 bites RISC, pl. Raspberry Pi Transmeta Crusoe alacsony fogyasztás, szoftveres ISA, VLIW MIPS 32/64 bites RISC, pl. PlayStation 2 Motorola 68000 Régi, de él. Pl. PLC-k, Apple Macintosh Microchip PIC Harvard architektúra, mikrokontroller Hardverközeli programozás 1
288
High-Performance Computing HPC - TOP 1 (2015) Tienhe-2 (Tejút 2) Kína, Guangzhou 33,86 TFLOPS számítási kapacitás 32 000 Intel Xeon (2.2GHz) + 48 000 Xeon Phi 3 120 000 mag 1375 GB memória 12400 TB háttértár 390 000 000 USD 17,6 MW fogyasztás Hardverközeli programozás 1
289