diff -urpN -X /home/fletch/.diff.exclude 105-numameminfo/fs/proc/proc_misc.c 111-schedstat/fs/proc/proc_misc.c
--- 105-numameminfo/fs/proc/proc_misc.c	Sat Jun 14 19:00:11 2003
+++ 111-schedstat/fs/proc/proc_misc.c	Sat Jun 14 19:00:15 2003
@@ -303,6 +303,9 @@ static struct file_operations proc_vmsta
 	.release	= seq_release,
 };
 
+extern int schedstats_read_proc(char *page, char **start, off_t off,
+				 int count, int *eof, void *data);
+
 #ifdef CONFIG_PROC_HARDWARE
 static int hardware_read_proc(char *page, char **start, off_t off,
 				 int count, int *eof, void *data)
@@ -715,6 +718,7 @@ void __init proc_misc_init(void)
 #endif
 		{"locks",	locks_read_proc},
 		{"execdomains",	execdomains_read_proc},
+		{"schedstat",	schedstats_read_proc},
 		{NULL,}
 	};
 	for (p = simple_ones; p->name; p++)
diff -urpN -X /home/fletch/.diff.exclude 105-numameminfo/kernel/sched.c 111-schedstat/kernel/sched.c
--- 105-numameminfo/kernel/sched.c	Sat Jun 14 18:37:38 2003
+++ 111-schedstat/kernel/sched.c	Sat Jun 14 19:00:15 2003
@@ -231,6 +231,83 @@ __init void node_nr_running_init(void)
 
 #endif /* CONFIG_NUMA */
 
+
+struct schedstat {
+	/* sys_sched_yield stats */
+	unsigned long yld_exp_empty;
+	unsigned long yld_act_empty;
+	unsigned long yld_both_empty;
+	unsigned long yld_cnt;
+
+	/* schedule stats */
+	unsigned long sched_noswitch;
+	unsigned long sched_switch;
+	unsigned long sched_cnt;
+
+	/* load_balance stats */
+	unsigned long lb_imbalance;
+	unsigned long lb_idle;
+	unsigned long lb_resched;
+	unsigned long lb_cnt;
+	unsigned long lb_nobusy;
+} ____cacheline_aligned;
+
+/*
+ * bump this up when changing the output format or the meaning of an existing
+ * format, so that tools can adapt (or abort)
+ */
+#define SCHEDSTAT_VERSION	1
+
+struct schedstat schedstats[NR_CPUS];
+
+/*
+ * This could conceivably exceed a page's worth of output on machines with
+ * large number of cpus, where large == about 4096/100 or 40ish. Start
+ * worrying when we pass 32, probably. Then this has to stop being a
+ * "simple" entry in proc/proc_misc.c and needs to be an actual seq_file.
+ */
+int schedstats_read_proc(char *page, char **start, off_t off,
+				 int count, int *eof, void *data)
+{
+	struct schedstat sums;
+	int i, len;
+
+	memset(&sums, 0, sizeof(sums));
+	len = sprintf(page, "version %d\n", SCHEDSTAT_VERSION);
+	for (i = 0; i < NR_CPUS; i++) {
+		if (!cpu_online(i)) continue;
+		sums.yld_exp_empty += schedstats[i].yld_exp_empty;
+		sums.yld_act_empty += schedstats[i].yld_act_empty;
+		sums.yld_both_empty += schedstats[i].yld_both_empty;
+		sums.yld_cnt += schedstats[i].yld_cnt;
+		sums.sched_noswitch += schedstats[i].sched_noswitch;
+		sums.sched_switch += schedstats[i].sched_switch;
+		sums.sched_switch += schedstats[i].sched_cnt;
+		sums.lb_idle += schedstats[i].lb_idle;
+		sums.lb_resched += schedstats[i].lb_resched;
+		sums.lb_cnt += schedstats[i].lb_cnt;
+		sums.lb_imbalance += schedstats[i].lb_imbalance;
+		sums.lb_nobusy += schedstats[i].lb_nobusy;
+		len += sprintf(page + len,
+		    "cpu%d %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
+		    i, schedstats[i].yld_both_empty,
+		    schedstats[i].yld_act_empty, schedstats[i].yld_exp_empty,
+		    schedstats[i].yld_cnt, schedstats[i].sched_noswitch,
+		    schedstats[i].sched_switch, schedstats[i].sched_cnt,
+		    schedstats[i].lb_idle, schedstats[i].lb_resched,
+		    schedstats[i].lb_cnt, schedstats[i].lb_imbalance,
+		    schedstats[i].lb_nobusy);
+	}
+	len += sprintf(page + len,
+	    "totals %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n",
+	    sums.yld_both_empty, sums.yld_act_empty, sums.yld_exp_empty,
+	    sums.yld_cnt, sums.sched_noswitch, sums.sched_switch,
+	    sums.sched_cnt, sums.lb_idle, sums.lb_resched, sums.lb_cnt,
+	    sums.lb_imbalance, sums.lb_nobusy);
+
+	return len;
+}
+
 /*
  * task_rq_lock - lock the runqueue a given task resides on and disable
  * interrupts.  Note the ordering: we can safely lookup the task_rq without
@@ -657,7 +734,6 @@ static inline task_t * context_switch(ru
 
 	return prev;
 }
-
 /*
  * nr_running, nr_uninterruptible and nr_context_switches:
  *
@@ -986,10 +1062,16 @@ static void load_balance(runqueue_t *thi
 	struct list_head *head, *curr;
 	task_t *tmp;
 
+	schedstats[this_cpu].lb_cnt++;
+	if (idle)
+		schedstats[this_cpu].lb_idle++;
 	busiest = find_busiest_queue(this_rq, this_cpu, idle, &imbalance, cpumask);
-	if (!busiest)
+	if (!busiest) {
+		schedstats[this_cpu].lb_nobusy++;
 		goto out;
+	}
 
+	schedstats[this_cpu].lb_imbalance += imbalance;
 	/*
 	 * We first consider expired tasks. Those will likely not be
 	 * executed in the near future, and they are most likely to
@@ -1244,13 +1326,14 @@ asmlinkage void schedule(void)
 	runqueue_t *rq;
 	prio_array_t *array;
 	struct list_head *queue;
-	int idx;
+	int idx, mycpu = smp_processor_id();
 
 	/*
 	 * Test if we are atomic.  Since do_exit() needs to call into
 	 * schedule() atomically, we ignore that path for now.
 	 * Otherwise, whine if we are scheduling when we should not be.
 	 */
+	schedstats[mycpu].sched_cnt++;
 	if (likely(!(current->state & (TASK_DEAD | TASK_ZOMBIE)))) {
 		if (unlikely(in_atomic())) {
 			printk(KERN_ERR "bad: scheduling while atomic!\n");
@@ -1288,6 +1371,7 @@ need_resched:
 pick_next_task:
 	if (unlikely(!rq->nr_running)) {
 #ifdef CONFIG_SMP
+		schedstats[mycpu].lb_resched++;
 		load_balance(rq, 1, cpu_to_node_mask(smp_processor_id()));
 		if (rq->nr_running)
 			goto pick_next_task;
@@ -1302,11 +1386,13 @@ pick_next_task:
 		/*
 		 * Switch the active and expired arrays.
 		 */
+		schedstats[mycpu].sched_switch++;
 		rq->active = rq->expired;
 		rq->expired = array;
 		array = rq->active;
 		rq->expired_timestamp = 0;
 	}
+	schedstats[mycpu].sched_noswitch++;
 
 	idx = sched_find_first_bit(array->bitmap);
 	queue = array->queue + idx;
@@ -1958,6 +2044,7 @@ asmlinkage long sys_sched_yield(void)
 {
 	runqueue_t *rq = this_rq_lock();
 	prio_array_t *array = current->array;
+	int mycpu = smp_processor_id();
 
 	/*
 	 * We implement yielding by moving the task into the expired
@@ -1966,7 +2053,15 @@ asmlinkage long sys_sched_yield(void)
 	 * (special rule: RT tasks will just roundrobin in the active
 	 *  array.)
 	 */
+	schedstats[mycpu].yld_cnt++;
 	if (likely(!rt_task(current))) {
+		if (current->array->nr_active == 1) {
+		    schedstats[mycpu].yld_act_empty++;
+		    if (!rq->expired->nr_active)
+			schedstats[mycpu].yld_both_empty++;
+		} else if (!rq->expired->nr_active) {
+			schedstats[mycpu].yld_exp_empty++;
+		}
 		dequeue_task(current, array);
 		enqueue_task(current, rq->expired);
 	} else {