trace_timeout.hpp

Go to the documentation of this file.

#pragma once
 
// trace_timeout.hpp — the owned, interruptible timeout behind Perfetto's
// auto-flush (WAH-4).
//
// It lives in its own header, compiled UNCONDITIONALLY, for the same reason
// `tracing_reminder_first_time()` does: Pulp's default build is
// PULP_TRACING=OFF, so anything defined only inside `#if PULP_TRACING_ENABLED`
// is never exercised by CI. The lifetime rules here are exactly the ones that
// were wrong, so they need a gate that actually runs.
//
// What it replaces: a detached `std::thread` that slept for N seconds and then
// called back into process-global tracing state. Two failures, both reachable
// from an ordinary DAW session:
//
//   * The plug-in module can be unloaded (`FreeLibrary` / `dlclose`) while that
//     thread still sleeps. It then wakes into freed code — on Windows, inside
//     the loader lock, which is a hard crash rather than a diagnosable fault.
//   * A timer armed for one capture could stop a LATER one. Close and reopen an
//     editor inside the `PULP_TRACE_SECONDS` window and the second capture was
//     silently truncated by the first one's timer.
//
// So: cancellation is immediate (a condition variable, not "after the remaining
// sleep"), the thread is joinable and joined by the final detach, and every
// timeout carries the session generation it was armed for.
 
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <functional>
#include <mutex>
#include <thread>
 
namespace pulp::runtime::detail {

constexpr bool timeout_targets_current_session(std::uint64_t armed_for,
                                               std::uint64_t current) noexcept {
    return armed_for != 0 && armed_for == current;
}

class TimeoutController {
public:
    TimeoutController() = default;
    TimeoutController(const TimeoutController&) = delete;
    TimeoutController& operator=(const TimeoutController&) = delete;
    ~TimeoutController() { cancel_and_join(); }

    void arm(std::chrono::milliseconds delay, std::uint64_t generation,
             std::function<void(std::uint64_t)> on_expire) {
        cancel_and_join();
        {
            std::lock_guard<std::mutex> lk(mu_);
            cancelled_ = false;
        }
        worker_ = std::thread([this, delay, generation,
                               on_expire = std::move(on_expire)] {
            {
                std::unique_lock<std::mutex> lk(mu_);
                // The predicate makes this immune to spurious wakeups AND to a
                // cancel that lands before the wait even starts — a real race,
                // because arm() releases mu_ before the thread runs.
                if (cv_.wait_for(lk, delay, [this] { return cancelled_; }))
                    return;
            }
            // Called with mu_ RELEASED: the callback re-enters tracing state
            // and may block, and holding mu_ here would make cancel_and_join()
            // wait on it.
            if (on_expire) on_expire(generation);
        });
    }

    void cancel_and_join() {
        if (!worker_.joinable()) return;
        {
            std::lock_guard<std::mutex> lk(mu_);
            cancelled_ = true;
        }
        cv_.notify_all();
        worker_.join();
    }

    bool armed() const noexcept { return worker_.joinable(); }
 
private:
    std::mutex mu_;
    std::condition_variable cv_;
    bool cancelled_ = false;
    std::thread worker_;
};
 
}  // namespace pulp::runtime::detail