Skip to contentSkip to conversation

sched: Add wait, sleep and iowait accounting tracepoints

tip:sched/core tip-bot for Peter Zijlstra 2 participants 3 messages Aug 3, 2009 Tracing

lore
Share & tools
lore
#0 lore raw
Commit-ID:  5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Gitweb:     http://git.kernel.org/tip/5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Author:     Peter Zijlstra <[email protected]>
AuthorDate: Thu, 23 Jul 2009 20:13:26 +0200
Committer:  Ingo Molnar <[email protected]>
CommitDate: Mon, 3 Aug 2009 14:35:37 +0200

sched: Add wait, sleep and iowait accounting tracepoints

Add 3 schedstat tracepoints to help account for wait-time, sleep-time and iowait-time.

They can also be used as a perf-counter source to profile tasks on these clocks.

Cc Steven Rostedt <[email protected]>
Cc Frederic Weisbecker <[email protected]>
Cc Arjan van de Ven <[email protected]>

LKML-Reference: <new-submission>

---
 include/trace/events/sched.h |   95 ++++++++++++++++++++++++++++++++++++++++++
 kernel/sched_fair.c          |   10 ++++-
 2 files changed, 104 insertions(+), 1 deletions(-)
include/trace/events/sched.h +95 -0
index 8949bb7..a4c369e 100644
@@ -340,6 +340,101 @@ TRACE_EVENT(sched_signal_send,
 		  __entry->sig, __entry->comm, __entry->pid)
 );
 
+/*
+ * XXX the below sched_stat tracepoints only apply to SCHED_OTHER/BATCH/IDLE
+ *     adding sched_stat support to SCHED_FIFO/RR would be welcome.
+ */
+
+/*
+ * Tracepoint for accounting wait time (time the task is runnable
+ * but not actually running due to scheduler contention).
+ */
+TRACE_EVENT(sched_stat_wait,
+
+	TP_PROTO(struct task_struct *tsk, u64 delay),
+
+	TP_ARGS(tsk, delay),
+
+	TP_STRUCT__entry(
+		__array( char,	comm,	TASK_COMM_LEN	)
+		__field( pid_t,	pid			)
+		__field( u64,	delay			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+		__entry->pid	= tsk->pid;
+		__entry->delay	= delay;
+	)
+	TP_perf_assign(
+		__perf_count(delay);
+	),
+
+	TP_printk("task: %s:%d wait: %Lu [ns]",
+			__entry->comm, __entry->pid,
+			(unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting sleep time (time the task is not runnable,
+ * including iowait, see below).
+ */
+TRACE_EVENT(sched_stat_sleep,
+
+	TP_PROTO(struct task_struct *tsk, u64 delay),
+
+	TP_ARGS(tsk, delay),
+
+	TP_STRUCT__entry(
+		__array( char,	comm,	TASK_COMM_LEN	)
+		__field( pid_t,	pid			)
+		__field( u64,	delay			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+		__entry->pid	= tsk->pid;
+		__entry->delay	= delay;
+	)
+	TP_perf_assign(
+		__perf_count(delay);
+	),
+
+	TP_printk("task: %s:%d sleep: %Lu [ns]",
+			__entry->comm, __entry->pid,
+			(unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting iowait time (time the task is not runnable
+ * due to waiting on IO to complete).
+ */
+TRACE_EVENT(sched_stat_iowait,
+
+	TP_PROTO(struct task_struct *tsk, u64 delay),
+
+	TP_ARGS(tsk, delay),
+
+	TP_STRUCT__entry(
+		__array( char,	comm,	TASK_COMM_LEN	)
+		__field( pid_t,	pid			)
+		__field( u64,	delay			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+		__entry->pid	= tsk->pid;
+		__entry->delay	= delay;
+	)
+	TP_perf_assign(
+		__perf_count(delay);
+	),
+
+	TP_printk("task: %s:%d iowait: %Lu [ns]",
+			__entry->comm, __entry->pid,
+			(unsigned long long)__entry->delay)
+);
+
 #endif /* _TRACE_SCHED_H */
 
 /* This part must be outside protection */
kernel/sched_fair.c +9 -1
index 471fa28..0e4d6c5 100644
@@ -546,6 +546,11 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 	schedstat_set(se->wait_sum, se->wait_sum +
 			rq_of(cfs_rq)->clock - se->wait_start);
 	schedstat_set(se->wait_start, 0);
+
+	if (entity_is_task(se)) {
+		trace_sched_stat_wait(task_of(se),
+			rq_of(cfs_rq)->clock - se->wait_start);
+	}
 }
 
 static inline void
@@ -636,8 +641,10 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
 		se->sleep_start = 0;
 		se->sum_sleep_runtime += delta;
 
-		if (tsk)
+		if (tsk) {
 			account_scheduler_latency(tsk, delta >> 10, 1);
+			trace_sched_stat_sleep(tsk, delta);
+		}
 	}
 	if (se->block_start) {
 		u64 delta = rq_of(cfs_rq)->clock - se->block_start;
@@ -655,6 +662,7 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
 			if (tsk->in_iowait) {
 				se->iowait_sum += delta;
 				se->iowait_count++;
+				trace_sched_stat_iowait(tsk, delta);
 			}
 
 			/*
#1 lore raw
Quoted 10 lines · tip-bot for Peter Zijlstra
Commit-ID:  5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Gitweb:     http://git.kernel.org/tip/5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Author:     Peter Zijlstra <[email protected]>
AuthorDate: Thu, 23 Jul 2009 20:13:26 +0200
Committer:  Ingo Molnar <[email protected]>
CommitDate: Mon, 3 Aug 2009 14:35:37 +0200

kernel/sched_fair.c update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se) · line 553

Quoted 8 lines
kernel/sched_fair.c +5 -0
@@ -546,6 +546,11 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 	schedstat_set(se->wait_sum, se->wait_sum +
 			rq_of(cfs_rq)->clock - se->wait_start);
 	schedstat_set(se->wait_start, 0);
+
+	if (entity_is_task(se)) {
+		trace_sched_stat_wait(task_of(se),
+			rq_of(cfs_rq)->clock - se->wait_start);
+	}

FYI, this doesnt build with !SCHEDSTATS. I suspect we shold maintain se->wait_start unconditionally.

Ingo

#2 lore raw
Quoted 9 lines · Ingo Molnar
Quoted 6 lines · tip-bot for Peter Zijlstra
Commit-ID:  5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Gitweb:     http://git.kernel.org/tip/5f3e60fb2a0e05cdaf9b59acb0bb249bb1e96362
Author:     Peter Zijlstra <[email protected]>
AuthorDate: Thu, 23 Jul 2009 20:13:26 +0200
Committer:  Ingo Molnar <[email protected]>
CommitDate: Mon, 3 Aug 2009 14:35:37 +0200
Quoted 14 lines

kernel/sched_fair.c update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se) · line 553

Quoted 11 lines
kernel/sched_fair.c +5 -0
@@ -546,6 +546,11 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 	schedstat_set(se->wait_sum, se->wait_sum +
 			rq_of(cfs_rq)->clock - se->wait_start);
 	schedstat_set(se->wait_start, 0);
+
+	if (entity_is_task(se)) {
+		trace_sched_stat_wait(task_of(se),
+			rq_of(cfs_rq)->clock - se->wait_start);
+	}

FYI, this doesnt build with !SCHEDSTATS. I suspect we shold maintain se->wait_start unconditionally.

Also noticed that we have this TASK_INTERRUPTIBLE vs TASK_UNINTERRUPTIBLE split in sleep vs block which I overlooked the other day.

Since all the other trace_sched_stat tracepoints are under CONFIG_SCHEDSTAT I fixed the above error by adding ifdefs.

This probably wants folding back into the original patch.

---
 include/trace/events/sched.h |   36 ++++++++++++++++++++++++++++++++----
 kernel/sched_fair.c          |    3 +++
 2 files changed, 35 insertions(+), 4 deletions(-)
include/trace/events/sched.h +32 -4
index a4c369e..c201b51 100644
@@ -376,8 +376,7 @@ TRACE_EVENT(sched_stat_wait,
 );
 
 /*
- * Tracepoint for accounting sleep time (time the task is not runnable,
- * including iowait, see below).
+ * Tracepoint for accounting sleep time, TASK_INTERRUPTIBLE
  */
 TRACE_EVENT(sched_stat_sleep,
 
@@ -406,8 +405,37 @@ TRACE_EVENT(sched_stat_sleep,
 );
 
 /*
- * Tracepoint for accounting iowait time (time the task is not runnable
- * due to waiting on IO to complete).
+ * Tracepoint for accounting block time, TASK_UNINTERRUPTIBLE
+ * (including iowait).
+ */
+TRACE_EVENT(sched_stat_block,
+
+	TP_PROTO(struct task_struct *tsk, u64 delay),
+
+	TP_ARGS(tsk, delay),
+
+	TP_STRUCT__entry(
+		__array( char,	comm,	TASK_COMM_LEN	)
+		__field( pid_t,	pid			)
+		__field( u64,	delay			)
+	),
+
+	TP_fast_assign(
+		memcpy(__entry->comm, tsk->comm, TASK_COMM_LEN);
+		__entry->pid	= tsk->pid;
+		__entry->delay	= delay;
+	)
+	TP_perf_assign(
+		__perf_count(delay);
+	),
+
+	TP_printk("task: %s:%d block: %Lu [ns]",
+			__entry->comm, __entry->pid,
+			(unsigned long long)__entry->delay)
+);
+
+/*
+ * Tracepoint for accounting iowait time, TASK_UNINTERRUPTIBLE
  */
 TRACE_EVENT(sched_stat_iowait,
 
kernel/sched_fair.c +3 -0
index 0e4d6c5..abc8e6c 100644
@@ -540,6 +540,7 @@ static void update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
 static void
 update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 {
+#ifdef CONFIG_SCHEDSTATS
 	schedstat_set(se->wait_max, max(se->wait_max,
 			rq_of(cfs_rq)->clock - se->wait_start));
 	schedstat_set(se->wait_count, se->wait_count + 1);
@@ -551,6 +552,7 @@ update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
 		trace_sched_stat_wait(task_of(se),
 			rq_of(cfs_rq)->clock - se->wait_start);
 	}
+#endif
 }
 
 static inline void
@@ -664,6 +666,7 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
 				se->iowait_count++;
 				trace_sched_stat_iowait(tsk, delta);
 			}
+			trace_sched_stat_block(tsk, delta);
 
 			/*
 			 * Blocking time is in units of nanosecs, so shift by