Az 1970-es évek végére a CPU tervezők és a fordító programok írói rájöttek, hogy az ilyen összetett utasítások mégsem olyan hasznosak. Nehéz volt olyan processzort tervezni, amelyben ezek a bonyolult utasítások igazán hatékonyan működtek, és nehéz volt olyan fordítóprogramot írni, amely ténylegesen ki tudta a sokféle és bonyolult utasítást, címzésmódot, adattípust használni. Ez változott meg a magasabb szintű programnyelvek megjelenésével, amelyek olyan utasításokat és címzéseket kezdtek alkalmazni, amelyeket az assembly programozók csak nagyon ritkán használtak. A chipterületet és a fordító programok összetettségét jobban hasznosíthatták általánosabb célokra, például sok, általánosabb célú regiszterre. A jó minőségű fordítóprogram elvégzi a processzor előfeldolgozási feladatait, az utasítások (elvben) úgy érkeznek, ahogy az adott processzornak a legjobban megfelel. Felesleges a kódot minden egyes alkalommal futásidőben optimalizálni, legjobb fordításkor elvégezni az időigényes feladatot.
Az első integrált áramkört Jack Kilby tervezte 1958-ban. Az első mikroprocesszorok a '70-es években jelentek meg - az első kereskedelmi forgalomba kerülő processzort - a 4 bites i4004-est - az Intel adta ki 1971-ben. A 80-as évek elején jelentek meg a RISC processzorok, amelyek a korábbi túl komplex CISC processzorok teljes áttervezésével, jórészt John Croke (IBM) munkája nyomán születtek meg az architektúra egyszerűsítésével. A memória árak csökkenésével az egyszerűbb, egyforma hosszúságú utasításokat a futószalagok (pieline-ok) hatékonyabban tudták kezelni (a "futószalag" hamarabb olvassa be a következő utasításokat, mint ahogy az előzők végrehajtása befejeződik).
Néhány példa a CISC mikroprocesszorokra:
- DEC VAX, PDP-8, PDP-11
- Motorola 68000 (68K), később Coldfire
- Intel 8051, Intel x86 generációi, x86_64
- ZiLOG Z80/Z180/ZNEO
Példák a RISC processzorokra:
- MIPS
- DEC Alpha
- PowerPC
- Atmel’s AVR
- Microchip PIC
- ARM processzorcsalád
- RISC-V
Minden modern processzor tartalmaz valamennyi RISC elemet, ráadásul a 8bit->16bit->32bit átmenetet is a RISC processzorok forszírozták, mert általában egy RISC utasítás 32 bit hosszú. Mindazonáltal évtizedekbe telt, mire a RISC architektúra el tudott terjedni, főként a RISC architektúrákon futó szoftverek hiánya miatt. Az Intel szintén hatással volt az elterjedésre, mivel rendelkezett a CISC architektúra használatának folytatásához szükséges tudással, erőforrással és nem találta szükségesnek az x86-os termékvonal újratervezést. Az i860/i960-as termékcsaládot leállították, az XScale család legnépszerűbb PXA termékvonalát eladták a Marvell Technologies-nek. Ez hatalmas piaci veszteséget okozott később az okostelefonok és tabletek elterjedésekor, mert az Intel legkisebb Atom processzorai alkalmatlanok voltak a feladatra, és a piacot vitte az ARM.
A MIPS architektúra volt az egyik első és "legtökéletesebb" RISC, általában ma is ezzel kezdik az iskolákban a tananyagot.
Az x86 család kicsit más. Eredetileg CISC architektúrát jelentett a nagyon kis memóriájú rendszerek számára (nem volt hely a nagy programoknak), és sok egymást követő verzión ment keresztül. A mai x86-os utasításkészlet nem csak azért bonyolult, mert CISC, hanem azért is, mert valójában egy 8086-os, egy 80386-os és egy Pentium "mag" is van az x86_64 processzorokban. A mai világban már nem beszélhetünk feketén-fehéren RISC és a CISC processzorokról. A legtöbb CPU-architektúra a szürke különféle árnyalata felé fejlődött.
A RISC-ek oldalán néhány modern MIPS-változat rendelkezik szorzó és osztó utasításokkal, nem egységes kódolással. Az ARM processzorok is bonyolultabbá váltak: sokuk rendelkezik 16 bites utasításkészlettel is, az úgynevezett Thumb-val, az "eredeti" 32 bites utasítások mellett. Ne felejtsük el a Jazelle-t, amely képes JVM utasítások végrehajtására magában a CPU-ban. A modern ARM processzorok SIMD utasításokat is tartalmaznak a multimédiás alkalmazásokhoz, így végül is rendelkeznek néhány összetett utasítással.
A CISC oldalon minden modern processzor belül bizonyos mértékig RISC. Mikrokóddal rendelkeznek az összes összetett makró utasítás definiálására. A processzor puszta összetettsége miatt az egyes modellek tervezése több évet is igénybe vehet, még a RISC kialakítás mellet is, a komponensek nagy száma, a futószalagok, a prediktív futtatás és még ki tudja mik miatt. A mikrokód szerencsére lehetőséget kínál a rejtett hibák utólagos javítására.
De miért maradnak a leggyorsabb processzorok CISC-ek kívülről? Ennek része az x86 (32 bites és 64 bites) család esetén a történelmi kompatibilitás. De nem csak erről van szó. A 2000-es évek elején az Intel megpróbálta elterjeszteni az Itanium architektúrát. Az Itanium összetett utasítások extrém esetét jelenti (nem igazán CISC, a design EPIC néven ismert). Még az elavult, utasításokat sorban végrehajtó, régimódi elképzelésen is túllépett: az utasításokat párhuzamosan hajtja végre a következő elágazásig/töréspontig. Az egyik oka az Itanium kudarcának az volt, hogy senki, még maga Intel sem tudott egy tisztességes fordító programot írni hozzá. A jó öreg, jórészt szekvenciális processzor, mint az x86_64 az a valami, amit még képesek vagyunk megérteni.
De van egy sokkal fontosabb ok is! A CISC processzorok a limitált memóriaméret miatt alakultak ki. Egyszerűen muszáj volt tömör és hatékony utasításkészletet használni, mert a RAM ára anno ('70) nagyon magas volt. Manapság a processzorok sokkal gyorsabbak, mint a memóriák. Egy memória olvasás alatt a processzor több száz utasítást is végre tud hajtani, a rés ráadásul egyre csak növekszik. A CPU órajel emelkedését csak kis mértékben követte a memória órajel növekedése. Ráadásul 4-12 CPU mag is lehet egy tokban, amelyek osztoznak a közös RAM-on. Manapság nincs jelentősége, hogy egy utasítást a processzor 1 vagy 10 órajel ciklus alatt hajt végre. Ráadásul az összetettebb utasítások hatékonyabban tudják a gyorsítótárat kihasználni.
Manapság a memória azért "drága" újra, mert nagyon "lassú". A nagy mennyiségű dinamikus memóriát állandóan frissíteni is kell, amely további órajel ciklusokat vesz el.
A 80-as, 90-es években az egész RISC ötlet legfontosabb eleme az volt, hogy azonos méretű utasítások használatával gyorsítsa a végrehajtást. A CPU minden alkalommal megkapja az azonos méretű utasításokat (nincs komplex, lassú, kitalálandó utasításméret lépés), a CPU csak egyszerű dolgokat csinál, egyszerűen és gyorsan el lehet dönteni, hogy mi a következő lépés. A memória olcsó volt. Így felszabadultak áramkörök a processzorban hasznosabb feladatokra (több regiszter, több feldolgozóegység, utasítások párhuzamos végrehajtása). Mivel a processzorok sokkal lassabbak voltak a memóriáknál, a lépés kifizetődött. De ahogy a processzorok egyre gyorsabbak lettek, javult a párhuzamos végrehajtás, nőtt a magok száma, addig a RAM sebesség alig növekedett (legalábbis nem ugyanolyan sebességgel, mint a CPU-k növekvő párhuzamossága). A beépített gyorsítótárak (cache) gyorsak, mint a CPU, de kis méretűek. Így tehát a memória újra kevés lett, de nem a költség, hanem a sebesség miatt. Újra eljött a CISC ideje. Közben a CPU-k még bonyolultabbakká váltak, sok elemet átvettek a RISC fordítóprogramok optimalizálásai közül: a műveleteket alapelemekre bontják, az utasításokat átrendezik és le is fordítják a belső, RISC szerű alap utasításokra, hogy lehetőség szerint párhuzamosan is végrehajthatók legyenek. Így mára a RISC kifejezés fokozatosan elveszítette a kezdeti fényét.
A probléma áthidalására némely CISC CPU gyorsítótára rendelkezik Huffman-kódolással is, amely tömörítve tovább gyorsítja a feldolgozást, míg az ARM processzorok u.n. inline tömörítést alkalmaznak.
| CISC | RISC |
| Eredeti mikroprocesszor architektúra | A 80-as években átdolgozott architektúra |
| Az összetett utasítások néhány órajel-ciklus alatt futnak le | Egy órajel ciklusú, egyszerű utasítások |
| Mikroprogram által vezérelt utasítás-végrehajtás | Huzalozott utasítás-végrehajtás |
| Hardver-centrikus tervezés, minden lehetséges hardver elem bevetése az optimalizálásba | Szoftver-centrikus tervezés, a magas szintű fordítóprogramok leveszik az optimalizálás terhét a programozóról |
| Változó hosszúságú utasítások | Rögzített hosszúságú utasítások |
| Hatékonyabb memória használat, több utasítás is igénybe veheti a tárolót |
Nagy mértékű memóriahasználat, csak a LOAD/STORE utasítások használhatják a tárat |
| Bonyolult, változó méretű utasítások | Egyszerű, szabványos utasítások |
| Mikrokód használata | Csak egy utasításréteg |
| Nagy mennyiségű utasítás | Kevés, azonos hosszúságú utasítás |
| Sokféle címzésmód | Kis számú címzésmód |
| Kevés regiszter | Nagy méretű regisztertár (>16) |
Egy "hagyományos" RISC processzor mindent a regiszterein keresztül végez (load/store aritmetika). Egy adott memória tartalmat csak úgy tudunk megváltoztatni, ha előbb beolvassuk valamelyik regiszterbe, elvégezzük a műveletet, majd visszaírjuk a memóriaterületre. Ez nagyon sok memória olvasási, írási művelettel jár.
Példaképpen csökkentsük egy adott memóriatartalmat eggyel:
CISC:
dec [address]
RISC:
ldr r0,[address]
sub r0,#1
str r0,[address]
Futószalagok nélkül a CISC dec utasítás több mint kétszer gyorsabban hajtódik végre, mint a RISC load/sub/store utasítások, ráadásul a bekapcsolt futószalagok jobb optimalizálást végeznek a dec utasítás végrehajtásakor.
Még egy x86 példa a bonyolult CISC utasításokra:
REP MOVS byte ptr ES:[DI],ES:[SI]
A CX regiszterbe kell tenni a darabszámot, amelyet nulláig csökkentve fut a ciklus. A REP 1 byte, MOVS 1 byte és hozzá jön az értékadás az elején.
Az utasítás memória írási, olvasási sebességgel másol memóriaterületet, néhány byte helyfoglalással.
Ugyanerre bonyolult ciklust kell írni ARM alatt, ahol minden egyes írási és olvasási program műveletet végig kell csinálni. Olyasmi érzés lehet, mint anno C64-en a 6510-es processzorral szorozni és osztani. A szorzó/osztó utasítás nem része az utasításkészletnek és kézzel kellett megírni.
A CISC másik nagy hajtóereje az ortogonalitás, minden utasítás minden címzési móddal (regiszter, abszolút cím, relatív eltolás stb.) használható.
Az Intel nagy reményeket fűzött a mobil piacnak, de valamiért mégsem terjedtek el (eléggé) a mobil Atomok. Ennek politikai okokon kívül az is lehet az oka, hogy a fejlesztések kezdetén nem volt elég kis méretű, fogyasztású és árú Intel processzor. Az olcsó kínai ARM és MIPS klónokon indult el a fejlesztés, nehezen állnak át a fejlesztők egy más, esetleg eltérő bájtsorrendű platformra.
Érdekes, hogy az Intel Xeon és a Qualcomm ARM szerver processzorok fej-fej mellett haladnak a performance-per-watt - teljesítmény/áramfelvétel teszteken, pedig - a közhiedelem szerint - az ARM alapú RISC rendszereknek kellene vezetni a listát.
A közelmúltban nyilvánosságra került prediktív előrejelzés és hasonló bug-ok, vajon hogyan fogják befolyásolni a versenyt?
De erről majd egy későbbi blog bejegyzésben írok.