Semaphores in SystemVerilog

🔑 Semaphores in SystemVerilog

#

Semaphores are a key built-in class in SystemVerilog that provide a flexible mechanism to control access to shared resources and synchronize processes. They’re widely used in verification environments to manage mutual exclusion, limit concurrency, and coordinate complex interactions between concurrent threads.

🗂️ What is a Semaphore?

#

Conceptually, a semaphore is like a bucket of keys:

• A semaphore is initialized with a certain number of keys.
• Processes must acquire a key from the bucket (using get()) before proceeding.
• When a process is done with its critical section, it returns the key to the bucket (using put()).

If all keys are taken, any additional process requesting a key will block until a key is available. This ensures that only a limited number of processes can proceed at the same time, effectively implementing mutual exclusion or concurrency control.

🛠️ Creating a Semaphore

#

Semaphores are created using the built-in semaphore class and the new() constructor.

semaphore sem;

// Create a semaphore with 2 keys
initial begin
  sem = new(2);
end

If you omit the argument to new(), the default key count is 0 (which blocks all processes until a key is explicitly put).

🚦 Using a Semaphore

#

🗝️ Acquiring a Key

#

Use the get() method to wait for a key from the semaphore.

sem.get(); // blocks until a key is available

You can also request more than one key:

sem.get(3); // waits for 3 keys

🔓 Releasing a Key

#

Use the put() method to return one or more keys to the semaphore.

sem.put(); // returns 1 key by default
sem.put(2); // returns 2 keys

⏳ Non-blocking Acquisition

#

Use the try_get() method to attempt to acquire keys without blocking.

if (sem.try_get()) begin
  // Proceed if successful
end else begin
  // Handle the case where no key was available
end

🔍 Summary of Key Methods

#

🛡️ Common Uses

#

• Mutual Exclusion: Limit access to shared resources (e.g., scoreboard, coverage collector).
• Concurrency Control: Limit the number of simultaneous transactions (e.g., concurrent accesses to a memory model).
• Resource Management: Manage testbench objects or bus drivers that are limited in quantity.

💡 Best Practices

#

✅ Always balance every get() with a corresponding put() to avoid deadlocks.
✅ Choose appropriate initial key counts to match the concurrency requirements of your environment.
✅ Use try_get() for non-blocking scenarios, like polling a resource availability.
✅ Document the intended usage of semaphores in your testbench to help maintenance and debugging.

📖 Conclusion

#

Semaphores are a powerful, built-in mechanism for controlling concurrency and synchronization in SystemVerilog. By properly applying semaphores, verification engineers can build robust and scalable testbenches that manage shared resources effectively.

module tb_semaphore_demo;

  // Define the semaphore object
  semaphore sem;

  // Shared data (critical section resource)
  logic [7:0] shared_data = 8'h00;

  // Clock generation
  logic clk = 0;
  always #5 clk = ~clk;

  // Initialize the semaphore with 1 key
  initial begin
    sem = new(1);
  end

  // Process A: increments shared_data
  initial begin
    repeat (3) begin
      sem.get();  // Acquire a key from the semaphore (enter critical section)
      $display("[Process A] Lock acquired at %0t", $time);

      // Critical section: modify shared_data
      shared_data += 8'h01;
      $display("[Process A] shared_data = %0h", shared_data);

      sem.put();  // Return the key to the semaphore (exit critical section)
      $display("[Process A] Lock released at %0t", $time);

      #10;  // Wait some time to allow other processes a chance
    end
  end

  // Process B: decrements shared_data
  initial begin
    repeat (3) begin
      sem.get();  // Acquire a key from the semaphore (enter critical section)
      $display("[Process B] Lock acquired at %0t", $time);

      // Critical section: modify shared_data
      shared_data -= 8'h01;
      $display("[Process B] shared_data = %0h", shared_data);

      sem.put();  // Return the key to the semaphore (exit critical section)
      $display("[Process B] Lock released at %0t", $time);

      #15;  // Wait some time to allow other processes a chance
    end
  end

  // End the simulation
  initial begin
    #100;
    $finish;
  end

endmodule