Fixed and tested aff-aware KFMLP. (finally!)

16 files changed, 334 insertions, 181 deletions

diff --git a/include/litmus/fpmath.h b/include/litmus/fpmath.h
index 35f81683d6ab..d062b5ab5dc2 100644
--- a/include/litmus/fpmath.h
+++ b/include/litmus/fpmath.h
@@ -1,6 +1,11 @@
 #ifndef __FP_MATH_H__
 #define __FP_MATH_H__
 
+#ifndef __KERNEL__
+#include <stdint.h>
+#define abs(x) (((x) < 0) ? -(x) : x)
+#endif
+
 // Use 64-bit because we want to track things at the nanosecond scale.
 // This can lead to very large numbers.
 typedef int64_t fpbuf_t;
@@ -11,7 +16,6 @@ typedef struct
 
 #define FP_SHIFT 10
 #define ROUND_BIT (FP_SHIFT - 1)
-#define ONE FP(1)
 
 #define _fp(x) ((fp_t) {x})
 
@@ -29,8 +33,6 @@ static inline fp_t _frac(fpbuf_t a, fpbuf_t b)
         return _fp(FP(a).val / (b));
 }
 
-#ifdef __KERNEL__
-
 static inline fpbuf_t _point(fp_t x) 
 {       
         return (x.val % (1 << FP_SHIFT));
@@ -60,11 +62,19 @@ static inline fp_t _mul(fp_t a, fp_t b)
 
 static inline fp_t _div(fp_t a, fp_t b)
 {
-        /* try not to overflow */
-        if (unlikely(  a.val > (2l << (BITS_PER_LONG - FP_SHIFT)) ))
+#if !defined(__KERNEL__) && !defined(unlikely)
+#define unlikely(x) (x)
+#define DO_UNDEF_UNLIKELY
+#endif
+        /* try not to overflow */       
+        if (unlikely(  a.val > (2l << ((sizeof(fpbuf_t)*8) - FP_SHIFT)) ))
                 return _fp((a.val / b.val) << FP_SHIFT);
         else
                 return _fp((a.val << FP_SHIFT) / b.val);
+#ifdef DO_UNDEF_UNLIKELY
+#undef unlikely
+#undef DO_UNDEF_UNLIKELY
+#endif
 }
 
 static inline fp_t _add(fp_t a, fp_t b)
@@ -131,4 +141,3 @@ static inline fp_t _max(fp_t a, fp_t b)
                 return a;
 }
 #endif
-#endif
diff --git a/include/litmus/gpu_affinity.h b/include/litmus/gpu_affinity.h
index c29ff3de997c..ca4d10b93203 100644
--- a/include/litmus/gpu_affinity.h
+++ b/include/litmus/gpu_affinity.h
@@ -31,9 +31,21 @@ static inline lt_t get_gpu_time(struct task_struct* t)
 
 static inline lt_t get_gpu_estimate(struct task_struct* t, gpu_migration_dist_t dist)
 {
-        lt_t val = _fp_to_integer(t->rt_param.gpu_migration_est[dist].est);
+        int i;
+        fpbuf_t temp = _fp_to_integer(t->rt_param.gpu_migration_est[dist].est);
+        lt_t val = (temp >= 0) ? temp : 0;  // never allow negative estimates...
         
-        // minimum value is 1.
+        WARN_ON(temp < 0);
+        
+        // lower-bound a distant migration to be at least equal to the level
+        // below it.
+        for(i = dist-1; (val == 0) && (i >= MIG_LOCAL); --i) {
+                val = _fp_to_integer(t->rt_param.gpu_migration_est[i].est);
+        }
+        
+        // minimum value is 1 (val is 0 if we haven't run with local affinity yet)
+        // TODO: pick a better default min-value.  1 is too small.  perhaps
+        // task execution time?
         return ((val > 0) ? val : 1);
 }
 
diff --git a/include/litmus/kexclu_affinity.h b/include/litmus/kexclu_affinity.h
index f5b5e7b1f359..51e097f8ec54 100644
--- a/include/litmus/kexclu_affinity.h
+++ b/include/litmus/kexclu_affinity.h
@@ -28,4 +28,8 @@ struct affinity_observer_ops
 
 struct litmus_lock* get_lock_from_od(int od);
 
+void affinity_observer_new(struct affinity_observer* aff,
+                                                   struct affinity_observer_ops* ops,
+                                                   struct affinity_observer_args* args);
+
 #endif
diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index e2df49b171c5..71df378236f5 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -125,9 +125,6 @@ static inline lt_t litmus_clock(void)
 #define earlier_release(a, b)  (lt_before(\
         (a)->rt_param.job_params.release,\
         (b)->rt_param.job_params.release))
-#define shorter_period(a, b)   (lt_before(\
-    (a)->rt_param.task_params.period,\
-    (b)->rt_param.task_params.period))
 void preempt_if_preemptable(struct task_struct* t, int on_cpu);
 
 #ifdef CONFIG_LITMUS_LOCKING
diff --git a/include/litmus/nvidia_info.h b/include/litmus/nvidia_info.h
index dd41c4c72b85..856c575374d3 100644
--- a/include/litmus/nvidia_info.h
+++ b/include/litmus/nvidia_info.h
@@ -26,7 +26,7 @@ int init_nv_device_reg(void);
 //int get_nv_device_id(struct task_struct* owner);
 
 
-int reg_nv_device(int reg_device_id, int register_device);
+int reg_nv_device(int reg_device_id, int register_device, struct task_struct *t);
 
 struct task_struct* get_nv_max_device_owner(u32 target_device_id);
 //int is_nv_device_owner(u32 target_device_id);
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index ad46ab4c64cc..11f081527545 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -126,12 +126,14 @@ enum klitirqd_sem_status
 
 typedef enum gpu_migration_dist
 {       
+        // TODO: Make this variable against NR_NVIDIA_GPUS
         MIG_LOCAL = 0,
         MIG_NEAR = 1,
         MIG_MED = 2,
-        MIG_FAR = 3,
+        MIG_FAR = 3,    // 8 GPUs in a binary tree hierarchy
+        MIG_NONE = 4,
         
-        MIG_LAST = MIG_FAR
+        MIG_LAST = MIG_NONE
 } gpu_migration_dist_t;
 
 typedef struct feedback_est{
@@ -190,7 +192,7 @@ struct rt_param {
         
         gpu_migration_dist_t    gpu_migration;
         int                             last_gpu;
-        feedback_est_t  gpu_migration_est[MIG_LAST]; // local, near, med, far
+        feedback_est_t  gpu_migration_est[MIG_LAST+1]; // local, near, med, far
         
         lt_t accum_gpu_time;
         lt_t gpu_time_stamp;
diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index 989757cdcc5c..250808e934a6 100644
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -45,8 +45,9 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 
         /* check for NULL tasks */
-        if (!first || !second)
+        if (!first || !second) {
                 return first && !second;
+        }
 
 #ifdef CONFIG_LITMUS_LOCKING
         /* Check for EFFECTIVE priorities. Change task
@@ -73,59 +74,68 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
                 /* first_task is boosted, how about second_task? */
                 if (!is_priority_boosted(second_task) ||
                     lt_before(get_boost_start(first_task),
-                              get_boost_start(second_task)))
+                                          get_boost_start(second_task))) {
                         return 1;
-                else
+                }
+                else {
                         return 0;
-        } else if (unlikely(is_priority_boosted(second_task)))
+                }
+        }
+        else if (unlikely(is_priority_boosted(second_task))) {
                 /* second_task is boosted, first is not*/
                 return 0;
+        }
 
 #endif
 
 //      // rate-monotonic for testing
-//      return !is_realtime(second_task)  ||
-//
-//      /* is the deadline of the first task earlier?
-//       * Then it has higher priority.
-//       */
-//      shorter_period(first_task, second_task) ||
-//
-//      /* Do we have a deadline tie?
-//       * Then break by PID.
-//       */
-//      (get_period(first_task) == get_period(second_task) &&
-//       (first_task->pid < second_task->pid ||
-//
-//        /* If the PIDs are the same then the task with the EFFECTIVE
-//         * priority wins.
-//         */
-//        (first_task->pid == second_task->pid &&
-//         !second->rt_param.inh_task)));
-
-        if (!is_realtime(second_task))
+//      if (!is_realtime(second_task)) {
+//              return true;
+//      }
+//      
+//      if (shorter_period(first_task, second_task)) {
+//              return true;
+//      }
+//      
+//      if (get_period(first_task) == get_period(second_task)) {
+//              if (first_task->pid < second_task->pid) {   
+//                      return true;
+//              }
+//              else if (first_task->pid == second_task->pid) {
+//                      return !second->rt_param.inh_task;
+//              }
+//      }
+
+        if (!is_realtime(second_task)) {
                 return true;
+        }
 
-        if (earlier_deadline(first_task, second_task))
+        if (earlier_deadline(first_task, second_task)) {
                 return true;
-
+        }
         if (get_deadline(first_task) == get_deadline(second_task)) {
+                
                 if (shorter_period(first_task, second_task)) {
                         return true;
                 }
                 if (get_rt_period(first_task) == get_rt_period(second_task)) {
-#ifdef CONFIG_LITMUS_SOFTIRQD
-                        if (first_task->rt_param.is_proxy_thread <
-                                                        second_task->rt_param.is_proxy_thread) {
-                                return true;
-                        }
-#endif      
                         if (first_task->pid < second_task->pid) {   
                                 return true;
                         }
                         if (first_task->pid == second_task->pid) {
+#ifdef CONFIG_LITMUS_SOFTIRQD
+                                if (first_task->rt_param.is_proxy_thread <
+                                        second_task->rt_param.is_proxy_thread) {
+                                        return true;
+                                }
+                                if(first_task->rt_param.is_proxy_thread == second_task->rt_param.is_proxy_thread) {
+                                        return !second->rt_param.inh_task;
+                                }
+#else 
                                 return !second->rt_param.inh_task;
-                        }
+#endif
+                        }                       
+    
                 }
         }
         
diff --git a/litmus/fdso.c b/litmus/fdso.c
index 0bacea179660..5a4f45c3251b 100644
--- a/litmus/fdso.c
+++ b/litmus/fdso.c
@@ -28,8 +28,9 @@ static const struct fdso_ops* fdso_ops[] = {
         &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 */
+        &generic_affinity_ops, /* IKGLP_GPU_AFF_OBS */
+        &generic_affinity_ops, /* KFMLP_SIMPLE_GPU_AFF_OBS */
+        &generic_affinity_ops, /* KFMLP_GPU_AFF_OBS */
 };
 
 static int fdso_create(void** obj_ref, obj_type_t type, void* __user config)
diff --git a/litmus/gpu_affinity.c b/litmus/gpu_affinity.c
index 43171390bed7..87349fe10a9b 100644
--- a/litmus/gpu_affinity.c
+++ b/litmus/gpu_affinity.c
@@ -5,15 +5,16 @@
 #include <litmus/litmus.h>
 #include <litmus/gpu_affinity.h>
 
-static void update_estimate(feedback_est_t* fb, fp_t* a, fp_t* b, lt_t observed)
+#define OBSERVATION_CAP 2*1e9
+
+static void update_estimate(feedback_est_t* fb, fp_t a, fp_t b, lt_t observed)
 {
         fp_t err, new;
-        fp_t actual = _frac(observed, 1); // observed is in ns, so beware of overflow!
+        fp_t actual = _integer_to_fp(observed);
         
         err = _sub(actual, fb->est);
-        new = _add(_mul(*a, err),
-                           _mul(*b, fb->accum_err));
-        
+        new = _add(_mul(a, err), _mul(b, fb->accum_err));
+
         fb->est = new;
         fb->accum_err = _add(fb->accum_err, err);
 }
@@ -22,47 +23,69 @@ void update_gpu_estimate(struct task_struct *t, lt_t observed)
 {
         feedback_est_t *fb = &(tsk_rt(t)->gpu_migration_est[tsk_rt(t)->gpu_migration]);
         
-        TRACE_TASK(t, "GPU est update before (dist = %d): %d.%d\n", 
-                           tsk_rt(t)->gpu_migration,
-                           _fp_to_integer(fb->est),
-                           _point(fb->est));
-        
-        update_estimate(fb,
-                                        &tsk_rt(t)->gpu_fb_param_a,
-                                        &tsk_rt(t)->gpu_fb_param_b,
-                                        observed);
+        WARN_ON(tsk_rt(t)->gpu_migration > MIG_LAST);
         
-        TRACE_TASK(t, "GPU est update after (dist = %d): %d.%d\n", 
+        if(unlikely(fb->est.val == 0)) {
+                // kludge-- cap observed values to prevent whacky estimations.
+                // whacky stuff happens during the first few jobs.
+                if(unlikely(observed > OBSERVATION_CAP)) {
+                        TRACE_TASK(t, "Crazy observation was capped: %llu -> %llu\n",
+                                           observed, OBSERVATION_CAP);
+                        observed = OBSERVATION_CAP;
+                }               
+                
+                // take the first observation as our estimate
+                // (initial value of 0 was bogus anyhow)
+                fb->est = _integer_to_fp(observed);
+                fb->accum_err = _div(fb->est, _integer_to_fp(2));  // ...seems to work.
+        }
+        else {
+                update_estimate(fb,
+                                                tsk_rt(t)->gpu_fb_param_a,
+                                                tsk_rt(t)->gpu_fb_param_b,
+                                                observed);
+                
+                if(_fp_to_integer(fb->est) <= 0) {
+                        // TODO: talk to Jonathan about how well this works.
+                        // Maybe we should average the observed and est instead?
+                        TRACE_TASK(t, "Invalid estimate. Patching.\n");
+                        fb->est = _integer_to_fp(observed);
+                        fb->accum_err = _div(fb->est, _integer_to_fp(2));  // ...seems to work.         
+                }               
+        }
+
+        TRACE_TASK(t, "GPU est update after (dist = %d, obs = %llu): %d.%d\n", 
                            tsk_rt(t)->gpu_migration,
+                           observed,
                            _fp_to_integer(fb->est),
                            _point(fb->est));    
 }
 
 gpu_migration_dist_t gpu_migration_distance(int a, int b)
 {
-        // GPUs organized in a binary hierarchy, no more than 2^MIG_LAST GPUs
+        // GPUs organized in a binary hierarchy, no more than 2^MIG_FAR GPUs
         int i;
-        int level;
-        int max_level;
+        int dist;
         
-        if(unlikely(a < 0 || b < 0)) {
-                return MIG_LAST;
+        if(likely(a >= 0 && b >= 0)) {
+                for(i = 0; i <= MIG_FAR; ++i) {
+                        if(a>>i == b>>i) {
+                                dist = i;
+                                goto out;
+                        }
+                }
+                dist = MIG_NONE; // hopefully never reached.
+                TRACE_CUR("WARNING: GPU distance too far! %d -> %d\n", a, b);
         }
-        
-        if(a == b) {
-                return MIG_LOCAL;
+        else {
+                dist = MIG_NONE;
         }
         
-        for(i = 1, level = 2, max_level = 1<<MIG_LAST;
-                level <= max_level;
-                ++i, level <<= 1) {
-                if(a/level == b/level) {
-                        return (gpu_migration_dist_t)(i);
-                }
-        }
+out:
+        TRACE_CUR("Distance %d -> %d is %d\n",
+                          a, b, dist);
         
-        WARN_ON(1);
-        return MIG_LAST;
+        return dist;
 }
 
 
diff --git a/litmus/kexclu_affinity.c b/litmus/kexclu_affinity.c
index a06df3e1acbd..552179bf797d 100644
--- a/litmus/kexclu_affinity.c
+++ b/litmus/kexclu_affinity.c
@@ -39,7 +39,7 @@ static int create_generic_aff_obs(void** obj_ref, obj_type_t type, void* __user
         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);
+                aff_obs->type = type;
                 *obj_ref = aff_obs;
     }
         return err;
@@ -82,3 +82,11 @@ struct litmus_lock* get_lock_from_od(int od)
         return NULL;
 }
 
+void affinity_observer_new(struct affinity_observer* aff,
+                                                   struct affinity_observer_ops* ops,
+                                                   struct affinity_observer_args* args)
+{
+        aff->ops = ops;
+        aff->lock = get_lock_from_od(args->lock_od);
+        aff->ident = atomic_inc_return(&aff_obs_id_gen);
+}
\ No newline at end of file
diff --git a/litmus/kfmlp_lock.c b/litmus/kfmlp_lock.c
index b30e5b589882..7cdca1b7b50a 100644
--- a/litmus/kfmlp_lock.c
+++ b/litmus/kfmlp_lock.c
@@ -99,12 +99,19 @@ static struct task_struct* kfmlp_select_hp_steal(struct kfmlp_semaphore* sem, wa
         if(*to_steal_from)
         {
                 struct list_head *pos;
+                struct task_struct *target = (*to_steal_from)->hp_waiter;
+                
+                TRACE_CUR("want to steal hp_waiter (%s/%d) from queue %d\n",
+                                  target->comm,
+                                  target->pid,
+                                  kfmlp_get_idx(sem, *to_steal_from));
+                
                 list_for_each(pos, &(*to_steal_from)->wait.task_list)
                 {
                         wait_queue_t *node = list_entry(pos, wait_queue_t, task_list);
                         struct task_struct *queued = (struct task_struct*) node->private;
                         /* Compare task prios, find high prio task. */
-                        if (queued == (*to_steal_from)->hp_waiter)
+                        if (queued == target)
                         {
                                 *to_steal = node;
                                 
@@ -115,6 +122,11 @@ static struct task_struct* kfmlp_select_hp_steal(struct kfmlp_semaphore* sem, wa
                                 return queued;
                         }
                 }
+                
+                TRACE_CUR("Could not find %s/%d in queue %d!!!  THIS IS A BUG!\n",
+                                  target->comm,
+                                  target->pid,
+                                  kfmlp_get_idx(sem, *to_steal_from));                            
         }
         
         return NULL;
@@ -133,6 +145,11 @@ static void kfmlp_steal_node(struct kfmlp_semaphore *sem,
         if(t == src->hp_waiter) {
                 src->hp_waiter = kfmlp_find_hp_waiter(src, NULL);
                 
+                TRACE_CUR("queue %d: %s/%d is new hp_waiter\n",
+                                  kfmlp_get_idx(sem, src),
+                                  (src->hp_waiter) ? src->hp_waiter->comm : "nil",
+                                  (src->hp_waiter) ? src->hp_waiter->pid : -1);
+
                 if(src->owner && tsk_rt(src->owner)->inh_task == t) {
                         litmus->decrease_prio(src->owner, src->hp_waiter);
                 }
@@ -140,6 +157,7 @@ static void kfmlp_steal_node(struct kfmlp_semaphore *sem,
         
         if(sem->shortest_queue->count > src->count) {
                 sem->shortest_queue = src;
+                TRACE_CUR("queue %d is the shortest\n", kfmlp_get_idx(sem, sem->shortest_queue));
         }
         
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
@@ -155,6 +173,10 @@ static void kfmlp_steal_node(struct kfmlp_semaphore *sem,
         if(litmus->compare(t, dst->hp_waiter)) {
                 dst->hp_waiter = t;
                 
+                TRACE_CUR("queue %d: %s/%d is new hp_waiter\n",
+                                  kfmlp_get_idx(sem, dst),
+                                  t->comm, t->pid);             
+                
                 if(dst->owner && litmus->compare(t, dst->owner))
                 {
                         litmus->increase_prio(dst->owner, t);
@@ -264,8 +286,9 @@ int kfmlp_lock(struct litmus_lock* l)
         
         if (my_queue->owner) {
                 /* resource is not free => must suspend and wait */
-                TRACE_CUR("queue %d: Resource is not free => must suspend and wait.\n",
-                                  kfmlp_get_idx(sem, my_queue));
+                TRACE_CUR("queue %d: Resource is not free => must suspend and wait. (queue size = %d)\n",
+                                  kfmlp_get_idx(sem, my_queue),
+                                  my_queue->count);
                 
                 init_waitqueue_entry(&wait, t);
                 
@@ -274,29 +297,37 @@ int kfmlp_lock(struct litmus_lock* l)
                 
                 __add_wait_queue_tail_exclusive(&my_queue->wait, &wait);
                 
+                TRACE_CUR("queue %d: hp_waiter is currently %s/%d\n",
+                                  kfmlp_get_idx(sem, my_queue),
+                                  (my_queue->hp_waiter) ? my_queue->hp_waiter->comm : "nil",
+                                  (my_queue->hp_waiter) ? my_queue->hp_waiter->pid : -1);
+                
                 /* check if we need to activate priority inheritance */
                 //if (edf_higher_prio(t, my_queue->hp_waiter))
-                if (litmus->compare(t, my_queue->hp_waiter))
-                {
+                if (litmus->compare(t, my_queue->hp_waiter)) {
                         my_queue->hp_waiter = t;
+                        TRACE_CUR("queue %d: %s/%d is new hp_waiter\n",
+                                          kfmlp_get_idx(sem, my_queue),
+                                          t->comm, t->pid);
+                        
                         //if (edf_higher_prio(t, my_queue->owner))
-                        if (litmus->compare(t, my_queue->owner))
-                        {
+                        if (litmus->compare(t, my_queue->owner)) {
                                 litmus->increase_prio(my_queue->owner, my_queue->hp_waiter);
                         }
                 }
                 
                 ++(my_queue->count);
                 
-#ifdef CONFIG_LITMUS_AFFINITY_LOCKING           
                 if(my_queue == sem->shortest_queue) {
                         sem->shortest_queue = kfmlp_find_shortest(sem, my_queue);
+                        TRACE_CUR("queue %d is the shortest\n",
+                                          kfmlp_get_idx(sem, sem->shortest_queue));
                 }
+                
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING           
                 if(sem->aff_obs) {
                         sem->aff_obs->ops->notify_enqueue(sem->aff_obs, my_queue, t);
                 }
-#else
-                sem->shortest_queue = kfmlp_find_shortest(sem, my_queue);
 #endif
                 
                 /* release lock before sleeping */
@@ -309,13 +340,11 @@ int kfmlp_lock(struct litmus_lock* l)
                 schedule();
                 
                 
-                if(my_queue->owner == t)
-                {
+                if(my_queue->owner == t) {
                         TRACE_CUR("queue %d: acquired through waiting\n",
                                           kfmlp_get_idx(sem, my_queue));
                 }
-                else
-                {
+                else {
                         /* this case may happen if our wait entry was stolen
                          between queues. record where we went. */
                         my_queue = kfmlp_get_queue(sem, t);
@@ -325,8 +354,7 @@ int kfmlp_lock(struct litmus_lock* l)
                                           kfmlp_get_idx(sem, my_queue));
                 }
         }
-        else
-        {
+        else {
                 TRACE_CUR("queue %d: acquired immediately\n",
                                   kfmlp_get_idx(sem, my_queue));
                 
@@ -334,16 +362,17 @@ int kfmlp_lock(struct litmus_lock* l)
                 
                 ++(my_queue->count);
                 
-#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
                 if(my_queue == sem->shortest_queue) {
                         sem->shortest_queue = kfmlp_find_shortest(sem, my_queue);
+                        TRACE_CUR("queue %d is the shortest\n",
+                                          kfmlp_get_idx(sem, sem->shortest_queue));
                 }
+                
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
                 if(sem->aff_obs) {
                         sem->aff_obs->ops->notify_enqueue(sem->aff_obs, my_queue, t);
                         sem->aff_obs->ops->notify_acquired(sem->aff_obs, my_queue, t);
                 }
-#else
-                sem->shortest_queue = kfmlp_find_shortest(sem, my_queue);
 #endif
                 
                 spin_unlock_irqrestore(&sem->lock, flags);
@@ -370,12 +399,16 @@ int kfmlp_unlock(struct litmus_lock* l)
                 goto out;
         }
         
+        TRACE_CUR("queue %d: unlocking\n", kfmlp_get_idx(sem, my_queue));       
+        
         my_queue->owner = NULL;  // clear ownership
         --(my_queue->count);
         
         if(my_queue->count < sem->shortest_queue->count)
         {
                 sem->shortest_queue = my_queue;
+                TRACE_CUR("queue %d is the shortest\n",
+                                  kfmlp_get_idx(sem, sem->shortest_queue));
         }
         
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
@@ -424,13 +457,13 @@ RETRY:
                 /* wake up next */
                 wake_up_process(next);
         }
-        else
-        {
+        else {
                 // TODO: put this stealing logic before we attempt to release
                 // our resource.  (simplifies code and gets rid of ugly goto RETRY.
                 wait_queue_t *wait;
                 
-                TRACE_CUR("queue %d: looking to steal someone...\n", kfmlp_get_idx(sem, my_queue));
+                TRACE_CUR("queue %d: looking to steal someone...\n",
+                                  kfmlp_get_idx(sem, my_queue));
 
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
                 next = (sem->aff_obs) ?
@@ -441,16 +474,18 @@ RETRY:
 #endif
                 
                 if(next) {
-                        kfmlp_steal_node(sem, my_queue, wait, to_steal_from);
-                        
-                        TRACE_CUR("queued %d: stole %s/%d from queue %d\n",
+                        TRACE_CUR("queue %d: stealing %s/%d from queue %d\n",
+                                          kfmlp_get_idx(sem, my_queue),
                                           next->comm, next->pid,
-                                          kfmlp_get_idx(sem, to_steal_from));
+                                          kfmlp_get_idx(sem, to_steal_from));                   
+                        
+                        kfmlp_steal_node(sem, my_queue, wait, to_steal_from);
                         
                         goto RETRY;  // will succeed this time.
                 }
                 else {          
-                        TRACE_CUR("queue %d: no one to steal.\n", kfmlp_get_idx(sem, my_queue));
+                        TRACE_CUR("queue %d: no one to steal.\n",
+                                          kfmlp_get_idx(sem, my_queue));
                 }
         }
         
@@ -597,7 +632,8 @@ static struct affinity_observer* kfmlp_aff_obs_new(struct affinity_observer_ops*
                 return(NULL);
         }
         
-        kfmlp_aff->obs.ops = ops;
+        affinity_observer_new(&kfmlp_aff->obs, ops, &aff_args.obs);
+        
         kfmlp_aff->ops = kfmlp_ops;
         kfmlp_aff->offset = aff_args.replica_to_gpu_offset;
         
@@ -645,34 +681,50 @@ struct kfmlp_queue* gpu_kfmlp_advise_enqueue(struct kfmlp_affinity* aff, struct
         
         // simply pick the shortest queue if, we have no affinity, or we have
         // affinity with the shortest
-        if((tsk_rt(t)->last_gpu < 0) ||
-           ((kfmlp_get_idx(sem, aff->shortest_queue->q) + aff->offset) == tsk_rt(t)->last_gpu)) {
+        if(unlikely(tsk_rt(t)->last_gpu < 0)) {
                 // we have affinity with the shorest queue.  pick it.
-                to_enqueue = aff->shortest_queue->q;
-                
-                TRACE_CUR("special case: no affinity or have affinity with shortest\n");
-                
+                shortest = aff->shortest_queue;
+                TRACE_CUR("special case: no affinity\n");
                 goto out;
         }
         
-        // enqueue where we will have the shortest time to completion
+        // all things being equal, let's start with the queue with which we have
+        // affinity.  this helps us maintain affinity even when we don't have
+        // an estiamte for local-affinity execution time (i.e., 2nd time on GPU)
+        shortest = &aff->q_info[tsk_rt(t)->last_gpu - aff->offset];
+        
+        if(shortest == aff->shortest_queue) {
+                TRACE_CUR("special case: have affinity with shortest queue\n");
+                goto out;
+        }
         
-        shortest = &aff->q_info[0];
-        min_len = shortest->estimated_len + get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, 0 + aff->offset));
+        min_len = shortest->estimated_len + get_gpu_estimate(t, MIG_LOCAL);
         
-        for(i = 1; i < sem->num_resources; ++i) {
-                lt_t est_len =
-                        aff->q_info[i].estimated_len +
-                        get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, i + aff->offset));
-                                                         
-                if(est_len < min_len) {
-                        shortest = &aff->q_info[i];
-                        min_len = est_len;
+        TRACE_CUR("cs is %llu on queue %d: est len = %llu\n",
+                          get_gpu_estimate(t, MIG_LOCAL),
+                          kfmlp_get_idx(sem, shortest->q),
+                          min_len);
+        
+        for(i = 0; i < sem->num_resources; ++i) {
+                if(&aff->q_info[i] != shortest) {
+                        
+                        lt_t est_len =
+                                aff->q_info[i].estimated_len +
+                                get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, i + aff->offset));
+                        if(est_len < min_len) {
+                                shortest = &aff->q_info[i];
+                                min_len = est_len;
+                        }
+                        
+                        TRACE_CUR("cs is %llu on queue %d: est len = %llu\n",
+                                          get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, i + aff->offset)),
+                                          kfmlp_get_idx(sem, aff->q_info[i].q),
+                                          est_len);                             
                 }
         }
-        to_enqueue = shortest->q;
         
-out:
+out:    
+        to_enqueue = shortest->q;
         TRACE_CUR("enqueue on fq %d (non-aff wanted fq %d)\n",
                           kfmlp_get_idx(sem, to_enqueue),
                           kfmlp_get_idx(sem, sem->shortest_queue));     
@@ -698,17 +750,20 @@ void gpu_kfmlp_notify_enqueue(struct kfmlp_affinity* aff, struct kfmlp_queue* fq
         int gpu = aff->offset + replica;
         struct kfmlp_queue_info *info = &aff->q_info[replica];
         lt_t est_time;
+        lt_t est_len_before;
         
         if(current == t) {
                 tsk_rt(t)->suspend_gpu_tracker_on_block = 1;
         }
-
+        
+        est_len_before = info->estimated_len;
         est_time = get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, gpu));
         info->estimated_len += est_time;
         
-        TRACE_CUR("fq %d est len is now %llu\n",
-                          kfmlp_get_idx(sem, aff->shortest_queue->q),
-                          aff->shortest_queue->estimated_len);
+        TRACE_CUR("fq %d: q_len (%llu) + est_cs (%llu) = %llu\n",
+                          kfmlp_get_idx(sem, info->q),
+                          est_len_before, est_time,
+                          info->estimated_len);
         
         if(aff->shortest_queue == info) {
                 // we may no longer be the shortest
@@ -764,7 +819,7 @@ void gpu_kfmlp_notify_acquired(struct kfmlp_affinity* aff, struct kfmlp_queue* f
         TRACE_CUR("%s/%d acquired gpu %d.  migration type = %d\n",
                           t->comm, t->pid, gpu, tsk_rt(t)->gpu_migration);
         
-        reg_nv_device(gpu, 1);  // register
+        reg_nv_device(gpu, 1, t);  // register
         
         tsk_rt(t)->suspend_gpu_tracker_on_block = 0;
         reset_gpu_tracker(t);
@@ -782,7 +837,7 @@ void gpu_kfmlp_notify_freed(struct kfmlp_affinity* aff, struct kfmlp_queue* fq,
         est_time = get_gpu_estimate(t, gpu_migration_distance(tsk_rt(t)->last_gpu, gpu));
         
         tsk_rt(t)->last_gpu = gpu;
-        reg_nv_device(gpu, 0);  // unregister
+        reg_nv_device(gpu, 0, t);       // unregister
         
         // update estimates
         update_gpu_estimate(t, get_gpu_time(t));
@@ -822,21 +877,25 @@ struct affinity_observer* kfmlp_gpu_aff_obs_new(struct affinity_observer_ops* op
 struct kfmlp_queue* simple_gpu_kfmlp_advise_enqueue(struct kfmlp_affinity* aff, struct task_struct* t)
 {
         struct kfmlp_semaphore *sem = kfmlp_from_lock(aff->obs.lock);
+//      TRACE_CUR("Simple GPU KFMLP advise_enqueue invoked\n");
         return sem->shortest_queue;
 }
 
 struct task_struct* simple_gpu_kfmlp_advise_steal(struct kfmlp_affinity* aff, wait_queue_t** to_steal, struct kfmlp_queue** to_steal_from)
 {
         struct kfmlp_semaphore *sem = kfmlp_from_lock(aff->obs.lock);
+//      TRACE_CUR("Simple GPU KFMLP advise_steal invoked\n");
         return kfmlp_select_hp_steal(sem, to_steal, to_steal_from);
 }
 
 void simple_gpu_kfmlp_notify_enqueue(struct kfmlp_affinity* aff, struct kfmlp_queue* fq, struct task_struct* t)
 {
+//      TRACE_CUR("Simple GPU KFMLP notify_enqueue invoked\n");
 }
 
 void simple_gpu_kfmlp_notify_dequeue(struct kfmlp_affinity* aff, struct kfmlp_queue* fq, struct task_struct* t)
 {
+//      TRACE_CUR("Simple GPU KFMLP notify_dequeue invoked\n");
 }
 
 void simple_gpu_kfmlp_notify_acquired(struct kfmlp_affinity* aff, struct kfmlp_queue* fq, struct task_struct* t)
@@ -844,7 +903,9 @@ void simple_gpu_kfmlp_notify_acquired(struct kfmlp_affinity* aff, struct kfmlp_q
         struct kfmlp_semaphore *sem = kfmlp_from_lock(aff->obs.lock);
         int gpu = kfmlp_get_idx(sem, fq) + aff->offset;
         
-        reg_nv_device(gpu, 1);  // register
+//      TRACE_CUR("Simple GPU KFMLP notify_acquired invoked\n");
+        
+        reg_nv_device(gpu, 1, t);  // register
 }
 
 void simple_gpu_kfmlp_notify_freed(struct kfmlp_affinity* aff, struct kfmlp_queue* fq, struct task_struct* t)
@@ -852,7 +913,9 @@ void simple_gpu_kfmlp_notify_freed(struct kfmlp_affinity* aff, struct kfmlp_queu
         struct kfmlp_semaphore *sem = kfmlp_from_lock(aff->obs.lock);
         int gpu = kfmlp_get_idx(sem, fq) + aff->offset;
         
-        reg_nv_device(gpu, 0);  // unregister
+//      TRACE_CUR("Simple GPU KFMLP notify_freed invoked\n");
+        
+        reg_nv_device(gpu, 0, t);       // unregister
 }
 
 struct kfmlp_affinity_ops simple_gpu_kfmlp_affinity =
diff --git a/litmus/litmus.c b/litmus/litmus.c
index dd8b72e1af08..b876e67b7a9b 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -67,7 +67,7 @@ void release_heap_free(struct release_heap* rh);
 asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
 {
         /* register the device to caller (aka 'current') */
-        return(reg_nv_device(nv_device_id, reg_action));
+        return(reg_nv_device(nv_device_id, reg_action, current));
 }
 #else
 asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
@@ -161,22 +161,6 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
 
         target->rt_param.task_params = tp;
 
-#ifdef CONFIG_LITMUS_SOFTIRQD
-        /* proxy thread off by default */
-        target->rt_param.is_proxy_thread = 0;
-    target->rt_param.cur_klitirqd = NULL;
-        //init_MUTEX(&target->rt_param.klitirqd_sem);
-        mutex_init(&target->rt_param.klitirqd_sem);
-        //init_completion(&target->rt_param.klitirqd_sem);
-        //target->rt_param.klitirqd_sem_stat = NOT_HELD;
-        atomic_set(&target->rt_param.klitirqd_sem_stat, NOT_HELD);
-#endif
-
-#ifdef CONFIG_LITMUS_NVIDIA
-        atomic_set(&target->rt_param.nv_int_count, 0);
-#endif
-
-
         retval = 0;
       out_unlock:
         read_unlock_irq(&tasklist_lock);
@@ -329,6 +313,22 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
         return ret;
 }
 
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
+void init_gpu_affinity_state(struct task_struct* p)
+{
+        // under-damped
+        p->rt_param.gpu_fb_param_a = _frac(14008, 10000);
+        p->rt_param.gpu_fb_param_b = _frac(16024, 10000);
+        // critically-damped
+        //      p->rt_param.gpu_fb_param_a = _frac(102, 1000);
+        //      p->rt_param.gpu_fb_param_b = _frac(303, 1000);
+        
+        p->rt_param.gpu_migration = MIG_NONE;
+        p->rt_param.last_gpu = -1;      
+}
+#endif
+
 /* p is a real-time task. Re-init its state as a best-effort task. */
 static void reinit_litmus_state(struct task_struct* p, int restore)
 {
@@ -388,10 +388,7 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
         }
         
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
-        p->rt_param.gpu_fb_param_a = _frac(14008, 1000);
-        p->rt_param.gpu_fb_param_b = _frac(16024, 1000);
-        p->rt_param.gpu_migration = MIG_LAST;
-        p->rt_param.last_gpu = -1;
+        init_gpu_affinity_state(p);
 #endif
         
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
@@ -443,10 +440,25 @@ long litmus_admit_task(struct task_struct* tsk)
         } else {
                 bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
-
+        
+        
+#ifdef CONFIG_LITMUS_NVIDIA
+        atomic_set(&tsk_rt(tsk)->nv_int_count, 0);
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
+        init_gpu_affinity_state(tsk);
+#endif
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         tsk_rt(tsk)->blocked_lock = NULL;
         raw_spin_lock_init(&tsk_rt(tsk)->hp_blocked_tasks_lock);
+        //INIT_BINHEAP_HANDLE(&tsk_rt(tsk)->hp_blocked_tasks, prio_order);  // done by scheduler
+#endif
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        /* proxy thread off by default */
+        tsk_rt(tsk)is_proxy_thread = 0;
+    tsk_rt(tsk)cur_klitirqd = NULL;
+        mutex_init(&tsk_rt(tsk)->klitirqd_sem);
+        atomic_set(&tsk_rt(tsk)->klitirqd_sem_stat, NOT_HELD);
 #endif
         
         retval = litmus->admit_task(tsk);
diff --git a/litmus/locking.c b/litmus/locking.c
index ef13062913ce..fd3c7260319f 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -52,7 +52,10 @@ static  int create_generic_lock(void** obj_ref, obj_type_t type, void* __user ar
                 lock->nest.hp_waiter_eff_prio = NULL;
 
                 INIT_BINHEAP_NODE(&lock->nest.hp_binheap_node);
-                WARN_ON(!(lock->nest.hp_waiter_ptr));
+                if(!lock->nest.hp_waiter_ptr) {
+                        TRACE_CUR("BEWARE: hp_waiter_ptr should probably not be NULL in "
+                                          "most uses. (exception: IKGLP donors)\n");
+                }
 #endif
                 lock->type = type;              
                 lock->ident = atomic_inc_return(&lock_id_gen);
diff --git a/litmus/nvidia_info.c b/litmus/nvidia_info.c
index 80900035881c..287e4a0662d9 100644
--- a/litmus/nvidia_info.c
+++ b/litmus/nvidia_info.c
@@ -418,16 +418,15 @@ void pai_check_priority_decrease(struct task_struct *t, int reg_device_id)
 }                  
 #endif
 
-static int __reg_nv_device(int reg_device_id)
+static int __reg_nv_device(int reg_device_id, struct task_struct *t)
 {
         int ret = 0;
         int i;
-        struct task_struct *t = current;
         struct task_struct *old_max = NULL;
         unsigned long flags;
         nv_device_registry_t *reg = &NV_DEVICE_REG[reg_device_id];
 
-    if(__test_bit(reg_device_id, &tsk_rt(t)->held_gpus)) {
+    if(test_bit(reg_device_id, &tsk_rt(t)->held_gpus)) {
                 // TODO: check if taks is already registered.
                 return ret;  // assume already registered.
         }
@@ -471,11 +470,10 @@ static int __reg_nv_device(int reg_device_id)
         return(ret);
 }
 
-static int __clear_reg_nv_device(int de_reg_device_id)
+static int __clear_reg_nv_device(int de_reg_device_id, struct task_struct *t)
 {
         int ret = 0;
         int i;
-        struct task_struct *t = current;
         unsigned long flags;
         nv_device_registry_t *reg = &NV_DEVICE_REG[de_reg_device_id];   
         
@@ -483,7 +481,7 @@ static int __clear_reg_nv_device(int de_reg_device_id)
     struct task_struct* klitirqd_th = get_klitirqd(de_reg_device_id);
 #endif
         
-        WARN_ON(!__test_bit(de_reg_device_id, &tsk_rt(t)->held_gpus));
+        WARN_ON(!test_bit(de_reg_device_id, &tsk_rt(t)->held_gpus));
 
         raw_spin_lock_irqsave(&reg->lock, flags);
         
@@ -518,16 +516,16 @@ static int __clear_reg_nv_device(int de_reg_device_id)
 }
 
 
-int reg_nv_device(int reg_device_id, int reg_action)
+int reg_nv_device(int reg_device_id, int reg_action, struct task_struct *t)
 {
         int ret;
 
         if((reg_device_id < NV_DEVICE_NUM) && (reg_device_id >= 0))
         {
                 if(reg_action)
-                        ret = __reg_nv_device(reg_device_id);
+                        ret = __reg_nv_device(reg_device_id, t);
                 else
-                        ret = __clear_reg_nv_device(reg_device_id);
+                        ret = __clear_reg_nv_device(reg_device_id, t);
         }
         else
         {
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index b4ab2361e37a..09334aea43ac 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -814,11 +814,12 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 
         /* If a task blocks we have no choice but to reschedule.
          */
-        if (blocks)
+        if (blocks) {
                 unlink(entry->scheduled);
+        }
         
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)    
-        if(tsk_rt(entry->scheduled)->held_gpus) {
+        if(exists && is_realtime(entry->scheduled) && tsk_rt(entry->scheduled)->held_gpus) {
                 if(!blocks || tsk_rt(entry->scheduled)->suspend_gpu_tracker_on_block) {
                         stop_gpu_tracker(entry->scheduled);
                 }
@@ -1119,7 +1120,9 @@ static void __increase_priority_inheritance(struct task_struct* t,
                                           "Occurance is likely okay: probably due to (hopefully safe) concurrent priority updates.\n",
                                    t->comm, t->pid,
                                    effective_priority(t)->comm, effective_priority(t)->pid,
-                                   prio_inh->comm, prio_inh->pid);
+                                   (prio_inh) ? prio_inh->comm : "nil",
+                                   (prio_inh) ? prio_inh->pid : -1);
+                WARN_ON(!prio_inh);
         }
 #endif
 }
@@ -1146,10 +1149,12 @@ static void increase_priority_inheritance(struct task_struct* t, struct task_str
         raw_spin_unlock(&gsnedf_lock);
         
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
-        for(i = find_first_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus));
-                i < NV_DEVICE_NUM;
-                i = find_next_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus), i)) {
-                pai_check_priority_increase(t, i);
+        if(tsk_rt(t)->held_gpus) {
+                for(i = find_first_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus));
+                        i < NV_DEVICE_NUM;
+                        i = find_next_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus), i+1)) {
+                        pai_check_priority_increase(t, i);
+                }
         }
 #endif
 }
@@ -1230,10 +1235,12 @@ static void decrease_priority_inheritance(struct task_struct* t,
         raw_spin_unlock(&gsnedf_lock);
         
 #if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
-        for(i = find_first_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus));
-                i < NV_DEVICE_NUM;
-                i = find_next_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus), i)) {
-                pai_check_priority_decrease(t, i);
+        if(tsk_rt(t)->held_gpus) {
+                for(i = find_first_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus));
+                        i < NV_DEVICE_NUM;
+                        i = find_next_bit(&tsk_rt(t)->held_gpus, sizeof(tsk_rt(t)->held_gpus), i+1)) {
+                        pai_check_priority_decrease(t, i);
+                }
         }
 #endif  
 }
@@ -1792,6 +1799,7 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
         .task_block             = gsnedf_task_block,
         .admit_task             = gsnedf_admit_task,
         .activate_plugin        = gsnedf_activate_plugin,
+        .compare                = edf_higher_prio,
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = gsnedf_allocate_lock,
         .increase_prio          = increase_priority_inheritance,
@@ -1800,6 +1808,7 @@ static struct sched_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         .nested_increase_prio           = nested_increase_priority_inheritance,
         .nested_decrease_prio           = nested_decrease_priority_inheritance,
+        .__compare                                      = __edf_higher_prio,
 #endif
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         .get_dgl_spinlock = gsnedf_get_dgl_spinlock,
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index de15e80743a8..a334fdf66c3b 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -112,6 +112,7 @@ static long litmus_dummy_deactivate_plugin(void)
 
 static int litmus_dummy_compare(struct task_struct* a, struct task_struct* b)
 {
+        TRACE_CUR("WARNING: Dummy compare function called!\n");
         return 0;
 }
 
@@ -177,6 +178,7 @@ static void litmus_dummy_nested_decrease_prio(struct task_struct* t, struct task
 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