Removed bug from edf-wm code

Updated the code to remove the condition that was causing soft-lockup
problem.

2 files changed, 44 insertions, 19 deletions

diff --git a/litmus/jobs.c b/litmus/jobs.c
index 92ba04bea1b2..4eed6e04fe0e 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -13,9 +13,10 @@ void prepare_for_next_period(struct task_struct *t)
         t->rt_param.job_params.release   = t->rt_param.job_params.deadline;
         t->rt_param.job_params.deadline += get_rt_period(t);
         t->rt_param.job_params.exec_time = 0;
+        t->rt_param.job_params.exec_time_curr_cpu = 0;
         /* update job sequence number */
         t->rt_param.job_params.job_no++;
-
+        t->rt_param.job_params.execs[0] = t->rt_param.task_params.exec_cost;
         /* don't confuse Linux */
         t->rt.time_slice = 1;
 }
@@ -66,8 +67,8 @@ long complete_job(void)
 
 void prepare_next_slice(struct task_struct *t, int new_release)
 {
+        int i;
         BUG_ON(!t);
-        int i=0;
 
         if(t->rt_param.job_params.job_no == 0){
                 /* This is the first job of this task. Update all parameters such as release time, deadline for each slice. */
diff --git a/litmus/sched_edf_wm.c b/litmus/sched_edf_wm.c
index 9ce0ebd97af5..64447f50f6ae 100644
--- a/litmus/sched_edf_wm.c
+++ b/litmus/sched_edf_wm.c
@@ -52,6 +52,7 @@ DEFINE_PER_CPU(edfwm_domain_t, edfwm_domains);
 
 static enum hrtimer_restart on_release_timer(struct hrtimer *timer)
 {
+        TRACE("calling scheduler_tick() after timer expiry, %llu \n", litmus_clock());
         scheduler_tick();
         return HRTIMER_NORESTART;
 }
@@ -162,15 +163,26 @@ static int edfwm_check_resched(rt_domain_t *edf)
 static int job_completion(struct task_struct* t,int forced)
 {
         lt_t now;
+        int t_flag=0;
+        edfwm_domain_t *edfwm = local_edfwm;
+
         sched_trace_task_completion(t,forced);
         TRACE_TASK(t, "job_completion().\n");
         now = litmus_clock();
+
+        if(edfwm->timer_flag == 1){
+                hrtimer_try_to_cancel(&edfwm->timer);
+        }
+
         if(is_tardy(t,now)){
                 TRACE_TASK(t,"became tardy\n");
+                t_flag=1;
                 if(t->rt_param.task_params.curr == t->rt_param.task_params.count -1 )
                         TRACE_TASK(t,"Task deadline, %llu, finished on %llu, Deadline miss for the job\n",t->rt_param.job_params.deadline,now);
                 else
                         TRACE_TASK(t,"Task deadline, %llu, finished on %llu, Deadline miss for the subjob: %d\n",t->rt_param.job_params.deadline,now,t->rt_param.task_params.curr);
+                //release_at(t, now);
+
         }
         set_rt_flags(t, RT_F_SLEEP);
 
@@ -186,9 +198,12 @@ static int job_completion(struct task_struct* t,int forced)
         else{
 
                 t->rt_param.job_params.exec_time = 0;
+                if(t_flag == 1)
+                        t->rt_param.job_params.deadline = litmus_clock();
                 prepare_for_next_period(t);
-                return 0;
+                return 2;
         }
+        return 0;
 }
 
 
@@ -199,7 +214,7 @@ static void edfwm_tick(struct task_struct *t)
         lt_t now, exec_time, exec_cost;
         int curr,count=1;
         int flag = 1;
-        int block = edfwm->block;
+        //int block = edfwm->block;
         BUG_ON(!t);
         BUG_ON(is_realtime(t) && t != edfwm->scheduled);
 
@@ -223,10 +238,11 @@ static void edfwm_tick(struct task_struct *t)
 
         if (is_realtime(t) && flag) {
 
-                if(count > 1){
+/*              if(count > 1)
+                {
                         TRACE_TASK(t,"edfwm tick: trying to stop timer (0x%p); end: %llu , at %llu\n",&edfwm->timer,edfwm->end_timer, litmus_clock());
                         hrtimer_try_to_cancel(&edfwm->timer);
-                }
+                }*/
                 if (!is_np(t)) {
                         set_tsk_need_resched(t);
                         TRACE("edfwm_scheduler_tick: "
@@ -240,14 +256,16 @@ static void edfwm_tick(struct task_struct *t)
                 }
         }
         now = litmus_clock();
-        if(block != 1 && count > 1 && flag ==0 && edfwm->end_timer <= now && t->state == TASK_RUNNING){
+/*      if(count>1){
+        if(block != 1  && count > 1 && flag ==0 && edfwm->end_timer <= now && t->state == TASK_RUNNING){
                 edfwm->end_timer = now + t->rt_param.job_params.execs[t->rt_param.task_params.curr] - t->rt_param.job_params.exec_time_curr_cpu;
-                if(edfwm->end_timer - now > 1000){
+                if(edfwm->end_timer - now > 1000 && !edfwm->timer_flag){
                         __hrtimer_start_range_ns(&edfwm->timer,ns_to_ktime(edfwm->end_timer),0,HRTIMER_MODE_ABS_PINNED,0);
                         edfwm->timer_flag = 1;
                         TRACE_TASK(t,"edfwm tick: timer (0x%p) started at : %llu, should go off at %llu \n",&edfwm->timer,now,edfwm->end_timer);
                 }
         }
+        }*/
 }
 
 
@@ -274,11 +292,11 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
          * edfwm->schedule may be null and prev _is_ realtime
          */
 
-        /*if(edfwm->scheduled && edfwm->scheduled != prev){
+        if(edfwm->scheduled && edfwm->scheduled != prev){
                 edfwm->scheduled = NULL;
-                spin_unlock(&edfwm->slock);
+                raw_spin_unlock(&edfwm->slock);
                 return NULL;
-        }*/
+        }
 
         BUG_ON(edfwm->scheduled && edfwm->scheduled != prev);
         BUG_ON(edfwm->scheduled && !is_realtime(prev));
@@ -337,6 +355,7 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
          * budget or wants to sleep completes. We may have to reschedule after
          * this.
          */
+//      TRACE_TASK(edfwm->scheduled, "out of time: %d, sleep: %d, NP: %d, !blocks: %d\n",out_of_time, sleep, np, !blocks);
         if (!np && (out_of_time || sleep) && !blocks) {
 
                 TRACE_TASK(edfwm->scheduled,"NP: %d, out_of_time: %d, sleep: %d,blocks: %d\n",np,out_of_time,sleep,blocks);
@@ -364,7 +383,7 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
                         remove(edf,edfwm->scheduled);
 
                 if (edfwm->scheduled && !blocks && !complete && smp_processor_id() == edfwm->scheduled->rt_param.task_params.cpu){
-                        TRACE_TASK(edfwm->scheduled," task requeued on %d\n",smp_processor_id());
+                        TRACE_TASK(edfwm->scheduled," task kept on %d(same cpu)\n",smp_processor_id());
                         requeue(edfwm->scheduled, edf,edfwm);
                 }
 
@@ -375,6 +394,7 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
                 if(complete)
                 {
                         edf1 = task_edf(edfwm->scheduled);
+                        TRACE_TASK(edfwm->scheduled," task requeued on %d\n",smp_processor_id());
                         requeue(edfwm->scheduled,edf1,edfwm);
                 }
 
@@ -391,18 +411,22 @@ static struct task_struct* edfwm_schedule(struct task_struct * prev)
                         next = prev;
 
         if (next) {
-
+                now = litmus_clock();
                 TRACE_TASK(next, "edfwm scheduled at %llu\n", litmus_clock());
+                TRACE_TASK(next, "resched: %d, exists: %d,  NP: %d, out of time: %d, sleep: %d, complete: %d, !blocks: %d\n",resched, exists,np,out_of_time, sleep, complete, !blocks);
                 set_rt_flags(next, RT_F_RUNNING);
 
-                if(next->rt_param.task_params.count > 1){
-                        if((out_of_time || sleep) && complete && !blocks){
-                                now = litmus_clock();
+//              if(next->rt_param.task_params.count > 1)
+                {
+                        if(((out_of_time || sleep) && complete && !blocks) || next->rt_param.job_params.job_no==2){
                                 edfwm->end_timer = now + next->rt_param.job_params.execs[next->rt_param.task_params.curr];
-                                if(edfwm->end_timer - now > 1000){
+                                if(edfwm->end_timer - now < 100)
+                                        edfwm->end_timer =  now + 100;
+//                              if(edfwm->end_timer - now > 100 && !edfwm->timer_flag){
+                                if(!edfwm->timer_flag){
                                         __hrtimer_start_range_ns(&edfwm->timer,ns_to_ktime(edfwm->end_timer),0,HRTIMER_MODE_ABS_PINNED,0);
                                         edfwm->timer_flag = 1;
-                                        TRACE_TASK(next,"edfwm schedule: timer(0x%p) started at : %llu, should go off at %llu \n",&edfwm->timer,now,edfwm->end_timer);
+                                        TRACE_TASK(next,"edfwm schedule: timer(0x%p) started at : %llu, should go off at %llu , diff= %llu, required exec: %llu\n",&edfwm->timer,now,edfwm->end_timer,edfwm->end_timer-now, next->rt_param.job_params.execs[next->rt_param.task_params.curr]);
                                 }
                         }
                 }
@@ -546,7 +570,7 @@ static void edfwm_task_block(struct task_struct *t)
         TRACE_TASK(t, "block at %llu, state=%d\n", litmus_clock(), t->state);
 
         BUG_ON(!is_realtime(t));
-        BUG_ON(is_queued(t));
+        //BUG_ON(is_queued(t));
 }
 
 static void edfwm_task_exit(struct task_struct * t)