Skip to contentSkip to conversation

sched: Add tunable capacity margin for fis_capacity

PATCH In review YT Chang 4 participants 4 messages Jun 16, 2021 – Jun 18, 2021

Subsystems (5)
lore
Share & tools
lore

YT Chang

author
#0 lore raw

PATCH 1/1 sched: Add tunable capacity margin for fis_capacity

Currently, the margin of cpu frequency raising and cpu overutilized are hard-coded as 25% (1280/1024). Make the margin tunable
to control the aggressive for placement and frequency control. Such as for power tuning framework could adjust smaller margin to slow down frequency raising speed and let task stay in smaller cpu.

For light loading scenarios, like beach buggy blitz and messaging apps, the app threads are moved big core with 25% margin and causing unnecessary power.
With 0% capacity margin (1024/1024), the app threads could be kept in little core and deliver better power results without any fps drop.

capacity margin 0% 10% 20% 30%
current current current current
Fps (mA) Fps (mA) Fps (mA) Fps (mA)

Beach buggy blitz  60 198.164  60   203.211  60   209.984  60  213.374
Yahoo browser      60 232.301 59.97 237.52  59.95 248.213  60  262.809
Change-Id Iba48c556ed1b73c9a2699e9e809bc7d9333dc004
---
 include/linux/sched/cpufreq.h | 19 +++++++++++++++++++
 include/linux/sched/sysctl.h  |  1 +
 include/linux/sysctl.h        |  1 +
 kernel/sched/fair.c           |  4 +++-
 kernel/sysctl.c               | 15 +++++++++++++++
 5 files changed, 39 insertions(+), 1 deletion(-)
include/linux/sched/cpufreq.h +19 -0
index 6205578..8a6c23a1 100644
@@ -23,6 +23,23 @@ void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
 void cpufreq_remove_update_util_hook(int cpu);
 bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy);
 
+#ifdef CONFIG_SMP
+extern unsigned int sysctl_sched_capacity_margin;
+
+static inline unsigned long map_util_freq(unsigned long util,
+					  unsigned long freq, unsigned long cap)
+{
+	freq = freq * util / cap;
+	freq = freq * sysctl_sched_capacity_margin / SCHED_CAPACITY_SCALE;
+
+	return freq;
+}
+
+static inline unsigned long map_util_perf(unsigned long util)
+{
+	return util * sysctl_sched_capacity_margin / SCHED_CAPACITY_SCALE;
+}
+#else
 static inline unsigned long map_util_freq(unsigned long util,
 					unsigned long freq, unsigned long cap)
 {
@@ -33,6 +50,8 @@ static inline unsigned long map_util_perf(unsigned long util)
 {
 	return util + (util >> 2);
 }
+#endif
+
 #endif /* CONFIG_CPU_FREQ */
 
 #endif /* _LINUX_SCHED_CPUFREQ_H */
include/linux/sched/sysctl.h +1 -0
index db2c0f3..5dee024 100644
@@ -10,6 +10,7 @@
 
 #ifdef CONFIG_SMP
 extern unsigned int sysctl_hung_task_all_cpu_backtrace;
+extern unsigned int sysctl_sched_capacity_margin;
 #else
 #define sysctl_hung_task_all_cpu_backtrace 0
 #endif /* CONFIG_SMP */
include/linux/sysctl.h +1 -0
index d99ca99..af6d70f 100644
@@ -41,6 +41,7 @@
 #define SYSCTL_ZERO	((void *)&sysctl_vals[0])
 #define SYSCTL_ONE	((void *)&sysctl_vals[1])
 #define SYSCTL_INT_MAX	((void *)&sysctl_vals[2])
+#define SCHED_CAPACITY_MARGIN_MIN   1024
 
 extern const int sysctl_vals[];
 
kernel/sched/fair.c +3 -1
index 20aa234..609b431 100644
@@ -111,7 +111,9 @@ int __weak arch_asym_cpu_priority(int cpu)
  *
  * (default: ~20%)
  */
-#define fits_capacity(cap, max)	((cap) * 1280 < (max) * 1024)
+unsigned int sysctl_sched_capacity_margin = 1280;
+EXPORT_SYMBOL_GPL(sysctl_sched_capacity_margin);
+#define fits_capacity(cap, max)	((cap) * sysctl_sched_capacity_margin < (max) * 1024)
 
 /*
  * The margin used when comparing CPU capacities.
kernel/sysctl.c +15 -0
index 14edf84..d6d2b84 100644
@@ -127,6 +127,11 @@
 static int six_hundred_forty_kb = 640 * 1024;
 #endif
 
+/* this is needed for the proc of sysctl_sched_capacity_margin */
+#ifdef CONFIG_SMP
+static int min_sched_capacity_margin = 1024;
+#endif /* CONFIG_SMP */
+
 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
 
@@ -1716,6 +1721,16 @@ int proc_do_static_key(struct ctl_table *table, int write,
 		.mode		= 0644,
 		.proc_handler	= proc_dointvec,
 	},
+#ifdef CONFIG_SMP
+	{
+		.procname	= "sched_capcity_margin",
+		.data		= &sysctl_sched_capacity_margin,
+		.maxlen		= sizeof(unsigned int),
+		.mode		= 0644,
+		.proc_handler	= proc_dointvec_minmax,
+		.extra1		= &min_sched_capacity_margin,
+	},
+#endif
 #ifdef CONFIG_SCHEDSTATS
 	{
 		.procname	= "sched_schedstats",
Signature · 1 line
1.9.1
maintainer
#1 lore raw
Quoted 3 lines · YT Chang

Currently, the margin of cpu frequency raising and cpu overutilized are hard-coded as 25% (1280/1024). Make the margin tunable

cpu_overutilized is 20% not 25%. Even if they light looks similar these 2 margins are differents

Quoted 10 lines

to control the aggressive for placement and frequency control. Such as for power tuning framework could adjust smaller margin to slow down frequency raising speed and let task stay in smaller cpu.

For light loading scenarios, like beach buggy blitz and messaging apps, the app threads are moved big core with 25% margin and causing unnecessary power.
With 0% capacity margin (1024/1024), the app threads could be kept in little core and deliver better power results without any fps drop.

Quoted 5 lines

capacity margin 0% 10% 20% 30%
current current current current
Fps (mA) Fps (mA) Fps (mA) Fps (mA)

Beach buggy blitz  60 198.164  60   203.211  60   209.984  60  213.374
Yahoo browser      60 232.301 59.97 237.52  59.95 248.213  60  262.809

Would be good to know the impact of each part:
Changing the +25% in cpufreq governor
Changing the 20% margin to detect overloaded CPU

Also, IIUC your description, the current values are ok with some UCs but not with others like the 2 aboves. Have you evaluated whether it was not your power model that was not accurate ?

Quoted 123 lines
Change-Id Iba48c556ed1b73c9a2699e9e809bc7d9333dc004
---
 include/linux/sched/cpufreq.h | 19 +++++++++++++++++++
 include/linux/sched/sysctl.h  |  1 +
 include/linux/sysctl.h        |  1 +
 kernel/sched/fair.c           |  4 +++-
 kernel/sysctl.c               | 15 +++++++++++++++
 5 files changed, 39 insertions(+), 1 deletion(-)
include/linux/sched/cpufreq.h +19 -0
index 6205578..8a6c23a1 100644
@@ -23,6 +23,23 @@ void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
 void cpufreq_remove_update_util_hook(int cpu);
 bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy);
 
+#ifdef CONFIG_SMP
+extern unsigned int sysctl_sched_capacity_margin;
+
+static inline unsigned long map_util_freq(unsigned long util,
+                                         unsigned long freq, unsigned long cap)
+{
+       freq = freq * util / cap;
+       freq = freq * sysctl_sched_capacity_margin / SCHED_CAPACITY_SCALE;
+
+       return freq;
+}
+
+static inline unsigned long map_util_perf(unsigned long util)
+{
+       return util * sysctl_sched_capacity_margin / SCHED_CAPACITY_SCALE;
+}
+#else
 static inline unsigned long map_util_freq(unsigned long util,
                                        unsigned long freq, unsigned long cap)
 {
@@ -33,6 +50,8 @@ static inline unsigned long map_util_perf(unsigned long util)
 {
        return util + (util >> 2);
 }
+#endif
+
 #endif /* CONFIG_CPU_FREQ */
 
 #endif /* _LINUX_SCHED_CPUFREQ_H */
include/linux/sched/sysctl.h +1 -0
index db2c0f3..5dee024 100644
@@ -10,6 +10,7 @@
 
 #ifdef CONFIG_SMP
 extern unsigned int sysctl_hung_task_all_cpu_backtrace;
+extern unsigned int sysctl_sched_capacity_margin;
 #else
 #define sysctl_hung_task_all_cpu_backtrace 0
 #endif /* CONFIG_SMP */
include/linux/sysctl.h +1 -0
index d99ca99..af6d70f 100644
@@ -41,6 +41,7 @@
 #define SYSCTL_ZERO    ((void *)&sysctl_vals[0])
 #define SYSCTL_ONE     ((void *)&sysctl_vals[1])
 #define SYSCTL_INT_MAX ((void *)&sysctl_vals[2])
+#define SCHED_CAPACITY_MARGIN_MIN   1024
 
 extern const int sysctl_vals[];
 
kernel/sched/fair.c +3 -1
index 20aa234..609b431 100644
@@ -111,7 +111,9 @@ int __weak arch_asym_cpu_priority(int cpu)
  *
  * (default: ~20%)
  */
-#define fits_capacity(cap, max)        ((cap) * 1280 < (max) * 1024)
+unsigned int sysctl_sched_capacity_margin = 1280;
+EXPORT_SYMBOL_GPL(sysctl_sched_capacity_margin);
+#define fits_capacity(cap, max)        ((cap) * sysctl_sched_capacity_margin < (max) * 1024)
 
 /*
  * The margin used when comparing CPU capacities.
kernel/sysctl.c +15 -1
index 14edf84..d6d2b84 100644
@@ -127,6 +127,11 @@
 static int six_hundred_forty_kb = 640 * 1024;
 #endif
 
+/* this is needed for the proc of sysctl_sched_capacity_margin */
+#ifdef CONFIG_SMP
+static int min_sched_capacity_margin = 1024;
+#endif /* CONFIG_SMP */
+
 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
 
@@ -1716,6 +1721,16 @@ int proc_do_static_key(struct ctl_table *table, int write,
                .mode           = 0644,
                .proc_handler   = proc_dointvec,
        },
+#ifdef CONFIG_SMP
+       {
+               .procname       = "sched_capcity_margin",
+               .data           = &sysctl_sched_capacity_margin,
+               .maxlen         = sizeof(unsigned int),
+               .mode           = 0644,
+               .proc_handler   = proc_dointvec_minmax,
+               .extra1         = &min_sched_capacity_margin,
+       },
+#endif
 #ifdef CONFIG_SCHEDSTATS
        {
                .procname       = "sched_schedstats",
--

1.9.1

#2 lore raw
In reply to YT Chang
Thank you for the patch! Yet something to improve:

Hi YT,

Thank you for the patch! Yet something to improve:

[auto build test ERROR on pm/linux-next]
[also build test ERROR on tip/sched/core kees/for-next/pstore linus/master v5.13-rc6 next-20210617] [If your patch is applied to the wrong git tree, kindly drop us a note.
And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]

url:    https://github.com/0day-ci/linux/commits/YT-Chang/sched-Add-tunable-capacity-margin-for-fis_capacity/20210617-101010
base:   https://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm.git linux-next
config: x86_64-randconfig-b001-20210617 (attached as .config)
compiler: clang version 13.0.0 (https://github.com/llvm/llvm-project 64720f57bea6a6bf033feef4a5751ab9c0c3b401)

reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# install x86_64 cross compiling tool for clang build
# apt-get install binutils-x86-64-linux-gnu
# https://github.com/0day-ci/linux/commit/5f9a234696d4aef51f1f2b506e7724760bb0f907
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review YT-Chang/sched-Add-tunable-capacity-margin-for-fis_capacity/20210617-101010 git checkout 5f9a234696d4aef51f1f2b506e7724760bb0f907
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross ARCH=x86_64

If you fix the issue, kindly add following tag as appropriate

All errors (new ones prefixed by >>):

>> kernel/sysctl.c:1747:13: error: use of undeclared identifier 'sysctl_sched_capacity_margin'; did you mean 'min_sched_capacity_margin'?
                   .data           = &sysctl_sched_capacity_margin,
                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                      min_sched_capacity_margin
   kernel/sysctl.c:132:12: note: 'min_sched_capacity_margin' declared here
   static int min_sched_capacity_margin = 1024;
              ^

1 error generated.

vim +1747 kernel/sysctl.c

1735
1736 static struct ctl_table kern_table[] = {
1737 {
1738 .procname = "sched_child_runs_first",
1739 .data = &sysctl_sched_child_runs_first,
1740 .maxlen = sizeof(unsigned int),
1741 .mode = 0644,
1742 .proc_handler = proc_dointvec,
1743 },
1744 #ifdef CONFIG_SMP
1745 {
1746 .procname = "sched_capcity_margin",

> 1747			.data		= &sysctl_sched_capacity_margin,

1748 .maxlen = sizeof(unsigned int),
1749 .mode = 0644,
1750 .proc_handler = proc_dointvec_minmax,
1751 .extra1 = &min_sched_capacity_margin,
1752 },
1753 #endif
1754 #ifdef CONFIG_SCHEDSTATS
1755 {
1756 .procname = "sched_schedstats",
1757 .data = NULL,
1758 .maxlen = sizeof(unsigned int),
1759 .mode = 0644,
1760 .proc_handler = sysctl_schedstats,
1761 .extra1 = SYSCTL_ZERO,
1762 .extra2 = SYSCTL_ONE,
1763 },
1764 #endif /* CONFIG_SCHEDSTATS */
1765 #ifdef CONFIG_NUMA_BALANCING
1766 {
1767 .procname = "numa_balancing",
1768 .data = NULL, /* filled in by handler */
1769 .maxlen = sizeof(unsigned int),
1770 .mode = 0644,
1771 .proc_handler = sysctl_numa_balancing,
1772 .extra1 = SYSCTL_ZERO,
1773 .extra2 = SYSCTL_ONE,
1774 },
1775 #endif /* CONFIG_NUMA_BALANCING */
1776 {
1777 .procname = "sched_rt_period_us",
1778 .data = &sysctl_sched_rt_period,
1779 .maxlen = sizeof(unsigned int),
1780 .mode = 0644,
1781 .proc_handler = sched_rt_handler,
1782 },
1783 {
1784 .procname = "sched_rt_runtime_us",
1785 .data = &sysctl_sched_rt_runtime,
1786 .maxlen = sizeof(int),
1787 .mode = 0644,
1788 .proc_handler = sched_rt_handler,
1789 },
1790 {
1791 .procname = "sched_deadline_period_max_us",
1792 .data = &sysctl_sched_dl_period_max,
1793 .maxlen = sizeof(unsigned int),
1794 .mode = 0644,
1795 .proc_handler = proc_dointvec,
1796 },
1797 {
1798 .procname = "sched_deadline_period_min_us",
1799 .data = &sysctl_sched_dl_period_min,
1800 .maxlen = sizeof(unsigned int),
1801 .mode = 0644,
1802 .proc_handler = proc_dointvec,
1803 },
1804 {
1805 .procname = "sched_rr_timeslice_ms",
1806 .data = &sysctl_sched_rr_timeslice,
1807 .maxlen = sizeof(int),
1808 .mode = 0644,
1809 .proc_handler = sched_rr_handler,
1810 },
1811 #ifdef CONFIG_UCLAMP_TASK
1812 {
1813 .procname = "sched_util_clamp_min",
1814 .data = &sysctl_sched_uclamp_util_min,
1815 .maxlen = sizeof(unsigned int),
1816 .mode = 0644,
1817 .proc_handler = sysctl_sched_uclamp_handler,
1818 },
1819 {
1820 .procname = "sched_util_clamp_max",
1821 .data = &sysctl_sched_uclamp_util_max,
1822 .maxlen = sizeof(unsigned int),
1823 .mode = 0644,
1824 .proc_handler = sysctl_sched_uclamp_handler,
1825 },
1826 {
1827 .procname = "sched_util_clamp_min_rt_default",
1828 .data = &sysctl_sched_uclamp_util_min_rt_default,
1829 .maxlen = sizeof(unsigned int),
1830 .mode = 0644,
1831 .proc_handler = sysctl_sched_uclamp_handler,
1832 },
1833 #endif
1834 #ifdef CONFIG_SCHED_AUTOGROUP
1835 {
1836 .procname = "sched_autogroup_enabled",
1837 .data = &sysctl_sched_autogroup_enabled,
1838 .maxlen = sizeof(unsigned int),
1839 .mode = 0644,
1840 .proc_handler = proc_dointvec_minmax,
1841 .extra1 = SYSCTL_ZERO,
1842 .extra2 = SYSCTL_ONE,
1843 },
1844 #endif
1845 #ifdef CONFIG_CFS_BANDWIDTH
1846 {
1847 .procname = "sched_cfs_bandwidth_slice_us",
1848 .data = &sysctl_sched_cfs_bandwidth_slice,
1849 .maxlen = sizeof(unsigned int),
1850 .mode = 0644,
1851 .proc_handler = proc_dointvec_minmax,
1852 .extra1 = SYSCTL_ONE,
1853 },
1854 #endif
1855 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
1856 {
1857 .procname = "sched_energy_aware",
1858 .data = &sysctl_sched_energy_aware,
1859 .maxlen = sizeof(unsigned int),
1860 .mode = 0644,
1861 .proc_handler = sched_energy_aware_handler,
1862 .extra1 = SYSCTL_ZERO,
1863 .extra2 = SYSCTL_ONE,
1864 },
1865 #endif
1866 #ifdef CONFIG_PROVE_LOCKING
1867 {
1868 .procname = "prove_locking",
1869 .data = &prove_locking,
1870 .maxlen = sizeof(int),
1871 .mode = 0644,
1872 .proc_handler = proc_dointvec,
1873 },
1874 #endif
1875 #ifdef CONFIG_LOCK_STAT
1876 {
1877 .procname = "lock_stat",
1878 .data = &lock_stat,
1879 .maxlen = sizeof(int),
1880 .mode = 0644,
1881 .proc_handler = proc_dointvec,
1882 },
1883 #endif
1884 {
1885 .procname = "panic",
1886 .data = &panic_timeout,
1887 .maxlen = sizeof(int),
1888 .mode = 0644,
1889 .proc_handler = proc_dointvec,
1890 },
1891 #ifdef CONFIG_COREDUMP
1892 {
1893 .procname = "core_uses_pid",
1894 .data = &core_uses_pid,
1895 .maxlen = sizeof(int),
1896 .mode = 0644,
1897 .proc_handler = proc_dointvec,
1898 },
1899 {
1900 .procname = "core_pattern",
1901 .data = core_pattern,
1902 .maxlen = CORENAME_MAX_SIZE,
1903 .mode = 0644,
1904 .proc_handler = proc_dostring_coredump,
1905 },
1906 {
1907 .procname = "core_pipe_limit",
1908 .data = &core_pipe_limit,
1909 .maxlen = sizeof(unsigned int),
1910 .mode = 0644,
1911 .proc_handler = proc_dointvec,
1912 },
1913 #endif
1914 #ifdef CONFIG_PROC_SYSCTL
1915 {
1916 .procname = "tainted",
1917 .maxlen = sizeof(long),
1918 .mode = 0644,
1919 .proc_handler = proc_taint,
1920 },
1921 {
1922 .procname = "sysctl_writes_strict",
1923 .data = &sysctl_writes_strict,
1924 .maxlen = sizeof(int),
1925 .mode = 0644,
1926 .proc_handler = proc_dointvec_minmax,
1927 .extra1 = &neg_one,
1928 .extra2 = SYSCTL_ONE,
1929 },
1930 #endif
1931 #ifdef CONFIG_LATENCYTOP
1932 {
1933 .procname = "latencytop",
1934 .data = &latencytop_enabled,
1935 .maxlen = sizeof(int),
1936 .mode = 0644,
1937 .proc_handler = sysctl_latencytop,
1938 },
1939 #endif
1940 #ifdef CONFIG_BLK_DEV_INITRD
1941 {
1942 .procname = "real-root-dev",
1943 .data = &real_root_dev,
1944 .maxlen = sizeof(int),
1945 .mode = 0644,
1946 .proc_handler = proc_dointvec,
1947 },
1948 #endif
1949 {
1950 .procname = "print-fatal-signals",
1951 .data = &print_fatal_signals,
1952 .maxlen = sizeof(int),
1953 .mode = 0644,
1954 .proc_handler = proc_dointvec,
1955 },
1956 #ifdef CONFIG_SPARC
1957 {
1958 .procname = "reboot-cmd",
1959 .data = reboot_command,
1960 .maxlen = 256,
1961 .mode = 0644,
1962 .proc_handler = proc_dostring,
1963 },
1964 {
1965 .procname = "stop-a",
1966 .data = &stop_a_enabled,
1967 .maxlen = sizeof (int),
1968 .mode = 0644,
1969 .proc_handler = proc_dointvec,
1970 },
1971 {
1972 .procname = "scons-poweroff",
1973 .data = &scons_pwroff,
1974 .maxlen = sizeof (int),
1975 .mode = 0644,
1976 .proc_handler = proc_dointvec,
1977 },
1978 #endif
1979 #ifdef CONFIG_SPARC64
1980 {
1981 .procname = "tsb-ratio",
1982 .data = &sysctl_tsb_ratio,
1983 .maxlen = sizeof (int),
1984 .mode = 0644,
1985 .proc_handler = proc_dointvec,
1986 },
1987 #endif
1988 #ifdef CONFIG_PARISC
1989 {
1990 .procname = "soft-power",
1991 .data = &pwrsw_enabled,
1992 .maxlen = sizeof (int),
1993 .mode = 0644,
1994 .proc_handler = proc_dointvec,
1995 },
1996 #endif
1997 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1998 {
1999 .procname = "unaligned-trap",
2000 .data = &unaligned_enabled,
2001 .maxlen = sizeof (int),
2002 .mode = 0644,
2003 .proc_handler = proc_dointvec,
2004 },
2005 #endif
2006 {
2007 .procname = "ctrl-alt-del",
2008 .data = &C_A_D,
2009 .maxlen = sizeof(int),
2010 .mode = 0644,
2011 .proc_handler = proc_dointvec,
2012 },
2013 #ifdef CONFIG_FUNCTION_TRACER
2014 {
2015 .procname = "ftrace_enabled",
2016 .data = &ftrace_enabled,
2017 .maxlen = sizeof(int),
2018 .mode = 0644,
2019 .proc_handler = ftrace_enable_sysctl,
2020 },
2021 #endif
2022 #ifdef CONFIG_STACK_TRACER
2023 {
2024 .procname = "stack_tracer_enabled",
2025 .data = &stack_tracer_enabled,
2026 .maxlen = sizeof(int),
2027 .mode = 0644,
2028 .proc_handler = stack_trace_sysctl,
2029 },
2030 #endif
2031 #ifdef CONFIG_TRACING
2032 {
2033 .procname = "ftrace_dump_on_oops",
2034 .data = &ftrace_dump_on_oops,
2035 .maxlen = sizeof(int),
2036 .mode = 0644,
2037 .proc_handler = proc_dointvec,
2038 },
2039 {
2040 .procname = "traceoff_on_warning",
2041 .data = &__disable_trace_on_warning,
2042 .maxlen = sizeof(__disable_trace_on_warning),
2043 .mode = 0644,
2044 .proc_handler = proc_dointvec,
2045 },
2046 {
2047 .procname = "tracepoint_printk",
2048 .data = &tracepoint_printk,
2049 .maxlen = sizeof(tracepoint_printk),
2050 .mode = 0644,
2051 .proc_handler = tracepoint_printk_sysctl,
2052 },
2053 #endif
2054 #ifdef CONFIG_KEXEC_CORE
2055 {
2056 .procname = "kexec_load_disabled",
2057 .data = &kexec_load_disabled,
2058 .maxlen = sizeof(int),
2059 .mode = 0644,
2060 /* only handle a transition from default "0" to "1" */
2061 .proc_handler = proc_dointvec_minmax,
2062 .extra1 = SYSCTL_ONE,
2063 .extra2 = SYSCTL_ONE,
2064 },
2065 #endif
2066 #ifdef CONFIG_MODULES
2067 {
2068 .procname = "modprobe",
2069 .data = &modprobe_path,
2070 .maxlen = KMOD_PATH_LEN,
2071 .mode = 0644,
2072 .proc_handler = proc_dostring,
2073 },
2074 {
2075 .procname = "modules_disabled",
2076 .data = &modules_disabled,
2077 .maxlen = sizeof(int),
2078 .mode = 0644,
2079 /* only handle a transition from default "0" to "1" */
2080 .proc_handler = proc_dointvec_minmax,
2081 .extra1 = SYSCTL_ONE,
2082 .extra2 = SYSCTL_ONE,
2083 },
2084 #endif
2085 #ifdef CONFIG_UEVENT_HELPER
2086 {
2087 .procname = "hotplug",
2088 .data = &uevent_helper,
2089 .maxlen = UEVENT_HELPER_PATH_LEN,
2090 .mode = 0644,
2091 .proc_handler = proc_dostring,
2092 },
2093 #endif
2094 #ifdef CONFIG_CHR_DEV_SG
2095 {
2096 .procname = "sg-big-buff",
2097 .data = &sg_big_buff,
2098 .maxlen = sizeof (int),
2099 .mode = 0444,
2100 .proc_handler = proc_dointvec,
2101 },
2102 #endif
2103 #ifdef CONFIG_BSD_PROCESS_ACCT
2104 {
2105 .procname = "acct",
2106 .data = &acct_parm,
2107 .maxlen = 3*sizeof(int),
2108 .mode = 0644,
2109 .proc_handler = proc_dointvec,
2110 },
2111 #endif
2112 #ifdef CONFIG_MAGIC_SYSRQ
2113 {
2114 .procname = "sysrq",
2115 .data = NULL,
2116 .maxlen = sizeof (int),
2117 .mode = 0644,
2118 .proc_handler = sysrq_sysctl_handler,
2119 },
2120 #endif
2121 #ifdef CONFIG_PROC_SYSCTL
2122 {
2123 .procname = "cad_pid",
2124 .data = NULL,
2125 .maxlen = sizeof (int),
2126 .mode = 0600,
2127 .proc_handler = proc_do_cad_pid,
2128 },
2129 #endif
2130 {
2131 .procname = "threads-max",
2132 .data = NULL,
2133 .maxlen = sizeof(int),
2134 .mode = 0644,
2135 .proc_handler = sysctl_max_threads,
2136 },
2137 {
2138 .procname = "random",
2139 .mode = 0555,
2140 .child = random_table,
2141 },
2142 {
2143 .procname = "usermodehelper",
2144 .mode = 0555,
2145 .child = usermodehelper_table,
2146 },
2147 #ifdef CONFIG_FW_LOADER_USER_HELPER
2148 {
2149 .procname = "firmware_config",
2150 .mode = 0555,
2151 .child = firmware_config_table,
2152 },
2153 #endif
2154 {
2155 .procname = "overflowuid",
2156 .data = &overflowuid,
2157 .maxlen = sizeof(int),
2158 .mode = 0644,
2159 .proc_handler = proc_dointvec_minmax,
2160 .extra1 = &minolduid,
2161 .extra2 = &maxolduid,
2162 },
2163 {
2164 .procname = "overflowgid",
2165 .data = &overflowgid,
2166 .maxlen = sizeof(int),
2167 .mode = 0644,
2168 .proc_handler = proc_dointvec_minmax,
2169 .extra1 = &minolduid,
2170 .extra2 = &maxolduid,
2171 },
2172 #ifdef CONFIG_S390
2173 {
2174 .procname = "userprocess_debug",
2175 .data = &show_unhandled_signals,
2176 .maxlen = sizeof(int),
2177 .mode = 0644,
2178 .proc_handler = proc_dointvec,
2179 },
2180 #endif
2181 #ifdef CONFIG_SMP
2182 {
2183 .procname = "oops_all_cpu_backtrace",
2184 .data = &sysctl_oops_all_cpu_backtrace,
2185 .maxlen = sizeof(int),
2186 .mode = 0644,
2187 .proc_handler = proc_dointvec_minmax,
2188 .extra1 = SYSCTL_ZERO,
2189 .extra2 = SYSCTL_ONE,
2190 },
2191 #endif /* CONFIG_SMP */
2192 {
2193 .procname = "pid_max",
2194 .data = &pid_max,
2195 .maxlen = sizeof (int),
2196 .mode = 0644,
2197 .proc_handler = proc_dointvec_minmax,
2198 .extra1 = &pid_max_min,
2199 .extra2 = &pid_max_max,
2200 },
2201 {
2202 .procname = "panic_on_oops",
2203 .data = &panic_on_oops,
2204 .maxlen = sizeof(int),
2205 .mode = 0644,
2206 .proc_handler = proc_dointvec,
2207 },
2208 {
2209 .procname = "panic_print",
2210 .data = &panic_print,
2211 .maxlen = sizeof(unsigned long),
2212 .mode = 0644,
2213 .proc_handler = proc_doulongvec_minmax,
2214 },
2215 #if defined CONFIG_PRINTK
2216 {
2217 .procname = "printk",
2218 .data = &console_loglevel,
2219 .maxlen = 4*sizeof(int),
2220 .mode = 0644,
2221 .proc_handler = proc_dointvec,
2222 },
2223 {
2224 .procname = "printk_ratelimit",
2225 .data = &printk_ratelimit_state.interval,
2226 .maxlen = sizeof(int),
2227 .mode = 0644,
2228 .proc_handler = proc_dointvec_jiffies,
2229 },
2230 {
2231 .procname = "printk_ratelimit_burst",
2232 .data = &printk_ratelimit_state.burst,
2233 .maxlen = sizeof(int),
2234 .mode = 0644,
2235 .proc_handler = proc_dointvec,
2236 },
2237 {
2238 .procname = "printk_delay",
2239 .data = &printk_delay_msec,
2240 .maxlen = sizeof(int),
2241 .mode = 0644,
2242 .proc_handler = proc_dointvec_minmax,
2243 .extra1 = SYSCTL_ZERO,
2244 .extra2 = &ten_thousand,
2245 },
2246 {
2247 .procname = "printk_devkmsg",
2248 .data = devkmsg_log_str,
2249 .maxlen = DEVKMSG_STR_MAX_SIZE,
2250 .mode = 0644,
2251 .proc_handler = devkmsg_sysctl_set_loglvl,
2252 },
2253 {
2254 .procname = "dmesg_restrict",
2255 .data = &dmesg_restrict,
2256 .maxlen = sizeof(int),
2257 .mode = 0644,
2258 .proc_handler = proc_dointvec_minmax_sysadmin,
2259 .extra1 = SYSCTL_ZERO,
2260 .extra2 = SYSCTL_ONE,
2261 },
2262 {
2263 .procname = "kptr_restrict",
2264 .data = &kptr_restrict,
2265 .maxlen = sizeof(int),
2266 .mode = 0644,
2267 .proc_handler = proc_dointvec_minmax_sysadmin,
2268 .extra1 = SYSCTL_ZERO,
2269 .extra2 = &two,
2270 },
2271 #endif
2272 {
2273 .procname = "ngroups_max",
2274 .data = &ngroups_max,
2275 .maxlen = sizeof (int),
2276 .mode = 0444,
2277 .proc_handler = proc_dointvec,
2278 },
2279 {
2280 .procname = "cap_last_cap",
2281 .data = (void *)&cap_last_cap,
2282 .maxlen = sizeof(int),
2283 .mode = 0444,
2284 .proc_handler = proc_dointvec,
2285 },
2286 #if defined(CONFIG_LOCKUP_DETECTOR)
2287 {
2288 .procname = "watchdog",
2289 .data = &watchdog_user_enabled,
2290 .maxlen = sizeof(int),
2291 .mode = 0644,
2292 .proc_handler = proc_watchdog,
2293 .extra1 = SYSCTL_ZERO,
2294 .extra2 = SYSCTL_ONE,
2295 },
2296 {
2297 .procname = "watchdog_thresh",
2298 .data = &watchdog_thresh,
2299 .maxlen = sizeof(int),
2300 .mode = 0644,
2301 .proc_handler = proc_watchdog_thresh,
2302 .extra1 = SYSCTL_ZERO,
2303 .extra2 = &sixty,
2304 },
2305 {
2306 .procname = "nmi_watchdog",
2307 .data = &nmi_watchdog_user_enabled,
2308 .maxlen = sizeof(int),
2309 .mode = NMI_WATCHDOG_SYSCTL_PERM,
2310 .proc_handler = proc_nmi_watchdog,
2311 .extra1 = SYSCTL_ZERO,
2312 .extra2 = SYSCTL_ONE,
2313 },
2314 {
2315 .procname = "watchdog_cpumask",
2316 .data = &watchdog_cpumask_bits,
2317 .maxlen = NR_CPUS,
2318 .mode = 0644,
2319 .proc_handler = proc_watchdog_cpumask,
2320 },
2321 #ifdef CONFIG_SOFTLOCKUP_DETECTOR
2322 {
2323 .procname = "soft_watchdog",
2324 .data = &soft_watchdog_user_enabled,
2325 .maxlen = sizeof(int),
2326 .mode = 0644,
2327 .proc_handler = proc_soft_watchdog,
2328 .extra1 = SYSCTL_ZERO,
2329 .extra2 = SYSCTL_ONE,
2330 },
2331 {
2332 .procname = "softlockup_panic",
2333 .data = &softlockup_panic,
2334 .maxlen = sizeof(int),
2335 .mode = 0644,
2336 .proc_handler = proc_dointvec_minmax,
2337 .extra1 = SYSCTL_ZERO,
2338 .extra2 = SYSCTL_ONE,
2339 },
2340 #ifdef CONFIG_SMP
2341 {
2342 .procname = "softlockup_all_cpu_backtrace",
2343 .data = &sysctl_softlockup_all_cpu_backtrace,
2344 .maxlen = sizeof(int),
2345 .mode = 0644,
2346 .proc_handler = proc_dointvec_minmax,
2347 .extra1 = SYSCTL_ZERO,
2348 .extra2 = SYSCTL_ONE,
2349 },
2350 #endif /* CONFIG_SMP */
2351 #endif
2352 #ifdef CONFIG_HARDLOCKUP_DETECTOR
2353 {
2354 .procname = "hardlockup_panic",
2355 .data = &hardlockup_panic,
2356 .maxlen = sizeof(int),
2357 .mode = 0644,
2358 .proc_handler = proc_dointvec_minmax,
2359 .extra1 = SYSCTL_ZERO,
2360 .extra2 = SYSCTL_ONE,
2361 },
2362 #ifdef CONFIG_SMP
2363 {
2364 .procname = "hardlockup_all_cpu_backtrace",
2365 .data = &sysctl_hardlockup_all_cpu_backtrace,
2366 .maxlen = sizeof(int),
2367 .mode = 0644,
2368 .proc_handler = proc_dointvec_minmax,
2369 .extra1 = SYSCTL_ZERO,
2370 .extra2 = SYSCTL_ONE,
2371 },
2372 #endif /* CONFIG_SMP */
2373 #endif
2374 #endif
2375

---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org

#3 lore raw
In reply to YT Chang

Hi YT Chang

Thanks for the patch.

Quoted 2 lines · YT Chang

Currently, the margin of cpu frequency raising and cpu overutilized are hard-coded as 25% (1280/1024). Make the margin tunable

The way I see cpu overutilized is that we check if we're above the 80% range.

Quoted 13 lines

to control the aggressive for placement and frequency control. Such as for power tuning framework could adjust smaller margin to slow down frequency raising speed and let task stay in smaller cpu.

For light loading scenarios, like beach buggy blitz and messaging apps, the app threads are moved big core with 25% margin and causing unnecessary power.
With 0% capacity margin (1024/1024), the app threads could be kept in little core and deliver better power results without any fps drop.

capacity margin 0% 10% 20% 30%
current current current current
Fps (mA) Fps (mA) Fps (mA) Fps (mA)

Quoted 6 lines
Beach buggy blitz  60 198.164  60   203.211  60   209.984  60  213.374
Yahoo browser      60 232.301 59.97 237.52  59.95 248.213  60  262.809
Change-Id Iba48c556ed1b73c9a2699e9e809bc7d9333dc004

---

We are aware of the cpu overutilized value not being adequate on some modern platforms. But I haven't considered or seen any issues with the frequency one. So the latter is an interesting one.

I like your patch, but sadly I can't agree with it too.

The dilemma is that there are several options forward based on what we've seen vendors do/want:

1. Modify the margin to be small for high end SoC and larger for lower end ones. Which is what your patch allows.
2. Some vendors have a per cluster (perf domain) value. So within the same SoC different margins are used for each capacity level.
3. Some vendors have asymmetric margin. A margin to move up and a different margin to go down.

We're still not sure which approach is the best way forward.

Your patch allows 1, but if it turned out options 2 or 3 are better; the ABI will make it hard to change.

Have you considered all these options? Do you have any data to help support 1 is enough for the range of platforms you work with at least?

We were considering also whether we can have a smarter logic to automagically set a better value for the platform, but no concrete suggestions yet.

So while I agree the current margin value of one size fits all is no longer suitable. But the variation of hardware and the possible approaches we could take need more careful thinking and consideration before committing to an ABI.

This patch is a good start for this discussion :)

Thanks

--
Qais Yousef