GSN/PSN: improve locking

3 files changed, 25 insertions, 14 deletions

diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 1088e6fed8..0134947ee6 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -141,6 +141,7 @@ struct task_struct* __peek_ready(rt_domain_t* rt)
  */
 void __add_release(rt_domain_t* rt, struct task_struct *task)
 {
+        TRACE_TASK(task, "add_release(), rel=%llu\n", get_release(task));
         list_add(&task->rt_list, &rt->release_queue);
         task->rt_param.domain = rt;
         do_without_rqlock(&rt->arm_timers);
diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index b8dc0b1f8e..5d61fe053c 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -179,8 +179,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                          * the caller to get things right.
                          */
                         if (entry != sched) {
-                                TRACE_TASK(linked, 
-                                           "already scheduled on %d, updating link.\n", 
+                                TRACE_TASK(linked,
+                                           "already scheduled on %d, updating link.\n",
                                            sched->cpu);
                                 tmp = sched->linked;
                                 linked->rt_param.linked_on = sched->cpu;
@@ -396,7 +396,7 @@ static void gsnedf_tick(struct task_struct* t)
 static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 {
         cpu_entry_t* entry = &__get_cpu_var(gsnedf_cpu_entries);
-        int out_of_time, sleep, preempt, np, exists, blocks;    
+        int out_of_time, sleep, preempt, np, exists, blocks;
         struct task_struct* next = NULL;
 
         /* Will be released in finish_switch. */
@@ -419,15 +419,15 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
         TRACE_TASK(prev, "invoked gsnedf_schedule.\n");
 
         if (exists)
-                TRACE_TASK(prev, 
+                TRACE_TASK(prev,
                            "blocks:%d out_of_time:%d np:%d sleep:%d preempt:%d "
                            "state:%d sig:%d\n",
-                           blocks, out_of_time, np, sleep, preempt, 
+                           blocks, out_of_time, np, sleep, preempt,
                            prev->state, signal_pending(prev));
         if (entry->linked && preempt)
-                TRACE_TASK(prev, "will be preempted by %s/%d\n", 
+                TRACE_TASK(prev, "will be preempted by %s/%d\n",
                            entry->linked->comm, entry->linked->pid);
-             
+
 
         /* If a task blocks we have no choice but to reschedule.
          */
@@ -481,12 +481,15 @@ static struct task_struct* gsnedf_schedule(struct task_struct * prev)
 
         spin_unlock(&gsnedf_lock);
 
+        TRACE("gsnedf_lock released, next=0x%p\n", next);
+
+
         if (next)
                 TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
         else if (exists && !next)
                 TRACE("becomes idle at %llu.\n", litmus_clock());
 
-        
+
         return next;
 }
 
@@ -498,6 +501,7 @@ static void gsnedf_finish_switch(struct task_struct *prev)
         cpu_entry_t*    entry = &__get_cpu_var(gsnedf_cpu_entries);
 
         entry->scheduled = is_realtime(current) ? current : NULL;
+        TRACE_TASK(prev, "switched away from\n");
 }
 
 
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 55c55862d1..290654bb8d 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -58,7 +58,7 @@ static void psnedf_domain_init(psnedf_domain_t* pedf,
 static void requeue(struct task_struct* t, rt_domain_t *edf)
 {
         if (t->state != TASK_RUNNING)
-                TRACE_TASK(t, "requeue: !TASK_RUNNING");
+                TRACE_TASK(t, "requeue: !TASK_RUNNING\n");
 
         set_rt_flags(t, RT_F_RUNNING);
         if (is_released(t, litmus_clock()))
@@ -197,17 +197,21 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
                 if (exists)
                         next = prev;
 
-        if (next)
+        if (next) {
+                TRACE_TASK(next, " == next\n");
                 set_rt_flags(next, RT_F_RUNNING);
+        } else {
+                TRACE("becoming idle.\n");
+        }
 
         pedf->scheduled = next;
         spin_unlock(&pedf->slock);
+
         return next;
 }
 
 
 /*      Prepare a task for running in RT mode
- *      Enqueues the task into master queue data structure
  */
 static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
 {
@@ -215,8 +219,7 @@ static void psnedf_task_new(struct task_struct * t, int on_rq, int running)
         psnedf_domain_t*        pedf = task_pedf(t);
         unsigned long           flags;
 
-        TRACE("[%d] psn edf: prepare new %d on CPU %d\n",
-                smp_processor_id(), t->pid, get_partition(t));
+        TRACE_TASK(t, "new\n");
 
         /* setup job parameters */
         release_at(t, litmus_clock());
@@ -244,6 +247,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         rt_domain_t*            edf  = task_edf(task);
         lt_t                    now;
 
+        TRACE_TASK(task, "wake up\n");
         spin_lock_irqsave(&pedf->slock, flags);
         BUG_ON(in_list(&task->rt_list));
         /* We need to take suspensions because of semaphores into
@@ -261,11 +265,13 @@ static void psnedf_task_wake_up(struct task_struct *task)
         }
         requeue(task, edf);
         spin_unlock_irqrestore(&pedf->slock, flags);
+        TRACE_TASK(task, "wake up done\n");
 }
 
 static void psnedf_task_block(struct task_struct *t)
 {
         /* only running tasks can block, thus t is in no queue */
+        TRACE_TASK(t, "block, state=%d\n", t->state);
         BUG_ON(!is_realtime(t));
         BUG_ON(in_list(&t->rt_list));
 }
@@ -316,7 +322,7 @@ static long psnedf_pi_block(struct pi_semaphore *sem,
                                 if (is_released(t, litmus_clock()))
                                         __add_ready(edf, t);
                                 else
-                                        __add_release(edf, t);
+                                        add_release(edf, t);
                         }
                 }