Archives
/
MangoHud
mirror of https://github.com/flightlessmango/MangoHud
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move logging functionality into a class

Browse Source
pull/247/head
Lars Krämer 4 years ago
parent 5fe5ac5f3d
commit 4101237fdd
3 changed files with 125 additions and 75 deletions
Show Stats Download Patch File Download Diff File

96
src/logging.cpp
Unescape Escape View File

@ -5,16 +5,11 @@
string os, cpu, gpu, ram, kernel, driver;
bool sysInfoFetched = false;
int gpuLoadLog = 0, cpuLoadLog = 0;
Clock::duration elapsedLog;
std::vector<std::string> logFiles;
double fps;
std::vector<logData> logArray;
ofstream out;
bool loggingOn;
Clock::time_point log_start, log_end;
logData currentLogData = {};
bool logUpdate = false;
std::unique_ptr<Logger> logger;
string exec(string command) {
char buffer[128];
@ -58,8 +53,10 @@ void upload_files(){
}
void writeFile(string filename){
auto& logArray = logger->get_log_data();
std::cerr << "writeFile(" << filename << ", vector<logData>(" << logArray.size() << "))\n";
logFiles.push_back(filename);
out.open(filename, ios::out | ios::app);
std::ofstream out(filename, ios::out | ios::app);
out << "os," << "cpu," << "gpu," << "ram," << "kernel," << "driver" << endl;
out << os << "," << cpu << "," << gpu << "," << ram << "," << kernel << "," << driver << endl;
out << "fps," << "cpu_load," << "gpu_load," << "cpu_temp," << "gpu_temp," << "gpu_core_clock," << "gpu_mem_clock," << "gpu_vram_used," << "ram_used," << "elapsed" << endl;
@ -76,9 +73,7 @@ void writeFile(string filename){
out << logArray[i].ram_used << ",";
out << std::chrono::duration_cast<std::chrono::microseconds>(logArray[i].previous).count() << "\n";
}
out.close();
logArray.clear();
logger->clear_log_data();
}
string get_log_suffix(){
@ -92,23 +87,68 @@ string get_log_suffix(){
void logging(void *params_void){
overlay_params *params = reinterpret_cast<overlay_params *>(params_void);
while (loggingOn){
auto now = Clock::now();
elapsedLog = now - log_start;
currentLogData.fps = fps;
currentLogData.previous = elapsedLog;
if (logUpdate)
logArray.push_back(currentLogData);
if (params->log_duration && (elapsedLog >= std::chrono::seconds(params->log_duration)))
loggingOn = false;
else
if (logUpdate)
this_thread::sleep_for(std::chrono::milliseconds(params->log_interval));
else
this_thread::sleep_for(chrono::milliseconds(0));
logger->wait_until_data_valid();
while (logger->is_active()){
logger->try_log();
this_thread::sleep_for(chrono::milliseconds(params->log_interval));
}
}
Logger::Logger(overlay_params* in_params)
: loggingOn(false),
values_valid(false),
params(in_params)
{
#ifndef NDEBUG
std::cerr << "Logger constructed!\n";
#endif
}
void Logger::start_logging() {
if(loggingOn) return;
values_valid = false;
loggingOn = true;
log_start = Clock::now();
if((not params->output_file.empty()) and (params->log_interval != 0)){
std::thread(logging, params).detach();
}
}
void Logger::stop_logging() {
if(not loggingOn) return;
loggingOn = false;
log_end = Clock::now();
std::thread(calculate_benchmark_data).detach();
if(not params->output_file.empty()) {
std::thread(writeFile, params->output_file + get_log_suffix()).detach();
}
}
void Logger::try_log() {
if(not is_active()) return;
if(not values_valid) return;
auto now = Clock::now();
auto elapsedLog = now - log_start;
currentLogData.previous = elapsedLog;
currentLogData.fps = fps;
logArray.push_back(currentLogData);
if(params->log_duration and (elapsedLog >= std::chrono::seconds(params->log_duration))){
stop_logging();
}
}
writeFile(params->output_file + get_log_suffix());
void Logger::wait_until_data_valid() {
std::unique_lock<std::mutex> lck(values_valid_mtx);
while(! values_valid) values_valid_cv.wait(lck);
}
void Logger::notify_data_valid() {
std::unique_lock<std::mutex> lck(values_valid_mtx);
values_valid = true;
values_valid_cv.notify_all();
}

48
src/logging.h
Unescape Escape View File

@ -3,9 +3,12 @@
#include <fstream>
#include <chrono>
#include <thread>
#include <condition_variable>
#include "timing.hpp"
#include "overlay_params.h"
using namespace std;
struct logData{
double fps;
@ -21,20 +24,43 @@ struct logData{
Clock::duration previous;
};
class Logger {
public:
Logger(overlay_params* in_params);
void start_logging();
void stop_logging();
void try_log();
bool is_active() const { return loggingOn; }
void wait_until_data_valid();
void notify_data_valid();
auto last_log_end() const noexcept { return log_end; }
auto last_log_begin() const noexcept { return log_start; }
const std::vector<logData>& get_log_data() const noexcept { return logArray; }
void clear_log_data() noexcept { logArray.clear(); }
private:
std::vector<logData> logArray;
Clock::time_point log_start;
Clock::time_point log_end;
bool loggingOn;
std::mutex values_valid_mtx;
std::condition_variable values_valid_cv;
bool values_valid;
overlay_params* params;
};
extern std::unique_ptr<Logger> logger;
extern string os, cpu, gpu, ram, kernel, driver;
extern bool sysInfoFetched;
extern Clock::duration elapsedLog;
extern std::vector<std::string> logFiles;
extern double fps;
extern std::vector<logData> logArray;
extern bool loggingOn;
extern Clock::time_point log_start, log_end;
extern logData currentLogData;
extern bool logUpdate;
void logging(void *params_void);
void writeFile(string filename);
string exec(string command);
string get_log_suffix(void);
void upload_file(void);
void upload_files(void);

56
src/overlay.cpp
Unescape Escape View File

@ -735,17 +735,17 @@ void init_system_info(){
}
void update_hw_info(struct swapchain_stats& sw_stats, struct overlay_params& params, uint32_t vendorID){
if (params.enabled[OVERLAY_PARAM_ENABLED_cpu_stats] || loggingOn) {
if (params.enabled[OVERLAY_PARAM_ENABLED_cpu_stats] || logger->is_active()) {
cpuStats.UpdateCPUData();
sw_stats.total_cpu = cpuStats.GetCPUDataTotal().percent;
if (params.enabled[OVERLAY_PARAM_ENABLED_core_load])
cpuStats.UpdateCoreMhz();
if (params.enabled[OVERLAY_PARAM_ENABLED_cpu_temp] || loggingOn)
if (params.enabled[OVERLAY_PARAM_ENABLED_cpu_temp] || logger->is_active())
cpuStats.UpdateCpuTemp();
}
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_stats] || loggingOn) {
if (params.enabled[OVERLAY_PARAM_ENABLED_gpu_stats] || logger->is_active()) {
if (vendorID == 0x1002)
getAmdGpuInfo();
@ -754,7 +754,7 @@ void update_hw_info(struct swapchain_stats& sw_stats, struct overlay_params& par
}
// get ram usage/max
if (params.enabled[OVERLAY_PARAM_ENABLED_ram] || loggingOn)
if (params.enabled[OVERLAY_PARAM_ENABLED_ram] || logger->is_active())
update_meminfo();
if (params.enabled[OVERLAY_PARAM_ENABLED_io_read] || params.enabled[OVERLAY_PARAM_ENABLED_io_write])
getIoStats(&sw_stats.io);
@ -769,8 +769,7 @@ void update_hw_info(struct swapchain_stats& sw_stats, struct overlay_params& par
currentLogData.cpu_load = cpuStats.GetCPUDataTotal().percent;
currentLogData.cpu_temp = cpuStats.GetCPUDataTotal().temp;
if (!logUpdate)
logUpdate = true;
logger->notify_data_valid();
}
void check_keybinds(struct swapchain_stats& sw_stats, struct overlay_params& params, uint32_t vendorID){
@ -792,22 +791,14 @@ void check_keybinds(struct swapchain_stats& sw_stats, struct overlay_params& par
#endif
if (pressed && (now - log_end > 11s)){
last_f2_press = now;
if(loggingOn){
log_end = now;
if(logger->is_active()){
logger->stop_logging();
std::thread(calculate_benchmark_data).detach();
} else {
logUpdate = false;
logger->start_logging();
std::thread(update_hw_info, std::ref(sw_stats), std::ref(params), vendorID).detach();
benchmark.fps_data.clear();
log_start = now;
}
if (!params.output_file.empty() && params.log_duration == 0 && params.log_interval == 0 && loggingOn)
writeFile(params.output_file + get_log_suffix());
loggingOn = !loggingOn;
if (!params.output_file.empty() && loggingOn && params.log_interval != 0)
std::thread(logging, &params).detach();
}
}
@ -873,12 +864,13 @@ void calculate_benchmark_data(){
}
void update_hud_info(struct swapchain_stats& sw_stats, struct overlay_params& params, uint32_t vendorID){
if(not logger) logger = std::make_unique<Logger>(&params);
uint32_t f_idx = sw_stats.n_frames % ARRAY_SIZE(sw_stats.frames_stats);
uint64_t now = os_time_get(); /* us */
double elapsed = (double)(now - sw_stats.last_fps_update); /* us */
fps = 1000000.0f * sw_stats.n_frames_since_update / elapsed;
if (loggingOn)
if (logger->is_active())
benchmark.fps_data.push_back(fps);
if (sw_stats.last_present_time) {
@ -1092,7 +1084,7 @@ void render_benchmark(swapchain_stats& data, struct overlay_params& params, ImVe
ImGui::SetNextWindowPos(ImVec2(data.main_window_pos.x, data.main_window_pos.y + window_size.y + 5), ImGuiCond_Always);
vector<pair<string, float>> benchmark_data = {{"97% ", benchmark.ninety}, {"AVG ", benchmark.avg}, {"1% ", benchmark.oneP}, {"0.1%", benchmark.pointOneP}};
float display_time = std::chrono::duration<float>(now - log_end).count();
float display_time = std::chrono::duration<float>(now - logger->last_log_end()).count();
static float display_for = 10.0f;
float alpha;
if(params.background_alpha != 0){
@ -1126,7 +1118,7 @@ void render_benchmark(swapchain_stats& data, struct overlay_params& params, ImVe
ImGui::TextColored(ImVec4(1.0, 1.0, 1.0, alpha / params.background_alpha), "%s", finished);
ImGui::Dummy(ImVec2(0.0f, 8.0f));
char duration[20];
snprintf(duration, sizeof(duration), "Duration: %.1fs", std::chrono::duration<float>(log_end - log_start).count());
snprintf(duration, sizeof(duration), "Duration: %.1fs", std::chrono::duration<float>(logger->last_log_end() - logger->last_log_begin()).count());
ImGui::SetCursorPosX((ImGui::GetWindowSize().x / 2 )- (ImGui::CalcTextSize(duration).x / 2));
ImGui::TextColored(ImVec4(1.0, 1.0, 1.0, alpha / params.background_alpha), "%s", duration);
for (auto& data_ : benchmark_data){
@ -1151,7 +1143,11 @@ void render_benchmark(swapchain_stats& data, struct overlay_params& params, ImVe
void render_imgui(swapchain_stats& data, struct overlay_params& params, ImVec2& window_size, bool is_vulkan)
{
<<<<<<< HEAD
ImGui::GetIO().FontGlobalScale = params.font_scale;
=======
if(not logger) logger = std::make_unique<Logger>(&params);
>>>>>>> 9c2e489... Move logging functionality into a class
uint32_t f_idx = (data.n_frames - 1) % ARRAY_SIZE(data.frames_stats);
uint64_t frame_timing = data.frames_stats[f_idx].stats[OVERLAY_PLOTS_frame_timing];
static float char_width = ImGui::CalcTextSize("A").x;
@ -1379,14 +1375,8 @@ void render_imgui(swapchain_stats& data, struct overlay_params& params, ImVec2&
ImGui::PopFont();
}
if (loggingOn && params.log_interval == 0){
elapsedLog = now - log_start;
if (params.log_duration && (elapsedLog) >= std::chrono::seconds(params.log_duration))
loggingOn = false;
currentLogData.fps = fps;
currentLogData.previous = elapsedLog;
logArray.push_back(currentLogData);
if (params.log_interval == 0){
logger->try_log();
}
if (params.enabled[OVERLAY_PARAM_ENABLED_frame_timing]){
@ -1432,18 +1422,12 @@ void render_imgui(swapchain_stats& data, struct overlay_params& params, ImVec2&
ImGui::PopFont();
#endif
if(loggingOn)
if(logger->is_active())
ImGui::GetWindowDrawList()->AddCircleFilled(ImVec2(data.main_window_pos.x + window_size.x - 15, data.main_window_pos.y + 15), 10, params.engine_color, 20);
window_size = ImVec2(window_size.x, ImGui::GetCursorPosY() + 10.0f);
ImGui::End();
if (loggingOn && params.log_duration && (now - log_start) >= std::chrono::seconds(params.log_duration)){
loggingOn = false;
log_end = now;
std::thread(calculate_benchmark_data).detach();
}
if((now - log_end) < 12s)
if((now - logger->last_log_end()) < 12s)
render_benchmark(data, params, window_size, height, now);
}
}

Write Preview
Loading…
Cancel
Save