Introduce a new driver in virt named steal_governor. This driver will compute the steal time and drive the policy decisions of preferred CPU state.
More on it can be found in the Documentation/driver-api/steal-governor.rst There is a new kconfig called STEAL_GOVERNOR which is introduced in subsequent patches. That driver is going to select PREFERRED_CPU. This makes configs driven by user preference. When the driver is disabled, preferred CPUs is same as active CPUs. File layout of the driver is being kept simple. - core.c - contains main driver code. This includes the periodic work function and take action on steal time which is introduced in subsequent patches. - core.h - header file which includes data structure. Main structure of steal governor has, - work: deferred periodic work function - steal, time: To calculate the delta in periodic work. - interval_ms, high_threshold, low_threshold: debug knobs of steal_governor. While there, Add MAINTAINERS entry for this new driver. Signed-off-by: Shrikanth Hegde <[email protected]> --- Documentation/driver-api/index.rst | 1 + Documentation/driver-api/steal-governor.rst | 117 ++++++++++++++++++++ MAINTAINERS | 9 ++ drivers/virt/steal_governor/core.c | 48 ++++++++ drivers/virt/steal_governor/core.h | 25 +++++ 5 files changed, 200 insertions(+) create mode 100644 Documentation/driver-api/steal-governor.rst create mode 100644 drivers/virt/steal_governor/core.c create mode 100644 drivers/virt/steal_governor/core.h diff --git a/Documentation/driver-api/index.rst b/Documentation/driver-api/index.rst index eaf7161ff957..0a973b59cba3 100644 --- a/Documentation/driver-api/index.rst +++ b/Documentation/driver-api/index.rst @@ -138,6 +138,7 @@ Subsystem-specific APIs sm501 soundwire/index spi + steal-governor surface_aggregator/index switchtec sync_file diff --git a/Documentation/driver-api/steal-governor.rst b/Documentation/driver-api/steal-governor.rst new file mode 100644 index 000000000000..1039d598fc2c --- /dev/null +++ b/Documentation/driver-api/steal-governor.rst @@ -0,0 +1,117 @@ +.. SPDX-License-Identifier: GPL-2.0 + +============== +Steal Governor +============== + +:Author: Shrikanth Hegde <[email protected]> + +Introduction +============ + +Steal governor is a driver aimed at solving the Noisy Neighbour problem +in paravirtualized environments. The performance of workload +running in one VM gets affected significantly due to other VMs and +combined they make slower forward progress. + +When there is overcommit of CPU resources, i.e. sum of virtual CPUs (vCPUs) +of all VMs is greater than number of physical CPUs (pCPUs) and +when all or many VMs have high utilization, hypervisor won't be able +to satisfy the CPU requirement and has to context switch within or +across VMs. I.e. the hypervisor needs to preempt one vCPU to run +another. This is called vCPU preemption. +This is more expensive compared to task context switch within a vCPU. + +In such cases it is better that combined vCPU ask from all VMs is reduced +by not using some of the vCPUs. vCPUs where workload can be safely +scheduled which won't increase any contention for pCPU are called as +"Preferred CPUs". + +See more on "Preferred CPUs" in Documentation/scheduler/sched-arch.rst. + +This driver makes CONFIG_PREFERRED_CPU=y which enables the scheduler core +infrastructure to move tasks to Preferred CPUs where possible. + +Core idea +========= + +steal time is an indication available today in Guest which shows contention +for underlying physical CPU. Use it as a hint in the guest to fold the +workload to a reduced set of vCPUs. When there is contention, steal time +will show up in all the guests. When each guest honors the hint and folds +the workload to a smaller set of vCPUs (Preferred CPUs), it reduces the +contention and thereby reduces vCPU preemption. +This is achieved without any cross-guest communication. + +Steal governor driver effectively does: + +1. Periodically computes steal time across the system. + +2. If steal time is greater than high threshold, reduce the number of + preferred CPUs by 1 core. Ensure at least one core is left always. + +3. If steal time is lower or equal to low threshold, increase the + number of preferred CPUs by 1 core. If preferred is same as active, + nothing to be done. + +4. Ensure preferred CPUs is always subset of active CPUs. + On feature disable it is same as active CPUs. + +This feature works best only when all the VMs enable the feature as +it is a co-operative scheme. If a specific VM doesn't enable this feature +it may end up with more CPUs than others, still should lead to better +performance when seen from system view. +Those who enable this driver must ensure it is enabled in all VMs. + +Module Parameters +================= + +interval_ms +----------- + +How often steal governor checks for steal time. +Default: 1000 i.e 1 second. Value should be in between 100ms to 100sec. + +This controls how fast steal governor driver reacts to changes to +the contention of physical CPUs. Since it does a fair amount of +work, setting too low may have overhead. Setting it too +high might render it ineffective. + +low_threshold +------------- + +lower threshold value in percentage * 100. +Default: 200, i.e 2% steal is considered as low threshold. +Can't be higher than high_threshold. + +This determines what values should be considered as nil/no steal values. +When steal governor see steal time is below or equal to this value, it +will increase the preferred CPUs by 1 core. Having value as zero +might cause oscillations. + +high_threshold +-------------- + +higher threshold value in percentage * 100 +Default: 500, i.e 5% steal is considered as high threshold. +Can't be lower than low_threshold. Must be less than 10000. + +This determines what values should be considered as high steal values. +When steal governor sees steal time is higher than this value, it will +reduce the preferred CPUs by 1 core. + +Notes +===== + +Selecting this driver makes CONFIG_PREFERRED_CPU=y. That makes configs +driven by user preference. + +It is recommended to build CONFIG_STEAL_GOVERNOR=m due to below reasons: + +1. Doing periodic work has additional overheads. Enabling this driver + in systems where steal time cannot happen is of no use. There is no + benefit with additional overheads in such systems. + +2. This works well when all VMs work in co-operative manner. When an + administrative user enables it in one VM, he/she will likely enable + it all VMs. diff --git a/MAINTAINERS b/MAINTAINERS index 15011f5752a9..0906684b2243 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -25914,6 +25914,15 @@ F: rust/helpers/jump_label.c F: rust/kernel/generated_arch_static_branch_asm.rs.S F: rust/kernel/jump_label.rs +STEAL GOVERNOR DRIVER +M: Shrikanth Hegde <[email protected]> +R: Yury Norov <[email protected]> +L: [email protected] +S: Maintained +T: git git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched/core +F: Documentation/driver-api/steal-governor.rst +F: drivers/virt/steal_governor/ + STI AUDIO (ASoC) DRIVERS M: Arnaud Pouliquen <[email protected]> L: [email protected] diff --git a/drivers/virt/steal_governor/core.c b/drivers/virt/steal_governor/core.c new file mode 100644 index 000000000000..055f155d2045 --- /dev/null +++ b/drivers/virt/steal_governor/core.c @@ -0,0 +1,48 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Steal time governor driver periodically computes steal time. + * Based on the thresholds it either reduce/increase the preferred + * CPUs which can be used by the workload to avoid vCPU preemption + * to an extent possible in paravirtualized environment. + * + * Available as module with CONFIG_STEAL_GOVERNOR + * + * Copyright (C) 2026 IBM + * Author: Shrikanth Hegde <[email protected]> + */ + +#include "core.h" + +#if !IS_ENABLED(CONFIG_PREFERRED_CPU) +#error "Steal Governor requires CONFIG_PREFERRED_CPU" +#endif + +static struct steal_governor sg_core_ctx; + +static void restore_preferred_to_active(void) +{ + int cpu; + + guard(cpus_read_lock)(); + for_each_cpu(cpu, cpu_active_mask) + set_cpu_preferred(cpu, true); +} + +static int __init steal_governor_init(void) +{ + pr_info("steal_governor is enabled\n"); + return 0; +} + +static void __exit steal_governor_exit(void) +{ + restore_preferred_to_active(); + pr_info("steal_governor is disabled\n"); +} + +module_init(steal_governor_init); +module_exit(steal_governor_exit); + +MODULE_LICENSE("GPL"); +MODULE_AUTHOR("IBM Corporation"); +MODULE_DESCRIPTION("Virtualization Steal Time Governor"); diff --git a/drivers/virt/steal_governor/core.h b/drivers/virt/steal_governor/core.h new file mode 100644 index 000000000000..e27305284ac0 --- /dev/null +++ b/drivers/virt/steal_governor/core.h @@ -0,0 +1,25 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +#ifndef __VIRT_STEAL_CORE_H +#define __VIRT_STEAL_CORE_H + +#include <linux/types.h> + +#include <linux/module.h> +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/cpuhplock.h> +#include <linux/cpumask.h> +#include <linux/workqueue.h> +#include <linux/ktime.h> +#include <linux/kconfig.h> + +struct steal_governor { + struct delayed_work work; + ktime_t time; + u64 steal; + unsigned int interval_ms; + unsigned int high_threshold; + unsigned int low_threshold; +}; + +#endif /* __VIRT_STEAL_CORE_H */ -- 2.47.3
