global_time_keeper.h

#ifndef __SCC_TLM_QK_GLOBAL_TIME_KEEPER_H__
#define __SCC_TLM_QK_GLOBAL_TIME_KEEPER_H__
 
#include "types.h"
#include <deque>
 
namespace tlm {
namespace scc {
namespace qk {
//
struct sc_time_syncronizer;
struct global_time_keeper {
    friend class sc_time_syncronizer;
    const sc_core::sc_time sc_time_step = 1_ms;
    static global_time_keeper& get() {
        static global_time_keeper keeper;
        return keeper;
    }

    inline uint64_t get_client_min_time_ticks() { return client_min_time; }
    inline uint64_t get_client_max_time_ticks(size_t idx) { return client_max_time; }
    inline void update_client_time_ticks(size_t idx, uint64_t tick) {
        client_coms_channels[idx].client2time_keeper.push(std::move(comms_entry{tick, std::move(callback_task())}));
        update_it.store(true);
        std::unique_lock<std::mutex> lk(upd_mtx);
        update.notify_all();
    }

    inline void schedule_task(size_t idx, std::packaged_task<sc_core::sc_time(void)>&& task, uint64_t when) {
        client_coms_channels[idx].client2time_keeper.push(std::move(comms_entry{when, std::move(task)}));
        update_it.store(true);
        std::unique_lock<std::mutex> lk(upd_mtx);
        update.notify_all();
    }

    inline uint64_t get_sc_time_ticks() { return sc_kernel_time.load(); }
    inline void update_sc_time_ticks(uint64_t tick) {
        sc_coms_channel.client2time_keeper.push(std::move(comms_entry{tick, std::move(callback_task())}));
        update_it.store(true);
        std::unique_lock<std::mutex> lk(upd_mtx);
        update.notify_all();
    }
 
protected:
    global_time_keeper();
 
    global_time_keeper(global_time_keeper const&) = delete;
 
    global_time_keeper(global_time_keeper&&) = delete;
 
    ~global_time_keeper();
 
    void start();
 
    size_t get_channel_index();
 
    void sync_local_times();
 
    std::atomic<bool> stop_it{false};
    std::atomic<bool> update_it{false};
    std::atomic_uint64_t client_min_time;
    std::atomic_uint64_t client_max_time;
    std::atomic_uint64_t sc_kernel_time;
    std::mutex upd_mtx;
    std::condition_variable update;
    thread_comms_channel sc_coms_channel{-1ULL};
    std::deque<thread_comms_channel> client_coms_channels;
    rigtorp::SPSCQueue<std::tuple<size_t, uint64_t, callback_task>> pending_tasks{1024};
    bool started = false;
};
} // namespace qk
} // namespace scc
} // namespace tlm
#endif // __SCC_TLM_QK_GLOBAL_TIME_KEEPER_H__