mirror of
https://github.com/yuzu-emu/yuzu.git
synced 2024-09-12 21:38:14 +02:00
This setting is best referred to as a speed limit, as it involves the limits of all timing based aspects of the emulator, not only framerate. This allows us to differentiate it from the fps unlocker setting.
165 lines
5.8 KiB
C++
165 lines
5.8 KiB
C++
// 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/fs/file.h"
|
|
#include "common/fs/fs.h"
|
|
#include "common/fs/path_util.h"
|
|
#include "common/math_util.h"
|
|
#include "common/settings.h"
|
|
#include "core/perf_stats.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 auto path = Common::FS::GetYuzuPath(Common::FS::YuzuPath::LogDir);
|
|
// %F Date format expanded is "%Y-%m-%d"
|
|
const auto filename = fmt::format("{:%F-%H-%M}_{:016X}.csv", *std::localtime(&t), title_id);
|
|
const auto filepath = path / filename;
|
|
|
|
if (Common::FS::CreateParentDir(filepath)) {
|
|
Common::FS::IOFile file(filepath, Common::FS::FileAccessMode::Write,
|
|
Common::FS::FileType::TextFile);
|
|
void(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() {
|
|
game_frames.fetch_add(1, std::memory_order_relaxed);
|
|
}
|
|
|
|
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 auto current_frames = static_cast<double>(game_frames.load(std::memory_order_relaxed));
|
|
const auto current_fps = current_frames / interval;
|
|
const PerfStatsResults results{
|
|
.system_fps = static_cast<double>(system_frames) / interval,
|
|
.average_game_fps = (current_fps + previous_fps) / 2.0,
|
|
.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.store(0, std::memory_order_relaxed);
|
|
previous_fps = current_fps;
|
|
|
|
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 SpeedLimiter::DoSpeedLimiting(microseconds current_system_time_us) {
|
|
if (!Settings::values.use_speed_limit.GetValue() ||
|
|
Settings::values.use_multi_core.GetValue()) {
|
|
return;
|
|
}
|
|
|
|
auto now = Clock::now();
|
|
|
|
const double sleep_scale = Settings::values.speed_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));
|
|
speed_limiting_delta_err += duration_cast<microseconds>(
|
|
std::chrono::duration<double, std::chrono::microseconds::period>(
|
|
(current_system_time_us - previous_system_time_us) / sleep_scale));
|
|
speed_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
|
|
speed_limiting_delta_err =
|
|
std::clamp(speed_limiting_delta_err, -max_lag_time_us, max_lag_time_us);
|
|
|
|
if (speed_limiting_delta_err > microseconds::zero()) {
|
|
std::this_thread::sleep_for(speed_limiting_delta_err);
|
|
auto now_after_sleep = Clock::now();
|
|
speed_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
|