If the entity isn't a task, return the task struct is meaningless.
Return NULL when entity isn't a task that makes the code more concise.
v1 -> v2:
fix 'struct rt_rq' no member named 'highest_prio'.
Yajun Deng (2):
sched/fair: Return NULL when entity isn't a task in task_of()
sched/rt: Return NULL when rt entity isn't a task in rt_task_of()
kernel/sched/fair.c | 50 ++++++++++++++++++------------------
kernel/sched/rt.c | 60 +++++++++++++-------------------------------
kernel/sched/sched.h | 4 ++-
3 files changed, 44 insertions(+), 70 deletions(-)
--
2.25.1
Before calling task_of(), we need to make sure that the entity is a task.
There is also a warning in task_of() if the entity isn't a task. That
means we need to check the entity twice. If the entity isn't a task,
return the task struct is meaningless.
Return NULL when entity isn't a task in task_of(), and call task_of()
instead of entity_is_task() when we need a task_struct.
Signed-off-by: Yajun Deng <[email protected]>
---
kernel/sched/fair.c | 50 +++++++++++++++++++++-----------------------
kernel/sched/sched.h | 4 +++-
2 files changed, 27 insertions(+), 27 deletions(-)
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index bcd0f230e21f..5003c8501398 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -470,8 +470,10 @@ static int cfs_rq_is_idle(struct cfs_rq *cfs_rq)
static int se_is_idle(struct sched_entity *se)
{
- if (entity_is_task(se))
- return task_has_idle_policy(task_of(se));
+ struct task_struct *p = task_of(se);
+
+ if (p)
+ return task_has_idle_policy(p);
return cfs_rq_is_idle(group_cfs_rq(se));
}
@@ -1156,6 +1158,7 @@ s64 update_curr_common(struct rq *rq)
static void update_curr(struct cfs_rq *cfs_rq)
{
struct sched_entity *curr = cfs_rq->curr;
+ struct task_struct *p;
s64 delta_exec;
if (unlikely(!curr))
@@ -1169,8 +1172,9 @@ static void update_curr(struct cfs_rq *cfs_rq)
update_deadline(cfs_rq, curr);
update_min_vruntime(cfs_rq);
- if (entity_is_task(curr))
- update_curr_task(task_of(curr), delta_exec);
+ p = task_of(curr);
+ if (p)
+ update_curr_task(p, delta_exec);
account_cfs_rq_runtime(cfs_rq, delta_exec);
}
@@ -1184,24 +1188,19 @@ static inline void
update_stats_wait_start_fair(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
struct sched_statistics *stats;
- struct task_struct *p = NULL;
if (!schedstat_enabled())
return;
stats = __schedstats_from_se(se);
- if (entity_is_task(se))
- p = task_of(se);
-
- __update_stats_wait_start(rq_of(cfs_rq), p, stats);
+ __update_stats_wait_start(rq_of(cfs_rq), task_of(se), stats);
}
static inline void
update_stats_wait_end_fair(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
struct sched_statistics *stats;
- struct task_struct *p = NULL;
if (!schedstat_enabled())
return;
@@ -1217,27 +1216,20 @@ update_stats_wait_end_fair(struct cfs_rq *cfs_rq, struct sched_entity *se)
if (unlikely(!schedstat_val(stats->wait_start)))
return;
- if (entity_is_task(se))
- p = task_of(se);
-
- __update_stats_wait_end(rq_of(cfs_rq), p, stats);
+ __update_stats_wait_end(rq_of(cfs_rq), task_of(se), stats);
}
static inline void
update_stats_enqueue_sleeper_fair(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
struct sched_statistics *stats;
- struct task_struct *tsk = NULL;
if (!schedstat_enabled())
return;
stats = __schedstats_from_se(se);
- if (entity_is_task(se))
- tsk = task_of(se);
-
- __update_stats_enqueue_sleeper(rq_of(cfs_rq), tsk, stats);
+ __update_stats_enqueue_sleeper(rq_of(cfs_rq), task_of(se), stats);
}
/*
@@ -1263,6 +1255,7 @@ update_stats_enqueue_fair(struct cfs_rq *cfs_rq, struct sched_entity *se, int fl
static inline void
update_stats_dequeue_fair(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
+ struct task_struct *tsk;
if (!schedstat_enabled())
return;
@@ -1274,8 +1267,8 @@ update_stats_dequeue_fair(struct cfs_rq *cfs_rq, struct sched_entity *se, int fl
if (se != cfs_rq->curr)
update_stats_wait_end_fair(cfs_rq, se);
- if ((flags & DEQUEUE_SLEEP) && entity_is_task(se)) {
- struct task_struct *tsk = task_of(se);
+ tsk = task_of(se);
+ if ((flags & DEQUEUE_SLEEP) && tsk) {
unsigned int state;
/* XXX racy against TTWU */
@@ -3569,12 +3562,14 @@ static inline void update_scan_period(struct task_struct *p, int new_cpu)
static void
account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
+ struct task_struct *p = task_of(se);
+
update_load_add(&cfs_rq->load, se->load.weight);
#ifdef CONFIG_SMP
- if (entity_is_task(se)) {
+ if (p) {
struct rq *rq = rq_of(cfs_rq);
- account_numa_enqueue(rq, task_of(se));
+ account_numa_enqueue(rq, p);
list_add(&se->group_node, &rq->cfs_tasks);
}
#endif
@@ -3586,10 +3581,12 @@ account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
static void
account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
{
+ struct task_struct *p = task_of(se);
+
update_load_sub(&cfs_rq->load, se->load.weight);
#ifdef CONFIG_SMP
- if (entity_is_task(se)) {
- account_numa_dequeue(rq_of(cfs_rq), task_of(se));
+ if (p) {
+ account_numa_dequeue(rq_of(cfs_rq), p);
list_del_init(&se->group_node);
}
#endif
@@ -5323,9 +5320,10 @@ static __always_inline void return_cfs_rq_runtime(struct cfs_rq *cfs_rq);
static void
dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
{
+ struct task_struct *p = task_of(se);
int action = UPDATE_TG;
- if (entity_is_task(se) && task_on_rq_migrating(task_of(se)))
+ if (p && task_on_rq_migrating(p))
action |= DO_DETACH;
/*
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 001fe047bd5d..6baba9ebcde1 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -1432,7 +1432,9 @@ static inline void update_idle_core(struct rq *rq) { }
#ifdef CONFIG_FAIR_GROUP_SCHED
static inline struct task_struct *task_of(struct sched_entity *se)
{
- SCHED_WARN_ON(!entity_is_task(se));
+ if (!entity_is_task(se))
+ return NULL;
+
return container_of(se, struct task_struct, se);
}
--
2.25.1
Before calling rt_task_of(), we need to make sure that the rt entity is
a task. There is also a warning in rt_task_of() if the rt entity isn't a
task. That means we need to check the rt entity twice. If the rt entity
isn't a task, return the task struct is meaningless.
Return NULL when rt entity isn't a task in rt_task_of(), and call
rt_task_of() instead of rt_entity_is_task() when we need a task_struct.
Signed-off-by: Yajun Deng <[email protected]>
---
v2: fix 'struct rt_rq' no member named 'highest_prio'.
v1: https://lore.kernel.org/all/[email protected]/
---
kernel/sched/rt.c | 60 ++++++++++++++---------------------------------
1 file changed, 17 insertions(+), 43 deletions(-)
diff --git a/kernel/sched/rt.c b/kernel/sched/rt.c
index 40d24f64b444..061f5f005c35 100644
--- a/kernel/sched/rt.c
+++ b/kernel/sched/rt.c
@@ -169,9 +169,9 @@ static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
static inline struct task_struct *rt_task_of(struct sched_rt_entity *rt_se)
{
-#ifdef CONFIG_SCHED_DEBUG
- WARN_ON_ONCE(!rt_entity_is_task(rt_se));
-#endif
+ if (!rt_entity_is_task(rt_se))
+ return NULL;
+
return container_of(rt_se, struct task_struct, rt);
}
@@ -1266,54 +1266,34 @@ static void __delist_rt_entity(struct sched_rt_entity *rt_se, struct rt_prio_arr
rt_se->on_list = 0;
}
-static inline struct sched_statistics *
-__schedstats_from_rt_se(struct sched_rt_entity *rt_se)
-{
-#ifdef CONFIG_RT_GROUP_SCHED
- /* schedstats is not supported for rt group. */
- if (!rt_entity_is_task(rt_se))
- return NULL;
-#endif
-
- return &rt_task_of(rt_se)->stats;
-}
-
static inline void
update_stats_wait_start_rt(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se)
{
- struct sched_statistics *stats;
- struct task_struct *p = NULL;
+ struct task_struct *p;
if (!schedstat_enabled())
return;
- if (rt_entity_is_task(rt_se))
- p = rt_task_of(rt_se);
-
- stats = __schedstats_from_rt_se(rt_se);
- if (!stats)
+ p = rt_task_of(rt_se);
+ if (!p)
return;
- __update_stats_wait_start(rq_of_rt_rq(rt_rq), p, stats);
+ __update_stats_wait_start(rq_of_rt_rq(rt_rq), p, &p->stats);
}
static inline void
update_stats_enqueue_sleeper_rt(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se)
{
- struct sched_statistics *stats;
- struct task_struct *p = NULL;
+ struct task_struct *p;
if (!schedstat_enabled())
return;
- if (rt_entity_is_task(rt_se))
- p = rt_task_of(rt_se);
-
- stats = __schedstats_from_rt_se(rt_se);
- if (!stats)
+ p = rt_task_of(rt_se);
+ if (!p)
return;
- __update_stats_enqueue_sleeper(rq_of_rt_rq(rt_rq), p, stats);
+ __update_stats_enqueue_sleeper(rq_of_rt_rq(rt_rq), p, &p->stats);
}
static inline void
@@ -1330,34 +1310,28 @@ update_stats_enqueue_rt(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se,
static inline void
update_stats_wait_end_rt(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se)
{
- struct sched_statistics *stats;
- struct task_struct *p = NULL;
+ struct task_struct *p;
if (!schedstat_enabled())
return;
- if (rt_entity_is_task(rt_se))
- p = rt_task_of(rt_se);
-
- stats = __schedstats_from_rt_se(rt_se);
- if (!stats)
+ p = rt_task_of(rt_se);
+ if (!p)
return;
- __update_stats_wait_end(rq_of_rt_rq(rt_rq), p, stats);
+ __update_stats_wait_end(rq_of_rt_rq(rt_rq), p, &p->stats);
}
static inline void
update_stats_dequeue_rt(struct rt_rq *rt_rq, struct sched_rt_entity *rt_se,
int flags)
{
- struct task_struct *p = NULL;
+ struct task_struct *p;
if (!schedstat_enabled())
return;
- if (rt_entity_is_task(rt_se))
- p = rt_task_of(rt_se);
-
+ p = rt_task_of(rt_se);
if ((flags & DEQUEUE_SLEEP) && p) {
unsigned int state;
--
2.25.1
Kindly ping...
Thanks
On 2023/12/6 14:33, Yajun Deng wrote:
> If the entity isn't a task, return the task struct is meaningless.
> Return NULL when entity isn't a task that makes the code more concise.
>
> v1 -> v2:
> fix 'struct rt_rq' no member named 'highest_prio'.
>
> Yajun Deng (2):
> sched/fair: Return NULL when entity isn't a task in task_of()
> sched/rt: Return NULL when rt entity isn't a task in rt_task_of()
>
> kernel/sched/fair.c | 50 ++++++++++++++++++------------------
> kernel/sched/rt.c | 60 +++++++++++++-------------------------------
> kernel/sched/sched.h | 4 ++-
> 3 files changed, 44 insertions(+), 70 deletions(-)
>
On Wed, 6 Dec 2023 14:33:59 +0800
Yajun Deng <[email protected]> wrote:
> Before calling task_of(), we need to make sure that the entity is a task.
> There is also a warning in task_of() if the entity isn't a task. That
> means we need to check the entity twice. If the entity isn't a task,
Does it really check it twice? Have you disassembled it to see if the code
is any better?
#define entity_is_task(se) (!se->my_q)
static inline struct task_struct *task_of(struct sched_entity *se)
{
SCHED_WARN_ON(!entity_is_task(se));
return container_of(se, struct task_struct, se);
}
The above is a macro and a static inline, which means that the compiler
should optimized out that second check.
> return the task struct is meaningless.
>
> Return NULL when entity isn't a task in task_of(), and call task_of()
> instead of entity_is_task() when we need a task_struct.
I'm not against the change, as it could be considered a clean up. But it is
up to the sched maintainers to decide if it's worth the churn.
-- Steve
>
> Signed-off-by: Yajun Deng <[email protected]>
On 2024/1/23 11:48, Steven Rostedt wrote:
> On Wed, 6 Dec 2023 14:33:59 +0800
> Yajun Deng <[email protected]> wrote:
>
>> Before calling task_of(), we need to make sure that the entity is a task.
>> There is also a warning in task_of() if the entity isn't a task. That
>> means we need to check the entity twice. If the entity isn't a task,
> Does it really check it twice? Have you disassembled it to see if the code
> is any better?
>
> #define entity_is_task(se) (!se->my_q)
> static inline struct task_struct *task_of(struct sched_entity *se)
> {
> SCHED_WARN_ON(!entity_is_task(se));
> return container_of(se, struct task_struct, se);
> }
>
> The above is a macro and a static inline, which means that the compiler
> should optimized out that second check.
Yes, the second check should be optimized.
>
>> return the task struct is meaningless.
>>
>> Return NULL when entity isn't a task in task_of(), and call task_of()
>> instead of entity_is_task() when we need a task_struct.
> I'm not against the change, as it could be considered a clean up. But it is
> up to the sched maintainers to decide if it's worth the churn.
Return NULL in task_of() makes the code cleaner.
>
> -- Steve
>
>
>> Signed-off-by: Yajun Deng <[email protected]>