Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • Start Here6
  • SystemVerilog Language Foundations28
  • Object-Oriented SystemVerilog for Verification30
    • Classes, Objects & Handles
    • Inheritance and Polymorphism
    • Static, Encapsulation & Parameterized Classes
    • Virtual Interfaces: the Class-to-Pins Bridge
    • Events, Semaphores, Mailboxes and Processes
      • Events: Edge Waits and Level Fixes
      • Semaphores: One Key and Many
      • Mailboxes: Typed Pipes with Backpressure
      • Threads and Control: Fork, Disable, Wait, Process
      • Synchronization Patterns: Handshakes, Phasing and Objections
      • Lab: Generator-to-Driver Handshake
    • OOP Patterns for Testbenches
  • Constraint Randomization — Interview-Critical Deep Dive36
  • SystemVerilog Assertions — Interview-Critical Deep Dive40
  • Functional Coverage in SystemVerilog22
  • Testbench Architecture in SystemVerilog23
  • Advanced Language & Integration25
  • Senior & Interview Preparation21
  • Principal-Level Verification28
Loading lesson

‹Object-Oriented SystemVerilog for Verification
  1. Topics
  2. SystemVerilog
  3. Object-Oriented SystemVerilog for Verification
  4. Events, Semaphores, Mailboxes and Processes

Part 2 · OOP for Verification · Intermediate

Events, Semaphores, Mailboxes and Processes

Events, semaphores, mailboxes, threads and bench sync patterns in one place.

  • 6topics
  • 6lessons

A testbench is a set of concurrent processes that must share data, arbitrate resources and agree when the test is over. SystemVerilog provides three primitives for this, event, semaphore and mailbox, plus the fork family and process handles for thread control.

Three primitives, three jobs: a mailbox moves data, an event marks a moment, a semaphore shares a resource.

Primitive

Carries data

Blocking

Typical use

event

No

@ and wait block

Done flags, phase sync

semaphore

No, keys only

get blocks

Resource arbitration

mailbox

Yes

put and get block

Producer-consumer pipes

Lesson

What it covers

Events: Edge Waits and Level Fixes

Trigger versus wait, triggered, handle passing and wait_order.

Semaphores: One Key and Many

Keys, bus arbitration, deadlock and backoff fixes.

Mailboxes: Typed Pipes with Backpressure

Bounded versus unbounded, typed handles and sizing.

Threads and Control: Fork, Disable, Wait, Process

Join variants, loop capture, disable fork, wait fork and process.

Synchronization Patterns: Handshakes, Phasing and Objections

Completion counters, objections with drain, races and barriers.

Lab: Generator-to-Driver Handshake

A deterministic bench tying every primitive together.

Check yourself A generator must hand items to a driver, two drivers share one bus, and the test must end exactly when all checking is done. Which primitive does each job?

Mailbox for the items, semaphore for the bus, and an objection counter or completion counter for end of test. Events only signal moments, so they cannot carry the items or arbitrate the bus.

Interview

This topic is interview-dense. Expect the trigger-before-wait race, AB-BA semaphore deadlock, mailbox handle aliasing, the fork loop-capture bug and the disable fork blast radius, each as a short code sketch.

PreviousNext: Events: Edge Waits and Level Fixes

Up next

Up nextEvents: Edge Waits and Level Fixes

Sign in to save progress

Practice this lessonReport an error

See also

  • Classes, Objects & Handles
  • Inheritance and Polymorphism
  • Static, Encapsulation & Parameterized Classes