early-access version 1255

src/core/perf_stats.cpp

@@ -0,0 +1,157 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <chrono>
+#include <iterator>
+#include <mutex>
+#include <numeric>
+#include <sstream>
+#include <thread>
+#include <fmt/chrono.h>
+#include <fmt/format.h>
+#include "common/file_util.h"
+#include "common/math_util.h"
+#include "core/perf_stats.h"
+#include "core/settings.h"
+
+using namespace std::chrono_literals;
+using DoubleSecs = std::chrono::duration<double, std::chrono::seconds::period>;
+using std::chrono::duration_cast;
+using std::chrono::microseconds;
+
+// Purposefully ignore the first five frames, as there's a significant amount of overhead in
+// booting that we shouldn't account for
+constexpr std::size_t IgnoreFrames = 5;
+
+namespace Core {
+
+PerfStats::PerfStats(u64 title_id) : title_id(title_id) {}
+
+PerfStats::~PerfStats() {
+    if (!Settings::values.record_frame_times || title_id == 0) {
+        return;
+    }
+
+    const std::time_t t = std::time(nullptr);
+    std::ostringstream stream;
+    std::copy(perf_history.begin() + IgnoreFrames, perf_history.begin() + current_index,
+              std::ostream_iterator<double>(stream, "\n"));
+    const std::string& path = Common::FS::GetUserPath(Common::FS::UserPath::LogDir);
+    // %F Date format expanded is "%Y-%m-%d"
+    const std::string filename =
+        fmt::format("{}/{:%F-%H-%M}_{:016X}.csv", path, *std::localtime(&t), title_id);
+    Common::FS::IOFile file(filename, "w");
+    file.WriteString(stream.str());
+}
+
+void PerfStats::BeginSystemFrame() {
+    std::lock_guard lock{object_mutex};
+
+    frame_begin = Clock::now();
+}
+
+void PerfStats::EndSystemFrame() {
+    std::lock_guard lock{object_mutex};
+
+    auto frame_end = Clock::now();
+    const auto frame_time = frame_end - frame_begin;
+    if (current_index < perf_history.size()) {
+        perf_history[current_index++] =
+            std::chrono::duration<double, std::milli>(frame_time).count();
+    }
+    accumulated_frametime += frame_time;
+    system_frames += 1;
+
+    previous_frame_length = frame_end - previous_frame_end;
+    previous_frame_end = frame_end;
+}
+
+void PerfStats::EndGameFrame() {
+    std::lock_guard lock{object_mutex};
+
+    game_frames += 1;
+}
+
+double PerfStats::GetMeanFrametime() const {
+    std::lock_guard lock{object_mutex};
+
+    if (current_index <= IgnoreFrames) {
+        return 0;
+    }
+
+    const double sum = std::accumulate(perf_history.begin() + IgnoreFrames,
+                                       perf_history.begin() + current_index, 0.0);
+    return sum / static_cast<double>(current_index - IgnoreFrames);
+}
+
+PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us) {
+    std::lock_guard lock{object_mutex};
+
+    const auto now = Clock::now();
+    // Walltime elapsed since stats were reset
+    const auto interval = duration_cast<DoubleSecs>(now - reset_point).count();
+
+    const auto system_us_per_second = (current_system_time_us - reset_point_system_us) / interval;
+
+    const PerfStatsResults results{
+        .system_fps = static_cast<double>(system_frames) / interval,
+        .game_fps = static_cast<double>(game_frames) / interval,
+        .frametime = duration_cast<DoubleSecs>(accumulated_frametime).count() /
+                     static_cast<double>(system_frames),
+        .emulation_speed = system_us_per_second.count() / 1'000'000.0,
+    };
+
+    // Reset counters
+    reset_point = now;
+    reset_point_system_us = current_system_time_us;
+    accumulated_frametime = Clock::duration::zero();
+    system_frames = 0;
+    game_frames = 0;
+
+    return results;
+}
+
+double PerfStats::GetLastFrameTimeScale() const {
+    std::lock_guard lock{object_mutex};
+
+    constexpr double FRAME_LENGTH = 1.0 / 60;
+    return duration_cast<DoubleSecs>(previous_frame_length).count() / FRAME_LENGTH;
+}
+
+void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
+    if (!Settings::values.use_frame_limit.GetValue() ||
+        Settings::values.use_multi_core.GetValue()) {
+        return;
+    }
+
+    auto now = Clock::now();
+
+    const double sleep_scale = Settings::values.frame_limit.GetValue() / 100.0;
+
+    // Max lag caused by slow frames. Shouldn't be more than the length of a frame at the current
+    // speed percent or it will clamp too much and prevent this from properly limiting to that
+    // percent. High values means it'll take longer after a slow frame to recover and start
+    // limiting
+    const microseconds max_lag_time_us = duration_cast<microseconds>(
+        std::chrono::duration<double, std::chrono::microseconds::period>(25ms / sleep_scale));
+    frame_limiting_delta_err += duration_cast<microseconds>(
+        std::chrono::duration<double, std::chrono::microseconds::period>(
+            (current_system_time_us - previous_system_time_us) / sleep_scale));
+    frame_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
+    frame_limiting_delta_err =
+        std::clamp(frame_limiting_delta_err, -max_lag_time_us, max_lag_time_us);
+
+    if (frame_limiting_delta_err > microseconds::zero()) {
+        std::this_thread::sleep_for(frame_limiting_delta_err);
+        auto now_after_sleep = Clock::now();
+        frame_limiting_delta_err -= duration_cast<microseconds>(now_after_sleep - now);
+        now = now_after_sleep;
+    }
+
+    previous_system_time_us = current_system_time_us;
+    previous_walltime = now;
+}
+
+} // namespace Core