Make release master support optional

Introduces CONFIG_RELEASE_MASTER and makes release
master support dependent on the new symbol. This is
useful because dedicated interrupt handling only applies
to "large" multicore platforms. This will allow us to
not implement smp_send_pull_timers() for all platforms.

6 files changed, 51 insertions, 3 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index d515d1af1096..674528eece14 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -9,7 +9,9 @@
 #include <linux/jiffies.h>
 #include <litmus/sched_trace.h>
 
+#ifdef CONFIG_RELEASE_MASTER
 extern atomic_t release_master_cpu;
+#endif
 
 extern atomic_t __log_seq_no;
 
diff --git a/include/litmus/rt_domain.h b/include/litmus/rt_domain.h
index 9bf980713474..59e6b54e9281 100644
--- a/include/litmus/rt_domain.h
+++ b/include/litmus/rt_domain.h
@@ -28,7 +28,10 @@ typedef struct _rt_domain {
         /* real-time tasks waiting for release are in here */
         raw_spinlock_t                  release_lock;
         struct release_queue            release_queue;
+
+#ifdef CONFIG_RELEASE_MASTER
         int                             release_master;
+#endif
 
         /* for moving tasks to the release queue */
         raw_spinlock_t                  tobe_lock;
@@ -52,8 +55,11 @@ struct release_heap {
         struct bheap                    heap;
         /* used to trigger the release */
         struct hrtimer                  timer;
+
+#ifdef CONFIG_RELEASE_MASTER
         /* used to delegate releases */
         struct hrtimer_start_on_info    info;
+#endif
         /* required for the timer callback */
         rt_domain_t*                    dom;
 };
diff --git a/litmus/Kconfig b/litmus/Kconfig
index cc49e1a7f9c7..614e1051fa49 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -1,6 +1,6 @@
 menu "LITMUS^RT"
 
-menu "Plugins"
+menu "Scheduling"
 
 config PLUGIN_CEDF
         bool "Clustered-EDF"
@@ -11,6 +11,16 @@ config PLUGIN_CEDF
           On smaller platforms (e.g., ARM PB11MPCore), using C-EDF
           makes little sense since there aren't any shared caches.
 
+config RELEASE_MASTER
+        bool "Release-master Support"
+        default n
+        help
+           Allow one processor to act as a dedicated interrupt processor
+           that services all timer interrupts, but that does not schedule
+           real-time tasks. See RTSS'09 paper for details
+           (http://www.cs.unc.edu/~anderson/papers.html).
+           Currently only supported by GSN-EDF.
+
 endmenu
 
 menu "Real-Time Synchronization"
diff --git a/litmus/litmus.c b/litmus/litmus.c
index b71fc819eb51..c60423228607 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -30,8 +30,10 @@ atomic_t cannot_use_plugin	= ATOMIC_INIT(0);
 /* Give log messages sequential IDs. */
 atomic_t __log_seq_no = ATOMIC_INIT(0);
 
+#ifdef CONFIG_RELEASE_MASTER
 /* current master CPU for handling timer IRQs */
 atomic_t release_master_cpu = ATOMIC_INIT(NO_CPU);
+#endif
 
 static struct kmem_cache * bheap_node_cache;
 extern struct kmem_cache * release_heap_cache;
@@ -627,6 +629,7 @@ static int proc_write_cluster_size(struct file *file,
         return len;
 }
 
+#ifdef CONFIG_RELEASE_MASTER
 static int proc_read_release_master(char *page, char **start,
                                     off_t off, int count,
                                     int *eof, void *data)
@@ -676,13 +679,16 @@ static int proc_write_release_master(struct file *file,
                 }
         }
 }
+#endif
 
 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;
+#ifdef CONFIG_RELEASE_MASTER
+        *release_master_file = NULL,
+#endif
+        *clus_cache_idx_file = NULL;
 
 static int __init init_litmus_proc(void)
 {
@@ -702,6 +708,7 @@ static int __init init_litmus_proc(void)
         curr_file->read_proc  = proc_read_curr;
         curr_file->write_proc = proc_write_curr;
 
+#ifdef CONFIG_RELEASE_MASTER
         release_master_file = create_proc_entry("release_master",
                                                 0644, litmus_dir);
         if (!release_master_file) {
@@ -711,6 +718,7 @@ 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;
+#endif
 
         clus_cache_idx_file = create_proc_entry("cluster_cache",
                                                 0644, litmus_dir);
@@ -741,8 +749,10 @@ static void exit_litmus_proc(void)
                 remove_proc_entry("active_plugin", litmus_dir);
         if (clus_cache_idx_file)
                 remove_proc_entry("cluster_cache", litmus_dir);
+#ifdef CONFIG_RELEASE_MASTER
         if (release_master_file)
                 remove_proc_entry("release_master", litmus_dir);
+#endif
         if (litmus_dir)
                 remove_proc_entry("litmus", NULL);
 }
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 8d5db6050723..26f1cc48f865 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -158,7 +158,9 @@ static void reinit_release_heap(struct task_struct* t)
 
         /* initialize */
         bheap_init(&rh->heap);
+#ifdef __ARCH_HAS_SEND_PULL_TIMERS
         atomic_set(&rh->info.state, HRTIMER_START_ON_INACTIVE);
+#endif
 }
 /* arm_release_timer() - start local release timer or trigger
  *     remote timer (pull timer)
@@ -221,15 +223,19 @@ static void arm_release_timer(rt_domain_t *_rt)
                          *
                          * PINNED mode is ok on both local and remote CPU
                          */
+#ifdef CONFIG_RELEASE_MASTER
                         if (rt->release_master == NO_CPU)
+#endif
                                 __hrtimer_start_range_ns(&rh->timer,
                                                 ns_to_ktime(rh->release_time),
                                                 0, HRTIMER_MODE_ABS_PINNED, 0);
+#ifdef CONFIG_RELEASE_MASTER
                         else
                                 hrtimer_start_on(rt->release_master,
                                                 &rh->info, &rh->timer,
                                                 ns_to_ktime(rh->release_time),
                                                 HRTIMER_MODE_ABS_PINNED);
+#endif
                 } else
                         TRACE_TASK(t, "0x%p is not my timer\n", &rh->timer);
         }
@@ -251,7 +257,9 @@ void rt_domain_init(rt_domain_t *rt,
         if (!order)
                 order = dummy_order;
 
+#ifdef CONFIG_RELEASE_MASTER
         rt->release_master = NO_CPU;
+#endif
 
         bheap_init(&rt->ready_queue);
         INIT_LIST_HEAD(&rt->tobe_released);
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c0c63eba70ce..e101768740ad 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -382,11 +382,13 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
+#ifdef CONFIG_RELEASE_MASTER
         /* Bail out early if we are the release master.
          * The release master never schedules any real-time tasks.
          */
         if (gsnedf.release_master == entry->cpu)
                 return NULL;
+#endif
 
         raw_spin_lock(&gsnedf_lock);
         clear_will_schedule();
@@ -518,14 +520,18 @@ static void gsnedf_task_new(struct task_struct * t, int on_rq, int running)
                 entry = &per_cpu(gsnedf_cpu_entries, task_cpu(t));
                 BUG_ON(entry->scheduled);
 
+#ifdef CONFIG_RELEASE_MASTER
                 if (entry->cpu != gsnedf.release_master) {
+#endif
                         entry->scheduled = t;
                         tsk_rt(t)->scheduled_on = task_cpu(t);
+#ifdef CONFIG_RELEASE_MASTER
                 } else {
                         /* do not schedule on release master */
                         preempt(entry); /* force resched */
                         tsk_rt(t)->scheduled_on = NO_CPU;
                 }
+#endif
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
@@ -767,7 +773,9 @@ static long gsnedf_activate_plugin(void)
         cpu_entry_t *entry;
 
         bheap_init(&gsnedf_cpu_heap);
+#ifdef CONFIG_RELEASE_MASTER
         gsnedf.release_master = atomic_read(&release_master_cpu);
+#endif
 
         for_each_online_cpu(cpu) {
                 entry = &per_cpu(gsnedf_cpu_entries, cpu);
@@ -775,12 +783,16 @@ static long gsnedf_activate_plugin(void)
                 atomic_set(&entry->will_schedule, 0);
                 entry->linked    = NULL;
                 entry->scheduled = NULL;
+#ifdef CONFIG_RELEASE_MASTER
                 if (cpu != gsnedf.release_master) {
+#endif
                         TRACE("GSN-EDF: Initializing CPU #%d.\n", cpu);
                         update_cpu_position(entry);
+#ifdef CONFIG_RELEASE_MASTER
                 } else {
                         TRACE("GSN-EDF: CPU %d is release master.\n", cpu);
                 }
+#endif
         }
         return 0;
 }