| //---------------------------------------------------------------------- | |
| // Copyright 2007-2011 Mentor Graphics Corporation | |
| // Copyright 2007-2011 Cadence Design Systems, Inc. | |
| // Copyright 2010-2011 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. | |
| //---------------------------------------------------------------------- | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: uvm_sequence_base | |
| // | |
| // The uvm_sequence_base class provides the interfaces needed to create streams | |
| // of sequence items and/or other sequences. | |
| // | |
| // A sequence is executed by calling its <start> method, either directly | |
| // or invocation of any of the `uvm_do_* macros. | |
| // | |
| // Executing sequences via <start>: | |
| // | |
| // A sequence's <start> method has a ~parent_sequence~ argument that controls | |
| // whether <pre_do>, <mid_do>, and <post_do> are called *in the parent* | |
| // sequence. It also has a ~call_pre_post~ argument that controls whether its | |
| // <pre_body> and <post_body> methods are called. | |
| // In all cases, its <pre_start> and <post_start> methods are always called. | |
| // | |
| // When <start> is called directly, you can provide the appropriate arguments | |
| // according to your application. | |
| // | |
| // The sequence execution flow looks like this | |
| // | |
| // User code | |
| // | |
| //| sub_seq.randomize(...); // optional | |
| //| sub_seq.start(seqr, parent_seq, priority, call_pre_post) | |
| //| | |
| // | |
| // The following methods are called, in order | |
| // | |
| //| | |
| //| sub_seq.pre_start() (task) | |
| //| sub_seq.pre_body() (task) if call_pre_post==1 | |
| //| parent_seq.pre_do(0) (task) if parent_sequence!=null | |
| //| parent_seq.mid_do(this) (func) if parent_sequence!=null | |
| //| sub_seq.body (task) YOUR STIMULUS CODE | |
| //| parent_seq.post_do(this) (func) if parent_sequence!=null | |
| //| sub_seq.post_body() (task) if call_pre_post==1 | |
| //| sub_seq.post_start() (task) | |
| // | |
| // | |
| // Executing sub-sequences via `uvm_do macros: | |
| // | |
| // A sequence can also be indirectly started as a child in the <body> of a | |
| // parent sequence. The child sequence's <start> method is called indirectly | |
| // by invoking any of the `uvm_do macros. | |
| // In these cases, <start> is called with | |
| // ~call_pre_post~ set to 0, preventing the started sequence's <pre_body> and | |
| // <post_body> methods from being called. During execution of the | |
| // child sequence, the parent's <pre_do>, <mid_do>, and <post_do> methods | |
| // are called. | |
| // | |
| // The sub-sequence execution flow looks like | |
| // | |
| // User code | |
| // | |
| //| | |
| //| `uvm_do_with_prior(seq_seq, { constraints }, priority) | |
| //| | |
| // | |
| // The following methods are called, in order | |
| // | |
| //| | |
| //| sub_seq.pre_start() (task) | |
| //| parent_seq.pre_do(0) (task) | |
| //| parent_req.mid_do(sub_seq) (func) | |
| //| sub_seq.body() (task) | |
| //| parent_seq.post_do(sub_seq) (func) | |
| //| sub_seq.post_start() (task) | |
| //| | |
| // | |
| // Remember, it is the *parent* sequence's pre|mid|post_do that are called, not | |
| // the sequence being executed. | |
| // | |
| // | |
| // Executing sequence items via <start_item>/<finish_item> or `uvm_do macros: | |
| // | |
| // Items are started in the <body> of a parent sequence via calls to | |
| // <start_item>/<finish_item> or invocations of any of the `uvm_do | |
| // macros. The <pre_do>, <mid_do>, and <post_do> methods of the parent | |
| // sequence will be called as the item is executed. | |
| // | |
| // The sequence-item execution flow looks like | |
| // | |
| // User code | |
| // | |
| //| parent_seq.start_item(item, priority); | |
| //| item.randomize(...) [with {constraints}]; | |
| //| parent_seq.finish_item(item); | |
| //| | |
| //| or | |
| //| | |
| //| `uvm_do_with_prior(item, constraints, priority) | |
| //| | |
| // | |
| // The following methods are called, in order | |
| // | |
| //| | |
| //| sequencer.wait_for_grant(prior) (task) \ start_item \ | |
| //| parent_seq.pre_do(1) (task) / \ | |
| //| `uvm_do* macros | |
| //| parent_seq.mid_do(item) (func) \ / | |
| //| sequencer.send_request(item) (func) \finish_item / | |
| //| sequencer.wait_for_item_done() (task) / | |
| //| parent_seq.post_do(item) (func) / | |
| // | |
| // Attempting to execute a sequence via <start_item>/<finish_item> | |
| // will produce a run-time error. | |
| //------------------------------------------------------------------------------ | |
| class uvm_sequence_base extends uvm_sequence_item; | |
| protected uvm_sequence_state m_sequence_state; | |
| int m_next_transaction_id = 1; | |
| local int m_priority = -1; | |
| uvm_recorder m_tr_recorder; | |
| int m_wait_for_grant_semaphore; | |
| // Each sequencer will assign a sequence id. When a sequence is talking to multiple | |
| // sequencers, each sequence_id is managed separately | |
| protected int m_sqr_seq_ids[int]; | |
| protected bit children_array[uvm_sequence_base]; | |
| protected uvm_sequence_item response_queue[$]; | |
| protected int response_queue_depth = 8; | |
| protected bit response_queue_error_report_disabled; | |
| // Variable: do_not_randomize | |
| // | |
| // If set, prevents the sequence from being randomized before being executed | |
| // by the `uvm_do*() and `uvm_rand_send*() macros, | |
| // or as a default sequence. | |
| // | |
| bit do_not_randomize; | |
| protected process m_sequence_process; | |
| local bit m_use_response_handler; | |
| static string type_name = "uvm_sequence_base"; | |
| // bits to detect if is_relevant()/wait_for_relevant() are implemented | |
| local bit is_rel_default; | |
| local bit wait_rel_default; | |
| // Function: new | |
| // | |
| // The constructor for uvm_sequence_base. | |
| // | |
| function new (string name = "uvm_sequence"); | |
| super.new(name); | |
| m_sequence_state = UVM_CREATED; | |
| m_wait_for_grant_semaphore = 0; | |
| m_init_phase_daps(1); | |
| endfunction | |
| // Function: is_item | |
| // | |
| // Returns 1 on items and 0 on sequences. As this object is a sequence, | |
| // ~is_item~ will always return 0. | |
| // | |
| virtual function bit is_item(); | |
| return 0; | |
| endfunction | |
| // Function: get_sequence_state | |
| // | |
| // Returns the sequence state as an enumerated value. Can use to wait on | |
| // the sequence reaching or changing from one or more states. | |
| // | |
| //| wait(get_sequence_state() & (UVM_STOPPED|UVM_FINISHED)); | |
| function uvm_sequence_state_enum get_sequence_state(); | |
| return m_sequence_state; | |
| endfunction | |
| // Task: wait_for_sequence_state | |
| // | |
| // Waits until the sequence reaches one of the given ~state~. If the sequence | |
| // is already in one of the state, this method returns immediately. | |
| // | |
| //| wait_for_sequence_state(UVM_STOPPED|UVM_FINISHED); | |
| task wait_for_sequence_state(int unsigned state_mask); | |
| wait (m_sequence_state & state_mask); | |
| endtask | |
| // Function: get_tr_handle | |
| // | |
| // Returns the integral recording transaction handle for this sequence. | |
| // Can be used to associate sub-sequences and sequence items as | |
| // child transactions when calling <uvm_component::begin_child_tr>. | |
| function integer get_tr_handle(); | |
| if (m_tr_recorder != null) | |
| return m_tr_recorder.get_handle(); | |
| else | |
| return 0; | |
| endfunction | |
| //-------------------------- | |
| // Group: Sequence Execution | |
| //-------------------------- | |
| // Task: start | |
| // | |
| // Executes this sequence, returning when the sequence has completed. | |
| // | |
| // The ~sequencer~ argument specifies the sequencer on which to run this | |
| // sequence. The sequencer must be compatible with the sequence. | |
| // | |
| // If ~parent_sequence~ is ~null~, then this sequence is a root parent, | |
| // otherwise it is a child of ~parent_sequence~. The ~parent_sequence~'s | |
| // pre_do, mid_do, and post_do methods will be called during the execution | |
| // of this sequence. | |
| // | |
| // By default, the ~priority~ of a sequence | |
| // is the priority of its parent sequence. | |
| // If it is a root sequence, its default priority is 100. | |
| // A different priority may be specified by ~this_priority~. | |
| // Higher numbers indicate higher priority. | |
| // | |
| // If ~call_pre_post~ is set to 1 (default), then the <pre_body> and | |
| // <post_body> tasks will be called before and after the sequence | |
| // <body> is called. | |
| virtual task start (uvm_sequencer_base sequencer, | |
| uvm_sequence_base parent_sequence = null, | |
| int this_priority = -1, | |
| bit call_pre_post = 1); | |
| bit old_automatic_phase_objection; | |
| set_item_context(parent_sequence, sequencer); | |
| if (!(m_sequence_state inside {UVM_CREATED,UVM_STOPPED,UVM_FINISHED})) begin | |
| uvm_report_fatal("SEQ_NOT_DONE", | |
| {"Sequence ", get_full_name(), " already started"},UVM_NONE); | |
| end | |
| if (m_parent_sequence != null) begin | |
| m_parent_sequence.children_array[this] = 1; | |
| end | |
| if (this_priority < -1) begin | |
| uvm_report_fatal("SEQPRI", $sformatf("Sequence %s start has illegal priority: %0d", | |
| get_full_name(), | |
| this_priority), UVM_NONE); | |
| end | |
| if (this_priority < 0) begin | |
| if (parent_sequence == null) this_priority = 100; | |
| else this_priority = parent_sequence.get_priority(); | |
| end | |
| // Check that the response queue is empty from earlier runs | |
| clear_response_queue(); | |
| m_priority = this_priority; | |
| if (m_sequencer != null) begin | |
| integer handle; | |
| uvm_tr_stream stream; | |
| if (m_parent_sequence == null) begin | |
| stream = m_sequencer.get_tr_stream(get_name(), "Transactions"); | |
| handle = m_sequencer.begin_tr(this, get_name()); | |
| m_tr_recorder = uvm_recorder::get_recorder_from_handle(handle); | |
| end else begin | |
| stream = m_sequencer.get_tr_stream(get_root_sequence_name(), "Transactions"); | |
| handle = m_sequencer.begin_child_tr(this, | |
| (m_parent_sequence.m_tr_recorder == null) ? 0 : m_parent_sequence.m_tr_recorder.get_handle(), | |
| get_root_sequence_name()); | |
| m_tr_recorder = uvm_recorder::get_recorder_from_handle(handle); | |
| end | |
| end | |
| // Ensure that the sequence_id is intialized in case this sequence has been stopped previously | |
| set_sequence_id(-1); | |
| // Remove all sqr_seq_ids | |
| m_sqr_seq_ids.delete(); | |
| // Register the sequence with the sequencer if defined. | |
| if (m_sequencer != null) begin | |
| void'(m_sequencer.m_register_sequence(this)); | |
| end | |
| // Change the state to PRE_START, do this before the fork so that | |
| // the "if (!(m_sequence_state inside {...}" works | |
| m_sequence_state = UVM_PRE_START; | |
| fork | |
| begin | |
| m_sequence_process = process::self(); | |
| // absorb delta to ensure PRE_START was seen | |
| #0; | |
| // Raise the objection if enabled | |
| // (This will lock the uvm_get_to_lock_dap) | |
| if (get_automatic_phase_objection()) begin | |
| m_safe_raise_starting_phase("automatic phase objection"); | |
| end | |
| pre_start(); | |
| if (call_pre_post == 1) begin | |
| m_sequence_state = UVM_PRE_BODY; | |
| #0; | |
| pre_body(); | |
| end | |
| if (parent_sequence != null) begin | |
| parent_sequence.pre_do(0); // task | |
| parent_sequence.mid_do(this); // function | |
| end | |
| m_sequence_state = UVM_BODY; | |
| #0; | |
| body(); | |
| m_sequence_state = UVM_ENDED; | |
| #0; | |
| if (parent_sequence != null) begin | |
| parent_sequence.post_do(this); | |
| end | |
| if (call_pre_post == 1) begin | |
| m_sequence_state = UVM_POST_BODY; | |
| #0; | |
| post_body(); | |
| end | |
| m_sequence_state = UVM_POST_START; | |
| #0; | |
| post_start(); | |
| // Drop the objection if enabled | |
| if (get_automatic_phase_objection()) begin | |
| m_safe_drop_starting_phase("automatic phase objection"); | |
| end | |
| m_sequence_state = UVM_FINISHED; | |
| #0; | |
| end | |
| join | |
| if (m_sequencer != null) begin | |
| m_sequencer.end_tr(this); | |
| end | |
| // Clean up any sequencer queues after exiting; if we | |
| // were forcibly stoped, this step has already taken place | |
| if (m_sequence_state != UVM_STOPPED) begin | |
| if (m_sequencer != null) | |
| m_sequencer.m_sequence_exiting(this); | |
| end | |
| #0; // allow stopped and finish waiters to resume | |
| if ((m_parent_sequence != null) && (m_parent_sequence.children_array.exists(this))) begin | |
| m_parent_sequence.children_array.delete(this); | |
| end | |
| old_automatic_phase_objection = get_automatic_phase_objection(); | |
| m_init_phase_daps(1); | |
| set_automatic_phase_objection(old_automatic_phase_objection); | |
| endtask | |
| // Task: pre_start | |
| // | |
| // This task is a user-definable callback that is called before the | |
| // optional execution of <pre_body>. | |
| // This method should not be called directly by the user. | |
| virtual task pre_start(); | |
| return; | |
| endtask | |
| // Task: pre_body | |
| // | |
| // This task is a user-definable callback that is called before the | |
| // execution of <body> ~only~ when the sequence is started with <start>. | |
| // If <start> is called with ~call_pre_post~ set to 0, ~pre_body~ is not | |
| // called. | |
| // This method should not be called directly by the user. | |
| virtual task pre_body(); | |
| return; | |
| endtask | |
| // Task: pre_do | |
| // | |
| // This task is a user-definable callback task that is called ~on the | |
| // parent sequence~, if any | |
| // sequence has issued a wait_for_grant() call and after the sequencer has | |
| // selected this sequence, and before the item is randomized. | |
| // | |
| // Although pre_do is a task, consuming simulation cycles may result in | |
| // unexpected behavior on the driver. | |
| // | |
| // This method should not be called directly by the user. | |
| virtual task pre_do(bit is_item); | |
| return; | |
| endtask | |
| // Function: mid_do | |
| // | |
| // This function is a user-definable callback function that is called after | |
| // the sequence item has been randomized, and just before the item is sent | |
| // to the driver. This method should not be called directly by the user. | |
| virtual function void mid_do(uvm_sequence_item this_item); | |
| return; | |
| endfunction | |
| // Task: body | |
| // | |
| // This is the user-defined task where the main sequence code resides. | |
| // This method should not be called directly by the user. | |
| virtual task body(); | |
| uvm_report_warning("uvm_sequence_base", "Body definition undefined"); | |
| return; | |
| endtask | |
| // Function: post_do | |
| // | |
| // This function is a user-definable callback function that is called after | |
| // the driver has indicated that it has completed the item, using either | |
| // this item_done or put methods. This method should not be called directly | |
| // by the user. | |
| virtual function void post_do(uvm_sequence_item this_item); | |
| return; | |
| endfunction | |
| // Task: post_body | |
| // | |
| // This task is a user-definable callback task that is called after the | |
| // execution of <body> ~only~ when the sequence is started with <start>. | |
| // If <start> is called with ~call_pre_post~ set to 0, ~post_body~ is not | |
| // called. | |
| // This task is a user-definable callback task that is called after the | |
| // execution of the body, unless the sequence is started with call_pre_post=0. | |
| // This method should not be called directly by the user. | |
| virtual task post_body(); | |
| return; | |
| endtask | |
| // Task: post_start | |
| // | |
| // This task is a user-definable callback that is called after the | |
| // optional execution of <post_body>. | |
| // This method should not be called directly by the user. | |
| virtual task post_start(); | |
| return; | |
| endtask | |
| // Group: Run-Time Phasing | |
| // | |
| // Automatic Phase Objection DAP | |
| local uvm_get_to_lock_dap#(bit) m_automatic_phase_objection_dap; | |
| // Starting Phase DAP | |
| local uvm_get_to_lock_dap#(uvm_phase) m_starting_phase_dap; | |
| // Function- m_init_phase_daps | |
| // Either creates or renames DAPS | |
| function void m_init_phase_daps(bit create); | |
| string apo_name = $sformatf("%s.automatic_phase_objection", get_full_name()); | |
| string sp_name = $sformatf("%s.starting_phase", get_full_name()); | |
| if (create) begin | |
| m_automatic_phase_objection_dap = uvm_get_to_lock_dap#(bit)::type_id::create(apo_name, get_sequencer()); | |
| m_starting_phase_dap = uvm_get_to_lock_dap#(uvm_phase)::type_id::create(sp_name, get_sequencer()); | |
| end | |
| else begin | |
| m_automatic_phase_objection_dap.set_name(apo_name); | |
| m_starting_phase_dap.set_name(sp_name); | |
| end | |
| endfunction : m_init_phase_daps | |
| `ifndef UVM_NO_DEPRECATED | |
| `define UVM_DEPRECATED_STARTING_PHASE | |
| `endif | |
| `ifdef UVM_DEPRECATED_STARTING_PHASE | |
| // DEPRECATED!! Use get/set_starting_phase accessors instead! | |
| uvm_phase starting_phase; | |
| // Value set via set_starting_phase | |
| uvm_phase m_set_starting_phase; | |
| // Ensures we only warn once per sequence | |
| bit m_warn_deprecated_set; | |
| `endif | |
| // Function: get_starting_phase | |
| // Returns the 'starting phase'. | |
| // | |
| // If non-~null~, the starting phase specifies the phase in which this | |
| // sequence was started. The starting phase is set automatically when | |
| // this sequence is started as the default sequence on a sequencer. | |
| // See <uvm_sequencer_base::start_phase_sequence> for more information. | |
| // | |
| // Internally, the <uvm_sequence_base> uses an <uvm_get_to_lock_dap> to | |
| // protect the starting phase value from being modified | |
| // after the reference has been read. Once the sequence has ended | |
| // its execution (either via natural termination, or being killed), | |
| // then the starting phase value can be modified again. | |
| // | |
| function uvm_phase get_starting_phase(); | |
| `ifdef UVM_DEPRECATED_STARTING_PHASE | |
| begin | |
| bit throw_error; | |
| if (starting_phase != m_set_starting_phase) begin | |
| if (!m_warn_deprecated_set) begin | |
| `uvm_warning("UVM_DEPRECATED", "'starting_phase' is deprecated and not part of the UVM standard. See documentation for uvm_sequence_base::set_starting_phase") | |
| m_warn_deprecated_set = 1; | |
| end | |
| if (m_starting_phase_dap.try_set(starting_phase)) | |
| m_set_starting_phase = starting_phase; | |
| else begin | |
| uvm_phase dap_phase = m_starting_phase_dap.get(); | |
| `uvm_error("UVM/SEQ/LOCK_DEPR", | |
| {"The deprecated 'starting_phase' variable has been set to '", | |
| (starting_phase == null) ? "<null>" : starting_phase.get_full_name(), | |
| "' after a call to get_starting_phase locked the value to '", | |
| (dap_phase == null) ? "<null>" : dap_phase.get_full_name(), | |
| "'. See documentation for uvm_sequence_base::set_starting_phase."}) | |
| end | |
| end | |
| end | |
| `endif | |
| return m_starting_phase_dap.get(); | |
| endfunction : get_starting_phase | |
| // Function: set_starting_phase | |
| // Sets the 'starting phase'. | |
| // | |
| // Internally, the <uvm_sequence_base> uses a <uvm_get_to_lock_dap> to | |
| // protect the starting phase value from being modified | |
| // after the reference has been read. Once the sequence has ended | |
| // its execution (either via natural termination, or being killed), | |
| // then the starting phase value can be modified again. | |
| // | |
| function void set_starting_phase(uvm_phase phase); | |
| `ifdef UVM_DEPRECATED_STARTING_PHASE | |
| begin | |
| if (starting_phase != m_set_starting_phase) begin | |
| if (!m_warn_deprecated_set) begin | |
| `uvm_warning("UVM_DEPRECATED", | |
| {"The deprecated 'starting_phase' variable has been set to '", | |
| starting_phase.get_full_name(), | |
| "' manually. See documentation for uvm_sequence_base::set_starting_phase."}) | |
| m_warn_deprecated_set = 1; | |
| end | |
| starting_phase = phase; | |
| m_set_starting_phase = phase; | |
| end | |
| end | |
| `endif | |
| m_starting_phase_dap.set(phase); | |
| endfunction : set_starting_phase | |
| // Function: set_automatic_phase_objection | |
| // Sets the 'automatically object to starting phase' bit. | |
| // | |
| // The most common interaction with the starting phase | |
| // within a sequence is to simply ~raise~ the phase's objection | |
| // prior to executing the sequence, and ~drop~ the objection | |
| // after ending the sequence (either naturally, or | |
| // via a call to <kill>). In order to | |
| // simplify this interaction for the user, the UVM | |
| // provides the ability to perform this functionality | |
| // automatically. | |
| // | |
| // For example: | |
| //| function my_sequence::new(string name="unnamed"); | |
| //| super.new(name); | |
| //| set_automatic_phase_objection(1); | |
| //| endfunction : new | |
| // | |
| // From a timeline point of view, the automatic phase objection | |
| // looks like: | |
| //| start() is executed | |
| //| --! Objection is raised !-- | |
| //| pre_start() is executed | |
| //| pre_body() is optionally executed | |
| //| body() is executed | |
| //| post_body() is optionally executed | |
| //| post_start() is executed | |
| //| --! Objection is dropped !-- | |
| //| start() unblocks | |
| // | |
| // This functionality can also be enabled in sequences | |
| // which were not written with UVM Run-Time Phasing in mind: | |
| //| my_legacy_seq_type seq = new("seq"); | |
| //| seq.set_automatic_phase_objection(1); | |
| //| seq.start(my_sequencer); | |
| // | |
| // Internally, the <uvm_sequence_base> uses a <uvm_get_to_lock_dap> to | |
| // protect the ~automatic_phase_objection~ value from being modified | |
| // after the reference has been read. Once the sequence has ended | |
| // its execution (either via natural termination, or being killed), | |
| // then the ~automatic_phase_objection~ value can be modified again. | |
| // | |
| // NEVER set the automatic phase objection bit to 1 if your sequence | |
| // runs with a forever loop inside of the body, as the objection will | |
| // never get dropped! | |
| function void set_automatic_phase_objection(bit value); | |
| m_automatic_phase_objection_dap.set(value); | |
| endfunction : set_automatic_phase_objection | |
| // Function: get_automatic_phase_objection | |
| // Returns (and locks) the value of the 'automatically object to | |
| // starting phase' bit. | |
| // | |
| // If 1, then the sequence will automatically raise an objection | |
| // to the starting phase (if the starting phase is not ~null~) immediately | |
| // prior to <pre_start> being called. The objection will be dropped | |
| // after <post_start> has executed, or <kill> has been called. | |
| // | |
| function bit get_automatic_phase_objection(); | |
| return m_automatic_phase_objection_dap.get(); | |
| endfunction : get_automatic_phase_objection | |
| // m_safe_raise_starting_phase | |
| function void m_safe_raise_starting_phase(string description = "", | |
| int count = 1); | |
| uvm_phase starting_phase = get_starting_phase(); | |
| if (starting_phase != null) | |
| starting_phase.raise_objection(this, description, count); | |
| endfunction : m_safe_raise_starting_phase | |
| // m_safe_drop_starting_phase | |
| function void m_safe_drop_starting_phase(string description = "", | |
| int count = 1); | |
| uvm_phase starting_phase = get_starting_phase(); | |
| if (starting_phase != null) | |
| starting_phase.drop_objection(this, description, count); | |
| endfunction : m_safe_drop_starting_phase | |
| //------------------------ | |
| // Group: Sequence Control | |
| //------------------------ | |
| // Function: set_priority | |
| // | |
| // The priority of a sequence may be changed at any point in time. When the | |
| // priority of a sequence is changed, the new priority will be used by the | |
| // sequencer the next time that it arbitrates between sequences. | |
| // | |
| // The default priority value for a sequence is 100. Higher values result | |
| // in higher priorities. | |
| function void set_priority (int value); | |
| m_priority = value; | |
| endfunction | |
| // Function: get_priority | |
| // | |
| // This function returns the current priority of the sequence. | |
| function int get_priority(); | |
| return m_priority; | |
| endfunction | |
| // Function: is_relevant | |
| // | |
| // The default is_relevant implementation returns 1, indicating that the | |
| // sequence is always relevant. | |
| // | |
| // Users may choose to override with their own virtual function to indicate | |
| // to the sequencer that the sequence is not currently relevant after a | |
| // request has been made. | |
| // | |
| // When the sequencer arbitrates, it will call is_relevant on each requesting, | |
| // unblocked sequence to see if it is relevant. If a 0 is returned, then the | |
| // sequence will not be chosen. | |
| // | |
| // If all requesting sequences are not relevant, then the sequencer will call | |
| // wait_for_relevant on all sequences and re-arbitrate upon its return. | |
| // | |
| // Any sequence that implements is_relevant must also implement | |
| // wait_for_relevant so that the sequencer has a way to wait for a | |
| // sequence to become relevant. | |
| virtual function bit is_relevant(); | |
| is_rel_default = 1; | |
| return 1; | |
| endfunction | |
| // Task: wait_for_relevant | |
| // | |
| // This method is called by the sequencer when all available sequences are | |
| // not relevant. When wait_for_relevant returns the sequencer attempt to | |
| // re-arbitrate. | |
| // | |
| // Returning from this call does not guarantee a sequence is relevant, | |
| // although that would be the ideal. The method provide some delay to | |
| // prevent an infinite loop. | |
| // | |
| // If a sequence defines is_relevant so that it is not always relevant (by | |
| // default, a sequence is always relevant), then the sequence must also supply | |
| // a wait_for_relevant method. | |
| virtual task wait_for_relevant(); | |
| event e; | |
| wait_rel_default = 1; | |
| if (is_rel_default != wait_rel_default) | |
| uvm_report_fatal("RELMSM", | |
| "is_relevant() was implemented without defining wait_for_relevant()", UVM_NONE); | |
| @e; // this is intended to never return | |
| endtask | |
| // Task: lock | |
| // | |
| // Requests a lock on the specified sequencer. If sequencer is ~null~, the lock | |
| // will be requested on the current default sequencer. | |
| // | |
| // A lock request will be arbitrated the same as any other request. A lock is | |
| // granted after all earlier requests are completed and no other locks or | |
| // grabs are blocking this sequence. | |
| // | |
| // The lock call will return when the lock has been granted. | |
| task lock(uvm_sequencer_base sequencer = null); | |
| if (sequencer == null) | |
| sequencer = m_sequencer; | |
| if (sequencer == null) | |
| uvm_report_fatal("LOCKSEQR", "Null m_sequencer reference", UVM_NONE); | |
| sequencer.lock(this); | |
| endtask | |
| // Task: grab | |
| // | |
| // Requests a lock on the specified sequencer. If no argument is supplied, | |
| // the lock will be requested on the current default sequencer. | |
| // | |
| // A grab request is put in front of the arbitration queue. It will be | |
| // arbitrated before any other requests. A grab is granted when no other grabs | |
| // or locks are blocking this sequence. | |
| // | |
| // The grab call will return when the grab has been granted. | |
| task grab(uvm_sequencer_base sequencer = null); | |
| if (sequencer == null) begin | |
| if (m_sequencer == null) begin | |
| uvm_report_fatal("GRAB", "Null m_sequencer reference", UVM_NONE); | |
| end | |
| m_sequencer.grab(this); | |
| end | |
| else begin | |
| sequencer.grab(this); | |
| end | |
| endtask | |
| // Function: unlock | |
| // | |
| // Removes any locks or grabs obtained by this sequence on the specified | |
| // sequencer. If sequencer is ~null~, then the unlock will be done on the | |
| // current default sequencer. | |
| function void unlock(uvm_sequencer_base sequencer = null); | |
| if (sequencer == null) begin | |
| if (m_sequencer == null) begin | |
| uvm_report_fatal("UNLOCK", "Null m_sequencer reference", UVM_NONE); | |
| end | |
| m_sequencer.unlock(this); | |
| end else begin | |
| sequencer.unlock(this); | |
| end | |
| endfunction | |
| // Function: ungrab | |
| // | |
| // Removes any locks or grabs obtained by this sequence on the specified | |
| // sequencer. If sequencer is ~null~, then the unlock will be done on the | |
| // current default sequencer. | |
| function void ungrab(uvm_sequencer_base sequencer = null); | |
| unlock(sequencer); | |
| endfunction | |
| // Function: is_blocked | |
| // | |
| // Returns a bit indicating whether this sequence is currently prevented from | |
| // running due to another lock or grab. A 1 is returned if the sequence is | |
| // currently blocked. A 0 is returned if no lock or grab prevents this | |
| // sequence from executing. Note that even if a sequence is not blocked, it | |
| // is possible for another sequence to issue a lock or grab before this | |
| // sequence can issue a request. | |
| function bit is_blocked(); | |
| return m_sequencer.is_blocked(this); | |
| endfunction | |
| // Function: has_lock | |
| // | |
| // Returns 1 if this sequence has a lock, 0 otherwise. | |
| // | |
| // Note that even if this sequence has a lock, a child sequence may also have | |
| // a lock, in which case the sequence is still blocked from issuing | |
| // operations on the sequencer. | |
| function bit has_lock(); | |
| return m_sequencer.has_lock(this); | |
| endfunction | |
| // Function: kill | |
| // | |
| // This function will kill the sequence, and cause all current locks and | |
| // requests in the sequence's default sequencer to be removed. The sequence | |
| // state will change to UVM_STOPPED, and the post_body() and post_start() callback | |
| // methods will not be executed. | |
| // | |
| // If a sequence has issued locks, grabs, or requests on sequencers other than | |
| // the default sequencer, then care must be taken to unregister the sequence | |
| // with the other sequencer(s) using the sequencer unregister_sequence() | |
| // method. | |
| function void kill(); | |
| if (m_sequence_process != null) begin | |
| // If we are not connected to a sequencer, then issue | |
| // kill locally. | |
| if (m_sequencer == null) begin | |
| m_kill(); | |
| // We need to drop the objection if we raised it... | |
| if (get_automatic_phase_objection()) begin | |
| m_safe_drop_starting_phase("automatic phase objection"); | |
| end | |
| return; | |
| end | |
| // If we are attached to a sequencer, then the sequencer | |
| // will clear out queues, and then kill this sequence | |
| m_sequencer.kill_sequence(this); | |
| // We need to drop the objection if we raised it... | |
| if (get_automatic_phase_objection()) begin | |
| m_safe_drop_starting_phase("automatic phase objection"); | |
| end | |
| return; | |
| end | |
| endfunction | |
| // Function: do_kill | |
| // | |
| // This function is a user hook that is called whenever a sequence is | |
| // terminated by using either sequence.kill() or sequencer.stop_sequences() | |
| // (which effectively calls sequence.kill()). | |
| virtual function void do_kill(); | |
| return; | |
| endfunction | |
| function void m_kill(); | |
| do_kill(); | |
| foreach(children_array[i]) begin | |
| i.kill(); | |
| end | |
| if (m_sequence_process != null) begin | |
| m_sequence_process.kill; | |
| m_sequence_process = null; | |
| end | |
| m_sequence_state = UVM_STOPPED; | |
| if ((m_parent_sequence != null) && (m_parent_sequence.children_array.exists(this))) | |
| m_parent_sequence.children_array.delete(this); | |
| endfunction | |
| //------------------------------- | |
| // Group: Sequence Item Execution | |
| //------------------------------- | |
| // Function: create_item | |
| // | |
| // Create_item will create and initialize a sequence_item or sequence | |
| // using the factory. The sequence_item or sequence will be initialized | |
| // to communicate with the specified sequencer. | |
| protected function uvm_sequence_item create_item(uvm_object_wrapper type_var, | |
| uvm_sequencer_base l_sequencer, string name); | |
| uvm_coreservice_t cs = uvm_coreservice_t::get(); | |
| uvm_factory factory=cs.get_factory(); | |
| $cast(create_item, factory.create_object_by_type( type_var, this.get_full_name(), name )); | |
| create_item.set_item_context(this, l_sequencer); | |
| endfunction | |
| // Function: start_item | |
| // | |
| // ~start_item~ and <finish_item> together will initiate operation of | |
| // a sequence item. If the item has not already been | |
| // initialized using create_item, then it will be initialized here to use | |
| // the default sequencer specified by m_sequencer. Randomization | |
| // may be done between start_item and finish_item to ensure late generation | |
| // | |
| virtual task start_item (uvm_sequence_item item, | |
| int set_priority = -1, | |
| uvm_sequencer_base sequencer=null); | |
| uvm_sequence_base seq; | |
| if(item == null) begin | |
| uvm_report_fatal("NULLITM", | |
| {"attempting to start a null item from sequence '", | |
| get_full_name(), "'"}, UVM_NONE); | |
| return; | |
| end | |
| if($cast(seq, item)) begin | |
| uvm_report_fatal("SEQNOTITM", | |
| {"attempting to start a sequence using start_item() from sequence '", | |
| get_full_name(), "'. Use seq.start() instead."}, UVM_NONE); | |
| return; | |
| end | |
| if (sequencer == null) | |
| sequencer = item.get_sequencer(); | |
| if(sequencer == null) | |
| sequencer = get_sequencer(); | |
| if(sequencer == null) begin | |
| uvm_report_fatal("SEQ",{"neither the item's sequencer nor dedicated sequencer has been supplied to start item in ",get_full_name()},UVM_NONE); | |
| return; | |
| end | |
| item.set_item_context(this, sequencer); | |
| if (set_priority < 0) | |
| set_priority = get_priority(); | |
| sequencer.wait_for_grant(this, set_priority); | |
| if (sequencer.is_auto_item_recording_enabled()) begin | |
| void'(sequencer.begin_child_tr(item, | |
| (m_tr_recorder == null) ? 0 : m_tr_recorder.get_handle(), | |
| item.get_root_sequence_name(), "Transactions")); | |
| end | |
| pre_do(1); | |
| endtask | |
| // Function: finish_item | |
| // | |
| // finish_item, together with start_item together will initiate operation of | |
| // a sequence_item. Finish_item must be called | |
| // after start_item with no delays or delta-cycles. Randomization, or other | |
| // functions may be called between the start_item and finish_item calls. | |
| // | |
| virtual task finish_item (uvm_sequence_item item, | |
| int set_priority = -1); | |
| uvm_sequencer_base sequencer; | |
| sequencer = item.get_sequencer(); | |
| if (sequencer == null) begin | |
| uvm_report_fatal("STRITM", "sequence_item has null sequencer", UVM_NONE); | |
| end | |
| mid_do(item); | |
| sequencer.send_request(this, item); | |
| sequencer.wait_for_item_done(this, -1); | |
| if (sequencer.is_auto_item_recording_enabled()) begin | |
| sequencer.end_tr(item); | |
| end | |
| post_do(item); | |
| endtask | |
| // Task: wait_for_grant | |
| // | |
| // This task issues a request to the current sequencer. If item_priority is | |
| // not specified, then the current sequence priority will be used by the | |
| // arbiter. If a lock_request is made, then the sequencer will issue a lock | |
| // immediately before granting the sequence. (Note that the lock may be | |
| // granted without the sequence being granted if is_relevant is not asserted). | |
| // | |
| // When this method returns, the sequencer has granted the sequence, and the | |
| // sequence must call send_request without inserting any simulation delay | |
| // other than delta cycles. The driver is currently waiting for the next | |
| // item to be sent via the send_request call. | |
| virtual task wait_for_grant(int item_priority = -1, bit lock_request = 0); | |
| if (m_sequencer == null) begin | |
| uvm_report_fatal("WAITGRANT", "Null m_sequencer reference", UVM_NONE); | |
| end | |
| m_sequencer.wait_for_grant(this, item_priority, lock_request); | |
| endtask | |
| // Function: send_request | |
| // | |
| // The send_request function may only be called after a wait_for_grant call. | |
| // This call will send the request item to the sequencer, which will forward | |
| // it to the driver. If the rerandomize bit is set, the item will be | |
| // randomized before being sent to the driver. | |
| virtual function void send_request(uvm_sequence_item request, bit rerandomize = 0); | |
| if (m_sequencer == null) begin | |
| uvm_report_fatal("SENDREQ", "Null m_sequencer reference", UVM_NONE); | |
| end | |
| m_sequencer.send_request(this, request, rerandomize); | |
| endfunction | |
| // Task: wait_for_item_done | |
| // | |
| // A sequence may optionally call wait_for_item_done. This task will block | |
| // until the driver calls item_done or put. If no transaction_id parameter | |
| // is specified, then the call will return the next time that the driver calls | |
| // item_done or put. If a specific transaction_id is specified, then the call | |
| // will return when the driver indicates completion of that specific item. | |
| // | |
| // Note that if a specific transaction_id has been specified, and the driver | |
| // has already issued an item_done or put for that transaction, then the call | |
| // will hang, having missed the earlier notification. | |
| virtual task wait_for_item_done(int transaction_id = -1); | |
| if (m_sequencer == null) begin | |
| uvm_report_fatal("WAITITEMDONE", "Null m_sequencer reference", UVM_NONE); | |
| end | |
| m_sequencer.wait_for_item_done(this, transaction_id); | |
| endtask | |
| // Group: Response API | |
| //-------------------- | |
| // Function: use_response_handler | |
| // | |
| // When called with enable set to 1, responses will be sent to the response | |
| // handler. Otherwise, responses must be retrieved using get_response. | |
| // | |
| // By default, responses from the driver are retrieved in the sequence by | |
| // calling get_response. | |
| // | |
| // An alternative method is for the sequencer to call the response_handler | |
| // function with each response. | |
| function void use_response_handler(bit enable); | |
| m_use_response_handler = enable; | |
| endfunction | |
| // Function: get_use_response_handler | |
| // | |
| // Returns the state of the use_response_handler bit. | |
| function bit get_use_response_handler(); | |
| return m_use_response_handler; | |
| endfunction | |
| // Function: response_handler | |
| // | |
| // When the use_response_handler bit is set to 1, this virtual task is called | |
| // by the sequencer for each response that arrives for this sequence. | |
| virtual function void response_handler(uvm_sequence_item response); | |
| return; | |
| endfunction | |
| // Function: set_response_queue_error_report_disabled | |
| // | |
| // By default, if the response_queue overflows, an error is reported. The | |
| // response_queue will overflow if more responses are sent to this sequence | |
| // from the driver than get_response calls are made. Setting value to 0 | |
| // disables these errors, while setting it to 1 enables them. | |
| function void set_response_queue_error_report_disabled(bit value); | |
| response_queue_error_report_disabled = value; | |
| endfunction | |
| // Function: get_response_queue_error_report_disabled | |
| // | |
| // When this bit is 0 (default value), error reports are generated when | |
| // the response queue overflows. When this bit is 1, no such error | |
| // reports are generated. | |
| function bit get_response_queue_error_report_disabled(); | |
| return response_queue_error_report_disabled; | |
| endfunction | |
| // Function: set_response_queue_depth | |
| // | |
| // The default maximum depth of the response queue is 8. These method is used | |
| // to examine or change the maximum depth of the response queue. | |
| // | |
| // Setting the response_queue_depth to -1 indicates an arbitrarily deep | |
| // response queue. No checking is done. | |
| function void set_response_queue_depth(int value); | |
| response_queue_depth = value; | |
| endfunction | |
| // Function: get_response_queue_depth | |
| // | |
| // Returns the current depth setting for the response queue. | |
| function int get_response_queue_depth(); | |
| return response_queue_depth; | |
| endfunction | |
| // Function: clear_response_queue | |
| // | |
| // Empties the response queue for this sequence. | |
| virtual function void clear_response_queue(); | |
| response_queue.delete(); | |
| endfunction | |
| virtual function void put_base_response(input uvm_sequence_item response); | |
| if ((response_queue_depth == -1) || | |
| (response_queue.size() < response_queue_depth)) begin | |
| response_queue.push_back(response); | |
| return; | |
| end | |
| if (response_queue_error_report_disabled == 0) begin | |
| uvm_report_error(get_full_name(), "Response queue overflow, response was dropped", UVM_NONE); | |
| end | |
| endfunction | |
| // Function- put_response | |
| // | |
| // Internal method. | |
| virtual function void put_response (uvm_sequence_item response_item); | |
| put_base_response(response_item); // no error-checking | |
| endfunction | |
| // Function- get_base_response | |
| virtual task get_base_response(output uvm_sequence_item response, input int transaction_id = -1); | |
| int queue_size, i; | |
| if (response_queue.size() == 0) | |
| wait (response_queue.size() != 0); | |
| if (transaction_id == -1) begin | |
| response = response_queue.pop_front(); | |
| return; | |
| end | |
| forever begin | |
| queue_size = response_queue.size(); | |
| for (i = 0; i < queue_size; i++) begin | |
| if (response_queue[i].get_transaction_id() == transaction_id) | |
| begin | |
| $cast(response,response_queue[i]); | |
| response_queue.delete(i); | |
| return; | |
| end | |
| end | |
| wait (response_queue.size() != queue_size); | |
| end | |
| endtask | |
| //------------------------ | |
| // Group- Sequence Library DEPRECATED | |
| //------------------------ | |
| `ifndef UVM_NO_DEPRECATED | |
| // Variable- seq_kind | |
| // | |
| // Used as an identifier in constraints for a specific sequence type. | |
| rand int unsigned seq_kind; | |
| // For user random selection. This excludes the exhaustive and | |
| // random sequences. | |
| constraint pick_sequence { | |
| (num_sequences() <= 2) || (seq_kind >= 2); | |
| (seq_kind < num_sequences()) || (seq_kind == 0); } | |
| // Function- num_sequences | |
| // | |
| // Returns the number of sequences in the sequencer's sequence library. | |
| function int num_sequences(); | |
| if (m_sequencer == null) | |
| return 0; | |
| return (m_sequencer.num_sequences()); | |
| endfunction | |
| // Function- get_seq_kind | |
| // | |
| // This function returns an int representing the sequence kind that has | |
| // been registerd with the sequencer. The return value may be used with | |
| // the <get_sequence> or <do_sequence_kind> methods. | |
| function int get_seq_kind(string type_name); | |
| `uvm_warning("UVM_DEPRECATED",$sformatf("%m deprecated.")) | |
| if(m_sequencer != null) | |
| return m_sequencer.get_seq_kind(type_name); | |
| else | |
| uvm_report_warning("NULLSQ", $sformatf("%0s sequencer is null.", | |
| get_type_name()), UVM_NONE); | |
| endfunction | |
| // Function- get_sequence | |
| // | |
| // This function returns a reference to a sequence specified by ~req_kind~, | |
| // which can be obtained using the <get_seq_kind> method. | |
| function uvm_sequence_base get_sequence(int unsigned req_kind); | |
| uvm_sequence_base m_seq; | |
| string m_seq_type; | |
| uvm_coreservice_t cs = uvm_coreservice_t::get(); | |
| uvm_factory factory=cs.get_factory(); | |
| `uvm_warning("UVM_DEPRECATED",$sformatf("%m deprecated.")) | |
| if (req_kind < 0 || req_kind >= m_sequencer.sequences.size()) begin | |
| uvm_report_error("SEQRNG", | |
| $sformatf("Kind arg '%0d' out of range. Need 0-%0d", | |
| req_kind, m_sequencer.sequences.size()-1), UVM_NONE); | |
| end | |
| m_seq_type = m_sequencer.sequences[req_kind]; | |
| if (!$cast(m_seq, factory.create_object_by_name(m_seq_type, get_full_name(), m_seq_type))) begin | |
| uvm_report_fatal("FCTSEQ", | |
| $sformatf("Factory cannot produce a sequence of type %0s.", | |
| m_seq_type), UVM_NONE); | |
| end | |
| m_seq.set_use_sequence_info(1); | |
| return m_seq; | |
| endfunction | |
| // Task- do_sequence_kind | |
| // | |
| // This task will start a sequence of kind specified by ~req_kind~, | |
| // which can be obtained using the <get_seq_kind> method. | |
| task do_sequence_kind(int unsigned req_kind); | |
| string m_seq_type; | |
| uvm_sequence_base m_seq; | |
| uvm_coreservice_t cs = uvm_coreservice_t::get(); | |
| uvm_factory factory=cs.get_factory(); | |
| `uvm_warning("UVM_DEPRECATED",$sformatf("%m deprecated.")) | |
| m_seq_type = m_sequencer.sequences[req_kind]; | |
| if (!$cast(m_seq, factory.create_object_by_name(m_seq_type, get_full_name(), m_seq_type))) begin | |
| uvm_report_fatal("FCTSEQ", | |
| $sformatf("Factory cannot produce a sequence of type %0s.", m_seq_type), UVM_NONE); | |
| end | |
| m_seq.set_item_context(this, m_sequencer); | |
| if(!m_seq.randomize()) begin | |
| uvm_report_warning("RNDFLD", "Randomization failed in do_sequence_kind()"); | |
| end | |
| m_seq.start(m_sequencer,this,get_priority(),0); | |
| endtask | |
| // Function- get_sequence_by_name | |
| // | |
| // Internal method. | |
| function uvm_sequence_base get_sequence_by_name(string seq_name); | |
| uvm_sequence_base m_seq; | |
| uvm_coreservice_t cs = uvm_coreservice_t::get(); | |
| uvm_factory factory=cs.get_factory(); | |
| `uvm_warning("UVM_DEPRECATED",$sformatf("%m deprecated.")) | |
| if (!$cast(m_seq, factory.create_object_by_name(seq_name, get_full_name(), seq_name))) begin | |
| uvm_report_fatal("FCTSEQ", | |
| $sformatf("Factory cannot produce a sequence of type %0s.", seq_name), UVM_NONE); | |
| end | |
| m_seq.set_use_sequence_info(1); | |
| return m_seq; | |
| endfunction | |
| // Task- create_and_start_sequence_by_name | |
| // | |
| // Internal method. | |
| task create_and_start_sequence_by_name(string seq_name); | |
| uvm_sequence_base m_seq; | |
| `uvm_warning("UVM_DEPRECATED",$sformatf("%m deprecated.")) | |
| m_seq = get_sequence_by_name(seq_name); | |
| m_seq.start(m_sequencer, this, this.get_priority(), 0); | |
| endtask | |
| `endif // UVM_NO_DEPRECATED | |
| //---------------------- | |
| // Misc Internal methods | |
| //---------------------- | |
| // m_get_sqr_sequence_id | |
| // --------------------- | |
| function int m_get_sqr_sequence_id(int sequencer_id, bit update_sequence_id); | |
| if (m_sqr_seq_ids.exists(sequencer_id)) begin | |
| if (update_sequence_id == 1) begin | |
| set_sequence_id(m_sqr_seq_ids[sequencer_id]); | |
| end | |
| return m_sqr_seq_ids[sequencer_id]; | |
| end | |
| if (update_sequence_id == 1) | |
| set_sequence_id(-1); | |
| return -1; | |
| endfunction | |
| // m_set_sqr_sequence_id | |
| // --------------------- | |
| function void m_set_sqr_sequence_id(int sequencer_id, int sequence_id); | |
| m_sqr_seq_ids[sequencer_id] = sequence_id; | |
| set_sequence_id(sequence_id); | |
| endfunction | |
| endclass | |