UVM / System Verilog - Threads and Synchronization.

• In SystemVerilog, when you instantiate static modules, you create multiple threads running the procedures within each instances.
• Synchronization
• Mailbox
• Streams
• Semaphore
• Use Ports, Exports and TLM_FIFOs
• uvm_put_port # (int) p1;
  p1 = new("put_port", this);
• uvm_get_port #(int) p2;
• uvm_tlm_fifl #(int) p3;
• m1.p1.connect (p3.put_export);
  m2.p2.connect (p3.get_export);

// in f1.svh, for class c1
   uvm_put_port # (int) p1;
   p1 = new("put_port", this);
// in f2.svh, for class c2
   uvm_get_port #(int) p2;
   p2 = new("p2", this);
// in f3.svh, which contains the 
//     test env for c1 and c2
   uvm_tlm_fifo #(int) p3;
   p3 = new("p3", this);
   c1.p1.connect (p3.put_export);
   c2.p2.connect (p3.get_export0;

// c1.p1 -> (put_export of env)
//               ->(p3)->
//          (get_export of env) -> c2.p2

   
endtask : run

• Put shared variable in a package, together with all the classes that share that variable (using `include);

virtual task run();
   integer i;
   for (i = 1; i < cnt; i++) begin : loop
      uvm_report_info ("run", $psprintf(...));
      my_pkg::shared = i; // used by other classes 
                          // for synchronization
      // i = my_pkg::shared; // to read from the shared
   end : loop
endtask : run

• Blocking Methods vs Non-Blocking Methods
• blocking method
• myport.put(<data>);
• myport.get(<data>);
• non-blocking method (returns 0 if failed)
• myport.try_put();
• myport.try_get();

Example

class c1 extends uvm_agent;
   uvm_put_port #(int)p1;
   `uvm_component_utils(c1)

   function new...

   virtual function void build_phase (uvm_phase phase);
      super.build_phase(phase);
      p1 = new("p1", this);
   endfunction : build_phase

   virtual task run_phase (uvm_phase phase);
      phase.raise_objection(this);
      for (int i = 0; i < cnt; i++) begin
         p1.put(i);
         uvm_report_info("run_phase",...);
      end : loop
      phase.drop_objection(this);
   endtask : run_phase
endclass : c1

class c2 extends uvm_agent;
   uvm_put_port #(int)p2;
   `uvm_component_utils(c2)

   function new...

   virtual function void build_phase (uvm_phase phase);
      super.build_phase(phase);
      p2 = new("p2", this);
   endfunction : build_phase

   virtual task run_phase (uvm_phase phase);
      int i;
      forever begin : loop
         p2.get(i);
         uvm_report_info("run_phase",...);
      end : loop
   endtask : run_phase
endclass : c2

class c3 extends uvm_agent;

   `uvm_component_utils(c3)

   c1 p1;
   c2 p2;
   uvm_tlm_fifo #(int) p3;

   function new...

   virtual function void build_phase (uvm_phase phase);
      super.build_phase(phase);
      p1 = c1::type_id::create("p1", this);
      p2 = c2::type_id::create("p2", this);
      p3 = new("p3", this);
   endfunction : build_phase

   virtual function void connect_phase (uvm_phase phase);
      super.connect_phase(phase);
      c1.p1.connect(p3.put_export);
      c2.p2.connect(p3.get_export);
   endfunction : connect_phase

   virtual task run_phase (uvm_phase phase);
   endtask : run_phase

endclass : c3

Example : Blocking Communication vs Non-blocking Communication

// blocking
// @(posedge clk); // this could be missed 
//                   and block the following
// my_port.get(data);
// bus <= data; 

// non-blocking
// @(posedge clk)
// my_port.try_get(data); // won't suspend
// bus <= data;
//

class c1 extends uvm_agent;

   `uvm_component_utils(c1)
   uvm_put_port #(int)p1;

   function new...

   virtual function void build_phase (uvm_phase phase);
      super.build_phase(phase);
      p1 = new("p1", this);
   endfunction : build_phase

   virtual task run_phase (uvm_phase phase);
      phase.raise_objection(this);
      for (int i = 0; i < cnt; i++) begin
         // p1.put(i);
         // uvm_report_info("run_phase",...);
         #UNIT_DELAY; // to delay this thread so the following
                      // is always slower than p2 and 
                      // should never fail
         assert (p1.try_put(i)) else
            uvm_report_info("run_phase: p1 not connected");
         uvm_report_info("run_phase", $psprintf("put: %0d",i));
      end : loop
      phase.drop_objection(this);
   endtask : run_phase
endclass : c1

class c2 extends uvm_agent;

   `uvm_component_utils(c2)
   uvm_put_port #(int)p2;

   function new...

   virtual function void build_phase (uvm_phase phase);
      super.build_phase(phase);
      p2 = new("p2", this);
   endfunction : build_phase

   virtual task run_phase (uvm_phase phase);
      int i;
      forever begin : loop
         // p2.get(i);
         // uvm_report_info("run_phase",...);
         if (p2.try_get(i))
            uvm_report_info ("run",
               $psprintf ("got: %0d",i));
         else
            uvm_report_info ("run","got nothing");
      end : loop
   endtask : run_phase
endclass : c2

OOP Programming Terms.

CRUD versus REST

CRUD means the basic operations to be done in a data repository. You directly handle records or data objects; apart from these operations, the records are passive entities. Typically it's just database tables and records. It is a simple term that was abbreviated because it's a common feature in many applications, and it's easier to say CRUD. It describes the 4 basic operations you can perform on data (or a resource). Create, Read, Update, Delete.

REST, on the other hand, operates on resource representations, each one identified by an URL. These are typically not data objects, but complex objects abstractions. It is more of a named practice just like AJAX but not a technology in itself. It encourages use of capabilities that have long been inherent in the HTTP protocol, but seldom used. When you have a URL (Uniform Resource Locator) and you point your browser to it by the address line, you're sending an HTTP request. Each HTTP request contains information that the server can use to know which HTTP response to send back to the client that issued the request.

Each request contains a URL, so the server knows which resource you want to access, but it can also contain a method. A method describes what to do with that resource.

But this "method" concept wasn't used very often.

Usually, people would just link to pages via the GET method, and issue any type of updates (deletions, insertions, updates) via the POST method.

And because of that you couldn't treat one resource (URL) as a true resource in itself. You had to have separate URLs for deletion, insertion or update of the same resource.

For example, a resource can be a user's comment. That means not only a record in a 'comment' table, but also its relationships with the 'user' resource, the post that comments, maybe another comment that it answers.

Operating on the comment isn't a primitive database operation, it can have significant side effects, like firing an alert to the original poster, or recalculating some gamelike 'points', or updating some 'followers stream'.

Also, a resource representation includes hypertext (check the HATEOAS principle), allowing the designer to express relationships between resources, or guiding the REST client in an operation's workflow.

In short, CRUD is a set primitive operations (mostly for databases and static data storages), while REST is a very-high-level API style (mostly for webservices and other 'live' systems).

a single URL describes a single resource. A single post is a single resource. With REST you treat resources the way they were meant to be treated. You're telling the server which resource you want to handle, and how to handle it.

There are many other features to "RESTful architecture", which you can read about in Wikipedia, other articles or books, if you're interested. There isn't a whole lot more to CRUD itself, on the other hand.

Example

http://...com/posts/create- POST request  -> Goes to posts.create() method in the server
http://...com/posts/1/show- GET request  -> Goes to posts.show(1) method in the server
http://...com/posts/1/delete - POST request  -> Goes to posts.delete(1) method in the server
http://...com/posts/1/edit- POST request  -> Goes to posts.edit(1) method in the server

With REST, you create forms that are smarter because they use other HTTP methods aside of POST, and program your server to be able to distinguish between methods, not only URLS. So for example:

http://...com/posts - POST request  -> Goes to posts.create() method in the server
http://...com/posts/1 - GET request  -> Goes to posts.show(1) method in the server
http://...com/posts/1 - DELETE request  -> Goes to posts.delete(1) method in the server
http://...com/posts/1 - PUT request  -> Goes to posts.edit(1) method in the server

CDN (Content Distribution Network)

• Several companies, including Google and Microsoft, allow you to link to jQuery, and some other common libraries, and get that file directly from their servers.
• This is more reliable and speedier.
• Spreading the requests across different servers can improve performance.
• Caching benefits - shared sites got cached on the client machine.
• Remove "http:" to avoid complaints of encryption or not.

Example

// Linking to Google CDN
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js">
</script>
// remove http:
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js">
</script>

Abstract Factory pattern vs Factory Method pattern

Abstract Factory vs. Factory Method

The methods of an Abstract Factory are implemented as Factory Methods. Both the Abstract Factory Pattern and the Factory Method Pattern decouples the client system from the actual implementation classes through the abstract types and factories. The Factory Method creates objects through inheritance where the Abstract Factory creates objects through composition.

The Abstract Factory Pattern consists of an AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct and Client.

How to implement

The Abstract Factory Pattern can be implemented using the Factory Method Pattern, Prototype Pattern or the Singleton Pattern. The ConcreteFactory object can be implemented as a Singleton as only one instance of the ConcreteFactory object is needed.

Factory Method pattern is a simplified version of Abstract Factory pattern. Factory Method pattern is responsible of creating products that belong to one family, while Abstract Factory pattern deals with multiple families of products.

Factory Method uses interfaces and abstract classes to decouple the client from the generator class and the resulting products. Abstract Factory has a generator that is a container for several factory methods, along with interfaces decoupling the client from the generator and the products.

When to Use the Factory Method Pattern

Use the Factory Method pattern when there is a need to decouple a client from a particular product that it uses. Use the Factory Method to relieve a client of responsibility for creating and configuring instances of a product.

When to Use the Abstract Factory Pattern

Use the Abstract Factory pattern when clients must be decoupled from product classes. Especially useful for program configuration and modification. The Abstract Factory pattern can also enforce constraints about which classes must be used with others. It may be a lot of work to make new concrete factories.

• Design Patterns : Abstract Factory Pattern
• Factory Method Pattern vs Abstract Factory Pattern

Java OOP.

• Java String is immutable object

Using "this"

public class MyClass {
     private final String value;
     private final String type;

     public MyClass(int x){
         this(Integer.toString(x), "int");
     }

     public MyClass(boolean x){
         this(Boolean.toString(x), "boolean");
     }

     public String toString(){
         return value;
     }

     public String getType(){
         return type;
     }

     private MyClass(String value, String type){
         this.value = value;
         this.type = type;
     }
}

Object Creation Initialization.

Initialization happens when,

1. A class is loaded.
2. A class is created/instantiated.

JVM does the following when it encounters class instantiation,

1. Allocates memory space for a new object, with room for the instance variables.
2. Process the constructor. If the constructor has parameters, JVM creates variables for the parameters and assigns them values passed in.
3. If the invoked constructor begins with a call to another constructor by using "this" keyword, JVM processes the called constructor.
4. Initialize instance and instance variable for this class. Undefined instance variables will be assigned default values.
5. Executes the rest of the invoked constructor.
6. Returns a reference variable that refers to the newly created object

Note:

• Static initialization is performed first before any instantiation takes place, even if the code comes later in the program.

EXAMPLE

package mypackage;

public class MyClass {
    int x = 3;
    int y;

    // instance initialization code block
    {
        y = x*2;
        System.out.println (y);
    }

    // static initialization code happens first
    static {
        System.out.println ("Static initialization, this will come first.");
    }

    public static void main (String[] args) {
        MyClass inst0 = new MyClass();
        MyClass inst1 = new MyClass();
    }
}

The instance initialization code can go unnoticed when the code gets bigger. A better practice to write initialization code is to put it in the constructor so it's more noticeable.

package mypackage;

public class MyClass2 {
    int x = 3;
    int y;

    // instance initialization code in the constructor
    public MyClass2 () {
        y = x*2;
        System.out.println (y);
    }

    // static initialization code happens first
    static {
        System.out.println ("Static initialization, this will come first.");
    }

    public static void main (String[] args) {
        MyClass2 inst0 = new MyClass2();
        MyClass2 inst1 = new MyClass2();
    }
}

If you have more than one constructor and each calls the same block of code, wrap the common initialization code in a method and let the constructors call it.

package mypackage;

public class MyClass3 {
    int x = 3;
    int y;

    // Two constructors
    public MyClass3 () {
        init();
    }
    public MyClass3 (int x) {
        this.x = x;
        init();
    }

    // instance initialization code in a method
    private void init () {
        y = x*2;
        System.out.println (y);
    }

    // static initialization code happens first
    static {
        System.out.println ("Static initialization, this will come first.");
    }

    public static void main (String[] args) {
        MyClass3 inst0 = new MyClass3();
        MyClass3 inst1 = new MyClass3();
    }
}

In C++, you must destroy objects after use. Java comes with a garbage collector which destroys unused objects and frees memory space.