Extend sched_plugin API for GPUSync.

Patch adds new interfaces to the sched_plugin struct/API.
New interfaces expose task prioritization and inheritance
routines of a scheduler to external components. For example,
a single locking protocol implementation can support both FIFO
and EDF prioritization via this API ("litmus->compare(a, b)").

2 files changed, 189 insertions, 8 deletions

diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index d65ae5ad8f91..8f458ffc4134 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -19,7 +19,6 @@ typedef long (*deactivate_plugin_t) (void);
 struct domain_proc_info;
 typedef long (*get_domain_proc_info_t) (struct domain_proc_info **info);
 
-
 /********************* scheduler invocation ******************/
 
 /*  Plugin-specific realtime tick handler */
@@ -61,14 +60,60 @@ typedef void (*task_exit_t)    (struct task_struct *);
  */
 typedef void (*task_cleanup_t)  (struct task_struct *);
 
+/**************************** misc ***************************/
+
+/* Called to compare the scheduling priorities between two tasks */
+typedef int (*higher_prio_t)(struct task_struct* a, struct task_struct* b);
+
+
+/************** locking and inheritance routines *************/
 #ifdef CONFIG_LITMUS_LOCKING
 /* Called when the current task attempts to create a new lock of a given
  * protocol type. */
 typedef long (*allocate_lock_t) (struct litmus_lock **lock, int type,
-                                 void* __user config);
+                                void* __user config);
+
+typedef void (*increase_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh);
+typedef void (*decrease_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh, int budget_triggered);
+typedef int (*__increase_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh);
+typedef int (*__decrease_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh, int budget_triggered);
+
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+typedef enum
+{
+        BASE,
+        EFFECTIVE
+} comparison_mode_t;
+typedef void (*nested_increase_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh, raw_spinlock_t *to_unlock,
+                                unsigned long irqflags);
+typedef void (*nested_decrease_prio_t)(struct task_struct* t,
+                                struct task_struct* prio_inh, raw_spinlock_t *to_unlock,
+                                unsigned long irqflags, int budget_triggered);
+typedef int (*__higher_prio_t)(struct task_struct* a, comparison_mode_t a_mod,
+                                struct task_struct* b, comparison_mode_t b_mod);
+#endif /* end LITMUS_NESTED_LOCKING */
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+typedef raw_spinlock_t* (*get_dgl_spinlock_t) (struct task_struct *t);
+#endif /* end LITMUS_DGL_SUPPORT */
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+struct affinity_observer;
+typedef long (*allocate_affinity_observer_t) (
+                                struct affinity_observer **aff_obs, int type,
+                                void* __user config);
+#endif /* end LITMUS_AFFINITY_LOCKING */
+#endif /* end LITMUS_LOCKING */
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+typedef int (*default_cpu_for_gpu_t)(int gpu);
 #endif
 
-
 /********************* sys call backends  ********************/
 /* This function causes the caller to sleep until the next release */
 typedef long (*complete_job_t) (void);
@@ -91,8 +136,8 @@ struct sched_plugin {
         get_domain_proc_info_t  get_domain_proc_info;
 
         /*      scheduler invocation    */
-        scheduler_tick_t        tick;
-        schedule_t              schedule;
+        scheduler_tick_t        tick;
+        schedule_t              schedule;
         finish_switch_t         finish_switch;
 
         /*      syscall backend         */
@@ -102,16 +147,42 @@ struct sched_plugin {
         /*      task state changes      */
         admit_task_t            admit_task;
 
-        task_new_t              task_new;
+        task_new_t              task_new;
         task_wake_up_t          task_wake_up;
         task_block_t            task_block;
 
         task_exit_t             task_exit;
         task_cleanup_t          task_cleanup;
 
+        /*  misc */
+        higher_prio_t           compare;
+
 #ifdef CONFIG_LITMUS_LOCKING
         /*      locking protocols       */
         allocate_lock_t         allocate_lock;
+        increase_prio_t         increase_prio;
+        decrease_prio_t         decrease_prio;
+        /*  varients that don't take scheduler locks */
+        __increase_prio_t       __increase_prio;
+        __decrease_prio_t       __decrease_prio;
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        /* nested locking */
+        nested_increase_prio_t  nested_increase_prio;
+        nested_decrease_prio_t  nested_decrease_prio;
+        __higher_prio_t         __compare;
+#endif /* end NESTED_LOCKING */
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        get_dgl_spinlock_t      get_dgl_spinlock;
+#endif /* end LITMUS_DGL_SUPPORT */
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        allocate_affinity_observer_t allocate_aff_obs;
+#endif /* end LITMUS_AFFINITY_LOCKING */
+#endif /* end LITMUS_LOCKING */
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+        default_cpu_for_gpu_t   map_gpu_to_cpu;
 #endif
 } __attribute__ ((__aligned__(SMP_CACHE_BYTES)));
 
@@ -122,7 +193,6 @@ int register_sched_plugin(struct sched_plugin* plugin);
 struct sched_plugin* find_sched_plugin(const char* name);
 void print_sched_plugins(struct seq_file *m);
 
-
 extern struct sched_plugin linux_sched_plugin;
 
 #endif
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index ab5b0c306a9a..c0b0bca23727 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -122,15 +122,88 @@ static long litmus_dummy_get_domain_proc_info(struct domain_proc_info **d)
 }
 
 #ifdef CONFIG_LITMUS_LOCKING
+static int litmus_dummy_compare(struct task_struct* a, struct task_struct* b)
+{
+        TRACE_CUR("WARNING: Dummy compare function called!\n");
+        return 0;
+}
 
 static long litmus_dummy_allocate_lock(struct litmus_lock **lock, int type,
-                                       void* __user config)
+                                void* __user config)
 {
         return -ENXIO;
 }
 
+static void litmus_dummy_increase_prio(struct task_struct* t,
+                                struct task_struct* prio_inh)
+{
+}
+
+static void litmus_dummy_decrease_prio(struct task_struct* t,
+                                struct task_struct* prio_inh, int budget_triggered)
+{
+}
+
+static int litmus_dummy___increase_prio(struct task_struct* t,
+                                struct task_struct* prio_inh)
+{
+        TRACE_CUR("WARNING: Dummy litmus_dummy___increase_prio called!\n");
+        return 0;
+}
+
+static int litmus_dummy___decrease_prio(struct task_struct* t,
+                                struct task_struct* prio_inh, int budget_triggered)
+{
+        TRACE_CUR("WARNING: Dummy litmus_dummy___decrease_prio called!\n");
+        return 0;
+}
 #endif
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+static void litmus_dummy_nested_increase_prio(struct task_struct* t,
+                                struct task_struct* prio_inh,
+                                raw_spinlock_t *to_unlock, unsigned long irqflags)
+{
+}
+
+static void litmus_dummy_nested_decrease_prio(struct task_struct* t,
+                                struct task_struct* prio_inh,
+                                raw_spinlock_t *to_unlock, unsigned long irqflags,
+                                int budget_triggered)
+{
+}
+
+static int litmus_dummy___compare(
+                                struct task_struct* a, comparison_mode_t a_mod,
+                                struct task_struct* b, comparison_mode_t b_mode)
+{
+        TRACE_CUR("WARNING: Dummy compare function called!\n");
+        return 0;
+}
+#endif
+
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+static raw_spinlock_t* litmus_dummy_get_dgl_spinlock(struct task_struct *t)
+{
+        return NULL;
+}
+#endif
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+static long litmus_dummy_allocate_aff_obs(struct affinity_observer **aff_obs,
+                                int type,
+                                void* __user config)
+{
+        return -ENXIO;
+}
+#endif
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+static int litmus_dummy_map_gpu_to_cpu(int gpu)
+{
+        return 0;
+}
+#endif
 
 /* The default scheduler plugin. It doesn't do anything and lets Linux do its
  * job.
@@ -149,7 +222,26 @@ struct sched_plugin linux_sched_plugin = {
         .deactivate_plugin = litmus_dummy_deactivate_plugin,
         .get_domain_proc_info = litmus_dummy_get_domain_proc_info,
 #ifdef CONFIG_LITMUS_LOCKING
+        .compare = litmus_dummy_compare,
         .allocate_lock = litmus_dummy_allocate_lock,
+        .increase_prio = litmus_dummy_increase_prio,
+        .decrease_prio = litmus_dummy_decrease_prio,
+        .__increase_prio = litmus_dummy___increase_prio,
+        .__decrease_prio = litmus_dummy___decrease_prio,
+#endif
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        .nested_increase_prio = litmus_dummy_nested_increase_prio,
+        .nested_decrease_prio = litmus_dummy_nested_decrease_prio,
+        .__compare = litmus_dummy___compare,
+#endif
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        .get_dgl_spinlock = litmus_dummy_get_dgl_spinlock,
+#endif
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        .allocate_aff_obs = litmus_dummy_allocate_aff_obs,
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+        .map_gpu_to_cpu = litmus_dummy_map_gpu_to_cpu,
 #endif
         .admit_task = litmus_dummy_admit_task
 };
@@ -189,7 +281,26 @@ int register_sched_plugin(struct sched_plugin* plugin)
         CHECK(deactivate_plugin);
         CHECK(get_domain_proc_info);
 #ifdef CONFIG_LITMUS_LOCKING
+        CHECK(compare);
         CHECK(allocate_lock);
+        CHECK(increase_prio);
+        CHECK(decrease_prio);
+        CHECK(__increase_prio);
+        CHECK(__decrease_prio);
+#endif
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        CHECK(nested_increase_prio);
+        CHECK(nested_decrease_prio);
+        CHECK(__compare);
+#endif
+#ifdef CONFIG_LITMUS_DGL_SUPPORT
+        CHECK(get_dgl_spinlock);
+#endif
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        CHECK(allocate_aff_obs);
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
+        CHECK(map_gpu_to_cpu);
 #endif
         CHECK(admit_task);