Jump to content

Philipp A Hartmann

Members
  • Content Count

    487
  • Joined

  • Last visited

  • Days Won

    117

Posts posted by Philipp A Hartmann


  1. The INSTALL notes currently say the following about the SC_CPLUSPLUS preprocessor switch (emphasis mine):

    Quote

     

    This setting allows downgrading the assumed version of the underlying C++ standard on the current platform.  By default, the latest supported version is chosen.

    Supported values are

    • SC_CPLUSPLUS=199701L (C++03, ISO/IEC 14882:1998, 14882:2003)
    • SC_CPLUSPLUS=201103L (C++11, ISO/IEC 14882:2011)
    • SC_CPLUSPLUS=201402L (C++14, ISO/IEC 14882:2014)
    • SC_CPLUSPLUS=201703L (C++17, ISO/IEC 14882:2017)

     

    This means, that you can explicitly opt-out of some SystemC features, that would generally be supported by your compiler's C++ language support.  Selecting a newer C++ standard version than supported by your compiler (setup) will typically not work - as you have experienced.

    That said, adding a preprocessor flag on the compiler command-line does not affect the language mode of the compiler.  How to switch your compiler to C++17 mode is outside of the scope of SystemC.  Your compiler (version) seems to require the -std=c++17 switch to enable this mode.  The SC_CPLUSPLUS flag is then not needed as it will be set automatically to the selected version.

    Hope that helps,
      Philipp


  2. 7 hours ago, taog said:

    It seems I can not use tlm2 socket like simple_initiator_socket/simple_target_socket in a pure C++ class which do not inherent from sc_module. Is TLM2 socket tight coupling with sc_module? Can I decouple this relationship?

    Yes, TLM sockets are dependent on SystemC and can only be used inside of a SystemC module.  This is because they are implemented via SystemC ports/exports, which can itself only be instantiated in SystemC modules as per the SystemC standard.

    If you want to bridge into a pure C++ model, you can pass the corresponding interface pointers into your C++ model via your own code (via get_interface() after elaboration).  This way, you only depend on sc_interface from SystemC (which is a base class of all SystemC/TLM interface classes) inside your C++ model.

    I'm not sure, what you are trying to achieve, though.  Why can't you use SystemC (which is just C++ at the end anyway)?

    Greetings from Duisburg,
      Philipp


  3. SystemC 2.3.2 (and later) does support a query whether an event was triggered in the previous delta cycle (or immediately in the current evaluation cycle).  This is similar to the sc_signal<>::event() function.  With this, you can ask every element in your array, whether it was triggered and may have caused a wakeup of the process.  Of course, multiple events can have triggered simultaneously and will only cause a single wakeup of the process.

    for( const auto ev& : e ) {
      if ( ev.triggered() ) {
        // ... 
      }
    }

    Hope that helps,
      Philipp


  4. 18 hours ago, Stephan Gerth said:

    Done.

    Thanks! I can reproduce the behavior and verified that removing the dynamic sensitivity in sc_thread_process::kill_process fixes the issue:

    void sc_thread_process::kill_process(sc_descendant_inclusion_info descendants )
    {
        // ...
        if ( sc_is_running() && m_has_stack )
        {
            m_throw_status = THROW_KILL;
            m_wait_cycle_n = 0;
            remove_dynamic_events(); // <-- add this line to avoid the exception
            simcontext()->preempt_with(this);
        }
        // ...
    }

    I'm not sure, if it is necessary to do the same for the static sensitivity.  At least I haven't come up with a similar scenario, where the error is actually "incorrect".


  5. 14 hours ago, Roman Popov said:

    I don't know what "TDB" means here, but it seems like the case when sc_event_list resides on SC_THREAD stack was not considered here.

    I did write the above comment and the case where a (e.g. temporary) list lives inside a thread is certainly one of the reasons why we need a check for premature destruction.  Due to the nature how event lists are internally handled, we will run into a memory corruption if list is destroyed while a process is still waiting for it.

    What was not considered is the explicit kill() of a process that is current waiting on such a list.

    The easiest fix would be to cancel (dynamic) sensitivity before doing the stack unwinding when killing the process.

    @Stephan Gerth: Can you submit a pull-request with your example above as testcase against the SystemC regressions repository?


  6. 22 hours ago, KEVIN CHACKO said:

    If the threads in top_uvm2 are in a SC_JOIN or SC_JOIN_None implementation(both commented in code) the whole system works fine without any errors but the issue is with the SC_JOIN_ANY implementation. 

    If you use SC_JOIN or your SC_JOIN_ANY, you want to keep the run_phase active until all (or at least one) of the threads terminate(s).  Why can't you raise an objection here?  You will drop the objection after the join, so the phase can successfully complete. (Without joining, it's fine not to raise an objection).


  7. The error looks strange to me, as terminated_events is not destroyed before exiting run_phase, i.e. after the wait() has returned.  However, I don't know how the objections are implemented in UVM SystemC and whether or how wait() is supported without raising an objection.  Can you check with a debugger, if an exception is thrown while your run_phase function is inside the wait()?

    Hope that helps,
      Philipp


  8. 52 minutes ago, TRANG said:

    I can't set base name for each initiator_socket as my expected.

    ex:   initiator_socket[0]   : " initiator_0_socket"

             initiator_socket [ 1]    : " initiator_1_socket"

             initiator_socket [ 2]    : " initiator_2_socket"

             initiator_socket [ 3]    : " initiator_3_socket"

    For this, you can use a custom creator, e.g. a lambda function in C++11.  For a tagged socket, you anyway need to specify the tag in the for the callbacks, so doing the registration in the creator saves you another loop in your code:

    sc_core::sc_vector< tlm_utils::simple_initiator_socket_tagged<Router > > initiator_socket;
    ...
    ///
    Router::Router():initiator_socket("initiator_socket",4,
      [this](const char* /*unused*/, size_t idx) {
        std::stringstream ss;
          ss << "initiator_" << idx << "_socket";
        auto * socket = new tlm_utils::simple_initiator_socket_tagged<Router >( ss.str().c_str() );
        //socket->register_invalidate_direct_mem_ptr( ..., idx );
        return socket;
      })
    
    {}

     

    Hope that helps,
      Philipp


  9. Hi Roman,

    This would be something to discuss in the Accellera SystemC LWG (or the IEEE P1666 WG).  In practice, most/all commercial simulators provide much more advanced tracing mechanisms already, beyond what the current sc_trace() API allows to support. My guess would be, that this part of the standard is something where it is difficult to reach consensus, as it touches the core distinguishing features of commercial SystemC offerings.

    Moreover, the sc_trace()-based API is a costly "pull" interface, which effectively loops over all variables at each time step and does a value comparison.  This is also pretty inefficient for e.g. signals, which already "know" if they changed.  So I think, a plain sc_interface::trace() addition is not sufficient to bring real additional value here.

    Last, but not least, this function would have to have a default (empty) implementation to not break existing models and would require some extension mechanism to add support for custom types.

    Greetings from Duisburg,
      Philipp


  10. 12 hours ago, Elvis Shera said:

    What if the SystemC installation has not been done via Cmake?  There must be a way to locate the libraries (given that systemc has been installed in a local directory) for the linking process. In that case what are the instruction to achieve this ?

    SystemC supports pkg-config as well and generates a corresponding systemc.pc file.  Of course, you still need to have the systemc.pc file somewhere in your PKG_CONFIG_PATH

    For manual Makefiles, you can check the templates in examples/build-unix as a starting point.

    Greetings from Duisburg,
      Philipp


  11. Hi Guillaume,

    17 hours ago, Guillaume Audeon said:

    My use case is about extending the TLM interfaces, especially the BW_IF with a blocking backward transport call. For all that I need to derive my thus extended sockets from the tlm_base_*_socket classes so as to be able to specify my extended transport interfaces (which is not possible with tlm_*_socket).

    thanks for the background!

    For the time being, I guess you need to work around this issue in your custom sockets then by providing your own implementation of this function in SystemC >= 2.3.2.

    Greetings from Duisburg,
      Philipp


  12. Hi Tibor,

    the stack_protect function is called upon creation and destruction of the thread.  Upon creation, a special guard page after the end of the stack is allocated and protected against accesses to catch (some) stack overflows.  Upon deletion of the thread, this protection is removed.

    Quoting https://danwalsh.livejournal.com/6117.html (highlighting mine):

    Quote

    The POSIX specification does not permit it, but the Linux implementation of mprotect allows changing the access protection of memory on the heap (e.g., allocated using malloc). This error indicates that heap memory was supposed to be made executable. Doing this is really a bad idea. If anonymous, executable memory is needed it should be allocated using mmap which is the only portable mechanism.

    Therefore, I agree that we probably don't need to try adding PROT_EXEC to the page's permissions and can only keep the read/write settings:

        // Revert the red zone to normal memory usage.
    
        else {
            ret = mprotect( redzone, pagesize - 1, PROT_READ|PROT_WRITE);
        }

    Can you try with this change again?

    Thanks and Greetings from Duisburg,
      Philipp


  13. Hi Guillaume,

    I agree, that the new pure-virtual functions in tlm_base_(initiator/target)_socket are not compliant to IEEE 1666-2011.  However, I'm curious what use case you have to use these classes directly instead of inheriting from tlm_(initiator/target)_socket, where the functions are implemented?

    Regarding the implementation on the base socket level, I suggest to add a typedef to the fw/bw interface classes, and use these typedefs in the socket base class then.  Something like:

    template <typename TYPES = tlm_base_protocol_types>
    class tlm_fw_transport_if
    // ...
    {
    public:
      typedef TYPES protocol_types;
    };
    
    // tlm_base_target_socket
    
      virtual sc_core::sc_type_index get_protocol_types() const
        { return typeid(typename FW_IF::protocol_types); }

    Theoretically, these types could mismatch between FW_IF and BW_IF in manual socket implementations.  Therefore, I'd suggest to refer to the FW_IF in the target and BW_IF in the initiator socket.

    Greetings from Duisburg,
      Philipp


  14. I'm not aware of any executable heap usage in SystemC either.  However, there is a known issue around executable stacks in the QuickThreads implementation on some SELinux-enabled machines.  Quoting the RELEASENOTES file:

      - When building the SystemC library with QuickThreads support, the
        resulting shared library is marked as requiring an executable stack
        by certain compilers/assemblers (or rather not marked as not needing
        one).  As a result, some system security systems (like SELinux) might
        refuse to load the library.  As a workaround for GNU (compatible)
        assemblers, pass the assembler flags variable with the option
          CCASFLAGS="-Wa,--noexecstack"
        to the `configure' script call before building the SystemC library.

    In case you can reproduce the effect again, can you try the suggested flag on the configure script?

    Hope that helps,
      Philipp


  15. On 9/27/2018 at 7:23 PM, Roman Popov said:

    This will break on each SystemC thread reset, since they are implemented using exceptions.  Some other more precise mechanism required.  'catch throw std::out_of_range' works for std::vector::at. But catching base classes, like 'catch throw std::logic_error' does not 

    You may be able to break on __cxa_throw explicitly and add a condition to the breakpoint to filter out unwanted exception types (e.g. sc_unwind_exception for  thread resets).

×