Randcase can be used in class or modules.

The randcase item expressions are non-negative integral values that constitute the branch weights.

An item weight divided by the sum of all weights gives the probability of taking that branch.

• Random Selection: The randcase structure allows the random selection of one out of multiple alternatives.
• Probabilities: The selection of different cases can be based on predefined probabilities.
• Procedural Block: randcase can be used inside procedural blocks (e.g., initial, always).

For example:
randcase
3 : x = 1;
1 : x = 2;
4 : x = 3;
endcase

The sum of all weights is 8; therefore, the probability of taking the first branch is (3/8)0.375, the probability

of taking the second is (1/8)0.125, and the probability of taking the third is (4/8)0.5.

If a branch specifies a zero weight, then that branch is not taken.

If all randcase_items specify zero weights, then no branch is taken and a warning can be issued.

The randcase weights can be arbitrary expressions, not just constants.

For example:
byte a, b;
randcase
a + b : x = 1;
a – b : x = 2;
a ^ ~b : x = 3;
12’b800 : x = 4;
endcase

In the preceding example, the first three weight expressions are computed using 8-bit precision, and the fourth

expression is computed using 12-bit precision.

The resulting weights are added as unsigned values using 12-bit precision. The weight selection then uses unsigned

12-bit comparison.

Each call to randcae statement will return a random number in the range from 0 to SUM.

$urandom_range(0,SUM) is used to generate a random number.

module rand_case;
integer x;
integer cnt_1, cnt_2, cnt_3;

initial begin
cnt_1 = 0;
cnt_2 = 0;
cnt_3 = 0;
repeat(100000) begin
randcase
3 : x = 1;
1 : x = 2;
4 : x = 3;
endcase
if(x == 1) begin
cnt_1++;
end
else if(x == 2) begin
cnt_2++;
end
else if(x ==3) begin
cnt_3++;
end
end
$display(“count_1 = %0d, count_2 = %0d, count_3 = %0d”, cnt_1, cnt_2, cnt_3);
$display(“Probability of count_1 = %0f, count_2 = %0f, count_3 = %0f”, (cnt_1/100000.0), (cnt_2/100000.0), (cnt_3/100000.0));
end
endmodule : rand_case

//Output:
// count_1 = 37378, count_2 = 12480, count_3 = 50142
// Probability of count_1 = 0.373780, count_2 = 0.124800, count_3 = 0.501420

The post What is Randcase in SystemVerilog? appeared first on Learn VLSI.

Conceptually, a semaphore is a bucket. When a semaphore is allocated, a bucket that contains a fixed number of keys is created. Processes using semaphores must first procure a key from the bucket before they can continue to execute.

 If a specific process requires a key, only a fixed number of occurrences of that process can be in progress simultaneously. All others must wait until a sufficient number of keys are returned to the bucket.

Semaphores are typically used for mutual exclusion, access control to shared resources, and basic synchronization.

Imagine that you and your spouse share a car. Obviously, only one person can drive it at a time. You can manage this situation by agreeing that whoever has the key can drive it. 

When you are done with the car, you give up the car so that the other person can use it. The key is the semaphore that makes sure only one person has access to the car.

In operating system terminology, this is known as “mutually exclusive access,” so a semaphore is known as a “mutex” and is used to control access to a resource.

Semaphores can be used in a testbench when you have a resource, such as a bus, that may have multiple requestors from inside the testbench but, as part of the physical design, can only have one driver.

In SystemVerilog, a thread that requests a key when it is not available always blocks the execution of that particular thread. Multiple blocking threads are queued in FIFO order.

Semaphore is a built-in class that provides the following methods:

— Create a semaphore with a specified number of keys: new()

— Obtain one or more keys from the bucket: get()

— Return one or more keys into the bucket: put()

— Try to obtain one or more keys without blocking: try_get()

The default value for keyCount is 0.

If the specified number of keys is not available, the get() method blocks process until the keys become available.

If the specified number of keys is not available, the try_get() method returns 0.

Types of Semaphores

1. Binary Semaphore:
   • Also known as a mutex (mutual exclusion).
   • Can take values 0 or 1.
   • Used to ensure that only one thread can access a resource at any given time.
2. Counting Semaphore:
   • Can take any non-negative integer value.
   • Used to control access to a pool of resources (e.g., a limited number of identical resources).

Uses of Semaphores

1. Mutual Exclusion: Semaphores can be used to protect critical sections of code, ensuring that only one thread can execute that section at a time. This is essential for maintaining data consistency when multiple threads access shared data.
2. Resource Management: Counting semaphores are useful for managing a finite number of resources, such as connections to a database or slots in a thread pool. They help keep track of available resources and allow processes to wait when resources are unavailable.
3. Event Counting: Semaphores can be used to signal the occurrence of events. For instance, one thread can signal a semaphore when a specific condition is met, allowing other waiting threads to continue execution.
4. Producer-Consumer Problems: In scenarios where one process produces data and another consumes it, semaphores help manage the synchronization between the producer and consumer, preventing race conditions and ensuring that the consumer waits when there is no data available.
5. Deadlock Prevention: Although semaphores can introduce complexity, they can also be part of strategies to prevent deadlocks when used thoughtfully with appropriate resource allocation protocols.

Example Use Case

Consider a simple example of a producer-consumer scenario:

• Producer: Adds items to a shared buffer.
• Consumer: Removes items from the buffer.

Using semaphores, we can ensure that the consumer waits if the buffer is empty and the producer waits if the buffer is full.

module top();
semaphore sema = new(1); // Create semaphore with 1 key.

initial begin
repeat(3) begin
fork
////////// PROCESS 1 ////////////////
begin
$display(“1: Waiting for key, time=%0t”, $time);
sema.get(1);
$display(“1: Got the Key, time=%0t”, $time);
#(10);// Do some work
sema.put(1);
$display(“1: Returning back key, time=%0t”, $time);
#(10);
end
////////// PROCESS 2 ////////////////
begin
#1;
$display(“2: Waiting for Key, time=%0t”, $time);
sema.get(1);
$display(“2: Got the Key, time=%0t”, $time);
#(10);//Do some work
sema.put(1);
$display(“2: Returning back key, time=%0t”, $time);
#(10);
end
join
$display();
end
#1000;
end
endmodule : top

//Output:
// 1: Waiting for key, time=0
// 1: Got the Key, time=0
// 2: Waiting for Key, time=1
// 1: Returning back key, time=10
// 2: Got the Key, time=10
// 2: Returning back key, time=20
//
// 1: Waiting for key, time=30
// 1: Got the Key, time=30
// 2: Waiting for Key, time=31
// 1: Returning back key, time=40
// 2: Got the Key, time=40
// 2: Returning back key, time=50
//
// 1: Waiting for key, time=60
// 1: Got the Key, time=60
// 2: Waiting for Key, time=61
// 1: Returning back key, time=70
// 2: Got the Key, time=70
// 2: Returning back key, time=80

Semaphores with Multiple Keys:

You can put more keys back than you took out. Suddenly you may have two keys but only one car!

Be careful if your testbench needs to get and put multiple keys. Perhaps you have one key left, and a thread requests two, causing it to block. Now a second thread requests a single semaphore – what should happen? In SystemVerilog the second request, get(1) , sneaks ahead of the earlier get(2) , bypassing the FIFO ordering.

The post What is Semaphore in sv? appeared first on Learn VLSI.

Full-time

Minimum Qualifications

• Bachelor’s degree in computer science, Electrical/Electronics Engineering, Engineering, or related field and 3+ years of Hardware Engineering or related work experience.
  

OR

Master’s degree in Computer Science, Electrical/Electronics Engineering, Engineering, or related field and 2+ years of Hardware Engineering or related work experience.

OR

PhD in Computer Science, Electrical/Electronics Engineering, Engineering, or related field and 1+ year of Hardware Engineering or related work experience.

• Experience: 7 to 10 years
• Physical design of block level with full understanding of PnR cycle.
• Good understanding of Physical design fundamentals
• Good hands-on experience on industry standard pnr tools like ICC2/Innovus
• Good understanding on signoff tool like Prime time , Redhawk and calibre
• Should be able to guide junior engineers in resolving technical issues.
• Tools : ICC/Innovus, PT, StarRC, Redhawk, Calibre DRC/LVS
• Scripting: TCL, Perl

The post Qualcomm Physical Design Engineer Job appeared first on Learn VLSI.

The post Hello world! appeared first on Learn VLSI.