threadloop.hpp

#pragma once
 
#include "cpu_timer.hpp"
#include "error_util.hpp"
#include "phonebook.hpp"
#include "plugin.hpp"
#include "record_logger.hpp"
#include "stoplight.hpp"
 
#include <atomic>
#include <cassert>
#include <chrono>
#include <functional>
#include <iostream>
#include <memory>
#include <thread>
 
namespace ILLIXR {
 
const record_header __threadloop_iteration_header{
    "threadloop_iteration",
    {
        {"plugin_id", typeid(std::size_t)},
        {"iteration_no", typeid(std::size_t)},
        {"skips", typeid(std::size_t)},
        {"cpu_time_start", typeid(std::chrono::nanoseconds)},
        {"cpu_time_stop", typeid(std::chrono::nanoseconds)},
        {"wall_time_start", typeid(std::chrono::high_resolution_clock::time_point)},
        {"wall_time_stop", typeid(std::chrono::high_resolution_clock::time_point)},
    }};
 
class threadloop : public plugin {
public:
    threadloop(const std::string& name_, phonebook* pb_)
        : plugin{name_, pb_}
        , _m_stoplight{pb->lookup_impl<Stoplight>()} { }
 
    void start() override {
        plugin::start();
        _m_thread = std::thread(std::bind(&threadloop::thread_main, this));
        assert(!_m_stoplight->check_should_stop());
        assert(_m_thread.joinable());
    }
 
    void stop() override {
        assert(_m_stoplight->check_should_stop());
        assert(_m_thread.joinable());
        _m_thread.join();
    }
 
    virtual void internal_stop() {
        _m_internal_stop.store(true);
    }
 
    ~threadloop() override {
        assert(_m_stoplight->check_should_stop());
        assert(!_m_thread.joinable());
    }
 
protected:
    std::size_t iteration_no = 0;
    std::size_t skip_no      = 0;
 
private:
    void thread_main() {
        record_coalescer it_log{record_logger_};
 
        // TODO: In the future, synchronize the main loop instead of the setup.
        // This is currently not possible because RelativeClock is required in
        // some setup functions, and RelativeClock is only guaranteed to be
        // available once `wait_for_ready()` unblocks.
        _m_stoplight->wait_for_ready();
        _p_thread_setup();
 
        while (!_m_stoplight->check_should_stop() && !should_terminate()) {
            skip_option s = _p_should_skip();
 
            switch (s) {
            case skip_option::skip_and_yield:
                std::this_thread::yield();
                ++skip_no;
                break;
            case skip_option::skip_and_spin:
                ++skip_no;
                break;
            case skip_option::run: {
                auto iteration_start_cpu_time  = thread_cpu_time();
                auto iteration_start_wall_time = std::chrono::high_resolution_clock::now();
 
                RAC_ERRNO();
                _p_one_iteration();
                RAC_ERRNO();
 
                it_log.log(record{__threadloop_iteration_header,
                                  {
                                      {id},
                                      {iteration_no},
                                      {skip_no},
                                      {iteration_start_cpu_time},
                                      {thread_cpu_time()},
                                      {iteration_start_wall_time},
                                      {std::chrono::high_resolution_clock::now()},
                                  }});
                ++iteration_no;
                skip_no = 0;
                break;
            }
            case skip_option::stop:
                // Break out of the switch AND the loop
                // See https://stackoverflow.com/questions/27788326/breaking-out-of-nested-loop-c
                goto break_loop;
            }
        }
    break_loop:
        [[maybe_unused]] int cpp_requires_a_statement_after_a_label_plz_optimize_me_away;
    }
 
protected:
    enum class skip_option {
        run,
 
        skip_and_spin,
 
        skip_and_yield,
 
        stop,
    };
 
    virtual skip_option _p_should_skip() {
        return skip_option::run;
    }
 
    virtual void _p_thread_setup() { }
 
    virtual void _p_one_iteration() = 0;
 
    bool should_terminate() {
        return _m_internal_stop.load();
    }
 
private:
    std::atomic<bool>                _m_internal_stop{false};
    std::thread                      _m_thread;
    std::shared_ptr<const Stoplight> _m_stoplight;
};
 
} // namespace ILLIXR