| // |
| //----------------------------------------------------------------------------- |
| // Copyright 2007-2011 Mentor Graphics Corporation |
| // Copyright 2007-2011 Cadence Design Systems, Inc. |
| // Copyright 2010 Synopsys, Inc. |
| // Copyright 2013 NVIDIA Corporation |
| // 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. |
| //----------------------------------------------------------------------------- |
| |
| //------------------------------------------------------------------------------ |
| // File: Transaction Recording Streams |
| // |
| |
| // class- m_uvm_tr_stream_cfg |
| // Undocumented helper class for storing stream |
| // initialization values. |
| class m_uvm_tr_stream_cfg; |
| uvm_tr_database db; |
| string scope; |
| string stream_type_name; |
| endclass : m_uvm_tr_stream_cfg |
| |
| typedef class uvm_set_before_get_dap; |
| typedef class uvm_text_recorder; |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_tr_stream |
| // |
| // The ~uvm_tr_stream~ base class is a representation of a stream of records |
| // within a <uvm_tr_database>. |
| // |
| // The record stream is intended to hide the underlying database implementation |
| // from the end user, as these details are often vendor or tool-specific. |
| // |
| // The ~uvm_tr_stream~ class is pure virtual, and must be extended with an |
| // implementation. A default text-based implementation is provided via the |
| // <uvm_text_tr_stream> class. |
| // |
| virtual class uvm_tr_stream extends uvm_object; |
| |
| // Variable- m_cfg_dap |
| // Data access protected reference to the DB |
| local uvm_set_before_get_dap#(m_uvm_tr_stream_cfg) m_cfg_dap; |
| |
| // Variable- m_records |
| // Active records in the stream (active == open or closed) |
| local bit m_records[uvm_recorder]; |
| |
| // Variable- m_warn_null_cfg |
| // Used to limit the number of warnings |
| local bit m_warn_null_cfg; |
| |
| // Variable- m_is_opened |
| // Used to indicate stream is open |
| local bit m_is_opened; |
| |
| // Variable- m_is_closed |
| // Used to indicate stream is closed |
| local bit m_is_closed; |
| |
| // !m_is_opened && !m_is_closed == m_is_freed |
| |
| // Function: new |
| // Constructor |
| // |
| // Parameters: |
| // name - Stream instance name |
| function new(string name="unnamed-uvm_tr_stream"); |
| super.new(name); |
| m_cfg_dap = new("cfg_dap"); |
| endfunction : new |
| |
| // Variable- m_ids_by_stream |
| // An associative array of integers, indexed by uvm_tr_streams. This |
| // provides a unique 'id' or 'handle' for each stream, which can be |
| // used to identify the stream. |
| // |
| // By default, neither ~m_ids_by_stream~ or ~m_streams_by_id~ are |
| // used. Streams are only placed in the arrays when the user |
| // attempts to determine the id for a stream. |
| local static integer m_ids_by_stream[uvm_tr_stream]; |
| |
| // Group: Configuration API |
| |
| // Function: get_db |
| // Returns a reference to the database which contains this |
| // stream. |
| // |
| // A warning will be asserted if get_db is called prior to |
| // the stream being initialized via <do_open>. |
| function uvm_tr_database get_db(); |
| m_uvm_tr_stream_cfg m_cfg; |
| if (!m_cfg_dap.try_get(m_cfg)) begin |
| if (m_warn_null_cfg == 1) |
| `uvm_warning("UVM/REC_STR/NO_CFG", |
| $sformatf("attempt to retrieve DB from '%s' before it was set!", |
| get_name())) |
| m_warn_null_cfg = 0; |
| return null; |
| end |
| return m_cfg.db; |
| endfunction : get_db |
| |
| // Function: get_scope |
| // Returns the ~scope~ supplied when opening this stream. |
| // |
| // A warning will be asserted if get_scope is called prior to |
| // the stream being initialized via <do_open>. |
| function string get_scope(); |
| m_uvm_tr_stream_cfg m_cfg; |
| if (!m_cfg_dap.try_get(m_cfg)) begin |
| if (m_warn_null_cfg == 1) |
| `uvm_warning("UVM/REC_STR/NO_CFG", |
| $sformatf("attempt to retrieve scope from '%s' before it was set!", |
| get_name())) |
| m_warn_null_cfg = 0; |
| return ""; |
| end |
| return m_cfg.scope; |
| endfunction : get_scope |
| |
| // Function: get_stream_type_name |
| // Returns a reference to the database which contains this |
| // stream. |
| // |
| // A warning will be asserted if get_stream_type_name is called prior to |
| // the stream being initialized via <do_open>. |
| function string get_stream_type_name(); |
| m_uvm_tr_stream_cfg m_cfg; |
| if (!m_cfg_dap.try_get(m_cfg)) begin |
| if (m_warn_null_cfg == 1) |
| `uvm_warning("UVM/REC_STR/NO_CFG", |
| $sformatf("attempt to retrieve STREAM_TYPE_NAME from '%s' before it was set!", |
| get_name())) |
| m_warn_null_cfg = 0; |
| return ""; |
| end |
| return m_cfg.stream_type_name; |
| endfunction : get_stream_type_name |
| |
| // Group: Stream API |
| // |
| // Once a stream has been opened via <uvm_tr_database::open_stream>, the user |
| // can ~close~ the stream. |
| // |
| // Due to the fact that many database implementations will require crossing |
| // a language boundary, an additional step of ~freeing~ the stream is required. |
| // |
| // A ~link~ can be established within the database any time between "Open" and |
| // "Free", however it is illegal to establish a link after "Freeing" the stream. |
| // |
| |
| // Function: close |
| // Closes this stream. |
| // |
| // Closing a stream closes all open recorders in the stream. |
| // |
| // This method will trigger a <do_close> call, followed by |
| // <uvm_recorder::close> on all open recorders within the |
| // stream. |
| function void close(); |
| if (!is_open()) |
| return; |
| |
| do_close(); |
| |
| foreach (m_records[idx]) |
| if (idx.is_open()) |
| idx.close(); |
| |
| m_is_opened = 0; |
| m_is_closed = 1; |
| endfunction : close |
| |
| // Function: free |
| // Frees this stream. |
| // |
| // Freeing a stream indicates that the database can free any |
| // references to the stream (including references to records |
| // within the stream). |
| // |
| // This method will trigger a <do_free> call, followed by |
| // <uvm_recorder::free> on all recorders within the stream. |
| function void free(); |
| process p; |
| string s; |
| uvm_tr_database db; |
| if (!is_open() && !is_closed()) |
| return; |
| |
| if (is_open()) |
| close(); |
| |
| do_free(); |
| |
| foreach (m_records[idx]) |
| idx.free(); |
| |
| // Clear out internal state |
| db = get_db(); |
| m_is_closed = 0; |
| p = process::self(); |
| if(p != null) |
| s = p.get_randstate(); |
| m_cfg_dap = new("cfg_dap"); |
| if(p != null) |
| p.set_randstate(s); |
| m_warn_null_cfg = 1; |
| if (m_ids_by_stream.exists(this)) |
| m_free_id(m_ids_by_stream[this]); |
| |
| // Clear out DB state |
| if (db != null) |
| db.m_free_stream(this); |
| endfunction : free |
| |
| // Function- m_do_open |
| // Initializes the state of the stream |
| // |
| // Parameters- |
| // db - Database which the stream belongs to |
| // scope - Optional scope |
| // stream_type_name - Optional type name for the stream |
| // |
| // This method will trigger a <do_open> call. |
| // |
| // An error will be asserted if- |
| // - m_do_open is called more than once without the stream |
| // being ~freed~ between. |
| // - m_do_open is passed a ~null~ db |
| function void m_do_open(uvm_tr_database db, |
| string scope="", |
| string stream_type_name=""); |
| |
| m_uvm_tr_stream_cfg m_cfg; |
| uvm_tr_database m_db; |
| if (db == null) begin |
| `uvm_error("UVM/REC_STR/NULL_DB", |
| $sformatf("Illegal attempt to set DB for '%s' to '<null>'", |
| this.get_full_name())) |
| return; |
| end |
| |
| if (m_cfg_dap.try_get(m_cfg)) begin |
| `uvm_error("UVM/REC_STR/RE_CFG", |
| $sformatf("Illegal attempt to re-open '%s'", |
| this.get_full_name())) |
| end |
| else begin |
| // Never set before |
| m_cfg = new(); |
| m_cfg.db = db; |
| m_cfg.scope = scope; |
| m_cfg.stream_type_name = stream_type_name; |
| m_cfg_dap.set(m_cfg); |
| m_is_opened = 1; |
| |
| do_open(db, scope, stream_type_name); |
| end |
| |
| endfunction : m_do_open |
| |
| // Function: is_open |
| // Returns true if this ~uvm_tr_stream~ was opened on the database, |
| // but has not yet been closed. |
| // |
| function bit is_open(); |
| return m_is_opened; |
| endfunction : is_open |
| |
| // Function: is_closed |
| // Returns true if this ~uvm_tr_stream~ was closed on the database, |
| // but has not yet been freed. |
| // |
| function bit is_closed(); |
| return m_is_closed; |
| endfunction : is_closed |
| |
| // Group: Transaction Recorder API |
| // |
| // New recorders can be opened prior to the stream being ~closed~. |
| // |
| // Once a stream has been closed, requests to open a new recorder |
| // will be ignored (<open_recorder> will return ~null~). |
| // |
| |
| // Function: open_recorder |
| // Marks the opening of a new transaction recorder on the stream. |
| // |
| // Parameters: |
| // name - A name for the new transaction |
| // open_time - Optional time to record as the opening of this transaction |
| // type_name - Optional type name for the transaction |
| // |
| // If ~open_time~ is omitted (or set to 0), then the stream will use |
| // the current time. |
| // |
| // This method will trigger a <do_open_recorder> call. If ~do_open_recorder~ |
| // returns a non-~null~ value, then the <uvm_recorder::do_open> method will |
| // be called in the recorder. |
| // |
| // Transaction recorders can only be opened if the stream is |
| // ~open~ on the database (per <is_open>). Otherwise the |
| // request will be ignored, and ~null~ will be returned. |
| function uvm_recorder open_recorder(string name, |
| time open_time = 0, |
| string type_name=""); |
| time m_time = (open_time == 0) ? $time : open_time; |
| |
| // Check to make sure we're open |
| if (!is_open()) |
| return null; |
| else begin |
| process p = process::self(); |
| string s; |
| |
| if (p != null) |
| s = p.get_randstate(); |
| |
| open_recorder = do_open_recorder(name, |
| m_time, |
| type_name); |
| |
| |
| |
| if (open_recorder != null) begin |
| m_records[open_recorder] = 1; |
| open_recorder.m_do_open(this, m_time, type_name); |
| end |
| if (p != null) |
| p.set_randstate(s); |
| end |
| endfunction : open_recorder |
| |
| // Function- m_free_recorder |
| // Removes recorder from the internal array |
| function void m_free_recorder(uvm_recorder recorder); |
| if (m_records.exists(recorder)) |
| m_records.delete(recorder); |
| endfunction : m_free_recorder |
| |
| // Function: get_recorders |
| // Provides a queue of all transactions within the stream. |
| // |
| // Parameters: |
| // q - A reference to the queue of <uvm_recorder>s |
| // |
| // The <get_recorders> method returns the size of the queue, |
| // such that the user can conditionally process the elements. |
| // |
| // | uvm_recorder tr_q[$]; |
| // | if (my_stream.get_recorders(tr_q)) begin |
| // | // Process the queue... |
| // | end |
| // |
| function unsigned get_recorders(ref uvm_recorder q[$]); |
| // Clear out the queue first... |
| q.delete(); |
| // Fill in the values |
| foreach (m_records[idx]) |
| q.push_back(idx); |
| // Finally return the size of the queue |
| return q.size(); |
| endfunction : get_recorders |
| |
| // Group: Handles |
| |
| // Variable- m_streams_by_id |
| // A corollary to ~m_ids_by_stream~, this indexes the streams by their |
| // unique ids. |
| local static uvm_tr_stream m_streams_by_id[integer]; |
| |
| // Function: get_handle |
| // Returns a unique ID for this stream. |
| // |
| // A value of ~0~ indicates that the recorder has been ~freed~, |
| // and no longer has a valid ID. |
| // |
| function integer get_handle(); |
| if (!is_open() && !is_closed()) begin |
| return 0; |
| end |
| else begin |
| integer handle = get_inst_id(); |
| |
| // Check for the weird case where our handle changed. |
| if (m_ids_by_stream.exists(this) && m_ids_by_stream[this] != handle) |
| m_streams_by_id.delete(m_ids_by_stream[this]); |
| |
| m_streams_by_id[handle] = this; |
| m_ids_by_stream[this] = handle; |
| |
| return handle; |
| end |
| endfunction : get_handle |
| |
| // Function- m_get_handle |
| // Provided to allow implementation-specific handles which are not |
| // identical to the built-in handles. |
| // |
| // This is an implementation detail of the UVM library, which allows |
| // for vendors to (optionally) put vendor-specific methods into the library. |
| virtual function integer m_get_handle(); |
| return get_handle(); |
| endfunction : m_get_handle |
| |
| // Function: get_stream_from_handle |
| // Static accessor, returns a stream reference for a given unique id. |
| // |
| // If no stream exists with the given ~id~, or if the |
| // stream with that ~id~ has been freed, then ~null~ is |
| // returned. |
| // |
| static function uvm_tr_stream get_stream_from_handle(integer id); |
| if (id == 0) |
| return null; |
| |
| if ($isunknown(id) || !m_streams_by_id.exists(id)) |
| return null; |
| |
| return m_streams_by_id[id]; |
| endfunction : get_stream_from_handle |
| |
| // Function- m_free_id |
| // Frees the id/stream link (memory cleanup) |
| // |
| static function void m_free_id(integer id); |
| uvm_tr_stream stream; |
| if (!$isunknown(id) && m_streams_by_id.exists(id)) |
| stream = m_streams_by_id[id]; |
| |
| if (stream != null) begin |
| m_streams_by_id.delete(id); |
| m_ids_by_stream.delete(stream); |
| end |
| endfunction : m_free_id |
| |
| // Group: Implementation Agnostic API |
| // |
| |
| // Function: do_open |
| // Callback triggered via <uvm_tr_database::open_stream>. |
| // |
| // Parameters: |
| // db - Database which the stream belongs to |
| // scope - Optional scope |
| // stream_type_name - Optional type name for the stream |
| // |
| // The ~do_open~ callback can be used to initialize any internal |
| // state within the stream, as well as providing a location to |
| // record any initial information about the stream. |
| protected virtual function void do_open(uvm_tr_database db, |
| string scope, |
| string stream_type_name); |
| endfunction : do_open |
| |
| // Function: do_close |
| // Callback triggered via <close>. |
| // |
| // The ~do_close~ callback can be used to set internal state |
| // within the stream, as well as providing a location to |
| // record any closing information. |
| protected virtual function void do_close(); |
| endfunction : do_close |
| |
| // Function: do_free |
| // Callback triggered via <free>. |
| // |
| // The ~do_free~ callback can be used to release the internal |
| // state within the stream, as well as providing a location |
| // to record any "freeing" information. |
| protected virtual function void do_free(); |
| endfunction : do_free |
| |
| // Function: do_open_recorder |
| // Marks the beginning of a new record in the stream. |
| // |
| // Backend implementation of <open_recorder> |
| protected virtual function uvm_recorder do_open_recorder(string name, |
| time open_time, |
| string type_name); |
| return null; |
| endfunction : do_open_recorder |
| |
| endclass : uvm_tr_stream |
| |
| //------------------------------------------------------------------------------ |
| // |
| // CLASS: uvm_text_tr_stream |
| // |
| // The ~uvm_text_tr_stream~ is the default stream implementation for the |
| // <uvm_text_tr_database>. |
| // |
| // |
| |
| class uvm_text_tr_stream extends uvm_tr_stream; |
| |
| // Variable- m_text_db |
| // Internal reference to the text-based backend |
| local uvm_text_tr_database m_text_db; |
| |
| `uvm_object_utils_begin(uvm_text_tr_stream) |
| `uvm_object_utils_end |
| |
| // Function: new |
| // Constructor |
| // |
| // Parameters: |
| // name - Instance name |
| function new(string name="unnamed-uvm_text_tr_stream"); |
| super.new(name); |
| endfunction : new |
| |
| // Group: Implementation Agnostic API |
| |
| // Function: do_open |
| // Callback triggered via <uvm_tr_database::open_stream>. |
| // |
| protected virtual function void do_open(uvm_tr_database db, |
| string scope, |
| string stream_type_name); |
| $cast(m_text_db, db); |
| if (m_text_db.open_db()) |
| $fdisplay(m_text_db.m_file, |
| " CREATE_STREAM @%0t {NAME:%s T:%s SCOPE:%s STREAM:%0d}", |
| $time, |
| this.get_name(), |
| stream_type_name, |
| scope, |
| this.get_handle()); |
| endfunction : do_open |
| |
| // Function: do_close |
| // Callback triggered via <uvm_tr_stream::close>. |
| protected virtual function void do_close(); |
| if (m_text_db.open_db()) |
| $fdisplay(m_text_db.m_file, |
| " CLOSE_STREAM @%0t {NAME:%s T:%s SCOPE:%s STREAM:%0d}", |
| $time, |
| this.get_name(), |
| this.get_stream_type_name(), |
| this.get_scope(), |
| this.get_handle()); |
| endfunction : do_close |
| |
| // Function: do_free |
| // Callback triggered via <uvm_tr_stream::free>. |
| // |
| protected virtual function void do_free(); |
| if (m_text_db.open_db()) |
| $fdisplay(m_text_db.m_file, |
| " FREE_STREAM @%0t {NAME:%s T:%s SCOPE:%s STREAM:%0d}", |
| $time, |
| this.get_name(), |
| this.get_stream_type_name(), |
| this.get_scope(), |
| this.get_handle()); |
| m_text_db = null; |
| return; |
| endfunction : do_free |
| |
| // Function: do_open_recorder |
| // Marks the beginning of a new record in the stream |
| // |
| // Text-backend specific implementation. |
| protected virtual function uvm_recorder do_open_recorder(string name, |
| time open_time, |
| string type_name); |
| if (m_text_db.open_db()) begin |
| return uvm_text_recorder::type_id::create(name); |
| end |
| |
| return null; |
| endfunction : do_open_recorder |
| |
| endclass : uvm_text_tr_stream |
