<'
unit env_u {
    clk : in event_port is instance;

    keep bind(clk, external);
    
    cnt : in simple_port of uint (bits:16) is instance;

    keep bind(cnt, external);
        
    !cnt_10s : uint;


    every_clk_tcm() @ clk$ is {
        while(TRUE) {

            if(cnt$ == 10) then {
                cnt_10s+=1;

            };
            wait cycle;
        };
    };
    
    run() is also {

        start every_clk_tcm();
    };
};

extend sys {

    env : env_u is instance;
    keep env.hdl_path() == "~/top";

    keep env.clk.hdl_path() == "clk";

    keep env.cnt.hdl_path() == "cnt";

    
    setup() is also { 
        set_config(run, tick_max, MAX_INT, exit_on, error); 
    }; 

};
    
'>

<'
unit env_u {    
    clk : in event_port is instance;

    keep bind(clk, external);
    
    cnt : in simple_port of uint (bits:16) is instance;

    keep bind(cnt, external);
        
    !cnt_10s : uint;

    
    event every_10_clks_e is true(cnt$ == 10) @ clk$;

    every_10_clks_tcm() @ every_10_clks_e is {
        while(TRUE) {

            cnt_10s+=1;
            wait cycle;
        };
    };

        
    run() is also {
        start every_10_clks_tcm();
    };

};

extend sys {
    env : env_u is instance;

    keep env.hdl_path() == "~/top";
    keep env.clk.hdl_path() == "clk";

    keep env.cnt.hdl_path() == "cnt";

    
    setup() is also { 
        set_config(run, tick_max, MAX_INT, exit_on, error); 
    }; 

};
    
'>

<'
unit env_u {    
    clk : in event_port is instance;

    keep bind(clk, external);
    
    cnt : in simple_port of uint (bits:16) is instance;

    keep bind(cnt, external);
        
    !cnt_10s : uint;

    
    event every_10_clks_e is true(cnt$ == 10) @ clk$;

    
    on every_10_clks_e {
        cnt_10s+=1;
    };
};

extend sys {
    env : env_u is instance;
    keep env.hdl_path() == "~/top";

    keep env.clk.hdl_path() == "clk";

    keep env.cnt.hdl_path() == "cnt";

    
    setup() is also { 
        set_config(run, tick_max, MAX_INT, exit_on, error); 
    }; 

};
    
'>

#!/usr/bin/perl

open(MODULE_LIST, ">modules.txt") || die $!;

{
  local $/=undef;
  open LOG, "specman1.elog" or die "Couldn't open file: $!";
  binmode LOG;
  $log = ;

  # turn cyclic imports into normal import form
  $log =~ s/\n/ /g;
  $log =~ s/Loading \(([^\)]*)\)/Loading $1/g;
  $log =~ s/ \+ ([^ ]*)/Loading $1/g;
  $log =~ s/Loading/\nLoading/g;

  # match normal imports
  my $normal_import_match_string = '^Loading[ |\n]([^ ]+\\.e)';
  my @evc_files;
  if(@evc_files = $log =~ /$normal_import_match_string/smg) {
    foreach $evc_file (@evc_files) {
      print MODULE_LIST "$evc_file" . "\n";
    }
  }
}

close(LOG);
close(MODULE_LIST);

package packet_pkg;

import ovm_pkg::*;
`include "ovm_macros.svh"

typedef enum {A, B} packet_type_t;

class packet_base extends ovm_sequence_item;
   `ovm_object_utils(packet_base);

   function new(string name = "");     
      super.new(name);     
   endfunction
endclass

class packet_A extends packet_base;
   
   rand int a;

   `ovm_object_utils_begin(packet_A);
   `ovm_field_int(a, OVM_ALL_ON)
   `ovm_object_utils_end
   
   function new(string name = "");     
      super.new(name);     
   endfunction
endclass

class packet_B extends packet_base;

   rand int b;

   `ovm_object_utils_begin(packet_B);
   `ovm_field_int(b, OVM_ALL_ON)
   `ovm_object_utils_end
   
   function new(string name = "");     
      super.new(name);     
   endfunction
endclass

class packet_sequencer extends ovm_sequencer#(packet_base, packet_base);
   `ovm_sequencer_utils(packet_sequencer);
   
   function new(string name, ovm_component parent);   
      super.new(name, parent);
      `ovm_update_sequence_lib
   endfunction
endclass

class packet_driver extends ovm_driver#(packet_base, packet_base);
  `ovm_component_utils(packet_driver)

  function new(string name, ovm_component parent);     
    super.new(name,parent);
  endfunction

  task run();
     packet_base next_packet;

     // This driver does nothing except for printing
     forever begin
        seq_item_port.get_next_item(next_packet);
        ovm_report_info("NEXT_PACKET",{"The next packet is:\n", next_packet.sprint()});
        seq_item_port.item_done(next_packet);
     end                
  endtask 
endclass

class packet_env extends ovm_env;
   `ovm_component_utils(packet_env);

   packet_sequencer sequencer;
   packet_driver driver;
   
   function new(string name, ovm_component parent);   
      super.new(name, parent);
   endfunction // new

   function void build();
      super.build();
      sequencer = packet_sequencer::type_id::create("packet_sequencer", this);
      driver = packet_driver::type_id::create("packet_driver", this);
   endfunction
   
   function void connect();
      super.connect();
      driver.seq_item_port.connect(sequencer.seq_item_export);
      driver.rsp_port.connect(sequencer.rsp_export);
   endfunction
endclass

class packet_seq_base extends ovm_sequence#(packet_base);

  `ovm_sequence_utils(packet_seq_base, packet_sequencer)

   // constrain this field to control packet_type
   rand packet_type_t packet_type;
   
   packet_A p_A;
   packet_B p_B;
   
  function new(string name = "packet_seq_base");
    super.new(name);
  endfunction
endclass
endpackage

package test_pkg;
import ovm_pkg::*;
import packet_pkg::*;
`include "ovm_macros.svh"

class specific_seq extends packet_seq_base;
   `ovm_sequence_utils(specific_seq, packet_sequencer)

   function new(string name = "specific_seq");
      super.new(name);
   endfunction // new

   // in a specific sequence:
   // 1. randomize to choose the next packet
   // 2. use the sequencer built-in factory
   // to create the item, randomize and send it
   
   task body();  
     forever begin

        randomize();
        
        case(packet_type)
          A : `ovm_do_with(p_A, {p_A.a == 5;}) 
          B : `ovm_do_with(p_B, {p_B.b == 6;}) 
        endcase

        #1;
     end
  endtask
endclass  

class test extends ovm_test;
   `ovm_component_utils(test);

   packet_env env;
   
   function new(string name = "test", ovm_component parent=null);
      super.new(name,parent);
   endfunction
   
  virtual function void build();
     super.build();

     env = packet_env::type_id::create("env", this);
     set_config_string("env.sequencer","default_sequence", "specific_seq");
  endfunction
endclass                                 
endpackage

module top;
   import ovm_pkg::*;
   import packet_pkg::*;
   import test_pkg::*;

   initial begin      
      run_test();
   end
endmodule

package vip_pkg;

import ovm_pkg::*;
`include "ovm_macros.svh"

class tr extends ovm_object;
   int serial_num;
   
   `ovm_object_utils_begin(tr)
   `ovm_field_int(serial_num, OVM_ALL_ON);
   `ovm_object_utils_end

   function new(string name ="");
      super.new(name);
   endfunction
endclass

// a : put side of the fifo
// b : get side of the fifo
// env : instantiates the fifo and connects
// it between a and b

// The port at the beginning
class a extends ovm_component;
   `ovm_component_utils(a)

   ovm_blocking_put_port#(tr) put_port;

   function new(string name, ovm_component parent);
      super.new(name,parent);
      put_port = new("put_port", this);
   endfunction

   task run();
      int serial_num;
      forever begin
         tr tr_i;
         
         $cast(tr_i, create_object("tr", "tr_i"));
         tr_i.serial_num = serial_num++; 
         // To follow a transaction place a breakpoint
         // on the line below.
         // When it breaks, go to "b" and place a
         // breakpoint at the designated point.
         // This is the only way you can follow a
         // transaction across a FIFO.
         put_port.put(tr_i);
         #1;
      end
   endtask
endclass 

// The implementation at the end
class b extends ovm_component;
   `ovm_component_utils(b)
   
   ovm_blocking_get_port#(tr) get_port; 

   function new(string name, ovm_component parent);
      super.new(name,parent);
      get_port = new("get_port",this);
   endfunction

   task run();
      tr tr_i;
      forever
        begin
           get_port.get(tr_i);
           // Place a breakpoint on the line below
           // to see the transaction come out of
           // the fifo.
           // Once it breaks, open the stack window.
           // You'll see that a is not anywhere there,
           // although that would be the most helpful
           // hint.
           tr_i.print();
        end
   endtask
endclass

// The env connects the port to the export
class env extends ovm_env;
   `ovm_component_utils(env)

   a a_i;
   b b_i;
   tlm_fifo#(tr) tlm_fifo_i;

   function new(string name, ovm_component parent);
      super.new(name,parent);
   endfunction

   function void build();
      super.build();
      $cast(a_i, create_component("a", "a_i"));
      $cast(b_i, create_component("b", "b_i"));
      tlm_fifo_i = new("tlm_fifo_i",this);
   endfunction // void

   function void connect();
      super.connect();
      a_i.put_port.connect(tlm_fifo_i.blocking_put_export);
      b_i.get_port.connect(tlm_fifo_i.blocking_get_export);
   endfunction
endclass // env

endpackage // vip

package tests;

import ovm_pkg::*;
import vip_pkg::*;
`include "ovm_macros.svh"

class test extends ovm_test;
   `ovm_component_utils(test);

   env env_i;
   
   function new(string name = "test", ovm_component parent=null);
      super.new(name,parent);
   endfunction // new

   function void build();      
      super.build();
      $cast(env_i, create_component("env", "env_i"));
   endfunction
endclass
endpackage // z

module top();
   import ovm_pkg::*;
   import vip_pkg::*;
   import tests::*;
   

   initial
     run_test();
endmodule

package vip_pkg;

import ovm_pkg::*;
`include "ovm_macros.svh"

class tr extends ovm_object;
   int serial_num;
   
   `ovm_object_utils_begin(tr)
   `ovm_field_int(serial_num, OVM_ALL_ON);
   `ovm_object_utils_end

   function new(string name ="");
      super.new(name);
   endfunction
endclass // tr

// a : the port at the beginning
// b : the implementation at the end

// The port at the beginning
class a extends ovm_component;
   `ovm_component_utils(a)

   ovm_blocking_put_port#(tr) put_port;

   function new(string name, ovm_component parent);
      super.new(name,parent);
      put_port = new("put_port", this);
   endfunction

   task run();
      int serial_num;
      forever begin
         tr tr_i;
         
         $cast(tr_i, create_object("tr", "tr_i"));
         tr_i.serial_num = serial_num++;      
         put_port.put(tr_i);
         #1;
      end
   endtask
endclass 

// The implementation at the end
class b extends ovm_component;
   `ovm_component_utils(b)
   
   ovm_blocking_put_imp#(tr,b) put_imp;

   function new(string name, ovm_component parent);
      super.new(name,parent);
      put_imp = new("put_imp",this);
   endfunction

   task put(tr tr_i);
      tr_i.print();    
   endtask
endclass

// The env connects the port to the export
class env extends ovm_env;
   `ovm_component_utils(env)

   a a_i;
   b b_i;

   function new(string name, ovm_component parent);
      super.new(name,parent);
   endfunction

   function void build();
      super.build();
      $cast(a_i, create_component("a", "a_i"));
      $cast(b_i, create_component("b", "b_i"));      
   endfunction // void

   function void connect();
      super.connect();
      a_i.put_port.connect(b_i.put_imp);
   endfunction
endclass // env

endpackage // vip

package tests;

import ovm_pkg::*;
import vip_pkg::*;
`include "ovm_macros.svh"

class test extends ovm_test;
   `ovm_component_utils(test);

   env env_i;
   
   function new(string name = "test", ovm_component parent=null);
      super.new(name,parent);
   endfunction // new

   function void build();      
      super.build();
      $cast(env_i, create_component("env", "env_i"));
   endfunction
endclass
endpackage // z

module top();
   import ovm_pkg::*;
   import vip_pkg::*;
   import tests::*;
   

   initial
     run_test();
endmodule

package multiple_port_imps_pkg;
import ovm_pkg::*;
`include "ovm_macros.svh"

`define TLM_BLOCKING_PUT_MASK (1<<0)
`define TLM_ANALYSIS_MASK (1<<8)

class ovm_blocking_multiple_put_imp #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
   local IMP m_imp; 
   
   function new (string name, IMP imp); 
      super.new (name, imp, OVM_IMPLEMENTATION, 1, 1); 
      m_imp = imp; 
      m_if_mask = `TLM_BLOCKING_PUT_MASK;
   endfunction // new
   
   virtual function string get_type_name();
      return "ovm_blocking_multiple_put_imp";
   endfunction // string

   task put (T t);
      m_imp.put(get_name(),t);
   endtask
endclass

class ovm_multiple_analysis_imp #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
   local IMP m_imp; 
   
   function new (string name, IMP imp); 
      super.new (name, imp, OVM_IMPLEMENTATION, 1, 1); 
      m_imp = imp; 
      m_if_mask = `TLM_ANALYSIS_MASK;
   endfunction // new
   
   virtual function string get_type_name();
      return "ovm_multiple_analysis_imp";
   endfunction // string

   function void write (input T t);
      m_imp.write(get_name(),t);
   endfunction
endclass

endpackage

package vip_pkg;

import ovm_pkg::*;
import multiple_port_imps_pkg::*;
`include "ovm_macros.svh"

class tr extends ovm_object;
   int serial_num;
   
   `ovm_object_utils_begin(tr)
   `ovm_field_int(serial_num, OVM_ALL_ON);
   `ovm_object_utils_end

   function new(string name ="");
      super.new(name);
   endfunction
endclass // tr

// a1,a2 : the two ports at the beginning
// b : the implementation at the end

// The port at the beginning (both are identical)
class a extends ovm_component;
   `ovm_component_utils(a)

   ovm_blocking_put_port#(tr) put_port;

   function new(string name, ovm_component parent);
      super.new(name,parent);
      put_port = new("put_port", this);
   endfunction

   task run();
      int serial_num;
      forever begin
         tr tr_i;
         
         $cast(tr_i, create_object("tr", "tr_i"));
         tr_i.serial_num = serial_num++;      
         put_port.put(tr_i);
         #1;
      end
   endtask
endclass

// The implementation at the end
class b extends ovm_component;
   `ovm_component_utils(b)
   
   ovm_blocking_multiple_put_imp#(tr,b) put_imp_source1;
   ovm_blocking_multiple_put_imp#(tr,b) put_imp_source2;

   function new(string name, ovm_component parent);
      super.new(name,parent);
      put_imp_source1 = new("put_imp_source1",this);
      put_imp_source2 = new("put_imp_source2",this);
   endfunction
   
   task put(string port_name, tr tr_i);
      case(port_name)
        "put_imp_source1" : put_source1(tr_i);
        "put_imp_source2" : put_source2(tr_i);
      endcase
   endtask // put

   task put_source1(tr tr_i);
      tr_i.print();
   endtask // put_source1

   task put_source2(tr tr_i);
      tr_i.print();
   endtask
endclass

// The env connects the port to the export
class env extends ovm_env;
   `ovm_component_utils(env)

   a a1_i;
   a a2_i;
   b b_i;

   function new(string name, ovm_component parent);
      super.new(name,parent);
   endfunction

   function void build();
      super.build();
      $cast(a1_i, create_component("a", "a1_i"));
      $cast(a2_i, create_component("a", "a2_i"));
      $cast(b_i, create_component("b", "b_i"));      
   endfunction // void

   function void connect();
      super.connect();
      a1_i.put_port.connect(b_i.put_imp_source1);
      a2_i.put_port.connect(b_i.put_imp_source2);
   endfunction
endclass // env

endpackage // vip

package tests;

import ovm_pkg::*;
import vip_pkg::*;
`include "ovm_macros.svh"

class test extends ovm_test;
   `ovm_component_utils(test);

   env env_i;
   
   function new(string name = "test", ovm_component parent=null);
      super.new(name,parent);
   endfunction // new

   function void build();      
      super.build();
      $cast(env_i, create_component("env", "env_i"));
   endfunction
endclass
endpackage // z

module top();
   import ovm_pkg::*;
   import vip_pkg::*;
   import tests::*;
   

   initial
     run_test();
endmodule