Martino Ferrari
3c0e7763ab
The persistent-mapped instance ring had three slots and recorded a fence per upload, so a frame recycled a slot whose fence was recorded a few draws earlier *in that same frame*: from the fourth of the demos' nine uploads on, each one waited on the frame's own work. It is free on a driver that retires draws promptly (the GLFW host, 1.07 ms/frame) and ~4 ms of the Qt widget's 7.11 ms under llvmpipe, and it grows with the trace and cursor counts this library exists for. * The ring grows to cover a frame's upload count, the frame's write cursor is the ring index (so a frame writes 0, 1, 2, ... and never a slot twice), one fence is recorded after the frame's last draw, and the only wait is at the start of the next frame. A wait that times out, or a slot written with no fence ever recorded behind it, drops the store to the orphan path -- the treatment a refused fence already had -- so nothing is ever written into storage the GPU may still be reading. * New test-only counters (PLOT_RING_STATS, the PLOT_PYRAMID_COUNT_* pattern: free functions, no member, so no consumer's layout changes) pin a frame's upload and wait counts. The new tests assert the frame's slot offsets are distinct, that the ring grew past its floor to cover the frame, and that a frame waits at most once per store -- read from the counters and from glClientWaitSync itself. * qt6: print the unresolved entry-point names before the load-failure branch, which used to return first and leave the one failure this widget can have reporting nothing but a generic message. * qt6: the cached pointer anchor is now in logical pixels and a move's delta is the logical difference scaled by the DPR in effect, so a scale change between two move events (the window dragged onto another monitor mid-drag) is no longer a cross-scale jump applied as a pan. The anchor moved into a toolkit-free unit (adapters/qt6/qt_pointer.hpp) with its own test. GLFW demo headless: 1.07 -> 0.73 ms/frame. Qt widget under xvfb/llvmpipe: 7.1 -> 3.8 ms at dpr 1.0, 6.7 -> 3.6 ms at 1.25, with both upload paths still rendering and the demo's scripted pan/box-zoom checks passing at both scales.
63 lines
2.3 KiB
C++
63 lines
2.3 KiB
C++
#pragma once
|
|
|
|
#ifdef PLOT_RING_STATS
|
|
|
|
#include <atomic>
|
|
|
|
#include <plot/core/types.hpp>
|
|
|
|
namespace plot::render::detail {
|
|
|
|
/// Test-only instrumentation for the persistent-mapped instance ring (see
|
|
/// `InstanceStore`). Every counter exists only when PLOT_RING_STATS is defined
|
|
/// -- the test build defines it, on the library and on the suite -- and none of
|
|
/// them is a data member of any class, so a consumer compiled without the macro
|
|
/// still lays `InstanceStore` out identically. No other build carries a counter
|
|
/// or an increment on the upload, frame or wait path.
|
|
///
|
|
/// The properties they pin are invisible in the pixels a frame draws: a ring that
|
|
/// syncs mid-frame rasterises exactly what one that does not does, and a ring that
|
|
/// recycles a slot within a frame draws correctly until the GPU happens to be
|
|
/// slower than the CPU. So `InstanceStore` counts
|
|
///
|
|
/// * `ring_uploads()` -- one per upload, i.e. a frame's upload count;
|
|
/// * `ring_waits()` -- one per fence wait. At most one per store per frame:
|
|
/// the wait is at the start of the frame, on the previous frame's fence;
|
|
/// * `ring_slots()` -- the largest ring any store has grown to, which must
|
|
/// cover the uploads a frame performs.
|
|
///
|
|
/// They are process-global rather than per-store because a test that drives one
|
|
/// `InstanceStore` reads them directly; a test that drives the whole `Renderer`
|
|
/// reads the aggregate, where there are two stores and so at most two waits a
|
|
/// frame.
|
|
///
|
|
/// Not part of any query surface and not meant for production use.
|
|
inline std::atomic<u64>& ring_uploads() {
|
|
static std::atomic<u64> count{0};
|
|
return count;
|
|
}
|
|
|
|
inline std::atomic<u64>& ring_waits() {
|
|
static std::atomic<u64> count{0};
|
|
return count;
|
|
}
|
|
|
|
inline std::atomic<u64>& ring_slots() {
|
|
static std::atomic<u64> count{0};
|
|
return count;
|
|
}
|
|
|
|
/// Records `slots` as the ring's largest size so far. A compare-exchange loop
|
|
/// rather than a store because two stores report into one counter.
|
|
inline void note_ring_slots(u64 slots) noexcept {
|
|
std::atomic<u64>& count = ring_slots();
|
|
u64 largest = count.load(std::memory_order_relaxed);
|
|
while (largest < slots &&
|
|
!count.compare_exchange_weak(largest, slots, std::memory_order_relaxed)) {
|
|
}
|
|
}
|
|
|
|
} // namespace plot::render::detail
|
|
|
|
#endif // PLOT_RING_STATS
|