477 lines
20 KiB
C++
477 lines
20 KiB
C++
#include "Performance_Overlay_p.h"
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <taskflow/taskflow.hpp>
|
|
#include "../base/Task.h"
|
|
#include "../plot/Plot_Core.h"
|
|
namespace renderive {
|
|
namespace {
|
|
class Performance_Overlay_Service {
|
|
public:
|
|
~Performance_Overlay_Service() {
|
|
shutdown();
|
|
}
|
|
bool try_submit(Task task) {
|
|
if (!task || shutting_down.load(std::memory_order_acquire))
|
|
return false;
|
|
auto topology = std::make_shared<tf::Taskflow>();
|
|
auto task_ptr = std::make_shared<Task>(std::move(task));
|
|
topology->emplace([task_ptr]() {
|
|
(*task_ptr)();
|
|
});
|
|
executor.run(*topology, [topology]() {});
|
|
return true;
|
|
}
|
|
void shutdown() {
|
|
if (shutting_down.exchange(true, std::memory_order_acq_rel))
|
|
return;
|
|
executor.wait_for_all();
|
|
}
|
|
private:
|
|
tf::Executor executor{1};
|
|
std::atomic_bool shutting_down{false};
|
|
};
|
|
Performance_Overlay_Service& performance_background_service() {
|
|
static Performance_Overlay_Service service;
|
|
return service;
|
|
}
|
|
double duration_ms(std::uint64_t begin_ns, std::uint64_t end_ns) {
|
|
return end_ns > begin_ns ? static_cast<double>(end_ns - begin_ns) / 1000000.0 : 0.0;
|
|
}
|
|
double cache_ratio(std::uint64_t hit, std::uint64_t miss) {
|
|
std::uint64_t total = hit + miss;
|
|
return total ? static_cast<double>(hit) / static_cast<double>(total) : 0.0;
|
|
}
|
|
std::string source_text(Refresh_Limit_Source source) {
|
|
switch (source) {
|
|
case Refresh_Limit_Source::Unknown:
|
|
return "unknown";
|
|
case Refresh_Limit_Source::Render:
|
|
return "render";
|
|
case Refresh_Limit_Source::Paint:
|
|
return "paint";
|
|
case Refresh_Limit_Source::User:
|
|
return "user";
|
|
}
|
|
return "unknown";
|
|
}
|
|
std::string outcome_text(Frame_Outcome outcome) {
|
|
switch (outcome) {
|
|
case Frame_Outcome::Presented:
|
|
return "presented";
|
|
case Frame_Outcome::Superseded:
|
|
return "superseded";
|
|
case Frame_Outcome::Render_Acquire_Dropped:
|
|
return "render_acquire_dropped";
|
|
case Frame_Outcome::Publish_Dropped:
|
|
return "publish_dropped";
|
|
case Frame_Outcome::Paint_Acquire_Dropped:
|
|
return "paint_acquire_dropped";
|
|
case Frame_Outcome::Worker_Budget_Dropped:
|
|
return "worker_budget_dropped";
|
|
case Frame_Outcome::Cancelled:
|
|
return "cancelled";
|
|
}
|
|
return "unknown";
|
|
}
|
|
std::string csv_escape(const std::string& value) {
|
|
std::string escaped;
|
|
escaped.reserve(value.size() + 2);
|
|
escaped.push_back('"');
|
|
for (char ch : value) {
|
|
if (ch == '"')
|
|
escaped.push_back('"');
|
|
escaped.push_back(ch);
|
|
}
|
|
escaped.push_back('"');
|
|
return escaped;
|
|
}
|
|
std::string renderable_cache_stats_text(const Frame_Lifecycle_Record& frame) {
|
|
std::ostringstream stream;
|
|
bool first = true;
|
|
for (const auto& stat : frame.renderable_cache_stats) {
|
|
if (!first)
|
|
stream << '|';
|
|
first = false;
|
|
stream << stat.object_name
|
|
<< ":parent=" << stat.parent_object_name
|
|
<< ";depth=" << stat.tree_depth
|
|
<< ";hit=" << stat.hit_count
|
|
<< ";miss=" << stat.miss_count
|
|
<< ";rebuild=" << stat.rebuild_count
|
|
<< ";rebuild_ns=" << stat.rebuild_time_ns
|
|
<< ";compose_ns=" << stat.compose_time_ns
|
|
<< ";subtree_compose_ns=" << renderable_cache_subtree_compose_time(frame.renderable_cache_stats, stat)
|
|
<< ";last_rebuild_ns=" << stat.last_rebuild_time_ns
|
|
<< ";last_compose_ns=" << stat.last_compose_time_ns
|
|
<< ";image_bytes=" << stat.last_image_bytes
|
|
<< ";image_area=" << stat.last_image_area
|
|
<< ";version=" << stat.last_edit_version << '/' << stat.last_ready_version;
|
|
}
|
|
return stream.str();
|
|
}
|
|
std::string renderable_stats_text(const Frame_Lifecycle_Record& frame) {
|
|
std::ostringstream stream;
|
|
bool first = true;
|
|
for (const auto& stat : frame.renderable_stats) {
|
|
if (!first)
|
|
stream << '|';
|
|
first = false;
|
|
stream << stat.object_name
|
|
<< ":parent=" << stat.parent_object_name
|
|
<< ";depth=" << stat.tree_depth
|
|
<< ";cache=" << (stat.cache_enabled ? 1 : 0)
|
|
<< ";render=" << stat.render_count
|
|
<< ";self_draw=" << stat.self_draw_count
|
|
<< ";render_ns=" << stat.total_render_time_ns
|
|
<< ";self_draw_ns=" << stat.self_draw_time_ns
|
|
<< ";last_render_ns=" << stat.last_total_render_time_ns
|
|
<< ";last_self_draw_ns=" << stat.last_self_draw_time_ns;
|
|
}
|
|
return stream.str();
|
|
}
|
|
class Frame_Performance_Logger {
|
|
public:
|
|
bool is_enabled() const {
|
|
return enabled();
|
|
}
|
|
void write(const Frame_Lifecycle_Record& frame) {
|
|
if (!enabled())
|
|
return;
|
|
const Refresh_Control_Snapshot& refresh = frame.refresh;
|
|
std::ostringstream stream;
|
|
stream << std::setprecision(9)
|
|
<< frame.frame_id << ','
|
|
<< frame.input_version << ','
|
|
<< outcome_text(frame.outcome) << ','
|
|
<< source_text(refresh.source) << ','
|
|
<< refresh.render_period_ns << ','
|
|
<< refresh.paint_period_ns << ','
|
|
<< refresh.user_period_ns << ','
|
|
<< refresh.target_period_ns << ','
|
|
<< duration_ms(frame.render_request_ns, frame.render_begin_ns) << ','
|
|
<< duration_ms(frame.prepare_begin_ns, frame.prepare_end_ns) << ','
|
|
<< duration_ms(frame.draw_begin_ns, frame.draw_end_ns) << ','
|
|
<< duration_ms(frame.render_begin_ns, frame.render_end_ns) << ','
|
|
<< duration_ms(frame.transition_12_ns, frame.paint_begin_ns ? frame.paint_begin_ns : frame.superseded_time_ns) << ','
|
|
<< duration_ms(frame.update_request_time_ns, frame.paint_begin_ns) << ','
|
|
<< duration_ms(frame.paint_begin_ns, frame.paint_end_ns) << ','
|
|
<< duration_ms(frame.core_data_time_ns, frame.paint_end_ns) << ','
|
|
<< frame.render_queue_wait_ns << ','
|
|
<< frame.ready_queue_wait_ns << ','
|
|
<< frame.present_queue_wait_ns << ','
|
|
<< frame.paint_return_wait_ns << ','
|
|
<< frame.raw_input_count << ','
|
|
<< frame.prepared_output_count << ','
|
|
<< frame.renderable_cache_hit_count << ','
|
|
<< frame.renderable_cache_miss_count << ','
|
|
<< frame.renderable_cache_rebuild_count << ','
|
|
<< frame.renderable_cache_rebuild_time_ns << ','
|
|
<< frame.renderable_cache_compose_time_ns << ','
|
|
<< frame.renderable_cache_image_bytes << ','
|
|
<< frame.renderable_cache_image_area << ','
|
|
<< cache_ratio(frame.renderable_cache_hit_count, frame.renderable_cache_miss_count) << ','
|
|
<< frame.pixel_width << ','
|
|
<< frame.pixel_height << ','
|
|
<< frame.core_data_time_ns << ','
|
|
<< frame.render_begin_ns << ','
|
|
<< frame.render_end_ns << ','
|
|
<< frame.transition_12_ns << ','
|
|
<< frame.transition_23_ns << ','
|
|
<< frame.paint_begin_ns << ','
|
|
<< frame.paint_end_ns << ','
|
|
<< frame.transition_32_ns << ','
|
|
<< frame.superseded_time_ns << ','
|
|
<< csv_escape(renderable_stats_text(frame)) << ','
|
|
<< csv_escape(renderable_cache_stats_text(frame));
|
|
csv_log(path(), header(), stream.str());
|
|
}
|
|
private:
|
|
static bool enabled() {
|
|
static bool value = []() {
|
|
const char* env = std::getenv("RENDERIVE_PERFORMANCE_LOG");
|
|
return env && std::atoi(env) != 0;
|
|
}();
|
|
return value;
|
|
}
|
|
static std::string path() {
|
|
static std::string value = []() {
|
|
const char* configured = std::getenv("RENDERIVE_PERFORMANCE_LOG_PATH");
|
|
if (!configured || configured[0] == '\0') {
|
|
return (std::filesystem::current_path() / "renderive_performance_log.csv").string();
|
|
}
|
|
return std::string(configured);
|
|
}();
|
|
return value;
|
|
}
|
|
static std::string header() {
|
|
return "frame_id,input_version,outcome,limit_source,render_period_ns,paint_period_ns,user_period_ns,target_period_ns,request_wait_ms,prepare_ms,draw_ms,render_ms,middle_wait_ms,update_wait_ms,paint_ms,frame_age_ms,render_queue_wait_ns,ready_queue_wait_ns,present_queue_wait_ns,paint_return_wait_ns,raw_input_count,prepared_output_count,cache_hit_count,cache_miss_count,cache_rebuild_count,cache_rebuild_time_ns,cache_compose_time_ns,cache_image_bytes,cache_image_area,cache_hit_ratio,pixel_width,pixel_height,core_data_time_ns,render_begin_time_ns,render_end_time_ns,transition_12_ns,transition_23_ns,paint_begin_time_ns,paint_end_time_ns,transition_32_ns,superseded_time_ns,renderable_stats,renderable_cache_stats";
|
|
}
|
|
};
|
|
Frame_Performance_Logger& frame_log() {
|
|
static Frame_Performance_Logger value;
|
|
return value;
|
|
}
|
|
static std::shared_ptr<Performance_Overlay> performance_overlay_owner(const std::shared_ptr<Plot_Render_Context>& ctx) {
|
|
if (!ctx)
|
|
return {};
|
|
auto observer = std::atomic_load_explicit(&ctx->frame_lifecycle_observer, std::memory_order_acquire);
|
|
return std::dynamic_pointer_cast<Performance_Overlay>(observer);
|
|
}
|
|
static std::function<void()> performance_update_callback(const std::shared_ptr<Plot_Render_Context>& ctx) {
|
|
if (!ctx)
|
|
return {};
|
|
std::lock_guard<std::mutex> lock(ctx->performance_update_callback_mutex);
|
|
return ctx->performance_update_callback;
|
|
}
|
|
static void request_performance_update(const std::shared_ptr<Performance_Worker_State>& worker) {
|
|
if (!worker)
|
|
return;
|
|
std::function<void()> callback;
|
|
{
|
|
std::lock_guard<std::mutex> lock(worker->update_callback_mutex);
|
|
callback = worker->update_callback;
|
|
}
|
|
if (callback)
|
|
callback();
|
|
}
|
|
}
|
|
void schedule_performance_metrics_worker(const std::shared_ptr<Performance_Worker_State>& state) {
|
|
if (!state || state->cancelled.load(std::memory_order_acquire))
|
|
return;
|
|
state->work_requested.store(true, std::memory_order_release);
|
|
if (state->worker_active.exchange(true, std::memory_order_acq_rel))
|
|
return;
|
|
if (!performance_background_service().try_submit(Task([state]() {
|
|
Performance_Overlay_Private::run_metrics_worker(state);
|
|
}))) {
|
|
state->worker_active.store(false, std::memory_order_release);
|
|
}
|
|
}
|
|
Performance_Overlay::Performance_Overlay()
|
|
: private_data(std::make_unique<Performance_Overlay_Private>()) {}
|
|
Performance_Overlay::~Performance_Overlay() = default;
|
|
Performance_Overlay_Private* Performance_Overlay::d() {
|
|
return private_data.get();
|
|
}
|
|
static std::shared_ptr<Performance_Overlay> attach_performance_overlay_impl(Plot_Core& plot, const Performance_Overlay_Options* options) {
|
|
auto ctx = plot.render_context();
|
|
if (!ctx)
|
|
return {};
|
|
auto shower = performance_overlay_owner(ctx);
|
|
if (shower) {
|
|
if (options)
|
|
shower->set_options(*options);
|
|
return shower;
|
|
}
|
|
auto created_shower = renderive::make_shared<Performance_Overlay>();
|
|
if (options)
|
|
created_shower->set_options(*options);
|
|
created_shower->set_update_callback(performance_update_callback(ctx));
|
|
std::atomic_store_explicit(&ctx->frame_lifecycle_observer, std::static_pointer_cast<Frame_Lifecycle_Observer>(created_shower), std::memory_order_release);
|
|
return created_shower;
|
|
}
|
|
std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Core& plot) {
|
|
return attach_performance_overlay_impl(plot, nullptr);
|
|
}
|
|
std::shared_ptr<Performance_Overlay> attach_performance_overlay(Plot_Core& plot, const Performance_Overlay_Options& options) {
|
|
return attach_performance_overlay_impl(plot, &options);
|
|
}
|
|
std::shared_ptr<Performance_Overlay> performance_overlay(Plot_Core& plot) {
|
|
return performance_overlay_owner(plot.render_context());
|
|
}
|
|
void detach_performance_overlay(Plot_Core& plot) {
|
|
auto ctx = plot.render_context();
|
|
if (!ctx)
|
|
return;
|
|
auto shower = performance_overlay_owner(ctx);
|
|
std::atomic_store_explicit(&ctx->frame_lifecycle_observer, std::shared_ptr<Frame_Lifecycle_Observer>{}, std::memory_order_release);
|
|
if (shower)
|
|
shower->set_enabled(false);
|
|
}
|
|
bool performance_overlay_enabled(const Plot_Core& plot) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
return shower && shower->enabled();
|
|
}
|
|
void set_performance_overlay_enabled(Plot_Core& plot, bool enabled) {
|
|
if (!enabled) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
if (shower)
|
|
shower->set_enabled(false);
|
|
return;
|
|
}
|
|
auto shower = attach_performance_overlay(plot);
|
|
if (shower) {
|
|
shower->set_enabled(true);
|
|
shower->set_viewport(plot.viewport_size(), plot.render_context() ? plot.render_context()->viewport_version.load(std::memory_order_acquire) : 0);
|
|
}
|
|
}
|
|
std::shared_ptr<const Performance_Display_Snapshot> performance_overlay_snapshot(const Plot_Core& plot) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
if (!shower || !shower->enabled())
|
|
return {};
|
|
return shower->display_snapshot();
|
|
}
|
|
void set_performance_overlay_update_callback(Plot_Core& plot, std::function<void()> callback) {
|
|
auto ctx = plot.render_context();
|
|
if (!ctx)
|
|
return;
|
|
{
|
|
std::lock_guard<std::mutex> lock(ctx->performance_update_callback_mutex);
|
|
ctx->performance_update_callback = std::move(callback);
|
|
}
|
|
auto shower = performance_overlay_owner(ctx);
|
|
if (shower)
|
|
shower->set_update_callback(performance_update_callback(ctx));
|
|
}
|
|
void notify_performance_overlay_viewport_changed(Plot_Core& plot) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
if (!shower || !shower->enabled())
|
|
return;
|
|
auto ctx = plot.render_context();
|
|
shower->set_viewport(plot.viewport_size(), ctx ? ctx->viewport_version.load(std::memory_order_acquire) : 0);
|
|
}
|
|
bool performance_overlay_handle_wheel(Plot_Core& plot, PointF position, double angle_delta_y, double pixel_delta_y) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
return shower && shower->enabled() && shower->handle_wheel(position, angle_delta_y, pixel_delta_y);
|
|
}
|
|
bool performance_overlay_handle_pointer_press(Plot_Core& plot, PointF position) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
return shower && shower->enabled() && shower->handle_pointer_press(position);
|
|
}
|
|
bool performance_overlay_handle_pointer_move(Plot_Core& plot, PointF position) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
return shower && shower->enabled() && shower->handle_pointer_move(position);
|
|
}
|
|
bool performance_overlay_handle_pointer_release(Plot_Core& plot, PointF position) {
|
|
auto shower = performance_overlay_owner(plot.render_context());
|
|
return shower && shower->enabled() && shower->handle_pointer_release(position);
|
|
}
|
|
void Performance_Overlay::set_enabled(bool enabled) {
|
|
auto worker = d()->metrics_worker;
|
|
d()->enabled_value.store(enabled, std::memory_order_release);
|
|
worker->enabled.store(enabled, std::memory_order_release);
|
|
if (!enabled) {
|
|
worker->published_snapshot.store({}, std::memory_order_release);
|
|
request_performance_update(worker);
|
|
return;
|
|
}
|
|
worker->reset_requested.store(true, std::memory_order_release);
|
|
worker->snapshot_rebuild_requested.store(true, std::memory_order_release);
|
|
schedule_performance_metrics_worker(worker);
|
|
}
|
|
bool Performance_Overlay::enabled() const {
|
|
return const_cast<Performance_Overlay*>(this)->d()->enabled_value.load(std::memory_order_acquire);
|
|
}
|
|
std::shared_ptr<const Performance_Display_Snapshot> Performance_Overlay::display_snapshot() const {
|
|
return const_cast<Performance_Overlay*>(this)->d()->metrics_worker->published_snapshot.load(std::memory_order_acquire);
|
|
}
|
|
void Performance_Overlay::set_options(Performance_Overlay_Options options) {
|
|
auto worker = d()->metrics_worker;
|
|
{
|
|
std::lock_guard<std::mutex> lock(worker->options_mutex);
|
|
worker->options = std::move(options);
|
|
}
|
|
worker->snapshot_rebuild_requested.store(true, std::memory_order_release);
|
|
if (enabled())
|
|
schedule_performance_metrics_worker(worker);
|
|
}
|
|
Performance_Overlay_Options Performance_Overlay::options() const {
|
|
auto worker = const_cast<Performance_Overlay*>(this)->d()->metrics_worker;
|
|
std::lock_guard<std::mutex> lock(worker->options_mutex);
|
|
return worker->options;
|
|
}
|
|
void Performance_Overlay::set_font(Font font) {
|
|
Performance_Overlay_Options value = options();
|
|
value.font = std::move(font);
|
|
set_options(std::move(value));
|
|
}
|
|
void Performance_Overlay::set_foreground(Color color) {
|
|
Performance_Overlay_Options value = options();
|
|
value.foreground = color;
|
|
set_options(std::move(value));
|
|
}
|
|
void Performance_Overlay::set_background(Color color) {
|
|
Performance_Overlay_Options value = options();
|
|
value.background = color;
|
|
set_options(std::move(value));
|
|
}
|
|
void Performance_Overlay::collect_frame(std::shared_ptr<const Frame_Lifecycle_Record> frame) {
|
|
if (!enabled())
|
|
return;
|
|
d()->enqueue_frame_metric(frame);
|
|
write_frame_performance_log(frame);
|
|
}
|
|
void Performance_Overlay::set_viewport(Size viewport, std::uint64_t version) {
|
|
d()->metrics_worker->viewport_width.store(viewport.width, std::memory_order_release);
|
|
d()->metrics_worker->viewport_height.store(viewport.height, std::memory_order_release);
|
|
d()->metrics_worker->viewport_version.store(version, std::memory_order_release);
|
|
d()->metrics_worker->snapshot_rebuild_requested.store(true, std::memory_order_release);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
}
|
|
bool Performance_Overlay::handle_wheel(PointF position, double angle_delta_y, double pixel_delta_y) {
|
|
auto snapshot = display_snapshot();
|
|
if (!snapshot || !snapshot->destination_rect.contains(position))
|
|
return false;
|
|
double line_height = snapshot->line_height > 0.0 ? snapshot->line_height : d()->metrics_worker->last_line_height;
|
|
double delta = 0.0;
|
|
if (pixel_delta_y != 0.0)
|
|
delta = -pixel_delta_y;
|
|
else if (angle_delta_y != 0.0)
|
|
delta = -(angle_delta_y / 120.0) * 3.0 * std::max(1.0, line_height);
|
|
if (delta != 0.0) {
|
|
performance_atomic_add(d()->metrics_worker->pending_wheel_delta_px, delta);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
}
|
|
return true;
|
|
}
|
|
bool Performance_Overlay::handle_pointer_press(PointF position) {
|
|
auto snapshot = display_snapshot();
|
|
if (!snapshot || snapshot->max_scroll_offset <= 0.0)
|
|
return false;
|
|
if (snapshot->scroll_thumb_rect.contains(position)) {
|
|
d()->metrics_worker->drag_anchor_y.store(position.y - snapshot->scroll_thumb_rect.y, std::memory_order_release);
|
|
d()->metrics_worker->drag_position_y.store(position.y, std::memory_order_release);
|
|
d()->metrics_worker->drag_end_requested.store(false, std::memory_order_release);
|
|
d()->metrics_worker->drag_active.store(true, std::memory_order_release);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
return true;
|
|
}
|
|
if (snapshot->scroll_track_rect.contains(position)) {
|
|
int page = position.y < snapshot->scroll_thumb_rect.y ? -1 : 1;
|
|
d()->metrics_worker->pending_page_delta.fetch_add(page, std::memory_order_acq_rel);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool Performance_Overlay::handle_pointer_move(PointF position) {
|
|
if (!d()->metrics_worker->drag_active.load(std::memory_order_acquire))
|
|
return false;
|
|
d()->metrics_worker->drag_position_y.store(position.y, std::memory_order_release);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
return true;
|
|
}
|
|
bool Performance_Overlay::handle_pointer_release(PointF position) {
|
|
if (!d()->metrics_worker->drag_active.load(std::memory_order_acquire))
|
|
return false;
|
|
d()->metrics_worker->drag_position_y.store(position.y, std::memory_order_release);
|
|
d()->metrics_worker->drag_end_requested.store(true, std::memory_order_release);
|
|
schedule_performance_metrics_worker(d()->metrics_worker);
|
|
return true;
|
|
}
|
|
void Performance_Overlay::set_update_callback(std::function<void()> callback) {
|
|
std::lock_guard<std::mutex> lock(d()->metrics_worker->update_callback_mutex);
|
|
d()->metrics_worker->update_callback = std::move(callback);
|
|
}
|
|
void write_frame_performance_log(std::shared_ptr<const Frame_Lifecycle_Record> frame) {
|
|
if (!frame || !frame_log().is_enabled())
|
|
return;
|
|
performance_background_service().try_submit(Task([frame = std::move(frame)]() {
|
|
frame_log().write(*frame);
|
|
}));
|
|
}
|
|
} // namespace renderive
|