From c6424403b3189f9be534db284e2651def2fd95f4 Mon Sep 17 00:00:00 2001 From: souldbminersmwc Date: Sun, 12 Apr 2026 17:43:45 -0400 Subject: [PATCH] hocmon: partially add ram bw --- Source/Horizon-OC-Monitor/Makefile | 1 + Source/Horizon-OC-Monitor/source/Utils.hpp | 39 +++++- .../source/modes/Configurator.hpp | 35 +++++ .../Horizon-OC-Monitor/source/modes/Full.hpp | 51 ++++++-- .../Horizon-OC-Monitor/source/modes/Micro.hpp | 5 + .../Horizon-OC-Monitor/source/modes/Mini.hpp | 123 +++++++++++------- 6 files changed, 193 insertions(+), 61 deletions(-) diff --git a/Source/Horizon-OC-Monitor/Makefile b/Source/Horizon-OC-Monitor/Makefile index c793d88a..e2e4776b 100644 --- a/Source/Horizon-OC-Monitor/Makefile +++ b/Source/Horizon-OC-Monitor/Makefile @@ -65,6 +65,7 @@ IS_STATUS_MONITOR_DIRECTIVE := 1 CFLAGS += -DIS_STATUS_MONITOR_DIRECTIVE=$(IS_STATUS_MONITOR_DIRECTIVE) # Enable appearance overriding +export MSYS2_ARG_CONV_EXCL := -DUI_OVERRIDE_PATH UI_OVERRIDE_PATH := /config/status-monitor/ CFLAGS += -DUI_OVERRIDE_PATH="\"$(UI_OVERRIDE_PATH)\"" diff --git a/Source/Horizon-OC-Monitor/source/Utils.hpp b/Source/Horizon-OC-Monitor/source/Utils.hpp index dbea4eda..f66f116a 100644 --- a/Source/Horizon-OC-Monitor/source/Utils.hpp +++ b/Source/Horizon-OC-Monitor/source/Utils.hpp @@ -583,8 +583,12 @@ void Misc(void*) { realCPU_Hz = hocclkCTX.realFreqs[HocClkModule_CPU]; realGPU_Hz = hocclkCTX.realFreqs[HocClkModule_GPU]; realRAM_Hz = hocclkCTX.realFreqs[HocClkModule_MEM]; - partLoad[HocClkPartLoad_EMC] = hocclkCTX.partLoad[HocClkPartLoad_EMC]; - partLoad[HocClkPartLoad_EMCCpu] = hocclkCTX.partLoad[HocClkPartLoad_EMCCpu]; + partLoad[HocClkPartLoad_EMC] = hocclkCTX.partLoad[HocClkPartLoad_EMC]; + partLoad[HocClkPartLoad_EMCCpu] = hocclkCTX.partLoad[HocClkPartLoad_EMCCpu]; + partLoad[HocClkPartLoad_RamBWAll] = hocclkCTX.partLoad[HocClkPartLoad_RamBWAll]; + partLoad[HocClkPartLoad_RamBWCpu] = hocclkCTX.partLoad[HocClkPartLoad_RamBWCpu]; + partLoad[HocClkPartLoad_RamBWGpu] = hocclkCTX.partLoad[HocClkPartLoad_RamBWGpu]; + partLoad[HocClkPartLoad_RamBWPeak] = hocclkCTX.partLoad[HocClkPartLoad_RamBWPeak]; realCPU_Temp = hocclkCTX.temps[HocClkThermalSensor_CPU]; realGPU_Temp = hocclkCTX.temps[HocClkThermalSensor_GPU]; realPLLX_Temp = hocclkCTX.temps[HocClkThermalSensor_PLLX]; @@ -714,8 +718,12 @@ void Misc3(void*) { if (R_SUCCEEDED(hocclkCheck)) { HocClkContext hocclkCTX; if (R_SUCCEEDED(hocclkIpcGetCurrentContext(&hocclkCTX))) { - partLoad[HocClkPartLoad_EMC] = hocclkCTX.partLoad[HocClkPartLoad_EMC]; - partLoad[HocClkPartLoad_EMCCpu] = hocclkCTX.partLoad[HocClkPartLoad_EMCCpu]; + partLoad[HocClkPartLoad_EMC] = hocclkCTX.partLoad[HocClkPartLoad_EMC]; + partLoad[HocClkPartLoad_EMCCpu] = hocclkCTX.partLoad[HocClkPartLoad_EMCCpu]; + partLoad[HocClkPartLoad_RamBWAll] = hocclkCTX.partLoad[HocClkPartLoad_RamBWAll]; + partLoad[HocClkPartLoad_RamBWCpu] = hocclkCTX.partLoad[HocClkPartLoad_RamBWCpu]; + partLoad[HocClkPartLoad_RamBWGpu] = hocclkCTX.partLoad[HocClkPartLoad_RamBWGpu]; + partLoad[HocClkPartLoad_RamBWPeak] = hocclkCTX.partLoad[HocClkPartLoad_RamBWPeak]; realCPU_Temp = hocclkCTX.temps[HocClkThermalSensor_CPU]; realGPU_Temp = hocclkCTX.temps[HocClkThermalSensor_GPU]; @@ -1274,6 +1282,7 @@ struct FullSettings { bool showFPS; bool showRES; bool showRDSD; + std::string ramInfoMode; bool useDynamicColors; bool disableScreenshots; uint16_t separatorColor; @@ -1309,6 +1318,7 @@ struct MiniSettings { std::string show; bool showpartLoad; bool showpartLoadCPUGPU; + std::string ramInfoMode; bool invertBatteryDisplay; bool disableScreenshots; bool sleepExit; @@ -1343,6 +1353,7 @@ struct MicroSettings { uint16_t textColor; std::string show; bool showpartLoad; + std::string ramInfoMode; bool setPosBottom; bool disableScreenshots; bool sleepExit; @@ -1430,6 +1441,7 @@ ALWAYS_INLINE void GetConfigSettings(MiniSettings* settings) { settings->show = "DTC+BAT+CPU+GPU+RAM+TMP+FPS+RES"; settings->showpartLoad = true; settings->showpartLoadCPUGPU = false; + settings->ramInfoMode = "LOAD"; settings->invertBatteryDisplay = true; settings->refreshRate = 1; settings->disableScreenshots = false; @@ -1639,6 +1651,12 @@ ALWAYS_INLINE void GetConfigSettings(MiniSettings* settings) { settings->showpartLoadCPUGPU = (key != "FALSE"); } + // Process RAM info mode + it = section.find("ram_info_mode"); + if (it != section.end()) { + settings->ramInfoMode = it->second; + } + // Invert the battery display value it = section.find("invert_battery_display"); if (it != section.end()) { @@ -1727,6 +1745,7 @@ ALWAYS_INLINE void GetConfigSettings(MicroSettings* settings) { convertStrToRGBA4444("#FFFF", &(settings->textColor)); settings->show = "FPS+CPU+GPU+RAM+SOC+BAT+DTC"; settings->showpartLoad = true; + settings->ramInfoMode = "LOAD"; settings->setPosBottom = false; settings->disableScreenshots = false; settings->sleepExit = false; @@ -1926,6 +1945,12 @@ ALWAYS_INLINE void GetConfigSettings(MicroSettings* settings) { settings->showpartLoad = (key != "FALSE"); } + // Process RAM info mode + it = section.find("ram_info_mode"); + if (it != section.end()) { + settings->ramInfoMode = it->second; + } + // Process show string it = section.find("show"); if (it != section.end()) { @@ -2257,6 +2282,7 @@ ALWAYS_INLINE void GetConfigSettings(FullSettings* settings) { settings->showFPS = true; settings->showRES = true; settings->showRDSD = true; + settings->ramInfoMode = "LOAD"; settings->useDynamicColors = true; settings->disableScreenshots = false; convertStrToRGBA4444("#888F", &(settings->separatorColor)); @@ -2352,6 +2378,11 @@ ALWAYS_INLINE void GetConfigSettings(FullSettings* settings) { settings->showRDSD = !(key == "FALSE"); } + it = section.find("ram_info_mode"); + if (it != section.end()) { + settings->ramInfoMode = it->second; + } + it = section.find("use_dynamic_colors"); if (it != section.end()) { key = it->second; diff --git a/Source/Horizon-OC-Monitor/source/modes/Configurator.hpp b/Source/Horizon-OC-Monitor/source/modes/Configurator.hpp index 95894bbd..f5328cea 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Configurator.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Configurator.hpp @@ -377,6 +377,21 @@ public: }); list->addItem(showRDSD); + { + const std::string curRamInfoMode = getCurrentRamInfoMode("full"); + auto* ramInfoModeItem = new tsl::elm::ListItem("RAM Info Mode"); + ramInfoModeItem->setValue(curRamInfoMode); + ramInfoModeItem->setClickListener([this, ramInfoModeItem](u64 keys) -> bool { + if (!(keys & KEY_A)) return false; + const std::string cur = ult::parseValueFromIniSection(configIniPath, "full", "ram_info_mode"); + const std::string next = cur == "Bandwidth" ? "Load" : "Bandwidth"; + ult::setIniFileValue(configIniPath, "full", "ram_info_mode", next); + ramInfoModeItem->setValue(next); + return true; + }); + list->addItem(ramInfoModeItem); + } + auto* dynamicColors = new tsl::elm::ToggleListItem("Use Dynamic Colors", getCurrentUseDynamicColors()); dynamicColors->setStateChangedListener([this](bool state) { ult::setIniFileValue(configIniPath, "fps-graph", "use_dynamic_colors", state ? "true" : "false"); @@ -449,6 +464,21 @@ public: list->addItem(partLoadCPUGPU); } + if (isMiniMode || isMicroMode) { + const std::string curRamInfoMode = getCurrentRamInfoMode(section); + auto* ramInfoModeItem = new tsl::elm::ListItem("RAM Info Mode"); + ramInfoModeItem->setValue(curRamInfoMode); + ramInfoModeItem->setClickListener([this, section, ramInfoModeItem](u64 keys) -> bool { + if (!(keys & KEY_A)) return false; + const std::string cur = ult::parseValueFromIniSection(configIniPath, section, "ram_info_mode"); + const std::string next = cur == "Bandwidth" ? "Load" : "Bandwidth"; + ult::setIniFileValue(configIniPath, section, "ram_info_mode", next); + ramInfoModeItem->setValue(next); + return true; + }); + list->addItem(ramInfoModeItem); + } + if (isMiniMode || isMicroMode) { auto* invertBatteryDisplay = new tsl::elm::ToggleListItem("Invert Battery Display", getCurrentInvertBatteryDisplay()); invertBatteryDisplay->setStateChangedListener([this, section](bool state) { @@ -616,6 +646,11 @@ private: return value != "FALSE"; } + std::string getCurrentRamInfoMode(const std::string& section) { + const std::string value = ult::parseValueFromIniSection(configIniPath, section, "ram_info_mode"); + return (value == "Bandwidth") ? "Bandwidth" : "Load"; + } + bool getCurrentInvertBatteryDisplay() { const std::string section = isMiniMode ? "mini" : "micro"; std::string value = ult::parseValueFromIniSection(configIniPath, section, "invert_battery_display"); diff --git a/Source/Horizon-OC-Monitor/source/modes/Full.hpp b/Source/Horizon-OC-Monitor/source/modes/Full.hpp index 567c2173..66c23b7a 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Full.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Full.hpp @@ -26,6 +26,7 @@ private: char BatteryDraw_c[64] = ""; char FPS_var_compressed_c[64] = ""; char RAM_load_c[64] = ""; + char RAM_load2_c[64] = ""; char Resolutions_c[64] = ""; char readSpeed_c[32] = ""; @@ -237,17 +238,24 @@ public: renderer->drawString(DeltaRAM_c, false, COMMON_MARGIN + deltaOffset, height_offset, 15, (settings.textColor)); } if (R_SUCCEEDED(hocclkCheck)) { - static std::vector partLoadColoredChars = {"CPU", "GPU"}; - //static auto loadLabelWidth = renderer->getTextDimensions("Load: ", false, 15).first; - renderer->drawString("Load", false, COMMON_MARGIN, height_offset+15, 15, (settings.catColor2)); - renderer->drawStringWithColoredSections(RAM_load_c, false, partLoadColoredChars, COMMON_MARGIN + valueOffset, height_offset+15, 15, (settings.textColor), settings.catColor2); + if (settings.ramInfoMode == "Bandwidth") { + static std::vector bwTotalColoredChars = {"Total", "Peak"}; + static std::vector bwCpuColoredChars = {"CPU", "GPU"}; + renderer->drawStringWithColoredSections(RAM_load_c, false, bwTotalColoredChars, COMMON_MARGIN, height_offset+15, 15, (settings.textColor), settings.catColor2); + renderer->drawStringWithColoredSections(RAM_load2_c, false, bwCpuColoredChars, COMMON_MARGIN, height_offset+30, 15, (settings.textColor), settings.catColor2); + } else { + static std::vector partLoadColoredChars = {"CPU", "GPU"}; + renderer->drawString("Load", false, COMMON_MARGIN, height_offset+15, 15, (settings.catColor2)); + renderer->drawStringWithColoredSections(RAM_load_c, false, partLoadColoredChars, COMMON_MARGIN + valueOffset, height_offset+15, 15, (settings.textColor), settings.catColor2); + } } } if (R_SUCCEEDED(Hinted)) { + const uint32_t ramUsageOffset = (R_SUCCEEDED(hocclkCheck) && settings.ramInfoMode == "Bandwidth") ? height_offset + 50 : height_offset + 40; //static auto textWidth = renderer->getTextDimensions("Total \nApplication \nApplet \nSystem \nSystem Unsafe ", false, 15).first; - renderer->drawString("Total\nApplication\nApplet\nSystem\nSystem Unsafe", false, COMMON_MARGIN, height_offset + 40, 15, (settings.catColor2)); - renderer->drawString(RAM_var_compressed_c, false, COMMON_MARGIN + valueOffset, height_offset + 40, 15, (settings.textColor)); - renderer->drawString(RAM_percentage_var_compressed_c, false, ramPercentageOffset, height_offset + 40, 15, (settings.textColor)); + renderer->drawString("Total\nApplication\nApplet\nSystem\nSystem Unsafe", false, COMMON_MARGIN, ramUsageOffset, 15, (settings.catColor2)); + renderer->drawString(RAM_var_compressed_c, false, COMMON_MARGIN + valueOffset, ramUsageOffset, 15, (settings.textColor)); + renderer->drawString(RAM_percentage_var_compressed_c, false, ramPercentageOffset, ramUsageOffset, 15, (settings.textColor)); } } @@ -484,12 +492,29 @@ public: ); if (R_SUCCEEDED(hocclkCheck)) { - const int RAM_GPU_Load = partLoad[HocClkPartLoad_EMC] - partLoad[HocClkPartLoad_EMCCpu]; - snprintf(RAM_load_c, sizeof RAM_load_c, - "%u.%u%% CPU %u.%u%% GPU %u.%u%%", - partLoad[HocClkPartLoad_EMC] / 10, partLoad[HocClkPartLoad_EMC] % 10, - partLoad[HocClkPartLoad_EMCCpu] / 10, partLoad[HocClkPartLoad_EMCCpu] % 10, - RAM_GPU_Load / 10, RAM_GPU_Load % 10); + if (settings.ramInfoMode == "Bandwidth") { + const unsigned bwAll = partLoad[HocClkPartLoad_RamBWAll] / 1000; + const unsigned bwAllD = (partLoad[HocClkPartLoad_RamBWAll] % 1000) / 100; + const unsigned bwPeak = partLoad[HocClkPartLoad_RamBWPeak] / 1000; + const unsigned bwPeakD= (partLoad[HocClkPartLoad_RamBWPeak]% 1000) / 100; + const unsigned bwCpu = partLoad[HocClkPartLoad_RamBWCpu] / 1000; + const unsigned bwCpuD = (partLoad[HocClkPartLoad_RamBWCpu] % 1000) / 100; + const unsigned bwGpu = partLoad[HocClkPartLoad_RamBWGpu] / 1000; + const unsigned bwGpuD = (partLoad[HocClkPartLoad_RamBWGpu] % 1000) / 100; + snprintf(RAM_load_c, sizeof RAM_load_c, + "Total %u.%u GB/s Peak %u.%u GB/s", + bwAll, bwAllD, bwPeak, bwPeakD); + snprintf(RAM_load2_c, sizeof RAM_load2_c, + "CPU %u.%u GB/s GPU %u.%u GB/s", + bwCpu, bwCpuD, bwGpu, bwGpuD); + } else { + const int RAM_GPU_Load = partLoad[HocClkPartLoad_EMC] - partLoad[HocClkPartLoad_EMCCpu]; + snprintf(RAM_load_c, sizeof RAM_load_c, + "%u.%u%% CPU %u.%u%% GPU %u.%u%%", + partLoad[HocClkPartLoad_EMC] / 10, partLoad[HocClkPartLoad_EMC] % 10, + partLoad[HocClkPartLoad_EMCCpu] / 10, partLoad[HocClkPartLoad_EMCCpu] % 10, + RAM_GPU_Load / 10, RAM_GPU_Load % 10); + } } ///Thermal snprintf(SOC_temperature_c, sizeof SOC_temperature_c, "%.1f\u00B0C", SOC_temperatureF); diff --git a/Source/Horizon-OC-Monitor/source/modes/Micro.hpp b/Source/Horizon-OC-Monitor/source/modes/Micro.hpp index 62509a8b..f068a359 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Micro.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Micro.hpp @@ -955,6 +955,11 @@ public: const float RAM_Total_all_f = (RAM_Total_application_u + RAM_Total_applet_u + RAM_Total_system_u + RAM_Total_systemunsafe_u) / (1024.0f * 1024.0f * 1024.0f); const float RAM_Used_all_f = (RAM_Used_application_u + RAM_Used_applet_u + RAM_Used_system_u + RAM_Used_systemunsafe_u) / (1024.0f * 1024.0f * 1024.0f); snprintf(MICRO_RAM_all_c, sizeof(MICRO_RAM_all_c), "%.0f%.0fGB", RAM_Used_all_f, RAM_Total_all_f); + } else if (settings.ramInfoMode == "Bandwidth" && R_SUCCEEDED(hocclkCheck)) { + // Bandwidth mode: show GB/s from context (partLoad values are in MB/s) + const unsigned bwAll = partLoad[HocClkPartLoad_RamBWAll] / 1000; + const unsigned bwAllD = (partLoad[HocClkPartLoad_RamBWAll] % 1000) / 100; + snprintf(MICRO_RAM_all_c, sizeof(MICRO_RAM_all_c), "%u.%uG", bwAll, bwAllD); } else { // User wants percentage display if (R_SUCCEEDED(hocclkCheck)) { diff --git a/Source/Horizon-OC-Monitor/source/modes/Mini.hpp b/Source/Horizon-OC-Monitor/source/modes/Mini.hpp index 91866590..80c74d4c 100644 --- a/Source/Horizon-OC-Monitor/source/modes/Mini.hpp +++ b/Source/Horizon-OC-Monitor/source/modes/Mini.hpp @@ -364,6 +364,30 @@ public: if (settings.realTemps) { width += renderer->getTextDimensions(" 888.8°C", false, fontsize).first; } + } else if (key == "RAM" && settings.ramInfoMode == "Bandwidth" && R_SUCCEEDED(hocclkCheck)) { + width = renderer->getTextDimensions("99.9GB/s@4444.4", false, fontsize).first; + if (settings.realVolts) { + if (isMariko) { + if (settings.showVDD2 && settings.decimalVDD2 && settings.showVDDQ) + width += renderer->getTextDimensions("4444.4444 mV4444 mV", false, fontsize).first; + else if (settings.showVDD2 && !settings.decimalVDD2 && settings.showVDDQ) + width += renderer->getTextDimensions("4444 mV4444 mV", false, fontsize).first; + else if (settings.showVDD2 && settings.decimalVDD2) + width += renderer->getTextDimensions("4444.4444 mV", false, fontsize).first; + else if (settings.showVDD2 && !settings.decimalVDD2) + width += renderer->getTextDimensions("4444 mV", false, fontsize).first; + else if (settings.showVDDQ) + width += renderer->getTextDimensions("4444 mV", false, fontsize).first; + } else { + if (settings.decimalVDD2) + width += renderer->getTextDimensions("4444.4444 mV", false, fontsize).first; + else + width += renderer->getTextDimensions("4444 mV", false, fontsize).first; + } + } + if (settings.realTemps) { + width += renderer->getTextDimensions(" 88.8°C", false, fontsize).first; + } } else if (key == "GPU" || (key == "RAM" && settings.showpartLoad && R_SUCCEEDED(hocclkCheck))) { //dimensions = renderer->drawString("100.0%@4444.4", false, 0, 0, fontsize, renderer->a(0x0000)); @@ -1142,53 +1166,64 @@ public: RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); } } else { - unsigned partLoadInt; - - if (R_SUCCEEDED(hocclkCheck)) { - partLoadInt = partLoad[HocClkPartLoad_EMC] / 10; - - if (settings.showpartLoadCPUGPU) { - unsigned ramCpuLoadInt = partLoad[HocClkPartLoad_EMCCpu] / 10; - int RAM_GPU_Load = partLoad[HocClkPartLoad_EMC] - partLoad[HocClkPartLoad_EMCCpu]; - unsigned ramGpuLoadInt = RAM_GPU_Load / 10; - - if (settings.realFrequencies && realRAM_Hz) { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%[%u%%,%u%%]@%hu.%hhu", - partLoadInt, ramCpuLoadInt, ramGpuLoadInt, - realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); - } else { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%[%u%%,%u%%]@%hu.%hhu", - partLoadInt, ramCpuLoadInt, ramGpuLoadInt, - RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); - } - } else { - if (settings.realFrequencies && realRAM_Hz) { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%@%hu.%hhu", partLoadInt, - realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); - } else { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%@%hu.%hhu", partLoadInt, - RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); - } - } + if (settings.ramInfoMode == "Bandwidth" && R_SUCCEEDED(hocclkCheck)) { + // Bandwidth mode: show GB/s from context (partLoad values are in MB/s) + const uint32_t ramFreq = settings.realFrequencies && realRAM_Hz ? realRAM_Hz : RAM_Hz; + const unsigned bwAll = partLoad[HocClkPartLoad_RamBWAll] / 1000; + const unsigned bwAllD = (partLoad[HocClkPartLoad_RamBWAll] % 1000) / 100; + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u.%uGB/s@%hu.%hhu", + bwAll, bwAllD, + ramFreq / 1000000, (ramFreq / 100000) % 10); } else { - const uint64_t RAM_Total_all = RAM_Total_application_u + RAM_Total_applet_u + - RAM_Total_system_u + RAM_Total_systemunsafe_u; - const uint64_t RAM_Used_all = RAM_Used_application_u + RAM_Used_applet_u + - RAM_Used_system_u + RAM_Used_systemunsafe_u; - partLoadInt = (RAM_Total_all > 0) ? (unsigned)((RAM_Used_all * 100) / RAM_Total_all) : 0; + unsigned partLoadInt; - if (settings.realFrequencies && realRAM_Hz) { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%@%hu.%hhu", partLoadInt, - realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); + if (R_SUCCEEDED(hocclkCheck)) { + partLoadInt = partLoad[HocClkPartLoad_EMC] / 10; + + if (settings.showpartLoadCPUGPU) { + unsigned ramCpuLoadInt = partLoad[HocClkPartLoad_EMCCpu] / 10; + int RAM_GPU_Load = partLoad[HocClkPartLoad_EMC] - partLoad[HocClkPartLoad_EMCCpu]; + unsigned ramGpuLoadInt = RAM_GPU_Load / 10; + + if (settings.realFrequencies && realRAM_Hz) { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%[%u%%,%u%%]@%hu.%hhu", + partLoadInt, ramCpuLoadInt, ramGpuLoadInt, + realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); + } else { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%[%u%%,%u%%]@%hu.%hhu", + partLoadInt, ramCpuLoadInt, ramGpuLoadInt, + RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); + } + } else { + if (settings.realFrequencies && realRAM_Hz) { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%@%hu.%hhu", partLoadInt, + realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); + } else { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%@%hu.%hhu", partLoadInt, + RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); + } + } } else { - snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), - "%u%%@%hu.%hhu", partLoadInt, - RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); + const uint64_t RAM_Total_all = RAM_Total_application_u + RAM_Total_applet_u + + RAM_Total_system_u + RAM_Total_systemunsafe_u; + const uint64_t RAM_Used_all = RAM_Used_application_u + RAM_Used_applet_u + + RAM_Used_system_u + RAM_Used_systemunsafe_u; + partLoadInt = (RAM_Total_all > 0) ? (unsigned)((RAM_Used_all * 100) / RAM_Total_all) : 0; + + if (settings.realFrequencies && realRAM_Hz) { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%@%hu.%hhu", partLoadInt, + realRAM_Hz / 1000000, (realRAM_Hz / 100000) % 10); + } else { + snprintf(MINI_RAM_var_compressed_c, sizeof(MINI_RAM_var_compressed_c), + "%u%%@%hu.%hhu", partLoadInt, + RAM_Hz / 1000000, (RAM_Hz / 100000) % 10); + } } } }