Philipp A Hartmann

  • Content count

  • Joined

  • Last visited

1 Follower

About Philipp A Hartmann

  • Rank
    Advanced Member

Profile Information

  • Gender
    Not Telling
  • Location
    Duisburg, DE

Recent Profile Visitors

554 profile views
  1. Did you include the required "extensions ctor" in your extension? template<unsigned DA_WIDTH> class scv_extensions<item_c<DA_WIDTH> > : public scv_extensions_base<item_c<DA_WIDTH> > { public: scv_extensions<sc_uint<DA_WIDTH> > addr; // ... SCV_EXTENSIONS_CTOR(item_c<DA_WIDTH>) { SCV_FIELD(addr); // ... } }; That said, (depending on your compiler) the current implementation of SCV_EXTENSIONS_CTOR is missing some "this->" qualifications in its body to cope with the different lookup rules for templated base classes. Hope that helps, Philipp
  2. Unfortunately, the fix for this issue didn't make it into the 2.3.2 public review release. But we have now a possible fix, which is under review for the final 2.3.2 release: In src/tlm_utils/multi_passthrough_target_socket.h, add the following lines before the loop in multi_passthrough_target_socket::end_of_elaboration(): // complete binding only if there has been a real bind bool unbound = (binders.size() == 1 && m_export_callback_created); // no call to get_base_interface has consumed the export - ignore if (unbound) return; Hope that helps, Philipp
  3. In general: Yes, this implementation is sufficient to implement a TLM2 extension. Still, there is a more reliable pattern to implement the copy_from and clone methods by using the copy constructor and assignment operator of your extension type (which you may need to implement in some cases anyway and will be provided for free in your particular example): class reg_extension : public tlm::tlm_extension<reg_extension> { public: tlm::tlm_extension_base* clone() const { return new reg_extension(*this); } // use copy constructor void copy_from(tlm::tlm_extension_base const & that ) { *this = static_cast<const reg_extension&>(that); } // use assignment operator // ... }; This pattern works very well for all Copyable and CopyAssignable classes without having to enumerate the members in clone and copy_from. Hope that helps, Philipp
  4. Exactly. Hope that helps, Philipp
  5. Hi S., The biggest issue in your code is that you set up the tracing before you initialize the "payload_data" pointer. Nothing good can come out of this. Secondly, sc_trace requires stable memory locations to trace, as it stores a pointer internally. So you can't easily reallocate the extension over and over again (or even later than the sc_trace call). Instead, I would suggest to reuse the extension across transactions and move it to a plain member in the class (changes added below): Hope that helps, Philipp
  6. Side note: You can't use virtual inheritance with SystemC modules. See the following thread for a related discussion: Your example doesn't require this, so it should be fine to simply drop the virtual keyword in the sc_module inheritance. Hope that helps, Philipp
  7. Maybe we can just reject "--enable-pthreads" on this platform explicitly. Generally speaking, you usually want to avoid pthreads, also on Linux, unless you have specific requirements. Greetings from Duisburg, Philipp
  8. Can you explain, why you try to use Pthreads on the Msys/MinGW platform? This environment doesn't come with a Pthreads library by default, you would need to install a separate one. And Pthreads will certainly be less efficient than the WinFiber-based process implementation. Thanks, Philipp
  9. Thanks for the reproducer, Sumit! This is indeed a regression compared to SystemC 2.3.0. I'll forward the issue to the SystemC Language Working Group. Greetings from Duisburg, Philipp
  10. The instance specific extension is tied to a specific accessor object (usually a member in a module, e.g. an interconnect). So each accessor can have its own extension object and is responsible for cleaning it up later. For regular TLM extensions, yes, there can only be one extension object of each type in a transaction payload.
  11. You can have a look at the "nb2b_adapter" test in the SystemC regression test suite, located at tests/tlm/nb2b_adapter/nb2b_adapter.cpp. In this example, you find the usage of an instance-specific extension for exactly that purpose: struct route_extension: tlm_utils::instance_specific_extension<route_extension> { int id; }; // ... virtual tlm::tlm_sync_enum nb_transport_fw( int id, tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_time& delay ) { route_extension* ext = 0; if (phase == tlm::BEGIN_REQ) { ext = new route_extension; ext->id = id; // <-- store ID in the extension accessor(trans).set_extension(ext); } // ... virtual tlm::tlm_sync_enum nb_transport_bw( int id, tlm::tlm_generic_payload& trans, tlm::tlm_phase& phase, sc_time& delay ) { route_extension* ext = 0; accessor(trans).get_extension(ext); sc_assert(ext); tlm::tlm_sync_enum status; status = targ_socket[ ext->id ]->nb_transport_bw( trans, phase, delay ); // use ID from the extension Hope that helps, Philipp
  12. In line 33 of your producer.h, it seems you accidentally try to copy an interface (something derived from sc_interface). In order to give more detailed feedback, please share the code around the offending line. Hope that helps, Philipp
  13. Hi Sumit, even if the sockets are optional, you still need to bind at least one socket callback, right? Can you please check, that you actually do this? Greetings from Duisburg, Philipp
  14. On modern GCC versions (starting with 5.x), you the binary interface changed between C++03 and C++11 mode. You need to build your SystemC library with the same compiler (settings) to get the C++11 version of the functions. Hope that helps, Philipp
  15. Hi Jonas, for now, this is a known leak (as stacks from statically created processes are currently deliberately not deleted) and allocations from sc_core::sc_cor_pkg_*::create should be suppressed. (Dynamically created threads are not affected, so it is not a "real" leak). Greetings from Duisburg, Philipp