1 files changed, 58 insertions, 14 deletions

diff --git a/litmus/sched_crm.c b/litmus/sched_crm.c
index fd7fab982998..e51de10557f9 100644
--- a/litmus/sched_crm.c
+++ b/litmus/sched_crm.c
@@ -57,6 +57,7 @@
 
 #ifdef CONFIG_LITMUS_PAI_SOFTIRQD
 #include <linux/interrupt.h>
+#include <litmus/trace.h>
 #endif
 
 #ifdef CONFIG_LITMUS_NVIDIA
@@ -425,17 +426,24 @@ static void crm_tick(struct task_struct* t)
 static void __do_lit_tasklet(struct tasklet_struct* tasklet, unsigned long flushed)
 {
         if (!atomic_read(&tasklet->count)) {
-                sched_trace_tasklet_begin(tasklet->owner);
+                if(tasklet->owner) {
+                        sched_trace_tasklet_begin(tasklet->owner);
+                }
                 
                 if (!test_and_clear_bit(TASKLET_STATE_SCHED, &tasklet->state))
                 {
                         BUG();
                 }
-                TRACE("%s: Invoking tasklet with owner pid = %d (flushed = %d).\n", __FUNCTION__, tasklet->owner->pid, flushed);
+                TRACE("%s: Invoking tasklet with owner pid = %d (flushed = %d).\n",
+                          __FUNCTION__,
+                          (tasklet->owner) ? tasklet->owner->pid : -1,
+                          (tasklet->owner) ? 0 : 1);
                 tasklet->func(tasklet->data);
                 tasklet_unlock(tasklet);
                 
-                sched_trace_tasklet_end(tasklet->owner, flushed);
+                if(tasklet->owner) {
+                        sched_trace_tasklet_end(tasklet->owner, flushed);
+                }
         }
         else {
                 BUG();
@@ -491,6 +499,7 @@ static void __extract_tasklets(crm_domain_t* cluster, struct task_struct* task,
 
 static void flush_tasklets(crm_domain_t* cluster, struct task_struct* task)
 {
+#if 0
         unsigned long flags;
         struct tasklet_head task_tasklets;
         struct tasklet_struct* step;
@@ -513,6 +522,27 @@ static void flush_tasklets(crm_domain_t* cluster, struct task_struct* task)
                 
                 step = temp;
         }
+#endif
+        
+        // lazy flushing.
+        // just change ownership to NULL and let an idle processor
+        // take care of it. :P
+        
+        struct tasklet_struct* step;
+        unsigned long flags;
+        
+        raw_spin_lock_irqsave(&cluster->crm_lock, flags);
+
+        for(step = cluster->pending_tasklets.head; step != NULL; step = step->next)
+        {
+                if(step->owner == task)
+                {
+                        TRACE("%s: Found tasklet to flush: %d\n", __FUNCTION__, step->owner->pid);
+                        step->owner = NULL;
+                }
+        }       
+        
+        raw_spin_unlock_irqrestore(&cluster->crm_lock, flags);
 }
 
 
@@ -524,6 +554,9 @@ static void do_lit_tasklets(crm_domain_t* cluster, struct task_struct* sched_tas
         unsigned long flags;
         
         while(work_to_do) {
+                
+                TS_NV_SCHED_BOTISR_START;
+                
                 // remove tasklet at head of list if it has higher priority.
                 raw_spin_lock_irqsave(&cluster->crm_lock, flags);       
                 
@@ -546,17 +579,17 @@ static void do_lit_tasklets(crm_domain_t* cluster, struct task_struct* sched_tas
                                 
                                 if(NULL == tasklet->next) {
                                         // tasklet is at the head, list only has one element
-                                        TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
+                                        TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, (tasklet->owner) ? tasklet->owner->pid : -1);
                                         cluster->pending_tasklets.tail = &(cluster->pending_tasklets.head);
                                 }
                                 
                                 // remove the tasklet from the queue
                                 cluster->pending_tasklets.head = tasklet->next;
                                 
-                                TRACE("%s: Removed tasklet for %d from tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
+                                TRACE("%s: Removed tasklet for %d from tasklet queue.\n", __FUNCTION__, (tasklet->owner) ? tasklet->owner->pid : -1);
                         }
                         else {
-                                TRACE("%s: Pending tasklet (%d) does not have priority to run on this CPU (%d).\n", __FUNCTION__, tasklet->owner->pid, smp_processor_id());
+                                TRACE("%s: Pending tasklet (%d) does not have priority to run on this CPU (%d).\n", __FUNCTION__, (tasklet->owner) ? tasklet->owner->pid : -1, smp_processor_id());
                                 tasklet = NULL;
                         }
                 }
@@ -577,6 +610,8 @@ static void do_lit_tasklets(crm_domain_t* cluster, struct task_struct* sched_tas
                 
                 raw_spin_unlock_irqrestore(&cluster->crm_lock, flags);
                 
+                TS_NV_SCHED_BOTISR_END;
+                
                 if(tasklet) {
                         __do_lit_tasklet(tasklet, 0ul);
                         tasklet = NULL; 
@@ -619,8 +654,8 @@ static void run_tasklets(struct task_struct* sched_task)
         preempt_disable();
         
         cluster = (is_realtime(sched_task)) ?
-        task_cpu_cluster(sched_task) :
-        remote_cluster(smp_processor_id());
+                task_cpu_cluster(sched_task) :
+                remote_cluster(smp_processor_id());
         
         if(cluster && cluster->pending_tasklets.head != NULL) {
                 TRACE("%s: There are tasklets to process.\n", __FUNCTION__);
@@ -679,8 +714,17 @@ static void __add_pai_tasklet(struct tasklet_struct* tasklet, crm_domain_t* clus
                 
                 // insert tasklet right before step->next.
                 
-                TRACE("%s: inserting tasklet for %d between %d and %d.\n", __FUNCTION__, tasklet->owner->pid, step->owner->pid, (step->next) ? step->next->owner->pid : -1);
-                
+                TRACE("%s: inserting tasklet for %d between %d and %d.\n", __FUNCTION__,
+                          tasklet->owner->pid,
+                          (step->owner) ?
+                              step->owner->pid :
+                              -1,
+                          (step->next) ?
+                                ((step->next->owner) ?
+                                        step->next->owner->pid :
+                                        -1) :
+                            -1);
+                          
                 tasklet->next = step->next;
                 step->next = tasklet;
                 
@@ -1070,6 +1114,10 @@ static void crm_task_exit(struct task_struct * t)
         unsigned long flags;
         crm_domain_t *cluster = task_cpu_cluster(t);
 
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+        flush_tasklets(cluster, t);
+#endif          
+
         /* unlink if necessary */
         raw_spin_lock_irqsave(&cluster->crm_lock, flags);
         unlink(t);
@@ -1080,10 +1128,6 @@ static void crm_task_exit(struct task_struct * t)
                 tsk_rt(t)->scheduled_on = NO_CPU;
         }
         raw_spin_unlock_irqrestore(&cluster->crm_lock, flags);
-
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-        flush_tasklets(cluster, t);
-#endif  
         
         BUG_ON(!is_realtime(t));
         TRACE_TASK(t, "RIP\n");