Add test to verify cpuidle governor ext's load, attach, and kfuncs.
This patch also provides a simple demonstration of `cpuidle_gov_ext_ops` usage:
- In `ops.init()`, we set the "rating" value to 60 - significantly exceeding other governors' ratings - to activate `cpuidle_gov_ext`.
- For specific scenarios (e.g., screen-off music playback on mobile devices), we can enable "expect_deeper" to transition to deeper idle states.
This implementation serves as a foundation, not a final solution.
We can explore further exploration of cpuidle strategies optimized for various usage scenarios.
Signed-off-by: Lin Yikai <yikai.lin@xxxxxxxx>
---
.../bpf/prog_tests/test_cpuidle_gov_ext.c | 28 +++
.../selftests/bpf/progs/cpuidle_gov_ext.c | 208 ++++++++++++++++++
2 files changed, 236 insertions(+)
create mode 100644 tools/testing/selftests/bpf/prog_tests/test_cpuidle_gov_ext.c
create mode 100644 tools/testing/selftests/bpf/progs/cpuidle_gov_ext.c
diff --git a/tools/testing/selftests/bpf/prog_tests/test_cpuidle_gov_ext.c b/tools/testing/selftests/bpf/prog_tests/test_cpuidle_gov_ext.c
new file mode 100644
index 000000000000..8b35771ada44
--- /dev/null
+++ b/tools/testing/selftests/bpf/prog_tests/test_cpuidle_gov_ext.c
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * test_cpuidle_gov_ext.c - test cpuidle governor ext's load, attach and kfuncs
+ *
+ * Copyright (C) Yikai Lin <yikai.lin@xxxxxxxx>
+ */
+
+#include <test_progs.h>
+#include "cpuidle_gov_ext.skel.h"
+
+void test_test_cpuidle_gov_ext(void)
+{
+ struct cpuidle_gov_ext *skel;
+ int err;
+
+ skel = cpuidle_gov_ext__open_and_load();
+ if (!ASSERT_OK_PTR(skel, "cpuidle_gov_ext__open_and_load"))
+ return;
+
+ skel->bss->expect_deeper = 1;
+ err = cpuidle_gov_ext__attach(skel);
+ if (!ASSERT_OK(err, "cpuidle_gov_ext__attach"))
+ goto cleanup;
+
+cleanup:
+ cpuidle_gov_ext__destroy(skel);
+}
+
diff --git a/tools/testing/selftests/bpf/progs/cpuidle_gov_ext.c b/tools/testing/selftests/bpf/progs/cpuidle_gov_ext.c
new file mode 100644
index 000000000000..62d5a9bc8cb3
--- /dev/null
+++ b/tools/testing/selftests/bpf/progs/cpuidle_gov_ext.c
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * cpuidle_gov_ext.c - test to use cpuidle governor ext by bpf
+ *
+ * Copyright (C) Yikai Lin <yikai.lin@xxxxxxxx>
+ */
+
+#include "vmlinux.h"
+
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+#include <bpf/bpf_core_read.h>
+
+char LICENSE[] SEC("license") = "GPL";
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+#ifndef max
+#define max(a, b) ((a) > (b) ? (a) : (b))
+#endif
+#ifndef min
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#define ALPHA 10
+#define ALPHA_SCALE 100
+#define FIT_FACTOR 90
+
+/*
+ * For some low-power scenarios,
+ * such as the screen off scenario of mobile devices
+ * (which will be determined by the user-space BPF program),
+ * we aim to choose a deeper state
+ * At this point, we will somewhat disregard the impact on CPU performance.
+ */
+int expect_deeper = 0;
+
+int bpf_cpuidle_ext_gov_update_rating(unsigned int rating) __ksym __weak;
+s64 bpf_cpuidle_ext_gov_latency_req(unsigned int cpu) __ksym __weak;
+s64 bpf_tick_nohz_get_sleep_length(void) __ksym __weak;
+
+struct cpuidle_gov_data {
+ int cpu;
+ int last_idx;
+ u64 last_pred;
+ u64 last_duration;
+ u64 next_pred;
+};
+
+struct {
+ __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+ __uint(max_entries, 1);
+ __type(key, u32);
+ __type(value, struct cpuidle_gov_data);
+} cpuidle_gov_data_map SEC(".maps");
+
+static u64 calculate_ewma(u64 last, u64 new, u32 alpha, u32 alpha_scale)
+{
+ return (alpha * new + (alpha_scale - alpha) * last) / alpha_scale;
+}
+
+static void update_predict_duration(struct cpuidle_gov_data *data,
+ struct cpuidle_driver *drv, struct cpuidle_device *dev)
+{
+ int idx;
+ struct cpuidle_state target;
+
+ if (!data || !drv || !dev)
+ return;
+ idx = data->last_idx;
+ data->last_duration = dev->last_residency_ns;
+ if (idx > 0) {
+ bpf_core_read(&target, sizeof(target), &drv->states[idx]);
+ if (data->last_duration > target.exit_latency)
+ data->last_duration -= target.exit_latency;
+ }
+ data->last_pred = data->next_pred;
+ data->next_pred = calculate_ewma(data->next_pred,
+ data->last_duration, ALPHA, ALPHA_SCALE);
+}
+
+/* Enable the cpuidle governor */
+SEC("struct_ops.s/enable")
+int BPF_PROG(bpf_cpuidle_enable, struct cpuidle_driver *drv, struct cpuidle_device *dev)
+{
+ u32 key = 0;
+ struct cpuidle_gov_data *data;
+
+ bpf_printk("cpuidle_gov_ext: enabled");
+ data = bpf_map_lookup_percpu_elem(&cpuidle_gov_data_map, &key, dev->cpu);
+ if (!data)
+ return 0;
+
+ __builtin_memset(data, 0, sizeof(struct cpuidle_gov_data));
+ data->cpu = dev->cpu;
+ return 0;
+}
+
+/* Disable the cpuidle governor */
+SEC("struct_ops.s/disable")
+void BPF_PROG(bpf_cpuidle_disable, struct cpuidle_driver *drv, struct cpuidle_device *dev)
+{
+ bpf_printk("cpuidle_gov_ext: disabled");
+}
+
+/* Select the next idle state */
+SEC("struct_ops.s/select")
+int BPF_PROG(bpf_cpuidle_select, struct cpuidle_driver *drv, struct cpuidle_device *dev)
+{
+ u32 key = 0;
+ s64 delta, latency_req, residency_ns;
+ int i, selected;
+ unsigned long long disable = 0;
+ struct cpuidle_gov_data *data;
+ struct cpuidle_state cs;
+
+ data = bpf_map_lookup_percpu_elem(&cpuidle_gov_data_map, &key, dev->cpu);
+ if (!data) {
+ bpf_printk("cpuidle_gov_ext: [%s] cpuidle_gov_data_map is NULL\n", __func__);
+ return 0;
+ }
+ latency_req = bpf_cpuidle_ext_gov_latency_req(dev->cpu);
+ delta = bpf_tick_nohz_get_sleep_length();
+
+ update_predict_duration(data, drv, dev);
+
+ for (i = ARRAY_SIZE(drv->states)-1; i > 0; i--) {
+ if (i > drv->state_count-1)
+ continue;
+ bpf_core_read(&cs, sizeof(cs), &drv->states[i]);
+ bpf_core_read(&disable, sizeof(disable), &dev->states_usage[i]);
+
+ if (disable)
+ continue;
+
+ if (latency_req < cs.exit_latency_ns)
+ continue;
+
+ if (delta < cs.target_residency_ns)
+ continue;
+
+ if (data->next_pred / FIT_FACTOR * ALPHA_SCALE < cs.target_residency_ns)
+ continue;
+
+ break;
+ }
+ residency_ns = drv->states[i].target_residency_ns;
+ if (expect_deeper &&
+ i < drv->state_count - 1 &&
+ data->last_pred >= residency_ns &&
+ data->next_pred < residency_ns &&
+ data->next_pred / FIT_FACTOR * ALPHA_SCALE >= residency_ns &&
+ data->next_pred / FIT_FACTOR * ALPHA_SCALE >= data->last_duration &&
+ delta > residency_ns) {
+ i++;
+ }
+
+ selected = i;
+ return selected;
+}
+
+//enable or disable scheduling tick after selecting cpuidle state
+SEC("struct_ops.s/set_stop_tick")
+bool BPF_PROG(bpf_cpuidle_set_stop_tick)
+{
+ return false;
+}
+
+/* Reflect function called after entering an idle state */
+SEC("struct_ops.s/reflect")
+void BPF_PROG(bpf_cpuidle_reflect, struct cpuidle_device *dev, int index)
+{
+ u32 key = 0;
+ struct cpuidle_gov_data *data;
+
+ data = bpf_map_lookup_percpu_elem(&cpuidle_gov_data_map, &key, dev->cpu);
+ if (!data) {
+ bpf_printk("cpuidle_gov_ext: [%s] cpuidle_gov_data_map is NULL\n", __func__);
+ return;
+ }
+ data->last_idx = index;
+}
+
+/* Initialize the BPF cpuidle governor */
+SEC("struct_ops.s/init")
+int BPF_PROG(bpf_cpuidle_init)
+{
+ int ret = bpf_cpuidle_ext_gov_update_rating(60);
+ return ret;
+}
+
+/* Cleanup after the BPF cpuidle governor */
+SEC("struct_ops.s/exit")
+void BPF_PROG(bpf_cpuidle_exit) { }
+
+/* Struct_ops linkage for cpuidle governor */
+SEC(".struct_ops.link")
+struct cpuidle_gov_ext_ops ops = {
+ .enable = (void *)bpf_cpuidle_enable,
+ .disable = (void *)bpf_cpuidle_disable,
+ .select = (void *)bpf_cpuidle_select,
+ .set_stop_tick = (void *)bpf_cpuidle_set_stop_tick,
+ .reflect = (void *)bpf_cpuidle_reflect,
+ .init = (void *)bpf_cpuidle_init,
+ .exit = (void *)bpf_cpuidle_exit,
+ .name = "BPF_cpuidle_gov"
+};
--
2.43.0
