[UVM] factory

最新推荐文章于 2024-10-16 11:03:48 发布
最新推荐文章于 2024-10-16 11:03:48 发布
阅读量771 收藏 5
点赞数 1
分类专栏： UVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbt_dvshare/article/details/84819881
版权

factory 的應用

1. simv  +UVM_TESTNAME=hello_world_test

   通過指定test case 的名字就可以運行，test 是怎麼被創建的呢？

        Actually call uvm_root::run_test(), where it

        1. gets test name from command line (+UVM_TESTNAME)

        2. construct a component of that type via uvm_factory 

            factory.create_component_by_name()

      其中，run_test（）是定義在module top 外面的task（通過import uvm_pkg），故module top 可以調用它。

 

2. 就是大家熟知的override。

sw_driver::type_id::set_type_override(old_sw_driver::get_type(), 0);

Which one wins depends on “replace” bit

  • replace= 1(default): later override will replace previous one
  • replace=0: otherwise

Multiple inst override

first inst override wins due to uvm_factory’s “return first match” when finding instance override type

Mixed type/inst override

inst override wins due to uvm_factory’s “inst override takes precedence” policy

parent wins: 若頂層的覆蓋與底層的覆蓋衝突，則頂層的覆蓋會最終生效。

用法

inst override

     inst override by type:

          original_class::type_id::set_inst_override(override_class::get_type(),relative_path,this)

          factory.set_inst_override_by_type(original_class::get_type(), override_class::get_type(), full_inst_path);

          set_inst_override_by_type(relative_path,original_class::get_type(), override_class::get_type());

    inst override by name:

          factory.set_inst_override_by_name("original_class_name" , "override_class_name", full_inst_path );

          set_inst_override(relative_path,"original_class_name" , "override_class_name");

type override

     Type override by type:

          factory.set_type_override_by_type (original_class::get_type(), override_class::get_type(), 1);

          original_class::type_id::set_type_override (override_class::get_type());

          set_type_override_by_type (original_class::get_type(), override_class::get_type(), 1);

    Type override by name:

         factory.set_type_override_by_name ("original_class_name","override_class_name", 1);

         set_type_override ("original_class_name","override_class_name", 1);

 

example: in test中

set_inst_override_by_type("env.o_agt.mon",my_monitor::get_type(),new_monitor::get_type());


//in top module

initial begin
     factory.set_inst_override_by_type(my_monitor::get_type(),new_monitor::get_type(),"uvm_test_top.env.o_agt.mon");

end

How does UVM factory work

1. 註冊

class new_sw_driver extends uvm_component;
  `uvm_component_utils_begin(new_sw_driver)
    `uvm_field_int(frame_num)
    `uvm_field_int(port_num)
  `uvm_component_utils_end
endclass

 `uvm_*_utils 這個宏就是註冊到factory中，那它都做了些什麼呢（以component為例）?

`define uvm_component_utils(T) \
   `m_uvm_component_registry_internal(T,T) \
   `m_uvm_get_type_name_func(T) \

 

`define m_uvm_component_registry_internal(T,S) \
   typedef uvm_component_registry #(T,`"S`") type_id; \
   static function type_id get_type(); \
     return type_id::get(); \
   endfunction \
   virtual function uvm_object_wrapper get_object_type(); \
     return type_id::get(); \
   endfunction

 

  
 uvm_component_registry #(type T=uvm_component,string Tname="<unknown>") extends uvm_object_wrapper;
   typedef uvm_component_registry #(T,Tname) this_type;

  //ex: typedef uvm_component_registry #(sw_driver,"sw_driver") type_id;
   
  local static this_type me = get();//當靜態變量初始化時通過調用get函數註冊到factory中

  static function this_type get();
    if (me == null) begin
      uvm_factory f = uvm_factory::get();
      me = new;
      f.register(me);
    end
    return me;
  endfunction

  static function T create();//在build_phase 調用的create就是它

從調用uvm_component_utils(T)可看出 T=Tname

factory 維護這一張註冊表(通過調用uvm_component_utils來把內容填入表中)：

`uvm_component_utils(sw_driver)

`uvm_component_utils(new_sw_driver)

 

Index by name

                                                    protected uvm_object_wrapper m_type_names[string];(name)                                                   

Index

Value

“sw_driver”

sw_driver::type_id

“new_sw_driver”

new_sw_driver::type_id

…

…

當調用set_type_override_by_name和run_test時會查看此表

Index by type_id

                                                 

                                                           protected bit m_types[uvm_object_wrapper];（type）

Index

Value

sw_driver::type_id

1

new_sw_driver::type_id

1

…

…

當調用set_type_override_by_type時會查看此表

 

2. override

factory同樣也維護著一張關於override 信息的表，表中每一行包括以下內容：

class uvm_factory_override;
  string full_inst_path;
  string orig_type_name;
  string ovrd_type_name;
  bit selected;
  uvm_object_wrapper orig_type;
  uvm_object_wrapper ovrd_type;
  //…
endclass

通過調用factory.set_type_override_by_type(sw_driver::get_type(), new_sw_driver::get_type(), 1);把信息寫入表中

                                                         protected uvm_factory_override m_type_overrides[$];

 

[0]

…

orig_type

sw_driver::type_id

 

orig_type_name

“sw_driver”

 

ovrd_type

new_sw_driver::type_id

 

ovrd_type_name

“new_sw_driver”

 

full_inst_path

“*”

 

selected

0

 

當有多個type override的信息時，比如

      new1_sw_driver::type_id::set_type_override(sw_driver::get_type(), 1);

      new2_sw_driver::type_id::set_type_override(sw_driver::get_type(), 1);

      當replace =1 時，運行第二條語句時會把m_type_overrides[0]（如上圖）中第一條語句產生的信息覆蓋掉，因為他們具有相同的orig_type。

     所以在m_type_overrides中具有相同orig_type的隊列元素只有一個。

function void uvm_factory::set_type_override_by_type (uvm_object_wrapper original_type,
                                                      uvm_object_wrapper override_type,
                                                      bit replace=1);
  bit replaced;

  // check that old and new are not the same
  if (original_type == override_type) begin
    if (original_type.get_type_name() == "" || original_type.get_type_name() == "<unknown>")
      uvm_report_warning("TYPDUP", {"Original and override type ",
                                    "arguments are identical"}, UVM_NONE);
    else
      uvm_report_warning("TYPDUP", {"Original and override type ",
                                    "arguments are identical: ",
                                    original_type.get_type_name()}, UVM_NONE);
    return;
  end

  // register the types if not already done so, for the benefit of string-based lookup
  if (!m_types.exists(original_type))
    register(original_type); 

  if (!m_types.exists(override_type))
    register(override_type); 


  // check for existing type override 如果第一次運行此函數不會執行這部分，因為m_type_overrides是空的
  foreach (m_type_overrides[index]) begin
    if (m_type_overrides[index].orig_type == original_type ||
        (m_type_overrides[index].orig_type_name != "<unknown>" &&
         m_type_overrides[index].orig_type_name != "" &&
         m_type_overrides[index].orig_type_name == original_type.get_type_name())) begin
      string msg;
      msg = {"Original object type '",original_type.get_type_name(),
             "' already registered to produce '",
             m_type_overrides[index].ovrd_type_name,"'"};
      if (!replace) begin
        msg = {msg, ".  Set 'replace' argument to replace the existing entry."};
        uvm_report_info("TPREGD", msg, UVM_MEDIUM);
        return;
      end
      msg = {msg, ".  Replacing with override to produce type '",
                  override_type.get_type_name(),"'."};
      uvm_report_info("TPREGR", msg, UVM_MEDIUM);
      replaced = 1;
      //把具有相同orig_type的覆蓋掉 
      m_type_overrides[index].orig_type = original_type; 
      m_type_overrides[index].orig_type_name = original_type.get_type_name(); 
      m_type_overrides[index].ovrd_type = override_type; 
      m_type_overrides[index].ovrd_type_name = override_type.get_type_name(); 
    end
  end

  // make a new entry
  if (!replaced) begin//第一次運行此函數會執行這部分
    uvm_factory_override override;
    override = new(.orig_type(original_type),
                   .orig_type_name(original_type.get_type_name()),
                   .full_inst_path("*"),
                   .ovrd_type(override_type));

    m_type_overrides.push_back(override);
  end

endfunction

 

 

 

當有多個inst override的信息時，比如

sw_driver::type_id::set_inst_override(new_sw_driver::get_type(), "env.driver[1]", this);

sw_driver::type_id::set_inst_override(new_sw_driver::get_type(), "env.driver[0]", this);

m_inst_override_queues[$]會產生兩組信息，而不是覆蓋掉原來的

 

                                                                  m_inst_override_queues[uvm_object_wrapper]

sw_driver::type_id

orig_type

sw_driver::type_id

sw_driver::type_id

orig_type_name

“sw_driver”

“sw_driver”

ovrd_type

new_sw_driver::type_id

new_sw_driver::type_id

ovrd_type_name

“new_sw_driver”

“new_sw_driver”

full_inst_path

“uvm_test_top.env.driver[1]”

“uvm_test_top.env.driver[0]”

selected

0

0

another type_id

orig_type

 

 

…

 

 

 

 

 

3. create 

    sw_driver::type_id::create(“sw_driver",this)

    這句話都做了哪些事情呢？

function sw_driver create(
                   string name, 
                   uvm_component parent, 
                   string contxt="");

   if (contxt == "" && parent != null)
      contxt =parent.get_full_name()

   uvm_factory f = uvm_factory::get();

   uvm_object obj = f.create_component_by_type(type_id, contxt, name, parent)
   
   $cast(create, obj)//obj要和create是父子關係


function uvm_component create_component_by_type(
                       uvm_object_wrapper requested_type,
                       string parent_inst_path="“,
                       string name, 
                       uvm_component parent);
  
   string full_inst_path ;
   concatenate  full_inst_path；
   requested_type = find_override_by_type(requested_type, full_inst_path);//查表看看是否有override信息，若有則返回override的type
   return requested_type.create_component(name, parent);//把override type new出來



function uvm_object_wrapper uvm_factory::find_override_by_type(uvm_object_wrapper requested_type,
                                                               string full_inst_path);

  uvm_object_wrapper override;
  uvm_factory_queue_class qc = null;
  if (m_inst_override_queues.exists(requested_type))
    qc = m_inst_override_queues[requested_type];

  foreach (m_override_info[index]) begin
    if ( //index != m_override_info.size()-1 &&
       m_override_info[index].orig_type == requested_type) begin
      uvm_report_error("OVRDLOOP", "Recursive loop detected while finding override.", UVM_NONE);
      if (!m_debug_pass)
        debug_create_by_type (requested_type, full_inst_path);

      return requested_type;
    end
  end

  // inst override; return first match; takes precedence over type overrides
  if (full_inst_path != "" && qc != null)
    for (int index = 0; index < qc.queue.size(); ++index) begin
      if ((qc.queue[index].orig_type == requested_type ||
           (qc.queue[index].orig_type_name != "<unknown>" &&
            qc.queue[index].orig_type_name != "" &&
            qc.queue[index].orig_type_name == requested_type.get_type_name())) &&
          uvm_is_match(qc.queue[index].full_inst_path, full_inst_path)) begin
      //当orig_type 等于requested_type而且full_inst_path也match
        m_override_info.push_back(qc.queue[index]);
        if (m_debug_pass) begin
          if (override == null) begin
            override = qc.queue[index].ovrd_type;
            qc.queue[index].selected = 1;
          end
        end
        else begin
          if (qc.queue[index].ovrd_type == requested_type)//沒有發生override
            return requested_type;
          else
            return find_override_by_type(qc.queue[index].ovrd_type,full_inst_path);
            //遞歸調用，比如1 override 2,2 override 3,最終是1 override 3
        end
      end
    end

  // type override - exact match
  foreach (m_type_overrides[index]) begin
    if (m_type_overrides[index].orig_type == requested_type ||
        (m_type_overrides[index].orig_type_name != "<unknown>" &&
         m_type_overrides[index].orig_type_name != "" &&
         requested_type != null &&
         m_type_overrides[index].orig_type_name == requested_type.get_type_name())) begin
      m_override_info.push_back(m_type_overrides[index]);
      if (m_debug_pass) begin
        if (override == null) begin
          override = m_type_overrides[index].ovrd_type;
          m_type_overrides[index].selected = 1;
        end
      end
      else begin
        if (m_type_overrides[index].ovrd_type == requested_type)
          return requested_type;
        else
          return find_override_by_type(m_type_overrides[index].ovrd_type,full_inst_path);
          //遞歸調用，比如1 override 2,2 override 3,最終是1 override 3
      end
    end
  end

  // type override with wildcard match
  //foreach (m_type_overrides[index])
  //  if (uvm_is_match(index,requested_type.get_type_name())) begin
  //    m_override_info.push_back(m_inst_overrides[index]);
  //    return find_override_by_type(m_type_overrides[index],full_inst_path);
  //  end

  if (m_debug_pass && override != null)
    if (override == requested_type)
      return requested_type;
    else
      return find_override_by_type(override,full_inst_path);

  return requested_type;

endfunction
function uvm_component create_component(
                       string name,
                       uvm_component parent);
  T obj;
  obj = new(name, parent);
  return obj;
endfunction
UVM：factory 机制
Starry__的博客
02-14 4768
目录1. 注册2. 创建3. 创建函数的重载3.1. 重载方法一次重载连续重载3.2. 信息打印 译作工厂机制，来源于设计模式中的工厂机制。 factoy机制的意义在于：通过将拓展类在工厂注册，可实现环境内部组件的创建与对象的重载 factory机制主要针对构成验证环境层次的uvm_component及其子类，以及构成环境配置属性和数据传输的uvm_object及其子类 1. 注册 使用factory机制的第一步就是将类注册到工厂。这个factory是整个全局仿真中存在且唯一的“机构”，所有被注册的类才能
UVM factory机制 override机制详解
liuwei848的博客
11-16 8370
factory机制 顾名思义，factory机制（工厂机制），最大的优点是根据字符串（类名），创建该类的实例，比如下面的一个类：class my_driver extends uvm_driver;当使用factory机制时就可以根据字符串“my_driver”创建属于类my_driver的一个实例。还有另一种解释是factory机制本质上是对new函数的重载，从某种意义上也确实是这么回事...
UVM中的factory机制实现
ahr7882的博客
04-29 489
首先在Systemverilog中便有对于重载的最基本的支持。 1)定义task/function时，使用virtual关键字。那之后在test_case中调用时，便使用句柄指向的对象的类型而不是句柄的类型来调用task/function。 好处：bird为基类，parrot为扩展类。bird类型的句柄可以指向parrot类型的对象，（进而在这种情况下，这个句柄可以直接赋值给p...
一些bug的解决记录（3）
polaris92929的博客
08-22 150
解决：没有将新添加的test文件写入svh头文件中，导致没有将其编译进去。
UVM factory/objection/virtual interface
踩坑记录
02-16 736
UVM 树形结构： driver： // 只有driver的验证平台 module dut(clk,rst_n,rxd,rx_dv,txd,tx_en); input clk; input rst_n; // 低电平复位 input[7:0] rxd; // 接收数据 input rx_dv; // 接收的数据有效指示 output [7:0] txd; // 发送数据 output tx_en; // 发送的数据有效指示 reg[7:0] txd; reg tx_en; a
uvm_factory——我们的工厂（一）
weixin_33971130的博客
11-20 305
factory 机制是实现（功能）：通过一个字符串来创建此字符串所代表的的类的一个实例。 //------------------------------------------------------------------------------ // // Group: Usage // // Using the factory involves three basic ope...
uvm_factory——我们的工厂（三）
weixin_33704234的博客
11-20 293
现在让我们回过头来想想factory 是用来干什么，它做了什么？ fantory就是生产uvm_object 和 uvm_component。用factory 生产和用SV直接new有什么区别了？ factory机制的的特点就是根据类的名字来创建类的实例。 uvm_object 在定义时调用 uvm_object_utils 宏，而 uvm_component 在定义时要调用uvm_comp...
UVM factory 机制的简单实现（有代码）
09-02
在系统Verilog的验证环境中，UVM（Universal Verification Methodology）是一个广泛应用的验证框架，它提供了许多高级功能，包括工厂（Factory）机制。这个工厂机制是UVM的核心部分，用于动态地创建和配置验证组件。...
UVM factory create
07-27
The UVM factory is a key component of the UVM framework, responsible for creating and managing objects dynamically. To create an object using the UVM factory, you need to follow these steps: 1. ...
UVM factory机制源码探微
05-30
UVM factory机制是UVM中非常重要的一个机制，它提供了一种灵活的方式来创建和管理UVM组件。在UVM中，每个组件都是通过一个工厂类来创建的，这个工厂类就是UVM factory机制的核心。 UVM factory机制的源码实现主要...
UVM—Factory机制
qq_72794467的博客
04-07 261
记录知识点，参考了UVM实战、芯片验证漫游指南、以及各位大佬的总结。如有错误，欢迎指正！一、简介Factory机制其实是对SV中new函数的重载，原始的new函数功能太过简单。经过factory机制的改良后，进行实例化的方法多了很多,有了Factory机制之后，可以根据类名创建这个类的一个实例，还可以在创建类的实例时根据是否有重载记录来决定是创建原始的类，还是创建重载的类的实例。二、uvm_component和uvm_object的例化定义——>注册——>构建。
UVM-工厂机制(factory)
sinat_41774721的博客
12-12 4016
文章目录1.工厂模式概述2.创建(create)2.1 **定义->注册->构建** 缺一不可2.2 什么是宏3.覆盖方法 1.工厂模式概述 工厂模式的主要解决的问题是，将原来分布在各个地方的对象创建过程单独抽离出来，交给工厂类负责创建。其他地方想要使用对象直接找工厂（即调用工厂的方法）获取对象。 UVM工厂的存在就是为了更方便地替换验证环境中的实例或者注册了的类型，同时工厂的注册机制也带来了配置的灵活性。 实例或类型替代，在UVM中称作覆盖，而被用来替换的对象或者类型，应该满足注册和多态的要
UVM 工厂（factory）机制
weixin_44377626的博客
11-06 578
UVM工厂机制实现了类型和实例的重载，提高了产品迭代效率及验证环境的复用性
UVM-factory机制
Nie_You的博客
07-23 2672
UVM_factory整理。
UVM factory机制
weixin_45704530的博客
02-14 521
factory机制的运作步骤 1、将用户自定义的类向factory的注册表中进行注册。 2、要使用“class_name::type_id::create()"来代替new实例化对象。 3、根据具体要求向替换表添加替换条目。 4、在运行仿真时，UVM会根据这两张表自动实现factory机制。 factory机制的使用 1、使用`uvm_object_utils()对uvm_object类进行注册。 2、使用`uvm_component_utils()对uvm_component类进行注册。 3、使用“cla
[UVM源代码研究] uvm中的factory机制（uvm-1.2版）
sunstat的博客
03-20 1242
uvm中的factory机制（uvm-1.2版）
UVM源码分析之factory机制详解
HelloQili的博客
01-03 1944
前言 作者在学习了一段时间的UVM factory源码之后写下此文，旨在记录自己的学习成果，毕竟好记性不如烂笔头嘛，当然如果能帮助到对这部分有疑惑的同仁就更好了。作者是在笔记本电脑上的windows环境下使用source insight软件分析UVM 源码的。感兴趣的同仁可以试试用source insight分析源码,个人认为还是比在纯编辑器(比如vim)方便很多。source insight支持systemverilog的配置文件可以通过https://download.csdn.net/downlo.
UVM基础-Factory机制
qq_36955425的博客
06-10 2270
回顾整个过程，总结起来就是：factory机制进行实例化的过程，会先对component进行注册，即调用f.registory，然后查询是否有重载记录，即调用find_override_by_type，如果有重载记录，则返回重载后的类，最后调用registory中的create_component函数，这个函数最终会调用重载后的类的构造函数new，如果没有重载记录，则调用当前实例化组件的构造函数（new）。这个函数有三个参数，第一个为被重载的类，第二个为重载的类，第三个为是否可以被后面的重载覆盖。
UVM初学篇 -（15） UVM factory 工厂机制
最新发布
u011164476的博客
10-16 986
工厂机制不是UVM独有的机制，这是面向对象语言特有的机制。在面向对象中工厂中角色就是两个：工厂和产品，工厂机制的意思在于将创建某一类对象的任务交给对应的工厂类统一管理，构建对象体系。工厂模式提供了一种灵活和可扩展的方式来创建对象，使代码更易于维护和扩展。通过将对象的创建逻辑封装在工厂中，可以隐藏对象的实现细节，提高代码复用性，并简化对象的创建过程，同时实现了对象之间的解耦。而UVM中工厂机制也是同样的道理，目的是为了更好的注册实例和方便地替换已经注册的实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值