Release 4.10 kernel/sched/stats.h

Directory: kernel/sched
#ifdef CONFIG_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)
{
	if (rq) {
		rq->rq_sched_info.run_delay += delta;
		rq->rq_sched_info.pcount++;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 38 100.00% 2 100.00%
Total 38 100.00% 2 100.00%

/*
 * Expects runqueue lock to be held for atomicity of update
 */

static inline void

rq_sched_info_depart(struct rq *rq, unsigned long long delta)
{
	if (rq)
		rq->rq_cpu_time += delta;
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 26 96.30% 1 50.00%
ken chen ken chen 1 3.70% 1 50.00%
Total 27 100.00% 2 100.00%


static inline void

rq_sched_info_dequeued(struct rq *rq, unsigned long long delta)
{
	if (rq)
		rq->rq_sched_info.run_delay += delta;
}
Contributors
Person Tokens Prop Commits CommitProp
ankita garg ankita garg 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%


#define schedstat_enabled()		static_branch_unlikely(&sched_schedstats)

#define schedstat_inc(var)		do { if (schedstat_enabled()) { var++; } } while (0)

#define schedstat_add(var, amt)		do { if (schedstat_enabled()) { var += (amt); } } while (0)

#define schedstat_set(var, val)		do { if (schedstat_enabled()) { var = (val); } } while (0)

#define schedstat_val(var)		(var)

#define schedstat_val_or_zero(var)	((schedstat_enabled()) ? (var) : 0)

#else /* !CONFIG_SCHEDSTATS */

static inline void

rq_sched_info_arrive(struct rq *rq, unsigned long long delta)
{}
Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


static inline void

rq_sched_info_dequeued(struct rq *rq, unsigned long long delta)
{}
Contributors
Person Tokens Prop Commits CommitProp
ankita garg ankita garg 13 81.25% 1 50.00%
ingo molnar ingo molnar 3 18.75% 1 50.00%
Total 16 100.00% 2 100.00%


static inline void

rq_sched_info_depart(struct rq *rq, unsigned long long delta)
{}
Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 13 81.25% 1 50.00%
ankita garg ankita garg 3 18.75% 1 50.00%
Total 16 100.00% 2 100.00%


#define schedstat_enabled()		0

#define schedstat_inc(var)		do { } while (0)

#define schedstat_add(var, amt)		do { } while (0)

#define schedstat_set(var, val)		do { } while (0)

#define schedstat_val(var)		0

#define schedstat_val_or_zero(var)	0
#endif /* CONFIG_SCHEDSTATS */

#ifdef CONFIG_SCHED_INFO


static inline void sched_info_reset_dequeued(struct task_struct *t)
{
	t->sched_info.last_queued = 0;
}

Contributors
Person Tokens Prop Commits CommitProp
ankita garg ankita garg 20 100.00% 1 100.00%
Total 20 100.00% 1 100.00%

/*
 * 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_dequeued(struct rq *rq, struct task_struct *t)
{
	unsigned long long now = rq_clock(rq), delta = 0;

	if (unlikely(sched_info_on()))
		if (t->sched_info.last_queued)
			delta = now - t->sched_info.last_queued;
	sched_info_reset_dequeued(t);
	t->sched_info.run_delay += delta;

	rq_sched_info_dequeued(rq, delta);
}

Contributors
Person Tokens Prop Commits CommitProp
ankita garg ankita garg 48 62.34% 1 25.00%
ingo molnar ingo molnar 19 24.68% 1 25.00%
michael s. tsirkin michael s. tsirkin 7 9.09% 1 25.00%
frederic weisbecker frederic weisbecker 3 3.90% 1 25.00%
Total 77 100.00% 4 100.00%

/*
 * 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 timeslice is.
 */


static void sched_info_arrive(struct rq *rq, struct task_struct *t)
{
	unsigned long long now = rq_clock(rq), delta = 0;

	if (t->sched_info.last_queued)
		delta = now - t->sched_info.last_queued;
	sched_info_reset_dequeued(t);
	t->sched_info.run_delay += delta;
	t->sched_info.last_arrival = now;
	t->sched_info.pcount++;

	rq_sched_info_arrive(rq, delta);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 72 86.75% 2 40.00%
michael s. tsirkin michael s. tsirkin 7 8.43% 1 20.00%
frederic weisbecker frederic weisbecker 3 3.61% 1 20.00%
ankita garg ankita garg 1 1.20% 1 20.00%
Total 83 100.00% 5 100.00%

/*
 * 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_dequeued() will clear that stamp when appropriate.
 */


static inline void sched_info_queued(struct rq *rq, struct task_struct *t)
{
	if (unlikely(sched_info_on()))
		if (!t->sched_info.last_queued)
			t->sched_info.last_queued = rq_clock(rq);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 36 80.00% 1 33.33%
michael s. tsirkin michael s. tsirkin 6 13.33% 1 33.33%
frederic weisbecker frederic weisbecker 3 6.67% 1 33.33%
Total 45 100.00% 3 100.00%

/*
 * 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_queued() 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)
{
	unsigned long long delta = rq_clock(rq) -
					t->sched_info.last_arrival;

	rq_sched_info_depart(rq, delta);

	if (t->state == TASK_RUNNING)
		sched_info_queued(rq, t);
}

Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 30 54.55% 1 25.00%
bharath ravi bharath ravi 13 23.64% 1 25.00%
michael s. tsirkin michael s. tsirkin 9 16.36% 1 25.00%
frederic weisbecker frederic weisbecker 3 5.45% 1 25.00%
Total 55 100.00% 4 100.00%

/*
 * 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)
{
	/*
         * prev now departs the cpu.  It's not interesting to record
         * stats about how efficient we were at scheduling the idle
         * process, however.
         */
	if (prev != rq->idle)
		sched_info_depart(rq, prev);

	if (next != rq->idle)
		sched_info_arrive(rq, next);
}
Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 44 83.02% 1 50.00%
michael s. tsirkin michael s. tsirkin 9 16.98% 1 50.00%
Total 53 100.00% 2 100.00%


static inline void

sched_info_switch(struct rq *rq,
		  struct task_struct *prev, struct task_struct *next)
{
	if (unlikely(sched_info_on()))
		__sched_info_switch(rq, prev, next);
}
Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 32 82.05% 1 50.00%
michael s. tsirkin michael s. tsirkin 7 17.95% 1 50.00%
Total 39 100.00% 2 100.00%

#else

#define sched_info_queued(rq, t)		do { } while (0)

#define sched_info_reset_dequeued(t)	do { } while (0)

#define sched_info_dequeued(rq, t)		do { } while (0)

#define sched_info_depart(rq, t)		do { } while (0)

#define sched_info_arrive(rq, next)		do { } while (0)

#define sched_info_switch(rq, t, next)		do { } while (0)
#endif /* CONFIG_SCHED_INFO */

/*
 * The following are functions that support scheduler-internal time accounting.
 * These functions are generally called at the timer tick.  None of this depends
 * on CONFIG_SCHEDSTATS.
 */

/**
 * cputimer_running - return true if cputimer is running
 *
 * @tsk:        Pointer to target task.
 */


static inline bool cputimer_running(struct task_struct *tsk)

{
	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;

	/* Check if cputimer isn't running. This is accessed without locking. */
	if (!READ_ONCE(cputimer->running))
		return false;

	/*
         * After we flush the task's sum_exec_runtime to sig->sum_sched_runtime
         * in __exit_signal(), we won't account to the signal struct further
         * cputime consumed by that task, even though the task can still be
         * ticking after __exit_signal().
         *
         * In order to keep a consistent behaviour between thread group cputime
         * and thread group cputimer accounting, lets also ignore the cputime
         * elapsing after __exit_signal() in any thread group timer running.
         *
         * This makes sure that POSIX CPU clocks and timers are synchronized, so
         * that a POSIX CPU timer won't expire while the corresponding POSIX CPU
         * clock delta is behind the expiring timer value.
         */
	if (unlikely(!tsk->sighand))
		return false;

	return true;
}

Contributors
Person Tokens Prop Commits CommitProp
kosaki motohiro kosaki motohiro 51 92.73% 1 50.00%
jason low jason low 4 7.27% 1 50.00%
Total 55 100.00% 2 100.00%

/**
 * account_group_user_time - Maintain utime for a thread group.
 *
 * @tsk:        Pointer to task structure.
 * @cputime:    Time value by which to increment the utime field of the
 *              thread_group_cputime structure.
 *
 * If thread group time is being maintained, get the structure for the
 * running CPU and update the utime field there.
 */


static inline void account_group_user_time(struct task_struct *tsk,
					   cputime_t cputime)
{
	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;

	if (!cputimer_running(tsk))
		return;

	atomic64_add(cputime, &cputimer->cputime_atomic.utime);
}

Contributors
Person Tokens Prop Commits CommitProp
frank mayhar frank mayhar 19 39.58% 2 22.22%
peter zijlstra peter zijlstra 15 31.25% 2 22.22%
jason low jason low 5 10.42% 2 22.22%
oleg nesterov oleg nesterov 5 10.42% 2 22.22%
kosaki motohiro kosaki motohiro 4 8.33% 1 11.11%
Total 48 100.00% 9 100.00%

/**
 * account_group_system_time - Maintain stime for a thread group.
 *
 * @tsk:        Pointer to task structure.
 * @cputime:    Time value by which to increment the stime field of the
 *              thread_group_cputime structure.
 *
 * If thread group time is being maintained, get the structure for the
 * running CPU and update the stime field there.
 */


static inline void account_group_system_time(struct task_struct *tsk,
					     cputime_t cputime)
{
	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;

	if (!cputimer_running(tsk))
		return;

	atomic64_add(cputime, &cputimer->cputime_atomic.stime);
}

Contributors
Person Tokens Prop Commits CommitProp
frank mayhar frank mayhar 18 37.50% 2 22.22%
peter zijlstra peter zijlstra 16 33.33% 2 22.22%
jason low jason low 5 10.42% 2 22.22%
oleg nesterov oleg nesterov 5 10.42% 2 22.22%
kosaki motohiro kosaki motohiro 4 8.33% 1 11.11%
Total 48 100.00% 9 100.00%

/**
 * account_group_exec_runtime - Maintain exec runtime for a thread group.
 *
 * @tsk:        Pointer to task structure.
 * @ns:         Time value by which to increment the sum_exec_runtime field
 *              of the thread_group_cputime structure.
 *
 * If thread group time is being maintained, get the structure for the
 * running CPU and update the sum_exec_runtime field there.
 */


static inline void account_group_exec_runtime(struct task_struct *tsk,
					      unsigned long long ns)
{
	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;

	if (!cputimer_running(tsk))
		return;

	atomic64_add(ns, &cputimer->cputime_atomic.sum_exec_runtime);
}
Contributors
Person Tokens Prop Commits CommitProp
frank mayhar frank mayhar 24 48.00% 2 25.00%
peter zijlstra peter zijlstra 14 28.00% 2 25.00%
jason low jason low 5 10.00% 2 25.00%
kosaki motohiro kosaki motohiro 4 8.00% 1 12.50%
oleg nesterov oleg nesterov 3 6.00% 1 12.50%
Total 50 100.00% 8 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
ingo molnar ingo molnar 404 45.60% 3 12.50%
ankita garg ankita garg 128 14.45% 1 4.17%
michael s. tsirkin michael s. tsirkin 70 7.90% 2 8.33%
frank mayhar frank mayhar 65 7.34% 2 8.33%
kosaki motohiro kosaki motohiro 64 7.22% 1 4.17%
peter zijlstra peter zijlstra 45 5.08% 2 8.33%
josh poimboeuf josh poimboeuf 35 3.95% 3 12.50%
jason low jason low 19 2.14% 2 8.33%
bharath ravi bharath ravi 13 1.47% 1 4.17%
oleg nesterov oleg nesterov 13 1.47% 2 8.33%
frederic weisbecker frederic weisbecker 12 1.35% 1 4.17%
mel gorman mel gorman 11 1.24% 1 4.17%
naveen n. rao naveen n. rao 4 0.45% 1 4.17%
rakib mullick rakib mullick 2 0.23% 1 4.17%
ken chen ken chen 1 0.11% 1 4.17%
Total 886 100.00% 24 100.00%
Directory: kernel/sched

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
ingo molnar	ingo molnar	38	100.00%	2	100.00%
	Total	38	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.10 kernel/sched/stats.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
