From 9280340fe029a23c170189dacdf9b2c734e9dfdd Mon Sep 17 00:00:00 2001 From: David Guillen Fandos Date: Wed, 12 May 2021 02:16:25 +0200 Subject: [PATCH] CPU governor/frequency part 2 This adds managed policies and settings to store them and reload them at startup. Only for Lakka builds! --- configuration.c | 10 ++ configuration.h | 8 ++ intl/msg_hash_us.h | 68 ++++++++++++ menu/cbs/menu_cbs_get_value.c | 90 ++++++++++++++++ menu/cbs/menu_cbs_left.c | 87 ++++++++++++++++ menu/cbs/menu_cbs_right.c | 89 +++++++++++++++- menu/cbs/menu_cbs_sublabel.c | 20 +++- menu/menu_displaylist.c | 65 ++++++++++-- menu/menu_driver.h | 2 + misc/cpufreq/cpufreq.c | 189 +++++++++++++++++++++++++++++++--- misc/cpufreq/cpufreq.h | 46 ++++++++- msg_hash.h | 19 ++++ retroarch.c | 24 +++++ 13 files changed, 691 insertions(+), 26 deletions(-) diff --git a/configuration.c b/configuration.c index ef622c9c9c..36f71d72ca 100644 --- a/configuration.c +++ b/configuration.c @@ -1279,6 +1279,10 @@ static struct config_array_setting *populate_settings_array(settings_t *settings SETTING_ARRAY("discord_app_id", settings->arrays.discord_app_id, true, DEFAULT_DISCORD_APP_ID, true); SETTING_ARRAY("ai_service_url", settings->arrays.ai_service_url, true, DEFAULT_AI_SERVICE_URL, true); SETTING_ARRAY("crt_switch_timings", settings->arrays.crt_switch_timings, false, NULL, true); +#ifdef HAVE_LAKKA + SETTING_ARRAY("cpu_main_gov", settings->arrays.cpu_main_gov, false, NULL, true); + SETTING_ARRAY("cpu_menu_gov", settings->arrays.cpu_menu_gov, false, NULL, true); +#endif *size = count; @@ -2113,6 +2117,12 @@ static struct config_uint_setting *populate_settings_uint( SETTING_UINT("video_black_frame_insertion", &settings->uints.video_black_frame_insertion, true, DEFAULT_BLACK_FRAME_INSERTION, false); +#ifdef HAVE_LAKKA + SETTING_UINT("cpu_scaling_mode", &settings->uints.cpu_scaling_mode, true, 0, false); + SETTING_UINT("cpu_min_freq", &settings->uints.cpu_min_freq, true, 1, false); + SETTING_UINT("cpu_max_freq", &settings->uints.cpu_max_freq, true, ~0U, false); +#endif + *size = count; return tmp; diff --git a/configuration.h b/configuration.h index 3dcdf9a8ee..055b787ebd 100644 --- a/configuration.h +++ b/configuration.h @@ -288,6 +288,12 @@ typedef struct settings unsigned core_updater_auto_backup_history_size; unsigned video_black_frame_insertion; unsigned quit_on_close_content; + +#ifdef HAVE_LAKKA + unsigned cpu_scaling_mode; + unsigned cpu_min_freq; + unsigned cpu_max_freq; +#endif } uints; struct @@ -387,6 +393,8 @@ typedef struct settings char crt_switch_timings[255]; #ifdef HAVE_LAKKA char timezone[TIMEZONE_LENGTH]; + char cpu_main_gov[32]; + char cpu_menu_gov[32]; #endif } arrays; diff --git a/intl/msg_hash_us.h b/intl/msg_hash_us.h index 50f84e7af5..4856e6b048 100644 --- a/intl/msg_hash_us.h +++ b/intl/msg_hash_us.h @@ -12092,6 +12092,58 @@ MSG_HASH( MENU_ENUM_LABEL_VALUE_CPU_POLICY_ENTRY, "Policy" ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE, + "Governing Mode" + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANUAL, + "Manual" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANUAL, + "Allows to manually tweak every detail in every CPU: governor, frequencies, etc. Only recommended for advanced users." + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF, + "Performance (Managed)" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF, + "Default and recommended mode. Maximum performance while playing while saving power when paused or browsing menus." + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANAGED_PER_CONTEXT, + "Custom Managed" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANAGED_PER_CONTEXT, + "Allows to choose what governors to use in menus and during gameplay. Performance, Ondemand or Schedutil are recommended during gameplay." + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MAX_PERF, + "Maximum Performance" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MAX_PERF, + "Always maximum performance: highest frequencies for best experience." + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MIN_POWER, + "Minimum Power" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MIN_POWER, + "Use the lowest frequency available to save power. Useful on battery powered devices but performance will be significantly reduced." + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_BALANCED, + "Balanced" + ) +MSG_HASH( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_BALANCED, + "Adapts to the current workload. Works well with most devices and emulators and helps saving power. Demanding games and cores might suffer a performance drop on some devices." + ) MSG_HASH( MENU_ENUM_LABEL_VALUE_CPU_POLICY_MIN_FREQ, "Minimum Frequency" @@ -12100,10 +12152,26 @@ MSG_HASH( MENU_ENUM_LABEL_VALUE_CPU_POLICY_MAX_FREQ, "Maximum Frequency" ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_MANAGED_MIN_FREQ, + "Minimum Core Frequency" + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_MANAGED_MAX_FREQ, + "Maximum Core Frequency" + ) MSG_HASH( MENU_ENUM_LABEL_VALUE_CPU_POLICY_GOVERNOR, "CPU Governor" ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_POLICY_CORE_GOVERNOR, + "Core Governor" + ) +MSG_HASH( + MENU_ENUM_LABEL_VALUE_CPU_POLICY_MENU_GOVERNOR, + "Menu Governor" + ) MSG_HASH( MENU_ENUM_LABEL_VALUE_PAL60_ENABLE, "Use PAL60 Mode" diff --git a/menu/cbs/menu_cbs_get_value.c b/menu/cbs/menu_cbs_get_value.c index f2a2ca9db7..f5befe000c 100644 --- a/menu/cbs/menu_cbs_get_value.c +++ b/menu/cbs/menu_cbs_get_value.c @@ -518,6 +518,50 @@ static void menu_action_setting_disp_set_label_core_manager_entry( #ifndef HAVE_LAKKA_SWITCH #ifdef HAVE_LAKKA +static void menu_action_setting_disp_cpu_gov_mode( + file_list_t* list, + unsigned *w, unsigned type, unsigned i, + const char *label, + char *s, size_t len, + const char *path, + char *s2, size_t len2) +{ + const char *alt = list->list[i].alt + ? list->list[i].alt + : list->list[i].path; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(NULL); + + if (alt) + strlcpy(s2, alt, len2); + + strlcpy(s, msg_hash_to_str( + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF + (int)mode), len); +} + +static void menu_action_setting_disp_cpu_gov_choose( + file_list_t* list, + unsigned *w, unsigned type, unsigned i, + const char *label, + char *s, size_t len, + const char *path, + char *s2, size_t len2) +{ + const char *alt = list->list[i].alt + ? list->list[i].alt + : list->list[i].path; + int fnum = atoi(list->list[i].label); + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + + if (alt) + strlcpy(s2, alt, len2); + + if (!fnum) + strlcpy(s, opts.main_policy, len); + else + strlcpy(s, opts.menu_policy, len); +} + static void menu_action_setting_disp_set_label_cpu_policy( file_list_t* list, unsigned *w, unsigned type, unsigned i, @@ -542,6 +586,39 @@ static void menu_action_setting_disp_set_label_cpu_policy( MENU_ENUM_LABEL_VALUE_CPU_POLICY_ENTRY), policyid); } +static void menu_action_cpu_managed_freq_label( + file_list_t* list, + unsigned *w, unsigned type, unsigned i, + const char *label, + char *s, size_t len, + const char *path, + char *s2, size_t len2) +{ + uint32_t freq = 0; + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + + switch (type) { + case MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ: + strlcpy(s2, msg_hash_to_str( + MENU_ENUM_LABEL_VALUE_CPU_MANAGED_MIN_FREQ), len2); + freq = opts.min_freq; + break; + case MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ: + strlcpy(s2, msg_hash_to_str( + MENU_ENUM_LABEL_VALUE_CPU_MANAGED_MAX_FREQ), len2); + freq = opts.max_freq; + break; + }; + + if (freq == 1) + strlcpy(s, "Min.", len); + else if (freq == ~0U) + strlcpy(s, "Max.", len); + else + snprintf(s, len, "%u MHz", freq / 1000); +} + static void menu_action_cpu_freq_label( file_list_t* list, unsigned *w, unsigned type, unsigned i, @@ -1786,6 +1863,15 @@ static int menu_cbs_init_bind_get_string_representation_compare_label( break; #ifndef HAVE_LAKKA_SWITCH #ifdef HAVE_LAKKA + case MENU_ENUM_LABEL_CPU_PERF_MODE: + BIND_ACTION_GET_VALUE(cbs, + menu_action_setting_disp_cpu_gov_mode); + break; + case MENU_ENUM_LABEL_CPU_POLICY_CORE_GOVERNOR: + case MENU_ENUM_LABEL_CPU_POLICY_MENU_GOVERNOR: + BIND_ACTION_GET_VALUE(cbs, + menu_action_setting_disp_cpu_gov_choose); + break; case MENU_ENUM_LABEL_CPU_POLICY_ENTRY: BIND_ACTION_GET_VALUE(cbs, menu_action_setting_disp_set_label_cpu_policy); @@ -1794,6 +1880,10 @@ static int menu_cbs_init_bind_get_string_representation_compare_label( case MENU_ENUM_LABEL_CPU_POLICY_MAX_FREQ: BIND_ACTION_GET_VALUE(cbs, menu_action_cpu_freq_label); break; + case MENU_ENUM_LABEL_CPU_MANAGED_MIN_FREQ: + case MENU_ENUM_LABEL_CPU_MANAGED_MAX_FREQ: + BIND_ACTION_GET_VALUE(cbs, menu_action_cpu_managed_freq_label); + break; case MENU_ENUM_LABEL_CPU_POLICY_GOVERNOR: BIND_ACTION_GET_VALUE(cbs, menu_action_cpu_governor_label); break; diff --git a/menu/cbs/menu_cbs_left.c b/menu/cbs/menu_cbs_left.c index bbe62cc687..66a85c1990 100644 --- a/menu/cbs/menu_cbs_left.c +++ b/menu/cbs/menu_cbs_left.c @@ -672,6 +672,82 @@ static int manual_content_scan_core_name_left(unsigned type, const char *label, } #ifdef HAVE_LAKKA +static int cpu_policy_mode_change(unsigned type, const char *label, + bool wraparound) +{ + bool refresh = false; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(NULL); + if (mode != CPUSCALING_MANAGED_PERFORMANCE) + mode--; + set_cpu_scaling_mode(mode, NULL); + menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh); + return 0; +} + +static int cpu_policy_freq_managed_tweak(unsigned type, const char *label, + bool wraparound) +{ + bool refresh = false; + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + + switch (type) { + case MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ: + opts.min_freq = get_cpu_scaling_next_frequency_limit( + opts.min_freq, -1); + set_cpu_scaling_mode(mode, &opts); + break; + case MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ: + opts.max_freq = get_cpu_scaling_next_frequency_limit( + opts.max_freq, -1); + set_cpu_scaling_mode(mode, &opts); + break; + }; + + return 0; +} + +static int cpu_policy_freq_managed_gov(unsigned type, const char *label, + bool wraparound) +{ + int pidx; + bool refresh = false; + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false); + + /* Using drivers[0] governors, should be improved */ + if (!drivers || !drivers[0]) + return -1; + + switch (atoi(label)) { + case 0: + pidx = string_list_find_elem(drivers[0]->available_governors, + opts.main_policy); + if (pidx > 1) + { + strlcpy(opts.main_policy, + drivers[0]->available_governors->elems[pidx-2].data, + sizeof(opts.main_policy)); + set_cpu_scaling_mode(mode, &opts); + } + break; + case 1: + pidx = string_list_find_elem(drivers[0]->available_governors, + opts.menu_policy); + if (pidx > 1) + { + strlcpy(opts.menu_policy, + drivers[0]->available_governors->elems[pidx-2].data, + sizeof(opts.menu_policy)); + set_cpu_scaling_mode(mode, &opts); + } + break; + }; + + return 0; +} + static int cpu_policy_freq_tweak(unsigned type, const char *label, bool wraparound) { @@ -1012,11 +1088,22 @@ static int menu_cbs_init_bind_left_compare_label(menu_file_list_cbs_t *cbs, break; #ifndef HAVE_LAKKA_SWITCH #ifdef HAVE_LAKKA + case MENU_ENUM_LABEL_CPU_PERF_MODE: + BIND_ACTION_LEFT(cbs, cpu_policy_mode_change); + break; case MENU_ENUM_LABEL_CPU_POLICY_MAX_FREQ: case MENU_ENUM_LABEL_CPU_POLICY_MIN_FREQ: case MENU_ENUM_LABEL_CPU_POLICY_GOVERNOR: BIND_ACTION_LEFT(cbs, cpu_policy_freq_tweak); break; + case MENU_ENUM_LABEL_CPU_MANAGED_MIN_FREQ: + case MENU_ENUM_LABEL_CPU_MANAGED_MAX_FREQ: + BIND_ACTION_LEFT(cbs, cpu_policy_freq_managed_tweak); + break; + case MENU_ENUM_LABEL_CPU_POLICY_CORE_GOVERNOR: + case MENU_ENUM_LABEL_CPU_POLICY_MENU_GOVERNOR: + BIND_ACTION_LEFT(cbs, cpu_policy_freq_managed_gov); + break; #endif #endif default: diff --git a/menu/cbs/menu_cbs_right.c b/menu/cbs/menu_cbs_right.c index 728c270ff0..aa68f6f863 100644 --- a/menu/cbs/menu_cbs_right.c +++ b/menu/cbs/menu_cbs_right.c @@ -789,8 +789,84 @@ static int manual_content_scan_core_name_right(unsigned type, const char *label, return 0; } -#ifdef HAVE_LAKKA_SWITCH +#ifndef HAVE_LAKKA_SWITCH #ifdef HAVE_LAKKA +static int cpu_policy_mode_change(unsigned type, const char *label, + bool wraparound) +{ + bool refresh = false; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(NULL); + if (mode != CPUSCALING_MANUAL) + mode++; + set_cpu_scaling_mode(mode, NULL); + menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh); + return 0; +} + +static int cpu_policy_freq_managed_tweak(unsigned type, const char *label, + bool wraparound) +{ + bool refresh = false; + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + + switch (type) { + case MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ: + opts.min_freq = get_cpu_scaling_next_frequency_limit( + opts.min_freq, 1); + set_cpu_scaling_mode(mode, &opts); + break; + case MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ: + opts.max_freq = get_cpu_scaling_next_frequency_limit( + opts.max_freq, 1); + set_cpu_scaling_mode(mode, &opts); + break; + }; + + return 0; +} + +static int cpu_policy_freq_managed_gov(unsigned type, const char *label, + bool wraparound) +{ + int pidx; + bool refresh = false; + cpu_scaling_opts_t opts; + enum cpu_scaling_mode mode = get_cpu_scaling_mode(&opts); + cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false); + + /* Using drivers[0] governors, should be improved */ + if (!drivers || !drivers[0]) + return -1; + + switch (atoi(label)) { + case 0: + pidx = string_list_find_elem(drivers[0]->available_governors, + opts.main_policy); + if (pidx && pidx + 1 < drivers[0]->available_governors->size) + { + strlcpy(opts.main_policy, + drivers[0]->available_governors->elems[pidx].data, + sizeof(opts.main_policy)); + set_cpu_scaling_mode(mode, &opts); + } + break; + case 1: + pidx = string_list_find_elem(drivers[0]->available_governors, + opts.menu_policy); + if (pidx && pidx + 1 < drivers[0]->available_governors->size) + { + strlcpy(opts.menu_policy, + drivers[0]->available_governors->elems[pidx].data, + sizeof(opts.menu_policy)); + set_cpu_scaling_mode(mode, &opts); + } + break; + }; + + return 0; +} + static int cpu_policy_freq_tweak(unsigned type, const char *label, bool wraparound) { @@ -1132,11 +1208,22 @@ static int menu_cbs_init_bind_right_compare_label(menu_file_list_cbs_t *cbs, break; #ifndef HAVE_LAKKA_SWITCH #ifdef HAVE_LAKKA + case MENU_ENUM_LABEL_CPU_PERF_MODE: + BIND_ACTION_RIGHT(cbs, cpu_policy_mode_change); + break; case MENU_ENUM_LABEL_CPU_POLICY_MAX_FREQ: case MENU_ENUM_LABEL_CPU_POLICY_MIN_FREQ: case MENU_ENUM_LABEL_CPU_POLICY_GOVERNOR: BIND_ACTION_RIGHT(cbs, cpu_policy_freq_tweak); break; + case MENU_ENUM_LABEL_CPU_MANAGED_MIN_FREQ: + case MENU_ENUM_LABEL_CPU_MANAGED_MAX_FREQ: + BIND_ACTION_RIGHT(cbs, cpu_policy_freq_managed_tweak); + break; + case MENU_ENUM_LABEL_CPU_POLICY_CORE_GOVERNOR: + case MENU_ENUM_LABEL_CPU_POLICY_MENU_GOVERNOR: + BIND_ACTION_RIGHT(cbs, cpu_policy_freq_managed_gov); + break; #endif #endif default: diff --git a/menu/cbs/menu_cbs_sublabel.c b/menu/cbs/menu_cbs_sublabel.c index 3c2851a4c1..00fbe1ec4f 100644 --- a/menu/cbs/menu_cbs_sublabel.c +++ b/menu/cbs/menu_cbs_sublabel.c @@ -1020,15 +1020,28 @@ static int action_bind_sublabel_cpu_policy_entry_list( { /* Displays info about the Policy entry */ cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false); + int idx = atoi(path); if (drivers) { - sprintf(s, "%s | Freq: %u MHz\n", drivers[i]->scaling_governor, - drivers[i]->current_frequency / 1000); + sprintf(s, "%s | Freq: %u MHz\n", drivers[idx]->scaling_governor, + drivers[idx]->current_frequency / 1000); return 0; } return -1; } +static int action_bind_sublabel_cpu_perf_mode( + file_list_t *list, + unsigned type, unsigned i, + const char *label, const char *path, + char *s, size_t len) +{ + /* Displays info about the mode selected */ + enum cpu_scaling_mode mode = get_cpu_scaling_mode(NULL); + strlcpy(s, msg_hash_to_str( + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF + (int)mode), len); + return 0; +} #endif #endif #ifdef HAVE_CHEEVOS @@ -3947,6 +3960,9 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs, case MENU_ENUM_LABEL_CPU_POLICY_ENTRY: BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_cpu_policy_entry_list); break; + case MENU_ENUM_LABEL_CPU_PERF_MODE: + BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_cpu_perf_mode); + break; #endif #endif case MENU_ENUM_LABEL_USER_LANGUAGE: diff --git a/menu/menu_displaylist.c b/menu/menu_displaylist.c index 438a161d10..550d4ee99f 100644 --- a/menu/menu_displaylist.c +++ b/menu/menu_displaylist.c @@ -9869,17 +9869,66 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type, if (drivers) { int count = 0; - while (*drivers) + + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE), + msg_hash_to_str(MENU_ENUM_LABEL_CPU_PERF_MODE), + MENU_ENUM_LABEL_CPU_PERF_MODE, + 0, 0, 0); + + switch (get_cpu_scaling_mode(NULL)) { - char policyid[16]; - sprintf(policyid, "%u", count++); + case CPUSCALING_MANUAL: + while (*drivers) + { + char policyid[16]; + sprintf(policyid, "%u", count++); + menu_entries_append_enum(info->list, + policyid, + policyid, + MENU_ENUM_LABEL_CPU_POLICY_ENTRY, + 0, 0, 0); + drivers++; + } + break; + case CPUSCALING_MANAGED_PER_CONTEXT: + /* Allows user to pick two governors */ menu_entries_append_enum(info->list, - policyid, - policyid, - MENU_ENUM_LABEL_CPU_POLICY_ENTRY, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CPU_POLICY_CORE_GOVERNOR), + "0", + MENU_ENUM_LABEL_CPU_POLICY_CORE_GOVERNOR, 0, 0, 0); - drivers++; - } + + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CPU_POLICY_MENU_GOVERNOR), + "1", + MENU_ENUM_LABEL_CPU_POLICY_MENU_GOVERNOR, + 0, 0, 0); + + /* fallthrough */ + case CPUSCALING_MANAGED_PERFORMANCE: + /* Allow users to choose max/min frequencies */ + menu_entries_append_enum(info->list, + "0", + "0", + MENU_ENUM_LABEL_CPU_MANAGED_MIN_FREQ, + MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ, + 0, 0); + + menu_entries_append_enum(info->list, + "1", + "1", + MENU_ENUM_LABEL_CPU_MANAGED_MAX_FREQ, + MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ, + 0, 0); + + break; + case CPUSCALING_MAX_PERFORMANCE: + case CPUSCALING_MIN_POWER: + case CPUSCALING_BALANCED: + /* No settings for these modes */ + break; + }; } info->need_push = true; diff --git a/menu/menu_driver.h b/menu/menu_driver.h index 19eb03fca3..1cff563d30 100644 --- a/menu/menu_driver.h +++ b/menu/menu_driver.h @@ -214,6 +214,8 @@ enum menu_settings_type MENU_SETTINGS_CPU_POLICY_SET_MINFREQ, MENU_SETTINGS_CPU_POLICY_SET_MAXFREQ, MENU_SETTINGS_CPU_POLICY_SET_GOVERNOR, + MENU_SETTINGS_CPU_MANAGED_SET_MINFREQ, + MENU_SETTINGS_CPU_MANAGED_SET_MAXFREQ, MENU_SET_CDROM_LIST, MENU_SET_LOAD_CDROM_LIST, diff --git a/misc/cpufreq/cpufreq.c b/misc/cpufreq/cpufreq.c index 1fba52ed97..84e8280b9f 100644 --- a/misc/cpufreq/cpufreq.c +++ b/misc/cpufreq/cpufreq.c @@ -24,12 +24,18 @@ #include #include "cpufreq.h" +#include "../../configuration.h" #define REFRESH_TIMEOUT 2 #define CPU_POLICIES_DIR "/sys/devices/system/cpu/cpufreq/" static time_t last_update = 0; static cpu_scaling_driver_t **scaling_drivers = NULL; +/* Mode state and its options */ +static enum cpu_scaling_mode cur_smode = CPUSCALING_MANAGED_PERFORMANCE; +static cpu_scaling_opts_t cur_smode_opts = { 1, ~0U, "performance", "ondemand" }; +/* Precalculate and store the absolute max and min frequencies */ +static uint32_t abs_min_freq = 1, abs_max_freq = ~0U; static bool readparse_uint32(const char *path, uint32_t *value) { @@ -80,15 +86,6 @@ static void free_drivers(cpu_scaling_driver_t **d) } } -void cpu_scaling_driver_free() -{ - if (scaling_drivers) - free_drivers(scaling_drivers); - - scaling_drivers = NULL; - last_update = 0; -} - cpu_scaling_driver_t **get_cpu_scaling_drivers(bool can_update) { if (can_update && (time(NULL) > last_update + REFRESH_TIMEOUT || @@ -142,6 +139,12 @@ cpu_scaling_driver_t **get_cpu_scaling_drivers(bool can_update) "scaling_min_freq", sizeof(fpath)); readparse_uint32(fpath, &drv->min_policy_freq); + /* Check current freq limits and update them */ + if (abs_min_freq > drv->min_cpu_freq || abs_min_freq == 1) + abs_min_freq = drv->min_cpu_freq; + if (abs_max_freq < drv->max_cpu_freq || abs_max_freq == ~0U) + abs_max_freq = drv->max_cpu_freq; + fill_pathname_join(fpath, policy_dir->elems[i].data, "scaling_max_freq", sizeof(fpath)); readparse_uint32(fpath, &drv->max_policy_freq); @@ -160,6 +163,7 @@ cpu_scaling_driver_t **get_cpu_scaling_drivers(bool can_update) filestream_read_file(fpath, (void**)&drv->scaling_governor, NULL); string_remove_all_chars(drv->scaling_governor, '\n'); + /* This is not available in many platforms! */ fill_pathname_join(fpath, policy_dir->elems[i].data, "scaling_available_frequencies", sizeof(fpath)); tmplst = readparse_list(fpath); @@ -168,7 +172,12 @@ cpu_scaling_driver_t **get_cpu_scaling_drivers(bool can_update) drv->available_freqs = calloc(tmplst->size, sizeof(uint32_t)); for (j = 0; j < tmplst->size; j++) { - drv->available_freqs[j] = (uint32_t)atol(tmplst->elems[j].data); + uint32_t freq = (uint32_t)atol(tmplst->elems[j].data); + drv->available_freqs[j] = freq; + if (abs_min_freq > freq || abs_min_freq == 1) + abs_min_freq = freq; + if (abs_max_freq < freq || abs_max_freq == ~0U) + abs_max_freq = freq; } string_list_free(tmplst); } @@ -254,10 +263,30 @@ uint32_t get_cpu_scaling_next_frequency( freq = freq + step * 100000; } - if (freq > driver->max_cpu_freq) - freq = driver->max_cpu_freq; - if (freq < driver->min_cpu_freq) - freq = driver->min_cpu_freq; + freq = MIN(freq, driver->max_cpu_freq); + freq = MAX(freq, driver->min_cpu_freq); + + return freq; +} + +uint32_t get_cpu_scaling_next_frequency_limit(uint32_t freq, int step) +{ + /* Tune step, if it's smaller than 100MHz */ + unsigned fstep = 100000; + if ((abs_max_freq - abs_min_freq) / 20 < fstep) + fstep = 50000; + + if (freq <= abs_min_freq && step < 0) + return 1; /* Means "minimum frequency" */ + + if (freq >= abs_max_freq && step > 0) + return ~0U; /* Means "maximum frequency" */ + + /* Just do small steps towards the max/min */ + freq = freq + step * fstep; + + freq = MIN(freq, abs_max_freq); + freq = MAX(freq, abs_min_freq); return freq; } @@ -278,4 +307,136 @@ bool set_cpu_scaling_governor(cpu_scaling_driver_t *driver, const char* governor return false; } +static void steer_all_drivers( + const char *governor, + uint32_t minfreq, + uint32_t maxfreq) +{ + cpu_scaling_driver_t **drivers = get_cpu_scaling_drivers(false); + if (!drivers) + return; + while (*drivers) + { + cpu_scaling_driver_t *d = *drivers++; + if (minfreq) + set_cpu_scaling_min_frequency(d, MAX(minfreq, d->min_cpu_freq)); + if (maxfreq) + set_cpu_scaling_max_frequency(d, MIN(maxfreq, d->max_cpu_freq)); + set_cpu_scaling_governor(d, governor); + } +} + +void set_cpu_scaling_signal(enum cpu_scaling_event event) +{ + switch (cur_smode) { + case CPUSCALING_MANAGED_PERFORMANCE: + /* Bump to perf or fall back to ondemand depending on the RA state */ + if (event == CPUSCALING_EVENT_FOCUS_CORE) + steer_all_drivers("performance", cur_smode_opts.min_freq, + cur_smode_opts.max_freq); + else + steer_all_drivers("ondemand", 1, ~0U); + break; + case CPUSCALING_MANAGED_PER_CONTEXT: + /* Apply the right settings the user specified */ + if (event == CPUSCALING_EVENT_FOCUS_CORE) + steer_all_drivers(cur_smode_opts.main_policy, cur_smode_opts.min_freq, + cur_smode_opts.max_freq); + else + steer_all_drivers(cur_smode_opts.menu_policy, 1, ~0U); + break; + default: + break; + }; +} + +enum cpu_scaling_mode get_cpu_scaling_mode(cpu_scaling_opts_t *opts) +{ + if (opts) + *opts = cur_smode_opts; + return cur_smode; +} + +void set_cpu_scaling_mode( + enum cpu_scaling_mode mode, + const cpu_scaling_opts_t *opts) +{ + settings_t *settings = config_get_ptr(); + + /* Store current state */ + cur_smode = mode; + if (opts) + cur_smode_opts = *opts; + + switch (mode) + { + case CPUSCALING_MANUAL: + /* Do nothing, the UI allows for tweaking directly */ + break; + case CPUSCALING_MANAGED_PERFORMANCE: + case CPUSCALING_MANAGED_PER_CONTEXT: + /* Simulate a state change to enforce the policy */ + set_cpu_scaling_signal(CPUSCALING_EVENT_FOCUS_MENU); + break; + case CPUSCALING_MAX_PERFORMANCE: + // Set performance and bump frequencies to min/max + steer_all_drivers("performance", 1, ~0U); + break; + case CPUSCALING_MIN_POWER: + // Set powersave and bump frequencies to min/max + steer_all_drivers("powersave", 1, ~0U); + break; + case CPUSCALING_BALANCED: + // Set ondemand and bump frequencies to min/max + steer_all_drivers("ondemand", 1, ~0U); + break; + }; + + if (settings) + { + /* Store current settings */ + settings->uints.cpu_scaling_mode = (int)cur_smode; + settings->uints.cpu_min_freq = cur_smode_opts.min_freq; + settings->uints.cpu_max_freq = cur_smode_opts.max_freq; + + strlcpy(settings->arrays.cpu_main_gov, cur_smode_opts.main_policy, + sizeof(settings->arrays.cpu_main_gov)); + strlcpy(settings->arrays.cpu_menu_gov, cur_smode_opts.menu_policy, + sizeof(settings->arrays.cpu_menu_gov)); + } +}; + +void cpu_scaling_driver_free() +{ + if (scaling_drivers) + free_drivers(scaling_drivers); + + scaling_drivers = NULL; + last_update = 0; +} + +void cpu_scaling_driver_init(void) +{ + /* Read the default settings */ + settings_t *settings = config_get_ptr(); + unsigned mode = settings->uints.cpu_scaling_mode; + cur_smode_opts.min_freq = settings->uints.cpu_min_freq; + cur_smode_opts.max_freq = settings->uints.cpu_max_freq; + + if (mode <= (int)CPUSCALING_MANUAL) + cur_smode = (enum cpu_scaling_mode)mode; + + if (settings->arrays.cpu_main_gov[0]) + strlcpy(cur_smode_opts.main_policy, settings->arrays.cpu_main_gov, + sizeof(cur_smode_opts.main_policy)); + if (settings->arrays.cpu_menu_gov[0]) + strlcpy(cur_smode_opts.menu_policy, settings->arrays.cpu_menu_gov, + sizeof(cur_smode_opts.menu_policy)); + + /* Force update the policy tree */ + get_cpu_scaling_drivers(true); + + /* Force enforce these settings */ + set_cpu_scaling_mode(cur_smode, NULL); +} diff --git a/misc/cpufreq/cpufreq.h b/misc/cpufreq/cpufreq.h index 06712d4020..38607e6852 100644 --- a/misc/cpufreq/cpufreq.h +++ b/misc/cpufreq/cpufreq.h @@ -20,6 +20,36 @@ RETRO_BEGIN_DECLS +#define MAX_GOV_STRLEN 32 + +/* Events from Frontend to the driver to drive policies */ +enum cpu_scaling_event +{ + CPUSCALING_EVENT_FOCUS_CORE, + CPUSCALING_EVENT_FOCUS_MENU, + CPUSCALING_EVENT_FOCUS_SCREENSAVER +}; + +/* Scaling mode selected by the user */ +enum cpu_scaling_mode +{ + CPUSCALING_MANAGED_PERFORMANCE = 0, /* Performance while running core */ + CPUSCALING_MANAGED_PER_CONTEXT, /* Policies for core, menu, etc. */ + CPUSCALING_MAX_PERFORMANCE, /* Performance (Max Freq) */ + CPUSCALING_MIN_POWER, /* Use Powersave governor */ + CPUSCALING_BALANCED, /* Uses schedutil/ondemand */ + CPUSCALING_MANUAL, /* Can manually tweak stuff */ +}; + +typedef struct cpu_scaling_opts +{ + /* Max/Min frequencies */ + uint32_t min_freq, max_freq; + /* Options for CPUSCALING_POLICY_PER_CONTEXT */ + char main_policy[MAX_GOV_STRLEN]; + char menu_policy[MAX_GOV_STRLEN]; +} cpu_scaling_opts_t; + typedef struct cpu_scaling_driver { /* Policy number in the sysfs tree */ @@ -39,7 +69,10 @@ typedef struct cpu_scaling_driver } cpu_scaling_driver_t; /* Safely free all memory used by the driver */ -void cpu_scaling_driver_free(); +void cpu_scaling_driver_free(void); + +/* Signal the initialization */ +void cpu_scaling_driver_init(void); /* Get a list of the available cpu scaling drivers */ cpu_scaling_driver_t **get_cpu_scaling_drivers(bool can_update); @@ -53,10 +86,21 @@ bool set_cpu_scaling_max_frequency( /* Calculate next/previous frequencies */ uint32_t get_cpu_scaling_next_frequency(cpu_scaling_driver_t *driver, uint32_t freq, int step); +uint32_t get_cpu_scaling_next_frequency_limit(uint32_t freq, int step); /* Set the scaling governor for this scaling driver */ bool set_cpu_scaling_governor(cpu_scaling_driver_t *driver, const char* governor); +/* Signal certain events that are of interest of this driver */ +void set_cpu_scaling_signal(enum cpu_scaling_event); + +/* Set the base cpufreq policy mode */ +void set_cpu_scaling_mode(enum cpu_scaling_mode mode, + const cpu_scaling_opts_t *opts); + +/* Get the base cpufreq policy mode */ +enum cpu_scaling_mode get_cpu_scaling_mode(cpu_scaling_opts_t *opts); + RETRO_END_DECLS #endif diff --git a/msg_hash.h b/msg_hash.h index a0433b8cf5..64c9cbbd81 100644 --- a/msg_hash.h +++ b/msg_hash.h @@ -2941,11 +2941,30 @@ enum msg_hash_enums MENU_LABEL(MIDI_VOLUME), MENU_LABEL(SUSTAINED_PERFORMANCE_MODE), + MENU_LABEL(CPU_PERF_MODE), MENU_LABEL(CPU_PERFPOWER), MENU_LABEL(CPU_POLICY_ENTRY), MENU_LABEL(CPU_POLICY_MIN_FREQ), MENU_LABEL(CPU_POLICY_MAX_FREQ), MENU_LABEL(CPU_POLICY_GOVERNOR), + MENU_LABEL(CPU_POLICY_CORE_GOVERNOR), + MENU_LABEL(CPU_POLICY_MENU_GOVERNOR), + MENU_LABEL(CPU_MANAGED_MIN_FREQ), + MENU_LABEL(CPU_MANAGED_MAX_FREQ), + + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF, + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANAGED_PER_CONTEXT, + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MAX_PERF, + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MIN_POWER, + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_BALANCED, + MENU_ENUM_LABEL_VALUE_CPU_PERF_MODE_MANUAL, + + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANAGED_PERF, + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANAGED_PER_CONTEXT, + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MAX_PERF, + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MIN_POWER, + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_BALANCED, + MENU_ENUM_SUBLABEL_VALUE_CPU_PERF_MODE_MANUAL, MENU_ENUM_LABEL_CHEAT_HANDLER_TYPE_EMU, MENU_ENUM_LABEL_CHEAT_HANDLER_TYPE_RETRO, diff --git a/retroarch.c b/retroarch.c index b82cc1c540..ac12405922 100644 --- a/retroarch.c +++ b/retroarch.c @@ -228,6 +228,7 @@ #include "gfx/video_crt_switch.h" #include "bluetooth/bluetooth_driver.h" #include "wifi/wifi_driver.h" +#include "misc/cpufreq/cpufreq.h" #include "led/led_driver.h" #include "midi/midi_driver.h" #include "core.h" @@ -13314,10 +13315,18 @@ static void retroarch_pause_checks(struct rarch_state *p_rarch) userdata.status = DISCORD_PRESENCE_GAME_PAUSED; command_event(CMD_EVENT_DISCORD_UPDATE, &userdata); #endif + +#ifdef HAVE_LAKKA + set_cpu_scaling_signal(CPUSCALING_EVENT_FOCUS_MENU); +#endif } else { RARCH_LOG("[Core]: %s\n", msg_hash_to_str(MSG_UNPAUSED)); + +#ifdef HAVE_LAKKA + set_cpu_scaling_signal(CPUSCALING_EVENT_FOCUS_CORE); +#endif } #if defined(HAVE_TRANSLATE) && defined(HAVE_GFX_WIDGETS) @@ -33206,6 +33215,10 @@ static void drivers_init(struct rarch_state *p_rarch, /* Initialize MIDI driver */ if (flags & DRIVER_MIDI_MASK) midi_driver_init(p_rarch, settings); + +#ifdef HAVE_LAKKA + cpu_scaling_driver_init(); +#endif } /** @@ -33298,6 +33311,10 @@ static void driver_uninit(struct rarch_state *p_rarch, int flags) if (flags & DRIVER_MIDI_MASK) midi_driver_free(p_rarch); + +#ifdef HAVE_LAKKA + cpu_scaling_driver_free(); +#endif } static void retroarch_deinit_drivers( @@ -35632,6 +35649,13 @@ static void menu_driver_toggle( p_rarch->menu_driver_alive = on; +#ifdef HAVE_LAKKA + if (on) + set_cpu_scaling_signal(CPUSCALING_EVENT_FOCUS_MENU); + else + set_cpu_scaling_signal(CPUSCALING_EVENT_FOCUS_CORE); +#endif + /* Apply any required menu pointer input inhibits * (i.e. prevent phantom input when using an overlay * to toggle the menu on) */