mirror of
https://github.com/KytyPS5/KytyPS5.git
synced 2026-10-20 19:07:01 +02:00
feat: add an in-game performance panel (#1090)
Add in-game performance panel Co-authored-by: nmzik <Nmzik@mail.ru>
This commit is contained in:
Juan Pablo Farias
committed by
GitHub
GitHub
parent
415387f00d
commit
6aa3846fb2
@@ -0,0 +1,747 @@
|
||||
#include "graphics/presentation/performanceOverlay.h"
|
||||
|
||||
#include "common/debugCounters.h"
|
||||
#include "common/emulatorConfig.h"
|
||||
#include "common/hostStats.h"
|
||||
#include "graphics/host_gpu/graphicContext.h"
|
||||
#include "imgui.h"
|
||||
#include "kernel/memory.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <condition_variable>
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#include <mutex>
|
||||
#include <optional>
|
||||
#include <stop_token>
|
||||
#include <thread>
|
||||
|
||||
namespace Libs::Graphics {
|
||||
|
||||
namespace {
|
||||
|
||||
using Clock = std::chrono::steady_clock;
|
||||
using Counter = Common::DebugCounters::Counter;
|
||||
using Peak = Common::DebugCounters::Peak;
|
||||
|
||||
constexpr auto REFRESH_INTERVAL = std::chrono::seconds(1);
|
||||
constexpr size_t FRAME_HISTORY = 120;
|
||||
constexpr float FRAME_GRAPH_MS = 50.0f;
|
||||
constexpr float FRAME_TIME_GOOD = 17.5f;
|
||||
constexpr float FRAME_TIME_MEDIUM = 34.0f;
|
||||
constexpr size_t COUNTER_COUNT = static_cast<size_t>(Counter::Count);
|
||||
|
||||
// Tables as wide as their columns; the default fills the window, which an auto-resizing
|
||||
// window then never shrinks.
|
||||
constexpr ImGuiTableFlags TABLE_FLAGS =
|
||||
ImGuiTableFlags_SizingFixedFit | ImGuiTableFlags_NoHostExtendX;
|
||||
|
||||
constexpr ImU32 GOOD = IM_COL32(96, 220, 120, 255);
|
||||
constexpr ImU32 MEDIUM = IM_COL32(230, 195, 60, 255);
|
||||
constexpr ImU32 BAD = IM_COL32(235, 80, 70, 255);
|
||||
constexpr ImU32 NEUTRAL = IM_COL32(160, 160, 160, 255);
|
||||
|
||||
struct FrameWindow {
|
||||
std::array<float, FRAME_HISTORY> intervals_ms {};
|
||||
size_t next = 0;
|
||||
size_t count = 0;
|
||||
uint32_t flips = 0;
|
||||
float max_ms = 0.0f;
|
||||
uint32_t guest_width = 0;
|
||||
uint32_t guest_height = 0;
|
||||
Clock::time_point last_flip = {};
|
||||
Clock::time_point window_start = {};
|
||||
};
|
||||
|
||||
// Shown values, recomputed once per refresh interval.
|
||||
struct Snapshot {
|
||||
double fps = 0.0;
|
||||
double frame_ms = 0.0;
|
||||
double max_frame_ms = 0.0;
|
||||
double low_fps = 0.0; // From the 99th percentile.
|
||||
double stalled_s = 0.0;
|
||||
uint32_t guest_width = 0;
|
||||
uint32_t guest_height = 0;
|
||||
std::array<double, COUNTER_COUNT> rates {};
|
||||
std::array<uint64_t, COUNTER_COUNT> totals {};
|
||||
uint64_t shader_compile_peak_ns = 0;
|
||||
uint64_t pipeline_create_peak_ns = 0;
|
||||
Common::HostStats host;
|
||||
std::optional<uint64_t> device_memory;
|
||||
uint64_t device_budget = 0;
|
||||
std::array<GraphicContext::HeapUsage, VK_MAX_MEMORY_HEAPS> heaps {};
|
||||
uint32_t heap_count = 0;
|
||||
std::array<float, FRAME_HISTORY> history {};
|
||||
size_t history_count = 0;
|
||||
Clock::time_point sample_time {};
|
||||
LibKernel::Memory::DebugStats guest_memory;
|
||||
};
|
||||
|
||||
std::mutex g_frame_mutex;
|
||||
FrameWindow g_frames;
|
||||
std::atomic<uint64_t> g_generation {0};
|
||||
std::atomic<bool> g_details {false};
|
||||
std::atomic<uint64_t> g_revision {0};
|
||||
|
||||
std::mutex g_host_mutex;
|
||||
Common::HostStats g_host_stats;
|
||||
uint64_t g_host_generation = 0;
|
||||
std::condition_variable_any g_sampler_wait;
|
||||
std::jthread g_sampler;
|
||||
|
||||
void SetOverlayEnabled(bool enabled) {
|
||||
{
|
||||
std::scoped_lock lock(g_host_mutex);
|
||||
if (enabled) {
|
||||
std::scoped_lock frame_lock(g_frame_mutex);
|
||||
g_frames = {};
|
||||
g_generation.fetch_add(1, std::memory_order_release);
|
||||
}
|
||||
Common::DebugCounters::SetEnabled(enabled);
|
||||
}
|
||||
g_sampler_wait.notify_all();
|
||||
}
|
||||
|
||||
bool GuestStalled(Clock::time_point now) {
|
||||
std::scoped_lock lock(g_frame_mutex);
|
||||
return now - g_frames.last_flip >= REFRESH_INTERVAL;
|
||||
}
|
||||
|
||||
// Host statistics can block for milliseconds (IOKit, thread enumeration), so sample them off
|
||||
// the present path. While the guest stops flipping (loading screens), ask for one repaint per
|
||||
// interval.
|
||||
void SamplerThread(const std::stop_token& stop) {
|
||||
std::optional<Common::HostStatsSampler> sampler;
|
||||
uint64_t sampled_generation = 0;
|
||||
std::unique_lock lock(g_host_mutex);
|
||||
while (!stop.stop_requested()) {
|
||||
g_sampler_wait.wait(lock, stop, [] { return Common::DebugCounters::Enabled(); });
|
||||
if (stop.stop_requested()) {
|
||||
break;
|
||||
}
|
||||
const auto generation = g_generation.load(std::memory_order_acquire);
|
||||
lock.unlock();
|
||||
if (!sampler || generation != sampled_generation) {
|
||||
sampler.emplace();
|
||||
sampled_generation = generation;
|
||||
}
|
||||
auto stats = sampler->Sample();
|
||||
lock.lock();
|
||||
g_host_stats = std::move(stats);
|
||||
g_host_generation = generation;
|
||||
if (Common::DebugCounters::Enabled() && GuestStalled(Clock::now())) {
|
||||
g_revision.fetch_add(1, std::memory_order_acq_rel);
|
||||
}
|
||||
g_sampler_wait.wait_for(lock, stop, REFRESH_INTERVAL, [generation] {
|
||||
return !Common::DebugCounters::Enabled() ||
|
||||
generation != g_generation.load(std::memory_order_acquire);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void EnsureSampler() {
|
||||
static std::once_flag once;
|
||||
std::call_once(once, [] { g_sampler = std::jthread(SamplerThread); });
|
||||
}
|
||||
|
||||
ImU32 FrameTimeColor(double ms) {
|
||||
return ms <= FRAME_TIME_GOOD ? GOOD : ms <= FRAME_TIME_MEDIUM ? MEDIUM : BAD;
|
||||
}
|
||||
|
||||
// Green below `warn`, yellow below `bad`, red above.
|
||||
ImU32 LevelColor(double value, double warn, double bad) {
|
||||
return value < warn ? GOOD : value < bad ? MEDIUM : BAD;
|
||||
}
|
||||
|
||||
ImVec4 Color(ImU32 color) {
|
||||
return ImGui::ColorConvertU32ToFloat4(color);
|
||||
}
|
||||
|
||||
std::string Bytes(uint64_t bytes) {
|
||||
constexpr double GIB = 1024.0 * 1024.0 * 1024.0;
|
||||
constexpr double MIB = 1024.0 * 1024.0;
|
||||
char buffer[32];
|
||||
if (static_cast<double>(bytes) >= GIB) {
|
||||
std::snprintf(buffer, sizeof(buffer), "%.2f GB", static_cast<double>(bytes) / GIB);
|
||||
} else {
|
||||
std::snprintf(buffer, sizeof(buffer), "%.0f MB", static_cast<double>(bytes) / MIB);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
std::string Bytes(std::optional<uint64_t> bytes) {
|
||||
return bytes ? Bytes(*bytes) : "n/a";
|
||||
}
|
||||
|
||||
std::string Throughput(double bytes_per_second) {
|
||||
char buffer[32];
|
||||
std::snprintf(buffer, sizeof(buffer), "%.1f MB/s", bytes_per_second / (1024.0 * 1024.0));
|
||||
return buffer;
|
||||
}
|
||||
|
||||
std::string Percent(std::optional<double> value) {
|
||||
if (!value) {
|
||||
return "n/a";
|
||||
}
|
||||
char buffer[16];
|
||||
std::snprintf(buffer, sizeof(buffer), "%.0f%%", *value);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void Row(const char* label, const std::string& value, std::optional<ImU32> color = std::nullopt) {
|
||||
ImGui::TableNextRow();
|
||||
ImGui::TableNextColumn();
|
||||
ImGui::TextDisabled("%s", label);
|
||||
ImGui::TableNextColumn();
|
||||
if (color) {
|
||||
ImGui::TextColored(Color(*color), "%s", value.c_str());
|
||||
} else {
|
||||
ImGui::TextUnformatted(value.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
[[gnu::format(printf, 1, 2)]] std::string Fmt(const char* format, ...) {
|
||||
char buffer[128];
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
std::vsnprintf(buffer, sizeof(buffer), format, args);
|
||||
va_end(args);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
bool BeginSection(const char* title) {
|
||||
ImGui::SeparatorText(title);
|
||||
return ImGui::BeginTable(title, 2, TABLE_FLAGS);
|
||||
}
|
||||
|
||||
void DrawFrameGraph(const std::array<float, FRAME_HISTORY>& history, size_t count, float width,
|
||||
float height) {
|
||||
const ImVec2 origin = ImGui::GetCursorScreenPos();
|
||||
auto* draw = ImGui::GetWindowDrawList();
|
||||
draw->AddRectFilled(origin, {origin.x + width, origin.y + height}, IM_COL32(0, 0, 0, 90));
|
||||
const auto y_of = [&](float ms) {
|
||||
return origin.y + height - std::min(ms, FRAME_GRAPH_MS) / FRAME_GRAPH_MS * height;
|
||||
};
|
||||
for (const float reference: {1000.0f / 60.0f, 1000.0f / 30.0f}) {
|
||||
draw->AddLine({origin.x, y_of(reference)}, {origin.x + width, y_of(reference)},
|
||||
IM_COL32(255, 255, 255, 45));
|
||||
}
|
||||
const float bar = width / static_cast<float>(FRAME_HISTORY);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
const float ms = history[i];
|
||||
const float x = origin.x + width - static_cast<float>(count - i) * bar;
|
||||
draw->AddRectFilled({x, y_of(ms)}, {x + std::max(bar - 1.0f, 1.0f), origin.y + height},
|
||||
FrameTimeColor(ms));
|
||||
}
|
||||
ImGui::Dummy({width, height});
|
||||
}
|
||||
|
||||
const char* PressureName(Common::MemoryPressure pressure) {
|
||||
switch (pressure) {
|
||||
case Common::MemoryPressure::Normal: return "Normal";
|
||||
case Common::MemoryPressure::Warning: return "Warning";
|
||||
case Common::MemoryPressure::Critical: return "Critical";
|
||||
case Common::MemoryPressure::Unknown: break;
|
||||
}
|
||||
return "n/a";
|
||||
}
|
||||
|
||||
ImU32 PressureColor(Common::MemoryPressure pressure) {
|
||||
switch (pressure) {
|
||||
case Common::MemoryPressure::Normal: return GOOD;
|
||||
case Common::MemoryPressure::Warning: return MEDIUM;
|
||||
case Common::MemoryPressure::Critical: return BAD;
|
||||
case Common::MemoryPressure::Unknown: break;
|
||||
}
|
||||
return NEUTRAL;
|
||||
}
|
||||
|
||||
const char* ThermalName(Common::ThermalPressure thermal) {
|
||||
switch (thermal) {
|
||||
case Common::ThermalPressure::Nominal: return "Nominal";
|
||||
case Common::ThermalPressure::Moderate: return "Moderate";
|
||||
case Common::ThermalPressure::Heavy: return "Heavy (throttling)";
|
||||
case Common::ThermalPressure::Critical: return "Critical (throttling)";
|
||||
case Common::ThermalPressure::Unknown: break;
|
||||
}
|
||||
return "n/a";
|
||||
}
|
||||
|
||||
ImU32 ThermalColor(Common::ThermalPressure thermal) {
|
||||
switch (thermal) {
|
||||
case Common::ThermalPressure::Nominal: return GOOD;
|
||||
case Common::ThermalPressure::Moderate: return MEDIUM;
|
||||
case Common::ThermalPressure::Heavy:
|
||||
case Common::ThermalPressure::Critical: return BAD;
|
||||
case Common::ThermalPressure::Unknown: break;
|
||||
}
|
||||
return NEUTRAL;
|
||||
}
|
||||
|
||||
const char* PresentModeName(Config::PresentMode mode) {
|
||||
switch (mode) {
|
||||
case Config::PresentMode::Fifo: return "FIFO";
|
||||
case Config::PresentMode::Mailbox: return "Mailbox";
|
||||
case Config::PresentMode::Immediate: return "Immediate";
|
||||
}
|
||||
return "?";
|
||||
}
|
||||
|
||||
double Rate(const Snapshot& shown, Counter counter) {
|
||||
return shown.rates[static_cast<size_t>(counter)];
|
||||
}
|
||||
|
||||
uint64_t Total(const Snapshot& shown, Counter counter) {
|
||||
return shown.totals[static_cast<size_t>(counter)];
|
||||
}
|
||||
|
||||
void TransferRow(const Snapshot& shown, const char* label, Counter upload, Counter download) {
|
||||
Row(label,
|
||||
Throughput(Rate(shown, upload)) + " up / " + Throughput(Rate(shown, download)) + " down");
|
||||
}
|
||||
|
||||
void GpuActivityRows(const Snapshot& shown) {
|
||||
const auto draws = Rate(shown, Counter::Draws);
|
||||
Row("Draw calls", Fmt("%.0f/frame %.0f/s", draws / std::max(shown.fps, 1.0), draws));
|
||||
// Includes present pacing waits, so a high value alone is not a stall.
|
||||
Row("CPU waiting on GPU",
|
||||
Fmt("%.0f ms/s (%.0f waits/s)", Rate(shown, Counter::GpuWaitNs) / 1e6,
|
||||
Rate(shown, Counter::GpuWaits)));
|
||||
}
|
||||
|
||||
void CompilationRows(const Snapshot& shown) {
|
||||
const auto row = [&](const char* label, Counter count_counter, Counter duration_counter,
|
||||
uint64_t peak_ns) {
|
||||
const auto count = Total(shown, count_counter);
|
||||
Row(label,
|
||||
Fmt("%llu (avg %.1f ms, peak %.1f ms)", static_cast<unsigned long long>(count),
|
||||
count != 0 ? static_cast<double>(Total(shown, duration_counter)) / 1e6 /
|
||||
static_cast<double>(count)
|
||||
: 0.0,
|
||||
static_cast<double>(peak_ns) / 1e6),
|
||||
Rate(shown, count_counter) > 0.0 ? MEDIUM : GOOD);
|
||||
};
|
||||
row("Shader recompiler", Counter::ShadersCompiled, Counter::ShaderCompileNs,
|
||||
shown.shader_compile_peak_ns);
|
||||
row("Pipeline compile", Counter::PipelinesCreated, Counter::PipelineCreateNs,
|
||||
shown.pipeline_create_peak_ns);
|
||||
}
|
||||
|
||||
void Refresh(Snapshot& shown, const GraphicContext& graphics, Clock::time_point now,
|
||||
uint64_t generation) {
|
||||
const double seconds = shown.sample_time == Clock::time_point {}
|
||||
? 0.0
|
||||
: std::chrono::duration<double>(now - shown.sample_time).count();
|
||||
for (size_t i = 0; i < COUNTER_COUNT; i++) {
|
||||
const auto value = Common::DebugCounters::Get(static_cast<Counter>(i));
|
||||
shown.rates[i] =
|
||||
seconds > 0.0 ? static_cast<double>(value - shown.totals[i]) / seconds : 0.0;
|
||||
shown.totals[i] = value;
|
||||
}
|
||||
shown.shader_compile_peak_ns = Common::DebugCounters::Get(Peak::ShaderCompileNs);
|
||||
shown.pipeline_create_peak_ns = Common::DebugCounters::Get(Peak::PipelineCreateNs);
|
||||
shown.sample_time = now;
|
||||
{
|
||||
std::scoped_lock lock(g_host_mutex);
|
||||
if (g_host_generation == generation) {
|
||||
shown.host = g_host_stats;
|
||||
}
|
||||
}
|
||||
shown.heap_count = graphics.GetHeapUsage(shown.heaps);
|
||||
shown.device_memory =
|
||||
graphics.CanReportMemoryUsage() ? std::optional<uint64_t>(0) : std::nullopt;
|
||||
shown.device_budget = 0;
|
||||
const bool discrete =
|
||||
graphics.GetPhysicalDeviceProperties().deviceType == vk::PhysicalDeviceType::eDiscreteGpu;
|
||||
for (uint32_t i = 0; i < shown.heap_count; i++) {
|
||||
const auto& heap = shown.heaps[i];
|
||||
if (shown.device_memory && (!discrete || heap.device_local)) {
|
||||
*shown.device_memory += heap.usage;
|
||||
shown.device_budget += heap.budget;
|
||||
}
|
||||
}
|
||||
if (g_details.load(std::memory_order_acquire)) {
|
||||
shown.guest_memory = LibKernel::Memory::GetDebugStats();
|
||||
}
|
||||
}
|
||||
|
||||
void DrawCompact(const Snapshot& shown) {
|
||||
if (!ImGui::BeginTable("##performance", 2, TABLE_FLAGS)) {
|
||||
return;
|
||||
}
|
||||
const auto& host = shown.host;
|
||||
if (shown.max_frame_ms > 0.0) {
|
||||
Row("Worst frame", Fmt("%.1f ms", shown.max_frame_ms), FrameTimeColor(shown.max_frame_ms));
|
||||
}
|
||||
Row("CPU", host.process_cpu_percent
|
||||
? Fmt("%.0f%% of %u threads", *host.process_cpu_percent, host.logical_cores)
|
||||
: std::string("n/a"));
|
||||
Row("GPU", Percent(host.gpu_percent));
|
||||
GpuActivityRows(shown);
|
||||
CompilationRows(shown);
|
||||
if (shown.device_memory) {
|
||||
Row("GPU memory", Bytes(*shown.device_memory) + " / " + Bytes(shown.device_budget));
|
||||
}
|
||||
TransferRow(shown, "Texture transfers", Counter::TextureUploadBytes,
|
||||
Counter::TextureDownloadBytes);
|
||||
TransferRow(shown, "Buffer transfers", Counter::BufferUploadBytes,
|
||||
Counter::BufferDownloadBytes);
|
||||
Row("Emulator RAM", Bytes(host.process_memory));
|
||||
if (host.system_memory_used && host.system_memory_total) {
|
||||
Row("System RAM",
|
||||
Bytes(*host.system_memory_used) + " / " + Bytes(*host.system_memory_total));
|
||||
}
|
||||
ImGui::EndTable();
|
||||
}
|
||||
|
||||
void DrawFramesAndCpu(const Snapshot& shown, vk::Extent2D extent) {
|
||||
const auto& host = shown.host;
|
||||
if (BeginSection("Frames")) {
|
||||
if (shown.low_fps > 0.0) {
|
||||
Row("1% low", Fmt("%.1f FPS", shown.low_fps), FrameTimeColor(1000.0 / shown.low_fps));
|
||||
}
|
||||
Row("Worst frame", Fmt("%.1f ms", shown.max_frame_ms), FrameTimeColor(shown.max_frame_ms));
|
||||
Row("Guest output", shown.guest_width != 0
|
||||
? Fmt("%ux%u", shown.guest_width, shown.guest_height)
|
||||
: std::string("n/a"));
|
||||
Row("Window", Fmt("%ux%u %s %u Hz", extent.width, extent.height,
|
||||
PresentModeName(Config::GetPresentMode()), Config::GetVblankFrequency()));
|
||||
Row("Flips", Fmt("%.0f/s requested", Rate(shown, Counter::FlipsRequested)));
|
||||
const auto rejected = Rate(shown, Counter::FlipsRejected);
|
||||
Row("Flip queue full", Fmt("%.0f/s", rejected), rejected > 0.0 ? BAD : GOOD);
|
||||
const auto late = Rate(shown, Counter::LateVblanks);
|
||||
Row("Late vblanks", Fmt("%.0f/s", late), LevelColor(late, 1.0, 10.0));
|
||||
Row("Swapchain rebuilds",
|
||||
Fmt("%llu (dropped %llu)",
|
||||
static_cast<unsigned long long>(Total(shown, Counter::SwapchainRecreations)),
|
||||
static_cast<unsigned long long>(Total(shown, Counter::DroppedPresents))));
|
||||
ImGui::EndTable();
|
||||
}
|
||||
if (BeginSection("CPU")) {
|
||||
Row("Emulator",
|
||||
host.process_cpu_percent
|
||||
? Fmt("%.0f%% of %u threads (%.1f cores)", *host.process_cpu_percent,
|
||||
host.logical_cores, *host.process_cpu_percent * host.logical_cores / 100.0)
|
||||
: std::string("n/a"));
|
||||
Row("Machine", Percent(host.system_cpu_percent),
|
||||
host.system_cpu_percent ? std::optional(LevelColor(*host.system_cpu_percent, 70, 90))
|
||||
: std::nullopt);
|
||||
if (host.thread_count) {
|
||||
Row("Host threads", Fmt("%u", *host.thread_count));
|
||||
}
|
||||
for (const auto& thread: host.busiest_threads) {
|
||||
Row(Fmt(" %.24s", thread.name.c_str()).c_str(), Fmt("%.0f%%", thread.cpu_percent),
|
||||
LevelColor(thread.cpu_percent, 70, 95));
|
||||
}
|
||||
if (host.context_switches_per_s) {
|
||||
Row("Context switches", Fmt("%.0f/s", *host.context_switches_per_s));
|
||||
}
|
||||
if (host.page_faults_per_s) {
|
||||
Row("Page faults", Fmt("%.0f/s (%.0f from disk)", *host.page_faults_per_s,
|
||||
host.page_ins_per_s.value_or(0.0)));
|
||||
}
|
||||
Row("Thermal", ThermalName(host.thermal_pressure), ThermalColor(host.thermal_pressure));
|
||||
const auto emulated = Rate(shown, Counter::EmulatedInstructions);
|
||||
Row("Emulated instrs", Fmt("%.0f/s", emulated), LevelColor(emulated, 1000, 100000));
|
||||
const auto unresolved = Rate(shown, Counter::UnresolvedImportCalls);
|
||||
Row("Missing HLE calls",
|
||||
Fmt("%.0f/s (%llu total)", unresolved,
|
||||
static_cast<unsigned long long>(Total(shown, Counter::UnresolvedImportCalls))),
|
||||
unresolved > 0.0 ? MEDIUM : GOOD);
|
||||
ImGui::EndTable();
|
||||
}
|
||||
}
|
||||
|
||||
void DrawGpu(const Snapshot& shown, const GraphicContext& graphics) {
|
||||
const auto& host = shown.host;
|
||||
if (BeginSection("GPU")) {
|
||||
Row("Device", host.gpu_model.empty()
|
||||
? std::string(graphics.GetPhysicalDeviceProperties().deviceName.data())
|
||||
: host.gpu_cores
|
||||
? Fmt("%s (%u cores)", host.gpu_model.c_str(), *host.gpu_cores)
|
||||
: host.gpu_model);
|
||||
Row("Utilization", Percent(host.gpu_percent),
|
||||
host.gpu_percent ? std::optional(LevelColor(*host.gpu_percent, 80, 95)) : std::nullopt);
|
||||
if (host.gpu_renderer_percent || host.gpu_tiler_percent) {
|
||||
Row("Renderer / tiler",
|
||||
Percent(host.gpu_renderer_percent) + " / " + Percent(host.gpu_tiler_percent));
|
||||
}
|
||||
if (host.gpu_memory_in_use) {
|
||||
Row("Driver memory", Bytes(*host.gpu_memory_in_use) + " in use / " +
|
||||
Bytes(host.gpu_memory_allocated) + " allocated");
|
||||
}
|
||||
if (host.gpu_recoveries) {
|
||||
Row("GPU resets", Fmt("%llu", static_cast<unsigned long long>(*host.gpu_recoveries)),
|
||||
*host.gpu_recoveries > 0 ? BAD : GOOD);
|
||||
}
|
||||
const double fps = std::max(shown.fps, 1.0);
|
||||
GpuActivityRows(shown);
|
||||
Row("Instances", Fmt("%.0f/frame", Rate(shown, Counter::DrawInstances) / fps));
|
||||
Row("Indirect draws", Fmt("%.0f/s", Rate(shown, Counter::IndirectDraws)));
|
||||
Row("Dispatches", Fmt("%.0f/frame %.0f/s", Rate(shown, Counter::Dispatches) / fps,
|
||||
Rate(shown, Counter::Dispatches)));
|
||||
Row("Queue submits", Fmt("%.0f/s", Rate(shown, Counter::QueueSubmits)));
|
||||
const auto faults = Rate(shown, Counter::GpuFaults);
|
||||
Row("Write-tracking faults", Fmt("%.0f/s", faults), LevelColor(faults, 20000, 100000));
|
||||
CompilationRows(shown);
|
||||
ImGui::EndTable();
|
||||
}
|
||||
if (BeginSection("GPU memory")) {
|
||||
if (shown.device_memory) {
|
||||
const double share = shown.device_budget != 0
|
||||
? static_cast<double>(*shown.device_memory) /
|
||||
static_cast<double>(shown.device_budget) * 100.0
|
||||
: 0.0;
|
||||
Row("Vulkan budget", Bytes(*shown.device_memory) + " / " + Bytes(shown.device_budget),
|
||||
LevelColor(share, 80, 95));
|
||||
}
|
||||
for (size_t heap = 0; heap < shown.heap_count; heap++) {
|
||||
const auto& usage = shown.heaps[heap];
|
||||
Row(Fmt(" Heap %zu%s", heap, usage.device_local ? " (device)" : "").c_str(),
|
||||
Bytes(usage.usage) + " / " + Bytes(usage.budget) +
|
||||
Fmt(" %u allocs", usage.allocations));
|
||||
}
|
||||
TransferRow(shown, "Texture transfers", Counter::TextureUploadBytes,
|
||||
Counter::TextureDownloadBytes);
|
||||
Row("Texture evictions", Fmt("%.0f/s", Rate(shown, Counter::TextureEvictions)));
|
||||
TransferRow(shown, "Buffer transfers", Counter::BufferUploadBytes,
|
||||
Counter::BufferDownloadBytes);
|
||||
Row("Buffer evictions", Fmt("%.0f/s", Rate(shown, Counter::BufferEvictions)));
|
||||
ImGui::EndTable();
|
||||
}
|
||||
}
|
||||
|
||||
void DrawMemoryAndIo(const Snapshot& shown) {
|
||||
const auto& host = shown.host;
|
||||
const auto& guest = shown.guest_memory;
|
||||
if (BeginSection("PS5 memory")) {
|
||||
const auto direct_used = guest.direct_allocated + guest.pooled_allocated;
|
||||
Row("Direct", Bytes(direct_used) + " / " + Bytes(guest.direct_total),
|
||||
LevelColor(guest.direct_total != 0 ? static_cast<double>(direct_used) /
|
||||
static_cast<double>(guest.direct_total) * 100.0
|
||||
: 0.0,
|
||||
85, 97));
|
||||
Row(" Mapped", Bytes(guest.direct_mapped));
|
||||
Row(" Pool",
|
||||
Bytes(guest.pooled_allocated) + " (" + Bytes(guest.pool_committed) + " committed)");
|
||||
Row("Flexible", Bytes(guest.flexible_used) + " / " + Bytes(guest.flexible_total));
|
||||
Row("Extended", Bytes(guest.automatic_allocated));
|
||||
// Past the pool size the guest sees no page-table entries available.
|
||||
const auto entries = std::max(guest.cpu_page_entries, guest.gpu_page_entries);
|
||||
Row("Page table (2 MB)",
|
||||
Fmt("CPU %llu GPU %llu / %llu",
|
||||
static_cast<unsigned long long>(guest.cpu_page_entries),
|
||||
static_cast<unsigned long long>(guest.gpu_page_entries),
|
||||
static_cast<unsigned long long>(guest.page_entries_total)),
|
||||
entries > guest.page_entries_total ? BAD
|
||||
: entries * 10 > guest.page_entries_total * 9 ? MEDIUM
|
||||
: GOOD);
|
||||
ImGui::EndTable();
|
||||
}
|
||||
if (BeginSection("Emulator process")) {
|
||||
Row("Footprint", Bytes(host.process_memory));
|
||||
Row("Resident", Bytes(host.process_resident));
|
||||
if (host.process_compressed) {
|
||||
Row("Compressed / swapped", Bytes(*host.process_compressed),
|
||||
*host.process_compressed > (1ull << 30u) ? MEDIUM : GOOD);
|
||||
}
|
||||
Row("File-backed", Bytes(host.process_file_backed));
|
||||
Row("Address space", Bytes(host.process_virtual));
|
||||
ImGui::EndTable();
|
||||
}
|
||||
if (BeginSection("System memory")) {
|
||||
if (host.system_memory_used && host.system_memory_total) {
|
||||
Row("Used", Bytes(*host.system_memory_used) + " / " + Bytes(*host.system_memory_total));
|
||||
}
|
||||
if (host.system_wired) {
|
||||
Row("Wired", Bytes(*host.system_wired));
|
||||
}
|
||||
if (host.system_compressed) {
|
||||
Row("Compressed", Bytes(*host.system_compressed));
|
||||
}
|
||||
Row("Cached files", Bytes(host.system_cached));
|
||||
Row("Free", Bytes(host.system_free));
|
||||
if (host.swap_used) {
|
||||
Row("Swap", Bytes(*host.swap_used) + " / " + Bytes(host.swap_total),
|
||||
*host.swap_used > (4ull << 30u) ? MEDIUM : GOOD);
|
||||
}
|
||||
Row("Pressure", PressureName(host.memory_pressure), PressureColor(host.memory_pressure));
|
||||
ImGui::EndTable();
|
||||
}
|
||||
if (BeginSection("I/O & audio")) {
|
||||
Row("Disk read / write", Throughput(host.disk_read_per_s.value_or(0.0)) + " / " +
|
||||
Throughput(host.disk_write_per_s.value_or(0.0)));
|
||||
Row("Guest file read / write", Throughput(Rate(shown, Counter::GuestFileReadBytes)) +
|
||||
" / " +
|
||||
Throughput(Rate(shown, Counter::GuestFileWriteBytes)));
|
||||
const auto underruns = Rate(shown, Counter::AudioUnderruns);
|
||||
Row("Audio underruns",
|
||||
Fmt("%.0f/s (%llu total)", underruns,
|
||||
static_cast<unsigned long long>(Total(shown, Counter::AudioUnderruns))),
|
||||
underruns > 0.0 ? BAD : GOOD);
|
||||
ImGui::EndTable();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
void PerformanceOverlayRecordFlip(uint32_t guest_width, uint32_t guest_height) noexcept {
|
||||
if (!Common::DebugCounters::Enabled()) {
|
||||
return;
|
||||
}
|
||||
std::scoped_lock lock(g_frame_mutex);
|
||||
const auto now = Clock::now();
|
||||
if (g_frames.window_start == Clock::time_point {}) {
|
||||
g_frames.window_start = now;
|
||||
}
|
||||
auto& frames = g_frames;
|
||||
if (frames.last_flip != Clock::time_point {}) {
|
||||
const float ms = std::chrono::duration<float, std::milli>(now - frames.last_flip).count();
|
||||
frames.intervals_ms[frames.next] = ms;
|
||||
frames.next = (frames.next + 1) % FRAME_HISTORY;
|
||||
frames.count = std::min(frames.count + 1, FRAME_HISTORY);
|
||||
frames.max_ms = std::max(frames.max_ms, ms);
|
||||
}
|
||||
frames.last_flip = now;
|
||||
frames.guest_width = guest_width;
|
||||
frames.guest_height = guest_height;
|
||||
frames.flips++;
|
||||
}
|
||||
|
||||
bool PerformanceOverlayEnabled() noexcept {
|
||||
return Common::DebugCounters::Enabled();
|
||||
}
|
||||
|
||||
void TogglePerformanceOverlay() noexcept {
|
||||
SetOverlayEnabled(!Common::DebugCounters::Enabled());
|
||||
g_revision.fetch_add(1, std::memory_order_acq_rel);
|
||||
}
|
||||
|
||||
void TogglePerformanceOverlayDetails() noexcept {
|
||||
if (Common::DebugCounters::Enabled()) {
|
||||
g_details.store(!g_details.load(std::memory_order_acquire), std::memory_order_release);
|
||||
} else {
|
||||
g_details.store(true, std::memory_order_release);
|
||||
SetOverlayEnabled(true);
|
||||
}
|
||||
g_revision.fetch_add(1, std::memory_order_acq_rel);
|
||||
}
|
||||
|
||||
uint64_t PerformanceOverlayRevision() noexcept {
|
||||
return g_revision.load(std::memory_order_acquire);
|
||||
}
|
||||
|
||||
float DrawPerformanceOverlay(const GraphicContext& graphics, vk::Extent2D extent) {
|
||||
if (!PerformanceOverlayEnabled()) {
|
||||
return 0.0f;
|
||||
}
|
||||
EnsureSampler();
|
||||
|
||||
static Snapshot shown;
|
||||
static uint64_t shown_generation = 0;
|
||||
static bool shown_details = false;
|
||||
const auto generation = g_generation.load(std::memory_order_acquire);
|
||||
const bool details = g_details.load(std::memory_order_acquire);
|
||||
const auto now = Clock::now();
|
||||
if (generation != shown_generation) {
|
||||
shown = {};
|
||||
shown_generation = generation;
|
||||
}
|
||||
if (shown.sample_time == Clock::time_point {} || now - shown.sample_time >= REFRESH_INTERVAL ||
|
||||
details != shown_details) {
|
||||
{
|
||||
std::scoped_lock lock(g_frame_mutex);
|
||||
auto& frames = g_frames;
|
||||
shown.history_count = frames.count;
|
||||
for (size_t i = 0; i < frames.count; i++) {
|
||||
shown.history[i] =
|
||||
frames.intervals_ms[(frames.next + FRAME_HISTORY - frames.count + i) %
|
||||
FRAME_HISTORY];
|
||||
}
|
||||
if (frames.window_start == Clock::time_point {}) {
|
||||
frames.window_start = now;
|
||||
}
|
||||
const double seconds = std::chrono::duration<double>(now - frames.window_start).count();
|
||||
shown.fps = seconds > 0.0 ? frames.flips / seconds : 0.0;
|
||||
shown.frame_ms = frames.flips > 0 ? seconds * 1000.0 / frames.flips : 0.0;
|
||||
shown.max_frame_ms = frames.max_ms;
|
||||
shown.stalled_s = frames.last_flip == Clock::time_point {}
|
||||
? 0.0
|
||||
: std::chrono::duration<double>(now - frames.last_flip).count();
|
||||
shown.guest_width = frames.guest_width;
|
||||
shown.guest_height = frames.guest_height;
|
||||
frames.flips = 0;
|
||||
frames.max_ms = 0.0f;
|
||||
frames.window_start = now;
|
||||
}
|
||||
shown_details = details;
|
||||
if (shown.history_count > 0) {
|
||||
auto sorted = shown.history;
|
||||
const auto end = sorted.begin() + shown.history_count;
|
||||
const auto percentile = sorted.begin() + shown.history_count * 99 / 100;
|
||||
std::nth_element(sorted.begin(), percentile, end);
|
||||
shown.low_fps = *percentile > 0.0f ? 1000.0 / *percentile : 0.0;
|
||||
}
|
||||
Refresh(shown, graphics, now, generation);
|
||||
}
|
||||
|
||||
const float scale = std::clamp(std::min(static_cast<float>(extent.width) / 1920.0f,
|
||||
static_cast<float>(extent.height) / 1080.0f),
|
||||
0.75f, 1.5f);
|
||||
ImGui::SetNextWindowPos({static_cast<float>(extent.width) - 12.0f * scale, 12.0f * scale},
|
||||
ImGuiCond_Always, {1.0f, 0.0f});
|
||||
ImGui::SetNextWindowBgAlpha(details ? 0.82f : 0.72f);
|
||||
constexpr ImGuiWindowFlags FLAGS =
|
||||
ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoInputs | ImGuiWindowFlags_NoNav |
|
||||
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
|
||||
ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoBringToFrontOnFocus |
|
||||
ImGuiWindowFlags_AlwaysAutoResize;
|
||||
ImGui::PushFont(nullptr, (details ? 13.0f : 15.0f) * scale);
|
||||
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 8.0f * scale);
|
||||
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, {10.0f * scale, 8.0f * scale});
|
||||
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, {8.0f * scale, 2.0f * scale});
|
||||
ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, {4.0f * scale, 1.0f * scale});
|
||||
if (ImGui::Begin("##kyty_performance_overlay", nullptr, FLAGS)) {
|
||||
if (shown.fps > 0.0) {
|
||||
ImGui::TextColored(Color(FrameTimeColor(shown.frame_ms)), "%.1f FPS %.1f ms",
|
||||
shown.fps, shown.frame_ms);
|
||||
} else if (shown.stalled_s >= 1.0) {
|
||||
ImGui::TextColored(Color(BAD), "No frames for %.0f s", shown.stalled_s);
|
||||
} else {
|
||||
ImGui::TextDisabled("Waiting for frames");
|
||||
}
|
||||
DrawFrameGraph(shown.history, shown.history_count, (details ? 330.0f : 260.0f) * scale,
|
||||
46.0f * scale);
|
||||
if (details) {
|
||||
// Three columns keep the detailed panel within a 720p window.
|
||||
if (ImGui::BeginTable("##details", 3, TABLE_FLAGS)) {
|
||||
ImGui::TableNextRow();
|
||||
ImGui::TableNextColumn();
|
||||
DrawFramesAndCpu(shown, extent);
|
||||
ImGui::TableNextColumn();
|
||||
DrawGpu(shown, graphics);
|
||||
ImGui::TableNextColumn();
|
||||
DrawMemoryAndIo(shown);
|
||||
ImGui::EndTable();
|
||||
}
|
||||
} else {
|
||||
DrawCompact(shown);
|
||||
}
|
||||
#if defined(__APPLE__)
|
||||
ImGui::TextDisabled(details ? "Cmd+Shift+P compact Cmd+P hide"
|
||||
: "Cmd+Shift+P details Cmd+P hide");
|
||||
#else
|
||||
ImGui::TextDisabled(details ? "Shift+F2 compact F2 hide" : "Shift+F2 details F2 hide");
|
||||
#endif
|
||||
}
|
||||
const float bottom = ImGui::GetWindowPos().y + ImGui::GetWindowSize().y;
|
||||
ImGui::End();
|
||||
ImGui::PopStyleVar(4);
|
||||
ImGui::PopFont();
|
||||
return bottom;
|
||||
}
|
||||
|
||||
} // namespace Libs::Graphics
|
||||
Reference in New Issue
Block a user