Infrastructure for affinity-aware k-exclusion

10 files changed, 183 insertions, 4 deletions

diff --git a/include/litmus/fdso.h b/include/litmus/fdso.h
index 2bff9cc3909d..baf28c47e95d 100644
--- a/include/litmus/fdso.h
+++ b/include/litmus/fdso.h
@@ -24,7 +24,10 @@ typedef enum  {
         IKGLP_SEM       = 3,
         KFMLP_SEM       = 4,
 
-        MAX_OBJ_TYPE    = 4
+        IKGLP_AFF_OBS = 5,
+        KFMLP_AFF_OBS = 6,
+        
+        MAX_OBJ_TYPE    = 6
 } obj_type_t;
 
 struct inode_obj_id {
diff --git a/include/litmus/kexclu_affinity.h b/include/litmus/kexclu_affinity.h
new file mode 100644
index 000000000000..f5b5e7b1f359
--- /dev/null
+++ b/include/litmus/kexclu_affinity.h
@@ -0,0 +1,31 @@
+#ifndef LITMUS_AFF_OBS_H
+#define LITMUS_AFF_OBS_H
+
+#include <litmus/locking.h>
+
+struct affinity_observer_ops;
+
+struct affinity_observer
+{
+        struct affinity_observer_ops* ops;
+        int type;
+        int ident;
+        
+        struct litmus_lock* lock;  // the lock under observation
+};
+
+typedef int (*aff_obs_open_t)(struct affinity_observer* aff_obs,
+                                                          void* __user arg);
+typedef int (*aff_obs_close_t)(struct affinity_observer* aff_obs);
+typedef void (*aff_obs_free_t)(struct affinity_observer* aff_obs);
+
+struct affinity_observer_ops
+{
+        aff_obs_open_t open;
+        aff_obs_close_t close;
+        aff_obs_free_t deallocate;
+};
+
+struct litmus_lock* get_lock_from_od(int od);
+
+#endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index b4eb8ee95687..cc638e9c55d1 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -52,6 +52,11 @@ union np_flag {
         } np;
 };
 
+struct affinity_observer_args
+{
+        int lock_od;
+};
+
 /* The definition of the data that is shared between the kernel and real-time
  * tasks via a shared page (see litmus/ctrldev.c).
  *
diff --git a/include/litmus/sched_plugin.h b/include/litmus/sched_plugin.h
index 8e65555d9b7f..d14f705ef414 100644
--- a/include/litmus/sched_plugin.h
+++ b/include/litmus/sched_plugin.h
@@ -11,6 +11,10 @@
 #include <litmus/locking.h>
 #endif
 
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+#include <litmus/kexclu_affinity.h>
+#endif
+
 #include <linux/interrupt.h>
 
 /************************ setup/tear down ********************/
@@ -59,6 +63,10 @@ typedef void (*task_exit_t)    (struct task_struct *);
 typedef long (*allocate_lock_t) (struct litmus_lock **lock, int type,
                                  void* __user config);
 
+typedef long (*allocate_affinity_observer_t) (
+                                                                struct affinity_observer **aff_obs, int type,
+                                                                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);
 typedef void (*nested_increase_prio_t)(struct task_struct* t, struct task_struct* prio_inh,
@@ -146,7 +154,11 @@ struct sched_plugin {
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         get_dgl_spinlock_t      get_dgl_spinlock;
 #endif
-    
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        allocate_affinity_observer_t allocate_aff_obs;
+#endif
+        
 #ifdef CONFIG_LITMUS_SOFTIRQD
     increase_prio_klitirq_t             increase_prio_klitirqd;
     decrease_prio_klitirqd_t    decrease_prio_klitirqd;
diff --git a/litmus/Kconfig b/litmus/Kconfig
index 6cf4d7eaa96f..263c3ee49c15 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -60,6 +60,16 @@ config LITMUS_LOCKING
           Say Yes if you want to include locking protocols such as the FMLP and
           Baker's SRP.
 
+config LITMUS_AFFINITY_LOCKING
+        bool "Enable affinity infrastructure in k-exclusion locking protocols."
+        depends on LITMUS_LOCKING
+        default n
+        help
+          Enable affinity tracking infrastructure in k-exclusion locking protocols.
+          This only enabled the *infrastructure* not actual affinity algorithms.
+
+          If unsure, say No.
+
 config LITMUS_NESTED_LOCKING
                 bool "Support for nested inheritance in locking protocols"
         depends on LITMUS_LOCKING
@@ -291,7 +301,19 @@ config LITMUS_NVIDIA
           depends on LITMUS_SOFTIRQD || LITMUS_PAI_SOFTIRQD
           default n
           help
-            Direct tasklets from NVIDIA devices to Litmus's klitirqd.
+            Direct tasklets from NVIDIA devices to Litmus's klitirqd
+                or PAI interrupt handling routines.
+
+                If unsure, say No.
+
+config LITMUS_AFFINITY_AWARE_GPU_ASSINGMENT
+          bool "Enable affinity-aware heuristics to improve GPU assignment."
+          depends on LITMUS_NVIDIA && LITMUS_AFFINITY_LOCKING
+          default n
+          help
+            Enable several heuristics to improve the assignment
+                of GPUs to real-time tasks to reduce the overheads
+                of memory migrations.
 
                 If unsure, say No.
 
diff --git a/litmus/Makefile b/litmus/Makefile
index 91fd32cb979d..1698afb75ec4 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -34,3 +34,5 @@ obj-$(CONFIG_LITMUS_NESTED_LOCKING) += rsm_lock.o ikglp_lock.o
 obj-$(CONFIG_LITMUS_SOFTIRQD) += litmus_softirq.o
 obj-$(CONFIG_LITMUS_PAI_SOFTIRQD) += litmus_pai_softirq.o
 obj-$(CONFIG_LITMUS_NVIDIA) += nvidia_info.o sched_trace_external.o
+
+obj-$(CONFIG_LITMUS_AFFINITY_LOCKING) += kexclu_affinity.o
diff --git a/litmus/fdso.c b/litmus/fdso.c
index 5ef858e59ab0..0bacea179660 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -20,12 +20,16 @@
 
 extern struct fdso_ops generic_lock_ops;
 
+extern struct fdso_ops generic_affinity_ops;
+
 static const struct fdso_ops* fdso_ops[] = {
         &generic_lock_ops, /* FMLP_SEM */
-        &generic_lock_ops, /* KFMLP_SEM */
         &generic_lock_ops, /* SRP_SEM */
         &generic_lock_ops, /* RSM_MUTEX */
         &generic_lock_ops, /* IKGLP_SEM */
+        &generic_lock_ops, /* KFMLP_SEM */
+        &generic_affinity_ops, /* IKGLP_AFF_OBS */
+        &generic_affinity_ops, /* KFMLP_AFF_OBS */
 };
 
 static int fdso_create(void** obj_ref, obj_type_t type, void* __user config)
diff --git a/litmus/kexclu_affinity.c b/litmus/kexclu_affinity.c
new file mode 100644
index 000000000000..a06df3e1acbd
--- /dev/null
+++ b/litmus/kexclu_affinity.c
@@ -0,0 +1,84 @@
+#include <litmus/fdso.h>
+#include <litmus/sched_plugin.h>
+#include <litmus/trace.h>
+#include <litmus/litmus.h>
+#include <litmus/locking.h>
+
+#include <litmus/kexclu_affinity.h>
+
+static int create_generic_aff_obs(void** obj_ref, obj_type_t type, void* __user arg);
+static int open_generic_aff_obs(struct od_table_entry* entry, void* __user arg);
+static int close_generic_aff_obs(struct od_table_entry* entry);
+static void destroy_generic_aff_obs(obj_type_t type, void* sem);
+
+struct fdso_ops generic_affinity_ops = {
+        .create  = create_generic_aff_obs,
+        .open    = open_generic_aff_obs,
+        .close   = close_generic_aff_obs,
+        .destroy = destroy_generic_aff_obs
+};
+
+static atomic_t aff_obs_id_gen = ATOMIC_INIT(0);
+
+static inline bool is_affinity_observer(struct od_table_entry *entry)
+{
+        return (entry->class == &generic_affinity_ops);
+}
+
+static inline struct affinity_observer* get_affinity_observer(struct od_table_entry* entry)
+{
+        BUG_ON(!is_affinity_observer(entry));
+        return (struct affinity_observer*) entry->obj->obj;
+}
+
+static int create_generic_aff_obs(void** obj_ref, obj_type_t type, void* __user arg)
+{
+        struct affinity_observer* aff_obs;
+        int err;
+        
+        err = litmus->allocate_aff_obs(&aff_obs, type, arg);
+        if (err == 0) {
+                BUG_ON(!aff_obs->lock);
+                aff_obs->ident = atomic_inc_return(&aff_obs_id_gen);
+                *obj_ref = aff_obs;
+    }
+        return err;
+}
+
+static int open_generic_aff_obs(struct od_table_entry* entry, void* __user arg)
+{
+        struct affinity_observer* aff_obs = get_affinity_observer(entry);
+        if (aff_obs->ops->open)
+                return aff_obs->ops->open(aff_obs, arg);
+        else
+                return 0; /* default: any task can open it */
+}
+
+static int close_generic_aff_obs(struct od_table_entry* entry)
+{
+        struct affinity_observer* aff_obs = get_affinity_observer(entry);
+        if (aff_obs->ops->close)
+                return aff_obs->ops->close(aff_obs);
+        else
+                return 0; /* default: closing succeeds */
+}
+
+static void destroy_generic_aff_obs(obj_type_t type, void* obj)
+{
+        struct affinity_observer* aff_obs = (struct affinity_observer*) obj;
+        aff_obs->ops->deallocate(aff_obs);
+}
+
+
+struct litmus_lock* get_lock_from_od(int od)
+{
+        extern struct fdso_ops generic_lock_ops;
+        
+        struct od_table_entry *entry = get_entry_for_od(od);
+        
+        if(entry && entry->class == &generic_lock_ops) {
+                return (struct litmus_lock*) entry->obj->obj;
+        }
+        return NULL;
+}
+
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 37294111bb0c..1440372227c6 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -1042,6 +1042,7 @@ static void __increase_priority_inheritance(struct task_struct* t,
 
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         /* this sanity check allows for weaker locking in protocols */
+        /* TODO (klitirqd): Skip this check if 't' is a proxy thread (???) */
         if(__edf_higher_prio(prio_inh, BASE, t, EFFECTIVE)) {
 #endif
                 TRACE_TASK(t, "inherits priority from %s/%d\n",
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 24326ce4657e..de15e80743a8 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -188,6 +188,14 @@ static raw_spinlock_t* litmus_dummy_get_dgl_spinlock(struct task_struct *t)
 }
 #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
 
 
 /* The default scheduler plugin. It doesn't do anything and lets Linux do its
@@ -228,6 +236,10 @@ struct sched_plugin linux_sched_plugin = {
 #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  
+        
         .admit_task = litmus_dummy_admit_task
 };
 
@@ -286,6 +298,9 @@ int register_sched_plugin(struct sched_plugin* plugin)
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         CHECK(get_dgl_spinlock);
 #endif
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        CHECK(allocate_aff_obs);
+#endif          
         CHECK(admit_task);
 
         if (!plugin->release_at)