Module 1: Verification Guidelines
- Introduction to Verification: Understanding the verification process, verification plans, and methodology basics.
- Testing Strategies: The difference between directed testing and constrained-random stimulus.
- Testbench Architecture: Basic testbench functionality, testbench components, building layered testbenches, and maximizing code reuse.
- Simulation & Performance: Simulation environment phases, functional coverage, and testbench performance.
Module 2: Data Types
- Built-in and Custom Types: Built-in data types, creating new types with typedef, enumerated types, constants, strings, and net types.
- Arrays and Storage: Fixed-size arrays, dynamic arrays, associative arrays, queues, and linked lists.
- Data Structures: Array methods, choosing a storage type, and creating user-defined structures.
Module 3: Procedural Statements and Routines
- Control Flow: Procedural statements and time values.
- Tasks and Functions: Task and function overviews, void functions, routine arguments, and returning from a routine.
- Storage Variables: Managing local data storage.
Module 4: Basic Object-Oriented Programming (OOP)
- OOP Fundamentals: OOP terminology, thinking in nouns rather than verbs, and creating your first class.
- Object Management: Creating new objects, copying objects, understanding dynamic objects, and object deallocation.
- Class Architecture: Class routines, out-of-class routine definitions, scoping rules, public vs. private variables, and using one class inside another.
Module 5: Connecting the Testbench and Design
- Interfaces and Timing: Separating the testbench and design, the interface construct, stimulus timing, and interface driving and sampling.
- Integration: Top-level scopes, program-module interactions, connecting it all together, and SystemVerilog Assertions.
Module 6: Randomization
- Randomization Basics: What to randomize, random control, and randomization in SystemVerilog.
- Constraints: Constraint details, solution probabilities, controlling multiple constraint blocks, valid constraints, and in-line constraints.
- Advanced Randomization: The pre_randomize and post_randomize functions, iterative and array constraints, atomic stimulus vs. scenario generation, and random generators.
Module 7: Threads and Interprocess Communication
- Thread Management: Working with threads and building a testbench with threads and Interprocess Communication (IPC).
- Synchronization: Utilizing events, semaphores, and mailboxes.
Module 8: Advanced OOP and Guidelines
- Advanced Class Concepts: Introduction to inheritance, composition vs. inheritance, factory patterns, and copying an object.
- Methods and Callbacks: Type casting, virtual methods, and using callbacks.
Module 9: Functional Coverage
- Coverage Fundamentals: Coverage types, functional coverage strategies, and basic functional coverage examples.
- Cover Groups: Anatomy of a cover group, triggering a cover group, and parameterized cover groups.
- Data and Analysis: Data sampling, cross coverage, coverage options, and analyzing coverage data.
Module 10: Advanced Interfaces
- Advanced Interface Concepts: Using virtual interfaces, connecting to multiple design configurations, and writing procedural code in an interface.