Add support for changing cluster size upon re-activation

- Cluster size can be modified unloading / reloading the plugin
- Add proper cleanup functions
- Polishing comments

1 files changed, 86 insertions, 56 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index db543f179838..d79278a571f7 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -11,6 +11,8 @@
  * - The plugins _does not_ attempt to put tasks in the right cluster i.e.
  *   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
  *
  *   For details on functions, take a look at sched_gsn_edf.c
  *
@@ -85,10 +87,12 @@ cedf_domain_t *cedf;
 #define remote_cluster(cpu)     ((cedf_domain_t *) per_cpu(cedf_cpu_entries, cpu).cluster)
 #define task_cpu_cluster(task)  remote_cluster(get_partition(task))
 
-/* Uncomment this if you want to see all scheduling decisions in the
- * TRACE() log.
+/* Uncomment WANT_ALL_SCHED_EVENTS if you want to see all scheduling
+ * decisions in the TRACE() log; uncomment VERBOSE_INIT for verbose
+ * information during the initialization of the plugin (e.g., topology)
 #define WANT_ALL_SCHED_EVENTS
  */
+#define VERBOSE_INIT
 
 static int cpu_lower_prio(struct bheap_node *_a, struct bheap_node *_b)
 {
@@ -745,97 +749,107 @@ static int num_clusters;
 /* we do not support cluster of different sizes */
 static unsigned int cluster_size;
 
-static long cedf_activate_plugin(void)
+#ifdef VERBOSE_INIT
+static void print_cluster_topology(cpumask_var_t mask, int cpu)
+{
+        int chk;
+        char buf[255];
+
+        chk = cpulist_scnprintf(buf, 254, mask);
+        buf[chk] = '\0';
+        printk(KERN_INFO "CPU = %d, shared cpu(s) = %s\n", cpu, buf);
+
+}
+
+static void cluster_check(void)
 {
         int i,j;
-        /* system checkup */
+
         for (i = 0; i < num_clusters; i++) {
-                printk(KERN_INFO "\nclus = %d\n", i);
+                printk(KERN_INFO "\nCluster = %d\ncpus: ", i);
                 for (j = 0; j < cluster_size; j++)
-                        printk(KERN_INFO "cpus = %d\n", (cedf[i].cpus[j])->cpu);
+                        printk(KERN_INFO "%d ", (cedf[i].cpus[j])->cpu);
         }
+}
+#endif
 
-        return 0;
+static void cleanup_cedf(void)
+{
+        int i;
+        for (i = 0; i < num_clusters; i++) {
+                kfree(cedf[i].cpus);
+                kfree(cedf[i].heap_node);
+                free_cpumask_var(cedf[i].cpu_map);
+        }
+
+        kfree(cedf);
 }
 
-/*      Plugin object   */
-static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
-        .plugin_name            = "C-EDF",
-        .finish_switch          = cedf_finish_switch,
-        .tick                   = cedf_tick,
-        .task_new               = cedf_task_new,
-        .complete_job           = complete_job,
-        .task_exit              = cedf_task_exit,
-        .schedule               = cedf_schedule,
-        .task_wake_up           = cedf_task_wake_up,
-        .task_block             = cedf_task_block,
-#ifdef CONFIG_FMLP
-        .fmlp_active            = 1,
-        .pi_block               = cedf_pi_block,
-        .inherit_priority       = cedf_inherit_priority,
-        .return_priority        = cedf_return_priority,
-#endif
-        .admit_task             = cedf_admit_task,
-        .activate_plugin        = cedf_activate_plugin,
-};
+static long cedf_deactivate_plugin(void)
+{
+        cleanup_cedf();
+        printk(KERN_INFO "C-EDF: Deactivate Plugin\n");
 
+        return 0;
+}
 
-static int __init init_cedf(void)
+static long cedf_activate_plugin(void)
 {
         int i, j, cpu, ccpu, cpu_count;
         cpu_entry_t *entry;
 
         cpumask_var_t mask;
-        char buf[255];
         int chk = 0;
 
-        printk(KERN_INFO "C-EDF: Init Plugin, cluster around cache index %d\n",
+        printk(KERN_INFO "C-EDF: Activate Plugin, cache index = %d\n",
                         cluster_cache_index);
 
         /* need to get cluster_size first */
-        if(!zalloc_cpumask_var(&mask, GFP_KERNEL))
+        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;
         }
 
         cluster_size = cpumask_weight(mask);
-        printk(KERN_INFO "cluster_size = %d\n", cluster_size);
 
         if ((num_online_cpus() % cluster_size) != 0) {
                 /* this can't be right, some cpus are left out */
-                printk(KERN_INFO "C-EDF: Trying to group %d cpus in %d!\n",
+                printk(KERN_ERR "C-EDF: Trying to group %d cpus in %d!\n",
                                 num_online_cpus(), cluster_size);
                 return -1;
         }
 
         num_clusters = num_online_cpus() / cluster_size;
-        printk(KERN_INFO "online_cpus = %d, nclus = %d\n", num_online_cpus(), num_clusters);
+        printk(KERN_INFO "C-EDF: %d cluster(s) of size = %d\n",
+                        num_clusters, cluster_size);
 
         /* initialize clusters */
-        cedf = kmalloc(num_clusters * sizeof(cedf_domain_t), GFP_KERNEL);
+        cedf = kmalloc(num_clusters * sizeof(cedf_domain_t), GFP_ATOMIC);
         for (i = 0; i < num_clusters; i++) {
 
                 cedf[i].cpus = kmalloc(cluster_size * sizeof(cpu_entry_t),
-                                GFP_KERNEL);
+                                GFP_ATOMIC);
                 cedf[i].heap_node = kmalloc(
                                 cluster_size * sizeof(struct bheap_node),
-                                GFP_KERNEL);
+                                GFP_ATOMIC);
                 bheap_init(&(cedf[i].cpu_heap));
                 edf_domain_init(&(cedf[i].domain), NULL, cedf_release_jobs);
 
-                if(!zalloc_cpumask_var(&cedf[i].cpu_map, GFP_KERNEL))
+                if(!zalloc_cpumask_var(&cedf[i].cpu_map, GFP_ATOMIC))
                         return -ENOMEM;
         }
 
         /* cycle through cluster and add cpus to them */
         for (i = 0; i < num_clusters; i++) {
 
-                printk(KERN_INFO "cluster %d\n", i);
-
                 for_each_online_cpu(cpu) {
                         /* check if the cpu is already in a cluster */
                         for (j = 0; j < num_clusters; j++)
@@ -846,20 +860,15 @@ static int __init init_cedf(void)
                                 continue;
 
                         /* this cpu isn't in any cluster */
-                        printk(KERN_INFO "cpu = %d\n", cpu);
-
                         /* get the shared cpus */
                         get_shared_cpu_map(mask, cpu, cluster_cache_index);
                         cpumask_copy(cedf[i].cpu_map, mask);
-
-                        chk = cpulist_scnprintf(buf, 254, mask);
-                        buf[chk] = '\0';
-                        printk(KERN_INFO "CPU = %d, shared cpu(s) = %s\n", cpu, buf);
-
+#ifdef VERBOSE_INIT
+                        print_cluster_topology(mask, cpu);
+#endif
                         /* add cpus to current cluster and init cpu_entry_t */
                         cpu_count = 0;
                         for_each_cpu(ccpu, cedf[i].cpu_map) {
-                                printk(KERN_INFO "cCPU = %d\n", ccpu);
 
                                 entry = &per_cpu(cedf_cpu_entries, ccpu);
                                 cedf[i].cpus[cpu_count] = entry;
@@ -881,19 +890,40 @@ static int __init init_cedf(void)
         }
 
         free_cpumask_var(mask);
+        return 0;
+}
+
+/*      Plugin object   */
+static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
+        .plugin_name            = "C-EDF",
+        .finish_switch          = cedf_finish_switch,
+        .tick                   = cedf_tick,
+        .task_new               = cedf_task_new,
+        .complete_job           = complete_job,
+        .task_exit              = cedf_task_exit,
+        .schedule               = cedf_schedule,
+        .task_wake_up           = cedf_task_wake_up,
+        .task_block             = cedf_task_block,
+#ifdef CONFIG_FMLP
+        .fmlp_active            = 1,
+        .pi_block               = cedf_pi_block,
+        .inherit_priority       = cedf_inherit_priority,
+        .return_priority        = cedf_return_priority,
+#endif
+        .admit_task             = cedf_admit_task,
+        .activate_plugin        = cedf_activate_plugin,
+        .deactivate_plugin      = cedf_deactivate_plugin,
+};
+
+
+static int __init init_cedf(void)
+{
         return register_sched_plugin(&cedf_plugin);
 }
 
 static void clean_cedf(void)
 {
-        int i;
-        for (i = 0; i < num_clusters; i++) {
-                kfree(cedf[i].cpus);
-                kfree(cedf[i].heap_node);
-                free_cpumask_var(cedf[i].cpu_map);
-        }
-
-        kfree(cedf);
+        cleanup_cedf();
 }
 
 module_init(init_cedf);