releasenotes

来自「基于4个mips核的noc设计」· 代码 · 共 424 行 · 第 1/2 页

        SC_REPORT_ERROR(id,msg), or SC_REPORT_FATAL(id,msg). These macros
        take a report id and an additional message text as arguments.

        In addition, an 'sc_assert(expression)' macro is provided, which
        behaves much like the standard 'assert()' macro, except that the
        current process name (full hierarchical name) and the simulation
        time are also printed (if applicable).

      o Debugging

        SystemC comes with a function called 'sc_stop_here()' that is
        provided for debugging purposes. You can set a breakpoint at
        this function in case of an error or warning, or you can set
        a breakpoint at a specific line within this function if you
        just want to break with a certain severity (e.g. errors only).
        The 'sc_stop_here()' function has two arguments, the report
        id and severity. These can be used in debuggers that support
        defining conditional breakpoints (e.g. break if id is 5).

      o Extending

        You can register your own report ids and messages with the
        'sc_report::register_id(id,msg)' function. Then you can generate
        a report of a certain severity by calling one of the above macros.
        Beware: report ids below 1000 are reserved for SystemC.

      o Other

        There are several other sc_report functions you can use.

        You can query the message belonging to a given report id with
        function 'sc_report::get_message(id)'. This function returns
        a constant character string (type const char*).

        You can (un)suppress an info or warning message for a given
        report id with function 'sc_report::suppress_id(id,suppress)'.
        The 'suppress' argument is of type boolean.

        You can query if an info or warning message for a given report
        id is suppressed with function 'sc_report::is_suppressed(id)'.
        This function returns a boolean.

        You can (un)suppress all info messages with function
        'sc_report::suppress_infos(suppress)'. The 'suppress' argument
        is of type boolean.

        You can (un)suppress all warning messages with function
        'sc_report::suppress_warnings(suppress)'. The 'suppress'
        argument is of type boolean.

        You can enable (disable) making all warning messages error
        messages with function 'sc_report::make_warnings_errors(do)'.
        The 'do' argument is of type boolean.

  - Instead of using a fixed length, the default constructors of the
    base classes of the bitvector (sc_bv_base, sc_lv_base) and integer
    (sc_int_base, sc_uint_base, sc_signed, sc_unsigned) classes now
    take the length from the current length context (like the base
    classes of the fixed-point types do). To this purpose two
    additional types have been added: sc_length_param and
    sc_length_context. The former type allows to query the length of
    the current length context, whereas the latter type allows to
    change the current length context.

  - The sc_fifo interfaces (and ports) have been extended to "export"
    the internal events. The sc_fifo_in_if interface now has a method
    'data_written_event()' that can be used to detect data write
    accesses on the fifo. The sc_fifo_out_if interface now has a
    method 'data_read_event()' that can be used to detect data read
    accesses on the fifo. A thread process writing to a fifo can do
    e.g.

      if( out.num_free() == 0 ) {
        // do something else first
        wait( out.data_read_event() );
      }
      out.write( a );

    A thread process reading from a fifo can do e.g.

      if( out.num_available() == 0 ) {
        // do something else first
        wait( in.data_written_event() );
      }
      in.read( a );

    It is now also possible to make a process statically sensitive to
    either the data read event or the data written event from a fifo.
    A module writing to a fifo can have e.g.

      SC_CTOR( fifo_writer ) {
        SC_THREAD( fifo_writer_proc );
        sensitive << out.data_read();
      }

    A module reading from a fifo can have e.g.

      SC_CTOR( fifo_reader ) {
        SC_METHOD( fifo_reader_proc );
        sensitive << in.data_written();
      }

    This is a beta feature.

  - All datatypes now also support input streaming, i.e., they support 
    reading their value from an input stream (istream). E.g.

      sc_bv<8> a;
      cin >> a;  // read the value for 'a' from standard input

    Input streaming and output streaming use the string input and
    string output functionality of the datatypes. The same format
    is/should be used.


4) Known limitations
====================

Here is a list of known limitations in this release:

  - The following problems have been reported in the forum and have not
    been fixed in this release. They will be fixed in a future release:
      o Bit-selects and part-selects on signals and signal ports are not
        yet supported.
      o Delayed write on signals and signal ports are not yet supported.

  - Concatenation of the arbitrary size integer types (sc_bigint,
    sc_biguint, sc_signed, sc_unsigned) is not yet implemented. Dummy
    functions are in place to produce a run-time error message in case 
    concatenation of these types is requested.


5) Beta features
================

In this section the beta features of this release are listed.

  - exported sc_fifo events and static sensitivity for sc_fifo events


6) Deprecated features
======================

In this section the deprecated features of this release are listed.

  - deprecated but fully functional

    o sc_logic_0, sc_logic_1, sc_logic_Z, and sc_logic_X are
      deprecated. Instead SC_LOGIC_0, SC_LOGIC_1, SC_LOGIC_Z, and
      SC_LOGIC_X should be used.

    o The SC_CTHREAD clocked thread process type is deprecated. There
      is not yet a full replacement, but you are encouraged to use the 
      SC_THREAD and SC_METHOD process types instead where possible.
      Until there is a full replacement for the SC_CTHREAD process
      type it will stay fully functional.

    o The sensitive_pos and sensitive_neg statements are deprecated.
      Instead use the pos() and neg() methods of the signal ports,
      e.g.

        sensitive << clk.pos(); // sensitive to the positive edge of clk

        sensitive << clk.neg(); // sensitive to the negative edge of clk

    o The sc_bit datatype is deprecated. Use type 'bool' instead,
      where possible.

  - deprecated and only functional when defining SC_DT_DEPRECATED

    o The to_signed() and to_unsigned() methods defined in some
      datatypes are deprecated. Use the to_int() and to_uint() methods
      instead.

    o The sc_bv_base constructors from datatypes sc_signed,
      sc_unsigned, sc_int_base, and sc_uint_base are deprecated.

    o The sc_lv_base constructors from datatypes sc_signed,
      sc_unsigned, sc_int_base, and sc_uint_base are deprecated.

    o The bitwidth() method defined in some datatypes is deprecated.
      Use the length() method instead.

  - deprecated and removed

    o The ! operator of datatype sc_logic is deprecated. Use the ~
      operator instead.


7) Fixed-point library
======================

(No change with 2.0 Production.)

SystemC contains a fixed-point datatypes package.

Compile-time macro SC_INCLUDE_FX must be defined in order to build
applications that use fixed point types. You can specify a compiler
flag, e.g. g++ -DSC_INCLUDE_FX ... or use a define statement before
you include systemc.h, e.g.

  #define SC_INCLUDE_FX
  #include "systemc.h"

Due to the large size of the fixed-point datatypes header files,
compilation can take considerably more time.

If you want to use the fixed-point data types only (i.e., not data-
types sc_int, sc_uint, sc_bigint, sc_biguint), compilation time can be
reduced by defining compile-time macro SC_FX_EXCLUDE_OTHER (in addition
to SC_INCLUDE_FX).