Provide USF for the portable equipment.

kernel/sched/usf.c new file +2 -0

@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: GPL-2.0
+/*

kernel/sched/usf.c new file +14 -0

+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/kthread.h>
+#include <linux/cpu.h>
+#include <linux/sysfs.h>
+#include <linux/kthread.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/kallsyms.h>

kernel/sched/usf.c new file +178 -0

+
+DEFINE_PER_CPU(unsigned long[PID_MAX_DEFAULT], task_hist_nivcsw);
+
+static struct {
+	bool is_sched_usf_enabled;
+	bool is_screen_on;
+	int sysctl_sched_usf_up_l0;
+	int sysctl_sched_usf_down;
+	int sysctl_sched_usf_non_ux;
+	int usf_up_l0;
+	int usf_down;
+	int usf_non_ux;
+} usf_vdev;
+
+void adjust_task_pred_demand(int cpuid,
+			     unsigned long *util,
+			     struct rq *rq)
+{
+	/* sysctl_sched_latency/sysctl_sched_min_granularity */
+	u32 bl_sw_num = 3;
+
+	if (!usf_vdev.is_sched_usf_enabled || !rq || !rq->curr ||
+		(rq->curr->pid >= PID_MAX_DEFAULT))
+		return;
+
+	if (usf_vdev.is_screen_on) {
+		if (rq->curr->nivcsw >
+		    (per_cpu(task_hist_nivcsw, cpuid)[rq->curr->pid]
+		     + bl_sw_num + 1)) {
+			(*util) += (*util) >> usf_vdev.usf_up_l0;
+		} else if (rq->curr->nivcsw <
+			   (per_cpu(task_hist_nivcsw, cpuid)[rq->curr->pid]
+			    + bl_sw_num - 1) && (rq->nr_running < bl_sw_num)) {
+			(*util) >>= usf_vdev.usf_down;
+		}
+		per_cpu(task_hist_nivcsw, cpuid)[rq->curr->pid] =
+		    rq->curr->nivcsw;
+	} else if (rq->curr->mm) {
+		(*util) >>= usf_vdev.usf_non_ux;
+	}
+
+	trace_sched_usf_adjust_utils(cpuid, usf_vdev.usf_up_l0,
+				     usf_vdev.usf_down,
+				     usf_vdev.usf_non_ux, *util);
+}
+
+static int usf_lcd_notifier(struct notifier_block *nb,
+			    unsigned long val, void *data)
+{
+	struct fb_event *evdata = data;
+	unsigned int blank;
+
+	if (!evdata)
+		return 0;
+
+	if (val != FB_EVENT_BLANK)
+		return 0;
+
+	if (evdata->data && val == FB_EVENT_BLANK) {
+		blank = *(int *)(evdata->data);
+
+		switch (blank) {
+		case FB_BLANK_POWERDOWN:
+			usf_vdev.is_screen_on = false;
+			if (usf_vdev.sysctl_sched_usf_non_ux != 0)
+				static_branch_enable(&adjust_task_pred_set);
+			else
+				static_branch_disable(&adjust_task_pred_set);
+
+			break;
+
+		case FB_BLANK_UNBLANK:
+			usf_vdev.is_screen_on = true;
+			if (usf_vdev.sysctl_sched_usf_up_l0 != 0 ||
+			    usf_vdev.sysctl_sched_usf_down != 0)
+				static_branch_enable(&adjust_task_pred_set);
+			else
+				static_branch_disable(&adjust_task_pred_set);
+			break;
+		default:
+			break;
+		}
+
+		usf_vdev.is_sched_usf_enabled = true;
+		pr_info("%s : usf_vdev.is_screen_on:%b\n",
+				     __func__, usf_vdev.is_screen_on);
+	}
+	return NOTIFY_OK;
+}
+
+static struct notifier_block usf_lcd_nb = {
+	.notifier_call = usf_lcd_notifier,
+	.priority = INT_MAX,
+};
+
+static ssize_t store_sched_usf_up_l0_r(struct kobject *kobj,
+				       struct kobj_attribute *attr,
+				       const char *buf, size_t count)
+{
+	int val = 0;
+	int ret = 0;
+
+	ret = kstrtoint(buf, 0, &val);
+	if (ret)
+		return ret;
+
+	if (val == 0) {
+		usf_vdev.sysctl_sched_usf_up_l0 = val;
+		usf_vdev.usf_up_l0 = 0;
+	} else if ((val > 0) && (val <= BOOST_MAX_V)) {
+		usf_vdev.sysctl_sched_usf_up_l0 = val;
+		usf_vdev.usf_up_l0 = LEVEL_TOP -
+				DIV_ROUND_UP(val, BOOST_MAX_V / 2);
+		ret = count;
+	} else {
+		pr_err(USF_TAG "%d should fall into [%d %d]",
+		       val, 0, BOOST_MAX_V);
+		ret = -EINVAL;
+	}
+	if ((usf_vdev.sysctl_sched_usf_up_l0 == 0) &&
+	    (usf_vdev.sysctl_sched_usf_down == 0))
+		static_branch_disable(&adjust_task_pred_set);
+	else
+		static_branch_enable(&adjust_task_pred_set);
+
+	return ret;
+}
+
+static ssize_t store_sched_usf_down_r(struct kobject *kobj,
+				      struct kobj_attribute *attr,
+				      const char *buf, size_t count)
+{
+	int val = 0;
+	int ret = 0;
+
+	ret = kstrtoint(buf, 0, &val);
+	if (ret)
+		return ret;
+
+	if ((val >= BOOST_MIN_V) && (val <= 0)) {
+		usf_vdev.sysctl_sched_usf_down = val;
+		usf_vdev.usf_down = DIV_ROUND_UP(-val, -BOOST_MIN_V / 2);
+		ret = count;
+	} else {
+		pr_err(USF_TAG "%d should fall into [%d %d]",
+		       val, BOOST_MIN_V, 0);
+		ret = -EINVAL;
+	}
+	if ((usf_vdev.sysctl_sched_usf_up_l0 == 0) &&
+	    (usf_vdev.sysctl_sched_usf_down == 0))
+		static_branch_disable(&adjust_task_pred_set);
+	else
+		static_branch_enable(&adjust_task_pred_set);
+
+	return ret;
+}
+
+static ssize_t store_sched_usf_non_ux_r(struct kobject *kobj,
+					struct kobj_attribute *attr,
+					const char *buf, size_t count)
+{
+	int val = 0;
+	int ret = 0;
+
+	ret = kstrtoint(buf, 0, &val);
+	if (ret)
+		return ret;
+
+	if ((val >= BOOST_MIN_V) && (val <= 0)) {
+		usf_vdev.sysctl_sched_usf_non_ux = val;
+		usf_vdev.usf_non_ux = DIV_ROUND_UP(-val, -BOOST_MIN_V / 2);
+		ret = count;
+	} else {
+		pr_err(USF_TAG "%d should fall into [%d %d]",
+		       val, BOOST_MIN_V, 0);
+		ret = -EINVAL;
+	}
+	if (usf_vdev.sysctl_sched_usf_non_ux == 0)

kernel/sched/usf.c new file +9 -0

+
+usf_show_node(sched_usf_up_l0_r, sched_usf_up_l0);
+usf_show_node(sched_usf_down_r, sched_usf_down);
+usf_show_node(sched_usf_non_ux_r, sched_usf_non_ux);
+
+usf_attr_rw(sched_usf_up_l0_r);
+usf_attr_rw(sched_usf_down_r);
+usf_attr_rw(sched_usf_non_ux_r);
+

kernel/sched/usf.c new file +8 -0

+
+static int __init intera_monitor_init(void)
+{
+	int res = -1;
+	struct device *dev;
+
+	res = fb_register_client(&usf_lcd_nb);
+	if (res < 0) {

Documentation/ABI/testing/sysfs-devices-system-cpu +37 -0

+What:		/sys/devices/system/cpu/sched_usf
+		/sys/devices/system/cpu/sched_usf/sched_usf_non_ux_r
+		/sys/devices/system/cpu/sched_usf/sched_usf_up_l0_r
+		/sys/devices/system/cpu/sched_usf/sched_usf_down_r
+Date:		Aug 2020
+Contact:	Linux kernel mailing list <[email protected]>
+Description:	User Sensitive Feedback factor auxiliary scheduling which
+		is providing more utils adjustment settings to the high level
+		by scenario identification.
+		sched_usf_non_ux_r:
+			The ratio of utils is cut down on screen off. The
+			default value is 0, which no util is adjusted on sugov
+			calculating utils to select cpufreq. Its range is
+			[-100 , 0]. If its value falls into [-50, 0), the half
+			of utils, which	calculates cpufreq, shall be  cut down.
+			If its value falls into [-100, -50), only a quarter of
+			utils are left to continue to calculate cpufreq.
+			It is expected to be set [-100, 0) once enter into the
+			identificated scenario, such as listen to music on
+			screen off, and recover to 0 on out of the scenario,
+			such as	screen on.
+
+		sched_usf_up_l0_r:
+			The ratio of utils is boost up on screen on. The
+			default value is 0, which no util is adjusted on sugov
+			calculates utils to select cpufreq. Its range is [0 , 100].
+			If its value falls into (0, 50], a quarter of extra utils,
+			which calculate cpufreq, shall be added. If its value
+			falls into (50, 100], the half of extra utils are added
+			to continue to	calculate cpufreq.
+			It is expected to be set (0, 100] once enter into the
+			identificated scenario, such as browsing videolet on
+			screen on, and recover to 0 on out of the scenario,
+			such as screen off or videolet into background.
+
+		sched_usf_down_r:
+			The ratio of utils is cut down on screen on. The

drivers/cpufreq/Kconfig +8 -0

+	help
+	  Select this option to enable the adjustment on the cpufreq with
+	  the user sensitive factors on schedule. It is special for mobile
+	  devices which more power care and quick response requirement on
+	  screen on.
+
+	  If unsure, say N.
+
 if X86
 source "drivers/cpufreq/Kconfig.x86"
 endif

include/trace/events/sched.h +0 -0

index ed168b0..d5e20b7 100644

include/trace/events/sched.h +29 -0

+
+	TP_ARGS(cpu_id, up, down, nonux, utils),
+
+	TP_STRUCT__entry(
+		__field(int, cpu_id)
+		__field(int, up)
+		__field(int, down)
+		__field(int, nonux)
+		__field(unsigned long, utils)
+	),
+
+	TP_fast_assign(
+		__entry->cpu_id	= cpu_id;
+		__entry->up	= up;
+		__entry->down	= down;
+		__entry->nonux	= nonux;
+		__entry->utils	= utils;
+	),
+
+	TP_printk("cpu_id=%d up=%d down=%d nonux=%d utils=%lu",
+		  __entry->cpu_id,
+		  __entry->up,
+		  __entry->down,
+		  __entry->nonux,
+		  __entry->utils)
+);
+#endif /* CONFIG_SCHED_USF */
+
+/*
  * Tracks migration of tasks from one runqueue to another. Can be used to
  * detect if automatic NUMA balancing is bouncing between nodes.
  */

kernel/sched/Makefile +1 -0

index 5fc9c9b..58a0e7b 100644
@@ -36,3 +36,4 @@ obj-$(CONFIG_CPU_FREQ_GOV_SCHEDUTIL) += cpufreq_schedutil.o
 obj-$(CONFIG_MEMBARRIER) += membarrier.o
 obj-$(CONFIG_CPU_ISOLATION) += isolation.o
 obj-$(CONFIG_PSI) += psi.o
+obj-$(CONFIG_SCHED_USF) += usf.o

kernel/sched/cpufreq_schedutil.c +0 -0

index 7fbaee2..79a0040 100644

kernel/sched/cpufreq_schedutil.c +0 -0

 	sg_cpu->max = max;
 	sg_cpu->bw_dl = cpu_bw_dl(rq);
 

kernel/sched/usf.c new file +28 -0

new file mode 100644
index 0000000..d4d7998
@@ -0,0 +1,294 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2020 XiaoMi Inc.
+ * Author: Yang Dongdong <[email protected]>
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See http://www.gnu.org/licenses/gpl-2.0.html for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/kthread.h>
+#include <linux/cpu.h>
+#include <linux/sysfs.h>
+#include <linux/kthread.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/kallsyms.h>
+#include <linux/fb.h>
+#include <linux/notifier.h>

kernel/sched/usf.c new file +42 -0

+	} else if (rq->curr->mm) {
+		(*util) >>= usf_vdev.usf_non_ux;
+	}
+
+	trace_sched_usf_adjust_utils(cpuid, usf_vdev.usf_up_l0,
+				     usf_vdev.usf_down,
+				     usf_vdev.usf_non_ux, *util);
+}
+
+static int usf_lcd_notifier(struct notifier_block *nb,
+			    unsigned long val, void *data)
+{
+	struct fb_event *evdata = data;
+	unsigned int blank;
+
+	if (!evdata)
+		return 0;
+
+	if (val != FB_EVENT_BLANK)
+		return 0;
+
+	if (evdata->data && val == FB_EVENT_BLANK) {
+		blank = *(int *)(evdata->data);
+
+		switch (blank) {
+		case FB_BLANK_POWERDOWN:
+			usf_vdev.is_screen_on = false;
+			if (usf_vdev.sysctl_sched_usf_non_ux != 0)
+				static_branch_enable(&adjust_task_pred_set);
+			else
+				static_branch_disable(&adjust_task_pred_set);
+
+			break;
+
+		case FB_BLANK_UNBLANK:
+			usf_vdev.is_screen_on = true;
+			if (usf_vdev.sysctl_sched_usf_up_l0 != 0 ||
+			    usf_vdev.sysctl_sched_usf_down != 0)
+				static_branch_enable(&adjust_task_pred_set);
+			else
+				static_branch_disable(&adjust_task_pred_set);
+			break;

kernel/sched/usf.c new file +13 -0

+
 
+static int __init intera_monitor_init(void)
+{
+	int res = -1;
+	struct device *dev;
+
+	res = fb_register_client(&usf_lcd_nb);
+	if (res < 0) {
+		pr_err("Failed to register usf_lcd_nb!\n");
+		return res;
+	}
+
+	/*

kernel/sched/usf.c new file +11 -0

+
+	return res;
+}
+
+module_init(intera_monitor_init);
+
+static void __exit intera_monitor_exit(void)
+{
+	struct device *dev;
+
+	dev = cpu_subsys.dev_root;

Documentation/ABI/testing/sysfs-devices-system-cpu +37 -0

+What:		/sys/devices/system/cpu/sched_usf
+		/sys/devices/system/cpu/sched_usf/sched_usf_non_ux_r
+		/sys/devices/system/cpu/sched_usf/sched_usf_up_l0_r
+		/sys/devices/system/cpu/sched_usf/sched_usf_down_r
+Date:		Aug 2020
+Contact:	Linux kernel mailing list <[email protected]>
+Description:	User Sensitive Feedback factor auxiliary scheduling which
+		is providing more utils adjustment settings to the high level
+		by scenario identification.
+		sched_usf_non_ux_r:
+			The ratio of utils is cut down on screen off. The
+			default value is 0, which no util is adjusted on sugov
+			calculating utils to select cpufreq. Its range is
+			[-100 , 0]. If its value falls into [-50, 0), the half
+			of utils, which	calculates cpufreq, shall be  cut down.
+			If its value falls into [-100, -50), only a quarter of
+			utils are left to continue to calculate cpufreq.
+			It is expected to be set [-100, 0) once enter into the
+			identificated scenario, such as listen to music on
+			screen off, and recover to 0 on out of the scenario,
+			such as	screen on.
+
+		sched_usf_up_l0_r:
+			The ratio of utils is boost up on screen on. The
+			default value is 0, which no util is adjusted on sugov
+			calculates utils to select cpufreq. Its range is [0 , 100].
+			If its value falls into (0, 50], a quarter of extra utils,
+			which calculate cpufreq, shall be added. If its value
+			falls into (50, 100], the half of extra utils are added
+			to continue to	calculate cpufreq.
+			It is expected to be set (0, 100] once enter into the
+			identificated scenario, such as browsing videolet on
+			screen on, and recover to 0 on out of the scenario,
+			such as screen off or videolet into background.
+
+		sched_usf_down_r:
+			The ratio of utils is cut down on screen on. The

Appreciate Qais for your above comments. I believe the clamp is very good for terminal devices per pid or cgroup setting. I really hope it works for the extended scenario, "screen off", although it has a potential side effect on "screen on" response because it needs to be recovered at high level with latency. I set "512" to sched_util_clamp_min and max on screen off for our developing device with android kernel5.4. However, it still could not replace sched_usf_non_ux_r from the test result as attachment. The cpufreq could not go down in time.
Screenshot at 2020-08-05 09:56:38.png

Appreciate Qais for your clamp implementation. I would like to add traces for uclamp_rq_util_with and feedback you if I run into any issues.

The util would not be adjusted as soon as FB screen on notification be received by USF from kernel level if it is set by sched_usf_non_ux, no matter whether screen on or off. However, sched_util_clamp_min/max have not been recovered until user space screen on detection. The screen on response would not be in time for the sensitive user when many background tasks are running. Whether the kernel module could also
set sched_util_clamp_min/max?

From: Dongdong Yang <[email protected]>

---

Documentation/ABI/testing/sysfs-devices-system-cpu +0 -0

index b555df8..e299418 100644
@@ -614,3 +614,51 @@ Description:	SPURR ticks for cpuX when it was idle.
 
 		This sysfs interface exposes the number of SPURR ticks
 		for cpuX when it was idle.

Documentation/ABI/testing/sysfs-devices-system-cpu +15 -0

+			screen on, and recover to 0 on out of the scenario,
+			such as screen off or videolet into background.
+
+		sched_usf_down_r:
+			The ratio of utils is cut down on screen on. The
+			default	value is 0, which no util is adjusted on sugov
+			calculating utils to select cpufreq. Its range is
+			[-100 , 0]. If its value falls into [-50, 0), the half
+			of utils, which	calculate cpufreq, shall be  cut down.
+			If its value falls into [-100, -50), only a quarter of
+			utils are left to continue to calculate cpufreq.
+			It is expected to be set [-100, 0) once enter into the
+			identificated scenario, such as browsing videolet on
+			screen on, and recover to 0 on	out of the scenario,
+			such as screen off or vidolet into background.