tools/sched_ext: Order single-cid cmask helpers as (cid, mask)

The BPF arena single-cid cmask helpers take the cmask first and the cid
second. Reorder them to (cid, mask) to match the kernel-side helpers and
the test_bit(nr, addr), cpumask_test_cpu(cpu, mask) convention. Range and
iteration helpers keep (mask, start).

Signed-off-by: Tejun Heo <tj@kernel.org>
Reviewed-by: Andrea Righi <arighi@nvidia.com>

diff --git a/tools/sched_ext/include/scx/cid.bpf.h b/tools/sched_ext/include/scx/cid.bpf.h
index 70f2a3829af4d8dcdb079536c56a95387f76dc51..9d89bb57e201b2b7a95ec63e92a9144f3ec5b9b1 100644 (file)
--- a/tools/sched_ext/include/scx/cid.bpf.h
+++ b/tools/sched_ext/include/scx/cid.bpf.h
@@ -40,12 +40,12 @@
  */
 #define CMASK_NR_WORDS(nr_cids)                ((u32)(((u64)(nr_cids) + 63) / 64 + 1))
 
-static __always_inline bool __cmask_contains(const struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool __cmask_contains(u32 cid, const struct scx_cmask __arena *m)
 {
        return cid >= m->base && cid < m->base + m->nr_cids;
 }
 
-static __always_inline u64 __arena *__cmask_word(const struct scx_cmask __arena *m, u32 cid)
+static __always_inline u64 __arena *__cmask_word(u32 cid, const struct scx_cmask __arena *m)
 {
        return (u64 __arena *)&m->bits[cid / 64 - m->base / 64];
 }
@@ -122,11 +122,11 @@ static __always_inline void cmask_reframe(struct scx_cmask __arena *m, u32 base,
        m->nr_cids = nr_cids;
 }
 
-static __always_inline bool cmask_test(const struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool cmask_test(u32 cid, const struct scx_cmask __arena *m)
 {
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return false;
-       return *__cmask_word(m, cid) & BIT_U64(cid & 63);
+       return *__cmask_word(cid, m) & BIT_U64(cid & 63);
 }
 
 /*
@@ -140,15 +140,15 @@ static __always_inline bool cmask_test(const struct scx_cmask __arena *m, u32 ci
  */
 #define CMASK_CAS_TRIES                (1U << 23)
 
-static __always_inline void cmask_set(struct scx_cmask __arena *m, u32 cid)
+static __always_inline void cmask_set(u32 cid, struct scx_cmask __arena *m)
 {
        u64 __arena *w;
        u64 bit, old, new;
        u32 i;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        bit = BIT_U64(cid & 63);
        bpf_for(i, 0, CMASK_CAS_TRIES) {
                old = *w;
@@ -161,15 +161,15 @@ static __always_inline void cmask_set(struct scx_cmask __arena *m, u32 cid)
        scx_bpf_error("cmask_set CAS exhausted at cid %u", cid);
 }
 
-static __always_inline void cmask_clear(struct scx_cmask __arena *m, u32 cid)
+static __always_inline void cmask_clear(u32 cid, struct scx_cmask __arena *m)
 {
        u64 __arena *w;
        u64 bit, old, new;
        u32 i;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        bit = BIT_U64(cid & 63);
        bpf_for(i, 0, CMASK_CAS_TRIES) {
                old = *w;
@@ -182,15 +182,15 @@ static __always_inline void cmask_clear(struct scx_cmask __arena *m, u32 cid)
        scx_bpf_error("cmask_clear CAS exhausted at cid %u", cid);
 }
 
-static __always_inline bool cmask_test_and_set(struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool cmask_test_and_set(u32 cid, struct scx_cmask __arena *m)
 {
        u64 __arena *w;
        u64 bit, old, new;
        u32 i;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return false;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        bit = BIT_U64(cid & 63);
        bpf_for(i, 0, CMASK_CAS_TRIES) {
                old = *w;
@@ -204,15 +204,15 @@ static __always_inline bool cmask_test_and_set(struct scx_cmask __arena *m, u32
        return false;
 }
 
-static __always_inline bool cmask_test_and_clear(struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool cmask_test_and_clear(u32 cid, struct scx_cmask __arena *m)
 {
        u64 __arena *w;
        u64 bit, old, new;
        u32 i;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return false;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        bit = BIT_U64(cid & 63);
        bpf_for(i, 0, CMASK_CAS_TRIES) {
                old = *w;
@@ -226,43 +226,43 @@ static __always_inline bool cmask_test_and_clear(struct scx_cmask __arena *m, u3
        return false;
 }
 
-static __always_inline void __cmask_set(struct scx_cmask __arena *m, u32 cid)
+static __always_inline void __cmask_set(u32 cid, struct scx_cmask __arena *m)
 {
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return;
-       *__cmask_word(m, cid) |= BIT_U64(cid & 63);
+       *__cmask_word(cid, m) |= BIT_U64(cid & 63);
 }
 
-static __always_inline void __cmask_clear(struct scx_cmask __arena *m, u32 cid)
+static __always_inline void __cmask_clear(u32 cid, struct scx_cmask __arena *m)
 {
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return;
-       *__cmask_word(m, cid) &= ~BIT_U64(cid & 63);
+       *__cmask_word(cid, m) &= ~BIT_U64(cid & 63);
 }
 
-static __always_inline bool __cmask_test_and_set(struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool __cmask_test_and_set(u32 cid, struct scx_cmask __arena *m)
 {
        u64 bit = BIT_U64(cid & 63);
        u64 __arena *w;
        u64 prev;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return false;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        prev = *w & bit;
        *w |= bit;
        return prev;
 }
 
-static __always_inline bool __cmask_test_and_clear(struct scx_cmask __arena *m, u32 cid)
+static __always_inline bool __cmask_test_and_clear(u32 cid, struct scx_cmask __arena *m)
 {
        u64 bit = BIT_U64(cid & 63);
        u64 __arena *w;
        u64 prev;
 
-       if (!__cmask_contains(m, cid))
+       if (!__cmask_contains(cid, m))
                return false;
-       w = __cmask_word(m, cid);
+       w = __cmask_word(cid, m);
        prev = *w & bit;
        *w &= ~bit;
        return prev;
@@ -671,7 +671,7 @@ static __always_inline void cmask_from_cpumask(struct scx_cmask __arena *m,
                        continue;
                cid = scx_bpf_cpu_to_cid(cpu);
                if (cid >= 0)
-                       __cmask_set(m, cid);
+                       __cmask_set(cid, m);
        }
 }
 

diff --git a/tools/sched_ext/scx_qmap.bpf.c b/tools/sched_ext/scx_qmap.bpf.c
index 8a2d6a8ebd8eddee8dd02ee55cfd7c4dcd680342..fd9a82a676278bca8eabadc1b4039f79fa9ac736 100644 (file)
--- a/tools/sched_ext/scx_qmap.bpf.c
+++ b/tools/sched_ext/scx_qmap.bpf.c
@@ -214,7 +214,7 @@ static s32 pick_direct_dispatch_cid(struct task_struct *p, s32 prev_cid,
        if (!always_enq_immed && p->nr_cpus_allowed == 1)
                return prev_cid;
 
-       if (cmask_test_and_clear(qa_idle_cids, prev_cid))
+       if (cmask_test_and_clear(prev_cid, qa_idle_cids))
                return prev_cid;
 
        cid = prev_cid;
@@ -224,7 +224,7 @@ static s32 pick_direct_dispatch_cid(struct task_struct *p, s32 prev_cid,
                barrier_var(cid);
                if (cid >= nr_cids)
                        return -1;
-               if (cmask_test_and_clear(qa_idle_cids, cid))
+               if (cmask_test_and_clear(cid, qa_idle_cids))
                        return cid;
        }
        return -1;
@@ -534,7 +534,7 @@ static bool dispatch_highpri(bool from_timer)
                if (!(taskc = lookup_task_ctx(p)))
                        return false;
 
-               if (cmask_test(&taskc->cpus_allowed, this_cid))
+               if (cmask_test(this_cid, &taskc->cpus_allowed))
                        cid = this_cid;
                else
                        cid = cmask_next_set_wrap(&taskc->cpus_allowed,
@@ -656,7 +656,7 @@ void BPF_STRUCT_OPS(qmap_dispatch, s32 cid, struct task_struct *prev)
                         * document this class of issue -- other schedulers
                         * seeing similar warnings can use this as a reference.
                         */
-                       if (!cmask_test(&taskc->cpus_allowed, cid))
+                       if (!cmask_test(cid, &taskc->cpus_allowed))
                                scx_bpf_kick_cid(scx_bpf_task_cid(p), 0);
 
                        batch--;
@@ -913,9 +913,9 @@ void BPF_STRUCT_OPS(qmap_update_idle, s32 cid, bool idle)
 {
        QMAP_TOUCH_ARENA();
        if (idle)
-               cmask_set(qa_idle_cids, cid);
+               cmask_set(cid, qa_idle_cids);
        else
-               cmask_clear(qa_idle_cids, cid);
+               cmask_clear(cid, qa_idle_cids);
 }
 
 void BPF_STRUCT_OPS(qmap_set_cmask, struct task_struct *p,