| // $Id: //dvt/vtech/dev/main/ovm/src/base/ovm_printer.svh#12 $ | |
| //------------------------------------------------------------------------------ | |
| // Copyright 2007-2009 Mentor Graphics Corporation | |
| // Copyright 2007-2009 Cadence Design Systems, Inc. | |
| // All Rights Reserved Worldwide | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the | |
| // "License"); you may not use this file except in | |
| // compliance with the License. You may obtain a copy of | |
| // the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in | |
| // writing, software distributed under the License is | |
| // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR | |
| // CONDITIONS OF ANY KIND, either express or implied. See | |
| // the License for the specific language governing | |
| // permissions and limitations under the License. | |
| //------------------------------------------------------------------------------ | |
| `ifndef OVM_PRINTER_SVH | |
| `define OVM_PRINTER_SVH | |
| typedef class ovm_printer_knobs; | |
| typedef class ovm_hier_printer_knobs; | |
| typedef class ovm_table_printer_knobs; | |
| typedef class ovm_tree_printer_knobs; | |
| parameter OVM_STDOUT = 1; // Writes to standard out and logfile | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_printer | |
| // | |
| // The ovm_printer class provides an interface for printing <ovm_objects> in | |
| // various formats. Subtypes of ovm_printer implement different print formats, | |
| // or policies. | |
| // | |
| // A user-defined printer format can be created, or one of the following four | |
| // built-in printers can be used: | |
| // | |
| // (see ovm_ref_printer.gif) | |
| // | |
| // - <ovm_printer> - provides raw, essentially un-formatted output | |
| // | |
| // - <ovm_table_printer> - prints the object in a tabular form. | |
| // | |
| // - <ovm_tree_printer> - prints the object in a tree form. | |
| // | |
| // - <ovm_line_printer> - prints the information on a single line, but uses the | |
| // same object separators as the tree printer. | |
| // | |
| // Printers have knobs that you use to control what and how information is printed. | |
| // These knobs are contained in separate knob classes: | |
| // | |
| // (see ovm_ref_printer_knobs.gif) | |
| // | |
| // - <ovm_printer_knobs> - common printer settings | |
| // | |
| // - <ovm_hier_printer_knobs> - settings for printing hierarchically | |
| // | |
| // - <ovm_table_printer_knobs> - settings specific to the table printer | |
| // | |
| // - <ovm_tree_printer_knobs> - settings specific to the tree printer | |
| // | |
| // | |
| // For convenience, global instances of each printer type are available for | |
| // direct reference in your testbenches. | |
| // | |
| // - <ovm_default_tree_printer> | |
| // - <ovm_default_line_printer> | |
| // - <ovm_default_table_printer> | |
| // - <ovm_default_printer> (set to default_table_printer by default) | |
| // | |
| // The <ovm_default_printer> is used by <ovm_object::print> and <ovm_object::sprint> | |
| // when the optional ~ovm_printer~ argument to these methods is not provided. | |
| // | |
| //------------------------------------------------------------------------------ | |
| class ovm_printer; | |
| // Variable: knobs | |
| // | |
| // The knob object provides access to the variety of knobs associated with a | |
| // specific printer instance. | |
| // | |
| // Each derived printer class overwrites the knobs variable with the | |
| // a derived knob class that extends <ovm_printer_knobs>. The derived knobs | |
| // class adds more knobs to the base knobs. | |
| ovm_printer_knobs knobs = new; | |
| // Group: Methods for printer usage | |
| // These functions are called from <ovm_object::print>, or they are called | |
| // directly on any data to get formatted printing. | |
| // Function: print_field | |
| // | |
| // Prints an integral field. | |
| // | |
| // name - The name of the field. | |
| // value - The value of the field. | |
| // size - The number of bits of the field (maximum is 4096). | |
| // radix - The radix to use for printingthe printer knob for radix is used | |
| // if no radix is specified. | |
| // scope_separator - is used to find the leaf name since many printers only | |
| // print the leaf name of a field. Typical values for the separator | |
| // are . (dot) or [ (open bracket). | |
| extern virtual function void print_field (string name, | |
| ovm_bitstream_t value, | |
| int size, | |
| ovm_radix_enum radix=OVM_NORADIX, | |
| byte scope_separator=".", | |
| string type_name=""); | |
| // Function: print_object_header | |
| // | |
| // Prints the header of an object. | |
| // | |
| // This function is called when an object is printed by reference. | |
| // For this function, the object will not be recursed. | |
| extern virtual function void print_object_header ( | |
| string name, | |
| ovm_object value, | |
| byte scope_separator="."); | |
| // Function: print_object | |
| // | |
| // Prints an object. Whether the object is recursed depends on a variety of | |
| // knobs, such as the depth knob; if the current depth is at or below the | |
| // depth setting, then the object is not recursed. | |
| // | |
| // By default, the children of <ovm_components> are printed. To turn this | |
| // behavior off, you must set the <ovm_component::print_enabled> bit to 0 for | |
| // the specific children you do not want automatically printed. | |
| extern virtual function void print_object (string name, | |
| ovm_object value, | |
| byte scope_separator="."); | |
| // Function: print_string | |
| // | |
| // Prints a string field. | |
| extern virtual function void print_string (string name, | |
| string value, | |
| byte scope_separator="."); | |
| // Function: print_time | |
| // | |
| // Prints a time value. name is the name of the field, and value is the | |
| // value to print. | |
| // | |
| // The print is subject to the ~$timeformat~ system task for formatting time | |
| // values. | |
| extern virtual function void print_time (string name, | |
| time value, | |
| byte scope_separator="."); | |
| // Group: Methods for printer subtyping | |
| // Function: print_header | |
| // | |
| // Prints header information. It is called when the current depth is 0, | |
| // before any fields have been printed. | |
| extern virtual function void print_header (); | |
| // Function: print_footer | |
| // | |
| // Prints footer information. It is called when the current depth is 0, | |
| // after all fields have been printed. | |
| extern virtual function void print_footer (); | |
| // Function: print_id | |
| // | |
| // Prints a field's name, or ~id~, which is the full instance name. | |
| // | |
| // The intent of the separator is to mark where the leaf name starts if the | |
| // printer if configured to print only the leaf name of the identifier. | |
| extern virtual protected function void print_id (string id, | |
| byte scope_separator="."); | |
| // Function: print_type_name | |
| // | |
| // Prints a field's type name. | |
| // | |
| // The ~is_object~ bit indicates that the item being printed is an object | |
| // derived from <ovm_object>. | |
| extern virtual protected function void print_type_name (string name, | |
| bit is_object=0); | |
| // Function: print_size | |
| // | |
| // Prints a field's size. A size of -1 indicates that no size is available, | |
| // in which case the printer inserts the appropriate white space if the format | |
| // requires it. | |
| extern virtual protected function void print_size (int size=-1); | |
| // Function: print_newline | |
| // | |
| // Prints a newline character. It is up to the printer to determine how | |
| // or whether to display new lines. The ~do_global_indent~ bit indicates | |
| // whether the call to print_newline() should honor the indent knob. | |
| extern virtual protected function void print_newline (bit do_global_indent=1); | |
| // Function: print_value | |
| // | |
| // Prints an integral field's value. | |
| // | |
| // The ~value~ vector is up to 4096 bits, and the ~size~ input indicates the | |
| // number of bits to actually print. | |
| // | |
| // The ~radix~ input is the radix that should be used for printing the value. | |
| extern virtual protected function void print_value (ovm_bitstream_t value, | |
| int size, | |
| ovm_radix_enum radix=OVM_NORADIX); | |
| // Function: print_value_object | |
| // | |
| // Prints a unique handle identifier for the given object. | |
| extern virtual protected function void print_value_object (ovm_object value); | |
| // Function: print_value_string | |
| // | |
| // Prints a string field's value. | |
| extern virtual protected function void print_value_string (string value); | |
| // Function: print_value_array | |
| // | |
| // Prints an array's value. | |
| // | |
| // This only prints the header value of the array, which means that it | |
| // implements the printer-specific print_array_header(). | |
| // | |
| // ~value~ is the value to be printed for the array. It is generally the | |
| // string representation of ~size~, but it may be any string. ~size~ is the | |
| // number of elements in the array. | |
| extern virtual function void print_value_array (string value="", | |
| int size=0); | |
| // Function: print_array_header | |
| // | |
| // Prints the header of an array. This function is called before each | |
| // individual element is printed. <print_array_footer> is called to mark the | |
| // completion of array printing. | |
| extern virtual function void print_array_header( | |
| string name, | |
| int size, | |
| string arraytype="array", | |
| byte scope_separator="."); | |
| // Function: print_array_range | |
| // | |
| // Prints a range using ellipses for values. This method is used when honoring | |
| // the array knobs for partial printing of large arrays, | |
| // <ovm_printer_knobs::begin_elements> and <ovm_printer_knobs::end_elements>. | |
| // | |
| // This function should be called after begin_elements have been printed | |
| // and after end_elements have been printed. | |
| extern virtual function void print_array_range (int min, int max); | |
| // Function: print_array_footer | |
| // | |
| // Prints the header of a footer. This function marks the end of an array | |
| // print. Generally, there is no output associated with the array footer, but | |
| // this method lets the printer know that the array printing is complete. | |
| extern virtual function void print_array_footer (int size=0); | |
| extern virtual protected function void indent (int depth, | |
| string indent_str=" "); | |
| extern virtual function void print_field_real (string name, | |
| real value, | |
| byte scope_separator="."); | |
| extern virtual function void print_generic (string name, | |
| string type_name, | |
| int size, | |
| string value, | |
| byte scope_separator="."); | |
| // Utility methods | |
| extern function bit istop (); | |
| extern function int index (string name); | |
| extern function string index_string (int index, string name=""); | |
| extern protected function void write_stream (string str); | |
| protected bit m_array_stack[$]; | |
| ovm_scope_stack m_scope = new; | |
| string m_string = ""; | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_table_printer | |
| // | |
| // The table printer prints output in a tabular format. | |
| // | |
| // The following shows sample output from the table printer. | |
| // | |
| //| --------------------------------------------------- | |
| //| Name Type Size Value | |
| //| --------------------------------------------------- | |
| //| c1 container - @1013 | |
| //| d1 mydata - @1022 | |
| //| v1 integral 32 'hcb8f1c97 | |
| //| e1 enum 32 THREE | |
| //| str string 2 hi | |
| //| value integral 12 'h2d | |
| //| --------------------------------------------------- | |
| // | |
| //------------------------------------------------------------------------------ | |
| class ovm_table_printer extends ovm_printer; | |
| // Variable: new | |
| // | |
| // Creates a new instance of ~ovm_table_printer~. | |
| extern function new(); | |
| // Variable: knobs | |
| // | |
| // An instance of <ovm_table_printer_knobs>, which govern the content | |
| // and format of the printed table. | |
| ovm_table_printer_knobs knobs = new; | |
| // Adds column headers | |
| extern virtual function void print_header (); | |
| extern virtual function void print_footer (); | |
| // Puts information in column format | |
| extern virtual function void print_id (string id, byte scope_separator="."); | |
| extern virtual function void print_size (int size=-1); | |
| extern virtual function void print_type_name (string name, bit is_object=0); | |
| extern virtual function void print_value (ovm_bitstream_t value, | |
| int size, | |
| ovm_radix_enum radix=OVM_NORADIX); | |
| extern virtual function void print_value_object (ovm_object value); | |
| extern virtual function void print_value_string (string value); | |
| extern virtual function void print_value_array (string value="", | |
| int size=0); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_tree_printer | |
| // | |
| // By overriding various methods of the <ovm_printer> super class, | |
| // the tree printer prints output in a tree format. | |
| // | |
| // The following shows sample output from the tree printer. | |
| // | |
| //| c1: (container@1013) { | |
| //| d1: (mydata@1022) { | |
| //| v1: 'hcb8f1c97 | |
| //| e1: THREE | |
| //| str: hi | |
| //| } | |
| //| value: 'h2d | |
| //| } | |
| // | |
| //------------------------------------------------------------------------------ | |
| class ovm_tree_printer extends ovm_printer; | |
| // Variable: new | |
| // | |
| // Creates a new instance of ~ovm_tree_printer~. | |
| extern function new(); | |
| // Variable: knobs | |
| // | |
| // An instance of <ovm_tree_printer_knobs>, which govern the content | |
| // and format of the printed tree. | |
| ovm_tree_printer_knobs knobs = new; | |
| // Information to print at the opening/closing of a scope | |
| extern virtual function void print_scope_open (); | |
| extern virtual function void print_scope_close (); | |
| // Puts information in tree format | |
| extern virtual function void print_id (string id, | |
| byte scope_separator="."); | |
| extern virtual function void print_type_name (string name, bit is_object=0); | |
| extern virtual function void print_object_header(string name, | |
| ovm_object value, | |
| byte scope_separator="."); | |
| extern virtual function void print_object (string name, | |
| ovm_object value, | |
| byte scope_separator="."); | |
| extern virtual function void print_string ( string name, | |
| string value, | |
| byte scope_separator="."); | |
| extern virtual function void print_value_object (ovm_object value); | |
| extern virtual function void print_value_array (string value="", | |
| int size=0); | |
| extern virtual function void print_array_footer (int size=0); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_line_printer | |
| // | |
| // The line printer prints output in a line format. | |
| // | |
| // The following shows sample output from the line printer. | |
| // | |
| //| c1: (container@1013) { d1: (mydata@1022) { v1: 'hcb8f1c97 e1: THREE str: hi } value: 'h2d } | |
| //------------------------------------------------------------------------------ | |
| class ovm_line_printer extends ovm_tree_printer; | |
| // Variable: new | |
| // | |
| // Creates a new instance of ~ovm_line_printer~. | |
| extern function new(); | |
| // Function: print_newline | |
| // | |
| // Overrides <ovm_printer::print_newline> to not print a newline, | |
| // effectively making everything appear on a single line. | |
| extern virtual function void print_newline (bit do_global_indent=1); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_printer_knobs | |
| // | |
| // The ~ovm_printer_knobs~ class defines the printer settings available to all | |
| // printer subtypes. Printer subtypes may subtype this class to provide | |
| // additional knobs for their specific format. For example, the | |
| // <ovm_table_printer> uses the <ovm_table_printer_knobs>, which defines knobs | |
| // for setting table column widths. | |
| // | |
| //------------------------------------------------------------------------------ | |
| class ovm_printer_knobs; | |
| // Variable: max_width | |
| // | |
| // The maximum with of a field. Any field that requires more characters will | |
| // be truncated. | |
| int max_width = 999; | |
| // Variable: truncation | |
| // | |
| // Specifies the character to use to indicate a field was truncated. | |
| string truncation = "+"; | |
| // Variable: header | |
| // | |
| // Indicates whether the <print_header> function should be called when | |
| // printing an object. | |
| bit header = 1; | |
| // Variable: footer | |
| // | |
| // Indicates whether the <print_footer> function should be called when | |
| // printing an object. | |
| bit footer = 1; | |
| // Variable: global_indent | |
| // | |
| // Specifies the number of spaces of indentation to add whenever a newline | |
| // is printed. | |
| int global_indent = 0; | |
| // Variable: full_name | |
| // | |
| // Indicates whether <print_id> should print the full name of an identifier | |
| // or just the leaf name. The line, table, and tree printers ignore this | |
| // bit and always print only the leaf name. | |
| bit full_name = 1; | |
| // Variable: identifier | |
| // | |
| // Indicates whether <print_id> should print the identifier. This is useful | |
| // in cases where you just want the values of an object, but no identifiers. | |
| bit identifier = 1; | |
| // Variable: depth | |
| // | |
| // Indicates how deep to recurse when printing objects. | |
| // A depth of -1 means to print everything. | |
| int depth = -1; | |
| // Variable: reference | |
| // | |
| // Controls whether to print a unique reference ID for object handles. | |
| // The behavior of this knob is simulator-dependent. | |
| bit reference = 1; | |
| // Variable: type_name | |
| // | |
| // Controls whether to print a field's type name. | |
| bit type_name = 1; | |
| // Variable: size | |
| // | |
| // Controls whether to print a field's size. | |
| bit size = 1; | |
| // Variable: begin_elements | |
| // | |
| // Defines the number of elements at the head of a list to print. | |
| // Use -1 for no max. | |
| int begin_elements = 5; | |
| // Variable: end_elements | |
| // | |
| // This defines the number of elements at the end of a list that | |
| // should be printed. | |
| int end_elements = 5; | |
| // Variable: show_radix | |
| // | |
| // Indicates whether the radix string ('h, and so on) should be prepended to | |
| // an integral value when one is printed. | |
| bit show_radix = 1; | |
| // Variable: prefix | |
| // | |
| // Specifies the string prepended to each output line | |
| string prefix = ""; | |
| // Variable: mcd | |
| // | |
| // This is a file descriptor, or multi-channel descriptor, that specifies | |
| // where the print output should be directed. | |
| // | |
| // By default, the output goes to the standard output of the simulator. | |
| int mcd = OVM_STDOUT; | |
| // Variable: default_radix | |
| // | |
| // This knob sets the default radix to use for integral values when no radix | |
| // enum is explicitly supplied to the print_field() method. | |
| ovm_radix_enum default_radix = OVM_HEX; | |
| // Variable: dec_radix | |
| // | |
| // This string should be prepended to the value of an integral type when a | |
| // radix of <OVM_DEC> is used for the radix of the integral object. | |
| // | |
| // When a negative number is printed, the radix is not printed since only | |
| // signed decimal values can print as negative. | |
| string dec_radix = "'d"; | |
| // Variable: bin_radix | |
| // | |
| // This string should be prepended to the value of an integral type when a | |
| // radix of <OVM_BIN> is used for the radix of the integral object. | |
| string bin_radix = "'b"; | |
| // Variable: oct_radix | |
| // | |
| // This string should be prepended to the value of an integral type when a | |
| // radix of <OVM_OCT> is used for the radix of the integral object. | |
| string oct_radix = "'o"; | |
| // Variable: unsigned_radix | |
| // | |
| // This is the string which should be prepended to the value of an integral | |
| // type when a radix of <OVM_UNSIGNED> is used for the radix of the integral | |
| // object. | |
| string unsigned_radix = "'d"; | |
| // Variable: hex_radix | |
| // | |
| // This string should be prepended to the value of an integral type when a | |
| // radix of <OVM_HEX> is used for the radix of the integral object. | |
| string hex_radix = "'h"; | |
| // Function: get_radix_str | |
| // | |
| // Converts the radix from an enumerated to a printable radix according to | |
| // the radix printing knobs (bin_radix, and so on). | |
| extern function string get_radix_str (ovm_radix_enum radix); | |
| // For internal use | |
| int column = 0; | |
| bit sprint = 0; | |
| bit print_fields = 1; | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_hier_printer_knobs | |
| // | |
| // The ~ovm_hier_printer_knobs~ is a simple container class that extends | |
| // <ovm_printer::ovm_printer_knobs> with settings for printing information | |
| // hierarchically. | |
| //------------------------------------------------------------------------------ | |
| class ovm_hier_printer_knobs extends ovm_printer_knobs; | |
| // Variable: indent_str | |
| // | |
| // This knob specifies the string to use for level indentation. | |
| // The default level indentation is two spaces. | |
| string indent_str = " "; | |
| // Variable: show_root | |
| // | |
| // This setting indicates whether or not the initial object that is printed | |
| // (when current depth is 0) prints the full path name. By default, the first | |
| // object is treated like all other objects and only the leaf name is printed. | |
| bit show_root = 0; | |
| extern function new(); | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_table_printer_knobs | |
| // | |
| // The ~ovm_table_printer_knobs~ is a simple container class that extends | |
| // <ovm_printer::ovm_hier_printer_knobs> with settings specific to printing | |
| // in table format. | |
| //------------------------------------------------------------------------------ | |
| class ovm_table_printer_knobs extends ovm_hier_printer_knobs; | |
| // Variable: name_width | |
| // | |
| // Sets the width of the ~name~ column. If set to 0, the column is not printed. | |
| int name_width = 25; | |
| // Variable: type_width | |
| // | |
| // Sets the width of the ~type~ column. If set to 0, the column is not printed. | |
| int type_width = 20; | |
| // Variable: size_width | |
| // | |
| // Sets the width of the ~size~ column. If set to 0, the column is not printed. | |
| int size_width = 5; | |
| // Variable: value_width | |
| // | |
| // Sets the width of the ~value~ column. If set to 0, the column is not printed. | |
| int value_width = 20; | |
| endclass | |
| //------------------------------------------------------------------------------ | |
| // | |
| // CLASS: ovm_tree_printer_knobs | |
| // | |
| // The ~ovm_tree_printer_knobs~ is a simple container class that extends | |
| // <ovm_printer::ovm_hier_printer_knobs> with settings specific to printing | |
| // in tree format. | |
| //------------------------------------------------------------------------------ | |
| class ovm_tree_printer_knobs extends ovm_hier_printer_knobs; | |
| // Variable: separator | |
| // | |
| // Determines the opening and closing separators used for | |
| // nested objects. | |
| string separator = "{}"; | |
| endclass | |
| `endif // OVM_PRINTER_SVH | |