Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

1 files changed, 47 insertions, 5 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index b87524cf1802..d5bb326ebc9b 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -20,11 +20,16 @@
 #include <litmus/sched_plugin.h>
 #include <litmus/edf_common.h>
 #include <litmus/sched_trace.h>
+#include <litmus/trace.h>
 
 #include <litmus/preempt.h>
 
 #include <litmus/bheap.h>
 
+#ifdef CONFIG_SCHED_CPU_AFFINITY
+#include <litmus/affinity.h>
+#endif
+
 #include <linux/module.h>
 
 /* Overview of GSN-EDF operations.
@@ -255,21 +260,52 @@ static noinline void requeue(struct task_struct* task)
         }
 }
 
+#ifdef CONFIG_SCHED_CPU_AFFINITY
+static cpu_entry_t* gsnedf_get_nearest_available_cpu(cpu_entry_t *start)
+{
+        cpu_entry_t *affinity;
+
+        get_nearest_available_cpu(affinity, start, gsnedf_cpu_entries,
+#ifdef CONFIG_RELEASE_MASTER
+                        gsnedf.release_master
+#else
+                        NO_CPU
+#endif
+                        );
+
+        return(affinity);
+}
+#endif
+
 /* check for any necessary preemptions */
 static void check_for_preemptions(void)
 {
         struct task_struct *task;
-        cpu_entry_t* last;
+        cpu_entry_t *last;
 
-        for(last = lowest_prio_cpu();
-            edf_preemption_needed(&gsnedf, last->linked);
-            last = lowest_prio_cpu()) {
+        for (last = lowest_prio_cpu();
+             edf_preemption_needed(&gsnedf, last->linked);
+             last = lowest_prio_cpu()) {
                 /* preemption necessary */
                 task = __take_ready(&gsnedf);
                 TRACE("check_for_preemptions: attempting to link task %d to %d\n",
                       task->pid, last->cpu);
+
+#ifdef CONFIG_SCHED_CPU_AFFINITY
+                {
+                        cpu_entry_t *affinity =
+                                        gsnedf_get_nearest_available_cpu(
+                                                &per_cpu(gsnedf_cpu_entries, task_cpu(task)));
+                        if (affinity)
+                                last = affinity;
+                        else if (last->linked)
+                                requeue(last->linked);
+                }
+#else
                 if (last->linked)
                         requeue(last->linked);
+#endif
+
                 link_task_to_cpu(task, last);
                 preempt(last);
         }
@@ -376,8 +412,10 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         /* Bail out early if we are the release master.
          * The release master never schedules any real-time tasks.
          */
-        if (gsnedf.release_master == entry->cpu)
+        if (unlikely(gsnedf.release_master == entry->cpu)) {
+                sched_state_task_picked();
                 return NULL;
+        }
 #endif
 
         raw_spin_lock(&gsnedf_lock);
@@ -783,6 +821,8 @@ int gsnedf_fmlp_lock(struct litmus_lock* l)
                                 set_priority_inheritance(sem->owner, sem->hp_waiter);
                 }
 
+                TS_LOCK_SUSPEND;
+
                 /* release lock before sleeping */
                 spin_unlock_irqrestore(&sem->wait.lock, flags);
 
@@ -793,6 +833,8 @@ int gsnedf_fmlp_lock(struct litmus_lock* l)
 
                 schedule();
 
+                TS_LOCK_RESUME;
+
                 /* Since we hold the lock, no other task will change
                  * ->owner. We can thus check it without acquiring the spin
                  * lock. */