[PATCH 1/2] sched: Add default dynamic preempt mode Kconfig

[Frederic Weisbecker]

Currently the default behaviour for CONFIG_PREEMPT_DYNAMIC is
preempt=full. So distros always have to override that with the boot
option if it's not their default choice.

Make things more convenient for them with providing that choice at
Kconfig time.

This should also encourage automatic testing robots relying on randconfig
to run through all the various preempt dynamic flavours.

(Unfortunately this involved copy-pasting help text for static PREEMPT
Kconfig entries. Perhaps referring to them would be enough?)

Signed-off-by: Frederic Weisbecker <frederic@xxxxxxxxxx>
---
 kernel/Kconfig.preempt | 53 ++++++++++++++++++++++++++++++++++++++++++
 kernel/sched/core.c    | 23 +++++++++++++++++-
 2 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/kernel/Kconfig.preempt b/kernel/Kconfig.preempt
index bd7c4147b9a8..384110d1a215 100644
--- a/kernel/Kconfig.preempt
+++ b/kernel/Kconfig.preempt
@@ -100,6 +100,59 @@ config PREEMPT_DYNAMIC
 	  Interesting if you want the same pre-built kernel should be used for
 	  both Server and Desktop workloads.
 
+choice
+	prompt "Preemption dynamic default boot mode"
+	default PREEMPT_DYNAMIC_FULL
+	depends on PREEMPT_DYNAMIC
+
+config PREEMPT_DYNAMIC_NONE
+	bool "Default boot with no Forced Preemption (Server)"
+	help
+	  This is the traditional Linux preemption model, geared towards
+	  throughput. It will still provide good latencies most of the
+	  time, but there are no guarantees and occasional longer delays
+	  are possible.
+
+	  Select this option if you are building a kernel for a server or
+	  scientific/computation system, or if you want to maximize the
+	  raw processing power of the kernel, irrespective of scheduling
+	  latencies.
+
+config PREEMPT_DYNAMIC_VOLUNTARY
+	bool "Default boot with Voluntary Kernel Preemption (Desktop)"
+	help
+	  This option reduces the latency of the kernel by adding more
+	  "explicit preemption points" to the kernel code. These new
+	  preemption points have been selected to reduce the maximum
+	  latency of rescheduling, providing faster application reactions,
+	  at the cost of slightly lower throughput.
+
+	  This allows reaction to interactive events by allowing a
+	  low priority process to voluntarily preempt itself even if it
+	  is in kernel mode executing a system call. This allows
+	  applications to run more 'smoothly' even when the system is
+	  under load.
+
+	  Select this if you are building a kernel for a desktop system.
+
+config PREEMPT_DYNAMIC_FULL
+	bool "Default boot with Preemptible Kernel (Low-Latency Desktop)"
+	help
+	  This option reduces the latency of the kernel by making
+	  all kernel code (that is not executing in a critical section)
+	  preemptible.  This allows reaction to interactive events by
+	  permitting a low priority process to be preempted involuntarily
+	  even if it is in kernel mode executing a system call and would
+	  otherwise not be about to reach a natural preemption point.
+	  This allows applications to run more 'smoothly' even when the
+	  system is under load, at the cost of slightly lower throughput
+	  and a slight runtime overhead to kernel code.
+
+	  Select this if you are building a kernel for a desktop or
+	  embedded system with latency requirements in the milliseconds
+	  range.
+endchoice
+
 config SCHED_CORE
 	bool "Core Scheduling for SMT"
 	default y
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 9e9a5be35cde..df47a8275c37 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -6238,6 +6238,14 @@ enum {
 
 int preempt_dynamic_mode = preempt_dynamic_full;
 
+#if defined(CONFIG_PREEMPT_DYNAMIC_FULL)
+static __initdata int preempt_dynamic_mode_init = preempt_dynamic_full;
+#elif defined(CONFIG_PREEMPT_DYNAMIC_VOLUNTARY)
+static __initdata int preempt_dynamic_mode_init = preempt_dynamic_voluntary;
+#elif defined(CONFIG_PREEMPT_DYNAMIC_NONE)
+static __initdata int preempt_dynamic_mode_init = preempt_dynamic_none;
+#endif
+
 int sched_dynamic_mode(const char *str)
 {
 	if (!strcmp(str, "none"))
@@ -6254,6 +6262,9 @@ int sched_dynamic_mode(const char *str)
 
 void sched_dynamic_update(int mode)
 {
+	if (preempt_dynamic_mode == mode)
+		return;
+
 	/*
 	 * Avoid {NONE,VOLUNTARY} -> FULL transitions from ever ending up in
 	 * the ZERO state, which is invalid.
@@ -6304,13 +6315,22 @@ static int __init setup_preempt_mode(char *str)
 		return 1;
 	}
 
-	sched_dynamic_update(mode);
+	preempt_dynamic_mode_init = mode;
+
 	return 0;
 }
 __setup("preempt=", setup_preempt_mode);
 
+static void __init init_preempt(void)
+{
+	if (preempt_dynamic_mode_init != preempt_dynamic_full)
+		sched_dynamic_update(preempt_dynamic_mode_init);
+}
+#else
+static inline void init_preempt(void) { }
 #endif /* CONFIG_PREEMPT_DYNAMIC */
 
+
 /*
  * This is the entry point to schedule() from kernel preemption
  * off of irq context.
@@ -9079,6 +9099,7 @@ void __init sched_init(void)
 	psi_init();
 
 	init_uclamp();
+	init_preempt();
 
 	scheduler_running = 1;
 }
-- 
2.25.1