Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 1 | |
| 2 | #ifdef CONFIG_SCHEDSTATS |
| 3 | /* |
| 4 | * bump this up when changing the output format or the meaning of an existing |
| 5 | * format, so that tools can adapt (or abort) |
| 6 | */ |
| 7 | #define SCHEDSTAT_VERSION 14 |
| 8 | |
| 9 | static int show_schedstat(struct seq_file *seq, void *v) |
| 10 | { |
| 11 | int cpu; |
Mike Travis | 39106dc | 2008-04-08 11:43:03 -0700 | [diff] [blame] | 12 | int mask_len = NR_CPUS/32 * 9; |
| 13 | char *mask_str = kmalloc(mask_len, GFP_KERNEL); |
| 14 | |
| 15 | if (mask_str == NULL) |
| 16 | return -ENOMEM; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 17 | |
| 18 | seq_printf(seq, "version %d\n", SCHEDSTAT_VERSION); |
| 19 | seq_printf(seq, "timestamp %lu\n", jiffies); |
| 20 | for_each_online_cpu(cpu) { |
| 21 | struct rq *rq = cpu_rq(cpu); |
| 22 | #ifdef CONFIG_SMP |
| 23 | struct sched_domain *sd; |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 24 | int dcount = 0; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 25 | #endif |
| 26 | |
| 27 | /* runqueue-specific stats */ |
| 28 | seq_printf(seq, |
Ken Chen | 480b943 | 2007-10-18 21:32:56 +0200 | [diff] [blame] | 29 | "cpu%d %u %u %u %u %u %u %u %u %u %llu %llu %lu", |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 30 | cpu, rq->yld_both_empty, |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 31 | rq->yld_act_empty, rq->yld_exp_empty, rq->yld_count, |
| 32 | rq->sched_switch, rq->sched_count, rq->sched_goidle, |
| 33 | rq->ttwu_count, rq->ttwu_local, |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 34 | rq->rq_sched_info.cpu_time, |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 35 | rq->rq_sched_info.run_delay, rq->rq_sched_info.pcount); |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 36 | |
| 37 | seq_printf(seq, "\n"); |
| 38 | |
| 39 | #ifdef CONFIG_SMP |
| 40 | /* domain-specific stats */ |
| 41 | preempt_disable(); |
| 42 | for_each_domain(cpu, sd) { |
| 43 | enum cpu_idle_type itype; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 44 | |
Mike Travis | 39106dc | 2008-04-08 11:43:03 -0700 | [diff] [blame] | 45 | cpumask_scnprintf(mask_str, mask_len, sd->span); |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 46 | seq_printf(seq, "domain%d %s", dcount++, mask_str); |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 47 | for (itype = CPU_IDLE; itype < CPU_MAX_IDLE_TYPES; |
| 48 | itype++) { |
Ken Chen | 480b943 | 2007-10-18 21:32:56 +0200 | [diff] [blame] | 49 | seq_printf(seq, " %u %u %u %u %u %u %u %u", |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 50 | sd->lb_count[itype], |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 51 | sd->lb_balanced[itype], |
| 52 | sd->lb_failed[itype], |
| 53 | sd->lb_imbalance[itype], |
| 54 | sd->lb_gained[itype], |
| 55 | sd->lb_hot_gained[itype], |
| 56 | sd->lb_nobusyq[itype], |
| 57 | sd->lb_nobusyg[itype]); |
| 58 | } |
Ingo Molnar | f95e0d1 | 2007-11-28 15:52:56 +0100 | [diff] [blame] | 59 | seq_printf(seq, |
| 60 | " %u %u %u %u %u %u %u %u %u %u %u %u\n", |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 61 | sd->alb_count, sd->alb_failed, sd->alb_pushed, |
| 62 | sd->sbe_count, sd->sbe_balanced, sd->sbe_pushed, |
| 63 | sd->sbf_count, sd->sbf_balanced, sd->sbf_pushed, |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 64 | sd->ttwu_wake_remote, sd->ttwu_move_affine, |
| 65 | sd->ttwu_move_balance); |
| 66 | } |
| 67 | preempt_enable(); |
| 68 | #endif |
| 69 | } |
| 70 | return 0; |
| 71 | } |
| 72 | |
| 73 | static int schedstat_open(struct inode *inode, struct file *file) |
| 74 | { |
| 75 | unsigned int size = PAGE_SIZE * (1 + num_online_cpus() / 32); |
| 76 | char *buf = kmalloc(size, GFP_KERNEL); |
| 77 | struct seq_file *m; |
| 78 | int res; |
| 79 | |
| 80 | if (!buf) |
| 81 | return -ENOMEM; |
| 82 | res = single_open(file, show_schedstat, NULL); |
| 83 | if (!res) { |
| 84 | m = file->private_data; |
| 85 | m->buf = buf; |
| 86 | m->size = size; |
| 87 | } else |
| 88 | kfree(buf); |
| 89 | return res; |
| 90 | } |
| 91 | |
| 92 | const struct file_operations proc_schedstat_operations = { |
| 93 | .open = schedstat_open, |
| 94 | .read = seq_read, |
| 95 | .llseek = seq_lseek, |
| 96 | .release = single_release, |
| 97 | }; |
| 98 | |
| 99 | /* |
| 100 | * Expects runqueue lock to be held for atomicity of update |
| 101 | */ |
| 102 | static inline void |
| 103 | rq_sched_info_arrive(struct rq *rq, unsigned long long delta) |
| 104 | { |
| 105 | if (rq) { |
| 106 | rq->rq_sched_info.run_delay += delta; |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 107 | rq->rq_sched_info.pcount++; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 108 | } |
| 109 | } |
| 110 | |
| 111 | /* |
| 112 | * Expects runqueue lock to be held for atomicity of update |
| 113 | */ |
| 114 | static inline void |
| 115 | rq_sched_info_depart(struct rq *rq, unsigned long long delta) |
| 116 | { |
| 117 | if (rq) |
| 118 | rq->rq_sched_info.cpu_time += delta; |
| 119 | } |
| 120 | # define schedstat_inc(rq, field) do { (rq)->field++; } while (0) |
| 121 | # define schedstat_add(rq, field, amt) do { (rq)->field += (amt); } while (0) |
Ingo Molnar | c3c7011 | 2007-08-02 17:41:40 +0200 | [diff] [blame] | 122 | # define schedstat_set(var, val) do { var = (val); } while (0) |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 123 | #else /* !CONFIG_SCHEDSTATS */ |
| 124 | static inline void |
| 125 | rq_sched_info_arrive(struct rq *rq, unsigned long long delta) |
| 126 | {} |
| 127 | static inline void |
| 128 | rq_sched_info_depart(struct rq *rq, unsigned long long delta) |
| 129 | {} |
| 130 | # define schedstat_inc(rq, field) do { } while (0) |
| 131 | # define schedstat_add(rq, field, amt) do { } while (0) |
Ingo Molnar | c3c7011 | 2007-08-02 17:41:40 +0200 | [diff] [blame] | 132 | # define schedstat_set(var, val) do { } while (0) |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 133 | #endif |
| 134 | |
Balbir Singh | 9a41785 | 2007-11-09 22:39:37 +0100 | [diff] [blame] | 135 | #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT) |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 136 | /* |
| 137 | * Called when a process is dequeued from the active array and given |
| 138 | * the cpu. We should note that with the exception of interactive |
| 139 | * tasks, the expired queue will become the active queue after the active |
| 140 | * queue is empty, without explicitly dequeuing and requeuing tasks in the |
| 141 | * expired queue. (Interactive tasks may be requeued directly to the |
| 142 | * active queue, thus delaying tasks in the expired queue from running; |
| 143 | * see scheduler_tick()). |
| 144 | * |
| 145 | * This function is only called from sched_info_arrive(), rather than |
| 146 | * dequeue_task(). Even though a task may be queued and dequeued multiple |
| 147 | * times as it is shuffled about, we're really interested in knowing how |
| 148 | * long it was from the *first* time it was queued to the time that it |
| 149 | * finally hit a cpu. |
| 150 | */ |
| 151 | static inline void sched_info_dequeued(struct task_struct *t) |
| 152 | { |
| 153 | t->sched_info.last_queued = 0; |
| 154 | } |
| 155 | |
| 156 | /* |
| 157 | * Called when a task finally hits the cpu. We can now calculate how |
| 158 | * long it was waiting to run. We also note when it began so that we |
| 159 | * can keep stats on how long its timeslice is. |
| 160 | */ |
| 161 | static void sched_info_arrive(struct task_struct *t) |
| 162 | { |
Balbir Singh | 9a41785 | 2007-11-09 22:39:37 +0100 | [diff] [blame] | 163 | unsigned long long now = task_rq(t)->clock, delta = 0; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 164 | |
| 165 | if (t->sched_info.last_queued) |
| 166 | delta = now - t->sched_info.last_queued; |
| 167 | sched_info_dequeued(t); |
| 168 | t->sched_info.run_delay += delta; |
| 169 | t->sched_info.last_arrival = now; |
Ingo Molnar | 2d72376 | 2007-10-15 17:00:12 +0200 | [diff] [blame] | 170 | t->sched_info.pcount++; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 171 | |
| 172 | rq_sched_info_arrive(task_rq(t), delta); |
| 173 | } |
| 174 | |
| 175 | /* |
| 176 | * Called when a process is queued into either the active or expired |
| 177 | * array. The time is noted and later used to determine how long we |
| 178 | * had to wait for us to reach the cpu. Since the expired queue will |
| 179 | * become the active queue after active queue is empty, without dequeuing |
| 180 | * and requeuing any tasks, we are interested in queuing to either. It |
| 181 | * is unusual but not impossible for tasks to be dequeued and immediately |
| 182 | * requeued in the same or another array: this can happen in sched_yield(), |
| 183 | * set_user_nice(), and even load_balance() as it moves tasks from runqueue |
| 184 | * to runqueue. |
| 185 | * |
| 186 | * This function is only called from enqueue_task(), but also only updates |
| 187 | * the timestamp if it is already not set. It's assumed that |
| 188 | * sched_info_dequeued() will clear that stamp when appropriate. |
| 189 | */ |
| 190 | static inline void sched_info_queued(struct task_struct *t) |
| 191 | { |
| 192 | if (unlikely(sched_info_on())) |
| 193 | if (!t->sched_info.last_queued) |
Balbir Singh | 9a41785 | 2007-11-09 22:39:37 +0100 | [diff] [blame] | 194 | t->sched_info.last_queued = task_rq(t)->clock; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 195 | } |
| 196 | |
| 197 | /* |
| 198 | * Called when a process ceases being the active-running process, either |
| 199 | * voluntarily or involuntarily. Now we can calculate how long we ran. |
| 200 | */ |
| 201 | static inline void sched_info_depart(struct task_struct *t) |
| 202 | { |
Balbir Singh | 9a41785 | 2007-11-09 22:39:37 +0100 | [diff] [blame] | 203 | unsigned long long delta = task_rq(t)->clock - |
| 204 | t->sched_info.last_arrival; |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 205 | |
| 206 | t->sched_info.cpu_time += delta; |
| 207 | rq_sched_info_depart(task_rq(t), delta); |
| 208 | } |
| 209 | |
| 210 | /* |
| 211 | * Called when tasks are switched involuntarily due, typically, to expiring |
| 212 | * their time slice. (This may also be called when switching to or from |
| 213 | * the idle task.) We are only called when prev != next. |
| 214 | */ |
| 215 | static inline void |
| 216 | __sched_info_switch(struct task_struct *prev, struct task_struct *next) |
| 217 | { |
| 218 | struct rq *rq = task_rq(prev); |
| 219 | |
| 220 | /* |
| 221 | * prev now departs the cpu. It's not interesting to record |
| 222 | * stats about how efficient we were at scheduling the idle |
| 223 | * process, however. |
| 224 | */ |
| 225 | if (prev != rq->idle) |
| 226 | sched_info_depart(prev); |
| 227 | |
| 228 | if (next != rq->idle) |
| 229 | sched_info_arrive(next); |
| 230 | } |
| 231 | static inline void |
| 232 | sched_info_switch(struct task_struct *prev, struct task_struct *next) |
| 233 | { |
| 234 | if (unlikely(sched_info_on())) |
| 235 | __sched_info_switch(prev, next); |
| 236 | } |
| 237 | #else |
| 238 | #define sched_info_queued(t) do { } while (0) |
| 239 | #define sched_info_switch(t, next) do { } while (0) |
Balbir Singh | 9a41785 | 2007-11-09 22:39:37 +0100 | [diff] [blame] | 240 | #endif /* CONFIG_SCHEDSTATS || CONFIG_TASK_DELAY_ACCT */ |
Ingo Molnar | 425e096 | 2007-07-09 18:51:58 +0200 | [diff] [blame] | 241 | |