per cpuset load average

[ Premise: I'm not considering this patch suitable for inclusion, mostly because I'm not convinced at all of the interface and I don't even know if cpuset is the right place for this feature. However, I just wrote it for a project and I would like to improve it, better integrate it in the kernel and share the code in general, in case someone else is also interested to use this feature. ]

Overview
~~~~~~~~
The cpusets subsystem allows to assign a different set of CPUs to a cgroup. A typical use case is to split large systems in small CPU/memory partitions and isolate certain users/applications in these subsets of the system.

Sometimes, to have a quick overview of each partition's state, we may be interested to get the load average of the CPUs assigned to a particular cpuset, rather than the global load average of the system.

Proposed solution
~~~~~~~~~~~~~~~~~
The proposal is to add a new file in the cpuset subsystem to report the load average of the CPUs assinged to a particular cpuset cgroup.

Example:

 # echo 0-1 > /sys/fs/cgroup/cpuset/foo/cpuset.cpus
 # echo 2-3 > /sys/fs/cgroup/cpuset/bar/cpuset.cpus

 # echo $$ > /sys/fs/cgroup/cpuset/foo/tasks
 # for i in `seq 4`; do yes > /dev/null & done

... after ~5mins ...

 # cat /proc/loadavg /sys/fs/cgroup/cpuset/{foo,bar}/cpuset.loadavg
 3.99 2.66 1.24 6/377 2855
 3.98 2.64 1.20
 0.01 0.02 0.04

In this case we can easily find that the cpuset "foo" is the most busy in the system.

[PATCH RFC 1/3] sched: introduce distinct per-cpu load average [PATCH RFC 2/3] cpusets: add load avgerage interface [PATCH RFC 3/3] cpusets: add documentation of the loadavg file

 include/linux/sched.h |    7 +++++
 kernel/cpuset.c       |   58 ++++++++++++++++++++++++++++++++++++
 kernel/sched/core.c   |   78 ++++++++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 139 insertions(+), 4 deletions(-)

Account per-cpu load average, as well as nr_running and nr_uninterruptible tasks.

The new element on_cpu_uninterruptible to task_struct is added to properly keep track of the cpu where the task was set to the uninterruptible sleep state.

This feature is required by the cpusets cgroup subsystem to report the load average per-cpuset.

---
 include/linux/sched.h |    7 +++++
 kernel/sched/core.c   |   78 ++++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 81 insertions(+), 4 deletions(-)

index 9d51e26..fb3df1b 100644
@@ -119,7 +119,10 @@ struct blk_plug;
  *    11 bit fractions.
  */
 extern unsigned long avenrun[];		/* Load averages */
+extern unsigned long cpu_avenrun[][NR_CPUS] /* Load averages per cpu */;
 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 */

@@ -138,7 +141,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);

@@ -1239,6 +1244,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;
 

1.7.9.5

Right, the update must be atomic to have a coherent nr_uninterruptible value. And AFAICS the only way to account a coherent nr_uninterruptible value per-cpu is to go with atomic ops... mmh... I'll think more on this.

Correct, I didn't realize that, sorry.

Many thanks for your review, Peter.

-Andrea

You could stick it in the cpu controller instead of cpuset, add a per-cpu nr_uninterruptible counter to struct task_group and update it from the enqueue/dequeue paths. Those already are per-cgroup (through cfs_rq, which has a tg pointer).

That would also give you better semantics since it would really be the load of the tasks of the cgroup, not whatever happened to run on a particular cpu regardless of groups. Then again, it might be 'fun' to get the hierarchical semantics right :-)

OTOH it would also make calculating the load-avg O(nr_cgroups) and since we do this from the tick and people are known to create a shitload (on the order of 1e3 and upwards) of those this might not actually be a very good idea.

Also, your patch 2 relies on the load avg function to be additive yet your completely fail to mention this and state whether this is so or not.

Furthermore, please look at PER_CPU() and friends as alternatives to [NR_CPUS] arrays.

That would be an interesting path to explore, even if my concern goes to the large hosting companies that want to create like a cpu cgroup for each user. In this case we may have big scalability issues. Maintaining all the required stats per-cpu seems a more scalable solution to me (except probably for the large SMP systems case...).

I wonder if it is worth to define rq->nr_uninterruptible as a pointer to percpu data rather than converting it to an atomic var... but this would be even worst for the large SMP systems. Especially for those that are not interested in the loadavg feature.

Correct, I'll report a more detailed description in the next version.

Will do.

Thanks again for your suggestions.

-Andrea

Add the new file loadavg to report the load average of the cpus assigned to the cpuset cgroup.

The load average is reported using the typical three values as they appear in /proc/loadavg, averaged over 1, 5 and 15 minutes.

Example:

  # cat /sys/fs/cgroup/cpuset/foo/cpuset.loadavg
  3.98 2.64 1.20

---
 kernel/cpuset.c |   58 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

index f33c715..fef6d3e 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,57 @@ 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;
+
+	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 +1832,12 @@ static struct cftype files[] = {
 		.private = FILE_MEMORY_PRESSURE_ENABLED,
 	},
 
+	{
+		.name = "loadavg",
+		.read_seq_string = cpuset_read_seq_string,
+		.private = FILE_LOADAVG,
+	},
+
 	{ }	/* terminate */
 };
 

1.7.9.5

---
 Documentation/cgroups/cpusets.txt |    1 +
 1 file changed, 1 insertion(+)

index cefd3d8..d5ddc36 100644
@@ -179,6 +179,7 @@ files describing that cpuset:
  - cpuset.memory_spread_slab flag: if set, spread slab cache evenly on allowed nodes
  - cpuset.sched_load_balance flag: if set, load balance within CPUs on that cpuset
  - cpuset.sched_relax_domain_level: the searching range when migrating tasks
+ - cpuset.loadavg: the load average of the CPUs in that cpuset
 
 In addition, only the root cpuset has the following file:
  - cpuset.memory_pressure_enabled flag: compute memory_pressure?

1.7.9.5