Az INTEL mikroprocesszorok architekturális fejlődésének bemutatása

Átírás

1 MISKOLCI EGYETEM GÉPÉSZMÉRNÖKI ÉS INFORMATIKAI KAR Automatizálási és Kommunikáció-technológiai Tanszék Az INTEL mikroprocesszorok architekturális SZAKDOLGOZAT Majoros Péter FAXCI Miskolc, Rákóczi Ferenc utca 28. II/2

2 Tartalomjegyzék 1.0. Bevezetés Az órajel és az IPC viszonya Alapfogalmak A processzorok típusai (CPU, GPU, APU) Flynn-féle osztályozási modell SoC és SoM A CPU stepping Az Intel processzorok fejlődéstörténete Intel Core i3, i5, i Intel Core ix technológiák Intel 22nm technológia A processzorok felépítése A mikroachitektúra aspektusai Mikroarchitekturális fogalmak RISC és CISC processzortervezési filozófia Utasítás-futószalag (pipeline) Buborék a pipeline-ban Cache Cache bejegyzések (cache entries) Cache az x86-os mikroprocesszorokban Cache teljesítmény Helyettesítési stratégiák A cache viszonya a többi adattárolóhoz Elágazás becslés Szuperskalár I

3 Története Skalártól a szuperskalárig Hyper-Threading Mit jelent a HyperThreading? A HyperThreading architektúra HyperThreading működés OpenCL up Sim Pipeline és szuperskalár végrehajtás szimulációja Hyper-Threading szimulációja OpenCL Cache szimulációja Továbbfejlesztési lehetőségek Összefoglalás Köszönetnyilvánítás Irodalomjegyzék CD melléklet tartalma II

4 BEVEZETŐ Ma már mindennapjaink szerves részét képezik a számítógépek. Ezek, bár kívülről nem látszik, többnyire rendkívül összetett és bonyolult felépítésűek. Tervezésük és programozásuk igen komoly kihívás jelent. A számítógépek talán legfontosabb eleme a központi feldolgozó egység, a CPU (Central Processing Unit), amelyet mikroprocesszornak vagy egyszerűen processzornak is hívnak. Ez hajtja végre a programozó által megadott parancsokat, irányítja és felügyeli az egész rendszer működését. Felépítését tekintve milliárdnyi tranzisztorból áll, amelyek logikai kapukba szerveződnek. Belőlük alakulnak ki az adatok tárolására alkalmas regiszterek és az adatokon műveleteket végző funkcionális egységek. A processzorok fejlesztésénél az egyik fő követelmény az, hogy a kiadott utasításokat a lehető leggyorsabban hajtsa végre. Erre az idők során számos technika alakult ki, melyek közül a legkézenfekvőbb az órajel növelése volt. Azonban, mint mindennek, ennek is megvannak a maga korlátai, amelyeken túl valami mást érdemes alkalmazni a cél érdekében. A processzorokba integrált tranzisztorok méretének csökkenésével vált lehetővé, hogy az adott méretű tokba egyre több és bonyolultabb áramköröket lehessen beépíteni. Mindezekkel pedig új lehetőségek nyíltak meg a tervezők előtt. Logikai szinten úgy tudták javítani az utasítások végrehajtásának sebességét, amelyre a puszta órajel-növelés nem lett volna képes. Szakdolgozatom ötlete azon alapul, hogy ezen teljesítmény-növelő technikák az átlagember számára kissé megfoghatatlanok. Ahhoz, hogy meg tudják érteni, milyen folyamatok zajlanak le a központi feldolgozó egységben, kisebb-nagyobb mértékben el kell mélyedniük a mikroprocesszorok világában. A mai CPU-kat tekintve ez egyre nehezebb feladat, mivel az architektúrák folyamatosan fejlődnek és bonyolódnak. Éppen ezért, hogy a mai processzorokban jelenlévő legfontosabb technikák mégis jól érthetőek legyenek, készítek egy olyan szimulációs programot, amely ezek működését mutatja be vizuálisan, animációk segítségével. Továbbá arra is lehetőséget biztosítok, hogy kipróbálható legyen, milyen lenne az utasítások feldolgozása, ha mindezek nem lennének jelen a processzorokban. Ennek keretében a legelterjedtebb technikák közül a pipeline és szuperskalár elvű feldolgozást és a cache-elést ismertetem. Kitérek továbbá az Intel processzorokban gyakori Hyper-Threading technológiára és a napjainkban egyre nagyobb teret és támogatást nyerő, a különféle számító egységek minél nagyobb kihasználását megcélzó OpenCL-re is. 1

5 ABSTRACT Computers are essential parts of our everyday life. These are mostly very complex and elaborate constructions, altough it does not appear from the outside. Designing and programming them means a serious challenge. Maybe the computers most significant part is the Central Processing Unit (CPU), which is also called microprocessor or simply processor. This executes the commands given by the programmer, controls and supervises the operating of the entire system. Concerning its construction it is made up of billions of transistors, which are organized into logical gates. These build up the registers, that are capable of storing data, and the functional units, executing operations on the data. One of the main goals during developing processors is to execute the given instructions as fast as possible. In the meantime several techniques evolved among which the most obvious was increasing the clock-cycle. However, as everything, it has its own limits beyond which it is worth applying someting else for the goal. As the size of the transistors integrated into processors decreased, became possible to build into the given size package even more in number and more complex circuits. Thanks to these, new opportunities arose for designers. At logical level they could speed up the execution of instructions, that would not be possible by merely increasing the clock-cycles. In my view these performance increasing techniques may be fuzzy for average people, which gives the base idea of my paper. In order to understand the processes in the Central Processing Unit, aquiring smaller or bigger background knowledge in the world of microprocessors is required. Concerning recent CPUs it can be a difficult task, because the architectures are constantly evolving and getting more complex. Due to this situation, to make the most important techniques in today's processors more clear, I develop a simulation program, which presents their operations visually, with the aid of animations. Furthermore I offer the option to try out the execution of instructions if these techniques were not present in processors. Among the most common techniques I present the pipeline and superscalar processing and caching. I also include Hyper-Threading technology, which is common in Intel processors; and OpenCL, recently gaining more and more ground and support, which targets the higher utilization of various computing units. 2

6 1.0. Bevezetés Az INTEL mikroprocesszorok architekturális Szakdolgozatomban a mai processzorokban megtalálható, azok számítási teljesítményére a legnagyobb hatást gyakoroló technikákkal foglalkozom. Célom egy olyan szimulációs szoftver készítése, amellyel látványosan és közérthetően prezentálhatóak ezen technikák és technológiák működése. Véleményem szerint az emberek könnyebben érthetik meg a processzorokban lezajló folyamatokat, ha ezeket egy-egy, kellőképpen leegyszerűsített animációkon keresztül láthatják. A ma legmeghatározóbb módszerek és megoldások közül ötöt emelek ki: a pipeline és a szuperskalár elvű feldolgozást, az Intel Hyper-Threading-et, a cache-elést és az OpenCL-t. Az első kettő két, egymástól független technika, de a program megírása szempontjából előnyösnek tartom, ha együtt mutatom be őket. Természetesen a valós implementációk eltérhetnek a szimulációkban megjelenő működéstől. Ennek vagy az az oka, hogy az érthetőség kedvéért bizonyos dolgokat leegyszerűsítek, vagy az, hogy az adott technikára számos, egymástól eltérő megoldás is létezik a piacon. Az első fejezetekben a mikroprocesszorok világát ismertetem. Utána bemutatom az Intel x86 processzorcsalád fejlődését és számos, ezekben megtalálható teljesítmény-növelő technikát részletesen is kifejtek. Ezt követően öt módszert kiemelve egy szimulációs, oktatási célra is alkalmas szoftvert készítek. A szakdolgozatban szereplő saját ábráim megtalálhatóak eredeti méretükben a CDmelléklet Photos jegyzékében. A szoftverem végrehajtható fájljai a Releases, a forráskód az up Sim jegyzékekben lesznek megtalálhatóak. A processzor architektúrák fejlődésének hátterében az egy tokba integrált tranzisztorok csíkszélességének folyamatos csökkenése áll. Ennek köszönhetően egyre több és több hely áll a tervezőmérnökök rendelkezésére, amely teret nyit az egyre komplexebb vezérlési logikák és módszerek megvalósítására. A gyártási csíkszélesség csökkenésének további jótékony hatása, hogy kevesebb energia szükséges a logikai áramkörök működtetéséhez és így a veszteségként kibocsátott hő mennyisége is kevesebb lesz. A tervezőknek kompromisszumot kell kötniük azt illetően, hogy a felszabaduló helyet a teljesítmény növelésére fordítják, és emiatt a fogyasztás és hőtermelés változatlan marad, vagy pedig ugyanazon a teljesítményszint mellett az alacsony fogyasztást helyezik előtérbe, esetleg egy köztes megoldást választanak. Általában mindháromnak van 3

7 létjogosultsága, így mindig az adott alkalmazás dönti el, hogy milyen célra optimalizált processzorra van szükség. Amennyiben elvonatkoztatunk a processzoroktól és pusztán elvi síkon vizsgáljuk a dolgozatban részletesen ismertetett technikákat, akkor észrevehetjük, hogy ezek az elgondolások tulajdonképpen nagyon hasonlítanak a termelő vállalatok gyártósorán fellépő problémákhoz és megoldásokhoz. Ebből a szemszögből nézve szinte mindegy, hogy elektronikusan kódolt utasításról, vagy egy megmunkálandó munkadarabról van-e szó, a lényeg a termelékenység maximalizálása. Ahogy a valóságos futószalagon egymás után, a megmunkálás különböző fázisaiban egyszerre vannak jelen a gyártmányok, úgy a gépi kódú utasítások feldolgozása is átlapoltan történik. A munkadarabok műveletközi vagy raktárbeli tárolása vagy szállítása is kulcsfontosságú a termelés szempontjából, akár csak egy számítógépben a gyorsítótárak, memóriák, háttértárak mérete és azok elérésének sebessége Az órajel és az IPC viszonya Talán már elmúltak azok az idők, amikor az emberek azt hitték, hogy a magasabb órajelű CPU a gyorsabb. Ez az általános nézet anno a Pentium 4 bemutatkozásával terjedt el (pontosabban az Intel próbálta terjeszteni), majd később az AMD Athlon megjelenése mutatott rá arra, hogy nem igaz. Egy adott processzor teljesítményét két szimpla változó szorzatának eredményeként kapjuk meg. Ezek a változók az órajel (pl. 2,6 GHz) és az IPC, azaz Instructions Per Cycle, magyarul egy órajelciklus alatt elvégzett műveletek száma. Egyértelmű, hogy két CPU közül a magasabb órajelű a gyorsabb, ha ugyanolyan IPC-vel rendelkeznek, tehát ha két azonos típusról van szó (pl. két Core i5 vagy két Phenom II X6). Ellenben ha két különböző típusú CPU-ról beszélünk, akkor az órajel ismerete önmagában nem elég ahhoz, hogy kiderüljön, melyik CPU a gyorsabb. Azt, hogy egy adott CPU milyen IPC-vel rendelkezik, nem lehet konkrétan meghatározni, hiszen tudni kellene azt is, hogy milyen műveletről van szó, azonban a CPU-tesztek ki szokták mutatni, ha egy adott architektúra azonos órajelen gyorsabb, mint egy másik. [1] 1.2. Alapfogalmak Adatút: a processzor azon része, ami tartalmazza az ALU-t bemeneteivel és kimeneteivel együtt. 4

8 Aritmetical Logic Unit (ALU): aritmetikai és logikai egység. A processzornak ez a része végzi a matematikai és logikai műveleteket. Egyszerű logikai áramkörből épül fel: összeadni, léptetni, összehasonlítani és invertálni tud. Control Unit (CU): vezérlőegység. Irányítja a feldolgozás folyamatát, a számítógép működését ütemezi. EM64T: az Intel 64-bites az AMD-től licenszelt utasításkészlete. Teljesen megegyezik az AMD64-gyel. Regiszterek: nagyon kicsi elérési idővel rendelkező átmeneti tárolók. Tranzisztor (kapcsoló módú): Elektronikus kapcsoló, melynek két állása van: zárt és nyitott. Zárt állapot alatt a tranzisztor ellenállásként viselkedik, a bemeneti feszültség alacsony, ennek megfelelően a kimeneti feszültség megegyezik a Vcc értékével. Ahhoz, hogy a tranzisztor nyitott állapotba kerüljön, a bemeneti feszültségnek meg kell haladnia egy kritikus értéket, ilyenkor a tranzisztor kinyit, és vezetékként viselkedik, ennek következtében a kimeneti feszültséget lehúzza 0 V-ra. A két állapot a logikai 0-át és a logikai 1-et hivatott reprezentálni. Utasítás-végrehajtás ütemezése: In order: Az utasítások végrehajtása szigorúan a beérkezett sorrendben történik. Out of order: Az ütemezésben lehetőség van az utasítások sorrendtől eltérő végrehajtására is, ha a hardver számára így kedvezőbb lesz. x86: az Intel által kifejlesztett utasításkészlet. Lehetőséget ad a fejlesztőknek a 8086/8088 alapú processzor programozására. Mindegyik IBM PC kompatibilis processzor támogatja. AMD64: az AMD által kifejlesztett 64-bites utasításkészlet. Nagy előnye, hogy támogatja a 32-bites architektúrára írt programok futtatását. Kihasználásához 64-bites Windows operációs rendszer vagy 64-bites Linux disztribúció szükséges. [2] Complex Instruction Set Computer (CISC): összetett utasításkészletű számítógép. Olyan architektúrát jelent, amelyben bonyolultabb utasításokkal írják le a programot. Előnye, hogy a programozó számára emberközelibb parancsokat biztosít, amelyekkel a programok könnyebben megírhatóak, ráadásul rövidebbek is lesznek. Hátránya, hogy egy ilyen utasítás végrehajtása több időt vesz igénybe a kód rövidsége ellenére, mivel a processzor több elemi utasításra bontja ezeket. Ráadásul a CISC-processzorok belső felépítése is bonyolultabb. Reduced Instruction Set Computer (RISC): csökkentett utasításkészletű számítógép. A CISC lassúságának kiküszöbölésére hozták létre. Rövidebb, egységnyi 5

9 végrehajtási idejű utasításokat tartalmaz. Kevésbé összetett utasításokat és egyszerűbb memóriakezelést biztosít, a CISC-hez képest pedig sokkal több általános célú regisztert használ. További előnye, hogy a processzor felépítése is egyszerűsödik. Streaming SIMD Extensions (SSE): a SIMD utasításkészlet kiegészítése az x86 architektúrához. Jelenleg a negyedik verziójánál tart (SSE4.2). Floating-point unit (FPU): lebegőpontos egység. Egy olyan részegysége a CPUnak, amelyet kifejezetten a lebegőpontos (valós) számokkal történő számolásra fejlesztettek ki A processzorok típusai (CPU, GPU, APU) Bár a processzor, mint fogalom általánosan kezelendő, vagyis minden esetben egy számolásra alkalmas lapkát jelent, ám a gyakorlatban azért ez nem ilyen triviális, hiszen a különböző igények különböző hardveres felépítést is igényelnek. Ennek hála már követni sem lehet, hogy a CPU, a GPU, illetve a SoC (System on a Chip) mellett felmerülő rövidítéseket, de ugyanakkor ezek kellően logikus módon vannak felépítve, így könnyű megérteni, hogy az elnevezés mögött mi rejlik. Nagyon leegyszerűsítve mindegyik processzor ugyanazt csinálja, vagyis a bemeneti információkon, illetve adatokon különböző feladatokat végeznek, majd az eredményt a kimenetre továbbítják. A főbb különbségeket az adja, hogy ezt hogyan teszik meg. 1. ábra: CPU CPU: A CPU (Central Processing Unit), azaz a központi feldolgozó egység talán a legrégebbi fogalom, és jellemzően csak processzorként szokás emlegetni. Sokan a számítógép agyaként jellemzik, ami kétségtelenül egy végletekig leegyszerűsített és sarkított meghatározás, de nem áll távol a valóságtól. Ez az egység minden számítógépben megtalálható, és lényegében az egész rendszer működéséért és a programok futtatásáért 6

10 felel. A CPU alapvető eleme a processzormag, ami lényegében elvégzi az adott feladatokat. Ezen a ponton beszélhetünk egymagos, illetve homogén többmagos CPU-ról. A rendkívül egyszerű meghatározás definiálja a lényeget, vagyis előbbi esetben a CPU-nak csak egyetlen processzormagja van, míg utóbbinál már több mag is található a lapkában. A CPU-kban található processzormag teljesítménye igen széles skálán mozoghat, és eszerint változik az adott egység teljesítménye és fogyasztása. Nyilvánvaló, hogy a nagyobb teljesítmény több energiát is igényel. A processzormagok általános jellemzője, hogy kevés, jellemzően egy vagy két feldolgozási szállal dolgoznak, de nem kizárt, hogy esetenként a szélesebb futószalagra több szálat érdemes bevetni. A szoftver a CPU-t a feldolgozási szálak alapján kezeli, és mindegyik szálra amolyan logikai feldolgozóként tekint. Mivel minden program más, így előfordulhat, hogy az adott feladat csak egy szálon hajtható végre, így ilyenkor a CPU többi erőforrása kihasználatlan marad. Mivel manapság már a többmagos CPU-k időszakát éljük, így törekedni kell arra, hogy az adott program a lehető legtöbb feldolgozási szálat hasznosítsa, amivel optimálisabban használhatók ki a jelen kor hardvereinek tudása. A CPU-kat egyébként alapvetően úgy tervezik, hogy a lehetőségekhez mérten magas legyen az egy szálon leadott teljesítményük, így ez a processzortípus, főleg a soros és a feladat párhuzamos feldolgozást kedveli, ám kevésbé hatékony az adatpárhuzamos forma mellett. Utóbbi probléma nem a funkcionális működés során merül fel, hanem az energiahatékonyság területén, ugyanis a mai CPU-kon egy operáció végrehajtása több, mint 1000 pj energiát is felemészt. Ez a szám a többi processzortípus paramétereihez képest borzalmasan magas. 2. ábra: GPU GPU: A GPU (Graphics Processing Unit), azaz a grafikus feldolgozó egység egy speciális igény kielégítésére született meg. Ahogy fentebb említettük, a CPU kifejezetten 7

11 nem hatékony az adatpárhuzamos feladatok végrehajtására, márpedig a számítógépes grafika pont ilyen elvű feldolgozást igényel. Ennek megfelelően pár évtizeddel ezelőtt speciális chip-ek kezdték ellepni a piacot, melyek lényegében csak a grafikai feladatok feldolgozására törekedtek, és ezen a területen nagyságrendekkel gyorsabbak, illetve hatékonyabbak voltak a CPU-knál. Az évek során a piac kinőtte magát, és ma már gyakorlatilag elképzelhetetlen egy számítógép működése egy modern GPU nélkül. Az általános fejlődés nem csak az egyre gyorsabb, hanem egyre okosabb GPU-kat is szült, így a kezdeti kifejezetten butának tekinthető, de az úgynevezett bedrótozott grafikai számítások szempontjából nagyon is jó grafikus chipeket olyan GPU-k váltották le, melyek egyre inkább törekedtek arra, hogy a lapkán belüli fixfunkciós részegységeket általánosabb feldolgozók váltsák le. Ezzel a GPU-kat egyre hatékonyabban lehetett programozni, és ma már ott tartunk, hogy a legmodernebb megoldások logikai felépítése nem sokban különbözik egy CPU processzormagjától. A mai GPU-k esetében a processzormaghoz hasonlítható feldolgozót multiprocesszornak szokás nevezni, és ezzel egy új fogalom is született, ami a GPGPU (General-Purpose computing on Graphics Processing Units). Ez lényegében arról szól, hogy a grafikus feldolgozó egység számítási teljesítményét nem csak grafikai számításra lehet befogni. Ha a logikai felépítésben nem is, de az elvi működés szintjén komoly különbségek vannak a processzormagok és a multiprocesszorok között. Nagyon leegyszerűsítve az egységek előnyei is hátrányai felcserélődnek. Ahogy fentebb említettük, a CPU processzormagja a jellemző felépítés okán nem éppen ideális az adatpárhuzamos számításokhoz. A GPU-k kifejezetten itt domborítanak, mivel a multiprocesszorok rendkívül sok feldolgozót használnak, és száz vagy akár ezer szálat is kezelnek egyszerre. A más elvek szerint működő felépítés az energiahatékonyságra is nagy hatással van, mivel a GPU-k esetében egy operáció végrehajtása kevesebb, mint 200 pj energiát is igényel. A GPU-k ugyanakkor nem kifejezetten kedvelik a soros és a feladat párhuzamos feldolgozást, noha nyilván képesek végrehajtani, ahogy a CPU is képes az adatpárhuzamos feldolgozásra. 8

12 3. ábra: APU APU: Az APU (Accelerated Processing Unit), azaz a gyorsított feldolgozó egység egy relatíve új fogalom, és alapvetően arról szól, hogy a CPU és a GPU előnyeit egy lapkában egyesítse. Ennek megfelelően a célja, hogy a soros és a feladat párhuzamos feldolgozás a központi processzormagokon, míg az adatpárhuzamos számítások az integrált grafikus vezérlő multiprocesszorain legyenek végrehajtva. Elméleti szinten így érhető el a leggyorsabb és a leghatékonyabb feldolgozás, mivel bizonyos feladatok nem bonthatók több szálra, míg számos algoritmus kifejezetten jól párhuzamosítható. Az elv hatékony működéséhez azonban a processzormagoknak és a multiprocesszoroknak közös címteret kell használni, illetve szükséges, hogy teljesen koherens memóriát osszanak meg egymással. [3] 1.4. Flynn-féle osztályozási modell Az általános célú párhuzamos rendszerek kategorizálására az évek során több modell is kialakult, ám Michael J. Flynn nevéhez fűződik a legelterjedtebb, széles körben alkalmazott osztályozási modell, ami az adatok kezelése alapján állítja fel az alábbi kategóriákat: SISD (Single Instruction Single Data): a végrehajtó egy órajelciklus alatt egy utasítást végez egy adaton. Klasszikus szekvenciális rendszer. Az ilyen elvű egységeket skalárfeldolgozónak nevezzük. Példa: Neumann-féle számítógép. SIMD (Single Instruction Multiple Data): a végrehajtó egy órajelciklus alatt egy utasítást végez több adaton. Az ilyen elvű egységeket vektorfeldolgozónak nevezzük. Példa: vektorprocesszor, tömbprocesszor. 9

13 MISD (Multiple Instruction Single Data): a végrehajtó egy órajelciklus alatt több utasítást végez egy adaton. Létezése vitatható, hiszen eleve furcsa, hogy több utasítást adunk ki ugyanarra az adatra, de némi megkötéssel besorolhatók ide a csővezetékes gépek. MIMD (Multiple Instruction Multiple Data): a végrehajtó egy órajelciklus alatt több utasítást végez több adaton. Az ilyen elvű egységek a szuperskalár feldolgozók. Példa: multiprocesszor, multiszámítógép. [4] 1.5. SoC és SoM A SoC rövidítés mögött a system on a chip vagyis rendszer egy chipben kifejezés áll. Olyan lapkáról van szó, ami a számítógép működéséhez szükséges minden (vagy majdnem minden) komponenst tartalmaz. Jellemzően központi végrehajtó egységek (processzormagok), specializált végrehajtó egységek (például grafikus mag, videokódolást gyorsító mag, 2D megjelenést gyorsító mag stb.), memóriavezérlő (esetleg memóriamodulok) és perifériavezérlők (például USB, SATA vagy PCI Express) vannak benne adatbuszokkal összekötve, de más komponensek (például Wi-Fi vagy 3G modem) is jelen lehetnek. Olyan helyen használják őket, ahol fontos a kis méret, integráltság. Jellemzően okostelefonokban, tabletekben és egyéb kézi készülékekben találkozunk velük, de jelen vannak a tévékben, nagyobb háztartási gépekben, autókban, ipari gépekben. Igazság szerint kevés esetben elég pusztán az egyetlen chipbe zárt SoC a rendszer működéséhez, a különböző konfigurációk kiépítéséhez a memóriamodulok, egyéb egységekeket (például 3G modem, GPS, stb.) külön chipben valósítják meg, így születnek a SoM (System on Module) vagyis egy modulon működő rendszerek. Tipikusan ilyenekkel szerelik az okostelefonokat vagy táblagépeket, ahol egy-egy extra chip felhasználásának kérdése a 3G modemmel, GPS-sel vagy éppen több memóriával szerelt változat. [5] 1.6. A CPU stepping A stepping a processzor gyártásánál felhasznált szilíciumlapka hardveres verziószámát jelöli. Néhány helyen revízióként is emlegetik, így angol nyelvű anyagokban sokszor csak revison kifejezés alatt találkozhatunk vele. A jelölés az esetek többségében egy betűből és egy számból áll, például C2. Amennyiben csak a szám emelkedik, akkor egy kisebb módosításról beszélhetünk, míg ezzel szemben a betű változása minden esetben egy nagyobb horderejű korrekcióról vagy újításról árulkodik. 10

14 Magasabb stepping szám/kód többnyire azt jelenti, hogy néhány hibát orvosoltak, illetve és/vagy a gyártástechnológiában történt nagyobb módosítás. Például cserélték a tranzisztorkészletet, más anyagot vetettek be, vagy egyszerűen csak valamilyen áttörést értek el, minek okán magasabb órajel és/vagy alacsonyabb fogyasztás várható az új verziótól. 4. ábra: AIDA64 CPUID: rendszerinformációs szoftver Régóta ismert tény, hogy a processzorokat komplex felépítésük miatt gyakorlatilag képtelenség hibátlanra tervezni, ennek következtében a gyártók termékeikről nyilvános hibajegyzéket (errata) készítenek, és az esetek többségében ezeket a hibákat javítják is, ha tudják, vagy ha épp szükségesnek találják. Jó néhány ilyen errata sosem került javításra, aminek oka, hogy nem befolyásolja komolyan az adott CPU működését. Ugyanakkor vannak komolyabb hibák is, amelyekre a tervezők már jóval nagyobb hangsúlyt fektetnek, és ezek miatt akár egy új stepping is születhet. Erre egy jó példa az AMD első négymagos, Barcelona nevű processzora, mely egy olyan, a TLB-t (Translation lookaside buffer, címfordítási puffer) érintő hibát tartalmazott, ami miatt később egy teljesen új stepping-et volt kénytelen kiadni a vállalat (B2 -> B3), amiben javításra került ez a hiba (is). Emellett az új stepping még sok más egyébben is változást hozhat. Például javíthatnak az integrált memóriavezérlő kompatibilitásán, vagy épp hatékonyabbá tehetik az energiagazdálkodást. Arra is mutatott már példát a processzortörténelem, hogy a stepping egy új utasításkészlettel is előrukkolt. Az AMD néhány évvel ezelőtti, E3 stepping-es Venice kódnevű lapkája erre kiváló példa, mely az előd D0 revíziójú Winchesterhez képest az 11

15 SSE3-mal gyarapította az akkori Athlon 64 utasításkészleteinek listáját. Fontos megjegyezni, hogy ebben az esetben a vállalat a stepping mellett a kódnevet is megváltoztatta (Winchester -> Venice), amire azért volt szükség, mert az SSE3-mal bekerült a listába egy számítási teljesítményt befolyásoló módosítás is. Amennyiben a kódnév változatlan marad, akkor az IPC nem változott a korábbi stepping-hez képest. A gyártástechnológiák folyamatos fejlesztéséből adódóan az újabb stepping-ek az esetek döntő többségében magasabb mértékű túlhajtásra adnak lehetőséget, bár már arra is láthattunk példát, hogy az újabb revíziónál kis mértékben csökkent a tuning-potenciál. 5. ábra: C3 steppinges Phenom II X4 955 A stepping-et akár a CPU tokozásától is le tudjuk olvasni. Az Intel esetében az ötjegyű sspec jelölés (pl.: SR00C, SR0PL) alapján tudjuk meghatározni, míg az AMD-nél a jóval hosszabb OPN jelölés utolsó két betűje alapján tudunk következtetni. Példa: a C2 és C3 stepping-es Phenom II X4 955 (5. ábra), ahol az előbbi kupakján a HDZ955FBK4DGI jelölés látható, míg utóbbinál már a HDZ955FBK4DGM sort láthatjuk. Az Intel és az AMD termékazonosító adatbázisa a következő linkeken keresztül érhető el: Intel ARK: AMD termékek: [6] 2. Az Intel processzorok fejlődéstörténete Moore-törvénye: 1965-ben az Intel egyik társalapítója, Gordon Moore azt jósolta, hogy az egy chip-be integrált tranzisztorok száma körülbelül kétévente megduplázódik. Azóta is Moore-törvényétől hajtva, az Intel technológiai forradalma folyamatosan tart, exponenciálisan növelve a processzorokba integrált tranzisztorok számát, mindezzel jobb teljesítményt és energiahatékonyságot érve el. [7] 12

16 Megjegyzés: a fejezet alábbi részében közölt tranzisztorszám becslés jellegű. A processzorok neve utáni zárójelben az alábbi adatokat adom meg: megjelenés ideje, kezdeti órajel, tranzisztorok száma, gyártási technológia. Intel 4004 (1971, 108 KHz, 2 300, 10 μm): Az úttörő Intel 4004 processzor ugyanakkora számítási kapacitással mutatkozott be, mint az ENIAC. Intel 8008 (1972, KHz, 3 500, 10 μm): Az Intel 8008 kétszer olyan erős volt, mint az Intel 4004 processzor. Intel 8080 (1974, 2 MHz, 4 500, 6 μm): Az Intel 8080 rendelkezett olyan tulajdonságokkal, amelyek lehetővé tették a videó-játékokat és az otthoni számítógépeket. Intel 8086 (1978, 5 MHz, , 3 μm): Ez volt az első 16-bites processzor, és teljesítménye csaknem tízszerese volt az elődeinek. Intel 8088 (1979, 5 MHz, , 3 μm): Az IBM új személyi számítógépeiben, az IBM PC-kben ezek a processzorok működtek. Intel 286 (1982, 6 MHz, , 1,5 μm): Az Intel 286 volt az első olyan processzor, amelyik az összes elődjére írt programot futtatni tudta. Intel 386 (1985, 16 MHz, , 1,5 μm): Képes volt több szoftver egyidejű futtatására (multi-tasking), és több mint 100-szor annyi tranzisztort tartalmazott, mint az eredeti Intel Intel 486 (1989, 25 MHz, , 1 μm): Az Intel 486 vezette be a Floating Point Unit-ot. A processzor képességei révén lehetett ténylegesen leváltani a parancssoros felhasználói felületet, és grafikusra áttérni. Intel Pentium (1993, 66 MHz, , 0,8 μm): Az Intel Pentium 112 millió parancs/másodperc-es sebessége tette lehetővé az olyan, valós világból származó adatok feldolgozását, mint például a beszéd, hang, kézírás és képfeldolgozás. Intel Pentium Pro (1995, 200 MHz, , 0,6 μm): A Dynamic Execution technológiának köszönhetően nagyban megnőtt a teljesítménye az előző generációkéhoz képest. Támogatta a fejlett 3D-s vizualizációt és interaktív működést. Intel Pentium II, Intel Pentium II Xeon (1997, 300 MHz, , 25 μm): A Pentium II jelentős teljesítmény-növekedése a P6 mikro-architektúra és a multimédiát támogató Intel MMX ötvözésének eredménye volt. Intel Pentium III, Intel Pentium III Xeon (1999, 500 MHz, , 0,18 μm): A Pentium III az Internet Streaming SIMD Extensions -t hajtotta végre, kiterjesztette a 13

17 processzor azonosítás koncepcióját, és többféle alacsony-fogyasztású üzemmódot is használt, hogy a tétlen állapotokban kevesebb energiát fogyasszon. Intel Pentium IV (2000), Intel Xeon (2001) (1,5 GHz, , 0,18 μm): A Pentium IV a nanotechnológiás korszak előfutára. Intel Pentium M (2002, 1,7 GHz, , 90 nm): A Pentium M, az Intel 855 chipset-család és az Intel PRO/Wireless 2100 hálózati csatlakozás az Intel Centrino processzor technológia három alapkomponense. Az Intel Centrino-t kifejezetten hordozható eszközök számára tervezték. Intel Itanium 2 (2002, 1,0 GHz, , 0,13 μm): Az Itanium 2 az első Itanium processzor örököse. Az architektúrája az Explicitly Parallel Instruction Computing (EPIC) -en alapul. Ez elvileg képes nagyjából 8-szor annyi munkát elvégezni egy órajel-ciklus alatt, mint bármelyik másik CISC vagy RISC architektúra. Intel Pentium D (2005, 3,2 GHz, , 65 nm): A Pentium D az első két teljes maggal rendelkező asztali processzor, amelyben mindkét mag azonos órajelen dolgozik és egy fizikai csomagban vannak. Intel Core 2 Duo, Intel Core 2 Extreme, Dual-Core Intel Xeon (2006, 2,93 GHz, , 65 nm): Az Intel Core 2 Duo a Pentium M mobil-mikroarchitektúráját optimalizálja és számos architekturális innovációval fejleszti. Az Intel Centrino Pro és Intel vpro processzor technológiák kiváló teljesítményt nyújtanak a kétmagos Core 2 Duo-k számára. Dual-Core Intel Itanium 2, 9000-es sorozat (2006, 1,66 GHz, , 90 nm): A Dual-Core Intel Itanium es sorozatának teljesítménye túlszárnyalja a korábbi egymagos, Itanium 2 processzorokét. A több mint 1,7 milliárd tranzisztorával és két végrehajtó egységével a korábbi Itanium-oknál kétszer gyorsabbak, miközben csökkentik az átlagos energiafelhasználást. Quad-Core Intel Xeon, Quad-Core Intel Core 2 Extreme (2006), Intel Core 2 Quad (2007) (2,66, GHz, , 65 nm): A Core 2 Quad sosem látott ereje mögött a négy, teljes értékű processzormag áll, amelyek a Core mikroarchitektúrára épülnek. A Quad-Core Intel Xeon 50%-al nagyobb teljesítményre képes, mint a piacvezető Dual-Core Intel Xeon ugyan abban a fogyasztási kategóriában. Quad-Core Intel Xeon (Penryn), Dual-Core Intel Xeon (Penryn), Quad-Core Intel Core 2 Extreme (Penryn) (2007, > 3 GHz, , 45 nm): Az Intel következő generációs, Penryn kódnevű Core 2 processzor családja piacvezető mikroarchitekturális fejlesztéseket tartalmaz. Az új SSE4 instrukciók javítják a videók, képek és 3D tartalmak 14

18 teljesítményét, és új energiagazdálkodási képességekkel is kiegészült. Ezek a fejlesztések tovább erősítik a Penryn processzor-család elsőségét a szegmensben. [7] 2.1. Intel Core i3, i5, i7 Az alábbi 1. táblázatban közölt adatok csupán tájékoztató jellegűek, a konkrét specifikáció eltérhet az itt leírtaktól. Az adatok gyűjtésénél a processzorba integrált technológiák meglétének a vizsgálata volt a fő cél, és csak az asztali változatra vonatkoznak. Emiatt az egész sorozatra (i3, i5, i7) jellemző tulajdonságokat külön kiemelem. Az Intel Core ix sorozat már a negyedik generációban jár, fejlesztésük a mai napig tart. Dolgozatomban a mobil illetve szerver processzorokkal nem foglalkozom. A modelltől függő bejegyzés akkor szerepel, ha nem minden processzorhoz adtak meg adatot, és emiatt nem egyértelműen megállapítható az adott tulajdonság megléte, vagy pedig vannak olyan modellek, amelyek rendelkeznek a megadott tulajdonsággal, és vannak, amelyek nem. A nincs adat kifejezést akkor használom, amikor a gyártó (Intel) hivatalosan semmilyen információt nem közölt az adott tulajdonságról. [8] Intel Core i3 Intel Core i5 Intel Core i7 Intel Core Megjelenés éve Órajel: 2,5-3,4 GHz 2,3-3,6 GHz Magok száma / Szálak száma (akár 3,86 GHz turbóval) 2,5-3,6 GHz (akár 3,8 GHz turbóval) i7 Extreme 3,2-3,5 GHz (akár 4 GHz turbóval) 2 / 4 2 / 4, 4 / 4 4 / 8, 6 / 12 4 / 8, 6 / 12 Cache 3-4 MB 3-8 MB 8-12 MB 8-15 MB Utasításkészlet Gyártási technológia Memória: SSE4.2; SSE4.1/4.2, AVX; 64-bit SSE4.2; SSE4.1/4.2, AVX; 64-bit SSE4.2; SSE4.1/4.2, AVX; AVX; 64-bit SSE4.2, SSE4.2; SSE4.2, AVX; 64-bit nm nm nm nm max GB, 2 csatorna max GB, 2 csatorna max GB, 2-4 csatorna max GB, 3-4 csatorna 15

19 Integrált mag Grafikai órajele videó mag Az INTEL mikroprocesszorok architekturális modelltől függő modelltől függő modelltől függő nincs adat MHz MHz 650 MHz nincs adat Intel Quick Sync Video Intel InTru 3D Technology Intel Wireless Display Intel Flexible Display Interface (Intel FDI) Intel Clear Video HD Technology Dual Display Capable Tranzisztorok száma (millió) Intel Hyper- Threading Technology (HT) Intel Turbo Boost Technology Intel Virtualization Technology for Directed I/O (VTd) Intel Trusted Execution modelltől függő modelltől függő modelltől függő nincs adat modelltől függő modelltől függő modelltől függő nincs adat modelltől függő modelltől függő modelltől függő nincs adat igen igen modelltől függő nincs adat igen igen modelltől függő nincs adat modelltől függő modelltől függő modelltől függő nincs adat igen modelltől függő igen igen nem igen, 1.X vagy igen, 1.X vagy igen, 1.X vagy 2.0 nem modelltől függő modelltől függő modelltől függő nem modelltől függő modelltől függő nem 16

20 Technology Az INTEL mikroprocesszorok architekturális Intel 64 igen igen igen igen Intel Demand Based Switching nem nem nem modelltől függő Idle States igen igen igen igen Enhanced SpeedStep Technology Thermal Monitoring Technologies Execute Bit Intel Disable igen igen igen igen modelltől függő modelltől függő modelltől függő modelltől függő igen igen igen igen 1. táblázat: a 3. generációs Intel i3, i5, i7 és i7 Extreme processzorok főbb tulajdonságai és az általuk támogatott technológiák. [8] 2.2. Intel Core ix technológiák Az alábbiakban azokat az Intel technológiákat tekintem át röviden, amelyek egy harmadik generációs, asztali Core ix (i3, i5, i7, i7 Extreme) processzorban előfordulhatnak. Intel Hyper-Threading Technology (Intel HT Technology): minden egyes fizikai magon 2 szoftveres szál végrehajtását valósítja meg. Ennek előnye, hogy a többszálas alkalmazások valódi párhuzamosságban futhatnak, és feldolgozásuk jóval kevesebb időt igényel. Intel Turbo Boost Technology: szükség esetén dinamikusan megnöveli a processzor órajelét kihasználva a termikus- és energiatartalékokat, amelyek még a rendszerben vannak (ha nem volt az IC eddig a túlmelegedés határán és a tápegység is bírja). Ezzel jelentősen javítja a teljesítményt, ha pedig erre nincs szükség, akkor csökkenti az energiafelhasználást. Intel Virtualization Technology for Directed I/O (VT-d): a már korábban megjelent IA-32 (VT-x) és Itanium (VT-i) virtualizáció továbbfejlesztése. Az eddigi hardveres támogatás a I/O-eszközök virtualizációjával egészül ki. Elsősorban azok profitálhatnak belőle, akik virtuális rendszereket használnak, mert a megbízhatóság és biztonság javításán túl a virtuális I/O teljesítményét is fokozza. 17

21 Intel Trusted Execution Technology: egy sokoldalú biztonsági kiegészítése az Intel processzoroknak és chipset-eknek, amelyek a digitális platformokat olyan védelmi képességekkel ruházza fel, mint a mért indítás (measured launch) és védett végrehajtás (protected execution). A lényege, hogy egy olyan környezetet tesz lehetővé, ahol az alkalmazások a saját terükben futhatnak, a rendszerben lévő összes többi programtól elkülönítve. Intel 64: az Intel 64-bites utasításkészlete (EM64T). Nagy előnye, hogy 4 GB-nál nagyobb, valós és virtuális memóriákat is kezelni tud. Intel Demand Based Switching: egy energiagazdálkodási technológia, amely esetében a számításokhoz szükséges feszültségszintek és órajel azon a legalacsonyabb szinten vannak, amelyeket az elvégzendő feladat megkíván. A technológia először a szerver processzoroknál jelent meg Intel SpeedStep Technology néven. Idle States (C-states, C-állapotok): energia-megtakarítási technológia. Akkor használatos, amikor a processzor üresjáratban van. A C0 az a működési állapot, amikor a CPU hasznos munkát végez. C1 az első üresjárati állapot, C2 a második, és így tovább. Az egyre magasabb számok egyre nagyobb energia-megtakarítást jelentenek. Enhanced Intel SpeedStep Technology: ez a fejlett technológia teszi lehetővé a nagy számítási teljesítményt úgy, hogy közben a mobil-eszközök alacsony energiafelhasználás iránti igényét is szem előtt tartja. A hagyományos Intel SpeedStep Technology egyszerre váltogatja a processzor feszültség-szintjeit és órajelét az adott terhelésnek megfelelően. Ezzel szemben az Enhanced Intel SpeedStep Technology a fejlettebb architektúrának köszönhetően olyan stratégiákkal rendelkezik, melyek külön tudják kezelni a feszültség- és frekvenciaváltásokat, továbbá képes a Clock Partitioning and Recovery használatára. Thermal Monitoring Technologies: ezek a technológiák védik meg a rendszert a túlmelegedés káros hatásaitól. A lapkába épített Digitális Hőmérséklet Szenzor (Digital Thermal Sensor, DTS) érzékeli a magok hőmérsékletét, és hőkezelési képességük révén szükség esetén csökkentik az energiafelhasználást és ezzel a termelt hőt, hogy az áramkörök a normál üzemi hőmérsékleti határaikon belül maradjanak. Execute Disable Bit: hardver-alapú biztonsági tulajdonság, amely képes csökkenteni a vírusoknak és a kártékony programoknak való kiszolgáltatottságot azáltal, hogy megakadályozza a kártékony kódok lefutását és a hálózaton való szétterjedésüket. [9] 18

22 2.3. Intel 22nm technológia Az INTEL mikroprocesszorok architekturális Az új tranzisztorok alacsony feszültségeken mutatott hatékonyságuknak köszönhetően az Intel Atom fejlesztői új, innovatív módon alakíthatják át az Atom mikroarchitektúráját. Az új konstrukció teljes egészében kihasználja a hihetetlenül alacsony fogyasztású 3D Tri-Gate tranzisztor-technológia nyújtotta előnyöket. Az Intel jövőbeli, 22 nm-es 3D Tri-Gate tranzisztorokon alapuló, alacsony-energiafelhasználásra tervezett SoC termékei alá fognak menni az 1 mw-os üresjárati fogyasztásnak. A 2011 végén bemutatott, 3. generációs Intel Core processzorok voltak az első, nagy sorozatban, 3D-s technológiával gyártott chip-ek. [10] Az Intel tervei szerint 2013-ban követné ezt a 14 nm, majd 2015-ben a 10 nm csíkszélességű tranzisztorok. [11] Most, 2011-ben az Intel olyan megoldást mutatott be, melyen már több mint egy évtizede dolgoznak mérnökei. Egy új, háromkapus tranzisztorról van szó, melyről először 2002-ben hallottunk, de a halogatások után végre az idei év második felében, az Ivy Bridge processzorokban kerül először sorozatgyártásra. Az újdonság forradalmi mivolta a mai divat szerint háromdimenziósnak nevezett felépítésből adódik. Az eddigi gyakorlattal ellentétben a forrás (source) és a nyelő (drain) között haladó vezeték kilép a harmadik dimenzióba, így immár nem egysíkú, hanem mondhatni élére állított vezetőben haladnak az elektronok, a kapuelektróda pedig nem csak felülről, hanem három oldalról fogja ezt körbe, így nagyobb felületen, nagyobb hatásfokkal zár, csökkentve ezzel a sok fejtörést okozó szivárgást. Az alábbi 6. ábra jól illusztrálja a régi (balra) és új (jobbra) felépítés közti fő különbséget. 6. ábra Aki figyelt annak idején a fizikaórákon tudja, egy tranzisztor hatásfokának, teljesítményének legjelentősebb meghatározója éppen a zárás minősége, hogy nyitott 19

23 kapunál, bekapcsolt állapotban minél nagyobb, zárt kapunál, kikapcsolt állapotban pedig minél kisebb áram folyjon át rajta. Felülnézetből ez a paraméter az integrált áramkör fogyasztását határozza meg. Emellett a kapcsolás sebessége kardinális kérdés, hiszen egyenes arányban van az integrált áramkör órajelével, vagyis a sebességét definiálja. Természetesen a jelenlegi egy síkú vezetős (planáris) tranzisztorokkal is elérhető lenne a 22 nm, de az Intel elemzése szerint ez a jelenlegi technológia mellett lényegesen megdrágítaná a gyártást, ráadásul az új, háromdimenziós verzió kapcsolási paraméterei jobbak. 7. ábra Az Intel rengeteg ábrája és kisfilmje közül talán a fenti (7. ábra) ábrázolja legjobban az új tranzisztor viszonyát az aktuális 32 nm-es megoldáshoz, ráadásul látható rajta a régi módszerrel elkészíthető 22 nm-es verzió tudása. A függőleges tengelyen a kapu késleltetése (gate delay) szerepel (minél kisebb, annál jobb), ami arányos a sebességgel. A vízszintes tengelyen a működési feszültség jelenik meg, ami pedig a fogyasztást mutatja. Az egyre kisebb és energiatakarékosabb eszközök világában a görbék bal oldala a lényeges, a kisfeszültségű üzem. Itt 37%-kal gyorsabb a 22 nm-es háromdimenziós tranzisztor a hagyományos 32 nm-esnél, továbbá az is látszik az ábrából, hogy a 3D-s verzió úgy 25%-kal lehet gyorsabb egy hagyományos kialakítású 22 nm-es eljárásnál (nem is beszélve az elvileg kisebb előállítási költségről). 20

24 A magas órajeles (alacsony kapu késleltetés) integrált áramköröknél előre jelzett 18%-os gyorsulás szintén számottevő, bár itt egy hagyományos 22 nm-es eljáráshoz képes a sebességbeli előny már nem olyan nagy. A gyors, komplex chipeknél viszont fontos tényező a szivárgási áram, aminek alacsonyan tartásában szintén jeleskedik a háromdimenziós megoldás. Itt arra kell gondolni, hogy a fejlesztőknek a kisebb fogyasztás és melegedés miatt nagyobb mozgásterük van az egyes komponensek kialakításában, egy kevésbé szivárgó technológiával összetettebb kapcsolás hozható létre azonos fogyasztási és melegedési paraméterek mellett. 8. ábra A 32 nm, planáris tranzisztor lapos vezetői (balra) és a 22 nm Tri-Gate, térbeli újdonság élére állított vezetői (középen) [12] 2.4. A processzorok felépítése Az informatikában a mikroarchitektúrával teljesen leírható egy számítógép, központi egység, vagy digitális jelfeldolgozó elektromos áramkör kapcsolási sémája hardver-alapú működése. Tudományos körökben a számítógépszervezet kifejezést használják, míg a számítógépiparban a mikroarchitektúra kifejezést használják gyakrabban. Mikroarchitektúra és utasításkészlet (ISA, Industry Standard Architecture, ipari-szabványú architektúra) együtt alkotják a számítógép-architektúra területét. [13] A mikroachitektúra aspektusai A csővezetékes adatösvény a leggyakrabban használt tervezési mód a jelenlegi mikroarchitektúrában. Ezt a technikát a legtöbb modern mikroprocesszorban, mikrokontrollerben és DSP-ben (Digital Signal Processor, digitális jelprocesszor) használják. A csővezetékes architektúra lehetővé teszi, hogy több utasítás fedje egymást végrehajtás közben, körülbelül. úgy, mint egy összeszerelő szalagon. A vezeték több különböző állomást is magába foglal, amelyek alapvetőek a mikroarchitekturális tervezésben. Néhány állomás tartalmaz olyat is, mint az utasításhívás, utasításdekódolás, - végrehajtás és -visszaírás. Néhány architektúra olyan állomást is tartalmaz, mint például 21

25 memória-hozzáférés. A csővezetékek tervezése az egyik központi mikroarchitekturális feladat. A végrehajtási egységek is alapvetőek a mikroarchitektúrához. A végrehajtási egységek tartalmazzák az aritmetikai logikai egységeket (ALU), lebegőpontos egységeket (FPU), a töltő/tároló egységeket, az elágazás előrejelzéseket és SIMD-t. Ezek az egységek hajtják végre a műveleteket vagy a processzor kalkulációit. A végrehajtási egységek számának megválasztása, lappangása és teljesítménye az egyik központi mikroachitekturális tervezési feladat. A memóriák mérete, lappangása, teljesítménye és összekapcsolhatóságuk a rendszeren belül is a mikroachitekturális döntések egyike. A rendszerszintű tervezési döntések, mint például, hogy legyenek vagy ne legyenek perifériák, értve itt memória kontrollereket például, ugyancsak a mikroarchitekturális tervezési folyamat részének tekinthető. Ideértjük a teljesítményszintű döntéseket és ezeknek a perifériáknak az összekapcsolhatóságát. Eltérően az architekturális tervezéstől, ahol egy bizonyos teljesítményszint elérése a fő cél, a mikroarchitekturális tervezés nagyobb figyelmet szentel az egyéb megszorításoknak. Minthogy a mikroarchitekturális tervezési döntések közvetlenül befolyásolják, hogy mi kerül a rendszerbe, a következő témáknak kell figyelmet szentelni: chip-terület / költség, energiafogyasztás, logikai összetettség, kapcsolódás egyszerűsége, gyárthatóság kérdése, debug-golás egyszerűsége (hibakeresés/javítás), tesztelhetőség. [13] Mikroarchitekturális fogalmak Általánosságban minden CPU, egymagos mikroprocesszor vagy többmagos megvalósítás a következő lépések végrehajtásával futtatja a programokat: 1. beolvassa az utasítást és dekódolja, 2. megtalál minden kapcsolódó adatot, ami az utasítás végrehajtásához szükséges, 3. feldolgozza az utasítást, 4. kiírja az eredményt. 22

26 Az egyszerűnek tűnő lépéssorozatot bonyolítja az a tény, hogy a memóriahierarchia, amely magában foglalja a gyorsítótárat, a fő memóriát és a nem-változó (non-volatile) tárolási egységeket, mint például a merevlemezeket (ahol a program-utasítások és adatok vannak), mindig is lassabb volt, mint maga a processzor. A (2) Lépés gyakran egy hosszas várakozást jelent, amíg az adat megérkezik a buszon keresztül a CPU-ba. Jelentős mennyiségű kutatást fektettek olyan tervezésekbe, amelyek kikerülik ezeket a késéseket amennyire csak lehetséges. Az évek alatt az egyik központi cél az volt, hogy minél több utasítást hajtsanak végre párhuzamosan, így növelve a program effektív végrehajtásának sebességét. Ezek a törekvések összetett logikai és áramköri struktúrákat eredményeztek. Kezdetben ezeket a technikákat csak drága mainframe-eken (nagyteljesítményű számítógép) vagy szuperkomputereken lehetett kivitelezni, köszönhetően a technikához szükséges nagy mennyiségű, bonyolult áramköröknek. Ahogy a félvezetőgyártás fejlődött mind több és több ilyen technika vált megvalósíthatóvá az egymagos processzorokon. [13] [14] RISC és CISC processzortervezési filozófia A RISC (csökkentett utasításkészletű számítógép) processzorok egyszerű, az összetett instrukciókat mellőző, tehát gyorsan végrehajtható utasításkészletre alapoznak; ehhez igazodik egyszerűnek mondható felépítésük. A rendszer célja az erőforrás ésszerű kihasználása, fix hosszúságú utasításszavakkal, és korlátozott számú címzési móddal. Az egyszerűbb kialakítás következtében több általános célú regiszter, vagy nagyobb méretű gyorstár elhelyezésére van lehetőség. A legismertebb RISC tervezési filozófiával készülő processzorok manapság az ARM termékei, de például a Sun UltraSPARC is ide sorolható. A CISC (összetett utasításkészletű számítógép) processzorok utasításkészlete rendkívül sok (akár több száz) utasítást tartalmaz, köztük sok speciális, összetettebb instrukciót is. Több bonyolult címzési mód lehetséges, ami változó hosszúságú utasítás szavakat eredményez, továbbá a gyakori, memóriát használó utasítások (load, store) végrehajtása is lassú, és viszonylag kevés általános célú regisztert tartalmaznak a processzorok. A rendszer rendkívül erőforrás-pazarló, illetve nagy probléma még, hogy az összetett utasításokat is ritkán használják. Mindenképp pozitívum azonban, hogy egyszerű gépi szinten programozni. Manapság már senki sem használ tisztán CISC processzort, de a régi 386-os lapkák ide sorolhatók. 23

27 A mai CISC elven működő processzorok, többnyire RISC magot használnak a feldolgozásnál, így a legegyszerűbb és egyben leggyakoribb utasításokat egyetlen adatútciklus alatt is végrehajtják, míg a bonyolult instrukciókat a CISC elvnek megfelelően értelmezik. A modernebb x86-os AMD64-es Intel és AMD processzorok így működnek. Természetesen általánosan lehetséges, hogy egy RISC processzor pár CISC-re jellemző tulajdonsággal rendelkezik, és ez előfordulhat fordítva is, így a fenti definíciók nincsenek kőbe vésve. [15] 2.5. Utasítás-futószalag (pipeline) Az utasítás-futószalag (a továbbiakban az elterjedtsége miatt az angol, pipeline elnevezést fogom használni) egy olyan számítógépes technika, amely erőteljesen gyorsítja az utasítások feldolgozási sebességét (tehát növeli az egy időegység alatt végrehajtható utasítások számát). A pipeline-technika nem csökkenti az utasítások feldolgozásának idejét, azonban mégis javítja a teljesítményt oly módon, hogy több utasítást hajt végre párhuzamosan. Minden egyes utasítás feldolgozása egymástól függő lépésekre van osztva. Az első lépés mindig a beolvasás (fetch) a memóriából; míg az utolsó általában az eredmények kiírása egy regiszterbe vagy a memóriába. A pipeline technika alapelve, hogy a processzor annyi utasításon dolgozzon egyszerre, ahány függő lépés van. Ez úgy képzelhető el, mint egy gyártószalag, ahol a gyártmányokat egyszerre munkálják meg a gyártási folyamat különböző fázisainak megfelelően, ahelyett, hogy az egész szalagon mindössze egyetlen gyártmány lenne. A pipeline is arra törekszik, hogy a processzor minden részegységét ellássa munkával, és egyik se legyen kihasználatlan. A rendszer órajelének a leglassabb lépés végrehajtási idejéhez kell igazodnia, és ideális esetben minden ciklusban befejeződik egy utasítás. Magát a pipeline kifejezést olyan csővezeték mintájára alkották meg, ahol annak minden részében egyszerre áramlik folyadék; hasonlóképpen a CPU minden része dolgozik valamin. [16] A CPU-kat órajel vezérli. Az órajel impulzusok hatására nem kell feltétlenül ugyanazoknak a dolgoknak történniük. A processzor dönti el, hogy egy órajelciklusban mely alrendszerének kell működnie. Számos oka van annak, hogy egy utasítást miért nem lehet teljes egészében egyetlen ciklus alatt végrehajtani. Például, ha egy regiszterbe kell 24

28 betölteni egy adatot vagy el kell végezni egy számítást, bizonyos időbe fog telni, amíg a regiszter kimenete stabillá nem válik vagy a számítás be nem fejeződik. Pipelinetechnikában azok a hatások, amelyek nem történhetnek egy időben, fogják alkotni az utasítás függő lépéseit. Az általános, 4 lépcsős pipeline az alábbi lépésekből áll: 1. beolvasás (fetch), 2. dekódolás (decode), 3. végrehajtás (execute), 4. visszaírás (write-back). 9. ábra: általános, 4 lépcsős pipeline; a színes négyzetek egymástól független utasításokat jelölnek Az ábrán látható felső szürke téglalap a végrehajtásra várakozó, az alsó a végrehajtott utasításokat tartalmazza. A középső fehér doboz pedig a pipeline. [16] Buborék a pipeline-ban A pipeline-os processzorokban bizonyos hazárdok elkerülése miatt előfordulhat, hogy a pipeline-ba úgynevezett buborék (bubble) kerül, és emiatt egy vagy több ciklusig bizonyos részei kihasználatlanok maradnak. 25

29 10. ábra: buborék a pipeline-ban Az ábrán a harmadik ciklusban a CPU nem tudja dekódolni a lila utasítást, mert például a processzor rájön arra, hogy a dekódolás eredménye függne a zöld utasítás végrehajtásától. A zöld utasítás nyugodtan haladhat tovább a végrehajtási és visszaírási lépésbe, de a lila egy ciklusidőre megakad a fetch-nél. A kék utasítás, amelyet a harmadik ciklusban kellett volna beolvasni szintén késik egy ciklust, ahogy mögötte a piros is. A buborék miatt (kék ovális alakzat) a processzor dekódoló áramköre kihasználatlan a 3. ciklusban, a végrehajtó a 4.-ben és a visszaíró az 5.-ben. Amikor a buborék kikerül a pipeline-ból a 6. ciklusban, a végrehajtás visszatér a normál ütembe. Viszont a zöld kivételével minden utasítás 1 ciklusnyi lemaradásban van. Hét helyett nyolc ciklusba telt mind a négy utasítás teljes végrehajtása. [16] 2.6. Cache Amikor a processzornak be kell olvasnia vagy ki kell írnia valamit a központi memóriába, előtte leellenőrzi, hogy az adott adat egy másolata megtalálható-e a cache-ben. Ha igen, akkor a CPU onnan fog olvasni vagy oda fog írni, amely sokkal gyorsabb, mintha ugyanezt a központi memóriával tenné. A legtöbb modern asztali, mobil és szerver processzornak legalább három független cache-e van: egy utasítás-cache (instruction cache), amely a végrehajtandó utasítások fetch-elését gyorsítja; egy adat-cache (data cache), amely az adatmozgatást támogatja; és egy úgynevezett translation lookaside buffer (TLB). Ez a virtuális-fizikai címfordítást gyorsítja mind az utasítások, mind az adatok esetében. Az adat-cache-t általában többszintű hierarchiába rendezik (L1, L2, stb). [17] 26

30 Cache bejegyzések (cache entries) Az INTEL mikroprocesszorok architekturális Az adatok meghatározott méretű blokkokban mozognak a memória és a cache között, amelyet cache lines-nak (cache sorok) hívnak. Amikor egy cache line másolódik a memóriából a cache-be, ehhez egy új cache bejegyzés készül. Ez a bejegyzés a másolt adaton kívül annak memóriabeli helyét is tartalmazni fogja, amelyet tag-nek neveznek. Mindig, amikor a processzornak írnia vagy olvasnia kell a fő memóriából, a művelet előtt mindig ellenőrzi, hogy a keresett blokk megtalálható-e a cache-ben. Ekkor a cache az összes szóba jöhető sorát végignézi, hogy valamelyikük tartalmazza-e a keresett címet. Ha a cím és a hozzá tartozó adat megtalálható a cache-ben, akkor cache-találat (cache hit) történt. Amennyiben a processzor nem találja meg a keresett memóriaterületet a cache-ben, az a cache-tévesztés (cache miss). Cache-találatkor a processzor azonnal írja vagy olvassa az adott cache line-t. Cache-tévesztéskor a cache egy új bejegyzést allokál és bemásolja a megfelelő területet a memóriából. Ezt követően a kérés a cache tartalma alapján hajtódik végre. [17] Cache az x86-os mikroprocesszorokban Ahogy az x86-os processzorok kezdték elérni a 20 MHz-es és az a fölötti órajeleket a 386-ban, kis méretű, gyors elérésű cache-memóriák jelentek meg az ilyen rendszerekben, hogy a teljesítményt növeljék. Erre azért volt szükség, mert a fő memóriaként használt DRAM-nak (Dynamic RAM) komoly (több mint 120 ns) késleltetése volt, csak úgy, mint a frissítési ciklusoknak. A cache-t jóval drágább, de jelentősen gyorsabb SRAM-ból (Static RAM) készítették, amelyeknek akkoriban a késleltetése 10 ns körüli volt. A korai cache-ek még a processzoron kívül, többnyire az alaplapon helyezkedtek el. Az ilyen socket-ekbe ültethető cache-ek opcionális extra vagy továbbfejlesztési lehetőségként szolgáltak. Az Intel 386 processzorok bizonyos változatai kb külső cache-t voltak képesek kezelni. A 486-os processzor lapkájába már közvetlenül be volt integrálva egy 8 kb-os cache modul. Ezt a cache-t Level 1-nek (L1) nevezték, hogy meg tudják különböztetni a lassabb, alaplapi cache-től, amelyet Level 2-nek (L2) hívtak. Az alaplapi cache-ek ekkor már nagyobbak voltak, tipikusan 256 kb. Az L2 cache-ek népszerűsége megmaradt a Pentium MMX korszakban is. Azonban elavulttá váltak az SDRAM-ok (Synchronous Dynamic RAM) megjelenésével, ráadásul az CPU órajel és a busz frekvencia közti egyre növekvő különbség miatt ezek a cache-ek már alig voltak valamivel gyorsabbak, mint a fő memória. 27

31 A cache implementációk következő lépcsőfokát az x86-os processzorcsaládon belül a Pentium Pro jelentette, mivel a másodlagos cache-t is a processzor lapkájába integrálták, az órajele pedig megegyezett a CPU-éval. Az alaplapi cache-ek meghosszabbodott népszerűséget élveztek az AMD K6-2 és AMD K6-III processzoroknak köszönhetően, amelyek az elismert, korábban az Intel által használt Socket-7-re épültek. A K6-III 256 kb integrált L2 cache-t tartalmazott, és harmadik szintű gyorsítótárként (L3) ki tudta használni az alaplapi cache-t is (bizonyos alaplapok akár 2 MB cache-t is tartalmazhattak). Miután a Socket-7 végleg elavulttá vált, az alaplapi cache-ek is eltűntek az x86-os rendszerekből. A háromszintű gyorsítótárak a többmagos CPU-kal együtt jelentek meg újra, ahol is az L3-at a processzorlapkába integrálták. Mára megszokottá vált, hogy mindegyik szint nagyobb méretű, mint az előző, és a Level 3 cache akár a 8 MB-ot is elérheti. Előreláthatólag ez a trend a közeljövőben is folytatódni fog. [17] Cache teljesítmény Azon cache műveletek arányát, amelyek sikeres találattal végződnek (cache hit), találati aránynak (hit rate) nevezzük. Ezzel akár egy adott program vagy algoritmus hatékonyságát is mérni lehet. Az olvasási tévesztések (read miss) lassítják a végrehajtást, mert azt eredményezik, hogy az adatokat a cache-nél sokkal lassabb központi memóriából kell betölteni. Az írási tévesztések (write miss) nem járnak ilyen hátránnyal, mivel a processzor folytathatja a munkáját, amíg az adatok a háttérben a memóriába másolódnak. [17] Helyettesítési stratégiák Egy cache miss esetében a cache-nek törölnie kell egy meglévő bejegyzését, hogy az újnak helyet készítsen. Helyettesítési stratégiának (replacement policy) hívják azt a heurisztikus módszert, amely kiválasztja a törlendő bejegyzést. Az alapvető problémája ezeknek a stratégiáknak az, hogy meg kell mondaniuk, melyik bejegyzést fogják a jövőben a legkisebb valószínűséggel használni. A jövőt megjósolni nagyon nehéz, éppen emiatt nem lehet tökéletesen eldönteni, hogy melyik döntési stratégiát érdemes választatni a meglévők közül. Egy népszerű módszer a legrégebben használt least-recently used (LRU), amely a legrégebben nem használt bejegyzést cseréli le. [17] 28

32 A cache viszonya a többi adattárolóhoz Az INTEL mikroprocesszorok architekturális Az alábbi ábra igen szemléletesen ábrázolja a cache-ek méretét és tároló kapacitását a többi, számítógépben fellelhető egyéb adattárolókhoz képest. Egy piramist formáz, melynek csúcsán a leggyorsabb, viszont legkisebb kapacitású regiszterek állnak. Ezt követik a cache-ek, majd a memória. Végül az olyan szektoros elrendezésű diszkek következnek, melyek több nagyságrenddel lassabbak a regisztereknél, viszont akár TB-os méretű kapacitással is rendelkezhetnek. A teljesség kedvéért a piramis aljára én még odatenném az Internetet is, mivel sebességét és jellegét tekintve tökéletesen illik ebbe a sémába: nagyon lassú elérési sebesség, ellenben óriási, szinte végtelen tárkapacitással párosítva. 11. ábra: adattárolók fajtái és jellemzőik [18] 2.7. Elágazás becslés Egy számítógép architektúrában az elágazás becslő (branch predictor) egy olyan digitális áramkör, amely megpróbálja kitalálni, hogy egy elágazás (például egy if-then-else struktúra) hova fog vezetni, mielőtt ezt még biztosan tudná. Az elágazás becslő célja, hogy növelje az utasítás-pipeline-ok áteresztőképességét. Ezek igen fontos szerepet töltenek be a nagy teljesítmény elérésében az olyan modern pipeline-os mikroprocesszorokban, mint az x86. A kétirányú elágaztatást többnyire egy feltételes ugrással (conditional jump) valósítják meg. A feltételes ugrás lehet kihagyott ( not taken ), vagyis közvetlenül az 29

33 elágazást követő első ág hajtódik végre, vagy lehet "megtett" ( taken ), amikor a vezérlés a második ágat tároló memóriaterületre ugrik. Egészen addig nem lehet biztosan tudni, hogy egy feltételes ugrásra sor kerül-e vagy sem, amíg a feltétel ki nem értékelődik, és az ugró utasítás a pipeline végrehajtó szakaszába nem kerül. Az elágazás becslő nélkül a processzornak meg kellene várnia azt, hogy a feltételes ugrás utasítása kikerüljön a végrehajtó állomásból, mielőtt a következő utasítás a pipeline fetch részébe kerülhessen. Az elágazás becslő éppen ezért megpróbálja elkerülni ezt az időveszteséget azáltal, hogy megjósolja, hogy nagy valószínűség szerint az elágazás kihagyott vagy megtett lesz-e. Az az ág, amelynek a legnagyobb esélye van arra, hogy végrehajtódjon, beolvasásra kerül és spekulatívan végrehajtódik. Amennyiben később kiderül, hogy a jóslat rossz volt, akkor a spekulatívan vagy részben végrehajtott utasítások eredményei el lesznek dobva, és a pipeline újrakezdi a megfelelő ággal, némi késést okozva. Az az idő, amely el lett pazarolva a téves jóslásnak köszönhetően, megegyezik a pipeline beolvasó és végrehajtó állomásai közti állomások számával. A modern mikroprocesszoroknak általában elég hosszú pipeline-jaik vannak, tehát a téves jóslásból eredő késleltetés 10 és 20 órajelciklus között alakul. Minél hosszabb a pipeline, annál nagyobb az igény egy jó elágazás becslőre. Az első alkalommal, amikor egy feltételes ugrással találkozik a processzor, akkor viszonylag kevés információ áll a rendelkezésére, amelyre a becslését alapozhatná. Azonban az elágazás becslő számon tartja, hogy az egyes ágakat kihagyta -e vagy sem. Ha egy olyan feltételes ugrással találkozik, amelyet már sokszor látott korábban, akkor a becslését ennek az előzményeire tudja alapozni. Az áramkör például tudhatja, hogy melyik ágat választotta korábban sokkal gyakrabban, vagy felismerheti, hogy minden második alkalommal ugrott arra az ágra. Az elágazás becslő nem ugyanaz, mint az elágazás cél becslő (branch target prediction). Az előbbi azt próbálja meghatározni, hogy egy feltételes ugrás megtételére vagy kihagyására lesz-e szükség. Ezzel szemben az utóbbi azt próbálja megmondani, hogy egy feltételes vagy feltétel nélküli ugrásnak mi lesz a célja, mielőtt még a tényleges utasítást dekódolná és végrehajtaná. Általában az elágazás becslőt és az elágazás cél becslőt ugyanabba az áramkörbe építik be. [19] 30

34 2.8. Szuperskalár Az INTEL mikroprocesszorok architekturális Egy szuperskalár (superscalar) elvű CPU architektúra a párhuzamosság úgynevezett utasításszintű párhuzamosság (instruction level parallelism, ILP) változatát valósítja meg egy processzoron belül. Ennek köszönhetően adott órajelen a CPU gyorsabban képes végrehajtani az utasításokat. A szuperskalár processzor egy órajelciklus alatt több utasítást tud végrehajtani azáltal, hogy a CPU redundáns funkcionális egységei között egy időben több parancsot oszt szét. Ezek a funkcionális egységek nem önálló CPU magok, hanem bizonyos, egyetlen processzoron belüli végrehajtási erőforrások, mint például az ALU, vagy az FPU. Flynn rendszere szerint egy egymagos szuperskalár processzor a SISD osztályba tartozik, míg ennek többmagos változata már MIMD. Habár a szuperskalár processzorok szintén pipeline felépítésűek, a pipeline és a szuperskalár architektúrák különböző teljesítmény-növelő technikák. A szuperskalár technika hagyományosan számos karakterisztikus viselkedéssel kapcsolható össze (egy adott CPU magon belül): az utasításokat egy szekvenciális utasítás-folyamból veszi, a CPU hardver futásidőben, dinamikusan ellenőrzi az utasítások közötti adatfüggőségeket (szemben a fordítási időben történő szoftveres ellenőrzéssel), a CPU több utasítást fogad el egy órajelciklus alatt. [20] Története 1998-óta alapvetően minden általános célú CPU-t szuperskalárúnak készítettek azoknak a kivételével, amelyeket alacsony energiafogyasztást igénylő helyeken használtak, mint például a beágyazott rendszerekben vagy az akkumulátorokról üzemelő eszközökben. A P5 Pentium volt az első x86-os szuperskalár processzor. Az Nx586, a P6 Pentium Pro és az AMD K5 az első olyan processzorok között voltak, amelyek az x86 utasításokat még azok tényleges végrehajtása előtt aszinkron módon dinamikus, mikrokód-szerű mikroutasítás szekvenciákba dekódolták. Ez lehetővé tette a pufferelt részleges utasítások dinamikus ütemezését, és még nagyobb fokú párhuzamosságot eredményezett a P5 Pentium egyszerűbb és sokkal szigorúbb eljárásaihoz képest. Továbbá egyszerűsítette a spekulatív végrehajtást is, és nagyobb órajel-frekvenciákat tett lehetővé az olyan rendszerekhez viszonyítva, mint a fejlett Cyrix 6x86. [20] 31

35 Skalártól a szuperskalárig Az INTEL mikroprocesszorok architekturális A legegyszerűbb processzorok a skalár processzorok. Minden egyes skalár processzor által végrehajtott utasítás többnyire egy vagy két adatot manipulál egyszerre. Összehasonlításképpen a vektor-processzorok utasításonként sok adaton dolgozik párhuzamosan. Egy kiváló analógia a skalár és vektor aritmetika közti különbség. Egy szuperskalár processzor ennek a kettőnek a keveréke. Minden utasítás egy adaton dolgozik, de egy CPU-n belül több redundáns funkcionális egység van. Emiatt több utasítás párhuzamosan több, egymástól független adatot tud feldolgozni. A szuperskalár CPU tervezés nagy hangsúlyt fektet arra, hogy növelje az utasítás szétosztó pontosságát, és a funkcionális egységek folyamatos kihasználtságát biztosítsa. Ez különösen akkor vált fontossá, amikor az egységek száma megnőtt. Míg a korai szuperskalár CPU-knak két ALU-juk és egyetlen FPU-juk volt, addig a modern processzorok, mint a PowerPC 970 négy ALU-t, két FPU-t és két SIMD-egységet tartalmaz. Ha az elosztó nem képes ezeket az egységeket hatékonyan ellátni utasításokkal, akkor ezt a rendszer teljesítménye fogja megsínyleni. A szuperskalár processzor általában fenn tudja tartani azt, hogy egy cikluson belül több utasítást hajt végre. Azonban csupán az, hogy a processzor több utasítást dolgoz fel párhuzamosan, még nem jelenti feltétlenül, hogy szuperskalár architektúráról van szó, hiszen a pipeline-os többprocesszoros vagy többmagos rendszerek ugyanerre képesek, más módszerekkel. Egy szuperskalár CPU-ban az elosztó beolvassa a memóriából az utasításokat és eldönti, hogy melyeket lehet párhuzamosan futtatni, és szétosztja őket az egy magban megtalálható redundáns funkcionális egységek között. Emiatt a szuperskalár processzort úgy lehet tekinteni, hogy több párhuzamos pipeline-nal rendelkezik, amelyek mindegyike egyidejűleg dolgozik az egy programszálból származó utasításokon. [20] 2.9. Hyper-Threading A többszálúság (multithreading) elve hasonlít a beavatkozó multitasking-hoz, de a modern szuperskalár processzorok végrehajtási szálak szintjén kerül implementálásra. A szimultán többszálúság (Simultaneous multithreading, SMT) egyike a szálkezelés két fő megvalósítási formájának. A másik formája az időszakos szálkezelés (temporal multithreading). Az utóbbi esetében a pipeline-ban csakis egyetlen szál utasításai lehetnek jelen egy időben. A szimultán szálkezelésben a pipeline különböző szakaszaiban több szál utasításai is végrehajtódhatnak egy időben. Az ehhez szükséges feltételek megteremtése 32

36 nem igényli a processzor architektúra jelentős megváltoztatását: főleg arra van szükség, hogy a processzor képessé váljon több szál utasításainak beolvasására egy ciklus alatt, és több regiszterre is, hogy a több szál adatait tárolni tudja. A konkurens szálak számát a tervezők döntik el, de gyakorlati megfontolásokból ez a szám többnyire kettő szokott lenni. Mivel a technika kifejezetten egy hatékonyság növelő megoldás és az osztott erőforrások között elkerülhetetlenül konfliktus fog fellépni, ezért a hatékonyság mérése igen nehéz is lehet. Az energia-hatékonyságot vizsgálva a nm-es Intel processzorok natív és irányított párhuzamos munkaterheléseinél az derült ki, hogy a 45 és 32 nm-es lapkáknál az SMT kiemelkedően keveset fogyaszt, még a sorrendi végrehajtású Atom CPU-khoz képest is. A modern processzorokban az SMT minimális dinamikus többletfogyasztással kezeli a konkurens végrehajtást. Néhány kutató megállapította, hogy extra szálakkal előre elő lehet állítani bizonyos osztott erőforrásokat, amelyek aztán egy másik szál teljesítményét fogják növelni. Mások redundáns számításokat végeznek az SMT segítségével, hogy ezzel bizonyos fokú hibadetekciót és helyreállítást tegyenek lehetővé. A legtöbb esetben az SMT célja, hogy elrejtse a memória késleltetését, növelje a hatékonyságot és a felhasznált hardveregységekhez viszonyított átbocsátó képességet. [21] Mit jelent a HyperThreading? A processzorok egyik teljesítménynövelő eszköze a szuperskalár architektúra, azaz kevésbé szépen nevezve az utasítások végrehajtásának párhuzamossága (ILP Instruction Level Parallelism) volt ebbe a kategóriába tartozik például az Athlon 3 db ALU egysége. Ezzel a probléma az, hogy például az egész számmal végzett műveletek sorrendje nehezen megjósolható, tehát megfelelő hatásfokkal nehezen párhuzamosítható. A mai operációs rendszerek és programok azonban már nem csak az utasítások szintjén hajtanak végre több párhuzamos műveletet. Több, egymás mellett futó programszálból áll az, amivel játszunk, szöveget szerkesztünk, filmet nézünk vagy épp netezünk. Ezen szálak párhuzamos feldolgozásához (TLP Thread Level Parallelism) szükséges erőforrás-megosztás könnyen megoldható, ha például többprocesszoros rendszereket használunk. A szálak lehetnek azonos vagy különböző alkalmazás szálai, és az operációs rendszer szintjén végrehajtandó szálak is. Jelenleg ez a technológia a processzorokban az időosztásos többszálúságként (TSM Time-Slice Multithreading) van jelen, amikor is egy szálon dolgozik a CPU, majd fix idő múlva vagy eseményvezérelten vált egy másik szálra. Ez persze több kihasználatlan ciklust is eredményez a váltások közti "üresjáratokban", azonban elég jól hasznosíthatók a 33

37 RAM késleltetési idők (amikor egy szálnak várnia kell a memóriahozzáférésre), mivel közben lehetőség nyílik más szálak végrehajtására. Természetesen ennél jobb a valódi többszálúság, azaz amikor egy végrehajtó egység megszakítás nélkül tud egy thread-del foglalkozni. A multiprocesszoros rendszerekkel eddig is nagy teljesítményt lehetett elérni ebben a tekintetben [22] A megvalósítás során a célok a következők voltak: Kis magméret-növekedés. Ezt sikerült is megvalósítani, mivel az állapotok tárolása relatíve kevés tranzisztort igényel. Az egyik LP (logikai processzor, későbbiekben LP) várakozása esetén (cache hibák, rossz jóslás, eredményre várás) a másik gond nélkül folytathassa a műveleteket. Ehhez az szükséges, hogy a belső mag összes tárolóját ne használhassa egyszerre egy szál, ami elérhető tárhasználat-limittel vagy pedig a tárolók megosztásával. Egy szál esetén a sebesség ugyanolyan gyors legyen, mintha nem lenne megosztva a mag. Ilyenkor viszont egyesíteni kell az erőforrásokat, amik esetleg fel vannak osztva a két szál számára. [22] A HyperThreading architektúra A Hyperthreading technológiával rendelkező processzorok úgy jelennek meg a programok számára, mint több logikai egység. Ez úgy történik, hogy a processzor két szimmetrikus állapottároló, a külső egységek számára hozzáférhető egységgel rendelkezik, melyek osztoznak a processzor végrehajtó egységein. Az operációs rendszer és a feladatok, mint két-két különálló LP-t programozhatnak, majd a processzor végrehajtja a két LP feladatait, ez a programok számára valódi párhuzamos végrehajtásként fog látszani. Így az Intel szerint jóval hatékonyabban használjuk a CPU-t a megvalósításhoz szükséges tranzisztorszám és magméret mindössze 5%-os növekedése mellett, azaz maga a logikai állapotokat tároló egység (architectural state store) elenyészően kevés helyet foglal a közösen használt erőforrások mellett (cache, végrehajtó egységek, branch predictors, vezérlőlogikák, buszok). Minden LP-nak megvan a maga interrupt vezérlője, ami a programvezérlési lehetőségeket nagymértékben tágítja. (Az interrupt azaz megszakítás vezérlő úgy működik, hogy a processzor külső eszköz által adott megszakításkérés hatására abbahagyja az aktuális programfolyamatot, elkezd egy másik, az adott eszközhöz előzetesen 34

38 hozzárendelt kódot végrehajtani, majd annak végeztével visszatér az eredeti programrészlethez ott, ahol abbahagyta. Gondoljunk például az egérre, megmozdításakor a processzor abbahagyja a végrehajtást, a mutató koordinátáit frissíti, majd folytatja az eredeti programot...) [22] HyperThreading működés 12. ábra: a Hyper-Threading működésének vázlata 1. Az utasítás felhozása a Level-1 cache-ből (más néven Execution Trace Cache, a továbbiakban TC). Mindkét LP-nak van hozzáférése a TC-hez, azonban ha egyszerre kérnek adatot, akkor felváltva az egyik órajelre az egyik, második órajelre a másikhoz fordul a cache vezérlő. Ugyanakkor, ha az egyik szál valamilyen okból várakozni kényszerül, a másik a TC teljes kapacitását kihasználhatja. Ez akkor működik, ha bent van az L1-ben a megfelelő kód, ekkor egyből az UOP Queue-val jelölt részhez érünk. A következő 2 pontban foglaltak csak akkor hajtódnak végre, ha az L1 cache-ben nincs benne az UOP (mikrokód, a végrehajtó egység számára közvetlenül értelmezhető utasítás). 2. A branch prediction logic, tehát a feltételes ugrásokat megbecsülő egység részben megosztott a két LP között, részben közös, a megosztott részek maguk a gondolkodó egységek, míg az ún. global history array, azaz a megelőző utasításokat tartalmazó rész közös, mivel ez egy nagyméretű tároló, aminek a megosztása jelentős tranzisztorszám-növekedéssel járt volna. 3. Az utasítás-dekódernek az IA-32 utasításkészletével nincs egyszerű dolga, hiszen a CISC felépítésből adódóan változó hosszúságú utasítások fordulnak elő. Általánosságban ezt az egységet akkor használja a processzor, ha a TC hibázott, mivel a sikeres cache találat esetén megadja a mikrokódot. Viszont ha mégsem, akkor a két szál egyidejűleg is fordulhat a dekóderhez, ez esetben egy dekóderen osztozik a két LP, azonban annak tárolnia kell mindkét LP által kezdeményezett 35

39 utasításdekódolás állapotait, mivel ezek szükségesek ahhoz, hogy LP-váltás esetén is helyesen működjön a dekóder egység. 4. Az UOP queue, azaz a mikrokódokat tartalmazó sor (futószalagként lehet elképzelni, mindig a végére rakjuk a következő utasítást, a végén meg leveszi a CPU) két részre osztott, mivel nem sok tranzisztort igényel, de biztosítja a fent megjelölt célok utolsó két követelményét. 5. A soronkívüli végrehajtó egység (OOOEU Out Of Order Execution Unit), amely képes az utasításokat az eredeti sorrendjüktől eltérő módon, sebességre optimalizálva végrehajtani, limitálja az adott LP-nek adható erőforrásokat olyan módon, hogyha mindkettő használja az OOOEU-t, akkor túlzott igények esetén várakoztatja az adott LP-t, de ha csak az egyik LP használja, akkor az összes erőforrást biztosítja számára. Az OOOEU lelke, az ütemező szintén limitálja a maximálisan lefoglalható tárolók számát, amelyekből a végrehajtó egységek kapják az adatot, azaz egyik szál sem sajátíthatja ki úgy a mag erőforrásait, hogy közben a másik szál is jelen van, ellenben kizárólag egy szál esetén gond nélkül működik a teljes kapacitás kihasználása. 6. A végrehajtó egység lényegében a Hyperthreadingtől függetlenül működik, hiszen gyakorlatilag ugyanúgy végre kell hajtania a megfelelő műveleteket a megfelelő adatokkal. Az eredmények visszaírásáról (write-back) a speciális retirement logic gondoskodik, ami azért speciális, mert az architecture state-eket figyelve a megfelelő LP-be írja vissza a megfelelő eredményt. [22] OpenCL Az OpenCL (Open Computing Language, nyílt számítási nyelv) az első nyílt, jogdíjmentes szabvány, amely a személyi számítógépekben, szerverekben és kézi eszközökben található modern processzorok párhuzamos és több platformú programozását teszi lehetővé. Az OpenCL nagyban növeli az alkalmazások sebességét és válaszidejét a piacon fellelhető alkalmazások széles skáláján, kezdve a játékoktól és szórakozástól egészen a tudományos és orvosi szoftverekig. [23] Az OpenCL egy Apple által megálmodott és a Khronos Group vezetésével fejlesztett felület, mely nyílt ipari szabványnak tekinthető, és a gyártók széles körben támogatják. A koncepció célja az adatpárhuzamos végrehajtásra tervezett, illetve a heterogén módon programozható processzorok képességeinek minél jobb kiaknázása. 36

40 Ezzel gyorsítható a feldolgozás, valamint a rendelkezésre álló erőforrások energiahatékony felhasználása is lehetséges. Az OpenCL koncepciójának alappillérei között szerepel, hogy tudjon kezelni bármilyen végrehajtó egységet, a végrehajtási modell pedig többdimenziós szerkezetre épít, ahol az adatokon párhuzamosan futtathatók a számítások. Az OpenCL segítségével a programozók képesek kihasználni a grafikus processzorok általános számítási teljesítményét, így azok a grafika mellett olyan jól párhuzamosítható feladatokra is befoghatók, amelyeken eddig a központi processzor dolgozott. Természetesen az OpenCL lehetőségei itt nem érnek véget, hiszen gyakorlatilag bármilyen speciális processzorhoz alkalmazható a felület, a rendszer hatékonyabb kihasználása érdekében. Az OpenCL felület az operációs rendszertől teljesen független, így bárhol megoldható a támogatása. A megfelelő driverről mindig az adott hardver gyártója gondoskodik. Esetenként előfordulhat, hogy egy cég a konkurens hardvereit is támogatja, de ez egyéni preferencia kérdése. Itt persze szó sincs hivatalos támogatásról, vagyis a nem gyári drivereket csak saját felelősségre szabad használni. A PC-s gyártók támogatásával kapcsolatban, a könnyebb átláthatóság kedvérét egy táblázatba foglaltuk össze az aktuális helyzetet a legfrissebb, végleges driverek képességeit figyelembe véve: 37

41 Driver AMD Intel NVIDIA OpenCL verzió OpenCL típusa driver APU-k kezelése (OpenCL felületen) 1.2-es GPU-k kezelése (OpenCL felületen) 1.2-es APU-k kezelése (OpenCL felületen) 1.1-es GPU-k kezelése (OpenCL felületen) 1.1-es GPU-k kezelése (OpenCL felületen) 1.0-s Konkurens CPUk nem hivatalos támogatása OpenCL driver utasításkészlete Operációs rendszer támogatása CPU Heterogén és APU) (CPU+GPU Heterogén (CPU és APU) Minden AMD APU Core i3/i és i7- Radeon HD 5000, 6000 és 7000 sorozat vagy újabb 3700, illetve Pentium G2000 sorozat vagy újabb Intel HD Graphics 2500/4000 sorozat vagy újabb csak GPU - - GeForce 400, 500 Radeon HD 4000 sorozat (béta támogatás) - - és 600 sorozat vagy újabb - Ion; GeForce 8, Intel, VIA nincs - SSE2, SSE3, SSE4A, AVX, XOP, FMA3, FMA4 Windows 7, 8, Vista, XP, illetve Linux 2. táblázat: A gyártók OpenCL driverei [24] SSE4.1, SSE4.2, AVX - Windows 7, 8, Vista, XP, illetve Linux 9, 100, 200, 300 sorozat Windows 7, 8, Vista, XP, illetve Linux 38

42 3.0. up Sim Az INTEL mikroprocesszorok architekturális A program elkészítésének célja, hogy közérthetően, látványosan prezentálni lehessen a CPU bizonyos, speciális hardveres egységeinek hatását a feldolgozási teljesítményre. Ennek részeként számos funkcionális alrendszer működését is be tudom mutatni. Szimulációimban főként gyártó-független megoldásokat mutatok be, amelyek minden modern asztali számítógépbe szánt processzorban megtalálhatóak. Azonban az SMT támogatását a nagyobb gyártók körében egyedül az Intel oldotta meg a Hyper-Threading nevű technológiája révén. Széles körű elterjedtsége és ötletessége miatt fontosnak tartottam, hogy ezt is be tudjam mutatni, így egy saját szimulációt kapott a HT. Az elkészített alkalmazás főként animációkat tartalmaz, amelyek a processzor egyes architekturális elemeinek működésén túl azt is megmutatják, hogy ezek segítségével milyen magasabb szintű lehetőségek nyílnak meg a szoftverek és fejlesztőik számára. Az általam készített alkalmazás neve up Sim, amely a mikroprocesszor szimulátor szavak rövidítéséből tevődik össze. Az elkészítése az alábbi szoftveres környezetben történt: OS: Microsoft Windows 7 Professional SP1 64-bit; IDE: Microsoft Visual Studio 2010 SP1; felhasznált programozási nyelvek: C#, XAML; szoftveres keretrendszer: Microsoft.NET Framework A program a Windows Presentation Foundation (WPF) technológián alapul. A magasabb fokú kompatibilitás érdekében a programot.net 3.0-ra és.net 3.5-re is lefordítottam (a WPF technológia a.net 3.0-ban jelent meg [25], ezért az ennél korábbi keretrendszert használó Microsoft Windows operációs rendszeren nem működik). A szoftver jelenlegi verziója X, ahol az X 30, 35 és 40 lehet. Ez utóbbi számok az adott.net keretrendszerre fordított verziókat jelölik, így például a 35 a.net 3.5-öt jelenti. Általánosságban elmondható, hogy minden véletlenszerűen generált értéket vagy eseményt egyenletes valószínűségi eloszlás szerint állíttattam elő. Az általam készített szimulációk további jellemzője, hogy az animációs lépések időtartamainak aránya nem felel meg a valós rendszerek működési sebességeinek arányával. Vagyis például a cache-működését bemutató programrészben az adatmozgások egymáshoz viszonyított sebessége nem egyezik meg a valóságban lévőknek. Ez amúgy is architektúránként változna, továbbá a cél ebben az esetben is az volt, hogy a különböző memóriatípusok közti gyorsaság-különbséget érzékeltetni lehessen a felhasználóval. 39

43 a) b) 13. ábra: az up Sim főablaka (a) és névjegye (b) A 13. a) ábrán az elkészült program főablaka látható. Ebből érhető el a szakdolgozat keretében kifejlesztett négy szimuláció és a szoftver névjegye, amely a 13. b) ábrán látható. A főablakban egy szimulációt kiválasztva az ablak eltűnik és helyette a kért alprogram jelenik meg. Bármelyik szimuláció ablakát bezárva a főmenü ismét láthatóvá válik. Hasonlóképpen működik a névjegy is: a Névjegy feliratra kattintva megjelenik a névjegy, amelyre kattintva pedig bezáródik a megjelenített ablak Pipeline és szuperskalár végrehajtás szimulációja 14. ábra: Pipeline és szuperskalár kombinált végrehajtása A 14. ábrán látható Pipeline ablakban kétféle, a feldolgozási teljesítményre nagy hatást gyakorló technológia animációja is megtekinthető. Az egyik a pipeline-feldolgozás, amely az egymást követő utasítások (piros és lila pöttyök) átlapolt feldolgozását szemlélteti. Itt a cache-ből beolvasott utasítások egyesével léphetnek a soron következő öt 40

44 feldolgozási fázis valamelyikébe. Ha a pipeline funkció ki van kapcsolva, egyszerre csak egy utasítás lehet az egész végrehajtási soron. Ennek segítségével jól látszik, hogy a pipeline egyetlen utasítás esetében nem növeli meg a sebességet, viszont többnél már egyértelműen megugrik az átbocsátó képesség. a) b) 15. ábra: nem pipeline-os (a), és pipeline-os (b) végrehajtás nem szuperskalár architektúrán A szuperskalár-architektúra úgy jelenik meg, hogy az előhívás közös fázisa után két végrehajtó sor jelenik meg. Itt az utasítások valódi párhuzamosságban kerülnek feldolgozásra. A párhuzamosítás ezen fajtáját pontosan ezért utasításszintű 41

45 párhuzamosságnak (ILP) nevezzük. Ez egy szál végrehajtását gyorsítja, több szál párhuzamosságát a többmagos vagy többprocesszoros architektúrák biztosítják. Az Intel Hyper-Threading technológia a programszálak bizonyos szintű párhuzamosítását oldja meg, amelyet a fenti szimulációs rész nem vesz figyelembe (ez egy magasabb szintű funkció és külön szimuláció foglalkozik ezzel, melyet a 3.2. fejezetben írok le). A szuperskalár kikapcsolásával az alsó végrehajtási sor eltűnik. A kettő vagy több pipeline hátránya, hogy csak olyan utasítások esetében használható ki a párhuzamos feldolgozás, ahol az éppen bent lévő parancsok függetlenek egymástól. Ha nem lennének függetlenek, akkor konfliktus helyzet alakulna ki, amely helytelen, nem determinisztikus működést eredményezne. Ennek eldöntésére és kezelésére több megoldás is létezik, amelyeket itt nem részletezek. A programban úgy veszem, hogy a 14. és 15. ábrán is látható piros pöttyök által szimbolizált utasítások szigorúan soros végrehajtást igényelnek, a lilák pedig tetszőlegesen párhuzamosíthatók. Ez utóbbiak generálását le is lehet kapcsolni. Így tehát a 14. ábrán megfigyelhető, hogy egy piros utasítással párhuzamosan csak egy lila hajtható végre. Két lila is futhat egymással párhuzamosan, viszont két piros a hazárdok miatt már nem. Alaphelyzetben a soros parancsok aránya 70%, a párhuzamosaké 30%. Ezen arány módosítását a program jelenlegi verziója még nem támogatja Hyper-Threading szimulációja Ebben a szimulációs ablakban az időszakos és szimultán szálkezelési technikák közti különbséget mutatom be. Az Intel processzorokban mára már megszokott hardveres tulajdonsággá vált az SMT, vagyis az Intel terminológiájában a Hyper-Threading (a továbbiakban HT). A technológiának köszönhetően egy HT egységgel felszerelt fizikai processzor a magasabb, szoftveres szintek számára két logikai processzornak fog látszódni. Ennek előnye igazán a többszálú alkalmazások esetén mutatkozik meg, mert azoknál a szálak közti váltás és ütemezés gyorsabbá válik. Igaz ugyan, hogy az egyes szálak végrehajtási sebessége nem nő, de a hardveres ütemezésnek köszönhetően, ha az egyik szál blokkolódik egy erőforrásra való várakozás miatt, akkor a másik azonnal a helyére léphet. Így a CPU végrehajtási egységei nem maradnak kihasználatlanok, amely miatt kívülről szemlélve úgy tűnik, hogy a többszálú program összességében gyorsabban hajtódik végre. Ilyenkor, mivel 42

46 csak egy program használja a processzort, az architektúra által kínált erőforrások (regiszterek, cache, feldolgozó egységek) mind annak a rendelkezésére állnak. Nem csak egy alkalmazás gyorsítható a HT-vel, hanem különböző programok szálai is. Habár ilyenkor többnyire nincsenek osztott erőforrások, ezért a párhuzamos működésből fakadó hazárdok nagy része sincs jelen, de a különböző programok adatai csak részben töltődnek be a processzorba, ellentétben az előbbi esettel. Előfordulhat azonban olyan eset is, amikor buborék képződik. Erre akkor kerül sor, amikor mindegyik szál valamely erőforrásra várakozik, ezért egyikük sem kerülhet be a pipeline-ba. A HT célja többek között ezen végrehajtási üresjáratok számának minimalizálása. A szimulációs programomban az úgynevezett Round-robin algoritmuson alapuló, de a HT-ra szabott ütemezést készítettem el. Ennek lényege, hogy minden szál egy meghatározott számú utasítást hajthat végre, és utána a processzor a következő szálat indítja. Az ütemező által kiválasztott szálat egy szürke, téglalap alakú háttér különbözteti meg a többitől. A jelölés függetlenül attól, hogy az az aktív szál, vagy a blokkolódása miatt éppen egy másik fut helyette. A HT újítása ott jelenik meg, hogy amikor az egyik szál következő utasítása meghatározott ciklusidejű várakozásra kényszerül, akkor az ütemező helyette a következő szál utasításait kezdi végrehajtani. Ezáltal a pipeline minden szakaszában folyamatosan lesz egy utasítás, a globális teljesítmény nő. Kétszálas esetben a második szál addig fut, amíg az első blokkolása megszűnik, vagy ő maga nem blokkolódik. 16. ábra: 4 szálas Hyper-Threading 43

47 Több mint két szálas rendszer esetén a programom működése kissé bonyolódik. Amennyiben az első szál várakozásra kényszerül, akkor a második szálat próbálja meg végrehajtani. Ha annak az első utasításának feldolgozásához szintén várakozás szükséges, akkor a harmadikra ugrik, és így tovább. Az ütemező megkeresi és elindítja azt a szálat, amelyet várakozás nélkül a pipeline-ba küldhet. Buborék csak akkor képződik, ha egyetlen olyan szál sincs, amely erőforrásra való várakozás nélkül megkezdhetné a végrehajtását. Ilyenkor az összes szál blokkolódik és vár. Az a szál fog leghamarabb elindulni, amelynél az ütemező felismeri, hogy megszűnt a blokkolódást előidéző ok. Miután lejárt az első szál Round-robin szerinti futási ideje, a második szálra kerül a sor. Ennek ütemezése hasonló módon történik, mint az elsőé. Idő előtti blokkolódásnál, két szál esetében az első, több szál esetében a harmadik szálat fogja vizsgálni, hogy készen álle a futásra, amíg a másodiknak várakoznia kell. Megjegyzem, az Intel architektúrák csak kétszálas SMT-re képesek. A programomban megjelenő három, illetve négy szálas Hyper-Threading pusztán az elv kiterjeszthetőségét és a teljesítményre gyakorolt kedvező hatását hivatott bemutatni. Futtatásakor két animációs mód közül lehet választani. Ezek a Léptetés és az Indítás gombok megnyomásával indíthatóak el. Az előbbi, ahogy a címkéjéből is látszik, egyetlen ciklust fog lefuttatni, utána az animáció leáll. A gomb ismételt lenyomásával a következő ciklus végrehajtása tekinthető meg. Ennek előnye, hogy a felhasználó a maga tempójában, egyesével nézheti meg a szálak utasításainak ütemezését. A folyamatos lejátszás az Indítás gombbal indítható el. Ekkor a program automatikusan küldi az instrukciókat a feldolgozó egységbe. A lejátszás ugyanennek a gombnak a megnyomásával állítható le. Ilyenkor az éppen aktuális animáció még befejeződik, de újabb már nem indul el. A gombok alatt található csúszkával lehet szabályozni az animáció sebességét; 25%, 50%, 100%, 200%, 400% és 800% közül lehet választani. A továbbiakban a szimuláció hangolható paramétereit és azok alapértelmezett értékét ismertetem. Szálak száma: az animációban részt vevő programszálak számát lehet beállítani. A program indításakor ez az érték kettőre van állítva, mivel az Intel processzorok HT egysége is két szál kezelésére képes. Az SMT bemutatásának érdekében három, illetve négy szálas 44

48 szimuláció is választható. Ez utóbbiak esetében jelentős teljesítménynövekedés figyelhető meg. Egészen pontosan tovább csökken a buborék képződésének valószínűsége, amely a globális hatékonyságot növeli. Az egy szálas, vagyis SMT nélküli eset a Klasszikus végrehajtási opcióval érhető el. Végrehajtás: a Hyper-Threading technológia engedélyezését vagy letiltását szabályozza. A Klasszikus módban nincs HT egység, emiatt ha egy szál blokkolódik, akkor azt az időt kivárja a processzor, és nem indít addig helyette egy másikat. Csak akkor vált a következő szálra, ha az elérte az előre meghatározott végrehajtandó utasítások számát. Vagyis, ha ez a szám öt, akkor csak a hatodik soron következő utasításnál ütemezi be helyette a következő szálat, függetlenül attól, hogy összességében mennyit kellett várakoznia. Ebben az üzemmódban a Szálak száma paraméter alatt a tényleges program-szálak számát kell érteni, mert a processzormag architekturálisan csakis egy szál végrehajtására képes. Ezzel ellentétben az Intel Hyper-Threading -nél a szám a CPU magon belüli, hardveresen kialakított szálkezelési áramkörök mennyiségét jelenti. A jelenlegi rendszerekben ez a szám kettő, tehát egy mag két szál adatait és erőforrásait tudja kezelni annak érdekében, hogy a másikat azonnal indíthassa, ha az egyik blokkolódna. Fontosnak tartottam, hogy a három és négyszálas eseteket is szemléltetni tudjam. Szoftveresen nem okoz különösebb nehézséget négy vagy annál sokkal több szál menedzselése sem, holott az áramkörök szintjén akár már három szál nyilvántartása is kiemelkedő többletköltséget jelentene és komoly tervezési megfontoltságot igényelne. Egy szál maximális futási ideje: azt a számot jelenti, amennyi utasítás végrehajtását követően az ütemező a következő szálra vált át. A 16. ábrán is látható, a szálak fölé írt számok azt jelentik, hogy az adott szál eddig hány utasítást dolgozott fel. Ebbe a számba azok az utasítások is beletartoznak, amelyeket egy másik szál blokkolódásának ideje alatt kerültek végrehajtásra. Alapbeállítás szerint a programomban minden szál 5 utasítás idejére kapja meg a feldolgozó egységet, utána a soron következő szál kerül ütemezésre. Ennek a paraméternek a minimális értéke 1, míg a maximuma 6. Például az első szál három utasítása már feldolgozásra került az ötből, amikor a negyedik 2 időegységnyi várakozásra kényszerül. Ilyenkor HT esetben a processzor megvizsgálja a második szálat, hogy az futásra kész-e. Tegyük fel, hogy igen. Ekkor, amíg az első szál két ciklusidőnyit várakozik, addig a második szálból két utasítás végrehajtódik. 45

49 Ez a két utasítás szintén bele fog számítani a második szál rendes maximális futási idejébe, ha rá kerül a sor. Miután megszűnt az első szál blokkolódását kiváltó ok, folytatódik ennek a futtatása a hátra lévő két utasítással. Mindezek után a második szál kapja meg a processzor végrehajtó egységét, hogy az ő öt utasítását tudja feldolgozni. Blokkolás valószínűsége: annak a valószínűsége, hogy egy utasítás milyen eséllyel fog blokkolást előidézni. Minden utasítás előállításakor az alkalmazás ennek a valószínűségnek megfelelően dönti el, hogy miként állítsa be az utasítást szimbolizáló kör szoftveres és grafikai paramétereit. Induláskor ez az érték 20%, amelyet 10 és 50% között lehet változtatni. Blokkolás maximális ideje: ha egy utasítás blokkolásos, akkor ez az érték határozza meg azt a ciklusidőben mért időtartamot, amennyit a szálnak várakoznia kell. Ha ez letelt, csak akkor lesz az adott utasítás a processzor feldolgozó egységébe küldhető. A paraméter kezdeti értéke 4, amely 1 és 8 között változtatható OpenCL Az OpenCL napjaink egyik legígéretesebbnek tűnő teljesítménynövelő technológiája. Néhány éve már jelen van a hardverekben, a GPGPU koncepcióból fejlődött ki, azonban egyelőre kevés olyan szoftver van, amely használná is ezt a lehetőséget. Ha ez megváltozna, és az alkalmazások szélesebb körben kezdenének építeni erre, nagyjából olyan szintű korszakváltás köszöntene be az informatikában, mint amilyen a többmagos processzorok elterjedése volt a kétezres években. Maga az elgondolás egyszerű: miért ne lehetne munkára fogni általános számítási célokra is azt a videóvezérlőt, amely igazán csak játékok és filmnézés közben aktív, minden más esetben pedig jó, ha részben ki van használva. A számítógépi grafikában fontos szerephez jutnak a mátrixok, hiszen minden geometriai transzformációt ezekkel írnak le. A GPU-k pedig célprocesszorként többek között a mátrixokkal történő műveletvégzésre vannak kiélezve, az extrém gyors szálkezeléséről nem is beszélve. Az OpenCL elterjedésének részben az szab még gátat, hogy nehéz az általános számítási feladatokat párhuzamosítani. Megjegyzem, a számítógépi grafika tipikusan olyan terület, ahol jól párhuzamosítható algoritmusokkal dolgoznak. Hasonló helyzet alakult ki a többmagos architektúrák megjelenésekor is: addig a fejlesztők egyetlen processzormagra optimalizálták programjaikat, és el kellett telnie néhány évnek, hogy az egyes alkalmazások is profitálni tudjanak a PC-kben jelenlévő több 46

50 végrehajtóegységből. A többmagos rendszerek látványosan gyorsították a multi-tasking-ot, azonban itt most az egy alkalmazáson belül elérhető teljesítménynövekedést vizsgálom. Tehát a technológia elsősorban olyan esetekben hozhat előnyt, amely alapvetően grafikai (multimédia), vagy sok, egymástól többé-kevésbé független részre felosztható probléma. Azonban tekintettel kell lenni arra is, hogy hiába van sok stream-processzor egy GPU-ban vagy hozzávetőlegesen néhány tucat általános célú processzor, ezek órajele jóval alacsonyabb, mint a CPU-é. Ezért minden esetben vizsgálni kell, hogy az erős párhuzamosításból adódó lehetséges nyereség nagyobb-e, mint amikor a program csak a központi processzoron futna (annak egy vagy több magján). Érdekes, de megvalósítható megoldás az olyan helyzet, amikor egy program általános célú, bonyolultabb műveleteit a CPU, a jól párhuzamosítható, rövidebb, esetlegesen célhardvert igénylő műveleteit pedig a GPU hajtaná végre. Az ehhez kapcsolódó szimulációm a megszokott módon nem csupán magát a technológiát mutatja be, hanem annak előzményeit is. Lehetőség adódik arra, hogy négy különféle utasítástípust háromféle feldolgozó egységen futtassunk, mindvégig feltételezve, hogy az utasítások végrehajthatóak ezeken az egységeken. 17. ábra: OpenCL Háromféle feldolgozóegység típus jelenik meg ebben a szimulációs ablakban. Kettő általános célú CPU-mag, négy általános célú GPU (GPGPU) és nyolc darab grafikus stream-processzor. Ma már nem jelent sem tervezési sem technológiai akadályt, hogy 47

51 mindezek egyetlen processzor-lapkán belül helyezkedjenek el. Több gyártó is jó ideje készít ilyen, grafikus célhardverrel felszerelt processzorokat (Intel Core család Intel HD Graphics-al, AMD APU). A processzorba integrált videó-vezérlőket szokás IGP-nek (Integrated Graphics Processor, integrált grafikus processzor) is nevezni. Ezen feldolgozó egységek megjelenítését úgy oldottam meg helytakarékossági okokból, hogy egyszerre csak a CPU-magok és vagy a GPGPU-k vagy a streamprocesszorok látszódnak, ahogy ez a 17. ábra esetében megfigyelhető. A program írásakor ügyeltem arra, hogy a lehetséges beállítások között ne legyen olyan eset, amikor mindkét grafikus processzorra egyszerre ütemeződnének feladatok. A valóságban természetesen ez gyakran előfordul, de a szimuláció logikai felépítése miatt ez nem került bele a programba. Végrehajtás módja: alapvetően kétféle végrehajtási mód van. Az egyik a Klasszikus, amely a különböző feladatok, különböző processzor típuson történő végrehajtását mutatja be. A másik pedig az OpenCL, amely egy heterogén környezetben zajlódó utasítás-csoport feldolgozását szemlélteti. Ez utóbbi módban a látványosság kedvéért érdemes lenne mindhárom processzor típust egyszerre megjeleníteni, azonban az OpenCL szemléletmód szempontjából ez nem lényeges. Kivételes módon ekkor a felhasználó csak a végrehajtandó utasítások számát állíthatja be, azok fajtáját és végrehajtási célját nem. Ezeket a program automatikusan, saját maga adja meg. Az ablakban mind a két CPU-mag, és mind a nyolc streamprocesszor aktív, a GPGPU-k el vannak rejtve. Erre az összesen tíz processzorra ütemeződnek a feladatok. Az egyszerűség kedvéért úgy vettem, hogy a CPU-kra általános célú és párhuzamosítható, míg a grafikus processzorokra grafikus jellegű (vagy azok képességeihez jól illő) feladatok kerülnek. Utasítások típusa: a program Klasszikus végrehajtás esetén négyféle utasítást különböztet meg. Általában elmondható, hogy az általános utasítások a CPU-n futnak a legjobban, de a GPGPU is alkalmas a kezelésükre. A grafikus utasítások bármin futhatnak, azonban a stream-processzorok képesek a leggyorsabban feldolgozni ezeket. Az utasítás típusok a következők: Általános, nem párhuzamosítható: szigorúan csak sorosan hajtható végre, ezért csak egy feldolgozóegység dolgozhat rajta. Leggyorsabban egy CPUmag tudja feldolgozni, de GPGPU-n is futtatható. Általános, gyengén párhuzamosítható: bizonyos párhuzamosságot megenged, amely elegendő a két CPU-mag hatékony kihasználásához. A GPGPU-k közül is csak kettőt tud igénybe venni. 48

52 Az INTEL mikroprocesszorok architekturális Általános, erősen párhuzamosítható: elviekben a rendszer által kínált összes általános-célú processzoron futtathatóak. A GPGPU-kon lassabbak azok alacsonyabb órajele miatt. Azonban valós rendszereken négynél jóval több ilyen processzor van, és ha a feladat valóban jól párhuzamosítható, a tisztán CPU-s végrehajtásnál sokkal gyorsabb megoldást kínálhat. A szimulációban mindkét CPU-t vagy mind a négy GPGPU-t használhatják. Grafikus (erősen párhuzamosítható): tipikusan grafikai jellegű feladatokat jelent. Ezek megoldására bármelyik processzor típus alkalmas, azonban leggyorsabban az IGP stream-processzorai képesek erre. Futás célja: Klasszikus módban az utasítások futási célját jelöli ki. Meghatározza, hogy az adott típusú utasítást milyen processzor típuson kívánjuk futtatni. Ezáltal megmutatható, hogy az adott fajtájú feladatok nagyságrendileg milyen gyorsan hajtódnak végre az adott feldolgozó egységen. A szimulációban a processzorok órajelét és utasítástípusonkénti feldolgozási idejét az alábbi 3. táblázatban foglaltam össze. CPU (~3.0 GHz) GPGPU (~1.0 GHz) GPU-stream Általános 1 s 3 s - Grafikus 2 s 1.25 s 1 s 3. táblázat A fenti táblázatból jól látszik, hogy mivel a CPU nagyjából háromszor gyorsabb a GPGPU-nál, ezért az általános feladatokat is ennyivel gyorsabban képes megoldani. A grafikus utasítások végrehajtási idejénél azonban teljes egészében általam választott számok szerepelnek. Ezek megválasztásakor azt tartottam szem előtt, hogy a GPU streamprocesszora kifejezetten erre lett kifejlesztve, így azon kell a leggyorsabban is végrehajtódnia. A GPGPU egy speciális GPU, ennél fogva kicsit lassabban, de jó hatásfokkal kell tudnia feldolgoznia az ilyen utasításokat. A CPU bármilyen rábízott feladatot meg tud oldani. Ennek a rugalmasságnak az ára az, hogy az ilyen speciális esetekben kissé lomhább, mint az előbbi két processzor típus Cache szimulációja A cache az adatok és utasítások processzorban való elérésének és tárolásának egyik legfontosabb eleme. Az eddig ismertetett technikák azzal foglalkoztak, hogy hogyan is érdemes gyorsan és hatékonyan a már a processzorban lévő adatokat feldolgozni. Ilyenkor 49

53 mindig feltételeztük, hogy ezek a szükséges adatok késleltetés nélkül, azonnal a rendelkezésünkre állnak. Az, hogy ez bizonyos fokig valóban így is legyen, valamilyen módon ellensúlyozni kell a RAM-ból (esetleg háttértárból vagy egyéb perifériából) történő adatmozgatásból fakadó elkerülhetetlen késleltetést. A program ezen részének tervezésekor több alternatíva is felmerült, hogy mit lenne érdemes megvalósítani. Az első ötletem a cache-entry-k kezelésének, keresésének és a cache-hit működésének részletes bemutatása volt. Ezt végül is elvetettem, mert ha ezt a mechanizmust akartam volna elkészíteni, akkor a többi programrészhez képest indokolatlanul bonyolult szoftvert kellett volna írnom. Gyakorlatilag egy valós program memória-műveleteit kellett volna beépítenem a szimulációba, hogy a cache szerepét be tudjam mutatni. Úgy véltem, hogy ezek az átlag felhasználó szempontjából kevésbé lényegesek, és a cache-nek vannak ennél érdekesebb aspektusai is. Ebből kifolyólag egy egyszerűbb megoldást kerestem. Ennek részeként a valós program beépítését is elvetettem, mert rájöttem, hogy a kívánt működést maga a felhasználó is létre tudja hozni. Ha ezt automatikusra készítettem volna, akkor pusztán a véletlenen múlt volna, hogy mikor fog egy, a felhasználó számára fontos esemény történni. Ellenben, ha maga a felhasználó választja ki, hogy mi történjen, úgy sokkal inkább előtérbe tud kerülni a szimuláció mondandója. A cache-szimuláció kizárólag a beolvasást mutatja meg, mert a műveletek szempontjából ez a kritikusabb (a nem módosuló kiírandó érték RAM-ba írása nem jelent problémát). Ezen belül is a legrégebben nem használt (LRU) helyettesítési stratégiát valósítom meg úgy, hogy egy cache-entry csak egyszer szerepel az egész cachehierarchiában. Az LRU stratégia abból áll, hogy a felhasználó választ egy adatot, amelyre majd szüksége lesz a processzornak. Ily módon maga a felhasználó fogja megadni a programvezérlést annak érdekében, hogy bármilyen olyan eset vizsgálható legyen, amelyre kíváncsi. A cache-vezérlő elkezdi a kért adatot az L1-ben keresni. A keresések nem jelennek meg önálló animációként. Ha nem találja, folytatja a keresést az L2-ben, majd az L3-ban, végül magában a RAM-ban. A szimulációmban párhuzamosan azzal, hogy az adat az L1-be mozgatódik, megkezdődik az L1 legöregebb bejegyzésének a kimozgatása L2-be (természetesen csak akkor, ha az L1 már tele van). Ha van hely, akkor egyszerűen beteszi oda, ha nincs, akkor elindul az L2 legöregebb bejegyzésének kimozgatása az L3-ba. 50

54 Az L3 nem fog adatot kiírni a RAM-ba, mert az egyszerűség kedvéért összesen 24 adatméretű RAM-ot készítettem, a három cache összkapacitása pedig = 32. A cache és RAM közti sebesség és tárkapacitás közti viszonyt kissé torzítom a szimulációban annak érdekében, hogy könnyen ábrázolható és felhasználói szemszögből még élvezhető gyorsaságú legyen. Ezeket a mérőszámokat az alábbi, 4. táblázatban foglaltam össze. A táblázat azt is megmutatja, hogy mely memória-típusok között lehetséges adatmozgatás. Mivel a kiírással nem foglalkozom, ezért a RAM-ba történő adatmozgatások idejéhez - -t írtam. Az L1 és a regiszterek közti adatcserék sem jelennek meg a szimulációban. Úgy veszem, hogy ami az L1-ben van, az igen minimális (a programban 0.0 s) idő alatt be tud kerülni a regiszterekbe. honnan/hova L1 (4) L2 (8) L3 (20) RAM (24) L1 (4) 0.0 s 1.0 s - - L2 (8) 1.0 s s - L3 (20) 1.5 s 1.5 s - - RAM (24) 2.5 s táblázat: az up Sim Cache szimulációjában használt memória-rekeszek mérete és adatmozgatási ideje Az alább látható kódrészlet az L1 cache-ben történő kereséskor történő cache-hit animációja. A cache-hit teljes animációjának ideje 1.0 másodperc, amely 0.5 s-os felvillanásból és ugyan ennyi ideig tartó visszahalványulásból tevődik össze. /// <summary> /// Cache-hit animációja az L1-ben. /// </summary> /// <param name="ec">az animálandó bejegyzés.</param> public void AnimateL1Access(EntryControl ec) { stackpanel1.isenabled = false; ColorAnimation ca = new ColorAnimation(Color.FromArgb(192, 255, 0, 0), TimeSpan.FromSeconds(0.5)); ca.autoreverse = true; ca.completed += (o, e) => { stackpanel1.isenabled = true; }; ec.background.beginanimation(solidcolorbrush.colorproperty, ca); } 51

55 18. ábra: Cache A programom jelenleg csak az egymagos cache-hierarchiát képes kezelni. Ennek megfelelően, ahogy az a 18. ábrán is látszik, csak a felsőbb processzor és a hozzá tartozó L1 és L2 cache-ek aktívak. Az L3 általában egy osztott cache szokott lenni, éppen ezért úgy alakítottam ki a megjelenítését, hogy mindkét maghoz hozzá tartozzon. A RAM a CPU-n kívül, bal oldalt található. A Beolvasható adatok részben található meg annak a 24 adatnak a listája, amelyeket a RAM-ból be lehet olvasni (a RAM itt pontosan 24 bejegyzést tartalmaz). A felhasználónak a kívánt adatra kell kattintania, melynek hatására az az L1-be kerül. Abban az esetben, amikor ez már eleve az L1-ben volt, úgy a cache-hitet az adatot szimbolizáló téglalap pirosas felvillanása jelzi. 52