Digitális technika VIMIAA02 9. hét

BUDAPESTI MŰSZAKI ÉS GAZDASÁGTUDOMÁNYI EGYETEM VILLAMOSMÉRNÖKI ÉS INFORMATIKAI KAR MÉRÉSTECHNIKA ÉS INFORMÁCIÓS RENDSZEREK TANSZÉK Digitális technika VIMIAA02 9. hét Fehér Béla BME MIT

Processzor adatstruktúrák DIGITÁLIS RENDSZEREK ÁLTALÁNOS FELÉPÍTÉSE: ADATSTRUKTÚRA + VEZÉRLÉS Vezérlés: Minden feladatra egységes általános elv De természetesen egyedi állapotdiagram, jelek, stb. Adatstruktúra: Egyedi felépítés, feladatorientált kialakítás Megmaradt a HW párhuzamos, időben konkurens működése

Processzor adatstruktúrák ADATSTRUKTÚRA + VEZÉRLÉS Adatstruktúra: Ahány feladat, annyi architektúra Lehetne itt is általánosítani? Valószínűleg igen Feladjuk a párhuzamos működés előnyét az egyszerű tervezhetőség érdekében Sok elemi művelet időben sorban egymás után, lehetőleg ugyanazt a HW-t használva

Processzor adatstruktúrák Milyen legyen az általános adatstruktúra? Komponensek: adattárolók, műveletvégzők, huzalozás Adattárolók: Önálló regiszterek: bármelyik adat bármikor elérhető/tölthető Regisztertömb: korlátozott számú adat érhető el (1,2,3) Stack: csak a stack teteje érhető el (1,2) Műveletvégzők: Egyedi elemek, közvetlen egyedi bemenetekkel Többfunkciós egység, funkcióválasztással és bemeneti operátor kiválasztással (ADD/SUB/COMP, AND/OR/XOR) Általános státuszjelek a művelet eredményéről (Z/C/N/V) Huzalozás: Bemenet/ kimenet kiválasztás/aktiválás Belső adatutak, operandus kiválasztás

Processzor adatstruktúrák Milyen legyen az általános adatstruktúra? Szabványosítás: Adatméret: minden legyen adat azonos méretű pl. 8 bit Egyedi jelek lehetnek egy bitvektor elemei, beolvasunk 8 bitet, és maszkoljuk a kívánt bitpozíciót Az eddigi külső vezérlőjelek (pl. START) is adatbemenetként kezelhetőek, beolvashatóak, tesztelhetőek és a teszt eredménye szerint használhatóak a vezérlési feladat végrehajtására A kimeneti jelek hasonlóan egységesen kezelhetők, 8 bites bitvektorok közvetlenül, egyedi bitek bitpozíció beállítással kiadhatók A vezérlő egység kimenete (pl. READY) is így kezelhető

Processzor vezérlés Az általános adatstruktúra jól használható, de képességei korlátosan érvényesíthetők Egy ütemben egy változó módosulhat Ez erősen szekvenciális végrehajtást jelent A vezérléshez az ASM működési modell csökkentett képessége bőven elegendő Nem jelent lényeges előnyt az általános FSM/HLSM tetszőleges állapotátmeneti képessége ASM állapotátmenetek: CONT: folytatás (ez az alapértelmezett mód) JUMP: ugrás tetszőleges állapotra (saját magára is) CJMP: elágazás, feltételes ugrás tetszőleges állapotra Feltétel nem teljesülése esetén CONT, folytatás

Processzor vezérlés ASM algoritmikus állapotvezérlővel A vezérlő ebben az esetben lehet egy egyszerű számlálón alapuló vezérlőegység: programszámláló (PC, Program Counter) Az állapotátmenetek vezérlése: CONT: PC <= PC + 1; // számláló INC JUMP : PC <= LABEL; // számláló LOAD CJMP : if (COND) then PC <= LABEL // LOAD else PC <= PC +1 // INC Ezt a feladatot egy inicializálható, tölthető bináris felfelé számláló tudja biztosítani RESET-re PC = 0, vagy a csupa 1, azaz 0xFFFF

Processzor vezérlés ASM algoritmikus állapotvezérlővel A vezérlőjelek tehát nem közvetlenül a PC értékéből származnak, (annak állapota nem direktben kódolja azokat), hanem a PC tartalma megcímzi és kiolvassa a programmemóriában található utasítás szót (FETCH), és az utasításszó tartalmazza a kódolt vezérlőjeleket (annyi biten, amennyi a formátumba belefér), ezt az utasítás dekóder értelmezi (DECODE) és juttatja el az adatstruktúra felé végrehajtásra (EXECUTE). Tehát az adatstruktúra vezérlőjel generálás folyamata: PC új érték FETCH DECODE EXECUTE Ez történik a processzor vezérlő egységében

Processzor műveletvégzés Regisztertömb alapú adatstruktúra kiegészítése be- /kimeneti interfésszel (memória, periféria) Általános tulajdonságok: Minden adatot először beírunk a regisztertömbbe Műveletet csak a regiszter adatokon végzünk Létezik közvetlen adat programkódból A részeredményeket visszaírjuk A végeredményt kiadjuk Ezt hívjuk LOAD/STORE felépítésnek A regisztertömb mérete Szélesség: 8/16/32/64 bit Mélység: 16/32/64 regiszter Több regiszter több reg. címbit (ut. méret) Több regiszter kevesebb extra adatmozgatás A 32 bites utasításméret jó kompromisszum

Processzor műveletvégzés Az adatstruktúra műveleti egysége: ALU: Aritmetikai Logikai Egység Műveleti képességek (utasítás készlet) Aritmetikai (ADD, SUB, INC, DEC.) Logikai (AND, OR, XOR, NOT ) Léptetés (SHL, SHR, ASH ) Forgatás (ROL, ROR, ) Feltétel vizsgálat (COMP, TST, ) Egyszerű adatmozgatás (MOV, LD, ST) Minden művelet a szabványos adatméreten 8 / 16 / 32 / 64 bit, az adott rendszer jellemzője Kisebb adatméret: operandus/eredmény maszkolása Nagyobb adatméret: Átvitelbit használatával kiterjesztett műveletvégzés

Processzor műveletvégzés ALU felépítése 1. verzió: Minden feladatra külön áramkör, a kimeneten MUX hálózattal nem gazdaságos 2. verzió: Sok feladat egyetlen összeadóval + a bemeneten speciális kiegészítés az adatelőkészítésre Kivonás: Kettes komplemens képzéssel Inkrementálás: 1 hozzáadása (pl. Ci) Dekrementálás: 1 kivonása Léptetés balra: önmagával összeadás Konkrét áramköri megoldások eltérőek Közös vonás: Néhány bites vezérlés: FUN bitek Operandus kiválasztás: REG1, REG2 cím Bemenet/kimenet előválasztás MUX vez

Összegzés Tetszőleges digitális rendszer: Általános rendszerterv: adatstruktúra + vezérlés Processzoros rendszerek: Általános processzor adatstruktúra + ASM alapú egyszerűsített processzor vezérlőegység A vezérlési állapot indirekt megadása: PC (programmemória cím) programtár olvasás (aktuális utasítás) dekódolt vezérlő jelek származtatása és végrehajtás Továbblépés: PC = PC +1 vagy esetleg (feltételes) ugrás Egységesített adatméret és be-/kimeneti interfészek LOAD/STORE működés, külső vagy memória adatok regiszterbe töltődnek használat előtt

MiniRISC processzor - Bevezetés 8 bites vezérlőegység egyszerű alkalmazásokhoz Jól illeszkedik a LOGSYS Spartan-3E FPGA kártya komplexitásához Egyszerű felépítés, kis erőforrásigény Harvard architektúra 256 x 16 bites programmemória 256 x 8 bites adatmemória Egyszerű RISC jellegű utasításkészlet Load/store architektúra Műveletvégzés csak regisztereken 16 x 8 bites belső regisztertömb

MiniRISC mintarendszer LED-ek DIP kapcsoló A bővítőcsatlakozó B bővítőcsatlakozó 128 x 8 bites adatmemória (0x00 0x7F) basic_owr (0x80) basic_in (0x81) basic_io (0x84 0x87) basic_io (0x88 0x8B) MiniRISC CPU Adatmem. Adatmemória interfész Debug Prg. mem. slave_usrt (0x8E 0x8F) basic_display (0x90 0x9F) basic_timer (0x8C 0x8D) basic_in (0x82) Debug modul 256 x 16 bites programmemória USRT JTAG nyomógombok fejlesztői és kommunikációs port kijelzők

MiniRISC processzor Felépítése követi az adatstruktúra-vezérlő szemléletet Vezérlő: az utasítások beolvasása, feldolgozása és ennek megfelelően az adatstruktúra vezérlése Adatstruktúra: műveletek végrehajtása az adatokon Adatmemória DOUT RD WR DIN DOUT Vezérlő jelek Feltétel jelek Adatstruktúra MiniRISC processzor

MiniRISC processzor adatstruktúra Adatmemória működése Adatmemória Adatmemória DIN DOUT RD WR DIN DOUT RD WR DIN DOUT RD WR MUX MUX MUX Regisztertömb Regisztertömb Regisztertömb ALU ALU ALU Adatmemória olvasás (load) Lokális adat átalakítása (ALU művelet) Adatmemória írás (store)

MiniRISC processzor A működés bemutatása egy egyszerű példán Példa: DMEM[3] = DMEM[0] + DMEM[1], ez négy adatstruktúra műveletet igényel: 1. REG[0] = DMEM[0] (load) 2. REG[1] = DMEM[1] (load) 3. REG[1] = REG[0] + REG[1] (ALU művelet) 4. DMEM[3] = REG[1] (store) Utasítás: a processzor által végrehajtható művelet Program: utasítások sorozata A végrehajtandó feladatot a processzor által támogatott utasításokra kell lebontani A programot a programmemória tárolja A vezérlőegység beolvassa az utasításokat és végrehajtja azokat az adatstruktúrán Programszámláló (Program Counter, PC): a beolvasandó utasítás címét állítja elő Utasításregiszter (Instruction Register, IR): a beolvasott utasítást tárolja PC DOUT IR Vezérlő vezérlő jelek feltétel jelek

MiniRISC processzor Minden egyes utasítás végrehajtásánál a vezérlőegységnek a következő lépéseket kell elvégeznie: Lehívás (fetch): az utasítás beolvasása a programmemóriából és a PC növelése Dekódolás (decode): a művelet és az operandusok meghatározása Végrehajtás (execute): az utasításhoz tartozó művelet végrehajtásra kerül az adatstruktúrán A vezérlő lehet például egy állapotgép A fenti lépésekhez a vezérlő állapotgép egy-egy állapota rendelhető hozzá Ekkor egy utasítás végrehajtása három órajelciklust igényel PC Vezérlő Init DOUT IR Fetch Decode Execute vezérlő jelek feltétel jelek

MiniRISC processzor teljes blokkvázlata A részletes felépítést lásd a Verilog forráskódban Adatmemória DOUT DIN DOUT RD WR IRQ PC Számláló 0x00 0x01 ugrási cím Verem Z,C,N,V Z,C,N,V IE bit IF bit IR vezérlő jelek MUX1 WrX Regisztertömb RdX RdY Debug modul Init Break Vezérlő állapotgép Fetch Decode Execute Int_req feltétel jelek MiniRISC processzor 8 bites konstans ugrási cím OP1 Adatstruktúra ALU MUX2 OP2

MiniRISC processzor működése Adatmemória 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] DMEM[0]=5 DMEM[1]=2 DMEM[2]=0 DMEM[3]=0 DOUT DOUT DOUT DIN DOUT RD WR PC 0 1 IR REG[0]=DMEM[0] PC 1 IR REG[0]=DMEM[0] PC 1 IR REG[0]=DMEM[0] MUX Vezérlő Init Fetch Vezérlő Init LOAD Fetch Vezérlő Init LOAD Fetch Regisztertömb REG[0]=? 5 REG[1]=? REG[2]=? Decode Execute Decode Execute Decode Execute ALU Adatstruktúra Utasítás lehívása Dekódolás Végrehajtás

MiniRISC processzor működése Adatmemória 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] DMEM[0]=5 DMEM[1]=2 DMEM[2]=0 DMEM[3]=0 DOUT DOUT DOUT DIN DOUT RD WR PC 1 2 IR REG[1]=DMEM[1] PC 2 IR REG[1]=DMEM[1] PC 2 IR REG[1]=DMEM[1] MUX Vezérlő Init Fetch Vezérlő Init LOAD Fetch Vezérlő Init LOAD Fetch Regisztertömb REG[0]=5 REG[1]=? 2 REG[2]=? Decode Execute Decode Execute Decode Execute ALU Adatstruktúra Utasítás lehívása Dekódolás Végrehajtás

MiniRISC processzor működése 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] Adatmemória DMEM[0]=5 DMEM[1]=2 DMEM[2]=0 DMEM[3]=0 DOUT DOUT DOUT DIN DOUT RD WR PC 2 3 IR R[1] = R[0] + R[1] PC 3 IR R[1] = R[0] + R[1] PC 3 IR R[1] = R[0] + R[1] MUX Vezérlő Init Fetch Vezérlő Init ADD Fetch Vezérlő Init ADD Fetch Regisztertömb REG[0]=5 REG[1]=2 7 REG[2]=? Decode Decode Decode Execute Execute Execute ALU 5 + 2 = 7 Adatstruktúra 5 2 Utasítás lehívása Dekódolás Végrehajtás 7

MiniRISC processzor működése Adatmemória 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] 0: REG[0]=DMEM[0] 1: REG[1]=DMEM[1] 2: REG[1]=REG[0]+REG[1] 3: DMEM[3]=REG[1] DMEM[0]=5 DMEM[1]=2 DMEM[2]=0 DMEM[3]=0 7 DOUT DOUT DOUT DIN DOUT RD WR PC 3 4 IR DMEM[3]=REG[1] PC 4 IR DMEM[3]=REG[1] PC 4 IR DMEM[3]=REG[1] MUX Vezérlő Init Fetch Vezérlő Init STORE Fetch Vezérlő Init STORE Fetch Regisztertömb REG[0]=5 REG[1]=7 REG[2]=? Decode Execute Decode Execute Decode Execute ALU Adatstruktúra Utasítás lehívása Dekódolás Végrehajtás

MiniRISC processzor utasításai A programmemória bináris kód formájában tartalmazza a végrehajtandó utasításokat (gépi kód, assembly kód) Magasabb szintű leírást a processzor nem tud értelmezni Minden utasítás tartalmazza a művelet leírását és a művelet elvégzéséhez szükséges egyéb adatokat művelet (4 bit) regisztercím (4 bit) memóriacím (8 bit) Cím Művelet Gépi kód (16 bit) Assembly kód 0: REG[0] = DMEM[0] 1101000000000000 MOV r0, 0x00 1: REG[1] = DMEM[1] 1101000100000001 MOV r1, 0x01 2: REG[1] = REG[0] + REG[1] 1111000100000000 ADD r1, r0 3: DMEM[3] = REG[1] 1001000100000011 MOV 0x03, r1

MiniRISC assembler A MiniRISC processzor felhasználói programjait alacsonyszintű (gépközeli) programnyelven készíthetjük el és fordíthatjuk futtatható bináris kódra. Az assembly nyelven megírt programok lefordítása a LOGSYS MiniRISCv2-as assemblerrel lehetséges Konkrét programfejlesztési részletek az előadás végén

MiniRISC kódgenerálás az assemblerrel Fordítás eredménye: Generált lista fájl: demo_add.lst

MiniRISC kódgenerálás az assemblerrel A generált memória tárgykód fájlok: kódfájl: code.hex 256 db 16 bites utasításkód Adatmemória kódfájl: data.hex 128 db 8 bites adat A kész kódfájlokat futtatás előtt a MiniRISC mintarendszer megfelelő memóriájába le kell tölteni. code.hex data.hex

MiniRISC IDE - Programfejlesztés Futtatás: - Szimulátorban - Hardveren Fordítás és letöltés Végrehajtás vezérlése Forráskód szerkesztő Assembler konzol Adatmemória tartalma USRT terminál Kijelző vezérlőpanel GPIO vezérlőpanel Periféria vezérlőpanel: - LED-ek, DIP kapcsoló - Nyomógombok CPU állapot: - PC, flag-ek, verem teteje, regiszterek tartalma - Végrehajtott utasítások száma - Elfogadott megszakításkérések száma

MiniRISC IDE - Programfejlesztés

Digitális technika 9. EA vége