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:
VHDL:
module and_gate(y, x1, x2); input x1, x2; output y; and(y,x1,x2); endmodule
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;
and_gate
and_gate
x1 y
x1 y
x2
x2 data_flow y <= x1 and x2;
7
EGYSZERŰ HDL PÉLDÁK (2) VERILOG: FÉL - ÖSSZEADÓ a b
sum
a
sum
Add_half c_out
b
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 ÉS KOMPLEXITÁS FÜGGŐ
MÓDOSÍTÁS ÉRZÉKETLEN A 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 • A STRUKTURÁIS MODELLEK OBJEKTUMOKAT KÖTNEK ÖSSZE A KIVÁNT TULAJDONSÁGÚ FUNKCIÓ MEGVALÓSÍTÁSÁRA
primitívek és modulok
STRUKTURÁLIS FUNKCIONÁLIS EGYSÉGEK
•
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).
•
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
REGISZTER TRANSFER LOGIKA VISELKEDÉSI ALGORITMIKUS
közvetlen kombinációs logika
műveleti utasítások
13
PÉLDA: KÉT-BITES KOMPARÁTOR A1 B1 A0 B0
A_lt_B TWO - BIT COMPARATOR
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 W6
A1
W1
B1 A0 B0
W7
W2
A_lt_B
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
W6
A1
W1
B1 A0 B0
W7
W2
A_lt_B
W3 A_gt_B W4 W5
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);
always @ (A or B) // Esemény figyelő begin A_lt_B = 0; input [1:0] A,B; A_gt_B = 0; output A_lt_B, A_gt_B, A_eq_B; A_eq_B = 0; if (A==B) A_eq_B = 1; reg A_lt_B; // Állapottartó változó else if (A>B) A_gt_B = 1; reg A_gt_B; else A_lt_B = 1; reg A_eq_B; 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
B1
A_gt_B
A0
MŰVELETI UTASÍTÁS
reg
A_lt_b
A_gt_b
A_eq_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;
G1 preset
1
q
clear
1
qbar
wire preset, clear; nand #1
G1 (q, preset, qbar), G2 (qbar, clear, q);
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); specify specparam
// hivatkozás a primitivre // opcionális időzítés adatok // min typ max késleltetések 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;
A
B
assign y = A | B; endmodule
bitwise_or
Numerikus példa, szimulációs eredmény : A: B: y:
1010 1111 0110 0100 1110 1111
y
28
IMPLICIT STRUKTURÁLIS MODELLEK A VERILOG PRIMITIVEK ÉS OPERÁTOROK “RUGALMASAK”. a
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]
8
8
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
Négy-bites adatút
module bit_or8_gate (y, a, b); input [7:0] a, b; output [7:0] y;
module bit_or4_gate (y, a, b); input [3:0] a, b; output [3:0] y;
assign y = a | b; // Bitenkénti OR endmodule
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. PÉLDA wire c_out, c_in; 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
rst data_in
q
clk
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ÁMFORMÁ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); port deklarációk input a, b; output sum, c_out; belső jel deklarácók wire c_out_bar; xor (sum, a, b); nand (c_out_bar, a, b); not (c_out, c_out_bar); endmodule
a
sum Add_half
b
c_out
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;
a 4
folytonos kijelölés
assign {c_out, sum} = a + b + c_in; endmodule
b
c_in
4 adder_4_df
c_out
4 sum
ö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)
ai
gi = a i & b i
// ai and bi
p i = a i ^ bi
// ai xor bi
si
bi
ci+1
ci
si
ci+1 si ci+1
bi ai
ci ai
ci+1
bi ci+1
si
ci+1
si
si ci
si = (ai ^ bi) ^ ci = pi ^ ci ci+1 = (ai ^ bi) & ci + ai & bi = pi & ci + gi
40
PÉLDA: ÁTVITELGYORSÍTÁS REKURZÍV ALGORITMUS: s0 = p 0 ^ c 0 c1 = p 0 & c 0 + g 0 s1 = p 1 ^ c 1 c2 = p 1 & c 1 + g 1
...
s2 = p 2 ^ c 2 c3 = p 2 & c 2 + g 2
ÖSSZEFOGLALVA: sum = p ^ (cn-1, ..., c2 , c1,c0)
// Bitenkénti kizáró-VAGY
c_out = cn
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
Átvitel generáló bitek. (Kombinációs logika)
c_in
b
Átvitel terjesztő bitek. (Kombinációs logika) p
g
Minden bemeneti változásra kiértékeli az átvitelt
Shiftelt átvitel generálása (Kombinációs logika)
Átvitel képzése (Kombinációs logika)
c_out
Folytonos kijelölés utasítás
c_in
Eseményvezérelt szekvenciális Putasítások d l
p
Összeg képzése (Kombinációs logika)
Folytonos kijelölés utasítás
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 (); ... Child_Module_B (); ... endmodule
// hivatkozás
module Child_Module_A ();
// deklaráció
// hivatkozás
// 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 Bemenetek
Verilog Modul
// almodul // almodul // primitív hivatkozás
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]
16
c_in
a[15:12] b[15:12] a[11:8] b[11:8] a[7:4]
a[3:0]
4
4
b[3:0]
c_in
16 4
Add_rca_16
16 c_out
b[7:4]
c_out
4
4
4
4
4
Add_rca_4
Add_rca_4
Add_rca_4
Add_rca_4
M4
M3
M2
M1
c_in12
c_in8
c_in4
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]
a[2]
b[3]
b[2]
M4 Add_full
c_in4
b[1]
M3 Add_full
c_4 sum[3]
a[1]
b[0]
M2 Add_full
c_in3
sum[2]
a[0]
c_in
M1 Add_full
c_in2
sum[1]
sum[0]
50
PÉLDA A HIERARCHIKUS DEKOMPOZICIÓRA Add_full
(a ⊕ b) ⊕ c_in
c_in a b
w1 a sum (a ⊕ b) Add_half b c_out w2 ab M1
a sum Add_half w3 b c_out M2
(a ⊕ b) c_in
sum c_out
(a + b) c_in + ab
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]
b[15:0]
16
(sum[3:0], (sum[7:4], (sum[11:8], (sum[15:12],
c_in4, c_in8, c_in12, c_out,
a[3:0], a[7:4], a[11:8], a[15:12],
16
Add_rca_16
16 c_out
Add_rca_4 M1 Add_rca_4 M2 Add_rca_4 M3 Add_rca_4 M4
c_in
b[3:0], b[7:4], b[11:8], b[15:12],
sum[15:0]
c_in); c_in4); c_in8); 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], Add_full M2 (sum[1], Add_full M3 (sum[2], Add_full M4 (sum[3], endmodule
c_in2, c_in3, c_in4, c_out,
a[0], b[0], c_in); a[1], b[1], c_in2); a[2], b[2], c_in3); a[3], b[3], c_in4);
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
xor
nand
not
Add_half
xor
invf101
nand
nanf201
not
55
EGYSZERŰ RTL ALTERNATÍVA
a
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; assign {c_out, sum} = a + b + c_in; endmodule
16
b
16
c_in
add_rtl
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
aktuális
g[3]
g[1]
g[0]
g[2]
sig_a sig_b sig_c sig_d
module child_mod (sig_a, sig_b, sig_c, sig_d); input sig_a, sig_b; output sig_c, sig_d;
child_mod
formális
// A modul funkció leírása endmodule
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 (
.sig_c(g[3]), .sig_d(g[2]), .sig_b(g[0]), .sig_a(g[1]));
actuális
g[1]
g[0]
g[3]
g[2]
sig_a sig_b sig_c sig_d child_mod
formális
endmodule 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
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 actuális
g[1]
g[0]
g[3]
g[2]
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
module mod_A(); // strukturális nand(); ... endmodule module mod_B(); // viselkedési //algoritmikus ... always ... endmodule
mod_B
mod_C
module mod_C(); // adat folyam assign X = ... endmodule
61
PÉLDA: KÜLÖNBÖZŐ SZÍNTŰ ABSZTRAKCIÓK mixed_levels data_in
data
clk
q_out
enable
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) q_out = data;
// eseményvezérlő utasítás // 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
nand #1 (q, preset, qbar); // egységnyi késleltetés nand #1 (qbar, clear, q); // azonosítók nincsenek endmodule
clear
1
q
1
qbar
module test_Nand_Latch_1 preset Műveleti kód, ami a preset és clear jeleket generálja
q Nand_Latch_1
clear
qbar
66
Nand_Latch TESZTELÉSI KÖRNYEZETE module test_Nand_Latch_1; reg preset, clear; wire q, qbar; Nand_Latch M1 (q, qbar, preset, clear); initial begin $monitor($time,, "preset = %b clear = %b q = %b qbar = %b", preset,clear,q,qbar); #10 preset = 0; clear = 1; #10 preset = 1;
// Beágyazó tesztelési környezet (DUTB) // forrásjelek regiszter típusok // kimeneti jelek huzal típusok // Hivatkozás a tesztelt modulra (UUT) // Vezérlőjelek generálása a UUT számára $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
10
tsim
20
clear 1 preset 0
10
clear 11
q
30
q1 0
G1 1
32
1
qbar
G2
qbar 1 0
12
31
68
A SZIMULÁCIÓ EREDMÉNYE
0 10 11 12 20 30 31 32 40
preset = x preset = 0 preset = 0 preset = 0 preset = 1 preset = 1 preset = 1 preset = 1 preset = 1
clear = x clear = 1 clear = 1 clear = 1 clear = 1 clear = 0 clear = 0 clear = 0 clear = 1
q=x q=x q=1 q=1 q=1 q=1 q=1 q=0 q=0
qbar = x qbar = x qbar = x qbar = 0 qbar = 0 qbar = 0 qbar = 1 qbar = 1 qbar = 1
Megjegyzés: Az eredmények az egységnyi késleltetésű (#1) modellekre vonatkoznak
69
A MODELL ELLENŐRZÉSE preset
q
qbar
clear -/1
1/1/0
0/0
-/0
0/1
-/1/0 0/1
0/-
1/1
A HDL MODELLEK MEGBÍZHATÓ 1/1
0/0
ELLENŐRZÉSE A TESZTKÖRNYEZET (DUTB) GONDOS, SZISZTEMATIKUS REQUIRES CAREFUL ELŐKÉSZÍTÉSÉT É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Ó C
A
D
B
A
B
C
D
0
10
20
30
40
50 t s im
A B C D
= = = =
x x x x
A = 1 B = 0
B = 1
A = 0
C = 0
C = 1
C = 0
D = 1
D = 0
D = 1
B = 0
72
NEM NULLA-KÉSLELTETÉSŰ SZIMULÁCIÓ A
C
3
B
D
2
A
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.
B
C
D
0
10
20
30
40
50 tsim
A B C D
= = = =
x x x x
A=1 B=0
B=1
A=0
C=1
B=0
C=0
C=0 D=0
D=1
D=1
73
INERCIÁLIS KÉSLELTETÉS - ESEMÉNY TÖRLÉS A B
C
3
D
2
A B C D 0
0 A=x B=x C=x D=x
10
20
10 A=1 B=0 10 C=0
30
30 B=1 13 D=1
40
50
tsim
tsim=33
tsim=35
30 C=1
33 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); $write(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 // 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;
// ugyanaz mint $stop(1).
$stop(0);
// megállás nyomtatás nélkül
$stop(1);
// megállás a szimulációs idő // és a hely megadásával
$stop(2);
// 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;
// ugyanaz mint $finish(1).
$finish(0);
// nyomtatás nélkül befejezi a szimulációt és // visszatér az operációs rendszerhez
$finish(1);
// befejezi a szimulációt, // kinyomtatja a szimulációs időt, a helyet és // visszatér az operációs rendszerhez
$finish(2);
// 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
