distinct load average per-cpuset

index 0dd42a0..e5dfe2a 100644
@@ -80,6 +80,8 @@ struct blk_plug;
  */
 extern unsigned long avenrun[];		/* Load averages */
 extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
+extern void get_cpu_avenrun(unsigned long *loads, int cpu,
+				unsigned long offset, int shift);
 
 #define FSHIFT		11		/* nr of bits of precision */
 #define FIXED_1		(1<<FSHIFT)	/* 1.0 as fixed-point */

@@ -98,7 +100,9 @@ extern int nr_threads;
 DECLARE_PER_CPU(unsigned long, process_counts);
 extern int nr_processes(void);
 extern unsigned long nr_running(void);
+extern unsigned long nr_running_cpu(int cpu);
 extern unsigned long nr_uninterruptible(void);
+extern unsigned long nr_uninterruptible_cpu(int cpu);
 extern unsigned long nr_iowait(void);
 extern unsigned long nr_iowait_cpu(int cpu);
 extern unsigned long this_cpu_load(void);

@@ -1197,6 +1201,8 @@ struct task_struct {
 #ifdef CONFIG_SMP
 	struct llist_node wake_entry;
 	int on_cpu;
+	/* Used to keep track of nr_uninterruptible tasks per-cpu */
+	int on_cpu_uninterruptible;
 #endif
 	int on_rq;
 

206 lines not on this page · raw message

index 6f79596..ac6c73f 100644
@@ -276,7 +276,8 @@ do {									\
 		   rq->load.weight);
 	P(nr_switches);
 	P(nr_load_updates);
-	P(nr_uninterruptible);
+	SEQ_printf(m, "  .%-30s: %lu\n", "nr_uninterruptible",
+		   nr_uninterruptible_cpu(cpu));
 	PN(next_balance);
 	P(curr->pid);
 	PN(clock);

index 7a7db09..8a0d303 100644
@@ -383,13 +383,7 @@ struct rq {
 	struct list_head leaf_rt_rq_list;
 #endif
 
-	/*
-	 * This is part of a global counter where only the total sum
-	 * over all CPUs matters. A task can increase this counter on
-	 * one CPU and if it got migrated afterwards it may decrease
-	 * it on another CPU. Always updated under the runqueue lock:
-	 */
-	unsigned long nr_uninterruptible;
+	unsigned long __percpu *nr_uninterruptible;
 
 	struct task_struct *curr, *idle, *stop;
 	unsigned long next_balance;

index f33c715..1bb10d1 100644
@@ -1465,6 +1465,7 @@ typedef enum {
 	FILE_MEMORY_PRESSURE,
 	FILE_SPREAD_PAGE,
 	FILE_SPREAD_SLAB,
+	FILE_LOADAVG,
 } cpuset_filetype_t;
 
 static int cpuset_write_u64(struct cgroup *cgrp, struct cftype *cft, u64 val)

@@ -1686,6 +1687,107 @@ static s64 cpuset_read_s64(struct cgroup *cont, struct cftype *cft)
 	return 0;
 }
 
+/*
+ * XXX: move all of this to a better place and unify the different
+ * re-definition of these macros.
+ */
+#define LOAD_INT(x) ((x) >> FSHIFT)
+#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
+
+static void cpuset_show_loadavg(struct seq_file *m, const struct cpuset *cs)
+{
+	unsigned long avnrun[3] = {};
+	int cpu;
+
+	/*
+	 * The global load average is an exponentially decaying average of:
+	 *
+	 *   x(t) = nr_running(t) + nr_uninterruptible(t)
+	 *
+	 * The global load average of the system is evaluated as:
+	 *
+	 *   load(t) = load(t - 1) * exp_k + x(t) * (1 - exp_k)
+	 *
+	 * So, the load average of a cpuset with N CPUS can be evaluated as:
+	 *
+	 *   load_cs(t) = load_cs(t - 1) * exp_k + x_cs(t) * (1 - exp_k),
+	 *   x_cs(t) = \sum{i = 1}^{N} x_i(t)
+	 *
+	 * This is equivalent to the sum of all the partial load averages of
+	 * each CPU assigned to the cpuset:
+	 *
+	 *   load_cs(t) = \sum{i = 1}^{N} load_i(t)
+	 *
+	 * Proof:
+	 *
+	 *   load_1(t) = load_1(t - 1) * exp_k + x_1(t) * (1 - exp_k)
+	 *   load_2(t) = load_2(t - 1) * exp_k + x_2(t) * (1 - exp_k)
+	 *   ...
+	 *   load_N(t) = load_N(t - 1) * exp_k + x_N(t) * (1 - exp_k)
+	 *
+	 *   ===>
+	 *
+	 *   load_1(t) = x_1(1) * (1 - exp_k) * exp_k^{t - 1} +
+	 *               x_1(2) * (1 - exp_k) * exp_k^{t - 2} +
+	 *               ... +
+	 *               x_1(t)(1 - exp_k)
+	 *   load_2(t) = x_2(1) * (1 - exp_k) * exp_k^{t - 1} +
+	 *               x_2(2) * (1 - exp_k) * exp_k^{t - 2} +
+	 *               ... +
+	 *               x_2(t)(1 - exp_k)
+	 *   ...
+	 *   load_N(t) = x_N(1) * (1 - exp_k) * exp_k^{t - 1} +
+	 *               x_N(2) * (1 - exp_k) * exp_k^{t - 2} +
+	 *               ... +
+	 *               x_N(t)(1 - exp_k)
+	 *
+	 *   ===>
+	 *
+	 *   load_1(t) + load_2(t) + ... + load_N(t) =
+	 *       \sum_{i = 1}^{N} x_i(1) * (1 - exp_k) * exp_k^{t - 1} +
+	 *       \sum_{i = 1}^{N} x_i(2) * (1 - exp_k) * exp_k^{t - 2} +
+	 *       ... +
+	 *       \sum_{i = 1}^{N} x_i(t) * (1 - exp_k) = load_cs(t)
+	 */
+	for_each_cpu(cpu, cs->cpus_allowed) {
+		unsigned long cpu_avnrun[3];
+		int i;
+
+		get_cpu_avenrun(cpu_avnrun, cpu, FIXED_1/200, 0);
+
+		for (i = 0; i < ARRAY_SIZE(cpu_avnrun); i++)
+			avnrun[i] += cpu_avnrun[i];
+	}
+	/*
+	 * TODO: also report nr_running/nr_threads and last_pid, producing the
+	 * same output as /proc/loadavg.
+	 *
+	 * For nr_running we can just sum the nr_running_cpu() of the cores
+	 * assigned to this cs; what should we report in nr_threads? maybe
+	 * cgroup_task_count()? and what about last_pid?
+	 */
+	seq_printf(m, "%lu.%02lu %lu.%02lu %lu.%02lu\n",
+		   LOAD_INT(avnrun[0]), LOAD_FRAC(avnrun[0]),
+		   LOAD_INT(avnrun[1]), LOAD_FRAC(avnrun[1]),
+		   LOAD_INT(avnrun[2]), LOAD_FRAC(avnrun[2]));
+}
+
+static int cpuset_read_seq_string(struct cgroup *cont, struct cftype *cft,
+			       struct seq_file *m)
+{
+	struct cpuset *cs = cgroup_cs(cont);
+	cpuset_filetype_t type = cft->private;
+
+	switch (type) {
+	case FILE_LOADAVG:
+		cpuset_show_loadavg(m, cs);
+		break;
+	default:
+		BUG();
+	}
+
+	return 0;
+}
 
 /*
  * for the common functions, 'private' gives the type of file

@@ -1780,6 +1882,12 @@ static struct cftype files[] = {
 		.private = FILE_MEMORY_PRESSURE_ENABLED,
 	},
 
+	{
+		.name = "loadavg",
+		.read_seq_string = cpuset_read_seq_string,
+		.private = FILE_LOADAVG,
+	},
+
 	{ }	/* terminate */
 };