Add /proc/litmus/cluster_cache

- read L2, L3 clustering from proc file (default L2)
- check for "feasible cluster size"

6 files changed, 93 insertions, 8 deletions

diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h
index 4e60b624d121..e75daac64962 100644
--- a/arch/x86/include/asm/processor.h
+++ b/arch/x86/include/asm/processor.h
@@ -172,7 +172,7 @@ extern void print_cpu_info(struct cpuinfo_x86 *);
 extern void init_scattered_cpuid_features(struct cpuinfo_x86 *c);
 extern unsigned int init_intel_cacheinfo(struct cpuinfo_x86 *c);
 extern unsigned short num_cache_leaves;
-extern void get_shared_cpu_map(cpumask_var_t mask,
+extern int get_shared_cpu_map(cpumask_var_t mask,
                                unsigned int cpu, int index);
 
 extern void detect_extended_topology(struct cpuinfo_x86 *c);
diff --git a/arch/x86/kernel/cpu/intel_cacheinfo.c b/arch/x86/kernel/cpu/intel_cacheinfo.c
index ffdc69c05e4c..ea348f24c23b 100644
--- a/arch/x86/kernel/cpu/intel_cacheinfo.c
+++ b/arch/x86/kernel/cpu/intel_cacheinfo.c
@@ -516,13 +516,21 @@ static DEFINE_PER_CPU(struct _cpuid4_info *, cpuid4_info);
 #define CPUID4_INFO_IDX(x, y)   (&((per_cpu(cpuid4_info, x))[y]))
 
 /* returns CPUs that share the index cache with cpu */
-void get_shared_cpu_map(cpumask_var_t mask, unsigned int cpu, int index)
+int get_shared_cpu_map(cpumask_var_t mask, unsigned int cpu, int index)
 {
+        int ret = 0;
         struct _cpuid4_info *this_leaf;
 
+        printk(KERN_INFO "idx = %d, max = %d\n", index, num_cache_leaves);
+        if (index >= num_cache_leaves) {
+                index = num_cache_leaves - 1;
+                ret = index;
+        }
+
         this_leaf = CPUID4_INFO_IDX(cpu,index);
         cpumask_copy(mask, to_cpumask(this_leaf->shared_cpu_map));
-        return;
+
+        return ret;
 }
 
 #ifdef CONFIG_SMP
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 2d856d587041..9c1c9f28ba79 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -133,6 +133,9 @@ struct sched_plugin {
 
 extern struct sched_plugin *litmus;
 
+/* cluster size: cache_index = 2 L2, cache_index = 3 L3 */
+extern int cluster_cache_index;
+
 int register_sched_plugin(struct sched_plugin* plugin);
 struct sched_plugin* find_sched_plugin(const char* name);
 int print_sched_plugins(char* buf, int max);
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 3cf7cb9e8a9f..c815c5ac492c 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -554,6 +554,52 @@ static int proc_write_curr(struct file *file,
         return len;
 }
 
+static int proc_read_cluster_size(char *page, char **start,
+                          off_t off, int count,
+                          int *eof, void *data)
+{
+        int len;
+        if (cluster_cache_index == 2)
+                len = snprintf(page, PAGE_SIZE, "L2\n");
+        else
+                /* (cluster_cache_index == 3) */
+                len = snprintf(page, PAGE_SIZE, "L3\n");
+
+        return len;
+}
+
+static int proc_write_cluster_size(struct file *file,
+                           const char *buffer,
+                           unsigned long count,
+                           void *data)
+{
+        int len;
+        /* L2, L3 */
+        char cache_name[5];
+
+        if(count > 5)
+                len = 4;
+        else
+                len = count;
+
+        if(copy_from_user(cache_name, buffer, len))
+                return -EFAULT;
+
+        cache_name[len] = '\0';
+        /* chomp name */
+        if (len > 1 && cache_name[len - 1] == '\n')
+                cache_name[len - 1] = '\0';
+
+        /* do a quick and dirty comparison to find the cluster size */
+        if (!strcmp(cache_name, "L2"))
+                cluster_cache_index = 2;
+        else if (!strcmp(cache_name, "L3"))
+                cluster_cache_index = 3;
+        else
+                printk(KERN_INFO "Cluster '%s' is unknown.\n", cache_name);
+
+        return len;
+}
 
 static int proc_read_release_master(char *page, char **start,
                                     off_t off, int count,
@@ -609,6 +655,7 @@ static struct proc_dir_entry *litmus_dir = NULL,
         *curr_file = NULL,
         *stat_file = NULL,
         *plugs_file = NULL,
+        *clus_cache_idx_file = NULL,
         *release_master_file = NULL;
 
 static int __init init_litmus_proc(void)
@@ -639,6 +686,16 @@ static int __init init_litmus_proc(void)
         release_master_file->read_proc = proc_read_release_master;
         release_master_file->write_proc  = proc_write_release_master;
 
+        clus_cache_idx_file = create_proc_entry("cluster_cache",
+                                                0644, litmus_dir);
+        if (!clus_cache_idx_file) {
+                printk(KERN_ERR "Could not allocate cluster_cache "
+                       "procfs entry.\n");
+                return -ENOMEM;
+        }
+        clus_cache_idx_file->read_proc = proc_read_cluster_size;
+        clus_cache_idx_file->write_proc = proc_write_cluster_size;
+
         stat_file = create_proc_read_entry("stats", 0444, litmus_dir,
                                            proc_read_stats, NULL);
 
@@ -656,6 +713,10 @@ static void exit_litmus_proc(void)
                 remove_proc_entry("stats", litmus_dir);
         if (curr_file)
                 remove_proc_entry("active_plugin", litmus_dir);
+        if (clus_cache_idx_file)
+                remove_proc_entry("cluster_cache", litmus_dir);
+        if (release_master_file)
+                remove_proc_entry("release_master", litmus_dir);
         if (litmus_dir)
                 remove_proc_entry("litmus", NULL);
 }
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 4f3b1ebe906c..e11c4c4eb27e 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -766,11 +766,12 @@ static long cedf_activate_plugin(void)
 
         cpumask_var_t mask;
         char buf[255];
-        int wrt;
+        int chk = 0;
 
         bheap_init(&cedf_cpu_heap);
         cedf.release_master = atomic_read(&release_master_cpu);
 
+        printk(KERN_INFO "Cluster cache index = %d\n", cluster_cache_index);
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(cedf_cpu_entries, cpu);
                 bheap_node_init(&entry->hn, entry);
@@ -784,11 +785,15 @@ static long cedf_activate_plugin(void)
                         TRACE("C-EDF: CPU %d is release master.\n", cpu);
                 }
 
-                get_shared_cpu_map(mask, cpu, 2);
-                wrt = cpulist_scnprintf(buf, 254, mask);
-                buf[wrt] = '\0';
-                printk(KERN_INFO "CPU = %d, shared_L2 cpus = %s\n", cpu, buf);
+                chk = get_shared_cpu_map(mask, cpu, cluster_cache_index);
 
+                if (chk)
+                        printk(KERN_INFO "C-EDF: Cannot cluster with %d, \
+                                using %d instead", cluster_cache_index, chk);
+
+                chk = cpulist_scnprintf(buf, 254, mask);
+                buf[chk] = '\0';
+                printk(KERN_INFO "CPU = %d, shared cpus = %s\n", cpu, buf);
         }
         return 0;
 }
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index bc7c0e93fb18..3767b30e610a 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -171,6 +171,14 @@ struct sched_plugin linux_sched_plugin = {
 };
 
 /*
+ * The cluster size is needed in C-EDF: it makes sense only to cluster
+ * around L2 or L3, so if cluster_cache_index = 2 (default) we cluster
+ * all the CPUs that shares a L2 cache, while cluster_cache_index = 3
+ * we cluster all CPs that shares a L3 cache
+ */
+int cluster_cache_index = 2;
+
+/*
  *      The reference to current plugin that is used to schedule tasks within
  *      the system. It stores references to actual function implementations
  *      Should be initialized by calling "init_***_plugin()"