jobcommon.h

#pragma once
 
#include <cstddef>
#include <inttypes.h>
#include <new>
#include <type_traits>
#include <utility>
 
#include "gaia/core/utility.h"
#include "gaia/mem/mem_alloc.h"
#include "gaia/mt/event.h"
#include "gaia/mt/jobqueue.h"
 
namespace gaia {
  namespace util {
    class SmallFunc;
    template <typename Signature>
    class MoveFunc;
  } // namespace util
 
  namespace mt {
    enum class JobPriority : uint8_t {
      High = 0,
      Low = 1
    };
    static inline constexpr uint32_t JobPriorityCnt = 2;
 
    enum JobCreationFlags : uint8_t {
      Default = 0,
      ManualDelete = 0x01,
      CanWait = 0x02,
      Background = 0x04
    };
 
    struct JobAllocCtx {
      JobPriority priority;
    };
 
    struct JobArgs {
      uint32_t idxStart;
      uint32_t idxEnd;
    };
 
    namespace detail {
      template <typename T>
      struct is_move_func: std::false_type {};
      template <typename Signature>
      struct is_move_func<util::MoveFunc<Signature>>: std::true_type {};
    } // namespace detail
 
    template <typename TArg>
    class JobCallable {
    public:
      static constexpr uint32_t InlineSize = 24;
 
    private:
      enum class Op : uint8_t { Invoke, Finish, Destroy, Move };
      using OpFn = void (*)(Op op, JobCallable* dst, JobCallable* src, const void* pArg);
 
      OpFn m_func = nullptr;
      alignas(std::max_align_t) uint8_t m_storage[InlineSize];
 
      static void op_storage(Op op, JobCallable* dst, JobCallable* src, [[maybe_unused]] const void* pArg) {
        auto*& pStorage = *reinterpret_cast<void**>(dst->m_storage);
        switch (op) {
          case Op::Invoke:
            GAIA_ASSERT(false && "The callable was already destroyed by finish()");
            break;
          case Op::Finish:
            break;
          case Op::Destroy:
            mem::AllocHelper::free(pStorage);
            break;
          case Op::Move:
            GAIA_ASSERT(src != nullptr);
            pStorage = *reinterpret_cast<void**>(src->m_storage);
            dst->m_func = src->m_func;
            src->m_func = nullptr;
            break;
        }
      }
 
      template <typename Fn>
      static constexpr bool invocable() {
        if constexpr (std::is_void_v<TArg>)
          return std::is_invocable_r_v<void, Fn&>;
        else
          return std::is_invocable_r_v<void, Fn&, const TArg&>;
      }
 
      template <typename Fn>
      static void invoke(Fn& fn, [[maybe_unused]] const void* pArg) {
        if constexpr (std::is_void_v<TArg>)
          fn();
        else {
          GAIA_ASSERT(pArg != nullptr);
          fn(*static_cast<const TArg*>(pArg));
        }
      }
 
      void destroy() {
        if (m_func != nullptr) {
          m_func(Op::Destroy, this, nullptr, nullptr);
          m_func = nullptr;
        }
      }
 
      void exec_inter(const void* pArg) const {
        GAIA_ASSERT(m_func != nullptr);
        m_func(Op::Invoke, const_cast<JobCallable*>(this), nullptr, pArg);
      }
 
      template <typename F>
      void init(F&& f) {
        using Fn = std::decay_t<F>;
        static_assert(
            !std::is_same_v<Fn, util::SmallFunc> && !detail::is_move_func<Fn>::value,
            "Pass the callable itself. SmallFunc and MoveFunc may keep it in SmallBlockAllocator, which job "
            "threads must not free from");
        static_assert(invocable<Fn>(), "JobCallable requires a callable compatible with its signature");
        static_assert(std::is_move_constructible_v<Fn>, "Callable must be move-constructible");
        static_assert(
            alignof(Fn) <= alignof(std::max_align_t), "Over-aligned callables are not supported for JobCallable");
 
        if constexpr (stores_inline<Fn>()) {
          new (m_storage) Fn(GAIA_FWD(f));
 
          m_func = [](Op op, JobCallable* dst, JobCallable* src, const void* pArg) {
            auto* pFn = reinterpret_cast<Fn*>(dst->m_storage);
            switch (op) {
              case Op::Invoke:
                invoke(*pFn, pArg);
                break;
              case Op::Finish:
                // A trivially destructible callable has nothing to end and is left untouched.
                if constexpr (!std::is_trivially_destructible_v<Fn>) {
                  pFn->~Fn();
                  dst->m_func = nullptr;
                }
                break;
              case Op::Destroy:
                if constexpr (!std::is_trivially_destructible_v<Fn>)
                  pFn->~Fn();
                break;
              case Op::Move: {
                GAIA_ASSERT(src != nullptr);
                auto* pSrcFn = reinterpret_cast<Fn*>(src->m_storage);
                new (dst->m_storage) Fn(GAIA_MOV(*pSrcFn));
                if constexpr (!std::is_trivially_destructible_v<Fn>)
                  pSrcFn->~Fn();
                dst->m_func = src->m_func;
                src->m_func = nullptr;
                break;
              }
            }
          };
        } else {
          auto* pStorage = mem::AllocHelper::alloc<Fn>();
          GAIA_ASSERT((uintptr_t)pStorage % alignof(Fn) == 0);
          auto* pFunc = new (pStorage) Fn(GAIA_FWD(f));
          *reinterpret_cast<Fn**>(m_storage) = pFunc;
 
          m_func = [](Op op, JobCallable* dst, JobCallable* src, const void* pArg) {
            auto*& pFn = *reinterpret_cast<Fn**>(dst->m_storage);
            switch (op) {
              case Op::Invoke:
                GAIA_ASSERT(pFn != nullptr);
                invoke(*pFn, pArg);
                break;
              case Op::Finish:
                // A trivially destructible callable has nothing to end and is left untouched.
                if constexpr (!std::is_trivially_destructible_v<Fn>) {
                  GAIA_ASSERT(pFn != nullptr);
                  pFn->~Fn();
                  dst->m_func = &op_storage;
                }
                break;
              case Op::Destroy:
                GAIA_ASSERT(pFn != nullptr);
                if constexpr (!std::is_trivially_destructible_v<Fn>)
                  pFn->~Fn();
                mem::AllocHelper::free(pFn);
                break;
              case Op::Move:
                GAIA_ASSERT(src != nullptr);
                *reinterpret_cast<Fn**>(dst->m_storage) = *reinterpret_cast<Fn**>(src->m_storage);
                dst->m_func = src->m_func;
                *reinterpret_cast<Fn**>(src->m_storage) = nullptr;
                src->m_func = nullptr;
                break;
            }
          };
        }
      }
 
    public:
      template <typename F>
      GAIA_NODISCARD static constexpr bool stores_inline() {
        using Fn = std::decay_t<F>;
        return sizeof(Fn) <= InlineSize && alignof(Fn) <= alignof(std::max_align_t);
      }
 
      JobCallable() = default;
      ~JobCallable() {
        if (m_func != nullptr)
          m_func(Op::Destroy, this, nullptr, nullptr);
      }
 
      JobCallable(const JobCallable&) = delete;
      JobCallable& operator=(const JobCallable&) = delete;
 
      JobCallable(JobCallable&& other) noexcept {
        if (other.m_func != nullptr)
          other.m_func(Op::Move, this, &other, nullptr);
      }
 
      JobCallable& operator=(JobCallable&& other) noexcept {
        if (this != &other) {
          destroy();
          if (other.m_func != nullptr)
            other.m_func(Op::Move, this, &other, nullptr);
        }
        return *this;
      }
 
      template <typename F, typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, JobCallable>>>
      JobCallable(F&& f) {
        init(GAIA_FWD(f));
      }
 
      template <typename F, typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, JobCallable>>>
      JobCallable& operator=(F&& f) {
        destroy();
        init(GAIA_FWD(f));
        return *this;
      }
 
      template <typename F>
      static JobCallable create(F&& f) {
        JobCallable func;
        func.init(GAIA_FWD(f));
        return func;
      }
 
      template <typename T = TArg, typename = std::enable_if_t<std::is_void_v<T>>>
      void exec() const {
        exec_inter(nullptr);
      }
 
      template <typename T = TArg, typename = std::enable_if_t<!std::is_void_v<T>>>
      void exec(const T& arg) const {
        exec_inter(&arg);
      }
 
      template <typename T = TArg, typename = std::enable_if_t<std::is_void_v<T>>>
      void operator()() const {
        exec_inter(nullptr);
      }
 
      template <typename T = TArg, typename = std::enable_if_t<!std::is_void_v<T>>>
      void operator()(const T& arg) const {
        exec_inter(&arg);
      }
 
      void reset() {
        destroy();
      }
 
      void finish() {
        if (m_func != nullptr)
          m_func(Op::Finish, this, nullptr, nullptr);
      }
 
      explicit operator bool() const {
        return m_func != nullptr;
      }
    };
 
    using JobFunc = JobCallable<void>;
    using JobArgsFunc = JobCallable<JobArgs>;
 
    struct Job {
      JobFunc func;
      JobPriority priority = JobPriority::High;
      JobCreationFlags flags = JobCreationFlags::Default;
    };
 
    struct JobParallel {
      JobArgsFunc func;
      JobPriority priority = JobPriority::High;
    };
 
    struct JobParallelRef {
      void* pCtx = nullptr;
      void (*invoke)(void*, const JobArgs&) = nullptr;
      JobPriority priority = JobPriority::High;
    };
 
    class ThreadPool;
 
    struct ThreadCtx {
      ThreadPool* tp;
      uint32_t workerIdx;
      JobPriority prio;
      bool background = false;
      bool threadCreated = false;
      Event event;
      JobQueue<512> jobQueue;
 
      ThreadCtx() = default;
      ~ThreadCtx() = default;
 
      void reset() {
        background = false;
        threadCreated = false;
        event.reset();
        jobQueue.clear();
      }
 
      ThreadCtx(const ThreadCtx& other) = delete;
      ThreadCtx& operator=(const ThreadCtx& other) = delete;
      ThreadCtx(ThreadCtx&& other) = delete;
      ThreadCtx& operator=(ThreadCtx&& other) = delete;
    };
  } // namespace mt
} // namespace gaia