thermal/drivers/Kconfig: Convert the CPU cooling device to a choice
Subsystems (3)
PATCH v2 1/4 thermal/drivers/Kconfig: Convert the CPU cooling device to a choice
The next changes will add a new way to cool down a CPU by injecting idle cycles. With the current configuration, a CPU cooling device is the cpufreq cooling device. As we want to add a new CPU cooling device, let's convert the CPU cooling to a choice giving a list of CPU cooling devices. At this point, there is obviously only one CPU cooling device.
There is no functional changes.
---
V2:
- Default CPU_FREQ_COOLING when CPU_THERMAL is set (Viresh Kumar)
--- drivers/thermal/Kconfig | 14 ++++++++++++-- drivers/thermal/Makefile | 2 +- include/linux/cpu_cooling.h | 6 +++--- 3 files changed, 16 insertions(+), 6 deletions(-)
drivers/thermal/Kconfig +12 -2
@@ -150,8 +150,18 @@ config THERMAL_GOV_POWER_ALLOCATOR config CPU_THERMAL bool "Generic cpu cooling support" - depends on CPU_FREQ depends on THERMAL_OF + help + Enable the CPU cooling features. If the system has no active + cooling device available, this option allows to use the CPU + as a cooling device. + +if CPU_THERMAL + +config CPU_FREQ_THERMAL + bool "CPU frequency cooling device" + depends on CPU_FREQ + default y help This implements the generic cpu cooling mechanism through frequency reduction. An ACPI version of this already exists
@@ -159,7 +169,7 @@ config CPU_THERMAL This will be useful for platforms using the generic thermal interface and not the ACPI interface. - If you want this support, you should say Y here. +endif config CLOCK_THERMAL bool "Generic clock cooling support"
drivers/thermal/Makefile +1 -1
@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE) += user_space.o thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR) += power_allocator.o # cpufreq cooling -thermal_sys-$(CONFIG_CPU_THERMAL) += cpu_cooling.o +thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o # clock cooling thermal_sys-$(CONFIG_CLOCK_THERMAL) += clock_cooling.o
include/linux/cpu_cooling.h +3 -3
@@ -19,7 +19,7 @@struct cpufreq_policy ; -#ifdef CONFIG_CPU_THERMAL +#ifdef CONFIG_CPU_FREQ_THERMAL /** * cpufreq_cooling_register - function to create cpufreq cooling device. * @policy: cpufreq policy.
@@ -40,7 +40,7 @@ void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev);struct thermal_cooling_device *of_cpufreq_cooling_register (struct cpufreq_policy *policy); -#else /* !CONFIG_CPU_THERMAL */ +#else /* !CONFIG_CPU_FREQ_THERMAL */ static inline struct thermal_cooling_device *cpufreq_cooling_register (struct cpufreq_policy *policy) {
@@ -58,6 +58,6 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy) {return NULL ; } -#endif /* CONFIG_CPU_THERMAL */ +#endif /* CONFIG_CPU_FREQ_THERMAL */ #endif /* __CPU_COOLING_H__ */
Signature · 1 line
2.17.1
PATCH v2 2/4 thermal/drivers/cpu_cooling: Add idle cooling device documentation
Provide some documentation for the idle injection cooling effect in order to let people to understand the rational of the approach for the idle injection CPU cooling device.
--- .../driver-api/thermal/cpu-idle-cooling.rst | 166 ++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 Documentation/driver-api/thermal/cpu-idle-cooling.rst
Documentation/driver-api/thermal/cpu-idle-cooling.rst new file +166 -0
@@ -0,0 +1,166 @@ + +Situation: +---------- + +Under certain circumstances a SoC can reach the maximum temperature +limit or is unable to stabilize the temperature around a temperature +control. When the SoC has to stabilize the temperature, the kernel can +act on a cooling device to mitigate the dissipated power. When the +maximum temperature is reached and to prevent a reboot or a shutdown, +a decision must be taken to reduce the temperature under the critical +threshold, that impacts the performance. + +Another situation is when the silicon reaches a certain temperature +which continues to increase even if the dynamic leakage is reduced to +its minimum by clock gating the component. The runaway phenomena will +continue with the static leakage and only powering down the component, +thus dropping the dynamic and static leakage will allow the component +to cool down. + +Last but not least, the system can ask for a specific power budget but +because of the OPP density, we can only choose an OPP with a power +budget lower than the requested one and underuse the CPU, thus losing +performances. In other words, one OPP under uses the CPU with a power +lesser than the power budget and the next OPP exceed the power budget, +an intermediate OPP could have been used if it were present. + +Solutions: +---------- + +If we can remove the static and the dynamic leakage for a specific +duration in a controlled period, the SoC temperature will +decrease. Acting at the idle state duration or the idle cycle +injection period, we can mitigate the temperature by modulating the +power budget. + +The Operating Performance Point (OPP) density has a great influence on +the control precision of cpufreq, however different vendors have a +plethora of OPP density, and some have large power gap between OPPs, +that will result in loss of performance during thermal control and +loss of power in other scenes. + +At a specific OPP, we can assume injecting idle cycle on all CPUs, +belonging to the same cluster, with a duration greater than the +cluster idle state target residency, we drop the static and the +dynamic leakage for this period (modulo the energy needed to enter +this state). So the sustainable power with idle cycles has a linear +relation with the OPP’s sustainable power and can be computed with a +coefficient similar to: + + Power(IdleCycle) = Coef x Power(OPP) + +Idle Injection: +--------------- + +The base concept of the idle injection is to force the CPU to go to an +idle state for a specified time each control cycle, it provides +another way to control CPU power and heat in addition to +cpufreq. Ideally, if all CPUs belonging to the same cluster, inject +their idle cycle synchronously, the cluster can reach its power down +state with a minimum power consumption and static leakage +drop. However, these idle cycles injection will add extra latencies as +the CPUs will have to wakeup from a deep sleep state. + + ^ + | + | + |------- ------- ------- + |_______|_____|_______|_____|_______|___________ + + <-----> + idle <----> + running + +With the fixed idle injection duration, we can give a value which is +an acceptable performance drop off or latency when we reach a specific +temperature and we begin to mitigate by varying the Idle injection +period. + +The mitigation begins with a maximum period value which decrease when +more cooling effect is requested. When the period duration is equal to +the idle duration, then we are in a situation the platform can’t +dissipate the heat enough and the mitigation fails. In this case the +situation is considered critical and there is nothing to do. The idle +injection duration must be changed by configuration and until we reach +the cooling effect, otherwise an additionnal cooling device must be +used or ultimately decrease the SoC performance by dropping the +highest OPP point of the SoC. + +The idle injection duration value must comply with the constraints: + +- It is lesser or equal to the latency we tolerate when the mitigation + begins. It is platform dependent and will depend on the user + experience, reactivity vs performance trade off we want. This value + should be specified. + +- It is greater than the idle state’s target residency we want to go + for thermal mitigation, otherwise we end up consuming more energy. + +Minimum period +-------------- + +The idle injection duration being fixed, it is obvious the minimum +period can’t be lesser than that, otherwise we will be scheduling the +idle injection task right before the idle injection duration is +complete, so waking up the CPU to put it asleep again. + +Maximum period +-------------- + +The maximum period is the initial period when the mitigation +begins. Theoretically when we reach the thermal trip point, we have to +sustain a specified power for specific temperature but at this time we +consume: + + Power = Capacitance x Voltage^2 x Frequency x Utilisation + +... which is more than the sustainable power (or there is something +wrong on the system setup). The ‘Capacitance’ and ‘Utilisation’ are a +fixed value, ‘Voltage’ and the ‘Frequency’ are fixed artificially +because we don’t want to change the OPP. We can group the +‘Capacitance’ and the ‘Utilisation’ into a single term which is the +‘Dynamic Power Coefficient (Cdyn)’ Simplifying the above, we have: + + Pdyn = Cdyn x Voltage^2 x Frequency + +The IPA will ask us somehow to reduce our power in order to target the +sustainable power defined in the device tree. So with the idle +injection mechanism, we want an average power (Ptarget) resulting on +an amount of time running at full power on a specific OPP and idle +another amount of time. That could be put in a equation: + + P(opp)target = ((trunning x (P(opp)running) + (tidle P(opp)idle)) / + (trunning + tidle) + ... + + tidle = trunning x ((P(opp)running / P(opp)target) - 1) + +At this point if we know the running period for the CPU, that gives us +the idle injection, we need. Alternatively if we have the idle +injection duration, we can compute the running duration with: + + trunning = tidle / ((P(opp)running / P(opp)target) - 1) + +Practically, if the running power is lesses than the targeted power, +we end up with a negative time value, so obviously the equation usage +is bound to a power reduction, hence a higher OPP is needed to have +the running power greater than the targeted power. + +However, in this demonstration we ignore three aspects: + + * The static leakage is not defined here, we can introduce it in the + equation but assuming it will be zero most of the time as it is + difficult to get the values from the SoC vendors + + * The idle state wake up latency (or entry + exit latency) is not + taken into account, it must be added in the equation in order to + rigorously compute the idle injection + + * The injected idle duration must be greater than the idle state + target residency, otherwise we end up consuming more energy and + potentially invert the mitigation effect + +So the final equation is: + + trunning = (tidle - twakeup ) x + (((P(opp)dyn + P(opp)static ) - P(opp)target) / P(opp)target )
Signature · 1 line
2.17.1
Re: [PATCH V2 2/4] thermal/drivers/cpu_cooling: Add idle cooling device documentation
Quoted 9 lines · Daniel Lezcano
Provide some documentation for the idle injection cooling effect in order to let people to understand the rational of the approach for the idle injection CPU cooling device.
Signed-off-by Daniel Lezcano <[email protected]>--- .../driver-api/thermal/cpu-idle-cooling.rst | 166 ++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 Documentation/driver-api/thermal/cpu-idle-cooling.rst
Signature · 1 line
viresh
PATCH v2 3/4 thermal/drivers/cpu_cooling: Introduce the cpu idle cooling driver
In reply to Daniel LezcanoThe cpu idle cooling device offers a new method to cool down a CPU by injecting idle cycles at runtime.
It has some similarities with the intel power clamp driver but it is actually designed to be more generic and relying on the idle injection powercap framework.
The idle injection cycle is fixed while the running cycle is variable. That allows to have control on the device reactivity for the user experience.
An idle state powering down the CPU or the cluster will allow to drop the static leakage, thus restoring the heat capacity of the SoC. It can be set with a trip point between the hot and the critical points, giving the opportunity to prevent a hard reset of the system when the cpufreq cooling fails to cool down the CPU.
With more sophisticated boards having a per core sensor, the idle cooling device allows to cool down a single core without throttling the compute capacity of several cpus belonging to the same clock line, so it could be used in collaboration with the cpufreq cooling device.
---
V2:
- Remove idle_duration_us field and use idle_inject API instead (Viresh Kumar)
- Fixed function definition wheh CPU_IDLE_COOLING is not set
- Inverted the initialization in the init function (Viresh Kumar)
--- drivers/thermal/Kconfig | 7 + drivers/thermal/Makefile | 1 + drivers/thermal/cpuidle_cooling.c | 233 ++++++++++++++++++++++++++++++ include/linux/cpu_cooling.h | 22 +++ 4 files changed, 263 insertions(+) create mode 100644 drivers/thermal/cpuidle_cooling.c
drivers/thermal/Kconfig +7 -0
@@ -169,6 +169,13 @@ config CPU_FREQ_THERMAL This will be useful for platforms using the generic thermal interface and not the ACPI interface. +config CPU_IDLE_THERMAL + bool "CPU idle cooling device" + depends on IDLE_INJECT + help + This implements the CPU cooling mechanism through + idle injection. This will throttle the CPU by injecting + idle cycle. endif config CLOCK_THERMAL
drivers/thermal/Makefile +1 -0
@@ -20,6 +20,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR) += power_allocator.o # cpufreq cooling thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o +thermal_sys-$(CONFIG_CPU_IDLE_THERMAL) += cpuidle_cooling.o # clock cooling thermal_sys-$(CONFIG_CLOCK_THERMAL) += clock_cooling.o
drivers/thermal/cpuidle_cooling.c new file +233 -0
233 lines not on this page · raw message
include/linux/cpu_cooling.h +22 -0
@@ -60,4 +60,26 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy) }#endif /* CONFIG_CPU_FREQ_THERMAL */ +struct cpuidle_driver ; + +#ifdef CONFIG_CPU_IDLE_THERMAL +extern struct thermal_cooling_device * +__init cpuidle_cooling_register (struct cpuidle_driver *drv); +extern struct thermal_cooling_device * +__init cpuidle_of_cooling_register (struct device_node *np, +struct cpuidle_driver *drv); +#else /* CONFIG_CPU_IDLE_THERMAL */ +static inline struct thermal_cooling_device * +__init cpuidle_cooling_register (struct cpuidle_driver *drv) +{ +return ERR_PTR (-EINVAL ); +} +static inline struct thermal_cooling_device * +__init cpuidle_of_cooling_register (struct device_node *np, +struct cpuidle_driver *drv) +{ +return ERR_PTR (-EINVAL ); +} +#endif /* CONFIG_CPU_IDLE_THERMAL */ +#endif /* __CPU_COOLING_H__ */
Signature · 1 line
2.17.1
Re: [PATCH V2 3/4] thermal/drivers/cpu_cooling: Introduce the cpu idle cooling driver
Quoted 3 lines · Daniel Lezcano
+/**
+ *cpuidle_of_cooling_register- Idle cooling device initialization function
+ * @drv: a cpuidle driver structure pointer
@np missing here.
Quoted 5 lines
+ *
+ * This function is in charge of creating a cooling device per cpuidle
+ * driver and register it to thermal framework.
+ *
+ * Returns a valid pointer to a thermal cooling device, aPTR_ERR
s/, a/, or a/ ?
Quoted 76 lines
+ * corresponding to the error detected in the underlying subsystems.
+ */drivers/thermal/cpuidle_cooling.c new file +68
-0+struct thermal_cooling_device * +__init cpuidle_of_cooling_register (struct device_node *np, +struct cpuidle_driver *drv) +{ +struct idle_inject_device *ii_dev; +struct cpuidle_cooling_device *idle_cdev; +struct thermal_cooling_device *cdev; +char dev_name[THERMAL_NAME_LENGTH ]; +int id, ret; + + idle_cdev =kzalloc (sizeof (*idle_cdev),GFP_KERNEL ); +if (!idle_cdev) { + ret = -ENOMEM ; + goto out; + } + + id =ida_simple_get (&cpuidle_ida,0 ,0 ,GFP_KERNEL ); +if (id <0 ) { + ret = id; + goto out_kfree; + } + + ii_dev =idle_inject_register (drv->cpumask); +if (IS_ERR (ii_dev)) { + ret =PTR_ERR (ii_dev); + goto out_id; + } + +idle_inject_set_duration (ii_dev,0 ,TICK_USEC ); + + idle_cdev->ii_dev = ii_dev; + +snprintf (dev_name,sizeof (dev_name),"thermal-idle-%d" , id); + + cdev =thermal_of_cooling_device_register (np, dev_name, idle_cdev, + &cpuidle_cooling_ops); +if (IS_ERR (cdev)) { + ret =PTR_ERR (cdev); + goto out_unregister; + } + +return cdev; + +out_unregister: +idle_inject_unregister (ii_dev); +out_id: +ida_simple_remove (&cpuidle_ida, id); +out_kfree: +kfree (idle_cdev); +out: +return ERR_PTR (ret); +} + +/** +* cpuidle_cooling_register - Idle cooling device initialization function +* @drv: a cpuidle driver structure pointer +* +* This function is in charge of creating a cooling device per cpuidle +* driver and register it to thermal framework. +* +* Returns a valid pointer to a thermal cooling device, a PTR_ERR +* corresponding to the error detected in the underlying subsystems. +*/ +struct thermal_cooling_device * +__init cpuidle_cooling_register (struct cpuidle_driver *drv) +{ +return cpuidle_of_cooling_register (NULL , drv); +}include/linux/cpu_cooling.h +0
-0@@ -60,4 +60,26 @@ of_cpufreq_cooling_register(struct cpufreq_policy *policy) }
include/linux/cpu_cooling.h of_cpufreq_cooling_register(struct cpufreq_policy *policy) · line 70
Quoted 10 lines
include/linux/cpu_cooling.h +8
-0#endif /* CONFIG_CPU_FREQ_THERMAL */ +struct cpuidle_driver ; + +#ifdef CONFIG_CPU_IDLE_THERMAL +extern struct thermal_cooling_device * +__init cpuidle_cooling_register (struct cpuidle_driver *drv); +extern struct thermal_cooling_device * +__init cpuidle_of_cooling_register (struct device_node *np, +struct cpuidle_driver *drv);
Maybe just drop the "extern" thing here as it is redundant really.
Quoted 5 lines
include/linux/cpu_cooling.h +5
-0+#else /* CONFIG_CPU_IDLE_THERMAL */ +static inline struct thermal_cooling_device * +__init cpuidle_cooling_register (struct cpuidle_driver *drv) +{ +return ERR_PTR (-EINVAL );
include/linux/cpu_cooling.h of_cpufreq_cooling_register(struct cpufreq_policy *policy) · line 85
Quoted 10 lines
include/linux/cpu_cooling.h +9
-0+} +static inline struct thermal_cooling_device * +__init cpuidle_of_cooling_register (struct device_node *np, +struct cpuidle_driver *drv) +{ +return ERR_PTR (-EINVAL ); +} +#endif /* CONFIG_CPU_IDLE_THERMAL */ +#endif /* __CPU_COOLING_H__ */
Signature · 1 line
viresh
Viresh Kumar
maintainerRe: [PATCH V2 3/4] thermal/drivers/cpu_cooling: Introduce the cpu idle cooling driver
In reply to Daniel LezcanoQuoted 21 lines · Daniel Lezcano
The cpu idle cooling device offers a new method to cool down a CPU by injecting idle cycles at runtime.
It has some similarities with the intel power clamp driver but it is actually designed to be more generic and relying on the idle injection powercap framework.
The idle injection cycle is fixed while the running cycle is variable. That allows to have control on the device reactivity for the user experience.
An idle state powering down the CPU or the cluster will allow to drop the static leakage, thus restoring the heat capacity of the SoC. It can be set with a trip point between the hot and the critical points, giving the opportunity to prevent a hard reset of the system when the cpufreq cooling fails to cool down the CPU.
With more sophisticated boards having a per core sensor, the idle cooling device allows to cool down a single core without throttling the compute capacity of several cpus belonging to the same clock line, so it could be used in collaboration with the cpufreq cooling device.
Quoted 8 lines
Signed-off-by Daniel Lezcano <[email protected]>---
V2:
- Removeidle_duration_usfield and useidle_injectAPI instead (Viresh Kumar)
- Fixed function definition whehCPU_IDLE_COOLINGis not set
- Inverted the initialization in the init function (Viresh Kumar)--- drivers/thermal/cpuidle_cooling.c | 233 ++++++++++++++++++++++++++++++
This needs to go in MAINTAINERS file btw :)
Signature · 1 line
viresh
PATCH v2 4/4 thermal/drivers/cpu_cooling: Rename to cpufreq_cooling
In reply to Daniel LezcanoAs we introduced the idle injection cooling device called cpuidle_cooling, let's be consistent and rename the cpu_cooling to cpufreq_cooling as this one mitigates with OPPs changes.
---
drivers/thermal/Makefile | 2 +-
drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} | 0
2 files changed, 1 insertion(+), 1 deletion(-)
rename drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} (100%)drivers/thermal/Makefile +1 -1
@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE) += user_space.o thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR) += power_allocator.o # cpufreq cooling -thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o +thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpufreq_cooling.o thermal_sys-$(CONFIG_CPU_IDLE_THERMAL) += cpuidle_cooling.o # clock cooling
drivers/thermal/cpufreq_cooling.c renamed from drivers/thermal/cpu_cooling.c +0 -0
Signature · 1 line
2.17.1
Viresh Kumar
maintainerRe: [PATCH V2 4/4] thermal/drivers/cpu_cooling: Rename to cpufreq_cooling
drivers/thermal/cpufreq_cooling.c
Quoted 28 lines · Daniel Lezcano
As we introduced the idle injection cooling device called
cpuidle_cooling, let's be consistent and rename thecpu_coolingtocpufreq_coolingas this one mitigates with OPPs changes.Signed-off-by Daniel Lezcano <[email protected]>--- drivers/thermal/Makefile | 2 +- drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename drivers/thermal/{cpu_cooling.c => cpufreq_cooling.c} (100%)drivers/thermal/Makefile +1
-1@@ -19,7 +19,7 @@ thermal_sys-$(CONFIG_THERMAL_GOV_USER_SPACE) += user_space.o thermal_sys-$(CONFIG_THERMAL_GOV_POWER_ALLOCATOR) += power_allocator.o # cpufreq cooling -thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpu_cooling.o +thermal_sys-$(CONFIG_CPU_FREQ_THERMAL) += cpufreq_cooling.o thermal_sys-$(CONFIG_CPU_IDLE_THERMAL) += cpuidle_cooling.o # clock coolingdrivers/thermal/cpufreq_cooling.c renamed from drivers/thermal/cpu_cooling.c +0
-0
This isn't enough. Please grep for cpu_cooling and you will see other places that you need to fix as well :)
Signature · 1 line
viresh
Quoted 10 lines · Daniel Lezcano
The next changes will add a new way to cool down a CPU by injecting idle cycles. With the current configuration, a CPU cooling device is the cpufreq cooling device. As we want to add a new CPU cooling device, let's convert the CPU cooling to a choice giving a list of CPU cooling devices. At this point, there is obviously only one CPU cooling device.
There is no functional changes.
Signed-off-by Daniel Lezcano <[email protected]>
Quoted 8 lines
---
V2:
- DefaultCPU_FREQ_COOLINGwhenCPU_THERMALis set (Viresh Kumar)--- drivers/thermal/Kconfig | 14 ++++++++++++-- drivers/thermal/Makefile | 2 +- include/linux/cpu_cooling.h | 6 +++--- 3 files changed, 16 insertions(+), 6 deletions(-)
Signature · 1 line
viresh