A VERILOG HARDVER LEÍRÓ NYELV ALKALMAZÁSA A LOGIKAI SZINTÉZISBEN

A VERILOG HARDVER LEÍRÓ NYELV ALKALMAZÁSA A LOGIKAI SZINTÉZISBEN Az OPEN VERILOG INTERNATIONAL (OVI) szervezet felkérésére készítette MICHAEL D. CILETTI Department of Electrical and Computer Engineering University of Colorado Colorado Springs, Colorado Copyright 1998 No part of these notes may be copied or reproduced in any form without the written permission of the author. A szerző jóváhagyásával átdolgozta és fordította FEHÉR BÉLA Budapesti Műszaki Egyetem Méréstechnika és Információs Rendszerek Tanszék 1

TARTALOM 1. rész: Bevezetés, modellek, hierarchikus tervezés, szimuláció 2. rész: Modulok felépítése, adattípusok, logikai operátorok 3. rész: Felhasználói primitívek, késleltetési modellek 4. rész: Működési leírás modellezése Veriloggal 5. rész: A Verilog szintézis módszereinek ismertetése 2

LEXIKAI SZABÁLYOK SZABÁLYOK Megjegyzések (COMMENTS) // Egyszerű megjegyzés /* Egy másik egyszerű megjegyzés */ /* Többsoros megjegyzés ami a páros lezáró karakterig tart */ SZÁMOK (NUMBERS) decimális, hexadecimális, oktális, bináris formátum: bitszám 'alap számérték 16'h5, 24'b1101, 2'b10 előjelek ill. aláhuzás a tagoláshoz megengedett KARAKTERLÁNCOK (STRING) " Idézőjelek közé zárt karaktersorozat" 3

A NYELV KIFEJLESZTÉSÉNEK CÉLJA A tradicionális tervezői módszereket, amelyek a kapuszintű, modulszintű kapcsolási rajzokon alapultak fokozatosan felváltják a hardverleiró nyelveken (HDL, Hardware Description Language) alapuló regisztertranszfer szintű (RTL Register Transfer Level) leírások, amelyek alapján a szintézis eszközök a kívánt funkciónak megfelelő áramköröket automatikusn előállítják A HDL nyelvnek a hardver működésének modellezésén túl olyan feltételeket kell biztosítania, amelyek a tervezői munka minőségét és hatékonyságát növelik 4

MI A HARDVER LEÍRÓ NYELV (HDL)? EGY SPECIÁLIS ALKALMAZÁSI TERÜLETHEZ KIFEJLESZTETT SZÁMÍTÓGÉPES PROGRAMOZÁSI NYELV MODELLEZI, ÁBRÁZOLJA ÉS SZIMULÁLJA A DIGITÁLIS HARDVERT KONKURRENS HARDVER MŰKÖDÉS PÁRHUZAMOS PROGRAM VÉGREHAJTÁS JELEK ÉRTÉKÉT ÉS IDŐBELI VÁLTOZÁSÁT KÉPES KÖVETNI SPECIÁLIS SZERKEZETEK ÉS SZEMANTIKA NÉHÁNY PÉLDA AZ ISMERTEBB NYELVEKRE: HILO2, HARDVER C, ABEL, VHDL 5

HDL MODELLEK A HDL modellek definiálják a bemeneti jelek és a kimeneti jelek közötti leképezéseket, ideértve az események, jelváltások ütemezését is. Az időtartománybeli viselkedés a szimuláció során válik láthatóvá A HDL nyelvek speciális szerkezeteket és kifejezéseket alkalmaznak a hardver eszközök időben párhuzamos, konkurens működésének leírására, az időbeli késleltetések és jelalakok modellezésére 6

EGYSZERŰ HDL PÉLDÁK (1) VERILOG: module and_gate(y, x1, x2); input x1, x2; output y; and(y,x1,x2); endmodule x1 x2 and_gate y VHDL: entity and_gate is port (x1,x2: in BIT; y: out BIT); end and_gate; architecture data_flow of and_gate is begin y <= x1 and x2; end data_flow; x1 x2 and_gate y data_flow y <= x1 and x2; 7

EGYSZERŰ HDL PÉLDÁK (2) VERILOG: FÉL - ÖSSZEADÓ a b sum c_out a b Add_half sum c_out module Add_half (sum, c_out, a, b); output sum, c_out; input a, b; wire c_out_bar; xor G1 (sum, a, b); nand G2 (c_out_bar, a, b); not G3 (c_out, c_out_bar); endmodule Megjegyzés: A primitív kapuk elnevezése (G1, G2, G3) nem szükséges 8

KAPCSOLÁSI RAJZ HDL KAPCSOLÁSI RAJZ HDL HAGYOMÁNYOS MÉRNÖKI ESZKÖZ MÉRNÖKI/INFORMATIKUS ESZKÖZ VIZUÁLIS INFORMÁCIÓ SZÖVEGES FORMA GRAFIKUS MUNKAHELY EDITOR ALAPÚ FUNKCIONALITÁS: IMPLICIT FUNKCIONALITÁS: EXPLICIT FÓKUSZ: KAPU SZINT FÓKUSZ: KEVERT SZINT ALACSONYSZINTŰ ABSZTRAKCIÓ MAGAS SZINTŰ ABSZTRAKCÓ MÓDOSÍTÁS KÖLTSÉGE MÉRET MÓDOSÍTÁS ÉRZÉKETLEN A ÉS KOMPLEXITÁS FÜGGŐ MÉRETRE ÉS KOMPLEXITÁSRA 9

A HDL NYELVEK ELŐNYEI TÁMOGATJÁK A STRUKTÚRÁLT TERVEZÉSI MÓDSZEREKET RUGALMASAN PARTICIONÁLHATÓK A NYELVI LEÍRÁS ALAPJÁN A KAPCSOLÁSI RAJZ GENERÁLHATÓ, HA SZÜKSÉGES MAGAS SZINTŰ ABSZTRAKCIÓ FELKÍNÁLJA ALTERNATÍVÁK ÖSSZEHASONLÍTÁSÁT MÓDOSÍTÁSOK GYORSAN VÉGREHAJTHATÓK JAVÍTJA A HATÉKONYSÁGOT ÉS MINŐSÉGET GYORS PROTOTÍPUS KIHASZNÁLJA A SZINTÉZIS ESZKÖZÖKET 10

A TERVEK HIERARKHIKUS SZINTJEI SZINT STRUKTURÁLIS VISELKEDÉSI PRIMITIVEK LEÍRÁS SZINTJE -------------------------------------------------------------------------------------------------------- RENDSZER CPU-K, MEMÓRIÁK TELJESÍTÉNY KOMPLEX IC BUSZOK, SPECIFICÁCIÓ, MICROPROCESSZOROK I/0 ÖSSZEFÜGGÉSEK, RAM, ROM, UART ALGORITMUSOK, PÁRRHUZAMOS PORTOK -------------------------------------------------------------------------------------------------------- REGISZTER REGISZTEREK, ALU-k, IGAZSÁGTÁBLA, SZÁMLÁLÓK, MUX-OK ÁLLAPOT TÁBLA, MŰVELETEK -------------------------------------------------------------------------------------------------------- KAPUSZINT KAPUK, FLIP-FLOPS LOGIKAI EGYENLETEK -------------------------------------------------------------------------------------------------------- ÁRAMKÖRI SZINT TRANZISZTOROK DIFFERENCIÁL R,L,C EGYENLETEK -------------------------------------------------------------------------------------------------------- FÉLVEZETŐ GEOMETRIAI -- OBJEKTUMOK 11

STRUKTURÁLT TERVEZÉSI MÓDSZEREK TOP-DOWN HIERARCHIKUS DEKOMPOZÍCIÓ: A KOMPLEX TERV EGYSZERŰBB, EGYMÁSNAK ALÁRENDELT FUNKCIÓJÚ EGYSÉGEKRE BONTÁSÁRA TERV MŰKÖDÉS KAPUK S ELLENŐRZÉS RÖVID TERVEZÉSI ÉS ELLENŐRZÉSI CIKLUSOK TERVEZHETŐ KÖLTSÉG ÉS ÜTEMEZÉS 12

ALTERNATÍV TERVEZÉSI STÍLUSOK A TERVEZÉSI ESZKÖZÖK EVOLÚCIÓJA MAGÁVAL HOZTA A HDL NYELVEKEN ÉS A SZINTÉZIS PROGRAMOKON ALAPULÓ TERVEZÉSI MÓDSZEREK FEJLŐDÉSÉT IS primitívek és modulok A STRUKTURÁIS MODELLEK OBJEKTUMOKAT KÖTNEK ÖSSZE A KIVÁNT TULAJDONSÁGÚ FUNKCIÓ MEGVALÓSÍTÁSÁRA FUNKCIONÁLIS EGYSÉGEK STRUKTURÁLIS VISELKEDÉSI REGISZTER TRANSFER LOGIKA ALGORITMIKUS RTL SZINTŰ VISELKEDÉSI LEÍRÁS NYELVI ESZKÖZÖKET HASZNÁL A LOGIKA IMPLEMENTÁLÁSÁRA KÖZVETLEN HIVATKOZÁSSAL A HARDVER ELEMEKRE (IMPLICIT KOMBINÁCIÓS LOGIKA). közvetlen kombinációs logika műveleti utasítások ALGORITMIKUS MŰKÖDÉSI LEÍRÁS MAGASSZINTŰ HDL MŰVELETI UTASÍTÁSOKKAL, AMI A KÍVÁNT I/O MŰKÖDÉST ÍRJA LE, FÜGGETLENÜL A KONKRÉT HARDVER MEGVALÓSÍTÁSTÓL 13

PÉLDA: KÉT-BITES KOMPARÁTOR A1 B1 A0 B0 TWO - BIT COMPARATOR A_lt_B A_gt_B A_eq_B LOGIKAI EGYENLETEK: A_lt_B = A1 B1 + A1 A0 B0 + A0 B1B0 A_gt_B = A1B1 + A0B1 B0 + A1A0B0 A_eq_B = A1 A0 B1 B0 + A1 A0B1 B0 + A1A0B1B0 + A1A0 B1B0 14

2 BITES KOMPARÁTOR: STRUKTURÁLIS MODELL STRUKTURÁLIS MODELLEK OBJEKTUMOKAT KAPCSOLNAK ÖSSZE A KÍVÁNT MŰKÖDÉSŰ RENDSZER MEGVALÓSÍTÁSÁHOZ A1 W6 W1 B1 A0 W7 W2 A_lt_B B0 W3 A_gt_B W4 W5 A_eq_B A KARNAUGH TÁBLA MINIMALIZÁLÁSA UTÁN A Verilog nyelv egy teljes logikai primitív készletet (and, or, xor) biztosít a strukturális modellek felépítéséhez. 15

2 BITES KOMPARÁTOR: STRUKTURÁLIS MODELL module compare_2_str (A_lt_B, A_gt_B, A_eq_B, A0, A1, B0, B1); input A0,A1,B0,B1; output A_lt_B, A_gt_B, A_eq_B; or (A_lt_B, w1, w2, w3); nor (A_gt_B, A_lt_B, A_eq_B); and (A_eq_B, w4, w5); and (w1, w6, B1); and (w2, w6, w7, B0); and (w3, w7, B0, B1); xnor (w4, A1, B1); xnor (w5, A0, B0); not (w6, A1); not (w7, A0); endmodule A1 B1 A0 B0 W7 W6 W1 W2 W3 W4 W5 A_lt_B A_gt_B A_eq_B Megjegyzés: A modulban használt primitívek interaktív, konkurens modulok, a kimenőjelek beállítása csak a bemenetek változásainak függvénye, bármely bemeneti jel változik, a kimenet kiértékelésre kerül 16

2 BITES KOMPARÁTOR: RTL ADAT FOLYAM MODELL A LOGIKAI / RTL / ADAT FOLYAM MODELLEK NYELVI OPERÁTOROKAT HASZNÁLNAK A FÜGGVÉNYEK LEÍRÁSÁRA, KÖZVETLEN (IMPLICIT) HIVATKOZÁSSAL AZ AZT MEGVALÓSÍTÓ ELEMI HARDVER EGYSÉGEKRE module compare_2_rtl (A_lt_B, A_gt_B, A_eq_B, A1, A0, B1, B0); input A1, A0, B1, B0; output A_lt_B, A_gt_B, A_eq_B; assign A_lt_B = (~A1) & B1 (~A1) & (~A0) & B0 (~A0) & B1 & B0; assign A_gt_B = A1 & (~B1) A0 & (~B1) & (~B0) A1 & A0 & (~B0); assign A_eq_B = (~A1) & (~A0) & (~B1) & (~B0) (~A1) & A0 & (~B1) & B0 A1 & A0 & B1 & B0 A1 & (~A0) & B1 & (~B0); endmodule Megjegyzés: A folytonos kijelölés ( assign.. =.. ) utasítás egy interaktív, folytonos eseményvezérlést ír elő a kifejezés jobb és bal oldala között, ez következésképpen közvetlen kombinációs logikai kapcsolatnak felel meg. 17

2 BITES KOMPARÁTOR: ALGORITMIKUS MODELL AZ ALGORITMIKUS LEÍRÁSOK A HDL NYELV MŰVELETI UTASÍTÁSAIVAL ÍRJÁK LE A KÍVÁNT I/O MŰKÖDÉST ANÉLKÜL, HOGY AZ AZT MEGVALÓSÍTÓ KONKRÉT HARDVERRŐL BÁRMIT FELTÉTELEZNÉNEK module compare_2_algorithmic (A_lt_B, A_gt_B, A_eq_B, A,B); input [1:0] A,B; output A_lt_B, A_gt_B, A_eq_B; reg A_lt_B; // Állapottartó változó reg A_gt_B; reg A_eq_B; always @ (A or B) // Esemény figyelő begin A_lt_B = 0; A_gt_B = 0; A_eq_B = 0; if (A==B) A_eq_B = 1; else if (A>B) A_gt_B = 1; else A_lt_B = 1; end endmodule Megjegyzés: A Verilog eseményvezérelt műveleti utasításai, pl. always..., csak állapottartó, regiszter típusú változókat tudnak kezelni, változtatni, ezért a kimeneti változók a deklaráció szerint regiszter típusúak. A szintézis során dől majd el, hogy ezek a regiszterek valójában flip-flop-ként realizálva lesznek-e vagy sem. A begin.end programrészleten belül SZEKVENCIÁLIS a programvégrehajtás. 18

2 BITES KOMPARÁTOR: VISELKEDÉSI (BEHAVIORAL) LEÍRÁS KÉT BITES KOMPARÁTOR A_lt_B A1 reg A_lt_b B1 A0 MŰVELETI UTASÍTÁS A_gt_B reg A_eq_B A_gt_b B0 reg A_eq_b A MODULBAN MINDEN always. MŰVELETI UTASÍTÁS ÁLLANDÓAN, KONKURRENSEN AKTÍV. EZ MODELLEZI A HARDVER PÁRHUZAMOS MŰKÖDÉSÉT. A MŰVELETI UTASÍTÁSOKON BELÜL A begin.end KÖZÖTTI PROGRAMUTASÍTÁSOK SZEKVENCIÁLISAN ÉRTÉKELŐDNEK KI. 19

A NYELV NÉHÁNY TULAJDONSÁGA A HARDVER MŰKÖDÉSÉT KÜLÖNBÖZŐ ABSZTRAKCIÓS SZINTEKEN MODELLEZI A KÜLÖNBÖZŐ ABSZTRAKCIÓS SZINTEK KEVERVE IS HASZNÁLHATÓK A LEÍRÁS ÉS A SZIMULÁCIÓ SORÁN IS TÁMOGATJA A HIERARCHIKUS DEKOMPOZÍCIÓT ESZKÖZÖKET AD A STRUKTURÁLT TERVEZÉSHEZ. KÉPES A HARDVER KONKURRENS, PÁRHUZAMOS MŰKÖDÉSÉNEK MODELLEZÉSÉRE. MEGTARTJA A NYELVI SZERKEZETEK ÉS A HARDVER KÖZÖTTI SZOROS KAPCSOLATOT. MEGFELELŐ FORMA KÜLÖNBÖZŐ RENDSZEREK KÖZÖTTI INTEGRÁCIÓRA 20

MODELLEZÉSI ÉS ABSZTRAKCIÓS ALTERNATÍVÁK A VERILOG NYELVBEN 21

A MODELLEK TÍPUSAI A Verilog nyelv három alapvető modell típust támogat: EXPLICIT STRUKTURÁLIS MODELL IMPLICIT STRUKTURÁLIS MODELL VISELKEDÉSI MODELL Általában egy Verilog funkcionális működési leírás tartalmazhatja a fentiek keverékét is. 22

PÉLDA: NAND LATCH (Explicit - Strukturális) A Verilog nyelvben a tervleírás alapegysége a modul. module Nand_Latch (q, qbar, preset, clear); output q, qbar; input preset, clear; preset G1 1 q wire preset, clear; nand #1 G1 (q, preset, qbar), G2 (qbar, clear, q); clear 1 qbar G2 endmodule Megjegyzés: A primitíveket (nand, or, xor, not, buf) a be- és kimeneti portjaikon keresztül kapcsoljuk össze. A példa ugyanazon típusú nand primitívre egy utasításban kétszer, duplán hivatkozik (G1 és G2). A közvetlen kombinációs visszacsatolás miatt mindkét kapuhoz egy 1ns késleltetést (#1) rendeltünk. 23

PÉLDA: nanf201 (Explicit Strukturális+Időzítés) module nanf201 (O,A1,B1); output O; input A1, B1; nand(o, A1, B1); // hivatkozás a primitivre specify // opcionális időzítés adatok // min typ max késleltetések specparam Tpd_0_1 = 1.13 : 3.09 : 7.75, // L H váltás Tpd_1_0 = 0.93 : 2.50 : 7.34; // H Lváltás (A1 => O) = (Tpd_0_1, Tpd_1_0); // (L H és H L késleltetések) (B1 => O) = (Tpd_0_1, Tpd_1_0); endspecify endmodule A specifikációs blokkok közvetlenül a modul be- és kimenetei közötti időzítés adatokat definiálják. A nanf201 azonosító egy 2.01 mikronos ASIC könyvtár elemére utal. 24

AZ EXPLICIT STRUKTURÁLIS MODELL TÍPUSÚ LEÍRÁS TÁMOGATÁSA KAPU SZINTŰ PRIMITIVEK (26 beépített, kombinációs) FELHASZNÁLÓI PRIMITIVEK (kombinációs, szekvenciális) TRANZISZTOR KAPCSOLÁSI SZINTŰ PRIMITÍVEK MODUL DEKLARÁCIÓ ÉS HIVATKOZÁS KÉSLELTETÉSI MODELLEK: A KAPUK INERCIÁLIS, A HUZALOK TRANSZPORT MODELLEL 4 ÉRTÉKŰ LOGIKA, 8 MEGHAJTÁSERŐSSÉGGEL HUZALOZOTT AND ÉS OR LOGIKÁK Az explicit strukturális leírás előre definiált működésű objektumokat kapcsol össze a szükséges funkciójú terv megvalósításához. Ezek lehetnek beépített primitív elemek vagy összetett funkciójú modulok. A megvalósított terv be-kimeneti viselkedése a részegységek funkciójából és az összekötések topológiájából következik. Az összekötéseket az egyszerű huzal (wire) adattípus biztosítja 25

PRIMITíVEK CÉL: ELŐRE DEFINIÁLT EGYSZERŰ HARDVER FUNKCIÓK BIZTOSÍTÁSA BEÉPÍTETT PRIMITÍVEK A NYELV CSAK KOMBINÁCIÓS BEÉPÍTETT PRIMITÍVEKET TARTALMAZ A KOMBINÁCIÓS PRIMITÍVEK KIMENETE KÖTELEZŐEN "wire" TÍPUSÚ A KOMBINÁCIÓS PRIMITÍVEK BEMENETEI LEHETNEK "wire" vagy "reg" TÍPUSÚAK. A BEMENETEKEN A 0, 1, X, Z ÉRTÉKEK MIND MEGENGEDETTEK FELHASZNÁLÓ ÁLTAL DEFINIÁLT PRIMITÍVEK (UDPs) A NYELV MEGENGEDI KOMBINÁCIÓS ÉS SZEKVENCIÁLIS TÍPUSÚ FELHASZNÁLÓI PRIMITÍVEK DEFINÍÁLÁSÁT IS 26

PRIMITÍVEK - ÁLTALÁNOS HIVATKOZÁS primitív_kapu_neve #erősség késleltetés (port_jelek_listája); SZABÁLYOK Az erősség és késleltetés paraméterek opcionálisak és egy listában azonosak az összes elemre. Többszörös, együttes hivatkozás megengedett. PÉLDÁK nand #1 G1 (y1, a1, b1), G2 (y2, a2, b2), G3 (y3, a3, b3); nand #1 nand #3 nand #2 G1 (y1, a1, b1); G2 (y2, a2, b2); G3 (y3, a3, b3); 27

IMPLICIT STRUKTURÁLIS MODELLEK Az implicit strukturális modell (RTL vagy adatfolyam [dataflow]) előre definiált nyelvi operátorokat és a konkurens folytonos kijelölés" utasítást használja a logikai működés előírására. Az operátorok közvetve (implicit) meghatározzák a megvalósító hardvert is. Az ilyen közvetett strukturális modellek alapján a szintézer programok könnyen tudnak közel optimális logikai hálózatot generálni. module bitwise_or (y, A, B); input [7:0] A, B; output [7:0] y; assign y = A B; A B endmodule bitwise_or Numerikus példa, szimulációs eredmény : A: 1010 1111 B: 0110 0100 y: 1110 1111 y 28

IMPLICIT STRUKTURÁLIS MODELLEK A VERILOG PRIMITIVEK ÉS OPERÁTOROK RUGALMASAK. 8 a 8 b a[7]b[7] a[6]b[6] a[5]b[5] a[4]b[4] a[3]b[3]a[2]b[2]a[1]b[1]a[0]b[0] bit_or8_gate 8 y y[7] y[6] y[5] y[4] y[3] y[2] y[1] y[0] Nyolc-bites adatút module bit_or8_gate (y, a, b); input [7:0] a, b; output [7:0] y; assign y = a b; // Bitenkénti OR endmodule Négy-bites adatút module bit_or4_gate (y, a, b); input [3:0] a, b; output [3:0] y; assign y = a b; // Bitenkénti OR endmodule 29

AZ IMPLICIT STRUKTURÁLIS MODELLEK TÁMOGATÁSA FOLYTONOS KIJELÖLÉS UTASÍTÁS assign y = a ^ b; ELŐRE DEFINIÁLT OPERÁTOROK assign y = a[7:0] ^ b[7:0]; assign v = a[3:0] ^ b[3:0]; RTL / ADATFOLYAM LEÍRÁSI STÍLUS KÉSLELTETÉSEK MODELLEZÉSE assign #3 y = a[7:0] ^ b[7:0]; 30

PÉLDA: ADATFOLYAM / RTL LEÍRÁS A FOLYTONOS KIJELÖLŐ UTASÍTÁSOK MINDIG AKTÍVAK PÉLDA module add_full_df (sum, c_out, a, b, c_in); output sum, c_out; input a, b, c_in; assign sum = a ^ b ^ c_in; // Bitenkénti XOR assign c_out = (a & b) (b & c_in) (a & c_in); endmodule ESEMÉNY TERJESZTÉS: BÁRMELY VÁLTOZÁS A KIFEJEZÉSEK JOBB OLDALÁN HASZNÁLT OPERÁTOROKBAN, AUTOMATIKUSAN ÉS AZONNAL ÚJ ÉRTÉKET RENDEL A BALOLDALI VÁLTOZÓKHOZ 31

A FOLYTONOS KIJELÖLÉS UTASÍTÁS SZINTAKTIKA assign meghajtás_erősség késleltetés előírás logikai_kifejezés; MEGJEGYZÉS: az opcionális meghajtás_erősség pl. strong0, strong1 lehet. wire c_out, c_in; PÉLDA wire [3:0] sum, in_a, in_b; assign {c_out, sum} = in_a + in_b + c_in; // {, } összekapcsolást jelöl MEGJEGYZÉS: Az eredmény egy 5-bites szó, egyszerre kap értéket két lazán kapcsolódó, de logikailag összetartozó mennyiség. 32

ADAT FOLYAM/ RTL LEÍRÁS A tervek adatfolyam / RTL leírása folytonos kijelölés utasításokat alkalmaz, amelyek közvetett (implicit) módon írják le a kombinációs hálózatokat megvalósító struktúrákat. A FOLYTONOS KIJELÖLÉS (assign) CSAK 'wire' HUZAL TÍPUSÚ VÁLTOZÓKRA VONATKOZHAT A FOLYTONOS KIJELÖLÉS UTASÍTÁSOK EGYMÁSSAL KONKURENSEK A FOLYTONOS KIJELÖLÉSEK MINDIG AKTÍVAK A JOBBOLDALI OPERANDUSOK MEGVÁLTOZÁSA A KIFEJEZÉSEK AZONNALI ÚJRA KIÉRTÉKELÉSÉT OKOZZA A FOLYTONOS KIJELÖLÉS A KIMENETET MEGHAJTÓ HARDVER ABSZTRAKT MODELLJÉT SZOLGÁLTATJA ELFEDI A KAPU SZINTŰ RÉSZLETEKET, KÖNNYEN OLVASHATÓ 33

PÉLDA: MULTIPLEXER ADATFOLYAM / RTL LEÍRÁSA FOLYTONOS KIJELÖLÉS UTASÍTÁSSAL FELADAT: MULTIPLEXER REALIZÁLÁSA FOLYTONOS KIJELÖLÉS UTASÍTÁSSAL module mux4_df_ca(a, b, c, d, select, y_out); input a, b, c, d; input [1:0] select; output y_out; assign y_out = (a &&!select[1] &&!select[0]) (b &&!select[1] && select [0]) (c && select[1] &&!select [0]) (d && select[1] && select [0]) ; endmodule 34

VISELKEDÉSI/MŰKÖDÉSI MODELLEK A Verilog támogatja az absztrakt viselkedési/működési (behavioral) modelleket. module Simple_flop (q, data_in, clk, rst); input data_in, clk, rst; output q; reg q; //Állapottartó változó always @ (posedge clk) begin if (rst ==1) q = 0; //Szinkron reset!! else q = data_in; end endmodule clk rst data_in q A Verilog nyelv beépített eszközöket tartalmaz az éldetektálásra. 35

A VISELKEDÉSI MODELLEZÉS TÁMOGATÁSA ESEMÉNYVEZÉRLŐ MŰVELETI UTASÍTÁSOK initial (konkurens) always (konkurens) ELJÁRÁS UTASÍTÁSOK (reg típus) szekvenciális értékadás kvázi-folytonos kijelölés nem-blokkoló értékadás vezérlések időzítés vezérlés eseményvezérlés várakozás UTASÍTÁSON BELÜLI IDŐZÍTÉSEK BEMENET/KIMENET TÍPUSÚ IDŐZÍTÉS MODELL NYELVI ESZKÖZÖK HULLÁM- FORMÁK GENERÁLÁSÁHOZ SZEKVENCIÁLIS ÉS PÁRHUZAMOS VÉGREHAJTÁS VEZÉRLÉS CIKLUSOK, FELTÉTELES UTASÍTÁSOK FÜGGVÉNY HÍVÁSOK TASZK HÍVÁSOK ABSZTRAKT ESEMÉNYNEVEK HIERARCHIKUS HIVATKOZÁSOK 36

PÉLDA: FÉL-ÖSSZEADÓ (Explicit - Strukturális) module név module portok module Add_half (sum, c_out, a, b); input a, b; port deklarációk output sum, c_out; wire c_out_bar; belső jel deklarácók a b Add_half sum c_out xor (sum, a, b); nand (c_out_bar, a, b); not (c_out, c_out_bar); endmodule primitív hivatkozások a b sum c_out 37

PÉLDA: XOR KAPU (ADATFOLYAM - Implicit Kombinaciós Logika) module xorf201_zero_delay (O, A1, B1); input A1, B1; output O; assign O = A1 ^ B1; endmodule 38

PÉLDA: BIT-SZELET TÍPUSÚ ÖSSZEADÓ (ADATFLOW - Implicit Kombinációs Logika) module adder_4_df (a, b, c_in, sum, c_out); MSB LSB output [3:0] sum; output c_out; input [3:0] a, b; input c_in; folytonos kijelölés assign {c_out, sum} = a + b + c_in; a b c_in 4 4 adder_4_df 4 c_out sum endmodule összekapcsolás Az összekapcsolás operátor az argumentumaiból a művelet elvégzése ill. az eredmény kijelölése szempontjából egy közös, egyesített objektumot állít elő. A VERILOG nyelv beépített aritmetikával rendelkezik 39

PÉLDA: ÁTVITELGYORSÍTÓS ÖSSZEADÓ (Viselkedési - Kombinált RTL és ALGORITMIKUS) a i b i b i a i c i g i = a i & b i // a i and b i p i = a i ^ b i // a i xor b i s i c i+1 s i c i s i a i c i+1 c i+1 c i+1 b i c i+1 s i s i c i c i+1 s i s i = (a i ^ b i ) ^ c i = p i ^ c i c i+1 = (a i ^ b i ) & c i + a i & b i = p i & c i + g i 40

PÉLDA: ÁTVITELGYORSÍTÁS REKURZÍV ALGORITMUS: s 0 = p 0 ^ c 0 c 1 = p 0 & c 0 + g 0 s 1 = p 1 ^ c 1 c 2 = p 1 & c 1 + g 1... s 2 = p 2 ^ c 2 c 3 = p 2 & c 2 + g 2 ÖSSZEFOGLALVA: sum = p ^ (c n-1,..., c 2, c 1,c 0 ) // Bitenkénti kizáró-vagy c_out = c n 41

PÉLDA: ÁTVITELGYORSÍTÁS (1) module Add_4 (sum, c_out, a, b, c_in); // általános 4-bites // átvitelgyorsítós összeadó // viselkedési modell output [3:0] sum; output c_out; input [3:0] a, b; input c_in; reg [3:0] carrychain; wire [3:0] g = a & b; wire [3:0] p = a ^ b; // átvitel generálás, bitenkénti AND kapcsolat // folytonos kijelölés // átvitel terjesztés, bitenkénti XOR kapcsolat // folytonos kijelölés 42

PÉLDA: ÁTVITELGYORSÍTÁS (2) always @(a or b or c_in) // bármely változónál esemény begin : carry_generation // a blokk név az 'i' lokális integer i; // változó használata miatt kell carrychain[0] = g[0] (p[0] & c_in); // (a lekérdezhetőség miatt) for(i = 1; i <= 3; i = i + 1) begin #0 // a #0 kikényszeríti carrychain[i] = g[i] (p[i] & carrychain[i-1]); // a kiértékelést end end wire [4:0] shiftedcarry = {carrychain, c_in} ; // összekapcsolás wire [3:0] sum = p ^ shiftedcarry; // összeg képzése wire c_out = shiftedcarry[4]; // átvitel beállítása endmodule 43

PÉLDA: ÁTVITELGYORSÍTÁS (3) a b c_in Átvitel generáló bitek. (Kombinációs logika) g Minden bemeneti változásra kiértékeli az átvitelt Átvitel terjesztő bitek. (Kombinációs logika) p c_in Folytonos kijelölés utasítás Eseményvezérelt szekvenciális Putasítások d l Shiftelt átvitel generálása (Kombinációs logika) p Átvitel képzése (Kombinációs logika) Összeg képzése (Kombinációs logika) Folytonos kijelölés utasítás c_out sum 44

HIERARCHIKUS DEKOMPOZICIÓ ÉS STRUKTURÁLT TERVEZÉSI MÓDSZEREK A VERILOG NYELVBEN 45

HIERARCHIKUS DEKOMPOZICIÓ AZ EGYMÁSBA ÁGYAZOTT MODULHIVATKOZÁSOK HIERACHIKUS DEKOMPOZICIÓT EREDMÉNYEZNEK. module TOP_MOD (); // deklaráció Child_Module_A (); // hivatkozás... Child_Module_B (); // hivatkozás... endmodule module Child_Module_A (); // deklaráció // Modul funkció leírása endmodule module Child_Module_B (); // deklaráció // Modul funkció leírása endmodule 46

PÉLDA: TELJES ÖSSZEADÓ (Explicit - Strukturális) module Add_full(sum, c_out, a, b, c_in);// fő modul input a, b, c_in; output c_out, sum; modul azonosító név wire w1, w2, w3, w4; Add_half M1 (w1, w2, a, b); Add_half M2 (sum, w3, w1, c_in); or (c_out, w2, w3); endmodule // almodul // almodul // primitív hivatkozás Bemenetek Verilog Modul Kimenetek A VERILOG NYELVBEN A MODUL TARTALMAZZA A TERVET 47

MODULOK ÖSSZEKAPCSOLÁSA MODULOK TARTALMAZHATNAK HIVATKOZÁSOKAT MÁS MODULOKRA. A MODULOK HIERARCHIKUS STRUKTURÁJÁT KÖZVETLENÜL A BEÁGYAZOTT MODULHIVATKOZÁSOK DEFINIÁLJÁK. A MODULOKAT PORTJAIKON KERESZTÜL KAPCSOLJUK ÖSSZE. A MODULOK CSATLAKOZHATNAK MÁS MODULOKHOZ VAGY VERILOG PRIMITÍVEKHEZ. 48

PÉLDA A HIERARCHIKUS DEKOMPOZICIÓRA Add_rca_16 A hierarchikus dekompozíció a tervet részekre osztja, melyek egyszerűbb funkcionalitással és komplexitással rendelkeznek. a[15:0] b[15:0] c_in a[15:12] b[15:12] a[11:8] b[11:8] a[7:4] b[7:4] a[3:0] b[3:0] c_in 16 16 4 4 4 4 4 4 4 4 Add_rca_16 Add_rca_4 Add_rca_4 Add_rca_4 Add_rca_4 16 c_out M4 c_in12 M3 c_in8 M2 c_in4 M1 c_out sum[15:0] sum[15:12] sum[11:8] sum[7:4] sum[3:0] 49

PÉLDA A HIERARCHIKUS DEKOMPOZICIÓRA Add_rca_4 a[3] b[3] a[2] b[2] a[1] b[1] a[0] b[0] c_in M4 M3 M2 M1 Add_full Add_full Add_full Add_full c_in4 c_4 c_in3 c_in2 sum[3] sum[2] sum[1] sum[0] 50

PÉLDA A HIERARCHIKUS DEKOMPOZICIÓRA Add_full c_in a b w1 a sum Add_half (a b) b c_out w2 M1 ab a sum Add_half b c_out M2 w3 (a b) c_in (a b) c_in (a + b) c_in + ab sum c_out 51

PÉLDA: 16-BITES ÖSSZEADÓ REALIZÁLÁSA module Add_rca_16 (sum, c_out, a, b, c_in); output [15:0] sum; output c_out; input [15:0] a, b; input c_in; wire c_in4, c_in8, c_in12, c_out; a[15:0] 16 Add_rca_16 b[15:0] 16 16 c_in c_out sum[15:0] Add_rca_4 M1 (sum[3:0], c_in4, a[3:0], b[3:0], c_in); Add_rca_4 M2 (sum[7:4], c_in8, a[7:4], b[7:4], c_in4); Add_rca_4 M3 (sum[11:8], c_in12, a[11:8], b[11:8], c_in8); Add_rca_4 M4 (sum[15:12], c_out, a[15:12], b[15:12], c_in12); endmodule 52

PÉLDA: 16-BITES ÖSSZEADÓ REALIZÁLÁSA module Add_rca_4 (sum, c_out, a, b, c_in); output [3: 0] sum; output c_out; input [3: 0] a, b; input c_in; wire c_in2, c_in3, c_in4; Add_full M1 (sum[0], c_in2, a[0], b[0], c_in); Add_full M2 (sum[1], c_in3, a[1], b[1], c_in2); Add_full M3 (sum[2], c_in4, a[2], b[2], c_in3); Add_full M4 (sum[3], c_out, a[3], b[3], c_in4); endmodule 53

PÉLDA: 16-BITES ÖSSZEADÓ REALIZÁLÁSA module Add_full(sum, c_out, a, b, c_in); output sum, c_out; input a, b, c_in; wire w1, w2, w3, w4; Add_half M1 (w1, w2, a, b); Add_half M2 (sum, w3, w2, c_in); or (c_out, w2, w3); endmodule module Add_half(sum, c_out, a, b); output sum, c_out; input a, b; wire c_bar; xorf201 M1 (sum, a, b); nanf201 M2 (c_bar, a, b); invf201 M3 (c_out, c_bar); endmodule Megjegyzés: A xxx201 típusú elemek könyvtári modulok, nem primitívek 54

HIERARCHIKUS TERVEZÉS A BEÁGYAZOTT MODULOKRA VONATKOZÓ HIVATKOZÁSOK FORMÁLJÁK A TERVEK TERMÉSZETES HIERARCHIÁJÁT Add_full M1 M2 Add_half Add_half invf101 nanf201 xor nand not xor nand not 55

EGYSZERŰ RTL ALTERNATÍVA module add_rtl_16 (sum, c_out, a, b, c_in); input [15:0] a, b; input c_in; output [15:0] sum output c_out; a b 16 16 add_rtl c_in assign {c_out, sum} = a + b + c_in; endmodule c_out 16 sum 56

MODUL PORTOK ÖSSZEKAPCSOLÁSAI KAPCSOLAT AZ AZONOSÍTÓK POZÍCIÓJA SZERINT module parent_mod; wire [4:0] g; child_mod G1 (g[3], g[1], g[0], g[2]); // A felsorolás sorrendje fontos endmodule module child_mod (sig_a, sig_b, sig_c, sig_d); input sig_a, sig_b; output sig_c, sig_d; // A modul funkció leírása endmodule g[3] g[1] g[0] g[2] sig_a sig_b sig_c sig_d child_mod aktuális formális 57

MODUL PORTOK ÖSSZEKAPCSOLÁSAI KAPCSOLAT NÉV SZERINTI EGYMÁSHOZ RENDELÉSSEL module parent_mod; wire [4:0] g; // A felsorolás sorrendje tetszőleges child_mod G1 ( endmodule.sig_c(g[3]),.sig_d(g[2]),.sig_b(g[0]),.sig_a(g[1])); module child_mod (sig_a, sig_b, sig_c, sig_d); input sig_a, sig_b; output sig_c, sig_d; // modul funkció leírása endmodule g[1] g[0] g[3] g[2] sig_a sig_b sig_c sig_d child_mod actuális formális 58

MODUL PORTOK ÖSSZEKAPCSOLÁSAI KAPCSOLAT NÉV SZERINT Átrendezve a könnyebb olvashatóság miatt module parent_mod; wire [4:0] g; // Felsorolás sorrendje tetszőleges child_mod G1 ( endmodule.sig_a(g[1]),.sig_b(g[0]),.sig_c(g[3]),.sig_d(g[2])); module child_mod (sig_a, sig_b, sig_c, sig_d); input sig_a, sig_b; output sig_c, sig_d; // modul funkció leírása endmodule g[1] g[0] g[3] g[2] actuális sig_a sig_b sig_c sig_d child_mod formális 59

MODUL PORTOK ÖSSZEKAPCSOLÁSAI SZABÁLY: CSAK 'wire' vagy 'reg' TÍPUS KAPCSOLHATÓ MODUL PORTRA, 'real' TÍPUSÚ VÁLTOZÓ NEM MEGOLDÁSI PÉLDA driver receiver net_r 64 module driver (net_r); output [64:1]net_r; real r; wire [64:1] net_r = $realtobits(r); // A kód, ami r értékét meghatározza endmodule; module receiver (net_r); input [64:1] net_r; real r; wire [64:1] net_r; initial r = $bitstoreal(net_r); endmodule 60

A HIERARCHIKUS DEKOMPOZÍCIÓ ÉS KÜLÖNBÖZŐ SZÍNTŰ ABSZTRAKCIÓK BÁRMELY FORMÁJÚ LEÍRÁS HASZNÁLHATÓ AKÁR EGYETLEN MODULON BELÜL IS module top_of_design mod_a mod_b mod_c module mod_a(); // strukturális nand();... endmodule module mod_b(); // viselkedési //algoritmikus... always... endmodule module mod_c(); // adat folyam assign X =... endmodule 61

PÉLDA: KÜLÖNBÖZŐ SZÍNTŰ ABSZTRAKCIÓK mixed_levels clk data_in enable data q_out module mixed_levels(data_in, enable, clk, q_out); input data_in, enable, clk; output q_out; reg q_out; wire data, enable, clk; always @ (posedge clk) // eseményvezérlő utasítás q_out = data; // szekvenciális értékadás nand(data, data_in, enable); // strukturális: primitív hivatkozás //UTASÍTÁS SORREND KÖZÖMBÖS! endmodule 62

MODELLEZÉS VERILOG NYELVI TÁMOGATÁS: STRUKTURÁLIS MODELLEK Primitív kapuk Összekötések Modul hivatkozások VISELKEDÉSI MODELLEK Folytonos értékadás/kijelölés utasítás (Implicit kombinációs logika) Műveleti utasítások /Algoritmusok 63

MODELLEZÉS ÉS SZIMULÁCIÓ 64

SZIMULÁCIÓS MÓDSZEREK module Design_Unit_Test_Bench Gerjesztőjel Generátor module Unit_Under_Test Válaszjel Megfigyelés A SZIMULÁCIÓHOZ EGY ÖNÁLLÓ, LEGFELSŐ SZÍNTŰ VERILOG MODULT ÉPÍTÜNK FEL, AMI A TERV TESZTKÖRNYEZETÉT FOGLALJA MAGÁBA "DESIGN UNIT TEST BENCH" (DUTB). EZZEL ELLENŐRIZZÜK A VERILOG NYELVEN REALIZÁLT "UNIT UNDER TEST" (UUT) MODULT. 65

Nand_Latch TESZTELÉSI KÖRNYEZETE module Nand_Latch (q, qbar, preset, clear); input preset, clear; output q, qbar; preset 1 q nand #1 (q, preset, qbar); // egységnyi késleltetés nand #1 (qbar, clear, q); // azonosítók nincsenek endmodule clear 1 qbar module test_nand_latch_1 Műveleti kód, ami a preset és clear jeleket generálja preset clear Nand_Latch_1 q qbar 66

Nand_Latch TESZTELÉSI KÖRNYEZETE module test_nand_latch_1; // Beágyazó tesztelési környezet (DUTB) reg preset, clear; // forrásjelek regiszter típusok wire q, qbar; // kimeneti jelek huzal típusok Nand_Latch M1 (q, qbar, preset, clear); // Hivatkozás a tesztelt modulra (UUT) initial begin // Vezérlőjelek generálása a UUT számára $monitor($time,, "preset = %b clear = %b q = %b qbar = %b", preset,clear,q,qbar); #10 preset = 0; clear = 1; #10 preset = 1; $stop; //. parancs a folytatáshoz #10 clear = 0; #10 clear = 1; #10 preset = 0; #10 $finish; end endmodule 67

A VÁRT EREDMÉNY preset 1 0 clear 1 0 q1 0 qbar 1 10 20 10 30 11 32 t sim preset clear G1 1 1 G2 q qbar 0 12 31 68

A SZIMULÁCIÓ EREDMÉNYE 0 preset = x clear = x q = x qbar = x 10 preset = 0 clear = 1 q = x qbar = x 11 preset = 0 clear = 1 q = 1 qbar = x 12 preset = 0 clear = 1 q = 1 qbar = 0 20 preset = 1 clear = 1 q = 1 qbar = 0 30 preset = 1 clear = 0 q = 1 qbar = 0 31 preset = 1 clear = 0 q = 1 qbar = 1 32 preset = 1 clear = 0 q = 0 qbar = 1 40 preset = 1 clear = 1 q = 0 qbar = 1 Megjegyzés: Az eredmények az egységnyi késleltetésű (#1) modellekre vonatkoznak 69

A MODELL ELLENŐRZÉSE preset q clear qbar 1/0 0/0 0/1 -/0 -/1 1/- -/- 0/1 0/- 1/1 1/1 0/0 1/0 A HDL MODELLEK MEGBÍZHATÓ ELLENŐRZÉSE A TESZTKÖRNYEZET (DUTB) GONDOS, SZISZTEMATIKUS REQUIRES ELŐKÉSZÍTÉSÉT CAREFUL ÉS HASZNÁLATÁT SYSTEMATIC DEVELOPMENT IGÉNYLI Az állapotokra: 1/0 jelöli a q = 1 és qbar = 0; az élekre: 1/- jelöli a preset =1, clear = don t care értékeket. 70

ESEMÉNY-VEZÉRELT SZIMULÁCIÓ A TERVEK ELLENŐRZÉSE ÁLTALÁBAN DIGITÁLIS SZIMULÁCIÓ SEGÍTSÉGÉVEL TÖRTÉNIK. ANALÓG SZIMULÁCIÓ (SPICE) - NAGY MEMÓRIA IGÉNY DIGITÁLIS SZIMULÁCIÓ - NAGY CPU IDŐ IGÉNY CIKLUS ALAPÚ SZIMULÁCIÓ - GYORS, GONDOS TERVEZÉS 71

NULLA-KÉSLELTETÉSŰ SZIMULÁCIÓ A B C D A B C D 0 10 20 30 40 50 t sim A = x B = x C = x D = x A = 1 B = 0 B = 1 A = 0 B = 0 C = 0 C = 1 C = 0 D = 1 D = 0 D = 1 72

NEM NULLA-KÉSLELTETÉSŰ SZIMULÁCIÓ A B C 3 2 D A B C D 0 10 20 30 40 50 A terjedési idő késleltetések befolyásolják az események ütemezését az időtengelyen, ezáltal az ok-okozat összefüggés alapján ugyanabban az időlépésben időbeli sorrendiséget eredményeznek. t sim A = x B = x C = x D = x A = 1 B = 0 C = 0 B = 1 C = 1 A = 0 C = 0 B = 0 D = 1 D = 0 D = 1 73

INERCIÁLIS KÉSLELTETÉS - ESEMÉNY TÖRLÉS A B C 3 2 D A B C D 0 10 20 30 40 50 t sim t sim =33 t sim =35 0 A = x B = x C = x D = x 10 A = 1 B = 0 C = 10 0 D = 13 1 30 30 33 B = 1 C = 1 D = 0 32 A = 0 Előkészített Esemény 74

ALAPVETŐ SZIMULÁCIÓS PARANCSOK SZIMULÁCIÓS AKTIVITÁS MEGFIGYELÉSE ($MONITOR) EREDMÉNYEK MEGJELENÍTÉSE ($DISPLAY) SZIMULÁCIÓS SZÁMÍTÁSOK MEGFIGYELÉSE ($STROBE) IDŐ FIGYELÉS (WATCH TIME) SZIMULÁCIÓ MEGÁLLÍTÁSA ($stop) SZIMULÁCIÓ BEFEJEZÉSE ($finish) SZIMULÁCIÓ ABBAHAGYÁSA (ctrl \) SZIMULÁCIÓ FOLYTATÁSA (.) 75

SZIMULÁCIÓS EREDMÉNYEK MEGJELENÍTÉSE CÉL: ADOTT IDŐPONTOKBAN A KIVÁLASZTOTT JELÉRTÉKEK ELLENŐRZÉSE $display(p1,p2,...,pn); // A szimuláció végrehajtása során a // kiválasztott jelek értékét mutatja // Új sor karaktert küld ki a nyomtatás végén $write(p1,p2,...,pn); // Ugyanaz mint $display újsor nélkül TIPIKUS FORMÁTUM $display("jelnevek felsorolása C szerű formátum specifikációval, pl. %b ", jelnév_lista ); Megjegyzés: a rendszer funkciók az eseményvezérelt műveleti blokkokban hívhatók 76

SZIMULÁCIÓS EREDMÉNYEK MEGJELENÍTÉSE PÉLDÁK $display($time, "SZIMULÁCIÓS EREDMÉNYEK - 1999 JANUÁR 18"); $display($time, "q_out = %b, q_bar_out = %b, reset = %b, data_in = %b, clk = %b, q, qb, rst, data, clk); MEGJEGYZÉSEK EZEK A FUNKCIÓK CSAK ELJÁRÁSOKON BELÜL HAJTÓDNAK VÉGRE. A $display UTASÍTÁSOK SZÁMA NEM KORLÁTOZOTT. A FORMÁTUM SPECIFIKÁCIÓ KIS ÉS NAGYBETŰT IS ELFOGAD TOVÁBBI RÉSZLETEK A NYELVI LEÍRÁSBAN A \ KARAKTER HASZNÁLHATÓ A SOR FOLYTATÁSÁRA 77

A SZIMULÁCIÓ MEGFIGYELÉSE CÉL: KIVÁLASZTOTT JELEK FOLYAMATOS MEGFIGYELÉSE A SZIMULÁCIÓ ALATT, TOVÁBBÁ MINDEN VÁLTOZÁS JELZÉSE ÉS NAPLÓZÁSA. $monitor(p1,p2,...,pn); // ahol p1, p2... jelnév paraméterek $monitoron // bekapcsolja az előzőleg kikapcsolt // $monitor állapotfigyelést $monitoroff // kikapcsolja a $monitor állapotfigyelést MEGJEGYZÉS $monitor AZ AKTUÁLIS SZIMULÁCIÓS IDŐ VÉGÉN NYOMTAT, TEHÁT AKKOR, AMIKOR MÁR MINDEN JELAKTIVITÁS BEFEJEZŐDÖTT. EGYIDŐBEN MINDIG CSAK EGY $monitor() LISTA LEHET AKTÍV. A KIJELZÉST A PARAMÉTERLISTA BÁRMELY AKTIVITÁSA ELINDÍTJA A $time IDŐ VÁLTOZÓBAN TÖRTÉNŐ AKTIVITÁS NEM OKOZ KIJELZÉST 78

STROBED DISPLAY CÉL: INFORMÁCIÓK KIJELZÉSE KÖZVETLENÜL A KÖVETKEZŐ SZIMULÁCIÓS CIKLUS MEGKEZDÉSE ELŐTT. $strobe("tetszőleges szöveg és formátum specifikáció", parameter_lista); PÉLDA forever @ (negedge clock) $strobe ("At time %d, data_value is %h, $time, data_value); MEGJEGYZÉS $strobe feltételezi, hogy minden aktivitás lezajlott, mielőtt nyomtatni kezd. A $strobe használható, mint elővigyázatos jelzés a nem helyesen terminálódó szimulációk ill. megfigyelések esetén 79

AZ IDŐ VÁLTOZÓ CÉL: A RENDSZERIDŐ HOZZÁFÉRÉS BIZTOSÍTÁSA $time ÉRDEMES A $time IDŐVÁLTOZÓT A NYOMTATÁSKOR A KIMENETI LISTÁBA FELVENNI, A KÖNNYEBB KIÉRTÉKELHETŐSÉG ÉRDEKÉBEN 80

A SZIMULÁCIÓ MEGÁLLÍTÁSA CÉL: A SZIMULÁCIÓ VÉGREHAJTÁSÁNAK ÁTMENETI FELFÜGGESZTÉSE $stop; $stop(0); $stop(1); $stop(2); // ugyanaz mint $stop(1). // megállás nyomtatás nélkül // megállás a szimulációs idő // és a hely megadásával // megállás a szimulációs idő, // a hely és a statisztika megadásával AZ ÁTMENETILEG FELFÜGGESZTETT SZIMULÁCIÓ FOLYTATHATÓ A. PARANCS KIADÁSÁVAL 81

A SZIMULÁCIÓ BEFEJEZÉSE CÉL: A SZIMULÁCIÓ BEFEJEZÉSE ÉS VISSZATÉRÉS AZ OPERÁCIÓS RENDSZERHEZ $finish; $finish(0); $finish(1); $finish(2); // ugyanaz mint $finish(1). // nyomtatás nélkül befejezi a szimulációt és // visszatér az operációs rendszerhez // befejezi a szimulációt, // kinyomtatja a szimulációs időt, a helyet és // visszatér az operációs rendszerhez // befejezi a szimulációt, // kinyomtatja a szimulációs időt, a helyet, // statisztikát ad a szimulációról és // visszatér az operációs rendszerhez 82

A SZIMULÁCIÓ LEÁLLÍTÁSA CÉL: A SZIMULÁCIÓS PROGRAM LEÁLLÍTÁSA; VISSZATÉRÉS AZ OPERÁCIÓS RENDSZERHEZ A SZIMULÁCIÓ A Ctrl \ BILLENTYŰKKEL ÁLLÍTHATÓ LE. 83

ÖSSZEFOGLALÁS - 1. Rész AZ ELSŐ RÉSZBEN ÁTTEKINTETTÜK A VERILOG LEHETŐSÉGEIT A STRUKTURÁLIS MODELLEZÉS VISELKEDÉSI MODELLEZÉS KEVERT SZINTŰ ABSZTRAKCIÓ HIERARCHIKUS DEKOMPOZÍCIÓ STRUKTURÁLT TERVEZÉSI MÓDSZEREK SZIMULÁCIÓ ÉS ELLENŐRZÉS SZEMPONTJÁBÓL 84