// //---------------------------------------------------------------------- // 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_build_phase; typedef class uvm_connect_phase; typedef class uvm_end_of_elaboration_phase; typedef class uvm_start_of_simulation_phase; typedef class uvm_run_phase; typedef class uvm_extract_phase; typedef class uvm_check_phase; typedef class uvm_report_phase; typedef class uvm_final_phase; typedef class uvm_pre_reset_phase; typedef class uvm_reset_phase; typedef class uvm_post_reset_phase; typedef class uvm_pre_configure_phase; typedef class uvm_configure_phase; typedef class uvm_post_configure_phase; typedef class uvm_pre_main_phase; typedef class uvm_main_phase; typedef class uvm_post_main_phase; typedef class uvm_pre_shutdown_phase; typedef class uvm_shutdown_phase; typedef class uvm_post_shutdown_phase; uvm_phase build_ph; uvm_phase connect_ph; uvm_phase end_of_elaboration_ph; uvm_phase start_of_simulation_ph; uvm_phase run_ph; uvm_phase extract_ph; uvm_phase check_ph; uvm_phase report_ph; //------------------------------------------------------------------------------ // // Class: uvm_domain // //------------------------------------------------------------------------------ // // Phasing schedule node representing an independent branch of the schedule. // Handle used to assign domains to components or hierarchies in the testbench // class uvm_domain extends uvm_phase; static local uvm_domain m_common_domain; static local uvm_domain m_uvm_domain; // run-time phases static local uvm_domain m_domains[string]; static local uvm_phase m_uvm_schedule; // Function: get_domains // // Provides a list of all domains in the provided ~domains~ argument. // static function void get_domains(output uvm_domain domains[string]); domains = m_domains; endfunction // Function: get_uvm_schedule // // Get the "UVM" schedule, which consists of the run-time phases that // all components execute when participating in the "UVM" domain. // static function uvm_phase get_uvm_schedule(); void'(get_uvm_domain()); return m_uvm_schedule; endfunction // Function: get_common_domain // // Get the "common" domain, which consists of the common phases that // all components execute in sync with each other. Phases in the "common" // domain are build, connect, end_of_elaboration, start_of_simulation, run, // extract, check, report, and final. // static function uvm_domain get_common_domain(); uvm_domain domain; uvm_phase schedule; if (m_common_domain != null) return m_common_domain; domain = new("common"); domain.add(uvm_build_phase::get()); domain.add(uvm_connect_phase::get()); domain.add(uvm_end_of_elaboration_phase::get()); domain.add(uvm_start_of_simulation_phase::get()); domain.add(uvm_run_phase::get()); domain.add(uvm_extract_phase::get()); domain.add(uvm_check_phase::get()); domain.add(uvm_report_phase::get()); domain.add(uvm_final_phase::get()); m_domains["common"] = domain; // for backward compatibility, make common phases visible; // same as uvm__phase::get(). build_ph = domain.find(uvm_build_phase::get()); connect_ph = domain.find(uvm_connect_phase::get()); end_of_elaboration_ph = domain.find(uvm_end_of_elaboration_phase::get()); start_of_simulation_ph = domain.find(uvm_start_of_simulation_phase::get()); run_ph = domain.find(uvm_run_phase::get()); extract_ph = domain.find(uvm_extract_phase::get()); check_ph = domain.find(uvm_check_phase::get()); report_ph = domain.find(uvm_report_phase::get()); m_common_domain = domain; domain = get_uvm_domain(); m_common_domain.add(domain, .with_phase(m_common_domain.find(uvm_run_phase::get()))); return m_common_domain; endfunction // Function: add_uvm_phases // // Appends to the given ~schedule~ the built-in UVM phases. // static function void add_uvm_phases(uvm_phase schedule); schedule.add(uvm_pre_reset_phase::get()); schedule.add(uvm_reset_phase::get()); schedule.add(uvm_post_reset_phase::get()); schedule.add(uvm_pre_configure_phase::get()); schedule.add(uvm_configure_phase::get()); schedule.add(uvm_post_configure_phase::get()); schedule.add(uvm_pre_main_phase::get()); schedule.add(uvm_main_phase::get()); schedule.add(uvm_post_main_phase::get()); schedule.add(uvm_pre_shutdown_phase::get()); schedule.add(uvm_shutdown_phase::get()); schedule.add(uvm_post_shutdown_phase::get()); endfunction // Function: get_uvm_domain // // Get a handle to the singleton ~uvm~ domain // static function uvm_domain get_uvm_domain(); if (m_uvm_domain == null) begin m_uvm_domain = new("uvm"); m_uvm_schedule = new("uvm_sched", UVM_PHASE_SCHEDULE); add_uvm_phases(m_uvm_schedule); m_uvm_domain.add(m_uvm_schedule); end return m_uvm_domain; endfunction // Function: new // // Create a new instance of a phase domain. function new(string name); super.new(name,UVM_PHASE_DOMAIN); if (m_domains.exists(name)) `uvm_error("UNIQDOMNAM", $sformatf("Domain created with non-unique name '%s'", name)) m_domains[name] = this; endfunction // Function: jump // // jumps all active phases of this domain to to-phase if // there is a path between active-phase and to-phase function void jump(uvm_phase phase); uvm_phase phases[$]; m_get_transitive_children(phases); phases = phases.find(item) with (item.get_state() inside {[UVM_PHASE_STARTED:UVM_PHASE_CLEANUP]}); foreach(phases[idx]) if(phases[idx].is_before(phase) || phases[idx].is_after(phase)) phases[idx].jump(phase); endfunction // jump_all // -------- static function void jump_all(uvm_phase phase); uvm_domain domains[string]; uvm_domain::get_domains(domains); foreach(domains[idx]) domains[idx].jump(phase); endfunction endclass