Interprocess communication#

Interprocess communication (IPC) is a set of programming interfaces that allow a programmer to coordinate activities among different program processes that can run concurrently in an operating system. This allows a program to handle many user requests at the same time

Cheat Sheet#

1-Events#

Event is used for synchronization between two or more concurrently active processes. Initially, we need to declare the event and then it needs to be triggered by using the -> or -» operator.

Processes can wait for the event by using the @ operator or wait(event_name.triggered). when both @ and wait comes at the same point then a race-around condition occurs in between both.

Create an event:-

event e;

Triggering the event:-

->e;

Wait for the event to be triggered:-

@e;  
or  
wait(e.triggered);  

Difference between @ and wait operator:#

Generally both the @ and wait operators are used to waiting for an event to be triggered. The main difference between @ and wait is that when waiting of an event and triggering of an event takes place at same time then @ cannot detect the triggering where as wait can detect the triggering of the event and then executes .Lets see the difference between @ and wait with a code below .

code snippet:

module wait_example;
  event e;
  initial begin 
    $display($time,"\t triggering the event");
    ->e;
  end 
  initial begin
    $display($time,"\t waiting for the event using wait");
    wait(e.triggered);
    $display($time,"\t event is triggered using wait");
  end
  initial begin
    $display($time,"\t waiting for the event using @");
    @(e.triggered);
    $display($time,"\t event is triggered using @");
  end
endmodule

In the code triggering and waiting of an event takes place at same time at 0ns.wait will trigger the event whereas “@” cannot detect the triggering
code output:

In the output we can see that triggering and waiting of an event takes place at same time at 0ns then wait can detect the triggering so it displays the statement ’event is triggered using wait “where as @ cannot detect the triggering so the display statement below @ is not executed.

wait_order():#

wait_order() method is used to specify the events to be triggered in a particular order. It block the processes until all the events are triggered in the specified order.

syntax:

wait_order(event_1,event_2….event_n);

Example:

event e1;     
event e2;  
event e3; 
wait_order(e1,e3,e2); 

In the above example the events will get triggered in the order e1 then e3 and then e2 ,then only process gets executed otherwise it block the process. If we have specified the order and events are not executed in the order then run time error is generated. To avoid this error we can use else statement so we can get user message under else if events are not triggered in the order. Lets see with example

Example:
wait_order(e1,e3,e2)
else display("events are out of order");

In this example, if events are not triggered in the given order a user message in else statement is displayed, instead of run time error being generated.

code snippet:

module wait_order;
  event e1; //declaring event e1
  event e2; //declaring event e2
  event e3; //declaring event e3
  
  initial begin
    fork
      //process-1, triggers the event e1
      begin
        #6;
        $display($time,"\tTriggering The Event e3");
        ->e3;
      end
      //process-2, triggers the event e2
      begin
        #2;
        $display($time,"\tTriggering The Event e1");
        ->e1;
      end
      //process-3, triggers the event e3
      begin
        #8;
        $display($time,"\tTriggering The Event e2");
        ->e2;
      end
      //process-4, wait for the events to trigger in order of e1,e3 and e2
      begin
        $display($time,"\tWaiting for the Event's to trigger");
        wait_order(e1,e3,e2)
          $display($time,"\tEvent's triggered Inorder");
        else
          $display($time,"\tEvent's triggered Out-Of-Order");
      end
    join
  end
endmodule  

In the above code events e1,e2,e3 are declared, using wait_order we are specifying the events to be triggered in the order e1,e3,e2.so only if events are trigerred in the given order e1->,e3->,e2 then only the statement below wait_order executes otherwise else statement will execute.

code output:

Merging events#

In merging events one event variable is assigned to another variable then another event variable is also triggered at same time when first event is triggered due to merging. It means when second event variable is assigned to first event variable then second event variable waits and block the processes until the first event variable is triggered.

syntax:

event variable 1=event variable 2;

Example:

event a;
event b;
event b=a; // Merging events a and b  

code snippet :

module merge_events;
  event a,b;
  initial begin
    fork
    #50 ->a; 
    #30 ->b;
    #20 b = a;
      begin 
        wait(a.triggered);
        $display("[%0t] event a is done",$time);
       end    
         begin 
           wait(b.triggered);
           $display("[%0t] event b is done ",$time);
         end
    join
  end
endmodule  

In the above code events a,b are declared then a,b events are merged by b=a.

code output:

Blocking and Nonblocking events:#

Blocking event#

Generally blocking events are triggered using -> operator. Blocking events work in active region so when waiting of an event and triggering of an event takes place at same time then @ operator block the process still event is triggered so in this way -> operator block the events when waiting of an event and triggering of an event takes place at same time .But we can use wait operator to avoid this blocking.

syntax:

-> event name

Example:

event BJT;  
-> BJT; // event triggered using blocking triggering// 

code snippet:

module blocking_event;
  event BJT;
  initial begin 
    $display($time,"\t triggering the event");
    ->BJT;
  end 
  initial begin
    $display($time,"\t waiting for the event using wait");
    wait(BJT.triggered);
    $display($time,"\t event BJT is triggered using wait");
  end
  initial begin
    $display($time,"\t waiting for the event using @");
    @(BJT.triggered);
    $display($time,"\t event BJT is triggered using @");
  end
endmodule  

code output:

As event BJT is declared using blocking triggering -> BJT.AS blocking triggering and @ both work in active region so when triggering and waiting of an event takes place at same time at 0ns by using @ operator it block the statement “event BJT is triggered using @”, below @(BJT.triggered)But we can use wait(BJT.triggered) to detect the triggering so it displays the statement “event BJT is triggered using @”.

Non blocking event#

Non blocking event is triggered using -» operator. As non blocking event triggering works in non blocking region and wait or @ works in active region so even though when waiting of an event and triggering of an event takes place at same time so @ does not blocks the process so –> is called as non blocking triggering. This is the difference between blocking and non blocking events.

syntax:

->>event name

Example:

event BJT;  
->> BJT; // event triggered using non blocking triggering// 

code snippet

module non_blocking;
  event BJT;
  initial begin 
    $display($time,"\t triggering the event");
    ->>BJT;
  end 
  initial begin
    $display($time,"\t waiting for the event using wait");
    wait(BJT.triggered);
    $display($time,"\t event BJT is triggered using wait");
  end
  initial begin
    $display($time,"\t waiting for the event using @");
    @(BJT.triggered);
    $display($time,"\t event BJT is triggered using @");
  end
endmodule  

In the above code event BJT is declared using non blocking triggering -»BJT so even though when waiting of an event and triggering of an event takes place at same time so @ does not blocks the process as non blocking triggering works in non blocking region where @ works in active region so @ unblock the process below the @(BJT.triggered);

code ouput:

2-Semaphores#

Semaphore is a built-in class which is provided in the built-in std package of System Verilog. A semaphore allows you to control access to a resource. Conceptually, a semaphore is a bucket. When a semaphore is allocated, a bucket that contains a fixed number of keys is created. With help of semaphore method key can be gets or puts key into the bucket(semaphores).
In an analogy, semaphore can be understood as a bike rentals shop from where we can use bikes(keys) and the other person(thread/process) can only use the bikes if they are available. And they(thread/process) should wait till the previous bikes are returned.

Now we’ll see how to use semaphores in System Verilog.

Syntax:

semaphore semaphore_name;

Methods:#

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

I. new()
II. get()
III. put()
IV. try_get()

I-new() :#

This method is used to create a semaphore with particular number of keys.

Syntax:

semaphore_name=new(n);

Here, key count(i.e., n) is an integer. By default, n=0. If a semaphore is not created properly it returns null.

Key count is the value that is initially given to the semaphore. If wanted, one can also increase the keys in semaphore by putting more keys (using put() method) into semaphore than the removed number of keys.

II-get()#

get() is used to get specified number of keys from the semaphore.

Syntax:

semaphore_name.get(m);

By default, m=1.

If the keys are not available for a thread/process(i.e., if any other thread/process is using the keys of semaphore), it will wait till the keys get back to the semaphore and then executes it’s action.

III-put()#

This method is used to return it’s keys to the semaphore.

Syntax:

semaphore_name.put(k);

By default, k=1.

Example:

Below is the example of how to create a handle of semaphore and keys in it and how to get and put keys into the semaphore using the above mentioned methods.

Code snippet:

In the below example we try to find what would happen if a process returns only some of the keys it procured and put the remaining later.

  module semaphore_example_1;
 
     semaphore sem=new(6);
 
     initial begin :BEGIN_I
        $display("In first initial block At time=[%0t] ",$time);
        sem.get(4);
        $display("Thread 1:Accessing 4 keys from semaphore At time=[%0t] ",$time);
        #5;
        sem.put(4);
        $display("Thread 1:Done using 4 keys At time=[%0t] ",$time);
     end :BEGIN_I
 
     initial begin :BEGIN_II
        $display("In second initial block At time=[%0t] ",$time);
        sem.get(2);
        $display("Thread 2:Accessing 2 keys from semaphore At time=[%0t] ",$time);
        #10;
        sem.put(2);
        $display("Thread 2:Done using 2 keys At time=[%0t] ",$time);
     end :BEGIN_II
 
  endmodule :semaphore_example_1

Output:
On above code we create 6 key. At a 0ns time in process-1 get 4 keys from semaphore and in process-2 get 2 keys.Then after time 5ns in process-1 we put 4 keys in semaphore and at time 10ns process-2 put 2 keys in semaphore.

Github lab link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example1/sema_exm1.sv
Githhub logfile link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example1/sema_exm1.log

Example-2:

code snippet:

In below code we try to explain what happen if we try to get more key than the available key

  module semaphore_exm_2;
 
     semaphore sem=new(6);
 
     initial begin :BEGIN_I
        $display("In first initial block At time=[%0t]",$time);
        sem.get(4);
        $display("Thread 1:Accessing 4 keys from semaphore  At time=[%0t]",$time);
        #5;
        sem.put(2);
        $display("Thread 1:Done using 2 keys  At time=[%0t]",$time);
        #20;
        $display("Thread 1:Still using the remaining 2 keys  At time=[%0t]",$time);
     end :BEGIN_I
 
     initial begin :BEGIN_II
        $display("In second initial block  At time=[%0t]",$time);
        sem.get(5);
        $display("Thread 2:Accessing 5 keys from semaphore  At time=[%0t]",$time);
        #10;
        sem.put(5);
        $display("Thread 2:Done using 5 keys  At time=[%0t]",$time);
    end :BEGIN_II
 
  endmodule :semaphore_exm_2

Output:

On above code we create 6 keys. At time 0ns process-1 get 4 keys from semaphore and process-2 try to get 5 key from semaphore but at a time only 2 keys are available so it block the next statement until 5 keys are available in semaphore. Then at 5ns time process-1 put 2 keys in semaphore and at time 4 keys are available in semaphore so process-2 again wait. At a 25ns time process-1 still using keys and process-1 is end but in semaphore only 4 keys are available so process-2 can not be execute.

Github lab link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example2/sema_exm2.sv
Github logfile link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example2/sema_exm2.log

IV-try_get()#

This method is also used to get specified number of keys from the semaphore. But unlike get() method, if keys are unavailable it will not wait and returns 0 and the next step executes.

Syntax:

semaphore_name.try_get(j);

By default, j=1.

If the specified number of keys are available, the method returns 1 and execution continues
If the specified number of keys are not available, the method returns 0 and execution continues

code snippet:

This code helps in understanding how to use try_get() method and what makes it different from get() method.

 module semaphore_exa_get_try;
 
     semaphore car_key = new(1);
 
     initial begin :BEGIN_I
 
        fork
 
         begin :BEGIN_I_FORK
            $display("person A Waiting for car, time=%0t", $time);
            car_key.get(1);
            $display("person A Got the car, time=%0t", $time);
            #10;
            car_key.put(1);
            $display("person A Returning back car, time=%0t", $time);
         end :BEGIN_I_FORK
 
         begin :BEGIN_II_FORK
            #1;
            $display("person B Waiting for car, time=%0t", $time);
            void'(car_key.try_get(1));
            $display("person B Got the car, time=%0t", $time);
            #10;
            car_key.put(1);
            $display("person B Returning back car, time=%0t", $time);
         end :BEGIN_II_FORK
 
       join
 
    end :BEGIN_I
 
  endmodule:semaphore_exa_get_try

Output:

On above code we create a 1 key. At time 0ns person A waiting for key and get a key from semaphore. At 1ns time person B waiting for key and 1ns there no key in semphore but here use try_get methos so it do not block the next statement so at 1ns it display person B Got the car.At the 10ns time in process-1 put the key and dispaly Person A returning back car.At 11ns time in process-2 put the key and display person B returning back car.

Github lab link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example3/sema_exm3.sv
Github logfile link: https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/semaphore/sema_example3/sema_exm3.log

3-Mailbox#

A System-Verilog mailbox is a way of communication between different processes to exchange data. One process can put data into a mailbox that stores data internally and can be retrieved by another process. Mailbox behaves as first-in, first-out (FIFO).

Types in mailbox#

Mailbox is classified into two types.

      Fig-1 Types in mailbox

Based on size, mailbox can take two forms :-
1.Bounded
2.Unbounded

Generic Mailbox#

The generic mailbox can be put or get data of any data type like int, bit, byte, string, etc. By default, the mailbox is a type-less or generic mailbox.

Syntax

mailbox <mailbox_name>;

I. Bounded#

If the size of the mailbox is defined then it is a bounded mailbox. When the mailbox is full, no further data can be put in the mailbox until an item or data is get from the mailbox.

Syntax:-

mailbox <mailbox_name> = new(size);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i =0;i<3;i++)begin:BEGIN_MAIN

         if(m.num()==2)begin:BEGIN_1
         $display("mailbox is full");

      end:BEGIN_1

      else
         begin:BEGIN_2

            a++;
            m.put(a);
            $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

         end:BEGIN_2

      end:BEGIN_MAIN

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

      task rec_data();

         begin:BEGIN_MAIN

            m.get(a);
            $display("[%0t] 2. Receiver: value of a = %0d",$time,a);
         end:BEGIN_MAIN
 
   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox mb = new(2);

   initial begin:BEGIN_MAIN

      a1 = new(mb);
      b1 = new(mb);
      repeat(3)

      begin:BEGIN_1
         
         a1.tra_data();
         $display("...............................................");
         b1.rec_data();

      end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-2 Output of Bounded Mailbox  

In the above fig, you can see that a Class A was created which transmits 3 data’s at a time. We are checking whether the mailbox is full or not by num method. As in module we bounded our mailbox to 2, it will transmit two data, but for third data it shows mailbox is full as there is no space in it. For receiver since we restricted it to receive only one data at a time, it will be receiving only one data.This process repeats for 3 times as we have given repeat(3) in module.

Know more about num():- https://github.com/muneeb-mbytes/SystemVerilog_Course/wiki/19.Interprocess-Communication#2-num

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/genric_mailbox/bounded_mailbox/bound.sv
Github logfile link:-https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/genric_mailbox/bounded_mailbox/bound_op.log

II. Unbounded#

If the size of the mailbox is not defined then it is a unbounded mailbox.

Syntax:-

mailbox <mailbox_name> = new();

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i =0;i<3;i++)begin:BEGIN_MAIN

         a++;
         m.put(a);
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

      begin:BEGIN_MAIN

         m.get(a);
         $display("[%0t] 2. Receiver: value of a = %0d",$time,a);

      end:BEGIN_MAIN


   endtask

endclass:B


module tb();

   A a1;
   B b1;
   mailbox main = new();

   initial begin:BEGIN_MAIN
      
      a1 = new(main);
      b1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();
         $display("...............................................");
         b1.rec_data();

      end:BEGIN_1

    end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-3 Output of Unbounded Mailbox  

In the above fig, you can see that a Class A was created which transmits 3 data’s at a time. Unlike bounded ,as it will have unlimitted size it can take all the three data at a time and transmit them and the receiver only receive one data and after it receives next set of fresh three data comes in(since used repeat(3)) as it is unbounded.

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/genric_mailbox/unbounded_mailbox/unbound.sv
Github logfile link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/genric_mailbox/unbounded_mailbox/unbound_op.log

Parameterized Mailbox#

The parameterized mailbox can be put or get data of particular data type. The parameterized mailbox is useful when data type needs to be fixed. For differences in data type, a compilation error will occur.

Syntax:-

mailbox #(<type>) <mailbox_name>

Code snippet:-

class A;
   int i;
   string country;
   string place;

   mailbox #(string) m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      country = "India";
      place = "Kashmir";
      m.put(country);
      m.put(place);
      $display("Transmitter: Country = %0s , must visit place = %0s",country,place);

      country = "South Africa";
      place = "Cape Town";
      m.put(country);
      m.put(place);
      $display("Transmitter: Country = %0s , must visit place = %0s",country,place);

      country = "Spain";
      place = "Barcelona";
      m.put(country);
      m.put(place);
      $display("Transmitter: Country = %0s , must visit place = %0s",country,place);

   endtask

endclass:A

class B;

   string country;
   string place;
   mailbox #(string) m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

       m.get(country);
       m.get(place);
       $display("Receiver: Country = %0s , must visit place = %0s",country,place);

        m.get(country);
        m.get(place);
        $display("Receiver: Country = %0s , must visit place = %0s",country,place);

        m.get(country);
        m.get(place);
        $display("Receiver: Country = %0s , must visit place = %0s",country,place);
   endtask

endclass:B

module  tb();

   A a1;
   B b1;
   int i;
   mailbox #(string) main = new(6);
   initial begin:BEGIN_MAIN

      a1= new(main);
      b1 = new(main);
      $display("");
      $display("");
      a1.tra_data();
      $display(".......................................................................");
      b1.rec_data();

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-4 Output of Parameterized Mailbox  

In the above fig, you can see that we had fixed our mailbox to string data type. Took two strings country and place and bounded the mailbox to size 6. Since the mailbox is of string type we will pass string values India, kashmir, South Africa ,Cape Town, Spain and Barcelona only. If any other data type it will throw compilation error.

Github lab link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/parameterized_mailbox/para_mailbox.sv
Github logfile link :-https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/parameterized_mailbox/para_op.log

Methods in Mailbox#

I. new#

Mailboxes are created by this method.

Syntax:-

mailbox <mailbox_name> = new(size); // creates a bounded mailbox

mailbox <mailbox_name> = new(); // creates an unbounded mailbox

Code snippet:-

class A;

   int a;
   int i;
   mailbox  m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task check();

      if(m == null)begin:BEGIN_1
         $display("Mailbox is not created");
      end:BEGIN_1

      else
         $display("Mailbox is created");

         for(i=0;i<3;i++)begin:BEGIN_2

            a++;
            m.put(a);
            $display("Value of a = %0d",a);

         end:BEGIN_2

    endtask

endclass:A

module  tb();

   A a1;
   mailbox main = new(3);
   initial begin:BEGIN_MAIN

      a1= new(main);
      $display("");
      $display("");
      a1.check();

    end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-5 Output of new_method  

In the above fig, we created a bounded mailbox of size 3 and we are checking it whether it has been created or not. Since it has been created we transmitted 3 data into it.

Github lab link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/new_method/bounded/new_md.sv
Github logfile link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/new_method/bounded/new_op.log

II. num#

This method returns the no of messages present in a mailbox.

Syntax:-

<mailbox_name>.num();

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
  endfunction

  task tra_data();

     for(i =0;i<3;i++)begin:BEGIN_MAIN

        a++;
        m.put(a);
        $display("[%0t] Transmitter: value of a = %0d",$time,a);
        $display(" No of messages in mailbox = %0d",m.num());

      end:BEGIN_MAIN

      $display(".....................................................");

   endtask

endclass:A

module tb();

   A a1;
   mailbox main = new();

   initial begin:BEGIN_MAIN

      a1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();

    end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb 

Output:-

      Fig-6 Output of num_method  

In the above fig, you can see that we had created an unbounded mailbox and we are transmitting three data’s at a time. Since it is unbounded we don’t have any restrictions we can transmit all the data. Now for the first time of transmission, the passed values of a are 1, 2, 3 and the no of messages are three which can be seen by num() method. We repeated the process for two times so that we are able to pass 4, 5, 6 and now the no of messages in mailbox is 6.

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/num_method/num.sv
Github logfile link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/num_method/num_op.log

III. put#

This method stores the data into the mailbox in FIFO order. It will block the process if mailbox is full.

Syntax:-

<mailbox_name>.put(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i =0;i<4;i++)begin:BEGIN_MAIN

         m.put(a);
         #1 a++;
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display(".....................................................");

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

  function new(mailbox m2);
     this.m = m2;
  endfunction

  task rec_data();

     begin:BEGIN_1

        m.get(a);
        $display("[%0t] 2. Receiver: value of a = %0d",$time,a);

     end:BEGIN_1

   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(3);

   initial begin:BEGIN_MAIN

      a1 = new(main);
      b1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();
         $display("................................................................");
         b1.rec_data();

      end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-7 Output of put_method  

In the above fig, you can see that mail box is of size 3 but we are trying to pass 4 data, since put is a blocking task it will not allow other task to perform until or unless it gets the fourth data, which is not possible(since size of mailbox is 3), so the program gets terminated.

Github lab link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/put_method/put.sv
Github logfile link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/put_method/put_op.log

IV. get#

This method can retrieve one message from the mailbox, if mailbox is empty it will block the process.

Syntax:-

<mailbox_name>.get(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i =0;i<2;i++)begin:BEGIN_MAIN
         a++;
         m.put(a);
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display("put successful");

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

      for(i =0;i<3;i++)begin:BEGIN_MAIN

         m.get(a);
         $display("[%0t] 2. Receiver: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display("get successful");
   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(2);

   initial begin:BEGIN_MAIN

      a1 = new(main);
      b1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();
         $display("...............................................");
         b1.rec_data();
      end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-8 Output of get_method  

In the above fig, you can see that mail box is of size 2 and we are trying to pass 2 data but at receiver side we are trying to receive 3 data at a time. So it will first receive 2 data as size is 2 and keeps on waiting for the other data. Since it is not possible it will terminate the program and will not print $display(“get successful”) line.

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/get_method/get.sv
Github logfile link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/get_method/get_op.log

V. try_put#

This method tries to put the data in a non blocking manner to store a message in the mailbox if not full. If successful returns 1 else 0.

Syntax:-

<mailbox_name>.try_put(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

  task tra_data();

     for(i =0;i<4;i++)begin:BEGIN_MAIN

        a++;
        if( m.try_put(a))
           $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);
        else
           $display("failed while trying to put data=%0d",a);

    end:BEGIN_MAIN
    $display(".....................................................");
    
  endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

      repeat(3) begin
         m.get(a);
         $display("[%0t] 2. Receiver: value of a = %0d",$time,a);
      end

   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(3);

   initial begin:BEGIN_MAIN

      a1 = new(main);
      b1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();
         b1.rec_data();

      end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-9 Output of try_put_method  

In the above fig, you can see that mail box is of size 3 but we are trying to pass 4 data, unlike put_method(which blocks the next set of execution),it will not block, but execute the next set of program. As you can see even though the mailbox is full it will go to next set of statements and prints $display(failed to get the value) statement.

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_put_method/try_put.sv
Github logfile link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_put_method/try_put_op.log

VI. try_get#

This is a non-blocking method which tries to get one message from the mailbox, returns 0 if mailbox is empty.

Syntax:-

<mailbox_name>.try_get(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i =0;i<4;i++)begin:BEGIN_MAIN

         a++;
         m.put(a);
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display("put successful");

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

      repeat(5)begin:BEGIN_MAIN

         if( m.try_get(a))
            $display("[%0t] 2. Receiver: value of a = %0d",$time,a);

         else
            $display("Failed while getting the value as mailbox is empty ");

      end:BEGIN_MAIN

      $display("get successful");

   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(4);

   initial begin:BEGIN_MAIN

      a1 = new(main);
      b1 = new(main);
      repeat(2)
      begin:BEGIN_1

         a1.tra_data();
         $display("...............................................");
         b1.rec_data();
       end:BEGIN_1

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-10 Output of try_get_method  

In the above fig, you can see that mail box is of size 4 but we are trying to pass 4 data, but at receiver side we are trying to get 5 data at a time. So at first we are transmitting a values 1,2,3,4 and at receiver side we are waiting for the fifth data as well. Since it is non blocking method, it will go to the next set of execution and prints (“get successful”).

Github lab link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_get_method/try_get.sv
Github logfile link:- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_get_method/try_get_op.log

VII. peek#

This method copies one message from the mailbox without removing the message from the mailbox queue.

Syntax:-

<mailbox_name>.peek(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i=0;i<1;i++)begin:BEGIN_MAIN

         a++;
         m.put(a);
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display("put successful");
      $display("Messages in mailbox = %0d",m.num());

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
    endfunction

   task rec_data();

      for(i =0;i<2;i++)begin:BEGIN_MAIN
         m.peek(a);
         $display("[%0t] Peeking value of a = %0d",$time,a);
         $display("Peek successful");
    
      end:BEGIN_MAIN

      m.get(a);
      $display("[%0t] 2. Receiver: value of a = %0d",$time,a);
      $display("get successful");
      $display("Messages in mailbox = %0d",m.num());
   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(2);

   initial begin:BEGIN_MAIN

     a1 = new(main);
     b1 = new(main);
     a1.tra_data();
     $display("...............................................");
     b1.rec_data();
     $display("...............................................");
     b1.rec_data();
     $display("End of program");

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-11 Output of peek_method  

In the above fig, you can see that mail box is of size 2 but we are transmitting only 1 data, but at receiver we are peeking(copy) the transmitted value twice (a =1). Now the mailbox is empty, since Peek is a blocking task, when we tried calling bi.rec_data() again it will block all statements after m.peek(a) and so will not display End of program.

Github lab link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/peek_method/peek.sv
Github logfile link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/peek_method/peek_op.log

VIII. try_peek#

This method tries to copy data from mailbox without removing it from mailbox.

Syntax:-

<mailbox_name>.try_peek(arguments);

Code snippet:-

class A;

   int a;
   int i;
   mailbox m;

   function new(mailbox m1);
      this.m = m1;
   endfunction

   task tra_data();

      for(i=0;i<1;i++)begin:BEGIN_MAIN

         a++;
         m.put(a);
         $display("[%0t] 1. Transmitter: value of a = %0d",$time,a);

      end:BEGIN_MAIN

      $display("put successful");
      $display("Messages in mailbox = %0d",m.num());

   endtask

endclass:A

class B;

   int a;
   int i;
   mailbox m;

   function new(mailbox m2);
      this.m = m2;
   endfunction

   task rec_data();

     for(i =0;i<2;i++)begin:BEGIN_MAIN

        if( m.try_peek(a)) begin:BEGIN_1
           $display("[%0t] Peeking value of a = %0d",$time,a);
           $display("Peek successful");

        end:BEGIN_1
        else
           begin

              $display("Peek failed as mailbox is empty");
              return;
           end
     end:BEGIN_MAIN

     m.get(a);
     $display("Receiver: value of a = %0d",a);
     $display("get successful");

   endtask

endclass:B

module tb();

   A a1;
   B b1;
   mailbox main = new(2);

   initial begin:BEGIN_MAIN

      a1 = new(main);
      b1 = new(main);
      a1.tra_data();
      $display("...............................................");
      b1.rec_data();
      $display("...............................................");
      b1.rec_data();
      $display("End of program");

   end:BEGIN_MAIN

endmodule:tb

Output:-

      Fig-12 Output of try_peek_method  

In the above fig, you can see that mail box is of size 2 but we are transmitting only 1 data, but at receiver we are peeking(copy) the transmitted value twice (a =1). Now the mailbox is empty, since try_peek is a blocking task, when we tried calling bi.rec_data() again it will try peeking the value. As the mailbox is empty it will print peek is failed and now End of program will also get executed.

Github lab link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_peek_method/try_peek.sv
Github logfile link :- https://github.com/muneeb-mbytes/SystemVerilog_Course/blob/production/Interprocess_communications/mailbox/methods_in_mailbox/try_peek_method/try_peek_op.log