6 files changed, 39 insertions, 15 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;