| // | |
| //---------------------------------------------------------------------- | |
| // Copyright 2007-2011 Mentor Graphics Corporation | |
| // Copyright 2007-2010 Cadence Design Systems, Inc. | |
| // Copyright 2010 Synopsys, 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; | |
| //------------------------------------------------------------------------------ | |
| // | |
| // 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. | |
| // | |
| // *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 it's 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 package-global phase handles can be | |
| // used (eg. connect_ph, run_ph) 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) | |
| //-------------------- | |
| // Group: Construction | |
| //-------------------- | |
| // Function: new | |
| // | |
| // Create a new phase node, with a name and a note of its type | |
| // name - name of this phase | |
| // type - task, topdown func or bottomup func | |
| // | |
| 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 <uvm_phase_type> | |
| // | |
| 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(); | |
| //----------------------- | |
| // Group: Synchronization | |
| //----------------------- | |
| // Function: get_objection | |
| // | |
| // Return the <uvm_objection> 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); | |
| // 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 <UVM_EQ> and <UVM_NE> operands, several <uvm_phase_states> 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: 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; | |
| 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 | |
| //------------------------------------------------------------------------------ | |
| // 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; | |
| if (name == "run") | |
| phase_done = uvm_test_done_objection::get(); | |
| else begin | |
| phase_done = new({name,"_objection"}); | |
| end | |
| 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; | |
| 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 | |
| new_node = new(phase.get_name(),UVM_PHASE_NODE,this); | |
| new_node.m_imp = phase; | |
| begin_node = new_node; | |
| end_node = new_node; | |
| 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 | |
| // INSERT BEFORE PHASE | |
| else if (before_phase != null && after_phase == null) begin | |
| begin_node.m_predecessors = before_phase.m_predecessors; | |
| end_node.m_successors[before_phase] = 1; | |
| foreach (before_phase.m_predecessors[pred]) begin | |
| pred.m_successors.delete(before_phase); | |
| pred.m_successors[begin_node] = 1; | |
| end | |
| before_phase.m_predecessors.delete(); | |
| before_phase.m_predecessors[end_node] = 1; | |
| end | |
| // INSERT AFTER PHASE | |
| else if (before_phase == null && after_phase != null) begin | |
| end_node.m_successors = after_phase.m_successors; | |
| begin_node.m_predecessors[after_phase] = 1; | |
| foreach (after_phase.m_successors[succ]) begin | |
| succ.m_predecessors.delete(after_phase); | |
| succ.m_predecessors[end_node] = 1; | |
| end | |
| after_phase.m_successors.delete(); | |
| after_phase.m_successors[begin_node] = 1; | |
| end | |
| // IN BETWEEN 'BEFORE' and 'AFTER' PHASES | |
| else if (before_phase != null && after_phase != null) begin | |
| if (!after_phase.is_before(before_phase)) begin | |
| `uvm_fatal("PH_ADD_PHASE",{"Phase '",before_phase.get_name(), | |
| "' is not before phase '",after_phase.get_name(),"'"}) | |
| end | |
| // before and after? add 1 pred and 1 succ | |
| begin_node.m_predecessors[after_phase] = 1; | |
| end_node.m_successors[before_phase] = 1; | |
| after_phase.m_successors[begin_node] = 1; | |
| before_phase.m_predecessors[end_node] = 1; | |
| if (after_phase.m_successors.exists(before_phase)) begin | |
| after_phase.m_successors.delete(before_phase); | |
| before_phase.m_successors.delete(after_phase); | |
| end | |
| end | |
| endfunction | |
| // get_parent | |
| // ---------- | |
| function uvm_phase uvm_phase::get_parent(); | |
| return m_parent; | |
| endfunction | |
| // get_imp | |
| // ------- | |
| function uvm_phase uvm_phase::get_imp(); | |
| return m_imp; | |
| endfunction | |
| // get_schedule | |
| // ------------ | |
| function uvm_phase uvm_phase::get_schedule(bit hier=0); | |
| uvm_phase sched; | |
| sched = this; | |
| if (hier) | |
| while (sched.m_parent != null && (sched.m_parent.get_phase_type() == UVM_PHASE_SCHEDULE)) | |
| sched = sched.m_parent; | |
| if (sched.m_phase_type == UVM_PHASE_SCHEDULE) | |
| return sched; | |
| if (sched.m_phase_type == UVM_PHASE_NODE) | |
| if (m_parent != null && m_parent.m_phase_type != UVM_PHASE_DOMAIN) | |
| return m_parent; | |
| return null; | |
| endfunction | |
| // get_domain | |
| // ---------- | |
| function uvm_domain uvm_phase::get_domain(); | |
| uvm_phase phase; | |
| phase = this; | |
| while (phase != null && phase.m_phase_type != UVM_PHASE_DOMAIN) | |
| phase = phase.m_parent; | |
| if (phase == null) // no parent domain | |
| return null; | |
| if(!$cast(get_domain,phase)) | |
| `uvm_fatal("PH/INTERNAL", "get_domain: m_phase_type is DOMAIN but $cast to uvm_domain fails") | |
| endfunction | |
| // get_domain_name | |
| // --------------- | |
| function string uvm_phase::get_domain_name(); | |
| uvm_domain domain; | |
| domain = get_domain(); | |
| if (domain == null) | |
| return "unknown"; | |
| return domain.get_name(); | |
| endfunction | |
| // get_schedule_name | |
| // ----------------- | |
| function string uvm_phase::get_schedule_name(bit hier=0); | |
| uvm_phase sched; | |
| string s; | |
| sched = get_schedule(hier); | |
| if (sched == null) | |
| return ""; | |
| s = sched.get_name(); | |
| while (sched.m_parent != null && sched.m_parent != sched && | |
| (sched.m_parent.get_phase_type() == UVM_PHASE_SCHEDULE)) begin | |
| sched = sched.m_parent; | |
| s = {sched.get_name(),(s.len()>0?".":""),s}; | |
| end | |
| return s; | |
| endfunction | |
| // get_full_name | |
| // ------------- | |
| function string uvm_phase::get_full_name(); | |
| string dom, sch; | |
| if (m_phase_type == UVM_PHASE_IMP) | |
| return get_name(); | |
| get_full_name = get_domain_name(); | |
| sch = get_schedule_name(); | |
| if (sch != "") | |
| get_full_name = {get_full_name, ".", sch}; | |
| if (m_phase_type != UVM_PHASE_DOMAIN && m_phase_type != UVM_PHASE_SCHEDULE) | |
| get_full_name = {get_full_name, ".", get_name()}; | |
| endfunction | |
| // get_phase_type | |
| // -------------- | |
| function uvm_phase_type uvm_phase::get_phase_type(); | |
| return m_phase_type; | |
| endfunction | |
| //----------------------- | |
| // Implementation - State | |
| //----------------------- | |
| // get_state | |
| // --------- | |
| function uvm_phase_state uvm_phase::get_state(); | |
| return m_state; | |
| endfunction | |
| // get_run_count | |
| // ------------- | |
| function int uvm_phase::get_run_count(); | |
| return m_run_count; | |
| endfunction | |
| // m_print_successors | |
| // ------------------ | |
| function void uvm_phase::m_print_successors(); | |
| uvm_phase found; | |
| static string spaces = " "; | |
| static int level; | |
| if (m_phase_type == UVM_PHASE_DOMAIN) | |
| level = 0; | |
| $display(spaces.substr(0,level*2),get_name(), " (",m_phase_type.name(),") id=%0d",get_inst_id()); | |
| level++; | |
| foreach (m_successors[succ]) begin | |
| succ.m_print_successors(); | |
| end | |
| level--; | |
| endfunction | |
| // m_find_predecessor | |
| // ------------------ | |
| function uvm_phase uvm_phase::m_find_predecessor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null); | |
| uvm_phase found; | |
| //$display(" FIND PRED node '",phase.get_name(),"' (id=",$sformatf("%0d",phase.get_inst_id()),") - checking against ",get_name()," (",m_phase_type.name()," id=",$sformatf("%0d",get_inst_id()),(m_imp==null)?"":{"/",$sformatf("%0d",m_imp.get_inst_id())},")"); | |
| if (phase == null) begin | |
| return null ; | |
| end | |
| if (phase == m_imp || phase == this) | |
| return this; | |
| foreach (m_predecessors[pred]) begin | |
| uvm_phase orig; | |
| orig = (orig_phase==null) ? this : orig_phase; | |
| if (!stay_in_scope || | |
| (pred.get_schedule() == orig.get_schedule()) || | |
| (pred.get_domain() == orig.get_domain())) begin | |
| found = pred.m_find_predecessor(phase,stay_in_scope,orig); | |
| if (found != null) | |
| return found; | |
| end | |
| end | |
| return null; | |
| endfunction | |
| // m_find_predecessor_by_name | |
| // -------------------------- | |
| function uvm_phase uvm_phase::m_find_predecessor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null); | |
| uvm_phase found; | |
| //$display(" FIND PRED node '",name,"' - checking against ",get_name()," (",m_phase_type.name()," id=",$sformatf("%0d",get_inst_id()),(m_imp==null)?"":{"/",$sformatf("%0d",m_imp.get_inst_id())},")"); | |
| if (get_name() == name) | |
| return this; | |
| foreach (m_predecessors[pred]) begin | |
| uvm_phase orig; | |
| orig = (orig_phase==null) ? this : orig_phase; | |
| if (!stay_in_scope || | |
| (pred.get_schedule() == orig.get_schedule()) || | |
| (pred.get_domain() == orig.get_domain())) begin | |
| found = pred.m_find_predecessor_by_name(name,stay_in_scope,orig); | |
| if (found != null) | |
| return found; | |
| end | |
| end | |
| return null; | |
| endfunction | |
| // m_find_successor | |
| // ---------------- | |
| function uvm_phase uvm_phase::m_find_successor(uvm_phase phase, bit stay_in_scope=1, uvm_phase orig_phase=null); | |
| uvm_phase found; | |
| //$display(" FIND SUCC node '",phase.get_name(),"' (id=",$sformatf("%0d",phase.get_inst_id()),") - checking against ",get_name()," (",m_phase_type.name()," id=",$sformatf("%0d",get_inst_id()),(m_imp==null)?"":{"/",$sformatf("%0d",m_imp.get_inst_id())},")"); | |
| if (phase == null) begin | |
| return null ; | |
| end | |
| if (phase == m_imp || phase == this) begin | |
| return this; | |
| end | |
| foreach (m_successors[succ]) begin | |
| uvm_phase orig; | |
| orig = (orig_phase==null) ? this : orig_phase; | |
| if (!stay_in_scope || | |
| (succ.get_schedule() == orig.get_schedule()) || | |
| (succ.get_domain() == orig.get_domain())) begin | |
| found = succ.m_find_successor(phase,stay_in_scope,orig); | |
| if (found != null) begin | |
| return found; | |
| end | |
| end | |
| end | |
| return null; | |
| endfunction | |
| // m_find_successor_by_name | |
| // ------------------------ | |
| function uvm_phase uvm_phase::m_find_successor_by_name(string name, bit stay_in_scope=1, uvm_phase orig_phase=null); | |
| uvm_phase found; | |
| //$display(" FIND SUCC node '",name,"' - checking against ",get_name()," (",m_phase_type.name()," id=",$sformatf("%0d",get_inst_id()),(m_imp==null)?"":{"/",$sformatf("%0d",m_imp.get_inst_id())},")"); | |
| if (get_name() == name) | |
| return this; | |
| foreach (m_successors[succ]) begin | |
| uvm_phase orig; | |
| orig = (orig_phase==null) ? this : orig_phase; | |
| if (!stay_in_scope || | |
| (succ.get_schedule() == orig.get_schedule()) || | |
| (succ.get_domain() == orig.get_domain())) begin | |
| found = succ.m_find_successor_by_name(name,stay_in_scope,orig); | |
| if (found != null) | |
| return found; | |
| end | |
| end | |
| return null; | |
| endfunction | |
| // find | |
| // ---- | |
| function uvm_phase uvm_phase::find(uvm_phase phase, bit stay_in_scope=1); | |
| // TBD full search | |
| //$display({"\nFIND node '",phase.get_name(),"' within ",get_name()," (scope ",m_phase_type.name(),")", (stay_in_scope) ? " staying within scope" : ""}); | |
| if (phase == m_imp || phase == this) | |
| return phase; | |
| find = m_find_predecessor(phase,stay_in_scope,this); | |
| if (find == null) | |
| find = m_find_successor(phase,stay_in_scope,this); | |
| endfunction | |
| // find_by_name | |
| // ------------ | |
| function uvm_phase uvm_phase::find_by_name(string name, bit stay_in_scope=1); | |
| // TBD full search | |
| //$display({"\nFIND node named '",name,"' within ",get_name()," (scope ",m_phase_type.name(),")", (stay_in_scope) ? " staying within scope" : ""}); | |
| if (get_name() == name) | |
| return this; | |
| find_by_name = m_find_predecessor_by_name(name,stay_in_scope,this); | |
| if (find_by_name == null) | |
| find_by_name = m_find_successor_by_name(name,stay_in_scope,this); | |
| endfunction | |
| // is | |
| // -- | |
| function bit uvm_phase::is(uvm_phase phase); | |
| return (m_imp == phase || this == phase); | |
| endfunction | |
| // is_before | |
| // --------- | |
| function bit uvm_phase::is_before(uvm_phase phase); | |
| //$display("this=%s is before phase=%s?",get_name(),phase.get_name()); | |
| // TODO: add support for 'stay_in_scope=1' functionality | |
| return (!is(phase) && m_find_successor(phase,0,this) != null); | |
| endfunction | |
| // is_after | |
| // -------- | |
| function bit uvm_phase::is_after(uvm_phase phase); | |
| //$display("this=%s is after phase=%s?",get_name(),phase.get_name()); | |
| // TODO: add support for 'stay_in_scope=1' functionality | |
| return (!is(phase) && m_find_predecessor(phase,0,this) != null); | |
| endfunction | |
| // execute_phase | |
| // ------------- | |
| task uvm_phase::execute_phase(); | |
| uvm_task_phase task_phase; | |
| uvm_root top; | |
| top = uvm_root::get(); | |
| // If we got here by jumping forward, we must wait for | |
| // all its predecessor nodes to be marked DONE. | |
| // (the next conditional speeds this up) | |
| // Also, this helps us fast-forward through terminal (end) nodes | |
| foreach (m_predecessors[pred]) | |
| wait (pred.m_state == UVM_PHASE_DONE); | |
| // If DONE (by, say, a forward jump), return immed | |
| if (m_state == UVM_PHASE_DONE) | |
| return; | |
| //--------- | |
| // SYNCING: | |
| //--------- | |
| // Wait for phases with which we have a sync() | |
| // relationship to be ready. Sync can be 2-way - | |
| // this additional state avoids deadlock. | |
| if (m_sync.size()) begin | |
| m_state = UVM_PHASE_SYNCING; | |
| foreach (m_sync[i]) begin | |
| wait (m_sync[i].m_state >= UVM_PHASE_SYNCING); | |
| end | |
| end | |
| m_run_count++; | |
| if (m_phase_trace) begin | |
| `UVM_PH_TRACE("PH/TRC/STRT","Starting phase",this,UVM_LOW) | |
| end | |
| // If we're a schedule or domain, then "fake" execution | |
| if (m_phase_type != UVM_PHASE_NODE) begin | |
| m_state = UVM_PHASE_STARTED; | |
| #0; | |
| m_state = UVM_PHASE_EXECUTING; | |
| #0; | |
| end | |
| else begin // PHASE NODE | |
| //--------- | |
| // STARTED: | |
| //--------- | |
| m_state = UVM_PHASE_STARTED; | |
| m_imp.traverse(top,this,UVM_PHASE_STARTED); | |
| m_ready_to_end_count = 0 ; // reset the ready_to_end count when phase starts | |
| #0; // LET ANY WAITERS WAKE UP | |
| //if (m_imp.get_phase_type() != UVM_PHASE_TASK) begin | |
| if (!$cast(task_phase,m_imp)) begin | |
| //----------- | |
| // EXECUTING: (function phases) | |
| //----------- | |
| m_state = UVM_PHASE_EXECUTING; | |
| #0; // LET ANY WAITERS WAKE UP | |
| m_imp.traverse(top,this,UVM_PHASE_EXECUTING); | |
| end | |
| else begin | |
| m_executing_phases[this] = 1; | |
| fork : master_phase_process | |
| begin | |
| m_phase_proc = process::self(); | |
| //----------- | |
| // EXECUTING: (task phases) | |
| //----------- | |
| m_state = UVM_PHASE_EXECUTING; | |
| task_phase.traverse(top,this,UVM_PHASE_EXECUTING); | |
| wait(0); // stay alive for later kill | |
| end | |
| join_none | |
| uvm_wait_for_nba_region(); //Give sequences, etc. a chance to object | |
| // Now wait for one of three criterion for end-of-phase. | |
| fork | |
| begin // guard | |
| fork | |
| // JUMP | |
| begin | |
| wait (m_jump_fwd || m_jump_bkwd); | |
| `UVM_PH_TRACE("PH/TRC/EXE/JUMP","PHASE EXIT ON JUMP REQUEST",this,UVM_DEBUG) | |
| end | |
| // WAIT_FOR_ALL_DROPPED | |
| begin | |
| bit do_ready_to_end ; // bit used for ready_to_end iterations | |
| // OVM semantic: don't end until objection raised or stop request | |
| if (phase_done.get_objection_total(top) || | |
| m_use_ovm_run_semantic && m_imp.get_name() == "run") begin | |
| if (!phase_done.m_top_all_dropped) | |
| phase_done.wait_for(UVM_ALL_DROPPED, top); | |
| `UVM_PH_TRACE("PH/TRC/EXE/ALLDROP","PHASE EXIT ALL_DROPPED",this,UVM_DEBUG) | |
| end | |
| else begin | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/SKIP","No objections raised, skipping phase",this,UVM_LOW) | |
| end | |
| wait_for_self_and_siblings_to_drop() ; | |
| do_ready_to_end = 1; | |
| //-------------- | |
| // READY_TO_END: | |
| //-------------- | |
| while (do_ready_to_end) begin | |
| uvm_wait_for_nba_region(); // Let all siblings see no objections before traverse might raise another | |
| `UVM_PH_TRACE("PH_READY_TO_END","PHASE READY TO END",this,UVM_DEBUG) | |
| m_ready_to_end_count++; | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH_READY_TO_END_CB","CALLING READY_TO_END CB",this,UVM_HIGH) | |
| m_state = UVM_PHASE_READY_TO_END; | |
| if (m_imp != null) | |
| m_imp.traverse(top,this,UVM_PHASE_READY_TO_END); | |
| uvm_wait_for_nba_region(); // Give traverse targets a chance to object | |
| wait_for_self_and_siblings_to_drop(); | |
| do_ready_to_end = (m_state == UVM_PHASE_EXECUTING) && (m_ready_to_end_count < max_ready_to_end_iter) ; //when we don't wait in task above, we drop out of while loop | |
| end | |
| end | |
| // TIMEOUT | |
| begin | |
| if (this.get_name() == "run") begin | |
| if (top.phase_timeout == 0) | |
| wait(top.phase_timeout != 0); | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/TO_WAIT", $sformatf("STARTING PHASE TIMEOUT WATCHDOG (timeout == %t)", top.phase_timeout), this, UVM_HIGH) | |
| `uvm_delay(top.phase_timeout) | |
| if ($time == `UVM_DEFAULT_TIMEOUT) begin | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/TIMEOUT", "PHASE TIMEOUT WATCHDOG EXPIRED", this, UVM_LOW) | |
| foreach (m_executing_phases[p]) begin | |
| if (p.phase_done.get_objection_total() > 0) begin | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/TIMEOUT/OBJCTN", | |
| $sformatf("Phase '%s' has outstanding objections:\n%s", p.get_full_name(), p.phase_done.convert2string()), | |
| this, | |
| UVM_LOW) | |
| end | |
| end | |
| `uvm_fatal("PH_TIMEOUT", | |
| $sformatf("Default timeout of %0t hit, indicating a probable testbench issue", | |
| `UVM_DEFAULT_TIMEOUT)) | |
| end | |
| else begin | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/TIMEOUT", "PHASE TIMEOUT WATCHDOG EXPIRED", this, UVM_LOW) | |
| foreach (m_executing_phases[p]) begin | |
| if (p.phase_done.get_objection_total() > 0) begin | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/TIMEOUT/OBJCTN", | |
| $sformatf("Phase '%s' has outstanding objections:\n%s", p.get_full_name(), p.phase_done.convert2string()), | |
| this, | |
| UVM_LOW) | |
| end | |
| end | |
| `uvm_fatal("PH_TIMEOUT", | |
| $sformatf("Explicit timeout of %0t hit, indicating a probable testbench issue", | |
| top.phase_timeout)) | |
| end | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/EXE/3","PHASE EXIT TIMEOUT",this,UVM_DEBUG) | |
| end // if (this.get_name() == "run") | |
| else begin | |
| wait (0); // never unblock for non-run phase | |
| end | |
| end // if (m_phase_trace) | |
| join_any | |
| disable fork; | |
| end | |
| join // guard | |
| end | |
| end | |
| m_executing_phases.delete(this); | |
| //--------- | |
| // JUMPING: | |
| //--------- | |
| // If jump_to() was called then we need to kill all the successor | |
| // phases which may still be running and then initiate the new | |
| // phase. The return is necessary so we don't start new successor | |
| // phases. If we are doing a forward jump then we want to set the | |
| // state of this phase's successors to UVM_PHASE_DONE. This | |
| // will let us pretend that all the phases between here and there | |
| // were executed and completed. Thus any dependencies will be | |
| // satisfied preventing deadlocks. | |
| // GSA TBD insert new jump support | |
| if (m_phase_type == UVM_PHASE_NODE) begin | |
| if(m_jump_fwd || m_jump_bkwd) begin | |
| `uvm_info("PH_JUMP", | |
| $sformatf("phase %s (schedule %s, domain %s) is jumping to phase %s", | |
| get_name(), get_schedule_name(), get_domain_name(), m_jump_phase.get_name()), | |
| UVM_MEDIUM); | |
| #0; // LET ANY WAITERS ON READY_TO_END TO WAKE UP | |
| // execute 'phase_ended' callbacks | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH_END","JUMPING OUT OF PHASE",this,UVM_HIGH) | |
| m_state = UVM_PHASE_ENDED; | |
| if (m_imp != null) | |
| m_imp.traverse(top,this,UVM_PHASE_ENDED); | |
| #0; // LET ANY WAITERS WAKE UP | |
| m_state = UVM_PHASE_JUMPING; | |
| if (m_phase_proc != null) begin | |
| m_phase_proc.kill(); | |
| m_phase_proc = null; | |
| end | |
| #0; // LET ANY WAITERS WAKE UP | |
| phase_done.clear(); | |
| if(m_jump_fwd) begin | |
| clear_successors(UVM_PHASE_DONE,m_jump_phase); | |
| end | |
| m_jump_phase.clear_successors(); | |
| m_jump_fwd = 0; | |
| m_jump_bkwd = 0; | |
| void'(m_phase_hopper.try_put(m_jump_phase)); | |
| m_jump_phase = null; | |
| return; | |
| end | |
| // WAIT FOR PREDECESSORS: // WAIT FOR PREDECESSORS: | |
| // function phases only | |
| if (task_phase == null) | |
| m_wait_for_pred(); | |
| //------- | |
| // ENDED: | |
| //------- | |
| // execute 'phase_ended' callbacks | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH_END","ENDING PHASE",this,UVM_HIGH) | |
| m_state = UVM_PHASE_ENDED; | |
| if (m_imp != null) | |
| m_imp.traverse(top,this,UVM_PHASE_ENDED); | |
| #0; // LET ANY WAITERS WAKE UP | |
| //--------- | |
| // CLEANUP: | |
| //--------- | |
| // kill this phase's threads | |
| m_state = UVM_PHASE_CLEANUP; | |
| if (m_phase_proc != null) begin | |
| m_phase_proc.kill(); | |
| m_phase_proc = null; | |
| end | |
| #0; // LET ANY WAITERS WAKE UP | |
| phase_done.clear(); | |
| end | |
| //------ | |
| // DONE: | |
| //------ | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/DONE","Completed phase",this,UVM_LOW) | |
| m_state = UVM_PHASE_DONE; | |
| m_phase_proc = null; | |
| #0; // LET ANY WAITERS WAKE UP | |
| //----------- | |
| // SCHEDULED: | |
| //----------- | |
| // If more successors, schedule them to run now | |
| if (m_successors.size() == 0) begin | |
| top.m_phase_all_done=1; | |
| end | |
| else begin | |
| // execute all the successors | |
| foreach (m_successors[succ]) begin | |
| if(succ.m_state < UVM_PHASE_SCHEDULED) begin | |
| succ.m_state = UVM_PHASE_SCHEDULED; | |
| #0; // LET ANY WAITERS WAKE UP | |
| void'(m_phase_hopper.try_put(succ)); | |
| if (m_phase_trace) | |
| `UVM_PH_TRACE("PH/TRC/SCHEDULED",{"Scheduled from phase ",get_full_name()},succ,UVM_LOW) | |
| end | |
| end | |
| end | |
| endtask | |
| function void uvm_phase::get_predecessors_for_successors(output bit pred_of_succ[uvm_phase]); | |
| bit done; | |
| bit successors[uvm_phase]; | |
| // get all successors | |
| foreach (m_successors[succ]) | |
| successors[succ] = 1; | |
| // replace TERMINAL or SCHEDULE nodes with their successors | |
| do begin | |
| done=1; | |
| foreach (successors[succ]) begin | |
| if (succ.get_phase_type() != UVM_PHASE_NODE) begin | |
| successors.delete(succ); | |
| foreach (succ.m_successors[next_succ]) | |
| successors[next_succ] = 1; | |
| done = 0; | |
| end | |
| end | |
| end while(!done); | |
| // get all predecessors to these successors | |
| foreach (successors[succ]) | |
| foreach (succ.m_predecessors[pred]) | |
| pred_of_succ[pred] = 1; | |
| // replace any terminal nodes with their predecessors, recursively. | |
| // we are only interested in "real" phase nodes | |
| do begin | |
| done=1; | |
| foreach (pred_of_succ[pred]) begin | |
| if (pred.get_phase_type() != UVM_PHASE_NODE) begin | |
| pred_of_succ.delete(pred); | |
| foreach (pred.m_predecessors[next_pred]) | |
| pred_of_succ[next_pred] = 1; | |
| done =0; | |
| end | |
| end | |
| end while (!done); | |
| // remove ourselves from the list | |
| pred_of_succ.delete(this); | |
| endfunction | |
| // m_wait_for_pred | |
| // --------------- | |
| task uvm_phase::m_wait_for_pred(); | |
| if(!(m_jump_fwd || m_jump_bkwd)) begin | |
| bit pred_of_succ[uvm_phase]; | |
| get_predecessors_for_successors(pred_of_succ); | |
| // wait for predecessors to successors (real phase nodes, not terminals) | |
| // mostly debug msgs | |
| foreach (pred_of_succ[sibling]) begin | |
| if (m_phase_trace) begin | |
| string s; | |
| s = $sformatf("Waiting for phase '%s' (%0d) to be READY_TO_END. Current state is %s", | |
| sibling.get_name(),sibling.get_inst_id(),sibling.m_state.name()); | |
| `UVM_PH_TRACE("PH/TRC/WAIT_PRED_OF_SUCC",s,this,UVM_HIGH) | |
| end | |
| sibling.wait_for_state(UVM_PHASE_READY_TO_END, UVM_GTE); | |
| if (m_phase_trace) begin | |
| string s; | |
| s = $sformatf("Phase '%s' (%0d) is now READY_TO_END. Releasing phase", | |
| sibling.get_name(),sibling.get_inst_id()); | |
| `UVM_PH_TRACE("PH/TRC/WAIT_PRED_OF_SUCC",s,this,UVM_HIGH) | |
| end | |
| end | |
| if (m_phase_trace) begin | |
| if (pred_of_succ.num()) begin | |
| string s = "( "; | |
| foreach (pred_of_succ[pred]) | |
| s = {s, pred.get_full_name()," "}; | |
| s = {s, ")"}; | |
| `UVM_PH_TRACE("PH/TRC/WAIT_PRED_OF_SUCC", | |
| {"*** All pred to succ ",s," in READY_TO_END state, so ending phase ***"},this,UVM_HIGH) | |
| end | |
| else begin | |
| `UVM_PH_TRACE("PH/TRC/WAIT_PRED_OF_SUCC", | |
| "*** No pred to succ other than myself, so ending phase ***",this,UVM_HIGH) | |
| end | |
| end | |
| end | |
| #0; // LET ANY WAITERS WAKE UP | |
| endtask | |
| //--------------------------------- | |
| // Implementation - Synchronization | |
| //--------------------------------- | |
| // raise_objection | |
| // --------------- | |
| function void uvm_phase::raise_objection (uvm_object obj, | |
| string description="", | |
| int count=1); | |
| phase_done.raise_objection(obj,description,count); | |
| endfunction | |
| // drop_objection | |
| // -------------- | |
| function void uvm_phase::drop_objection (uvm_object obj, | |
| string description="", | |
| int count=1); | |
| phase_done.drop_objection(obj,description,count); | |
| endfunction | |
| // sync | |
| // ---- | |
| function void uvm_phase::sync(uvm_domain target, | |
| uvm_phase phase=null, | |
| uvm_phase with_phase=null); | |
| if (!this.is_domain()) begin | |
| `uvm_fatal("PH_BADSYNC","sync() called from a non-domain phase schedule node"); | |
| end | |
| else if (target == null) begin | |
| `uvm_fatal("PH_BADSYNC","sync() called with a null target domain"); | |
| end | |
| else if (!target.is_domain()) begin | |
| `uvm_fatal("PH_BADSYNC","sync() called with a non-domain phase schedule node as target"); | |
| end | |
| else if (phase == null && with_phase != null) begin | |
| `uvm_fatal("PH_BADSYNC","sync() called with null phase and non-null with phase"); | |
| end | |
| else if (phase == null) begin | |
| // whole domain sync - traverse this domain schedule from begin to end node and sync each node | |
| int visited[uvm_phase]; | |
| uvm_phase queue[$]; | |
| queue.push_back(this); | |
| visited[this] = 1; | |
| while (queue.size()) begin | |
| uvm_phase node; | |
| node = queue.pop_front(); | |
| if (node.m_imp != null) begin | |
| sync(target, node.m_imp); | |
| end | |
| foreach (node.m_successors[succ]) begin | |
| if (!visited.exists(succ)) begin | |
| queue.push_back(succ); | |
| visited[succ] = 1; | |
| end | |
| end | |
| end | |
| end else begin | |
| // single phase sync | |
| // this is a 2-way ('with') sync and we check first in case it is already there | |
| uvm_phase from_node, to_node; | |
| int found_to[$], found_from[$]; | |
| if(with_phase == null) with_phase = phase; | |
| from_node = find(phase); | |
| to_node = target.find(with_phase); | |
| if(from_node == null || to_node == null) return; | |
| found_to = from_node.m_sync.find_index(node) with (node == to_node); | |
| found_from = to_node.m_sync.find_index(node) with (node == from_node); | |
| if (found_to.size() == 0) from_node.m_sync.push_back(to_node); | |
| if (found_from.size() == 0) to_node.m_sync.push_back(from_node); | |
| end | |
| endfunction | |
| // unsync | |
| // ------ | |
| function void uvm_phase::unsync(uvm_domain target, | |
| uvm_phase phase=null, | |
| uvm_phase with_phase=null); | |
| if (!this.is_domain()) begin | |
| `uvm_fatal("PH_BADSYNC","unsync() called from a non-domain phase schedule node"); | |
| end else if (target == null) begin | |
| `uvm_fatal("PH_BADSYNC","unsync() called with a null target domain"); | |
| end else if (!target.is_domain()) begin | |
| `uvm_fatal("PH_BADSYNC","unsync() called with a non-domain phase schedule node as target"); | |
| end else if (phase == null && with_phase != null) begin | |
| `uvm_fatal("PH_BADSYNC","unsync() called with null phase and non-null with phase"); | |
| end else if (phase == null) begin | |
| // whole domain unsync - traverse this domain schedule from begin to end node and unsync each node | |
| int visited[uvm_phase]; | |
| uvm_phase queue[$]; | |
| queue.push_back(this); | |
| visited[this] = 1; | |
| while (queue.size()) begin | |
| uvm_phase node; | |
| node = queue.pop_front(); | |
| if (node.m_imp != null) unsync(target,node.m_imp); | |
| foreach (node.m_successors[succ]) begin | |
| if (!visited.exists(succ)) begin | |
| queue.push_back(succ); | |
| visited[succ] = 1; | |
| end | |
| end | |
| end | |
| end else begin | |
| // single phase unsync | |
| // this is a 2-way ('with') sync and we check first in case it is already there | |
| uvm_phase from_node, to_node; | |
| int found_to[$], found_from[$]; | |
| from_node = target.find(phase); | |
| to_node = target.find(phase); | |
| found_to = from_node.m_sync.find_index(node) with (node == to_node); | |
| found_from = to_node.m_sync.find_index(node) with (node == from_node); | |
| if (found_to.size()) from_node.m_sync.delete(found_to[0]); | |
| if (found_from.size()) to_node.m_sync.delete(found_from[0]); | |
| end | |
| endfunction | |
| // wait_for_state | |
| //--------------- | |
| task uvm_phase::wait_for_state(uvm_phase_state state, uvm_wait_op op=UVM_EQ); | |
| case (op) | |
| UVM_EQ: wait((state&m_state) != 0); | |
| UVM_NE: wait((state&m_state) == 0); | |
| UVM_LT: wait(m_state < state); | |
| UVM_LTE: wait(m_state <= state); | |
| UVM_GT: wait(m_state > state); | |
| UVM_GTE: wait(m_state >= state); | |
| endcase | |
| endtask | |
| //------------------------- | |
| // Implementation - Jumping | |
| //------------------------- | |
| // jump | |
| // ---- | |
| // | |
| // Note that this function does not directly alter flow of control. | |
| // That is, the new phase is not initiated in this function. | |
| // Rather, flags are set which execute_phase() uses to determine | |
| // that a jump has been requested and performs the jump. | |
| function void uvm_phase::jump(uvm_phase phase); | |
| uvm_phase d; | |
| // TBD refactor | |
| if ((m_state < UVM_PHASE_STARTED) || | |
| (m_state > UVM_PHASE_READY_TO_END) ) | |
| begin | |
| `uvm_error("JMPPHIDL", { "Attempting to jump from phase \"", | |
| get_name(), "\" which is not currently active (current state is ", | |
| m_state.name(), "). The jump will not happen until the phase becomes ", | |
| "active."}) | |
| end | |
| // A jump can be either forward or backwards in the phase graph. | |
| // If the specified phase (name) is found in the set of predecessors | |
| // then we are jumping backwards. If, on the other hand, the phase is in the set | |
| // of successors then we are jumping forwards. If neither, then we | |
| // have an error. | |
| // | |
| // If the phase is non-existant and thus we don't know where to jump | |
| // we have a situation where the only thing to do is to uvm_report_fatal | |
| // and terminate_phase. By calling this function the intent was to | |
| // jump to some other phase. So, continuing in the current phase doesn't | |
| // make any sense. And we don't have a valid phase to jump to. So we're done. | |
| d = m_find_predecessor(phase,0); | |
| if (d == null) begin | |
| d = m_find_successor(phase,0); | |
| if (d == null) begin | |
| string msg; | |
| $sformat(msg,{"phase %s is neither a predecessor or successor of ", | |
| "phase %s or is non-existant, so we cannot jump to it. ", | |
| "Phase control flow is now undefined so the simulation ", | |
| "must terminate"}, phase.get_name(), get_name()); | |
| `uvm_fatal("PH_BADJUMP", msg); | |
| end | |
| else begin | |
| m_jump_fwd = 1; | |
| `uvm_info("PH_JUMPF",$sformatf("jumping forward to phase %s", phase.get_name()), | |
| UVM_DEBUG); | |
| end | |
| end | |
| else begin | |
| m_jump_bkwd = 1; | |
| `uvm_info("PH_JUMPB",$sformatf("jumping backward to phase %s", phase.get_name()), | |
| UVM_DEBUG); | |
| end | |
| m_jump_phase = d; | |
| //m_terminate_phase(); // JAR - not needed | |
| endfunction | |
| // jump_all | |
| // -------- | |
| function void uvm_phase::jump_all(uvm_phase phase); | |
| `uvm_warning("NOTIMPL","uvm_phase::jump_all is not implemented and has been replaced by uvm_domain::jump_all") | |
| endfunction | |
| // get_jump_target | |
| // --------------- | |
| function uvm_phase uvm_phase::get_jump_target(); | |
| return m_jump_phase; | |
| endfunction | |
| // clear | |
| // ----- | |
| // for internal graph maintenance after a forward jump | |
| function void uvm_phase::clear(uvm_phase_state state = UVM_PHASE_DORMANT); | |
| m_state = state; | |
| m_phase_proc = null; | |
| phase_done.clear(this); | |
| endfunction | |
| // clear_successors | |
| // ---------------- | |
| // for internal graph maintenance after a forward jump | |
| // - called only by execute_phase() | |
| // - depth-first traversal of the DAG, calliing clear() on each node | |
| // - do not clear the end phase or beyond | |
| function void uvm_phase::clear_successors(uvm_phase_state state = UVM_PHASE_DORMANT, | |
| uvm_phase end_state=null); | |
| if(this == end_state) | |
| return; | |
| clear(state); | |
| foreach(m_successors[succ]) begin | |
| succ.clear_successors(state, end_state); | |
| end | |
| endfunction | |
| //--------------------------------- | |
| // Implementation - Overall Control | |
| //--------------------------------- | |
| // wait_for_self_and_siblings_to_drop | |
| // ----------------------------- | |
| // This task loops until this phase instance and all its siblings, either | |
| // sync'd or sharing a common successor, have all objections dropped. | |
| task uvm_phase::wait_for_self_and_siblings_to_drop() ; | |
| bit need_to_check_all = 1 ; | |
| uvm_root top; | |
| bit siblings[uvm_phase]; | |
| top = uvm_root::get(); | |
| get_predecessors_for_successors(siblings); | |
| foreach (m_sync[i]) begin | |
| siblings[m_sync[i]] = 1; | |
| end | |
| while (need_to_check_all) begin | |
| need_to_check_all = 0 ; //if all are dropped, we won't need to do this again | |
| // wait for own objections to drop | |
| if (phase_done.get_objection_total(top) != 0) begin | |
| m_state = UVM_PHASE_EXECUTING ; | |
| phase_done.wait_for(UVM_ALL_DROPPED, top); | |
| need_to_check_all = 1 ; | |
| end | |
| // now wait for siblings to drop | |
| foreach(siblings[sib]) begin | |
| sib.wait_for_state(UVM_PHASE_EXECUTING, UVM_GTE); // sibling must be at least executing | |
| if (sib.phase_done.get_objection_total(top) != 0) begin | |
| m_state = UVM_PHASE_EXECUTING ; | |
| sib.phase_done.wait_for(UVM_ALL_DROPPED, top); // sibling must drop any objection | |
| need_to_check_all = 1 ; | |
| end | |
| end | |
| end | |
| endtask | |
| // kill | |
| // ---- | |
| function void uvm_phase::kill(); | |
| `uvm_info("PH_KILL", {"killing phase '", get_name(),"'"}, UVM_DEBUG); | |
| if (m_phase_proc != null) begin | |
| m_phase_proc.kill(); | |
| m_phase_proc = null; | |
| end | |
| endfunction | |
| // kill_successors | |
| // --------------- | |
| // Using a depth-first traversal, kill all the successor phases of the | |
| // current phase. | |
| function void uvm_phase::kill_successors(); | |
| foreach (m_successors[succ]) | |
| succ.kill_successors(); | |
| kill(); | |
| endfunction | |
| // m_run_phases | |
| // ------------ | |
| // This task contains the top-level process that owns all the phase | |
| // processes. By hosting the phase processes here we avoid problems | |
| // associated with phase processes related as parents/children | |
| task uvm_phase::m_run_phases(); | |
| uvm_root top = uvm_root::get(); | |
| // initiate by starting first phase in common domain | |
| begin | |
| uvm_phase ph = uvm_domain::get_common_domain(); | |
| void'(m_phase_hopper.try_put(ph)); | |
| end | |
| forever begin | |
| uvm_phase phase; | |
| m_phase_hopper.get(phase); | |
| fork | |
| begin | |
| phase.execute_phase(); | |
| end | |
| join_none | |
| #0; // let the process start running | |
| end | |
| endtask | |
| // terminate_phase | |
| // --------------- | |
| function void uvm_phase::m_terminate_phase(); | |
| phase_done.clear(this); | |
| endfunction | |
| // print_termination_state | |
| // ----------------------- | |
| function void uvm_phase::m_print_termination_state(); | |
| `uvm_info("PH_TERMSTATE", | |
| $sformatf("phase %s outstanding objections = %0d", | |
| get_name(), phase_done.get_objection_total(uvm_root::get())), | |
| UVM_DEBUG); | |
| endfunction | |