|
EDA365欢迎您!
您需要 登录 才可以下载或查看,没有帐号?注册
x
* I% \, E% ^* ?/ G2 ySystemVerilog for Verification:
( y: b- k9 B7 m4 j% ZA Guide to Learning the Testbench Language Features0 [1 F5 G! M( l; x
1. VERIFICATION GUIDELINES 1
8 M" j2 k$ p, S3 x' k3 @* t8 S1.1 Introduction 1
$ K# b7 f8 _8 E" z4 q0 R1.2 The Verification Process 2
8 b. E" ^5 D9 M7 C+ _4 K7 ^/ x/ w1.3 The Verification Plan 4
% ^: v: z/ x% P7 B/ o+ Q" c1.4 The Verification Methodology Manual 4
% L* y/ i/ t! g p* D. N' @ H! b+ _1.5 Basic Testbench Functionality 50 a# c0 U% l- ]/ e% T
1.6 Directed Testing 5
4 Z6 p* i/ H, d3 a1.7 Methodology Basics 7. O# a# u5 m$ ^) d2 Q9 ~4 X" b
1.8 Constrained-Random Stimulus 89 O4 }' m# `0 [5 {% ?# I
1.9 What Should You Randomize? 10
) G3 `( m) f, `: P2 Z/ A6 T0 ?1.10 Functional Coverage 13 V L" b+ s1 _) O# E" j i5 n
1.11 Testbench Components 15; h* H9 q6 J, }4 F
1.12 Layered Testbench 16 K9 ^% S1 F% n+ \) a' F
1.13 Building a Layered Testbench 228 n( w. ^; D! ~& K0 q, z; c
1.14 Simulation Environment Phases 23
- W# Z2 Z Y1 z; y. \! h0 j4 [' S T1.15 Maximum Code Reuse 24 l& ]: w+ @/ `) n" }% w
1.16 Testbench Performance 24
: F! R6 C6 }. G5 ~1 n: B* T1.17 Conclusion 25
! Q$ l, c5 }1 b( |2. DATA TYPES 27
: v! G8 {) a* y2.1 Introduction 274 R3 B& T. ? j5 U
2.2 Built-in Data Types 27$ d3 S* j/ t7 n. l: `
viii SystemVerilog for Verification
; ?! \1 i3 t( \9 N+ A2.3 Fixed-Size Arrays 29
9 D C) B* M) B6 g3 z2 _2.4 Dynamic Arrays 34
/ S# S- U. N8 C7 L: a6 n/ {3 _2.5 Queues 36; n8 y' x! n* ^- j5 n9 F
2.6 Associative Arrays 37+ q4 s: }2 P$ Q* o) Q/ J
2.7 Linked Lists 39* t3 ]- @" X/ b0 W8 v
2.8 Array Methods 40
1 F) Q; {# `! s8 Y$ q$ _" P& B2.9 Choosing a Storage Type 42) r( {: [8 r3 w6 o ~
2.10 Creating New Types with typedef 45
- Z4 b9 i m5 z5 N$ \ `2.11 Creating User-Defined Structures 46
& Z/ O, p9 y$ Q8 E( j5 R5 b2.12 Enumerated Types 47
) u& |* R0 ^5 l3 ^2.13 Constants 51; y* p$ B) }0 x: z; l% O
2.14 Strings 51
+ ?4 W! o2 q0 `9 A' K7 `2.15 Expression Width 52# t1 X2 U; A5 a- f& y. K
2.16 Net Types 53
7 @! D! p) F8 o! E2.17 Conclusion 53" f5 F/ }6 X9 [4 E
3. PROCEDURAL STATEMENTS AND ROUTINES 55
8 `* @: S; g2 _4 I3.1 Introduction 55
/ s5 ^! Y+ Z! b& _% K! L3.2 Procedural Statements 55
4 x0 Y, N" o$ o: F0 {2 s8 r3.3 Tasks, Functions, and Void Functions 56
7 U; u+ s" i/ w1 Q E" l3.4 Task and Function Overview 57, E5 V, K$ C$ o* x
3.5 Routine Arguments 570 }; K" Y) I4 \
3.6 Returning from a Routine 62
( a- k6 w, [" O' X3.7 Local Data Storage 629 _ J0 [) e4 c
3.8 Time Values 646 A( x) r- p) u# }" R" o6 |
3.9 Conclusion 65/ F" `$ j9 c. t: L- x
4. BASIC OOP 67; N, q3 |- P2 F) }0 G8 A7 G
4.1 Introduction 67$ }) W' ]+ |# \$ m. H
4.2 Think of Nouns, not Verbs 67
- s9 P, |6 }' y7 o* e& J) z7 w1 N4.3 Your First Class 68
) b1 _" x B K0 J; ]9 Z9 m4.4 Where to Define a Class 69
r0 k8 a. Y# h/ q$ }4.5 OOP Terminology 69
8 T* B6 Q9 L& G9 o; _) Y" q0 g' e4.6 Creating New Objects 70+ G- n+ ]4 c4 D8 Z! a' u& L
4.7 Object Deallocation 74
4 E9 a" M+ F! c/ o4.8 Using Objects 76
4 w) D7 j) S' }* d) D, B4.9 Static Variables vs. Global Variables 765 ~& {3 J3 t* P9 z, \4 z
4.10 Class Routines 78, t, C' M" B- `8 m4 j5 C! Q1 m
4.11 Defining Routines Outside of the Class 79 p9 R+ @. u. `0 \3 D5 j- R
4.12 Scoping Rules 81 v! H- U5 j2 {! V2 D+ G/ F, x& v
4.13 Using One Class Inside Another 85
* G. p7 L" C4 w( h4.14 Understanding Dynamic Objects 87
3 }7 I- b9 S5 X+ C3 I4 Z, X/ g4.15 Copying Objects 91 c& }, I+ W& e) `
4.16 Public vs. Private 957 `8 o1 H1 k8 e8 D/ m% e; M
Contents ix
8 L% r6 L3 f# w" p2 E4.17 Straying Off Course 96( u5 I* y# D% t% P6 M5 ^
4.18 Building a Testbench 965 w. u$ _8 F' A
4.19 Conclusion 976 F( @' K% T9 c& d& F0 J: c7 X9 [
5. CONNECTING THE TESTBENCH AND DESIGN 99
* B0 y1 b* n1 N. I5.1 Introduction 99
$ l, ~0 X3 t/ o( j6 ~7 i. U0 S5.2 Separating the Testbench and Design 99 h- P& |) K) q+ B
5.3 The Interface Construct 102
% w8 p* H( N7 O% `/ c" Z( V$ ]5.4 Stimulus Timing 108
9 {- [% u2 D. {. w5.5 Interface Driving and Sampling 114' z* ~0 E4 U$ B$ d& m# m- c
5.6 Connecting It All Together 121
/ c' d+ I9 T4 v5.7 Top-Level Scope 121. y) N( a; d) c- l9 N& X
5.8 Program – Module Interactions 123
9 C! ?/ A4 s0 a) H: M+ W" S5.9 SystemVerilog Assertions 124
# T& {& e: f7 A- G. C* D5 E5.10 The Four-Port ATM Router 126
1 n4 {) N' s# b# m5.11 Conclusion 1343 {7 h0 d3 X- ?; r# U% A# C: W( k
6. RANDOMIZATION 135
7 I9 R( r4 M- ^! s M6 ?) ^6.1 Introduction 135* ?# l V. l' ]: V' f2 l# x
6.2 What to Randomize 136, V$ F+ }. _' s' r' B
6.3 Randomization in SystemVerilog 138
: M5 ~7 [% i2 b: V6.4 Constraint Details 141
* N8 ~. w& |- M' R3 K! W6.5 Solution Probabilities 149
' s' p" C, P: k8 r; j6.6 Controlling Multiple Constraint Blocks 154. N& n g7 I% x/ f. w- x+ T& ~$ _! d
6.7 Valid Constraints 154
( T: {+ V. c R: Q6.8 In-line Constraints 1550 {+ h% o9 P5 P! Y8 m3 Z
6.9 The pre_randomize and post_randomize Functions 156
6 I) j8 x- }. L# q5 D% q0 d6.10 Constraints Tips and Techniques 158
" S5 T' W& G$ [1 N" `; B6 `; P6.11 Common Randomization Problems 164
! U. m+ B! q0 W6.12 Iterative and Array Constraints 1650 i, [7 k9 H3 _, y) C
6.13 Atomic Stimulus Generation vs. Scenario Generation 172
, V/ U' }- E1 Y8 e+ i8 G/ k7 t6.14 Random Control 175
# e0 b9 u! Y4 \% I/ h) x' v6.15 Random Generators 177
& L$ K& Z- m* V5 C% a+ U6.16 Random Device Configuration 180' `% D: Q X; q7 W p1 _' F* \
6.17 Conclusion 182, }2 y2 I' ^) R
7. THREADS AND INTERPROCESS COMMUNICATION 183
1 c8 Z6 T/ A$ T! M2 o$ K7.1 Introduction 1835 t$ X, b3 G$ C$ p' y& r+ k
7.2 Working with Threads 184
* ~. s+ W2 G2 i7.3 Interprocess Communication 194
: w7 n. I! L5 T7 \/ b7 w- C7.4 Events 195
5 X; \$ v% ^/ _; s" _7.5 Semaphores 1998 |; X M4 J$ z5 ?/ g. c( A+ h$ t
7.6 Mailboxes 201
7 F T w+ r6 I Y {$ g% g( K3 s7.7 Building a Testbench with Threads and IPC 210" `; W' t& X+ j6 C' W0 A# \; h& u
x SystemVerilog for Verification
- w+ L# s9 L P, \. ?7.8 Conclusion 214" {/ v- ?# E: [3 c2 |" _
8. ADVANCED OOP AND GUIDELINES 215( f# Z1 y3 Y/ Y2 n1 Y/ {# t4 v
8.1 Introduction 215! c; e: C, i0 _ `" W* x% L
8.2 Introduction to Inheritance 2160 R8 N- l; u l4 l6 s! y- ?' E4 V
8.3 Factory Patterns 221
K: I" }$ S" q8 ~/ ]% W0 T8.4 Type Casting and Virtual Methods 225/ t, b" G2 N! A4 Q# Z
8.5 Composition, Inheritance, and Alternatives 228
- i9 ]% E9 {2 e F) r& h( v8.6 Copying an Object 233
: }+ h" }7 w* c4 [9 V4 {9 x/ R8.7 Callbacks 236
' ^: d9 X# |% g$ Z+ @, |' Q+ s' |8.8 Conclusion 240
5 I. _6 U4 p/ j' ]4 u3 ^9. FUNCTIONAL COVERAGE 2418 s: G! j2 e' @; n v _/ n
9.1 Introduction 2419 `8 L- C" H; W
9.2 Coverage Types 243( D; [- k1 w* O4 ], H" \
9.3 Functional Coverage Strategies 2462 Q7 P5 F6 O$ U3 z$ F0 H/ l
9.4 Simple Functional Coverage Example 248
( C4 [5 @* X9 G U O7 l7 D$ F9.5 Anatomy of a Cover Group 251
2 B$ `2 r: S, m9.6 Triggering a Cover Group 253
, g3 u1 b% D/ X8 o% p/ g9.7 Data Sampling 256
, k% V2 x6 P1 O6 f" d' Q6 ? |9.8 Cross Coverage 2650 m7 @4 H! e" v( ^
9.9 Coverage Options 272( P! k6 V. m/ d( _" E# T6 T
9.10 Parameterized Cover Groups 2740 f( A1 ?" U$ `' p! [
9.11 Analyzing Coverage Data 275& o$ k6 ~) E8 \# N" v+ j9 ^. }
9.12 Measuring Coverage Statistics During Simulation 2768 J. O8 p+ V0 B( B3 ^
9.13 Conclusion 277
" q; l/ v. v" k& f( X9 ]10. ADVANCED INTERFACES 279) q4 t* N: t- F; ]/ F
10.1 Introduction 279
' Q$ V! B+ ?& ~# o10.2 Virtual Interfaces with the ATM Router 2797 s/ ]0 ?9 D& n# Q. @
10.3 Connecting to Multiple Design Configurations 2845 O F& N% `7 d, V- g& v
10.4 Procedural Code in an Interface 290
: m4 H2 }8 `- N9 f; s" p! H10.5 Conclusion 294
* V& W6 w E* d/ z- VReferences 295
( O& w- B* v: {) J5 ?) rIndex 297
$ N$ M0 X1 B1 s5 x0 T |
|