asset_handle.h

Go to the documentation of this file.

#pragma once
 
#include <engine/engine_export.h>
#include <hpp/filesystem.hpp>
#include <logging/logging.h>
 
#include <atomic>
#include <chrono>
#include <memory>
#include <mutex>
#include <string>
#include <uuid/uuid.h>
 
#include "../threading/threader.h"
 
template<typename T>
using task_future = tpp::job_shared_future<T>;
 
template<typename T>
struct asset_handle;
 
namespace asset_detail
{
 
template<typename T>
class atomic_shared_ptr
{
public:
    atomic_shared_ptr() = default;
    explicit atomic_shared_ptr(std::shared_ptr<T> initial) : ptr_(std::move(initial)) {}
 
    auto load(std::memory_order order = std::memory_order_seq_cst) const -> std::shared_ptr<T>
    {
#if defined(__cpp_lib_atomic_shared_ptr) && (__cpp_lib_atomic_shared_ptr >= 201711L)
        return ptr_.load(order);
#else
        return std::atomic_load_explicit(&ptr_, order);
#endif
    }
 
    void store(std::shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst)
    {
#if defined(__cpp_lib_atomic_shared_ptr) && (__cpp_lib_atomic_shared_ptr >= 201711L)
        ptr_.store(std::move(desired), order);
#else
        std::atomic_store_explicit(&ptr_, std::move(desired), order);
#endif
    }
 
private:
#if defined(__cpp_lib_atomic_shared_ptr) && (__cpp_lib_atomic_shared_ptr >= 201711L)
    std::atomic<std::shared_ptr<T>> ptr_{};
#else
    std::shared_ptr<T> ptr_{};
#endif
};
 
} // namespace asset_detail
 
template<typename T>
struct asset_link
{
    using task_future_t = task_future<std::shared_ptr<T>>;
    using weak_asset_t = std::weak_ptr<T>;
 
    struct state_t
    {
        hpp::uuid uid;
        std::string id;
        task_future_t task;
    };
 
    asset_detail::atomic_shared_ptr<state_t> state{std::make_shared<state_t>()};
 
    mutable std::mutex weak_asset_mtx;
    mutable weak_asset_t weak_asset;
 
    mutable std::atomic<int64_t> last_access_ns{0};
};
 
template<typename T>
struct asset_handle
{
    using asset_link_t = asset_link<T>;
    using state_t = typename asset_link_t::state_t;
    using state_ptr = std::shared_ptr<state_t>;
    using task_future_t = typename asset_link_t::task_future_t;
 
    auto operator==(const asset_handle& rhs) const -> bool
    {
        return uid() == rhs.uid() && id() == rhs.id() && is_valid() == rhs.is_valid();
    }
 
    auto version() const -> uintptr_t
    {
        update_last_access();
        return uintptr_t(peek().get());
    }
 
    operator bool() const
    {
        return is_valid();
    }
 
    auto id() const -> std::string
    {
        if(auto s = load_state())
        {
            return s->id;
        }
        return {};
    }
 
    auto uid() const -> hpp::uuid
    {
        if(auto s = load_state())
        {
            return s->uid;
        }
        return {};
    }
 
    auto name() const -> std::string
    {
        return fs::path(id()).stem().string();
    }
 
    auto extension() const -> std::string
    {
        return fs::path(id()).extension().string();
    }
 
    auto get(bool wait = true) const -> std::shared_ptr<T>
    {
        update_last_access();
 
        if(auto cached_asset = peek())
        {
            return cached_asset;
        }
 
        // Take a stable snapshot. Even if another thread invalidates the link
        // mid-call, our local `s` keeps the old state alive for the duration.
        auto s = load_state();
        if(!s || !s->task.valid())
        {
            return empty_asset();
        }
 
        if(!s->task.is_submitted())
        {
            s->task.submit();
        }
 
        const bool ready = s->task.is_ready();
        const bool should_get = ready || wait;
        if(!should_get)
        {
            return empty_asset();
        }
 
        // Copy the task locally; we may need to change priority. task.get()
        // may block — we must hold no locks here.
        auto task = s->task;
        if(!ready)
        {
            task.change_priority(tpp::priority::high());
        }
 
        auto value = task.get();
        if(value)
        {
            std::lock_guard<std::mutex> lock(link_->weak_asset_mtx);
            link_->weak_asset = value;
            return value;
        }
        return empty_asset();
    }
 
    auto is_valid() const -> bool
    {
        auto s = load_state();
        return s && s->task.valid();
    }
 
    auto is_ready() const -> bool
    {
        auto s = load_state();
        return s && s->task.valid() && s->task.is_ready();
    }
 
    auto is_deferred() const -> bool
    {
        auto s = load_state();
        return s && s->task.valid() && !s->task.is_submitted();
    }
 
    auto is_loading() const -> bool
    {
        auto s = load_state();
        return s && s->task.valid() && s->task.is_submitted() && !s->task.is_ready();
    }
 
    void submit()
    {
        auto s = load_state();
        if(s && s->task.valid() && !s->task.is_submitted())
        {
            s->task.submit();
        }
    }
 
    void demote_to_deferred()
    {
        if(!link_)
        {
            return;
        }
 
        auto old = load_state();
        auto fresh = std::make_shared<state_t>();
        if(old)
        {
            fresh->uid = old->uid;
            fresh->id = old->id;
        }
        link_->state.store(std::move(fresh), std::memory_order_release);
 
        std::lock_guard<std::mutex> lock(link_->weak_asset_mtx);
        link_->weak_asset.reset();
    }
 
    auto last_access() const -> std::chrono::steady_clock::time_point
    {
        if(!link_)
        {
            return {};
        }
        const auto ns = link_->last_access_ns.load(std::memory_order_relaxed);
        return std::chrono::steady_clock::time_point(std::chrono::nanoseconds(ns));
    }
 
    auto task_id() const
    {
        if(auto s = load_state(); s && s->task.valid())
        {
            return s->task.id;
        }
        return tpp::job_id{};
    }
 
    void set_internal_job(const task_future_t& future)
    {
        ensure();
        publish_state(
            [&](state_t& fresh) -> void
            {
                fresh.task = future;
            });
 
        std::lock_guard<std::mutex> lock(link_->weak_asset_mtx);
        link_->weak_asset.reset();
    }
 
    void set_internal_ids(const hpp::uuid& internal_uid, const std::string& internal_id = get_empty_id())
    {
        ensure();
        publish_state(
            [&](state_t& fresh) -> void
            {
                fresh.uid = internal_uid;
                fresh.id = internal_id;
            });
    }
 
    void set_internal_id(const std::string& internal_id = get_empty_id())
    {
        ensure();
        publish_state(
            [&](state_t& fresh) -> void
            {
                fresh.id = internal_id;
            });
    }
 
    void invalidate()
    {
        if(auto s = load_state(); s && s->task.valid())
        {
            const auto task_count = s->task.use_count();
            if(task_count > 1)
            {
                APPLOG_TRACE("{} - task leak use_count {}", s->id, task_count);
            }
        }
 
        if(!link_)
        {
            return;
        }
        link_->state.store(std::make_shared<state_t>(), std::memory_order_release);
 
        std::lock_guard<std::mutex> lock(link_->weak_asset_mtx);
        link_->weak_asset.reset();
    }
 
    static auto get_empty() -> const asset_handle&
    {
        static const asset_handle none_asset = []() -> asset_handle
        {
            asset_handle asset;
            asset.set_internal_ids({});
            return asset;
        }();
        return none_asset;
    }
 
    static auto get_empty_id() -> const std::string&
    {
        static const std::string empty{"None"};
        return empty;
    }
 
    auto peek() const -> std::shared_ptr<T>
    {
        if(!link_)
        {
            return nullptr;
        }
        std::lock_guard<std::mutex> lock(link_->weak_asset_mtx);
        return link_->weak_asset.lock();
    }
 
    void ensure()
    {
        static_assert(sizeof(asset_link_t) >= 1, "Type must be fully defined");
        if(!link_)
        {
            link_ = std::make_shared<asset_link_t>();
        }
    }
 
private:
    auto load_state() const -> state_ptr
    {
        if(!link_)
        {
            return nullptr;
        }
        return link_->state.load(std::memory_order_acquire);
    }
 
    template<typename F>
    void publish_state(F&& mutator)
    {
        auto old = load_state();
        auto fresh = std::make_shared<state_t>();
        if(old)
        {
            *fresh = *old;
        }
        std::forward<F>(mutator)(*fresh);
        link_->state.store(std::move(fresh), std::memory_order_release);
    }
 
    static auto empty_asset() -> std::shared_ptr<T>
    {
        static const std::shared_ptr<T> empty = std::make_shared<T>();
        return empty;
    }
 
    void update_last_access() const
    {
        if(!link_)
        {
            return;
        }
        const auto now = std::chrono::steady_clock::now().time_since_epoch();
        const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(now).count();
        link_->last_access_ns.store(ns, std::memory_order_relaxed);
    }
 
    std::shared_ptr<asset_link_t> link_;
};