/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _KERNEL_STATS_H #define _KERNEL_STATS_H #ifdef CONFIG_SCHEDSTATS extern struct static_key_false sched_schedstats; /* * Expects runqueue lock to be held for atomicity of update */ static inline void rq_sched_info_arrive(struct rq *rq, unsigned long long delta) { … } /* * Expects runqueue lock to be held for atomicity of update */ static inline void rq_sched_info_depart(struct rq *rq, unsigned long long delta) { … } static inline void rq_sched_info_dequeue(struct rq *rq, unsigned long long delta) { … } #define schedstat_enabled() … #define __schedstat_inc(var) … #define schedstat_inc(var) … #define __schedstat_add(var, amt) … #define schedstat_add(var, amt) … #define __schedstat_set(var, val) … #define schedstat_set(var, val) … #define schedstat_val(var) … #define schedstat_val_or_zero(var) … void __update_stats_wait_start(struct rq *rq, struct task_struct *p, struct sched_statistics *stats); void __update_stats_wait_end(struct rq *rq, struct task_struct *p, struct sched_statistics *stats); void __update_stats_enqueue_sleeper(struct rq *rq, struct task_struct *p, struct sched_statistics *stats); static inline void check_schedstat_required(void) { … } #else /* !CONFIG_SCHEDSTATS: */ static inline void rq_sched_info_arrive (struct rq *rq, unsigned long long delta) { } static inline void rq_sched_info_dequeue(struct rq *rq, unsigned long long delta) { } static inline void rq_sched_info_depart (struct rq *rq, unsigned long long delta) { } #define schedstat_enabled … #define __schedstat_inc … #define schedstat_inc … #define __schedstat_add … #define schedstat_add … #define __schedstat_set … #define schedstat_set … #define schedstat_val … #define schedstat_val_or_zero … #define __update_stats_wait_start … #define __update_stats_wait_end … #define __update_stats_enqueue_sleeper … #define check_schedstat_required … #endif /* CONFIG_SCHEDSTATS */ #ifdef CONFIG_FAIR_GROUP_SCHED struct sched_entity_stats { … } __no_randomize_layout; #endif static inline struct sched_statistics * __schedstats_from_se(struct sched_entity *se) { … } #ifdef CONFIG_PSI void psi_task_change(struct task_struct *task, int clear, int set); void psi_task_switch(struct task_struct *prev, struct task_struct *next, bool sleep); #ifdef CONFIG_IRQ_TIME_ACCOUNTING void psi_account_irqtime(struct rq *rq, struct task_struct *curr, struct task_struct *prev); #else static inline void psi_account_irqtime(struct rq *rq, struct task_struct *curr, struct task_struct *prev) {} #endif /*CONFIG_IRQ_TIME_ACCOUNTING */ /* * PSI tracks state that persists across sleeps, such as iowaits and * memory stalls. As a result, it has to distinguish between sleeps, * where a task's runnable state changes, and requeues, where a task * and its state are being moved between CPUs and runqueues. */ static inline void psi_enqueue(struct task_struct *p, bool wakeup) { … } static inline void psi_dequeue(struct task_struct *p, bool sleep) { … } static inline void psi_ttwu_dequeue(struct task_struct *p) { … } static inline void psi_sched_switch(struct task_struct *prev, struct task_struct *next, bool sleep) { … } #else /* CONFIG_PSI */ static inline void psi_enqueue(struct task_struct *p, bool wakeup) {} static inline void psi_dequeue(struct task_struct *p, bool sleep) {} static inline void psi_ttwu_dequeue(struct task_struct *p) {} static inline void psi_sched_switch(struct task_struct *prev, struct task_struct *next, bool sleep) {} static inline void psi_account_irqtime(struct rq *rq, struct task_struct *curr, struct task_struct *prev) {} #endif /* CONFIG_PSI */ #ifdef CONFIG_SCHED_INFO /* * We are interested in knowing how long it was from the *first* time a * task was queued to the time that it finally hit a CPU, we call this routine * from dequeue_task() to account for possible rq->clock skew across CPUs. The * delta taken on each CPU would annul the skew. */ static inline void sched_info_dequeue(struct rq *rq, struct task_struct *t) { … } /* * Called when a task finally hits the CPU. We can now calculate how * long it was waiting to run. We also note when it began so that we * can keep stats on how long its time-slice is. */ static void sched_info_arrive(struct rq *rq, struct task_struct *t) { … } /* * This function is only called from enqueue_task(), but also only updates * the timestamp if it is already not set. It's assumed that * sched_info_dequeue() will clear that stamp when appropriate. */ static inline void sched_info_enqueue(struct rq *rq, struct task_struct *t) { … } /* * Called when a process ceases being the active-running process involuntarily * due, typically, to expiring its time slice (this may also be called when * switching to the idle task). Now we can calculate how long we ran. * Also, if the process is still in the TASK_RUNNING state, call * sched_info_enqueue() to mark that it has now again started waiting on * the runqueue. */ static inline void sched_info_depart(struct rq *rq, struct task_struct *t) { … } /* * Called when tasks are switched involuntarily due, typically, to expiring * their time slice. (This may also be called when switching to or from * the idle task.) We are only called when prev != next. */ static inline void sched_info_switch(struct rq *rq, struct task_struct *prev, struct task_struct *next) { … } #else /* !CONFIG_SCHED_INFO: */ #define sched_info_enqueue … #define sched_info_dequeue … #define sched_info_switch … #endif /* CONFIG_SCHED_INFO */ #endif /* _KERNEL_STATS_H */
Codebase Browser
linux