1 files changed, 96 insertions, 37 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 5e977dd2fef0..87f8bc9bb50b 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -44,6 +44,10 @@
 
 #include <litmus/bheap.h>
 
+#ifdef CONFIG_SCHED_CPU_AFFINITY
+#include <litmus/affinity.h>
+#endif
+
 /* to configure the cluster size */
 #include <litmus/litmus_proc.h>
 
@@ -95,7 +99,7 @@ typedef struct clusterdomain {
         struct bheap_node *heap_node;
         struct bheap      cpu_heap;
         /* lock for this cluster */
-#define cedf_lock domain.ready_lock
+#define cluster_lock domain.ready_lock
 } cedf_domain_t;
 
 /* a cedf_domain per cluster; allocation is done at init/activation time */
@@ -204,7 +208,7 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
 }
 
 /* unlink - Make sure a task is not linked any longer to an entry
- *          where it was linked before. Must hold cedf_lock.
+ *          where it was linked before. Must hold cluster_lock.
  */
 static noinline void unlink(struct task_struct* t)
 {
@@ -240,7 +244,7 @@ static void preempt(cpu_entry_t *entry)
 }
 
 /* requeue - Put an unlinked task into gsn-edf domain.
- *           Caller must hold cedf_lock.
+ *           Caller must hold cluster_lock.
  */
 static noinline void requeue(struct task_struct* task)
 {
@@ -257,11 +261,34 @@ static noinline void requeue(struct task_struct* task)
         }
 }
 
+#ifdef CONFIG_SCHED_CPU_AFFINITY
+static cpu_entry_t* cedf_get_nearest_available_cpu(
+                                cedf_domain_t *cluster, cpu_entry_t *start)
+{
+        cpu_entry_t *affinity;
+
+        get_nearest_available_cpu(affinity, start, cedf_cpu_entries,
+#ifdef CONFIG_RELEASE_MASTER
+                cluster->domain.release_master
+#else
+                NO_CPU
+#endif
+                );
+
+        /* make sure CPU is in our cluster */
+        if (affinity && cpu_isset(affinity->cpu, *cluster->cpu_map))
+                return(affinity);
+        else
+                return(NULL);
+}
+#endif
+
+
 /* check for any necessary preemptions */
 static void check_for_preemptions(cedf_domain_t *cluster)
 {
         struct task_struct *task;
-        cpu_entry_t* last;
+        cpu_entry_t *last;
 
         for(last = lowest_prio_cpu(cluster);
             edf_preemption_needed(&cluster->domain, last->linked);
@@ -270,8 +297,20 @@ static void check_for_preemptions(cedf_domain_t *cluster)
                 task = __take_ready(&cluster->domain);
                 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 =
+                                        cedf_get_nearest_available_cpu(cluster,
+                                                &per_cpu(cedf_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);
         }
@@ -292,15 +331,15 @@ static void cedf_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         cedf_domain_t* cluster = container_of(rt, cedf_domain_t, domain);
         unsigned long flags;
 
-        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
 
         __merge_ready(&cluster->domain, tasks);
         check_for_preemptions(cluster);
 
-        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cluster_lock, flags);
 }
 
-/* caller holds cedf_lock */
+/* caller holds cluster_lock */
 static noinline void job_completion(struct task_struct *t, int forced)
 {
         BUG_ON(!t);
@@ -378,7 +417,18 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
         int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
-        raw_spin_lock(&cluster->cedf_lock);
+#ifdef CONFIG_RELEASE_MASTER
+        /* Bail out early if we are the release master.
+         * The release master never schedules any real-time tasks.
+         */
+        if (unlikely(cluster->domain.release_master == entry->cpu)) {
+                sched_state_task_picked();
+                return NULL;
+        }
+#endif
+
+        raw_spin_lock(&cluster->cluster_lock);
+
         clear_will_schedule();
 
         /* sanity checking */
@@ -462,10 +512,10 @@ static struct task_struct* cedf_schedule(struct task_struct * prev)
                         next = prev;
 
         sched_state_task_picked();
-        raw_spin_unlock(&cluster->cedf_lock);
+        raw_spin_unlock(&cluster->cluster_lock);
 
 #ifdef WANT_ALL_SCHED_EVENTS
-        TRACE("cedf_lock released, next=0x%p\n", next);
+        TRACE("cluster_lock released, next=0x%p\n", next);
 
         if (next)
                 TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
@@ -504,7 +554,7 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
         /* the cluster doesn't change even if t is running */
         cluster = task_cpu_cluster(t);
 
-        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
 
         /* setup job params */
         release_at(t, litmus_clock());
@@ -513,15 +563,25 @@ static void cedf_task_new(struct task_struct * t, int on_rq, int running)
                 entry = &per_cpu(cedf_cpu_entries, task_cpu(t));
                 BUG_ON(entry->scheduled);
 
-                entry->scheduled = t;
-                tsk_rt(t)->scheduled_on = task_cpu(t);
+#ifdef CONFIG_RELEASE_MASTER
+                if (entry->cpu != cluster->domain.release_master) {
+#endif
+                        entry->scheduled = t;
+                        tsk_rt(t)->scheduled_on = task_cpu(t);
+#ifdef CONFIG_RELEASE_MASTER
+                } else {
+                        /* do not schedule on release master */
+                        preempt(entry); /* force resched */
+                        tsk_rt(t)->scheduled_on = NO_CPU;
+                }
+#endif
         } else {
                 t->rt_param.scheduled_on = NO_CPU;
         }
         t->rt_param.linked_on          = NO_CPU;
 
         cedf_job_arrival(t);
-        raw_spin_unlock_irqrestore(&(cluster->cedf_lock), flags);
+        raw_spin_unlock_irqrestore(&(cluster->cluster_lock), flags);
 }
 
 static void cedf_task_wake_up(struct task_struct *task)
@@ -534,7 +594,8 @@ static void cedf_task_wake_up(struct task_struct *task)
 
         cluster = task_cpu_cluster(task);
 
-        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
+
         /* We need to take suspensions because of semaphores into
          * account! If a job resumes after being suspended due to acquiring
          * a semaphore, it should never be treated as a new job release.
@@ -557,7 +618,8 @@ static void cedf_task_wake_up(struct task_struct *task)
                 }
         }
         cedf_job_arrival(task);
-        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
+
+        raw_spin_unlock_irqrestore(&cluster->cluster_lock, flags);
 }
 
 static void cedf_task_block(struct task_struct *t)
@@ -570,9 +632,9 @@ static void cedf_task_block(struct task_struct *t)
         cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
         unlink(t);
-        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cluster_lock, flags);
 
         BUG_ON(!is_realtime(t));
 }
@@ -584,7 +646,7 @@ static void cedf_task_exit(struct task_struct * t)
         cedf_domain_t *cluster = task_cpu_cluster(t);
 
         /* unlink if necessary */
-        raw_spin_lock_irqsave(&cluster->cedf_lock, flags);
+        raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
         unlink(t);
         if (tsk_rt(t)->scheduled_on != NO_CPU) {
                 cpu_entry_t *cpu;
@@ -592,7 +654,7 @@ static void cedf_task_exit(struct task_struct * t)
                 cpu->scheduled = NULL;
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
-        raw_spin_unlock_irqrestore(&cluster->cedf_lock, flags);
+        raw_spin_unlock_irqrestore(&cluster->cluster_lock, flags);
 
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");
@@ -605,16 +667,6 @@ static long cedf_admit_task(struct task_struct* tsk)
 
 
 
-
-
-
-
-
-
-
-
-
-
 #ifdef CONFIG_LITMUS_LOCKING
 
 #include <litmus/fdso.h>
@@ -692,11 +744,11 @@ static void set_priority_inheritance(struct task_struct* t, struct task_struct*
 {
         cedf_domain_t* cluster = task_cpu_cluster(t);
         
-        raw_spin_lock(&cluster->cedf_lock);
+        raw_spin_lock(&cluster->cluster_lock);
         
         __set_priority_inheritance(t, prio_inh);
 
-        raw_spin_unlock(&cluster->cedf_lock);
+        raw_spin_unlock(&cluster->cluster_lock);
 }
 
 
@@ -727,9 +779,9 @@ static void clear_priority_inheritance(struct task_struct* t)
 {
         cedf_domain_t* cluster = task_cpu_cluster(t);
         
-        raw_spin_lock(&cluster->cedf_lock);
+        raw_spin_lock(&cluster->cluster_lock);
         __clear_priority_inheritance(t);
-        raw_spin_unlock(&cluster->cedf_lock);
+        raw_spin_unlock(&cluster->cluster_lock);
 }
 
 
@@ -857,7 +909,7 @@ static struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
         
                 cluster = task_cpu_cluster(max_hp);
 
-                raw_spin_lock(&cluster->cedf_lock);
+                raw_spin_lock(&cluster->cluster_lock);
                 
                 if(tsk_rt(my_queue->owner)->inh_task == max_hp)
                 {
@@ -867,7 +919,7 @@ static struct task_struct* kfmlp_remove_hp_waiter(struct kfmlp_semaphore* sem)
                                 __set_priority_inheritance(my_queue->owner, my_queue->hp_waiter);
                         }
                 }
-                raw_spin_unlock(&cluster->cedf_lock);
+                raw_spin_unlock(&cluster->cluster_lock);
                 
                 list_for_each(pos, &my_queue->wait.task_list)
                 {
@@ -1270,6 +1322,9 @@ static long cedf_activate_plugin(void)
 
                 if(!zalloc_cpumask_var(&cedf[i].cpu_map, GFP_ATOMIC))
                         return -ENOMEM;
+#ifdef CONFIG_RELEASE_MASTER
+                cedf[i].domain.release_master = atomic_read(&release_master_cpu);
+#endif
         }
 
         /* cycle through cluster and add cpus to them */
@@ -1312,7 +1367,11 @@ static long cedf_activate_plugin(void)
 
                                 entry->linked = NULL;
                                 entry->scheduled = NULL;
-                                update_cpu_position(entry);
+#ifdef CONFIG_RELEASE_MASTER
+                                /* only add CPUs that should schedule jobs */
+                                if (entry->cpu != entry->cluster->domain.release_master)
+#endif
+                                        update_cpu_position(entry);
                         }
                         /* done with this cluster */
                         break;