Look up a concept, code symbol or debugging topic. Continue into the lesson for examples, practice and the next step in your learning path.
Model combinational hardware with continuous and procedural assignments; use blocking assignments, defaults, if and case statements; prevent latches; and code decoders, multiplexers, comparators, and ALUs clearly.
Open reference →Model registers with nonblocking assignments; implement enables, counters, and shift registers; distinguish synchronous and asynchronous reset; and code a finite-state machine with safe defaults and recovery.
Open reference →Distinguish packed vectors from unpacked arrays; model synchronous memories; define read-during-write behavior; use procedural loops; and create repeated or conditional hardware with generate constructs.
Open reference →Use functions for reusable combinational calculations; use tasks for testbench procedures; choose parameters and localparams for constants; and apply include files and macros without hiding design intent.
Open reference →Explain event-driven simulation, delta cycles, blocking and nonblocking update timing; identify races; separate clock generation, stimulus, and checking; and distinguish simulation delays from implementation timing.
Open reference →Build a testbench with a stable clock and reset; apply directed and boundary stimulus; calculate expected results; report useful failures; dump waves; stop cleanly; and return an unambiguous pass/fail outcome.
Open reference →Review RTL for functional intent, widths, signedness, combinational completeness, clock and reset discipline, hierarchy, synthesis portability, warnings, X behavior, and verification evidence.
Open reference →Choose between four-state `logic` and two-state `bit`/`int`; declare packed and unpacked arrays correctly; build readable models with `typedef`, `enum` and `struct`; control width and sign with explicit casts; and use `string` for testbench messages.
Open reference →Select the right collection for a testbench job; size and resize dynamic arrays; use queues as FIFOs and stacks; index sparse data with associative arrays; iterate with `foreach`; and apply the built-in array reduction, ordering and locator methods.
Open reference →Declare a class with properties, a constructor and methods; distinguish a handle from the object it refers to; explain `null` handles and garbage collection; implement shallow and deep copies; and use `static` members and `this` correctly.
Open reference →Extend a base class and call its members with `super`; explain how `virtual` methods select behaviour at run time; use `$cast` to move a base handle back to a derived type safely; define abstract classes with pure virtual methods; and…
Open reference →Start parallel threads with `fork...join`, `join_any` and `join_none`; stop threads safely with `disable fork`; synchronise threads with named events; protect shared resources with semaphores; and pass transactions between components with mailboxes.
Open reference →Bundle a protocol's signals into an `interface`; restrict direction with `modport`; remove testbench-to-DUT races with a clocking block; connect class-based components to the DUT through a `virtual interface`; and choose input and output skews deliberately.
Open reference →Describe the role of each testbench layer; write transaction, generator, driver, monitor and scoreboard classes; connect them with mailboxes inside an environment; control a run from a test class; and decide when a test has finished.
Open reference →Declare `rand` and `randc` properties; write constraint blocks that keep stimulus legal; call `randomize()` and always check its result; add inline constraints with `randomize() with`; use `pre_randomize` and `post_randomize`; and reproduce a failing test from its seed.
Open reference →Shape value distributions with `dist`; express conditional rules with implication and `if/else`; control solving order with `solve...before`; make defaults overridable with `soft`; switch constraints and random variables on and off at run time; and constrain the size and contents of…
Open reference →Distinguish immediate from concurrent assertions; build sequences with cycle delays and repetition; write properties with overlapping and non-overlapping implication; use `$rose`, `$fell`, `$stable` and `$past`; disable checks during reset; and attach assertions to a design with `bind`.
Open reference →Explain the difference between code coverage and functional coverage; write covergroups with coverpoints and explicit bins; mark illegal and ignored values; cross coverpoints to measure combinations; choose when coverage is sampled; and use coverage results to drive test closure.
Open reference →Combine an interface, class-based components, constrained-random stimulus, a reference model, assertions and coverage into one environment for a synchronous FIFO; organise the run as a regression with recorded seeds; and assemble the evidence needed to sign off a block.
Open reference →A file that groups other files; compression is a separate operation.
Open reference →Follow the eight-week programme to connect individual concepts with design decisions, simulation, debugging and verification evidence.
Open the training plan