part. gpu hack and fixed dumb ikglp bug

IKGLP wasn't being passed the right value for
'm' in C-EDF.  It went undected for so long
since m < k in our GPUSync experiments.

3 files changed, 17 insertions, 14 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 49b2b45396e4..144be3b6ee3d 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -355,6 +355,7 @@ struct rt_param {
 
 #ifdef CONFIG_REALTIME_AUX_TASKS
         unsigned int            is_aux_task:1;
+        unsigned int            aux_ready:1;
         unsigned int            has_aux_tasks:1;
         unsigned int            hide_from_aux_tasks:1;
 
diff --git a/litmus/ikglp_lock.c b/litmus/ikglp_lock.c
index e78a4ec0dff6..57be5db5f1be 100644
--- a/litmus/ikglp_lock.c
+++ b/litmus/ikglp_lock.c
@@ -1771,6 +1771,8 @@ struct litmus_lock* ikglp_new(int m,
         int nr_replicas = 0;
         int i;
 
+        BUG_ON(m <= 0);
+
         if(!access_ok(VERIFY_READ, arg, sizeof(nr_replicas)))
         {
                 return(NULL);
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 9d4e822aeede..508a0596f9a7 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -316,10 +316,10 @@ static noinline void requeue(struct task_struct* task)
 
         if (is_released(task, litmus_clock()))
 #ifdef CONFIG_REALTIME_AUX_TASKS
-                if (unlikely(tsk_rt(task)->is_aux_task && task->state != TASK_RUNNING)) {
+                if (unlikely(tsk_rt(task)->is_aux_task && task->state != TASK_RUNNING && !tsk_rt(task)->aux_ready)) {
                         /* aux_task probably transitioned to real-time while it was blocked */
                         TRACE_CUR("aux task %s/%d is not ready!\n", task->comm, task->pid);
-                        unlink(task); /* really needed? */
+                        tsk_rt(task)->aux_ready = 1; /* allow this to only happen once per aux task */
                 }
                 else
 #endif
@@ -419,16 +419,6 @@ static noinline void job_completion(struct task_struct *t, int forced)
 
 #ifdef CONFIG_LITMUS_LOCKING
         BUG_ON(!is_persistent(t) && tsk_rt(t)->inh_task);
-#if 0
-        if (!is_persistent(t) && tsk_rt(t)->inh_task) {
-                /* job completing while inheriting a priority */
-                TRACE_TASK(t,
-                        "WARNING: Completing job while still inheriting a "
-                        "priority (%s/%d)!\n",
-                        tsk_rt(t)->inh_task->comm,
-                        tsk_rt(t)->inh_task->pid);
-        }
-#endif
 #endif
 
         /* set flags */
@@ -1572,7 +1562,7 @@ static struct litmus_lock_ops cedf_ikglp_lock_ops = {
 static struct litmus_lock* cedf_new_ikglp(void* __user arg)
 {
         // assumes clusters of uniform size.
-        return ikglp_new(cluster_size/num_clusters, &cedf_ikglp_lock_ops, arg);
+        return ikglp_new(cluster_size, &cedf_ikglp_lock_ops, arg);
 }
 
 #endif  /* CONFIG_LITMUS_NESTED_LOCKING */
@@ -1728,8 +1718,18 @@ static void cleanup_cedf(void)
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
 static int cedf_map_gpu_to_cpu(int gpu)
 {
+        int default_cpu;
         int cpu_cluster = gpu / gpu_cluster_size;
-        int default_cpu = cedf[cpu_cluster].cpus[0]->cpu;  // first CPU in given cluster
+
+        /* bonham-specific hack for the fully partitioned case (both CPUs and GPUs partitioned) */
+        /* TODO: Make this aware of the NUMA topology generically */
+        if(num_clusters == 12 && num_gpu_clusters == 8) {
+                if(gpu >= 4) {
+                        cpu_cluster += 2; // assign the GPU to a CPU on the same NUMA node
+                }
+        }
+
+        default_cpu = cedf[cpu_cluster].cpus[0]->cpu;  // first CPU in given cluster
 
         TRACE("CPU %d is default for GPU %d interrupt threads.\n", default_cpu, gpu);