1 files changed, 33 insertions, 45 deletions

diff --git a/litmus/edf_common.c b/litmus/edf_common.c
index 5a3f5b417f73..c279bf12a7f5 100755
--- a/litmus/edf_common.c
+++ b/litmus/edf_common.c
@@ -22,7 +22,7 @@
 #include <litmus/fpmath.h>
 #endif
 
-#if defined(CONFIG_EDF_TIE_BREAK_HASH) || defined(CONFIG_REALTIME_AUX_TASKS)
+#if defined(CONFIG_EDF_TIE_BREAK_HASH)
 #include <linux/hash.h>
 static inline long edf_hash(struct task_struct *t)
 {
@@ -43,23 +43,6 @@ static inline long edf_hash(struct task_struct *t)
 }
 #endif
 
-#ifdef CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE
-int aux_tie_break(struct task_struct *first, struct task_struct *second)
-{
-        long fhash = edf_hash(first);
-        long shash = edf_hash(second);
-        if (fhash < shash) {
-                TRACE_CUR("%s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, 1);
-                return 1;
-        }
-        else if(fhash == shash) {
-                TRACE_CUR("%s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, (first->pid < second->pid));
-                return first->pid < second->pid;
-        }
-        return 0;
-}
-#endif
-
 
 /* edf_higher_prio -  returns true if first has a higher EDF priority
  *                    than second. Deadline ties are broken by PID.
@@ -93,44 +76,47 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 #if defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_BOOSTED)
         /* run aux tasks at max priority */
+        /* TODO: Actually use prio-boosting. */
         if (first->rt_param.is_aux_task != second->rt_param.is_aux_task)
         {
                 return (first->rt_param.is_aux_task > second->rt_param.is_aux_task);
         }
         else if(first->rt_param.is_aux_task && second->rt_param.is_aux_task)
         {
+                if(first->group_leader == second->group_leader) {
+                        TRACE_CUR("aux tie break!\n");  // tie-break by BASE priority of the aux tasks
+                        goto aux_tie_break;
+                }
                 first = first->group_leader;
                 second = second->group_leader;
         }
 #elif defined(CONFIG_REALTIME_AUX_TASK_PRIORITY_INHERITANCE)
         {
-        int first_lo_aux, second_lo_aux;
-        int first_hi_aux, second_hi_aux;
-        first_lo_aux = first->rt_param.is_aux_task && !first->rt_param.inh_task;
-        second_lo_aux = second->rt_param.is_aux_task && !second->rt_param.inh_task;
-
-        if (first_lo_aux && !second_lo_aux) {
-                TRACE_CUR("%s/%d >> %s/%d --- 0\n", first->comm, first->pid, second->comm, second->pid);
-                return 0;
-        }
-        else if (second_lo_aux && !first_lo_aux) {
-                TRACE_CUR("%s/%d >> %s/%d --- 1\n", first->comm, first->pid, second->comm, second->pid);
-                return 1;
-        }
-        else if (first_lo_aux && second_lo_aux) {
-                int aux_lo_tie_break = aux_tie_break(first, second);
-                TRACE_CUR("low aux tie break: %s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, aux_lo_tie_break);
-                return aux_lo_tie_break;
-        }
-
-        first_hi_aux = first->rt_param.is_aux_task && first->rt_param.inh_task;
-        second_hi_aux = second->rt_param.is_aux_task && second->rt_param.inh_task;
-
-        if (first_hi_aux && second_hi_aux && first->rt_param.inh_task == second->rt_param.inh_task) {
-                int aux_hi_tie_break = aux_tie_break(first, second);
-                TRACE_CUR("hi aux tie break: %s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, aux_hi_tie_break);
-                return aux_hi_tie_break;
-        }
+                int first_lo_aux = first->rt_param.is_aux_task && !first->rt_param.inh_task;
+                int second_lo_aux = second->rt_param.is_aux_task && !second->rt_param.inh_task;
+
+                /* prioritize aux tasks without inheritance below real-time tasks */
+                if (first_lo_aux || second_lo_aux) {
+                        // one of these is an aux task without inheritance.
+                        if(first_lo_aux && second_lo_aux) {
+                                TRACE_CUR("aux tie break!\n");  // tie-break by BASE priority of the aux tasks
+                                goto aux_tie_break;
+                        }
+                        else {
+                                // make the aux thread lowest priority real-time task
+                                int temp = (first_lo_aux) ? !is_realtime(second) : !is_realtime(first);
+                                TRACE_CUR("%s/%d >> %s/%d --- %d\n", first->comm, first->pid, second->comm, second->pid, temp);
+                                return temp;
+                        }
+                }
+                
+                if (first->rt_param.is_aux_task && second->rt_param.is_aux_task &&
+                        first->rt_param.inh_task == second->rt_param.inh_task) {  // inh_task is !NULL for both tasks since neither was a lo_aux task
+                        // Both aux tasks inherit from the same task, so tie-break
+                        // by base priority of the aux tasks.
+                        TRACE_CUR("aux tie break!\n");
+                        goto aux_tie_break;
+                }
         }
 #endif
 
@@ -174,6 +160,8 @@ int edf_higher_prio(struct task_struct* first, struct task_struct* second)
 
 #endif
 
+aux_tie_break:
+        
         if (!is_realtime(second_task)) {
                 return 1;
         }