Subversion Repositories uart2bus_testbench

//

//----------------------------------------------------------------------

//   Copyright 2007-2011 Mentor Graphics Corporation

//   Copyright 2007-2010 Cadence Design Systems, Inc.

//   Copyright 2010-2013 Synopsys, Inc.

//   Copyright 2013      NVIDIA Corporation

//   Copyright 2013      Cisco Systems, Inc.

//   All Rights Reserved Worldwide

//

//   Licensed under the Apache License, Version 2.0 (the

//   "License"); you may not use this file except in

//   compliance with the License.  You may obtain a copy of

//   the License at

//

//       http://www.apache.org/licenses/LICENSE-2.0

//

//   Unless required by applicable law or agreed to in

//   writing, software distributed under the License is

//   distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

//   CONDITIONS OF ANY KIND, either express or implied.  See

//   the License for the specific language governing

//   permissions and limitations under the License.

//----------------------------------------------------------------------

typedef class uvm_test_done_objection;

typedef class uvm_sequencer_base;

typedef class uvm_domain;

typedef class uvm_task_phase;

typedef class uvm_phase_cb;

//------------------------------------------------------------------------------

//

// Section: Phasing Definition classes

//

//------------------------------------------------------------------------------

//

// The following class are used to specify a phase and its implied functionality.

//

//------------------------------------------------------------------------------

//

// Class: uvm_phase

//

//------------------------------------------------------------------------------

//

// This base class defines everything about a phase: behavior, state, and context.

//

// To define behavior, it is extended by UVM or the user to create singleton

// objects which capture the definition of what the phase does and how it does it.

// These are then cloned to produce multiple nodes which are hooked up in a graph

// structure to provide context: which phases follow which, and to hold the state

// of the phase throughout its lifetime.

// UVM provides default extensions of this class for the standard runtime phases.

// VIP Providers can likewise extend this class to define the phase functor for a

// particular component context as required.

//

// This base class defines everything about a phase: behavior, state, and context.

//

// To define behavior, it is extended by UVM or the user to create singleton

// objects which capture the definition of what the phase does and how it does it.

// These are then cloned to produce multiple nodes which are hooked up in a graph

// structure to provide context: which phases follow which, and to hold the state

// of the phase throughout its lifetime.

// UVM provides default extensions of this class for the standard runtime phases.

// VIP Providers can likewise extend this class to define the phase functor for a

// particular component context as required.

//

// *Phase Definition*

//

// Singleton instances of those extensions are provided as package variables.

// These instances define the attributes of the phase (not what state it is in)

// They are then cloned into schedule nodes which point back to one of these

// implementations, and calls its virtual task or function methods on each

// participating component.

// It is the base class for phase functors, for both predefined and

// user-defined phases. Per-component overrides can use a customized imp.

//

// To create custom phases, do not extend uvm_phase directly: see the

// three predefined extended classes below which encapsulate behavior for

// different phase types: task, bottom-up function and top-down function.

//

// Extend the appropriate one of these to create a uvm_YOURNAME_phase class

// (or YOURPREFIX_NAME_phase class) for each phase, containing the default

// implementation of the new phase, which must be a uvm_component-compatible

// delegate, and which may be a ~null~ implementation. Instantiate a singleton

// instance of that class for your code to use when a phase handle is required.

// If your custom phase depends on methods that are not in uvm_component, but

// are within an extended class, then extend the base YOURPREFIX_NAME_phase

// class with parameterized component class context as required, to create a

// specialized functor which calls your extended component class methods.

// This scheme ensures compile-safety for your extended component classes while

// providing homogeneous base types for APIs and underlying data structures.

//

// *Phase Context*

//

// A schedule is a coherent group of one or mode phase/state nodes linked

// together by a graph structure, allowing arbitrary linear/parallel

// relationships to be specified, and executed by stepping through them in

// the graph order.

// Each schedule node points to a phase and holds the execution state of that

// phase, and has optional links to other nodes for synchronization.

//

// The main operations are: construct, add phases, and instantiate

// hierarchically within another schedule.

//

// Structure is a DAG (Directed Acyclic Graph). Each instance is a node

// connected to others to form the graph. Hierarchy is overlaid with m_parent.

// Each node in the graph has zero or more successors, and zero or more

// predecessors. No nodes are completely isolated from others. Exactly

// one node has zero predecessors. This is the root node. Also the graph

// is acyclic, meaning for all nodes in the graph, by following the forward

// arrows you will never end up back where you started but you will eventually

// reach a node that has no successors.

//

// *Phase State*

//

// A given phase may appear multiple times in the complete phase graph, due

// to the multiple independent domain feature, and the ability for different

// VIP to customize their own phase schedules perhaps reusing existing phases.

// Each node instance in the graph maintains its own state of execution.

//

// *Phase Handle*

//

// Handles of this type uvm_phase are used frequently in the API, both by

// the user, to access phasing-specific API, and also as a parameter to some

// APIs. In many cases, the singleton phase handles can be

// used (eg. ) in APIs. For those APIs that need to look

// up that phase in the graph, this is done automatically.

class uvm_phase extends uvm_object;

  //`uvm_object_utils(uvm_phase)

  `uvm_register_cb(uvm_phase, uvm_phase_cb)

  //--------------------

  // Group: Construction

  //--------------------

  // Function: new

  //

  // Create a new phase node, with a name and a note of its type

  //   name   - name of this phase

  //   type   - a value in 

  //

  extern function new(string name="uvm_phase",

                      uvm_phase_type phase_type=UVM_PHASE_SCHEDULE,

                      uvm_phase parent=null);

  // Function: get_phase_type

  //

  // Returns the phase type as defined by 

  //

  extern function uvm_phase_type get_phase_type();

  //-------------

  // Group: State

  //-------------

  // Function: get_state

  //

  // Accessor to return current state of this phase

  //

  extern function uvm_phase_state get_state();

  // Function: get_run_count

  //

  // Accessor to return the integer number of times this phase has executed

  //

  extern function int get_run_count();

  // Function: find_by_name

  //

  // Locate a phase node with the specified ~name~ and return its handle.

  // With ~stay_in_scope~ set, searches only within this phase's schedule or

  // domain.

  //

  extern function uvm_phase find_by_name(string name, bit stay_in_scope=1);

  // Function: find

  //

  // Locate the phase node with the specified ~phase~ IMP and return its handle.

  // With ~stay_in_scope~ set, searches only within this phase's schedule or

  // domain.

  //

  extern function uvm_phase find(uvm_phase phase, bit stay_in_scope=1);

  // Function: is

  //

  // returns 1 if the containing uvm_phase refers to the same phase

  // as the phase argument, 0 otherwise

  //

  extern function bit is(uvm_phase phase);

  // Function: is_before

  //

  // Returns 1 if the containing uvm_phase refers to a phase that is earlier

  // than the phase argument, 0 otherwise

  //

  extern function bit is_before(uvm_phase phase);

  // Function: is_after

  //

  // returns 1 if the containing uvm_phase refers to a phase that is later

  // than the phase argument, 0 otherwise

  //

  extern function bit is_after(uvm_phase phase);

  //-----------------

  // Group: Callbacks

  //-----------------

  // Function: exec_func

  //

  // Implements the functor/delegate functionality for a function phase type

  //   comp  - the component to execute the functionality upon

  //   phase - the phase schedule that originated this phase call

  //

  virtual function void exec_func(uvm_component comp, uvm_phase phase); endfunction

  // Function: exec_task

  //

  // Implements the functor/delegate functionality for a task phase type

  //   comp  - the component to execute the functionality upon

  //   phase - the phase schedule that originated this phase call

  //

  virtual task exec_task(uvm_component comp, uvm_phase phase); endtask

  //----------------

  // Group: Schedule

  //----------------

  // Function: add

  //

  // Build up a schedule structure inserting phase by phase, specifying linkage

  //

  // Phases can be added anywhere, in series or parallel with existing nodes

  //

  //   phase        - handle of singleton derived imp containing actual functor.

  //                  by default the new phase is appended to the schedule

  //   with_phase   - specify to add the new phase in parallel with this one

  //   after_phase  - specify to add the new phase as successor to this one

  //   before_phase - specify to add the new phase as predecessor to this one

  //

  extern function void add(uvm_phase phase,

                           uvm_phase with_phase=null,

                           uvm_phase after_phase=null,

                           uvm_phase before_phase=null);

  // Function: get_parent

  //

  // Returns the parent schedule node, if any, for hierarchical graph traversal

  //

  extern function uvm_phase get_parent();

  // Function: get_full_name

  //

  // Returns the full path from the enclosing domain down to this node.

  // The singleton IMP phases have no hierarchy.

  //

  extern virtual function string get_full_name();

  // Function: get_schedule

  //

  // Returns the topmost parent schedule node, if any, for hierarchical graph traversal

  //

  extern function uvm_phase get_schedule(bit hier = 0);

  // Function: get_schedule_name

  //

  // Returns the schedule name associated with this phase node

  //

  extern function string get_schedule_name(bit hier = 0);

  // Function: get_domain

  //

  // Returns the enclosing domain

  //

  extern function uvm_domain get_domain();

  // Function: get_imp

  //

  // Returns the phase implementation for this this node.

  // Returns ~null~ if this phase type is not a UVM_PHASE_LEAF_NODE.

  //

  extern function uvm_phase get_imp();

  // Function: get_domain_name

  //

  // Returns the domain name associated with this phase node

  //

  extern function string get_domain_name();

  // Function: get_adjacent_predecessor_nodes

  //

  // Provides an array of nodes which are predecessors to

  // ~this~ phase node.  A 'predecessor node' is defined

  // as any phase node which lies prior to ~this~ node in

  // the phase graph, with no nodes between ~this~ node and

  // the predecessor node.

  //

  extern function void get_adjacent_predecessor_nodes(ref uvm_phase pred[]);

  // Function: get_adjacent_successor_nodes

  //

  // Provides an array of nodes which are successors to

  // ~this~ phase node.  A 'successor's node' is defined

  // as any phase node which comes after ~this~ node in

  // the phase graph, with no nodes between ~this~ node

  // and the successor node.

  //

  extern function void get_adjacent_successor_nodes(ref uvm_phase succ[]);

  //-----------------------

  // Group: Phase Done Objection

  //-----------------------

  //

  // Task-based phase nodes within the phasing graph provide a 

  // based interface for prolonging the execution of the phase.  All other

  // phase types do not contain an objection, and will report a fatal error

  // if the user attempts to ~raise~, ~drop~, or ~get_objection_count~.

  // Function- m_report_null_objection

  // Simplifies the reporting of ~null~ objection errors

  extern function void m_report_null_objection(uvm_object obj,

                                               string description,

                                               int count,

                                               string action);

  // Function: get_objection

  //

  // Return the  that gates the termination of the phase.

  //

  function uvm_objection get_objection(); return this.phase_done; endfunction

  // Function: raise_objection

  //

  // Raise an objection to ending this phase

  // Provides components with greater control over the phase flow for

  // processes which are not implicit objectors to the phase.

  //

  //|   while(1) begin

  //|     some_phase.raise_objection(this);

  //|     ...

  //|     some_phase.drop_objection(this);

  //|   end

  //|   ...

  //

  extern virtual function void raise_objection (uvm_object obj,

                                                string description="",

                                                int count=1);

  // Function: drop_objection

  //

  // Drop an objection to ending this phase

  //

  // The drop is expected to be matched with an earlier raise.

  //

  extern virtual function void drop_objection (uvm_object obj,

                                               string description="",

                                               int count=1);

  // Function: get_objection_count

  //

  // Returns the current number of objections to ending this phase raised by the given ~object~.

  //

  extern virtual function int get_objection_count( uvm_object obj=null );

  //-----------------------

  // Group: Synchronization

  //-----------------------

  // The functions 'sync' and 'unsync' add soft sync relationships between nodes

  //

  // Summary of usage:

  //| my_phase.sync(.target(domain)

  //|              [,.phase(phase)[,.with_phase(phase)]]);

  //| my_phase.unsync(.target(domain)

  //|                [,.phase(phase)[,.with_phase(phase)]]);

  //

  // Components in different schedule domains can be phased independently or in sync

  // with each other. An API is provided to specify synchronization rules between any

  // two domains. Synchronization can be done at any of three levels:

  //

  // - the domain's whole phase schedule can be synchronized

  // - a phase can be specified, to sync that phase with a matching counterpart

  // - or a more detailed arbitrary synchronization between any two phases

  //

  // Each kind of synchronization causes the same underlying data structures to

  // be managed. Like other APIs, we use the parameter dot-notation to set

  // optional parameters.

  //

  // When a domain is synced with another domain, all of the matching phases in

  // the two domains get a 'with' relationship between them. Likewise, if a domain

  // is unsynched, all of the matching phases that have a 'with' relationship have

  // the dependency removed. It is possible to sync two domains and then just

  // remove a single phase from the dependency relationship by unsyncing just

  // the one phase.

  // Function: sync

  //

  // Synchronize two domains, fully or partially

  //

  //   target       - handle of target domain to synchronize this one to

  //   phase        - optional single phase in this domain to synchronize,

  //                  otherwise sync all

  //   with_phase   - optional different target-domain phase to synchronize with,

  //                  otherwise use ~phase~ in the target domain

  //

  extern function void sync(uvm_domain target,

                            uvm_phase phase=null,

                            uvm_phase with_phase=null);

  // Function: unsync

  //

  // Remove synchronization between two domains, fully or partially

  //

  //   target       - handle of target domain to remove synchronization from

  //   phase        - optional single phase in this domain to un-synchronize,

  //                  otherwise unsync all

  //   with_phase   - optional different target-domain phase to un-synchronize with,

  //                  otherwise use ~phase~ in the target domain

  //

  extern function void unsync(uvm_domain target,

                              uvm_phase phase=null,

                              uvm_phase with_phase=null);

  // Function: wait_for_state

  //

  // Wait until this phase compares with the given ~state~ and ~op~ operand.

  // For  and  operands, several  can be

  // supplied by ORing their enum constants, in which case the caller will

  // wait until the phase state is any of (UVM_EQ) or none of (UVM_NE) the

  // provided states.

  //

  // To wait for the phase to be at the started state or after

  //

  //| wait_for_state(UVM_PHASE_STARTED, UVM_GTE);

  //

  // To wait for the phase to be either started or executing

  //

  //| wait_for_state(UVM_PHASE_STARTED | UVM_PHASE_EXECUTING, UVM_EQ);

  //

  extern task wait_for_state(uvm_phase_state state, uvm_wait_op op=UVM_EQ);

  //---------------

  // Group: Jumping

  //---------------

  // Force phases to jump forward or backward in a schedule

  //

  // A phasing domain can execute a jump from its current phase to any other.

  // A jump passes phasing control in the current domain from the current phase

  // to a target phase. There are two kinds of jump scope:

  //

  // - local jump to another phase within the current schedule, back- or forwards

  // - global jump of all domains together, either to a point in the master

  //   schedule outwith the current schedule, or by calling jump_all()

  //

  // A jump preserves the existing soft synchronization, so the domain that is

  // ahead of schedule relative to another synchronized domain, as a result of

  // a jump in either domain, will await the domain that is behind schedule.

  //

  // *Note*: A jump out of the local schedule causes other schedules that have

  // the jump node in their schedule to jump as well. In some cases, it is

  // desirable to jump to a local phase in the schedule but to have all

  // schedules that share that phase to jump as well. In that situation, the

  // jump_all static function should be used. This function causes all schedules

  // that share a phase to jump to that phase.

  // Function: jump

  //

  // Jump to a specified ~phase~. If the destination ~phase~ is within the current

  // phase schedule, a simple local jump takes place. If the jump-to ~phase~ is

  // outside of the current schedule then the jump affects other schedules which

  // share the phase.

  //

  extern function void jump(uvm_phase phase);

  // Function: set_jump_phase

  //

  // Specify a phase to transition to when phase is complete.

  // Note that this function is part of what jump() does; unlike jump()

  // it does not set the flag to terminate the phase prematurely.

  extern function void set_jump_phase(uvm_phase phase) ;

  // Function: end_prematurely

  //

  // Set a flag to cause the phase to end prematurely.

  // Note that this function is part of what jump() does; unlike jump()

  // it does not set a jump_phase to go to after the phase ends.

  extern function void end_prematurely() ;

  // Function- jump_all

  //

  // Make all schedules jump to a specified ~phase~, even if the jump target is local.

  // The jump happens to all phase schedules that contain the jump-to ~phase~,

  // i.e. a global jump.

  //

  extern static function void jump_all(uvm_phase phase);

  // Function: get_jump_target

  //

  // Return handle to the target phase of the current jump, or ~null~ if no jump

  // is in progress. Valid for use during the phase_ended() callback

  //

  extern function uvm_phase get_jump_target();

  int unsigned max_ready_to_end_iter = 20;

  //--------------------------

  // Internal - Implementation

  //--------------------------

  // Implementation - Construction

  //------------------------------

  protected uvm_phase_type m_phase_type;

  protected uvm_phase      m_parent;     // our 'schedule' node [or points 'up' one level]

  uvm_phase                m_imp;        // phase imp to call when we execute this node

  // Implementation - State

  //-----------------------

  local uvm_phase_state    m_state;

  local int                m_run_count; // num times this phase has executed

  local process            m_phase_proc;

  int                      m_num_procs_not_yet_returned;

  extern function uvm_phase m_find_predecessor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null);

  extern function uvm_phase m_find_successor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null);

  extern function uvm_phase m_find_predecessor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null);

  extern function uvm_phase m_find_successor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null);

  extern function void m_print_successors();

  // Implementation - Callbacks

  //---------------------------

  // Provide the required component traversal behavior. Called by execute()

  virtual function void traverse(uvm_component comp,

                                 uvm_phase phase,

                                 uvm_phase_state state);

  endfunction

  // Provide the required per-component execution flow. Called by traverse()

  virtual function void execute(uvm_component comp,

                                 uvm_phase phase);

  endfunction

  // Implementation - Schedule

  //--------------------------

  protected bit  m_predecessors[uvm_phase];

  protected bit  m_successors[uvm_phase];

  protected uvm_phase m_end_node;

  // Track the currently executing real task phases (used for debug)

  static protected bit m_executing_phases[uvm_phase];

  function uvm_phase get_begin_node(); if (m_imp != null) return this; return null; endfunction

  function uvm_phase get_end_node();   return m_end_node; endfunction

  // Implementation - Synchronization

  //---------------------------------

  local uvm_phase m_sync[$];  // schedule instance to which we are synced

  uvm_objection phase_done; // phase done objection

  local int unsigned m_ready_to_end_count;

  function int unsigned get_ready_to_end_count();

     return m_ready_to_end_count;

  endfunction

  extern local function void get_predecessors_for_successors(output bit pred_of_succ[uvm_phase]);

  extern local task m_wait_for_pred();

  // Implementation - Jumping

  //-------------------------

  local bit                m_jump_bkwd;

  local bit                m_jump_fwd;

  local uvm_phase          m_jump_phase;

  local bit                m_premature_end;

  extern function void clear(uvm_phase_state state = UVM_PHASE_DORMANT);

  extern function void clear_successors(

                             uvm_phase_state state = UVM_PHASE_DORMANT,

                             uvm_phase end_state=null);

  // Implementation - Overall Control

  //---------------------------------

  local static mailbox #(uvm_phase) m_phase_hopper = new();

  extern static task m_run_phases();

  extern local task  execute_phase();

  extern local function void m_terminate_phase();

  extern local function void m_print_termination_state();

  extern local task wait_for_self_and_siblings_to_drop();

  extern function void kill();

  extern function void kill_successors();

  // TBD add more useful debug

  //---------------------------------

  protected static bit m_phase_trace;

  local static bit m_use_ovm_run_semantic;

  function string convert2string();

  //return $sformatf("PHASE %s = %p",get_name(),this);

  string s;

    s = $sformatf("phase: %s parent=%s  pred=%s  succ=%s",get_name(),

                     (m_parent==null) ? "null" : get_schedule_name(),

                     m_aa2string(m_predecessors),

                     m_aa2string(m_successors));

    return s;

  endfunction

  local function string m_aa2string(bit aa[uvm_phase]); // TBD tidy

    string s;

    int i;

    s = "'{ ";

    foreach (aa[ph]) begin

      uvm_phase n = ph;

      s = {s, (n == null) ? "null" : n.get_name(),

        (i == aa.num()-1) ? "" : ", "};

      i++;

    end

    s = {s, " }"};

    return s;

  endfunction

  function bit is_domain();

    return (m_phase_type == UVM_PHASE_DOMAIN);

  endfunction

  virtual function void m_get_transitive_children(ref uvm_phase phases[$]);

    foreach (m_successors[succ])

    begin

        phases.push_back(succ);

        succ.m_get_transitive_children(phases);

    end

  endfunction

endclass

//------------------------------------------------------------------------------

//

// Class: uvm_phase_state_change

//

//------------------------------------------------------------------------------

//

// Phase state transition descriptor.

// Used to describe the phase transition that caused a

//  callback to be invoked.

//

class uvm_phase_state_change extends uvm_object;

  `uvm_object_utils(uvm_phase_state_change)

  // Implementation -- do not use directly

  /* local */ uvm_phase       m_phase;

  /* local */ uvm_phase_state m_prev_state;

  /* local */ uvm_phase       m_jump_to;

  function new(string name = "uvm_phase_state_change");

    super.new(name);

  endfunction

  // Function: get_state()

  //

  // Returns the state the phase just transitioned to.

  // Functionally equivalent to .

  //

  virtual function uvm_phase_state get_state();

    return m_phase.get_state();

  endfunction

  // Function: get_prev_state()

  //

  // Returns the state the phase just transitioned from.

  //

  virtual function uvm_phase_state get_prev_state();

    return m_prev_state;

  endfunction

  // Function: jump_to()

  //

  // If the current state is ~UVM_PHASE_ENDED~ or ~UVM_PHASE_JUMPING~ because of

  // a phase jump, returns the phase that is the target of jump.

  // Returns ~null~ otherwise.

  //

  function uvm_phase jump_to();

    return m_jump_to;

  endfunction

endclass

//------------------------------------------------------------------------------

//

// Class: uvm_phase_cb

//

//------------------------------------------------------------------------------

//

// This class defines a callback method that is invoked by the phaser

// during the execution of a specific node in the phase graph or all phase nodes.

// User-defined callback extensions can be used to integrate data types that

// are not natively phase-aware with the UVM phasing.

//

class uvm_phase_cb extends uvm_callback;

  // Function: new

  // Constructor

  function new(string name="unnamed-uvm_phase_cb");

     super.new(name);

  endfunction : new

  // Function: phase_state_change

  //

  // Called whenever a ~phase~ changes state.

  // The ~change~ descriptor describes the transition that was just completed.

  // The callback method is invoked immediately after the phase state has changed,

  // but before the phase implementation is executed.

  //

  // An extension may interact with the phase,

  // such as raising the phase objection to prolong the phase,

  // in a manner that is consistent with the current phase state.

  //

  // By default, the callback method does nothing.

  // Unless otherwise specified, modifying the  phase transition descriptor has

  // no effect on the phasing schedule or execution.

  //

  virtual function void phase_state_change(uvm_phase phase,

                                           uvm_phase_state_change change);

  endfunction

endclass

//------------------------------------------------------------------------------

//

// Class: uvm_phase_cb_pool

//

//------------------------------------------------------------------------------

//

// Convenience type for the uvm_callbacks#(uvm_phase, uvm_phase_cb) class.

//

typedef uvm_callbacks#(uvm_phase, uvm_phase_cb) uvm_phase_cb_pool;

//------------------------------------------------------------------------------

//                               IMPLEMENTATION

//------------------------------------------------------------------------------

typedef class uvm_cmdline_processor;

`define UVM_PH_TRACE(ID,MSG,PH,VERB) \

   `uvm_info(ID, {$sformatf("Phase '%0s' (id=%0d) ", \

       PH.get_full_name(), PH.get_inst_id()),MSG}, VERB);

//-----------------------------

// Implementation - Construction

//-----------------------------

// new

function uvm_phase::new(string name="uvm_phase",

                        uvm_phase_type phase_type=UVM_PHASE_SCHEDULE,

                        uvm_phase parent=null);

  super.new(name);

  m_phase_type = phase_type;

  // The common domain is the only thing that initializes m_state.  All

  // other states are initialized by being 'added' to a schedule.

  if ((name == "common") &&

      (phase_type == UVM_PHASE_DOMAIN))

    m_state = UVM_PHASE_DORMANT;

  m_run_count = 0;

  m_parent = parent;

  begin

    uvm_cmdline_processor clp = uvm_cmdline_processor::get_inst();

    string val;

    if (clp.get_arg_value("+UVM_PHASE_TRACE", val))

      m_phase_trace = 1;

    else

      m_phase_trace = 0;

    if (clp.get_arg_value("+UVM_USE_OVM_RUN_SEMANTIC", val))

      m_use_ovm_run_semantic = 1;

    else

      m_use_ovm_run_semantic = 0;

  end

  if (parent == null && (phase_type == UVM_PHASE_SCHEDULE ||

                         phase_type == UVM_PHASE_DOMAIN )) begin

    //m_parent = this;

    m_end_node = new({name,"_end"}, UVM_PHASE_TERMINAL, this);

    this.m_successors[m_end_node] = 1;

    m_end_node.m_predecessors[this] = 1;

  end

endfunction

// add

// ---

// TBD error checks if param nodes are actually in this schedule or not

function void uvm_phase::add(uvm_phase phase,

                             uvm_phase with_phase=null,

                             uvm_phase after_phase=null,

                             uvm_phase before_phase=null);

  uvm_phase new_node, begin_node, end_node, tmp_node;

  uvm_phase_state_change state_chg;

  if (phase == null)

      `uvm_fatal("PH/NULL", "add: phase argument is null")

  if (with_phase != null && with_phase.get_phase_type() == UVM_PHASE_IMP) begin

    string nm = with_phase.get_name();

    with_phase = find(with_phase);

    if (with_phase == null)

      `uvm_fatal("PH_BAD_ADD",

         {"cannot find with_phase '",nm,"' within node '",get_name(),"'"})

  end

  if (before_phase != null && before_phase.get_phase_type() == UVM_PHASE_IMP) begin

    string nm = before_phase.get_name();

    before_phase = find(before_phase);

    if (before_phase == null)

      `uvm_fatal("PH_BAD_ADD",

         {"cannot find before_phase '",nm,"' within node '",get_name(),"'"})

  end

  if (after_phase != null && after_phase.get_phase_type() == UVM_PHASE_IMP) begin

    string nm = after_phase.get_name();

    after_phase = find(after_phase);

    if (after_phase == null)

      `uvm_fatal("PH_BAD_ADD",

         {"cannot find after_phase '",nm,"' within node '",get_name(),"'"})

  end

  if (with_phase != null && (after_phase != null || before_phase != null))

    `uvm_fatal("PH_BAD_ADD",

       "cannot specify both 'with' and 'before/after' phase relationships")

  if (before_phase == this || after_phase == m_end_node || with_phase == m_end_node)

    `uvm_fatal("PH_BAD_ADD",

       "cannot add before begin node, after end node, or with end nodes")

  // If we are inserting a new "leaf node"

  if (phase.get_phase_type() == UVM_PHASE_IMP) begin

    uvm_task_phase tp;

    new_node = new(phase.get_name(),UVM_PHASE_NODE,this);

    new_node.m_imp = phase;

    begin_node = new_node;

    end_node = new_node;

    // The phase_done objection is only required

    // for task-based nodes

    if ($cast(tp, phase)) begin

       if (new_node.get_name() == "run") begin

         new_node.phase_done = uvm_test_done_objection::get();

       end

       else begin

         new_node.phase_done = uvm_objection::type_id::create({phase.get_name(), "_objection"});

       end

    end

  end

  // We are inserting an existing schedule

  else begin

    begin_node = phase;

    end_node   = phase.m_end_node;

    phase.m_parent = this;

  end

  // If 'with_phase' is us, then insert node in parallel

  /*

  if (with_phase == this) begin

    after_phase = this;

    before_phase = m_end_node;

  end

  */

  // If no before/after/with specified, insert at end of this schedule

  if (with_phase == null && after_phase == null && before_phase == null) begin

    before_phase = m_end_node;

  end

  if (m_phase_trace) begin

    uvm_phase_type typ = phase.get_phase_type();

    `uvm_info("PH/TRC/ADD_PH",

      {get_name()," (",m_phase_type.name(),") ADD_PHASE: phase=",phase.get_full_name()," (",

      typ.name(),", inst_id=",$sformatf("%0d",phase.get_inst_id()),")",

      " with_phase=",   (with_phase == null)   ? "null" : with_phase.get_name(),

      " after_phase=",  (after_phase == null)  ? "null" : after_phase.get_name(),

      " before_phase=", (before_phase == null) ? "null" : before_phase.get_name(),

      " new_node=",     (new_node == null)     ? "null" : {new_node.get_name(),

                                                           " inst_id=",

                                                           $sformatf("%0d",new_node.get_inst_id())},

      " begin_node=",   (begin_node == null)   ? "null" : begin_node.get_name(),

      " end_node=",     (end_node == null)     ? "null" : end_node.get_name()},UVM_DEBUG)

  end

  // INSERT IN PARALLEL WITH 'WITH' PHASE

  if (with_phase != null) begin

    begin_node.m_predecessors = with_phase.m_predecessors;

    end_node.m_successors = with_phase.m_successors;

    foreach (with_phase.m_predecessors[pred])

      pred.m_successors[begin_node] = 1;

    foreach (with_phase.m_successors[succ])

      succ.m_predecessors[end_node] = 1;

  end