3 files changed, 64 insertions, 6 deletions

diff --git a/litmus/Kconfig b/litmus/Kconfig
index ad8dc8308cf0..651b66a77c65 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -36,6 +36,24 @@ config RELEASE_MASTER
 
 endmenu
 
+menu "Performance Hacks"
+
+config CPU_SCHED_BIAS
+        bool "Tasks prefer previous CPU(s)."
+        default n
+        help
+                Allow tasks to be rescheduled on their previously used CPU(s) if that
+                CPU(s) is not currently not executing real-time work.  This may improve
+                performance through the possible preservation of cache affinity.
+
+                Warning: May make bugs harder to find as tasks will migrate less
+                frequently.
+
+                Only bias towards previously used CPU is currently implemented. In the
+                future: bias on CPU topology.
+
+endmenu
+
 menu "Real-Time Synchronization"
 
 config NP_SECTION
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 73fe1c442a0d..851de716de0a 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -261,17 +261,35 @@ static noinline void requeue(struct task_struct* task)
 static void check_for_preemptions(cedf_domain_t *cluster)
 {
         struct task_struct *task;
-        cpu_entry_t* last;
+        cpu_entry_t *last;
+
+#ifdef CONFIG_CPU_SCHED_BIAS
+        cpu_entry_t *pref;
+#endif
 
         for(last = lowest_prio_cpu(cluster);
             edf_preemption_needed(&cluster->domain, last->linked);
             last = lowest_prio_cpu(cluster)) {
                 /* preemption necessary */
                 task = __take_ready(&cluster->domain);
-                TRACE("check_for_preemptions: attempting to link task %d to %d\n",
-                      task->pid, last->cpu);
+
+#ifdef CONFIG_CPU_SCHED_BIAS
+                /* where was task last scheduled? */
+                pref = &per_cpu(cedf_cpu_entries, task_cpu(task));
+
+                if (!pref->linked) {
+                        last = pref;
+                }
+                else if (last->linked) {
+                        requeue(last->linked);
+                }
+#else /* end CONFIG_CPU_SCHED_BIAS */
                 if (last->linked)
                         requeue(last->linked);
+#endif
+
+                TRACE("check_for_preemptions: attempting to link task %d to %d\n",
+                      task->pid, last->cpu);
                 link_task_to_cpu(task, last);
                 preempt(last);
         }
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index c5c9600c33d8..dd670f5219c1 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -257,17 +257,39 @@ static noinline void requeue(struct task_struct* task)
 static void check_for_preemptions(void)
 {
         struct task_struct *task;
-        cpu_entry_t* last;
+        cpu_entry_t *last;
+
+#ifdef CONFIG_CPU_SCHED_BIAS
+        cpu_entry_t *pref;
+#endif
 
         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_CPU_SCHED_BIAS
+                /* where was task last scheduled? */
+                pref = &per_cpu(gsnedf_cpu_entries, task_cpu(task));
+
+                if (!pref->linked
+#ifdef CONFIG_RELEASE_MASTER
+                        && (pref->cpu != gsnedf.release_master)
+#endif
+                   ) {
+                        last = pref;
+                }
+                else if (last->linked) {
+                        requeue(last->linked);
+                }
+#else /* end CONFIG_CPU_SCHED_BIAS */
                 if (last->linked)
                         requeue(last->linked);
+#endif
+
+                TRACE("check_for_preemptions: attempting to link task %d to %d\n", 
+                                                task->pid, last->cpu);
                 link_task_to_cpu(task, last);
                 preempt(last);
         }