Release 4.17 kernel/sched/stats.h

Directory: kernel/sched
/* SPDX-License-Identifier: GPL-2.0 */

#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 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 26 96.30% 1 50.00%
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 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 { var++; } while (0)

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

#define __schedstat_add(var, amt)	do { var += (amt); } while (0)

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

#define __schedstat_set(var, val)	do { var = (val); } 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 16 100.00% 2 100.00%
Total 16 100.00% 2 100.00%



static inline void rq_sched_info_dequeued(struct rq *rq, unsigned long long delta) { }
Contributors
Person Tokens Prop Commits CommitProp
Ankita Garg 12 75.00% 1 33.33%
Ingo Molnar 4 25.00% 2 66.67%
Total 16 100.00% 3 100.00%



static inline void rq_sched_info_depart  (struct rq *rq, unsigned long long delta) { }
Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 13 81.25% 2 66.67%
Ankita Garg 3 18.75% 1 33.33%
Total 16 100.00% 3 100.00%


# define   schedstat_enabled()		0

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

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

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

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

# define __schedstat_set(var, val)	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 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 48 62.34% 1 25.00%
Ingo Molnar 19 24.68% 1 25.00%
Michael S. Tsirkin 7 9.09% 1 25.00%
Frédéric 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 72 86.75% 2 40.00%
Michael S. Tsirkin 7 8.43% 1 20.00%
Frédéric Weisbecker 3 3.61% 1 20.00%
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 38 80.85% 2 50.00%
Michael S. Tsirkin 6 12.77% 1 25.00%
Frédéric Weisbecker 3 6.38% 1 25.00%
Total 47 100.00% 4 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 30 54.55% 1 25.00%
Bharath Ravi 13 23.64% 1 25.00%
Michael S. Tsirkin 9 16.36% 1 25.00%
Frédéric 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 44 83.02% 2 66.67%
Michael S. Tsirkin 9 16.98% 1 33.33%
Total 53 100.00% 3 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 32 82.05% 1 50.00%
Michael S. Tsirkin 7 17.95% 1 50.00%
Total 39 100.00% 2 100.00%

#else /* !CONFIG_SCHED_INFO: */

# 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 */
Overall Contributors
Person Tokens Prop Commits CommitProp
Ingo Molnar 409 55.72% 4 21.05%
Ankita Garg 127 17.30% 1 5.26%
Michael S. Tsirkin 70 9.54% 2 10.53%
Peter Zijlstra 50 6.81% 2 10.53%
Josh Poimboeuf 35 4.77% 3 15.79%
Bharath Ravi 13 1.77% 1 5.26%
Frédéric Weisbecker 12 1.63% 1 5.26%
Mel Gorman 11 1.50% 1 5.26%
Naveen N. Rao 4 0.54% 1 5.26%
Ken Chen 1 0.14% 1 5.26%
Rakib Mullick 1 0.14% 1 5.26%
Greg Kroah-Hartman 1 0.14% 1 5.26%
Total 734 100.00% 19 100.00%
Directory: kernel/sched

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
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.17 kernel/sched/stats.h

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
