perf_counters.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.
#if defined(PULP_BENCHMARK) && !defined(GPU_RUNTIME_BENCHMARK)
#error "PULP_BENCHMARK needs a gpu-runtime built with GPU_RUNTIME_BENCHMARK"
#endif
#if defined(GPU_RUNTIME_BENCHMARK)
#include <gpu_runtime/bench/perf_counters.hpp>
 
namespace pulp::render::bench {
using gpu_runtime::bench::now_us;
using gpu_runtime::bench::PerfCounters;
} // namespace pulp::render::bench
#endif // GPU_RUNTIME_BENCHMARK
#else  // !PULP_GPU_RUNTIME

 
#ifdef PULP_BENCHMARK
 
#include <atomic>
#include <chrono>
 
namespace pulp::render::bench {

static inline double now_us() {
    using Clock = std::chrono::high_resolution_clock;
    return static_cast<double>(
        std::chrono::duration_cast<std::chrono::nanoseconds>(
            Clock::now().time_since_epoch()).count()) / 1000.0;
}

struct PerfCounters {
    // Per-frame latency buckets (microseconds, accumulated across samples).
    std::atomic<double> audio_copy_total_us{0.0};
    std::atomic<double> triplebuffer_publish_total_us{0.0};
    std::atomic<double> gpu_upload_total_us{0.0};
    std::atomic<double> gpu_readback_total_us{0.0};
    std::atomic<double> gpu_dispatch_total_us{0.0};
    std::atomic<double> total_frame_total_us{0.0};
 
    // Per-frame bandwidth buckets (bytes, accumulated across samples).
    std::atomic<double> cpu_to_gpu_bytes_total{0.0};
    std::atomic<double> gpu_to_cpu_bytes_total{0.0};
 
    // Number of samples (frames) rolled into the above totals.
    std::atomic<double> sample_count{0.0};
 
    // JS→GPU upload instrumentation. Captures the JS-driven WebGPU resource
    // setup path in `core/view/src/widget_bridge.cpp`: base64 decode cost,
    // the number of WriteBuffer calls (so per-upload cost is derivable from
    // `gpu_upload_total_us / gpu_buffer_upload_count`), and the peak resident
    // GPU-buffer memory so we can tell whether a workload actually stresses
    // the bridge.
    //
    // The peak is tracked via a `compare_exchange` loop in
    // `observe_resident_peak` so concurrent writers stay monotonic
    // without a lock.
    std::atomic<double> base64_decode_total_us{0.0};
    std::atomic<double> gpu_buffer_upload_count{0.0};
    std::atomic<double> gpu_buffer_bytes_resident_peak{0.0};

    void reset() {
        audio_copy_total_us.store(0.0, std::memory_order_relaxed);
        triplebuffer_publish_total_us.store(0.0, std::memory_order_relaxed);
        gpu_upload_total_us.store(0.0, std::memory_order_relaxed);
        gpu_readback_total_us.store(0.0, std::memory_order_relaxed);
        gpu_dispatch_total_us.store(0.0, std::memory_order_relaxed);
        total_frame_total_us.store(0.0, std::memory_order_relaxed);
        cpu_to_gpu_bytes_total.store(0.0, std::memory_order_relaxed);
        gpu_to_cpu_bytes_total.store(0.0, std::memory_order_relaxed);
        sample_count.store(0.0, std::memory_order_relaxed);
        base64_decode_total_us.store(0.0, std::memory_order_relaxed);
        gpu_buffer_upload_count.store(0.0, std::memory_order_relaxed);
        gpu_buffer_bytes_resident_peak.store(0.0, std::memory_order_relaxed);
    }

    void observe_resident_peak(double candidate) {
        double prev = gpu_buffer_bytes_resident_peak.load(std::memory_order_relaxed);
        while (candidate > prev &&
               !gpu_buffer_bytes_resident_peak.compare_exchange_weak(
                   prev, candidate, std::memory_order_relaxed)) {
            // `prev` is refreshed by `compare_exchange_weak` on failure;
            // loop until we either succeed or the candidate is no
            // longer larger.
        }
    }

    struct Snapshot {
        double audio_copy_total_us = 0.0;
        double triplebuffer_publish_total_us = 0.0;
        double gpu_upload_total_us = 0.0;
        double gpu_readback_total_us = 0.0;
        double gpu_dispatch_total_us = 0.0;
        double total_frame_total_us = 0.0;
        double cpu_to_gpu_bytes_total = 0.0;
        double gpu_to_cpu_bytes_total = 0.0;
        double sample_count = 0.0;
        double base64_decode_total_us = 0.0;
        double gpu_buffer_upload_count = 0.0;
        double gpu_buffer_bytes_resident_peak = 0.0;
    };

    Snapshot snapshot_and_reset() {
        Snapshot s;
        s.audio_copy_total_us =
            audio_copy_total_us.exchange(0.0, std::memory_order_relaxed);
        s.triplebuffer_publish_total_us =
            triplebuffer_publish_total_us.exchange(0.0, std::memory_order_relaxed);
        s.gpu_upload_total_us =
            gpu_upload_total_us.exchange(0.0, std::memory_order_relaxed);
        s.gpu_readback_total_us =
            gpu_readback_total_us.exchange(0.0, std::memory_order_relaxed);
        s.gpu_dispatch_total_us =
            gpu_dispatch_total_us.exchange(0.0, std::memory_order_relaxed);
        s.total_frame_total_us =
            total_frame_total_us.exchange(0.0, std::memory_order_relaxed);
        s.cpu_to_gpu_bytes_total =
            cpu_to_gpu_bytes_total.exchange(0.0, std::memory_order_relaxed);
        s.gpu_to_cpu_bytes_total =
            gpu_to_cpu_bytes_total.exchange(0.0, std::memory_order_relaxed);
        s.sample_count =
            sample_count.exchange(0.0, std::memory_order_relaxed);
        s.base64_decode_total_us =
            base64_decode_total_us.exchange(0.0, std::memory_order_relaxed);
        s.gpu_buffer_upload_count =
            gpu_buffer_upload_count.exchange(0.0, std::memory_order_relaxed);
        s.gpu_buffer_bytes_resident_peak =
            gpu_buffer_bytes_resident_peak.exchange(0.0, std::memory_order_relaxed);
        return s;
    }
};
 
} // namespace pulp::render::bench
 
#endif // PULP_BENCHMARK
 
#endif // PULP_GPU_RUNTIME