]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - kernel/sched/stats.h
2 #ifdef CONFIG_SCHEDSTATS
5 * Expects runqueue lock to be held for atomicity of update
8 rq_sched_info_arrive(struct rq
*rq
, unsigned long long delta
)
11 rq
->rq_sched_info
.run_delay
+= delta
;
12 rq
->rq_sched_info
.pcount
++;
17 * Expects runqueue lock to be held for atomicity of update
20 rq_sched_info_depart(struct rq
*rq
, unsigned long long delta
)
23 rq
->rq_cpu_time
+= delta
;
27 rq_sched_info_dequeued(struct rq
*rq
, unsigned long long delta
)
30 rq
->rq_sched_info
.run_delay
+= delta
;
32 #define schedstat_enabled() static_branch_unlikely(&sched_schedstats)
33 #define schedstat_inc(var) do { if (schedstat_enabled()) { var++; } } while (0)
34 #define schedstat_add(var, amt) do { if (schedstat_enabled()) { var += (amt); } } while (0)
35 #define schedstat_set(var, val) do { if (schedstat_enabled()) { var = (val); } } while (0)
36 #define schedstat_val(var) (var)
37 #define schedstat_val_or_zero(var) ((schedstat_enabled()) ? (var) : 0)
39 #else /* !CONFIG_SCHEDSTATS */
41 rq_sched_info_arrive(struct rq
*rq
, unsigned long long delta
)
44 rq_sched_info_dequeued(struct rq
*rq
, unsigned long long delta
)
47 rq_sched_info_depart(struct rq
*rq
, unsigned long long delta
)
49 #define schedstat_enabled() 0
50 #define schedstat_inc(var) do { } while (0)
51 #define schedstat_add(var, amt) do { } while (0)
52 #define schedstat_set(var, val) do { } while (0)
53 #define schedstat_val(var) 0
54 #define schedstat_val_or_zero(var) 0
55 #endif /* CONFIG_SCHEDSTATS */
57 #ifdef CONFIG_SCHED_INFO
58 static inline void sched_info_reset_dequeued(struct task_struct
*t
)
60 t
->sched_info
.last_queued
= 0;
64 * We are interested in knowing how long it was from the *first* time a
65 * task was queued to the time that it finally hit a cpu, we call this routine
66 * from dequeue_task() to account for possible rq->clock skew across cpus. The
67 * delta taken on each cpu would annul the skew.
69 static inline void sched_info_dequeued(struct rq
*rq
, struct task_struct
*t
)
71 unsigned long long now
= rq_clock(rq
), delta
= 0;
73 if (unlikely(sched_info_on()))
74 if (t
->sched_info
.last_queued
)
75 delta
= now
- t
->sched_info
.last_queued
;
76 sched_info_reset_dequeued(t
);
77 t
->sched_info
.run_delay
+= delta
;
79 rq_sched_info_dequeued(rq
, delta
);
83 * Called when a task finally hits the cpu. We can now calculate how
84 * long it was waiting to run. We also note when it began so that we
85 * can keep stats on how long its timeslice is.
87 static void sched_info_arrive(struct rq
*rq
, struct task_struct
*t
)
89 unsigned long long now
= rq_clock(rq
), delta
= 0;
91 if (t
->sched_info
.last_queued
)
92 delta
= now
- t
->sched_info
.last_queued
;
93 sched_info_reset_dequeued(t
);
94 t
->sched_info
.run_delay
+= delta
;
95 t
->sched_info
.last_arrival
= now
;
96 t
->sched_info
.pcount
++;
98 rq_sched_info_arrive(rq
, delta
);
102 * This function is only called from enqueue_task(), but also only updates
103 * the timestamp if it is already not set. It's assumed that
104 * sched_info_dequeued() will clear that stamp when appropriate.
106 static inline void sched_info_queued(struct rq
*rq
, struct task_struct
*t
)
108 if (unlikely(sched_info_on()))
109 if (!t
->sched_info
.last_queued
)
110 t
->sched_info
.last_queued
= rq_clock(rq
);
114 * Called when a process ceases being the active-running process involuntarily
115 * due, typically, to expiring its time slice (this may also be called when
116 * switching to the idle task). Now we can calculate how long we ran.
117 * Also, if the process is still in the TASK_RUNNING state, call
118 * sched_info_queued() to mark that it has now again started waiting on
121 static inline void sched_info_depart(struct rq
*rq
, struct task_struct
*t
)
123 unsigned long long delta
= rq_clock(rq
) -
124 t
->sched_info
.last_arrival
;
126 rq_sched_info_depart(rq
, delta
);
128 if (t
->state
== TASK_RUNNING
)
129 sched_info_queued(rq
, t
);
133 * Called when tasks are switched involuntarily due, typically, to expiring
134 * their time slice. (This may also be called when switching to or from
135 * the idle task.) We are only called when prev != next.
138 __sched_info_switch(struct rq
*rq
,
139 struct task_struct
*prev
, struct task_struct
*next
)
142 * prev now departs the cpu. It's not interesting to record
143 * stats about how efficient we were at scheduling the idle
146 if (prev
!= rq
->idle
)
147 sched_info_depart(rq
, prev
);
149 if (next
!= rq
->idle
)
150 sched_info_arrive(rq
, next
);
153 sched_info_switch(struct rq
*rq
,
154 struct task_struct
*prev
, struct task_struct
*next
)
156 if (unlikely(sched_info_on()))
157 __sched_info_switch(rq
, prev
, next
);
160 #define sched_info_queued(rq, t) do { } while (0)
161 #define sched_info_reset_dequeued(t) do { } while (0)
162 #define sched_info_dequeued(rq, t) do { } while (0)
163 #define sched_info_depart(rq, t) do { } while (0)
164 #define sched_info_arrive(rq, next) do { } while (0)
165 #define sched_info_switch(rq, t, next) do { } while (0)
166 #endif /* CONFIG_SCHED_INFO */
169 * The following are functions that support scheduler-internal time accounting.
170 * These functions are generally called at the timer tick. None of this depends
171 * on CONFIG_SCHEDSTATS.
175 * get_running_cputimer - return &tsk->signal->cputimer if cputimer is running
177 * @tsk: Pointer to target task.
179 #ifdef CONFIG_POSIX_TIMERS
181 struct thread_group_cputimer
*get_running_cputimer(struct task_struct
*tsk
)
183 struct thread_group_cputimer
*cputimer
= &tsk
->signal
->cputimer
;
185 /* Check if cputimer isn't running. This is accessed without locking. */
186 if (!READ_ONCE(cputimer
->running
))
190 * After we flush the task's sum_exec_runtime to sig->sum_sched_runtime
191 * in __exit_signal(), we won't account to the signal struct further
192 * cputime consumed by that task, even though the task can still be
193 * ticking after __exit_signal().
195 * In order to keep a consistent behaviour between thread group cputime
196 * and thread group cputimer accounting, lets also ignore the cputime
197 * elapsing after __exit_signal() in any thread group timer running.
199 * This makes sure that POSIX CPU clocks and timers are synchronized, so
200 * that a POSIX CPU timer won't expire while the corresponding POSIX CPU
201 * clock delta is behind the expiring timer value.
203 if (unlikely(!tsk
->sighand
))
210 struct thread_group_cputimer
*get_running_cputimer(struct task_struct
*tsk
)
217 * account_group_user_time - Maintain utime for a thread group.
219 * @tsk: Pointer to task structure.
220 * @cputime: Time value by which to increment the utime field of the
221 * thread_group_cputime structure.
223 * If thread group time is being maintained, get the structure for the
224 * running CPU and update the utime field there.
226 static inline void account_group_user_time(struct task_struct
*tsk
,
229 struct thread_group_cputimer
*cputimer
= get_running_cputimer(tsk
);
234 atomic64_add(cputime
, &cputimer
->cputime_atomic
.utime
);
238 * account_group_system_time - Maintain stime for a thread group.
240 * @tsk: Pointer to task structure.
241 * @cputime: Time value by which to increment the stime field of the
242 * thread_group_cputime structure.
244 * If thread group time is being maintained, get the structure for the
245 * running CPU and update the stime field there.
247 static inline void account_group_system_time(struct task_struct
*tsk
,
250 struct thread_group_cputimer
*cputimer
= get_running_cputimer(tsk
);
255 atomic64_add(cputime
, &cputimer
->cputime_atomic
.stime
);
259 * account_group_exec_runtime - Maintain exec runtime for a thread group.
261 * @tsk: Pointer to task structure.
262 * @ns: Time value by which to increment the sum_exec_runtime field
263 * of the thread_group_cputime structure.
265 * If thread group time is being maintained, get the structure for the
266 * running CPU and update the sum_exec_runtime field there.
268 static inline void account_group_exec_runtime(struct task_struct
*tsk
,
269 unsigned long long ns
)
271 struct thread_group_cputimer
*cputimer
= get_running_cputimer(tsk
);
276 atomic64_add(ns
, &cputimer
->cputime_atomic
.sum_exec_runtime
);