A VERILOG HARDVER LEÍRÓ NYELV ALKALMAZÁSA A LOGIKAI SZINTÉZISBEN M.D. CILETTI Department of Electrical and Computer Engineering University of Colorado Colorado Springs, Colorado Copyright 1997 No part of these notes may be copied or reproduced in any form without the written permission of the author. A szerző írásbeli engedélye és jóváhagyása alapján átdolgozta és magyarra fordította FEHÉR BÉLA Budapesti Műszaki Egyetem Méréstechnika és Információs Rendszerek Tanszék
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
UTASÍTÁSON BELÜLI KÉSLELTETÉS PÉLDA module dff_viselk (data, clk, q, qbar, reset); input data, clk, reset; output q, qbar; reg q; parameter kapcs_ido = 5; parameter kis_ido = 2; assign qbar = # kis_ido ~q;
// Eltérés q, qbar között
always @(clk or reset) begin if (reset == 0) q = # kapcs_ido 0; else q = # kapcs_ido data; end endmodule A data bemenet értéke a kapcs_ido kapcsolási idő múlva jeleneik meg a q kimeneten, amit egy kis_ido múlva a qbar kimenet változása is követ.
3
UTASÍTÁSON BELÜLI KÉSLELTETÉS preset data
q
clk
qbar clear
module D_Flop (preset, clear, q, qbar, clock, data); input preset, clear, clock, data; output q, qbar; reg q; parameter delay = 5; assign qbar = ~q; always @ (negedge clock) q = # delay data; // késleltetett értékadás
always @ (clear or preset) begin if (!clear) #1 assign q = 0; //PCA else if (!preset) assign q = 1; else deassign q; end endmodule
4
ISMÉTLŐDŐ ESEMÉYEK Az utasításon belüli késleltetés tartalmazhat ismétlődési számot is. PÉLDA
EKVIVALENS MEGOLDÁS
reg_a = repeat (5) @ (negedge clock) reg_b;
begin temp = reg_b; @ (negedge clock); @ (negedge clock); @ (negedge clock); @ (negedge clock); @ (negedge clock); reg_a = temp; end
// reg_b mintavételezett értékét 5 órajel ciklus utáni másolja át reg_a-ba
5
ISMÉTLŐDŐ ESEMÉNYEK VEZÉRLÉSE module repeater; reg clock; reg reg_a, reg_b; initial
clock = 0;
initial begin #5reg_a = 1; #10 reg_a = 0; #5 reg_a = 1; #20 reg_a = 0; end always #5 clock = ~ clock; initial #100 $finish;
clock
0
10
20
30
40
50
60
70
80 t
10
20
30
40
50
60
70
80 t
10
20
30
40
50
60
70
80 t
reg_a
reg_b
0
initial begin #10 reg_b = repeat (5) @ (posedge clock) reg_a; end endmodule
6
IDŐZÍTÉSVEZÉRLÉSI MODELLEK A VISELKEDÉSI LEÍRÁSOKBAN ASSIGNMENTS
FLOW CONTROL
Procedural Assignment (=)
Case
Procedural -Continuous (assign)
Branching
Non-Blocking (<=)
Loops
Assignment Delay Control
Parallel Activity (fork ... join)
Assignment Event Control Intra-Assignment Delay TIMING
CODE MANAGEMENT
Wait
Function Calls
Named Events
Task Calls
Pin-Pin Delay
Prog. Lang. Interface (PLI)
7
IDŐZÍTÉSI ÉS KÉSLELTETÉSI MODELLEK CÉL: A viselkedési leírás egy-egy aktivitásához késleltetést rendelhet. PROCEDURÁLIS KÉSLELTETÉS
X_in
X_in t
KI-BEMENETI VISELKEDÉS LEÍRÁSA
Y_out Y_out talgo
t
• Késleltetés vezérlés (#) (Blokkolja / felfüggeszti a végrehajtást) • Eseményvezérlés (@) (Aktivitásokat szinkronizál) • Utasításon belüli késleltetés (Késlelteti az értékadást) • Wait (a továbblépés feltételei) • Nevesített esemény (Szinkronizáció absztrakt eseményekhez) • Interfész (I/O) késleltetés modellezése
8
A 'wait' UTASÍTÁS CÉL: A SZINTÉRZÉKENY ESEMÉNYVEZÉRLÉS TÁMOGATÁSA SZINTAKTIKA wait (feltétel_kifejezés) utasítás_vagy_üres; HATÁSA: A végrehajtás felfüggesztődik, amíg a 'wait' feltétel_kifejezés értéke 'IGAZ' nem lesz. PÉLDA ... begin wait (!enable) #10 a = b; #10 c = d; end ...
9
PÉLDA A 'wait' HASZNÁLATÁRA - HANDSHAKE module server (data_out, server_ready, client_ready); output [15:0] data_out; output server_ready; input client_ready; reg server_ready; reg [15:0] data_out;
SERVER data_out
CLIENT 16
server_ready
server_ready client_ready
client_ready
várakozás client_ready-re
client_ready
data_in
server_ready és várakozás !client_ready-re
!client_ready
várakozás client_ready-re
client_ready
10
PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE always begin server_ready = 0; forever begin wait (client_ready) data_out = $random; server_ready = 1; wait (!client_ready) server_ready = 0; end end endmodule
// SZERVER OLDAL // kezdeti feltétel beállítása // várakozás a kliens kérésére // kimeneti adat frissítése // szerver kész az adat küldésre // átvitel kész
11
PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE module client (data_in, server_ready, client_ready); input [15:0] input output reg reg [15:0]
data_in; server_ready; client_ready; client_ready; data_reg;
SERVER data_out
CLIENT 16
server_ready
server_ready client_ready
client_ready
várakozás client_ready-re
client_ready
data_in
server_ready és várakozás !client_ready-re
!client_ready
várakozás client_ready-re
client_ready
12
PÉLDA 'wait' HASZNÁLATÁRA - HANDSHAKE always begin client_ready = 1; forever begin wait (server_ready) data_reg = data_in; client_ready = 0; // adat feldolgozása wait (!server_ready) client_ready = 1; end end endmodule
// KLIENS OLDAL // kliens kész jelzés // várakozás a szerver válaszára // adat átvétele // jelzés visszavétele // várakozás a szerverre // kész válasz a szervernek
13
HANDSHAKE SZIMULÁCIÓ module top_module(); // Random client/server wire [3:0] data_out, data_in; wire server_ready, client_ready; server M1 (data_out, server_ready, client_ready); client M2 (data_out, server_ready, client_ready); initial begin #300 $finish; end endmodule module server(data_out, output [3:0] output input reg reg [3:0] reg [3:0]
server_ready, client_ready); data_out; server_ready; client_ready; server_ready; data_out; timer;
always begin # 15 server_ready = 0; forever begin wait (client_ready) timer = $random; # timer data_out = $random; #5 server_ready = 1;
wait (!client_ready) #3 server_ready = 0; end
end endmodule
module client(data_in, server_ready, client_ready); input [3:0] data_in; input server_ready; output client_ready; reg client_ready; reg [3:0] data_reg; reg [3:0] timer; always begin #30 client_ready = 1; forever begin wait (server_ready) #2 data_reg = data_in; timer = $random; # timer client_ready = 0; wait (!server_ready) #30 client_ready = 1; end end endmodule
14
KOMMUNIKÁCIÓ ELJÁRÁSOK KÖZÖTT (INTER-PROCESS COMMUNICATION, IPC)
A Verilog nyelv két módszert kínál a konkurrens folyamatok (viselkedési leírások) szinkronizációjára: • Élérzékeny eseményvezérlő kifejezés • Nevesített esemény. A nevesített események olyan szinkronizációt biztosítanak, amely akár hierarchikus szintek között is, modulportokat nem igényelve használható.
15
NEVESÍTETT ESEMÉNYEK CÉL: ELJÁRÁSOK KÖZTI KOMMUNIKÁCIÓ BIZTOSÍTÁSA. JELLEMZŐK: •
•
•
NINCS MEGVALÓSÍTÁSHOZ KÖTVE, MINT PL. wire OR reg. ABSZTRAKT MECHANIZMUS A KOMMUNIKÁCIÓRA / SZINKRONIZÁCIÓRA TÁMOGATJA A MAGAS SZINTŰ VISELKEDÉSI MODELLEZÉST SPECIÁLIS TULAJDONSÁG:
AZ IPC PORTOK NÉLKÜL VALÓSÍT MEG MODULOK KÖZÖTTI KOMMUNIKÁCIÓT
16
NEVESÍTETT ESEMÉNYEK •
DEKLARÁCIÓ: event esemény_neve;
•
HASZNÁLAT:
-> esemény_neve;
MEGJEGYZÉSEK: • A nevesített eseményeket a használat előtt deklarálni kell. • Nincs szükség hardver elemekre az esemény tárolásához (reg) vagy az átviteléhez (wire). • A nevesített esemény szerkezet sokkal absztraktabb, mint az egyszerű eseményvezérlő kifejezés. • A VHDL-ben nincs hasonló szerkezet. • Nem szükséges semmi speciális művelet a mechanizmus használatához.
17
PÉLDA NEVESÍTETT ESENÉNY HASZNÁLATÁRA clock
up_edge_of_clock q_out
data
module named_event1(q_out, clock, data); input clock, data; output q_out; reg q_out; event up_edge_of_clock; always @(posedge clock) -> up_edge_of_clock; always @(up_edge_of_clock) q_out = data; endmodule
18
PÉLDA NEVESÍTETT ESEMÉNY HASZNÁLATÁRA M1 clock
M2 do_it
q_out
data
module Top (clock, data, q_out); input clock, data; output q_out; Talker M1 (clock); Receiver M2 (q_out, data); endmodule
module Receiver (q_out, data); input data; output q_out; reg q_out;
module Talker (clock); input clock; event do_it;
endmodule
always @(Top.M1.do_it) q_out = data;
always @(posedge clock) -> do_it; endmodule
19
KÉSLELTETÉSI MODELLEK MODULOK BE-/KIMENETI KÉSLELTETÉSE CÉL: A teljes modul késleltetés modellezése egyszerű be/kimeneti időadatokkal. MODUL BE/KIMENETI KÉSLELTETÉS
X_in
X_in t
VERILOG MODUL
Y_out
Y_out tmod
t
• Különböző ütemezések lehetségesek • Interfész alapú viselkedési model • A késleltetést szétválasztja a belső funkcionalitástól MEGJEGYZÉS: CSAK A MODULOKNAK LEHET BE/KIMENETI KÉSLELTETÉSE
20
MODULOK BE-/KIMENETI KÉSLELTETÉSE preset
clear 5ns
5ns
data flop_QCA
q
clock
8ns
A be/kimeneti késleltetési modell megengedi a tervezőnek a időzítés specifikáció elválasztását a modul belső funcionalitásának definiálásától.
21
MODUL KÉSLELTETÉSI JELUTAK A be/kimeneti utaknak két típusa lehetséges: párhuzamos vagy teljes. =>
*>
Párhuzamos be/kimeneti késl.
Teljes be/kimeneti késleltetés
• A párhuzamos kapcsolat skalárokat vagy azonos méretű vektorokat igényel. • A teljes kapcsolat vektort skalárral, vektorokat eltérő vagy azonos méretű vektorokkal, többszörös jelforrásokat többszörös jelvégpontokkal társít össze.
22
JELUTAK MEGADÁSÁNAK SZABÁLYAI SZABÁLYOK • A modul jelút végpont csak modulon belüli meghajtó kimenete lehet. • A => operator párhuzamos kapcsolatot specifikál a megfelelő be- és kimeneti bitek között. • A *> operator teljes kapcsolatot specifikál minden bemenet és minden kimenet között. • A modul jelút forrása csak deklarált input vagy inout lehet. • A modul jelút végpontja csak deklarált output vagy inout lehet.
23
PÉLDA MODUL JELÚT KÉSLELTETÉSRE module mod_path_FF (clock,data,clear,preset,q_out,q_outbar); input clock, data, clear, preset; output q_out, q_outbar; reg q; wire q_outbar = ~ q_out; buf (q_out, q); // Szükséges meghajtó always @ (clear or preset) begin if (!clear) assign q = 0; // PCA else if (!preset) assign q = 1; else deassign q; end always @(posedge clock) q = data;
preset data
q_out
clk y
q_outbar clear
specify specparam t_rise_clk_q = 90, t_fall_clk_q = 110, t_rise_ctl_q = 40, t_fall_ctl_q = 50; // be-/kimeneti jelút időzítés specifikáció (clock => q_out) = (t_rise_clk_q, t_fall_clk_q); (clear, preset *> q_out) = t_rise_ctl_q, t_fall_ctl_q); endspecify endmodule
24
PÉLDA: NAND KAPU KÉSLELTETÉSI MODELLJE Az ASIC technológiai könyvtárak gyakran két részletben modelleznek: primitívekkel írják le a fuknkciót és ún. "specify" blokkal a be-/kimeneti késleltetéseket.
module nanf201 (O, A1, B1); // 1.2 mikronos CMOS cella output O; input A1, B1; nand(O, A1, B1);
// primitív kapu használata
specify specparam
// optionális modul jelút időyítések Tpd_0_1 = 0.052:0.097:0.289, Tpd_1_0 = 0.061:0.129:0.330;
(A1, B1 => O) = (Tpd_0_1, Tpd_1_0); endspecify endmodule
25
ÖSSZEFOGLALÓ A KÉSLELTETÉS SPECIFIKÁCIÓS SZERKEZETEKRŐL KOMBINÁCIÓS LOGIKA
KÉSLELTETÉS TÍPUSA
Primitív kapu késleltetése assign értékadás Huzal deklaráció Huzal assign értékadás
Tehetelenségi(min:typ:max, rising, falling, turn-off) Tehetelenségi(min:typ:max, rising, falling, turn-off) Transzport késleltetés Tehetetlenségi(min:typ:max, rising, falling)
SZEKVENCIÁLIS LOGIKA Késleltetés vezérlás Esemény vezérlés Utasításon belüli késleltetés vezérlés Be/kimeneti késleltetés
# blokkoló_utasítás @ # @ (esemény_kifejezés) repeat ( ) @ (esemény_kifejezés) Specifikációs blokk
26
IDŐZÍTÉS ELLENŐRZÉS Verilog nyelv a szimuláció során szükséges minden időzítés ellenőrzési feladatra beépített rendszer taszkokat biztosít. TASZK
FUNKCIÓ
$setup
Figyelmeztet, ha a jel a referenciajel aktív éle előtti specifikált intervallumban változik.
$hold
Figyelmeztet, ha a jel a referenciajel aktív éle utáni specifikált Intervallumban változik.
$setuphold
Együttesen ellenőrzi mindkét fenti feltételt.
$period
Figyelmeztet, ha a jel periódusideje rövidebb a specifikáltnál.
$width
Figyelmeztet, ha a pulzus szélesség keskenyebb a specifikáltnál.
$skew
Figyelmeztet, ha két jel elcsúszása meghaladja a specifikált értéket.
$recovery
Figyelmeztet, ha a jel feléledési ideje meghaladja a specifikált értéket.
27
BEÁLLÁSI IDŐ (SETUP TIME) $setup (adat_esemény, referencia_esemény, határérték, jelzés); PÉLDA 5
slack sig_a
sys_clk
sig_a tsetup sig_b
$setup (sig_a, posedge sys_clk, 5) sig_a teljesíti a beállási idő korlátozást. sig_b nem teljesíti a beállási idő korlátozást.
A beállási idő veszélyeztetése akkor fordul elő, amikor az adat_esemény a referencia_ eseményhez képest a megadott határértéknek megfelelő időintervallumon belül fordul elő. A gyakorlatban az adatnak stabilnak kell lennie, a regiszterek (flipflop-ok) órajelének aktív éle előtt. A szintézis eszközök a kombinációs jel utak késleltetésének minimalizálásával igyekeznek megfelelő tartalék időt (slack) biztosítani a kritikus jelútban is. Az időzítés ellenőrzéseket általában a specify … endspecifiy blokk tartalmazza a modulban. A szimulátorok automatikusan figyelik a jelalakok megfelelősségét.
28
TARTÁSI IDŐ (HOLD TIME) $hold (adat_esemény, referencia_esemény, határérték, jelzés); PÉLDA 2 sys_clk sig_a thold
A tartási idő veszélyeztetése akkor fordul elő, amikor az adat_esemény a referencia_ eseményhez képest a megadott határértéknél rövidebb idő alatt fordul elő. A gyakorlatban az adatnak stabilnak kell maradnia az órajel aktív éle után, hogy a flip-flop-on belüli tranziens folyamatok megbízhatóan befejeződjenek. A szintézis eszközök a rövid kombinációs jel utakat megnyújtják, az időzítési adatok teljesítése érdekében.
sig_b
$hold (sig_a, posedge sys_clk, 5) sig_a nem teljesíti a tartási idő korlátozást. sig_b teljesíti a tartási idő korlátozást.
Az opcionális jelzés regiszter használható az időzítésbeli problémák kezelésére a modellben, pl. x érték továbbadására. (Lásd Verilog Language Reference Manual)
29
BEÁLLÁSI ÉS TARTÁSI IDŐK (SETUP AND HOLD TIMES) $setuphold (adat_esemény, referencia_esemény, setup_limit, hold_limit, jelzés); PÉLDA setup_limit
hold_limit
sys_clk
sig_a
sig_b
$setuphold (sig_a, posedge sys_clk, 5,3) sig_a teljesíti mindkét korlátozást.
posedge jelentése: 01, 0x, x1 átmenetek negedge jelentése: 10, x0, 1x átmenetek Az élváltásoknál nincs különbség a 'z' érték és az 'x' érték kezelése között. A Verilog támogatja az egyedi él specifikációkat is, pl.: edge [01]
sig_b nem teljesíti valamelyik korlátázást.
30
MINIMÁLIS PULZUS SZÉLESÉG (PULSE WIDTH) $width (referencia_esemény, határérték jelzés); PÉLDA
tMPW
A $width taszk ellenőrzi a minimális pulzus szélességet az élvezérelt eszközök modelljeinél. $width (posedge clock_a, 20);
clock_a
clock_b
clock_a teljesíti a pulzus szélesség korlátot.
Az élvezérelt eszköz órajel pulzusának egy minimális időtartamot meg kell haladnia, a belső tranziens folyamatok teljes befejeződése érdelében. Az órajel terjesztési fák tervezése fokozott gondosságot igényel.
clock_b nem teljesíti a pulzus szél. korlátot.
31
PERIÓDUSIDŐ $period (referencia_esemény, határérték, jelzés); PÉLDA
tperiod clock_a
A $period taszk ellenőrzi a kiválasztott jel két referencia eseményének alapján a periódusidőt.
tlimit
$period (posedge clock_a, 25); clock_a teljesíti a periódusidő korlátot.
32
ELCSÚSZÁS (SKEW) $skew (referencia_esemény, adat_esmény, határérék, jelzés); PÉLDA
tskew
clk1 clk2
A $skew taszk ellenőrzi az időelcsúszást, (időeltérést) a két jel referencia élei között és jelzi, ha ez kisebb a megadott határértéknél Az órajel elcsúszás minimalizálásának fontos szerepe van a rendszer teljesítő képességének növelésében.
$skew(posedge clk1, negedge clk2, 3);
33
FELÉLEDÉSI IDŐ (RECOVERY TIME) $recovery (referencia_esemény, adat_esmény, határérék, jelzés); PÉLDA
trec set clock_a
clock_a teljesíti a feléledési idő által a periódusidejére adott korlátot.
A $recovery taszk ellenőrzi, hogy egy szinkron viselkedési leírással adott modell a reset vagy set vezérlőjel deaktiválása után a megadott időn belül működésre kész-e. A feléledési idő korlát specifikálja, hogy a vezérlőjel megszűnése után mennyi időn belül kell megjönnie az első órajel felfutó élnek. $recovery (negedge set, posedge clock,3); Tipikus alkalmazás a buszjelek bekapcsolási időzítésének ellenőrzése.
34
FELTÉTELES ESEMÉNYEK (CONDITIONED EVENTS) A feltételes események összekapcsolják az időzítés ellenőrzést egy feltételes jellel.
PÉLDA $setup (data, posedge clock &&& (~reset), 10); MEGJEGYZÉS: A reset jel aktív értéke esetén a &&& speciális operátor segítségével a szükségtelen időzítési jelzéseket letiltjuk.
35
PÉLDA IDŐZÍTÉSADATOK HASZNÁLATÁRA FLIP-FLOP MODELLEZÉSÉNÉL `timescale 1ns / 1ps `celldefine module dfnf311 (Q, Q_b, DATA1, CLK2); // Negative edge-triggered flip-Flop with Q and QB input DATA1, CLK2; output Q, Q_b; reg notify; parameter vlib_flat_module = 1 ; U_FD_N_NO inst1 (Q_int, DATA1, CLK2, notify); // user-defined primitive buf inst2 (Q, Q_int); not inst3 (Q_b, Q_int);
36
specify // Module paths specparam Area_Cost = 4268.16; (negedge CLK2 => (Q +: DATA1)) = (0.525:1.129:2.889, 0.749:1.525:3.948); specparam RiseScale$CLK2$Q = 0.00094:0.00205:0.00540; specparam FallScale$CLK2$Q = 0.00086:0.00165:0.00397; (negedge CLK2 => (Q_b -: DATA1)) = (0.590:1.243:3.207, 0.425:0.914:2.616); specparam RiseScale$CLK2$Q_b = 0.00120:0.00248:0.00658; specparam FallScale$CLK2$Q_b = 0.00140:0.00289:0.00248; specparam
inputCap$CLK2 = 40.18, InputCap$DATA1 = 24.11;
specparam
InputLoad$CLK2 = 0.009:0.021:0.053, InputLoad$DATA1 = 0.005:0.013:0.032;
specparam
t_SETUP$DATA1 = 0.76:0.92:1.68, t_HOLD$DATA1 = 0.44:0.74:0.46, t_PW_H$CLK2 = 0.37:0.67:1.99, t_PW_L$CLK2 = 0.37:0.67:1.99;
37
// Timing checks $setuphold(negedge CLK2, DATA1, t_SETUP$DATA1, t_HOLD$DATA1, notify); $width (posedge CLK2, t_PW_H$CLK2, 0, notify); $width (negedge CLK2, t_PW_L$CLK2, 0, notify); `ifdef not_cadence specparam MaxLoad = `MAX_LOAD_1X; `endif endspecify endmodule `endcelldefine
38
primitive U_FD_N_NO (Q, D, CP , NOTIFIER_REG); output Q; input NOTIFIER_REG, D, CP; reg Q; // FUNCTION : NEGATIVE EDGE TRIGGERED D FLIP-FLOP ( Q OUTPUT UDP ). table // D CP 1 (10) 0 (10) 1 (1x) 0 (1x) 1 (x0) 0 (x0) ? (0x) ? (?1) * ? ? ? endtable endprimitive
NOTIFIER_REG : Qt : Qt+1 ? ?
: ? : 1; // clocked data : ? : 0;
? ? ? ? ? ? ? *
: : : : : : : :
1 0 1 0 ? ? ? ?
: : : : : : : :
1; // reducing pessimism 0; 1; 0; -; // no change on rising edge -; -; // ignore edges on data x; // all transitions
39
A SZIMULÁCIÓS IDŐ SKÁLÁZÁSA `timescale
/
A `timescale direktíva specifikálja a fizikai időegységet és azt a felbontást amit a Verilog forrásnyelvi modulban használni akarunk. s ms us ns ps fs
seconds milliseconds microseconds nanoseconds picoseconds femtoseconds
`timescale 10 ns / 1 ns module … parameter delay = 1.76; endmodule A delay értéke 18 ns lesz a kerekítés miatt.
• A numerikus értékek az idő_egység többszöröseként értelmezettek • A felbontásnak megfelelő értékre kerekít a rendszer. • A szimuláció során az eltérő időegységet használó modulok keverhetők.
40
KÓD SZERVEZÉS ASSIGNMENTS
FLOW CONTROL
Procedural Assignment (=)
Case
Procedural -Continuous (assign)
Branching
Non-Blocking (<=)
Loops
Assignment Delay Control
Parallel Activity (fork ... join)
Assignment Event Control Intra-Assignment Delay TIMING
CODE MANAGEMENT
Wait
Function Calls
Named Events
Task Calls
Pin-Pin Delay
Prog. Lang. Interface (PLI)
41
TASZKOK ÉS FÜGGVÉNYEK
CÉL: • A meglévő, korábbi Verilog kód újra felhasználása • A kód kisebb egységekre osztása • Érthetőség növelése • Adat rejtés, információ redukció modulok között • Kód karbantarthatóságának növelése
42
BEÉPÍTETT TASZKOK ÉS FÜGGVÉNYEK Néhány példa a beépített rendszer taszkokra: $rtoi
Valós konvertálása egésszé csonkolással.
$itor
Egész konvertálása valóssá.
$realtobits
Valós konvertálása 64 bites reprezentációra.
$bitstoreal
Bitminta konvertálása valósra.
$time
Visszaadja az aktuális szimulációs időt (skálázott 64 bites érték).
$stime
Visszaadja az aktuális szimulációs időt 32 bites formátumban.
$realtime
Visszaad egy olyan valós értéket, ami a hívó modul időegysége szerint skálázott.
43
FÜGGVÉNYEK CÉL: Procedurális utasítások és értékadások kiértékelését valósítja meg. • Modulban deklarálható • Kifejezésekben hívható • Használhat lokális változókat • Nem tartalmazhat időzítés vagy eseményvezérlő utasításokat • Legalább egy bemeneti változója kell legyen
44
PÉLDA MULTIPLEXER MEGVALÓSÍTÁSÁRA FÜGGVÉNYHÍVÁSSAL module mux4_df_fc (a, b, c, d, select, y_out); input a, b, c, d; input [1:0] select; output y_out; assign y_out = mux (a, b, c, d, select);
function mux; input a, b, c, d; input [1:0] select; case (select) 2'b00: mux = a; 2'b01: mux = b; 2'b10: mux = c; 2'b11: mux = d; default: mux = 'bx; endcase endfunction endmodule
Megjegyzés: A 2’b00 jelölés kétbites értéket jelöl.
45
PÉLDA AUTONÓM LFSR PSZEUDÓ VÉLETLEN GENERÁTOR module Autonomous_LFSR (Clock, Reset, Y); parameter Length = 8; input Clock, Reset; Y[7] output [Length-1: 0] Y; 1 + 0 reg [Length-1: 0] Y;
c[0:7] = [1100_1111] y 0
1
+
0
+
0
+
0
c[1]
+ c[7]
Y[0]
1
h91
1
0
0
0
0
1
1
1
h87
1
0
0
0
1
1
0
0
h8c
0
1
0
0
0
1
1
0
h46
always @ (posedge Clock) begin if (!Reset) Y = 8’b1001_0001; else Y = LFSR_Value (Y); end
46
PÉLDA AUTONÓM LFSR FÜGGVÉNY DEKLARÁCIÓ ÉS HASZNÁLATA function [Length-1: 0] LFSR_Value; parameter Length = 8; parameter [1:Length-1] Tap_Coefficient = 7’b1001_111; input [Length-1: 0] LFSR_state; integer Cell_ptr; begin for (Cell_ptr = Length -2; Cell_ptr >= 0; Cell_ptr = Cell_ptr -1) if (Tap_Coefficient [Cell_ptr + 1] == 1) // A visszacsatolások helyén LFSR_Value [Cell_ptr] = LFSR_state [Cell_ptr + 1] ^ LFSR_state [0]; // XOR else LFSR_Value [Cell_ptr] = LFSR_state [Cell_ptr +1]; // Egyszerű shift LFSR_Value [Length - 1] = LFSR_state [0]; end endfunction endmodule
47
PÉLDA AUTONÓM LFSR c[0:7] = [1100_1111] Y[7]
1
Y[0]
+ c[1]
0
0
1
+
0
+
0
1
0
0
0
0
1
1
0
0
0
1
0
0
0
0
0
+
0
+ c[7]
1
h91
1
1
h87
1
0
0
h8c
1
1
0
h46
48
TASZKOK • Modulon belül deklarálható.
• A 'return' után az eredmények elérhetők.
• Viselkedési leíráson hívható.
• Lehetnek lokális változói.
• Végrehajtása után a vezérlést a következő utasításra adja.
• Tartalmazhat időzítés és eseményvezérlő utasításokat.
• Kifejezéseken belül nem használható.
• Rekurzívan hívható (saját magából, vagy egy másik taszkból, melyet önmaga hívott).
• A taszkoknak paraméterek átadhatók.
• (Közös memória - Statikus változók Potenciális lehetőség mellékhatásokra).
49
PÉLDA A TASZKOK HASZNÁLATÁRA module Autonomous_LFSR3 (Clock, Reset,Y); parameter Length = 8; parameter [1:Length-1] Tap_Coefficient = 7'b1001_111; input Clock, Reset; output [Length-1: 0] Y; reg [Length-1:0] Y; integer Cell_ptr; always @ (posedge Clock) begin if (!Reset) Y = 8'b1001_0001; // Reset állapot 8'h91 else Update_LFSR; end
50
PÉLDA A TASZKOK HASZNÁLATÁRA task Update_LFSR; reg [Length-1:0] LFSR_state; begin LFSR_state = Y; for (Cell_ptr = Length -2; Cell_ptr >= 0; Cell_ptr = Cell_ptr -1) if (Tap_Coefficient [Cell_ptr +1] == 1) // A visszacsatolások helyén Y [Cell_ptr] = LFSR_state [Cell_ptr+1] ^ LFSR_state [0]; else Y [Cell_ptr] = LFSR_state [Cell_ptr +1]; Y [Length-1] = LFSR_state [0]; end endtask endmodule
51
END OF Part 4b
52
