task_info.hxx

Go to the documentation of this file.

 
#pragma once
#include <ice/task_types.hxx>
#include <atomic>
 
namespace ice
{

    enum class TaskState : ice::u8
    {
        None,
        Invalid = None,

        Created = 0x01,

        Running = 0x02,

        Suspended = 0x04,

        Succeeded = 0x08,

        Canceled = 0x10,

        Failed = 0x20,
 
        All = Created | Running | Suspended | Succeeded | Canceled | Failed,
    };
 
    template<bool IsProfilerEnabled = false>
    struct TaskProfilingInfo { };
 
    template<>
    struct TaskProfilingInfo<true>
    {
        char const* fiber_name;
    };
 
    struct TaskInfo final
    {
        static constexpr bool HasProfilingInfo = false;
 
        TaskInfo() noexcept = default;
        TaskInfo(TaskInfo&&) noexcept = delete;
        TaskInfo(TaskInfo const&) noexcept = delete;
        auto operator=(TaskInfo&&) noexcept -> TaskInfo& = delete;
        auto operator=(TaskInfo const&) noexcept -> TaskInfo& = delete;
 
        auto aquire() noexcept -> ice::TaskInfo*;
        void release() noexcept;
 
        bool has_any(ice::TaskState state) const noexcept;
 
        ice::TaskProfilingInfo<false> profiling;
        std::atomic<ice::TaskState> state = TaskState::Created;
 
    private:
        std::atomic<ice::u8> _refcount = 1;
    };
 
    inline auto TaskInfo::aquire() noexcept -> TaskInfo*
    {
        ICE_ASSERT_CORE(_refcount.load(std::memory_order_relaxed) < 255);
        _refcount.fetch_add(1, std::memory_order_relaxed);
        return this;
    }
 
    inline void TaskInfo::release() noexcept
    {
        ICE_ASSERT_CORE(_refcount.load(std::memory_order_relaxed) != 0);
        if (_refcount.fetch_sub(1, std::memory_order_relaxed) == 0)
        {
            delete this;
        }
    }
 
    inline bool TaskInfo::has_any(ice::TaskState flags) const noexcept
    {
        return ice::has_any(state.load(std::memory_order_relaxed), flags);
    }
 
} // namespace ice