On 9/2/2025 12:36 AM, Rafael J. Wysocki wrote:
On Mon, Sep 1, 2025 at 3:56 PM Lin Yikai yikai.lin@vivo.com wrote:
Changes in v2:
- Optimized the logic in descriptions. (Song Liu)
- Created a new header file to declare kfuncs for future extensions included by other files. (Christian Loehle)
- Fixed some logical issues in the code. (Christian Loehle)
Reference: [1] https://lore.kernel.org/bpf/20250829101137.9507-1-yikai.lin@vivo.com/
Summary
Hi, everyone, This patch set introduces an extensible cpuidle governor framework using BPF struct_ops, enabling dynamic implementation of idle-state selection policies via BPF programs.
Motivation
As is well-known, CPUs support multiple idle states (e.g., C0, C1, C2, ...), where deeper states reduce power consumption, but results in longer wakeup latency, potentially affecting performance. Existing generic cpuidle governors operate effectively in common scenarios but exhibit suboptimal behavior in specific Android phone's use cases.
Our testing reveals that during low-utilization scenarios (e.g., screen-off background tasks like music playback with CPU utilization <10%), the C0 state occupies ~50% of idle time, causing significant energy inefficiency.
I gather that this is based on measurements taken on ARM-based platforms because for x86 it is demonstrably not true.
Yes, we conducted our tests on mobile phones based on Qualcomm SoCs, which use the ARM64 platform. There are only two cpuidle states in total on these CPUs (C0/C1). Through tracing cpuidle and scheduling, we found that during screen-off music playback, although the task running time accounts for less than 10%, the C0 state's proportion exceeds 50%.
Reducing C0 to ≤20% could yield ≥5% power savings on mobile phones.
To address this, we expect: 1.Dynamic governor switching to power-saved policies for low cpu utilization scenarios (e.g., screen-off mode) 2.Dynamic switching to alternate governors for high-performance scenarios (e.g., gaming)
All of this can be done without using BPF at all, so why use it here?
Thanks for your comments.
Conclusion first ------------------ Yes,it is possible to switch different governors using sysfs nodes, but that lacks granularity and flexibility. This approach aims to preserve the common logic of existing Linux governors while adding flexibility for scenario-specific optimizations on certain SoC platforms or by ODMs.
Details second ----------------- Below is a comparison of traditional governor methods with a BPF-based approach for dynamic optimization of the cpuidle governor:
1.Agile Iteration -Traditional: Governor policies require being predetermined and statically embedded before kernel compilation. -BPF: Allows dynamic policy iteration based on real-time market user feedback User-space components can be updated via cloud deployment, eliminating the need for kernel modifications, recompilation, or reboots. It is very convenient for mobile device updates.
2.Dynamic Fine-Tuning -Traditional: Involves replacing the entire governor, which is less granular. -BPF: Allows granular tuning of governor parameters. -Examples: --Screen-off music playback: dynamically enable "expect_deeper" or other flags add by BPF progs for deeper idle states. --Gaming scenarios: Allows idle strategy parameters adjustments via user-space signals (e.g., FPS, charging state) – metrics often opaque to the kernel.
So, by exposing tunable parameters through BPF maps, user-space applications could make more run-time parameters adjustments, enhancing precision for specific scenarios.
Wish more additional insights you might have on this. Thanks, [yikai]