gpu_render_time.hpp

Go to the documentation of this file.

#pragma once
 
#if defined(PULP_GPU_RUNTIME)
// This build's device layer is gpu-runtime's (tools/cmake/PulpGpuRuntime.cmake):
// these are its types and functions under their Pulp names, so a Pulp object
// and a gpu-runtime object are one and the same.
#include <gpu_runtime/gpu_render_time.hpp>
 
namespace pulp::render {
using gpu_runtime::gpu_render_ns_to_ms;
using gpu_runtime::gpu_surface_disabled_toggles;
using gpu_runtime::GpuFramesInFlight;
using gpu_runtime::GpuRenderTimeTracker;
using gpu_runtime::kDawnTimestampQuantizationToggle;
using gpu_runtime::kGpuRenderNanosecondsPerMillisecond;
} // namespace pulp::render
#else // !PULP_GPU_RUNTIME
 
#include <atomic>
#include <cstdint>
#include <optional>
#include <vector>
 
namespace pulp::render {


inline constexpr double kGpuRenderNanosecondsPerMillisecond = 1.0e6;

inline constexpr const char* kDawnTimestampQuantizationToggle = "timestamp_quantization";

[[nodiscard]] inline std::vector<const char*>
gpu_surface_disabled_toggles(bool timestamp_query_requested) {
    std::vector<const char*> disabled;
    if (timestamp_query_requested) {
        disabled.push_back(kDawnTimestampQuantizationToggle);
    }
    return disabled;
}

[[nodiscard]] inline std::optional<double>
gpu_render_ns_to_ms(std::uint64_t elapsed_ns, bool callback_ok) {
    if (!callback_ok || elapsed_ns == 0) {
        return std::nullopt;
    }
    return static_cast<double>(elapsed_ns) / kGpuRenderNanosecondsPerMillisecond;
}

class GpuRenderTimeTracker {
public:
    void store(std::uint64_t elapsed_ns, bool callback_ok) {
        if (auto ms = gpu_render_ns_to_ms(elapsed_ns, callback_ok)) {
            last_ms_.store(*ms, std::memory_order_relaxed);
            have_sample_.store(true, std::memory_order_relaxed);
        }
    }

    [[nodiscard]] bool have_sample() const {
        return have_sample_.load(std::memory_order_relaxed);
    }

    [[nodiscard]] double last_ms() const {
        return last_ms_.load(std::memory_order_relaxed);
    }
 
private:
    std::atomic<double> last_ms_{0.0};
    std::atomic<bool> have_sample_{false};
};

class GpuFramesInFlight {
public:
    void on_submitted() { count_.fetch_add(1, std::memory_order_relaxed); }
    void on_finished() {
        int current = count_.load(std::memory_order_relaxed);
        while (current > 0 &&
               !count_.compare_exchange_weak(current, current - 1,
                                             std::memory_order_relaxed)) {}
    }
    [[nodiscard]] int count() const { return count_.load(std::memory_order_relaxed); }
 
private:
    std::atomic<int> count_{0};
};
 
} // namespace pulp::render
 
#endif // PULP_GPU_RUNTIME