OVM重要概念之——Factory模式

当你希望改变Testbench结构但又不想改变Testbench代码时，例如想换一个driver，Factory模式可以满足你的需求。

.Factory模式提供了一个 不改变testbench代码替换object的方法。Factory保留了一个registered objects列表。当你创建新的对象时，列表被访问。如果已经存在，则返回override object，否则返回registered object。

想要仔细了解factory机制有点费工夫，（但是想要知道怎样使用还是很容易的）.下面的例子展示factory机制：

class object_base;
  virtual function void print();
    $display("object_base");
  endfunction
endclass

//----------------------------------------------------------------------
// wrapper_base
//
// Wrapper base for all objects registered with the factory.  Since
// wrappers are parmaeterized, this base class lets us deal with the all
// the paramerized derived classes polymorphically.
//----------------------------------------------------------------------
class wrapper_base;
  virtual function object_base create_object();
    return null;
  endfunction
endclass

//----------------------------------------------------------------------
// factory
//
// Singleton object that contains the core data structure for the
// factory and the methods for accessing the data structure.  The data
// structure is an associative array of overrides indexed by type
// handle.
//----------------------------------------------------------------------
class factory;

  static factory f;
  wrapper_base override_map[wrapper_base];

  local function new();
  endfunction

  static function factory get();
    if(f == null)
      f = new();
    return f;
  endfunction

  function void register(wrapper_base w);
    override_map[w] = w;
  endfunction

  function void set_override(wrapper_base requested_type,
                             wrapper_base override_type);
    override_map[requested_type] = override_type;
  endfunction

  function object_base create(wrapper_base
                              requested_type);
    object_base obj;
    wrapper_base override_type =
      override_map[requested_type];
    bj = override_type.create_object();
    return obj;
  endfunction

endclass

//----------------------------------------------------------------------
// parameterized wrapper
//
// Each specialization of the parameterized wrapper represents a type.
// These objects are singletons so there can never be more than one
// handle for each type.
//
// The constructor, new(), is a private function.  The only way to
// create a new wrapper is by using the get_type() function, the
// constructor cannot be called directly.
//----------------------------------------------------------------------
class wrapper #(type T=object_base) extends wrapper_base;

  typedef wrapper#(T) this_type;

  static this_type type_handle = get_type();

  local function new();
  endfunction

  function object_base create_object();
    T t = new();
    return t;
  endfunction

  static function T create();
    T obj;
    factory f = factory::get();
    assert($cast(obj, f.create(get_type())));
    return obj;
  endfunction

  static function this_type get_type();
    factory f;
    if(type_handle == null) begin
      type_handle = new();
      f = factory::get();
      f.register(type_handle);
    end
    return type_handle;
  endfunction

  static function void set_override(wrapper_base
                                    override_type);
    factory f = factory::get();
    f.set_override(type_handle, override_type);
  endfunction

endclass

//----------------------------------------------------------------------
// family of classes derived from a single base class
//----------------------------------------------------------------------
class family_base extends object_base;

  typedef wrapper#(family_base) type_id;

  virtual function void print();
    $display("family_base");
  endfunction
endclass

class A extends family_base;

  typedef wrapper#(A) type_id;

  virtual function void print();
    $display("A");
  endfunction
endclass

class B extends family_base;

  typedef wrapper#(B) type_id;

  virtual function void print();
    $display("B");
  endfunction
endclass

class C extends family_base;

  typedef wrapper#(C) type_id;

  virtual function void print();
    $display("C");
  endfunction
endclass

//----------------------------------------------------------------------
// env
//
// top-level environment where we execute the example
//----------------------------------------------------------------------
class env;

  factory f;
  family_base h;

  function void run();

    f = factory::get();

    h = family_base::type_id::create();
    h.print();

    family_base::type_id::set_override(B::type_id::get_type());

    h = family_base::type_id::create();
    h.print();

  endfunction

endclass

//----------------------------------------------------------------------
// top
//----------------------------------------------------------------------
module top;

  env e;

  initial begin
    e = new();
    e.run();
  end

endmodule

引用网上牛人对此例的解释