adaptive: allow jobs to overrun

Do not forcefully preempt tasks.

1 files changed, 11 insertions, 25 deletions

diff --git a/kernel/sched_adaptive.c b/kernel/sched_adaptive.c
index 1942422452..f31450eaaa 100644
--- a/kernel/sched_adaptive.c
+++ b/kernel/sched_adaptive.c
@@ -333,28 +333,12 @@ static reschedule_check_t adaptive_scheduler_tick(void)
         struct task_struct*     t = current;
         reschedule_check_t      want_resched = NO_RESCHED;
 
-        /* expire tasks even if not in real-time mode
-         * this makes sure that at the end of real-time mode
-         * no task  "runs away forever".
+        /* Account for exec time.
+         * Since we don't preempt forcefully, nothing else needs to be done.
          */
         if (is_realtime(t))
-                TRACE_CUR("before dec: time_slice == %u\n", t->time_slice);
-
-        if (is_realtime(t) && t->time_slice && !--t->time_slice) {              
-                if (!is_np(t)) { /* np tasks will be preempted when they become
-                                    preemptable again */
-                        want_resched = FORCE_RESCHED;
-                        set_will_schedule();
-                        TRACE("adaptive_scheduler_tick: "
-                              "%d is preemptable "
-                              " => FORCE_RESCHED\n", t->pid);                   
-                } else {
-                        TRACE("adaptive_scheduler_tick: "
-                              "%d is non-preemptable, "
-                              "preemption delayed.\n", t->pid);                 
-                        request_exit_np(t);
-                }
-        } 
+                t->rt_param.times.exec_time++;
+
 
         /* only the first CPU needs to release jobs */
         if (get_rt_mode() == MODE_RT_RUN && smp_processor_id() == 0) {
@@ -380,7 +364,10 @@ static noinline void job_completion(struct task_struct *t)
 
         sched_trace_job_completion(t);
 
-        TRACE_TASK(t, "job_completion().\n");
+        TRACE_TASK(t, "job %d completes, delta WCET = %d\n", 
+                   t->rt_param.times.job_no, 
+                   t->rt_param.times.exec_time - 
+                   t->rt_param.basic_params.exec_cost);
 
         /* set flags */
         set_rt_flags(t, RT_F_SLEEP);
@@ -421,7 +408,7 @@ static int adaptive_schedule(struct task_struct * prev,
                          runqueue_t * rq)
 {
         cpu_entry_t*            entry = &__get_cpu_var(adaptive_cpu_entries);
-        int                     out_of_time, sleep, preempt, np, exists, 
+        int                     sleep, preempt, np, exists, 
                                 rt, blocks;
         struct task_struct*     linked;
 
@@ -436,7 +423,6 @@ static int adaptive_schedule(struct task_struct * prev,
         /* (0) Determine state */       
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
-        out_of_time = exists && !entry->scheduled->time_slice;
         np          = exists && is_np(entry->scheduled);
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
@@ -452,7 +438,7 @@ static int adaptive_schedule(struct task_struct * prev,
          * that we are still linked. Multiple calls to request_exit_np() don't
          * hurt.
          */
-        if (np && (out_of_time || preempt || sleep)) {          
+        if (np && (preempt || sleep)) {         
                 unlink(entry->scheduled);
                 request_exit_np(entry->scheduled);
         }
@@ -461,7 +447,7 @@ static int adaptive_schedule(struct task_struct * prev,
          * budget or wants to sleep completes. We may have to reschedule after
          * this.
          */
-        if (!np && (out_of_time || sleep))
+        if (!np && sleep)
                 job_completion(entry->scheduled);               
         
         /* Stop real-time tasks when we leave real-time mode