Jump to content

Philipp A Hartmann

  • Content Count

  • Joined

  • Last visited

  • Days Won


Philipp A Hartmann last won the day on August 23

Philipp A Hartmann had the most liked content!


About Philipp A Hartmann

  • Rank
    Advanced Member

Profile Information

  • Gender
    Not Telling
  • Location
    Duisburg, DE

Recent Profile Visitors

1,837 profile views
  1. Philipp A Hartmann

    sc_interface binding incorrectly

    Your consumer process is wrong: void do_reads() { char c; while (true) { if ( in->nb_read(c) ) { // only print valid characters cout << c << flush; } // wait for the next clock wait(); } } Hope that helps, Philipp
  2. Philipp A Hartmann


    Hi Guillaume, 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
  3. 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): 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
  4. Philipp A Hartmann


    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
  5. 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
  6. Philipp A Hartmann

    tlm_fifo nb_peek

    Alternatively, as you don't seem to require the debug interface, you can change the port to: sc_port<tlm::tlm_get_peek_if<int> > target_port;
  7. Hi Jan, please check this thread for a previous discussion (and fix) of this issue: Hope that helps, Philipp
  8. Philipp A Hartmann

    SystemC catching/rethrowing standard exceptions is harmful?

    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).
  9. Philipp A Hartmann

    SystemC Simulation

    Short answer: You can't. See this thread for a related discussion: Greetings from Duisburg, Philipp
  10. Philipp A Hartmann

    SystemC catching/rethrowing standard exceptions is harmful?

    Hi Roman, I can give some background here, as I'm guilty of the current implementation. The kernel also needs to handle exceptions that are escaping SystemC thread processes. These are originally thrown in a different stack and still need to be propagated to sc_main, i.e. the main thread in order to be able to still catch the exceptions there in user code. The propagation across stacks has to be done by catching in one stack and rethrowing in another. That said, exception handling not only covers sc_report, but also arbitrary exception types escaping sc_main or a SystemC thread. We don't want to cause std::terminate to be called in case of uncaught exceptions, but want to properly propagate, catch and wind down the simulation. Therefore, all exceptions are translated to standard sc_report objects before cross-stack propagation and are finally handled outside of sc_main. For consistency, the translation to sc_report is done for both, thread and method processes: It's an error, if an exception escapes a SystemC process and errors are reported as sc_report (and routed through the report handler) in SystemC. Users can catch the original exceptions themselves by adding catch blocks to sc_main and their SystemC processes. Hope that helps, Philipp
  11. Philipp A Hartmann

    Possible Bug/Regression in SystemC 2.3.2: Race Condition

    Hi Ameya, thanks for testing. As said before, unfortunately I cannot reproduce this on my end. I would need more details on the current behavior: The backtrace looks like there is something broken during model teardown. Have you seen other cases? Are all simulations with processes hanging in a similar way? (e.g. can you provide a full regression result?) Greetings from Duisburg, Philipp
  12. Philipp A Hartmann

    Possible Bug/Regression in SystemC 2.3.2: Race Condition

    Hi Ameya, I currently don't have access to such new Linux platforms, but I may have a suspicion about a potential root cause. Can you please check, if it helps to change the sc_process_b::delete_process function in src/sysc/kernel/sc_process.cpp as follows: // if ( this != sc_get_current_process_b() ) if ( NULL == sc_get_current_process_b() ) Thanks and Greetings from Duisburg, Philipp
  13. This example still uses the positional binding feature of SystemC, which is deprecated as per IEEE Std. 1666 (see Annex C (h), emphasis mine): hth, Philipp
  14. The full data length is independent of the word length. The rules for DATAWORD are defined by the standard as follows (see 14.20.3): From your example below, you seem to be using four byte word, so "unsigned" (or uint32_t) could be a used as a DATAWORD parameter.
  15. Hi Khushi, the best is to look up the definition in the IEEE 1666-2011 standard, section 14.20(.3). The different conversion functions have different constraints associated with them, allowing for more performant implementations for the _word, _aligned, and _single specializations. The _generic one covers arbitrary cases. The DATAWORD template parameter allows for optimizations as well (and endianness is always specific to the notion of a word). Hope that helps, Philipp