quantum_keeper_mt.h

#ifndef __SCC_TLM_QUANTUMKEEPER_MT_H__
#define __SCC_TLM_QUANTUMKEEPER_MT_H__
 
#include "qk/sc_time_syncronizer.h"
#include <scc/async_thread.h>
#include <sysc/kernel/sc_simcontext.h>
 
#if SC_VERSION_MAJOR < 3
#warning "Multithreaded quantum keeper is only supported with SystemC 3.0 and newer"
#else
#define DEBUG_MT_SCHEDULING
 
namespace tlm {
namespace scc {
struct quantumkeeper_mt : sc_core::sc_object {
    quantumkeeper_mt()
    : sc_core::sc_object("qk")
    , gtk_idx(qk::sc_time_syncronizer::get().get_channel_index()) {
        sc_core::sc_spawn_options opt;
        opt.spawn_method();
        opt.set_sensitivity(&keep_alive);
    }
    virtual ~quantumkeeper_mt() = default;
 
    void run_thread(std::function<sc_core::sc_time()> f) {
        qk::sc_time_syncronizer::get().notify_client_blocked(gtk_idx, false);
        reset(sc_core::sc_time_stamp());
        thread_executor.start([this, f]() {
            this->check_and_sync(sc_core::SC_ZERO_TIME);
            auto ret = f();
            qk::sc_time_syncronizer::get().notify_client_blocked(gtk_idx, true);
            return ret;
        });
        wait(thread_executor.thread_finish_event());
    }
    inline void inc(sc_core::sc_time const& core_inc) {
        local_absolute_time += core_inc;
        local_time_ticks_limit = qk::global_time_keeper::get().get_client_max_time_ticks(gtk_idx);
    }
    inline void check_and_sync(sc_core::sc_time const& core_inc) {
        inc(core_inc);
        qk::global_time_keeper::get().update_client_time_ticks(gtk_idx, local_absolute_time.value());
        // wait until the SystemC thread advanced to the same time then we are minus the global quantum
        while(local_absolute_time.value() > local_time_ticks_limit) {
            std::this_thread::yield(); // should do the same than __builtin_ia32_pause() or _mm_pause() on MSVC
            local_time_ticks_limit = qk::global_time_keeper::get().get_client_max_time_ticks(gtk_idx);
        }
    }
    inline void execute_on_sysc(std::function<void(void)> fct) { execute_on_sysc(fct, local_absolute_time); }
    inline void execute_on_sysc(std::function<void(void)>& fct, sc_core::sc_time when) {
        qk::callback_task task([this, &fct]() {
            auto t0 = sc_core::sc_time_stamp();
            fct();
            return sc_core::sc_time_stamp() - t0;
        });
        auto ret = task.get_future();
        qk::global_time_keeper::get().schedule_task(gtk_idx, std::move(task), when.value());
        auto duration = ret.get();
        check_and_sync(duration);
    }
    sc_core::sc_time get_local_time() const { return local_absolute_time - get_current_sc_time(); }
    sc_core::sc_time get_local_absolute_time() const { return local_absolute_time; }
    sc_core::sc_time get_current_sc_time() const { return sc_core::sc_time::from_value(qk::global_time_keeper::get().get_sc_time_ticks()); }
    void reset() { reset(get_current_sc_time()); }
    void reset(sc_core::sc_time const& abs_time) { local_absolute_time = sc_core::sc_time_stamp(); }
 
    void unblock_thread() { qk::global_time_keeper::get().update_client_time_ticks(gtk_idx, local_absolute_time.value()); }
 
protected:
    size_t gtk_idx;
    ::scc::async_thread thread_executor;
    sc_core::sc_event keep_alive;
    sc_core::sc_time local_absolute_time;
    uint64_t local_time_ticks_limit{0};
};
} // namespace scc
} // namespace tlm
#endif
#endif // __SCC_TLM_QUANTUMKEEPER_MT_H__