Add support for one single cluster (all cpus) on C-EDF

- With the "ALL" cluster size option the behavior of C-EDF is
  equivalent to G-EDF (one single cluster)

2 files changed, 31 insertions, 13 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index e43596a5104c..c14203e6f611 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -575,8 +575,10 @@ static int proc_read_cluster_size(char *page, char **start,
                 len = snprintf(page, PAGE_SIZE, "L2\n");
         else if (cluster_cache_index == 3)
                 len = snprintf(page, PAGE_SIZE, "L3\n");
-        else /* (cluster_cache_index == 1) */
+        else if (cluster_cache_index == 1)
                 len = snprintf(page, PAGE_SIZE, "L1\n");
+        else
+                len = snprintf(page, PAGE_SIZE, "ALL\n");
 
         return len;
 }
@@ -610,6 +612,8 @@ static int proc_write_cluster_size(struct file *file,
                 cluster_cache_index = 3;
         else if (!strcmp(cache_name, "L1"))
                 cluster_cache_index = 1;
+        else if (!strcmp(cache_name, "ALL"))
+                cluster_cache_index = num_online_cpus();
         else
                 printk(KERN_INFO "Cluster '%s' is unknown.\n", cache_name);
 
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index da44b451c9ad..0e292aa7b97c 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -12,10 +12,14 @@
  *   the programmer needs to be aware of the topology to place tasks
  *   in the desired cluster
  * - default clustering is around L2 cache (cache index = 2)
- *   supported clusters are: L1 (private cache: pedf), L2, L3
+ *   supported clusters are: L1 (private cache: pedf), L2, L3, ALL (all
+ *   online_cpus are placed in a single cluster).
  *
  *   For details on functions, take a look at sched_gsn_edf.c
  *
+ * Currently, we do not support changes in the number of online cpus.
+ * If the num_online_cpus() dynamically changes, the plugin is broken.
+ *
  * This version uses the simple approach and serializes all scheduling
  * decisions by the use of a queue lock. This is probably not the
  * best way to do it, but it should suffice for now.
@@ -640,17 +644,23 @@ static long cedf_activate_plugin(void)
         if(!zalloc_cpumask_var(&mask, GFP_ATOMIC))
                 return -ENOMEM;
 
-        chk = get_shared_cpu_map(mask, 0, cluster_cache_index);
-        if (chk) {
-                /* if chk != 0 then it is the max allowed index */
-                printk(KERN_INFO "C-EDF: Cannot support cache index = %d\n",
-                                cluster_cache_index);
-                printk(KERN_INFO "C-EDF: Using cache index = %d\n",
-                                chk);
-                cluster_cache_index = chk;
-        }
+        if (unlikely(cluster_cache_index == num_online_cpus())) {
+
+                cluster_size = num_online_cpus();
+        } else {
 
-        cluster_size = cpumask_weight(mask);
+                chk = get_shared_cpu_map(mask, 0, cluster_cache_index);
+                if (chk) {
+                        /* if chk != 0 then it is the max allowed index */
+                        printk(KERN_INFO "C-EDF: Cannot support cache index = %d\n",
+                                        cluster_cache_index);
+                        printk(KERN_INFO "C-EDF: Using cache index = %d\n",
+                                        chk);
+                        cluster_cache_index = chk;
+                }
+
+                cluster_size = cpumask_weight(mask);
+        }
 
         if ((num_online_cpus() % cluster_size) != 0) {
                 /* this can't be right, some cpus are left out */
@@ -693,7 +703,11 @@ static long cedf_activate_plugin(void)
 
                         /* this cpu isn't in any cluster */
                         /* get the shared cpus */
-                        get_shared_cpu_map(mask, cpu, cluster_cache_index);
+                        if (unlikely(cluster_cache_index == num_online_cpus()))
+                                cpumask_copy(mask, cpu_online_mask);
+                        else
+                                get_shared_cpu_map(mask, cpu, cluster_cache_index);
+
                         cpumask_copy(cedf[i].cpu_map, mask);
 #ifdef VERBOSE_INIT
                         print_cluster_topology(mask, cpu);