adaptive: take out all synchronization support

Get rid of inherited GSN synchronization functions.

1 files changed, 14 insertions, 127 deletions

diff --git a/kernel/sched_adaptive.c b/kernel/sched_adaptive.c
index e36d74ae2c..b53de45908 100644
--- a/kernel/sched_adaptive.c
+++ b/kernel/sched_adaptive.c
@@ -586,7 +586,6 @@ static reschedule_check_t adaptive_scheduler_tick(void)
         if (is_realtime(t))
                 t->rt_param.times.exec_time++;
 
-
         /* only the first CPU needs to release jobs */
         if (get_rt_mode() == MODE_RT_RUN) {
                 queue_lock_irqsave(&adaptive_lock, flags);
@@ -666,8 +665,6 @@ static noinline void job_completion(struct task_struct *t)
  *      - !is_running(scheduled)        // the job blocks
  *      - get_rt_flag() == RT_F_SLEEP   // the job completed (by syscall)
  *      - linked != scheduled           // we need to reschedule (for any reason)
- *      - is_np(scheduled)              // rescheduling must be delayed,
- *                                         sys_exit_np must be requested
  *      
  * Any of these can occur together. 
  */
@@ -676,7 +673,7 @@ static int adaptive_schedule(struct task_struct * prev,
                          runqueue_t * rq)
 {
         cpu_entry_t*            entry = &__get_cpu_var(adaptive_cpu_entries);
-        int                     sleep, preempt, np, exists, 
+        int                     sleep, preempt, exists, 
                                 rt, blocks;
         struct task_struct*     linked;
 
@@ -691,7 +688,6 @@ static int adaptive_schedule(struct task_struct * prev,
         /* (0) Determine state */       
         exists      = entry->scheduled != NULL;
         blocks      = exists && !is_running(entry->scheduled);
-        np          = exists && is_np(entry->scheduled);
         sleep       = exists && get_rt_flags(entry->scheduled) == RT_F_SLEEP;
         preempt     = entry->scheduled != entry->linked;
         rt          = get_rt_mode() == MODE_RT_RUN;
@@ -701,21 +697,9 @@ static int adaptive_schedule(struct task_struct * prev,
         if (blocks)
                 unlink(entry->scheduled);
 
-        /* Request a sys_exit_np() call if we would like to preempt but cannot.
-         * We need to make sure to update the link structure anyway in case
-         * that we are still linked. Multiple calls to request_exit_np() don't
-         * hurt.
-         */
-        if (np && (preempt || sleep)) {         
-                unlink(entry->scheduled);
-                request_exit_np(entry->scheduled);
-        }
-
-        /* Any task that is preemptable and either exhausts its execution
-         * budget or wants to sleep completes. We may have to reschedule after
-         * this.
+        /* Task wants to sleep -> job is done.
          */
-        if (!np && sleep)
+        if (sleep)
                 job_completion(entry->scheduled);               
         
         /* Stop real-time tasks when we leave real-time mode 
@@ -737,16 +721,14 @@ static int adaptive_schedule(struct task_struct * prev,
         /* The final scheduling decision. Do we need to switch for some reason?
          * If linked different from scheduled select linked as next.
          */ 
-        if ((!np || blocks) &&
-            entry->linked != entry->scheduled) {
+        if (entry->linked != entry->scheduled) {
                 /* Take care of a previously scheduled
                  * job by taking it out of the Linux runqueue.
                  */
-                if (entry->scheduled) {                 
+                if (entry->scheduled)
                         if (prev->array)
                                 /* take it out of the run queue */
-                                deactivate_task(prev, rq);
-                }
+                                deactivate_task(prev, rq);              
 
                 /* Schedule a linked job? */
                 if (entry->linked) {
@@ -842,23 +824,14 @@ static void adaptive_wake_up_task(struct task_struct *task)
               task->pid, task->time_slice);
         task->state = TASK_RUNNING;
 
-        /* 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.
-         */
-        if (get_rt_flags(task) == RT_F_EXIT_SEM) {
-                set_rt_flags(task, RT_F_RUNNING);
-        } else {
-                if (is_tardy(task)) {
-                        /* new sporadic release */
-                        edf_release_now(task);
-                        sched_trace_job_release(task);
-                }
-                else if (task->time_slice)
-                        /* came back in time before deadline
-                         */
-                        set_rt_flags(task, RT_F_RUNNING);
+        if (is_tardy(task)) {
+                /* new sporadic release */
+                edf_release_now(task);
+                sched_trace_job_release(task);
         }
+        else if (task->time_slice)
+                /* came back in time before deadline */
+                set_rt_flags(task, RT_F_RUNNING);       
 
         queue_lock_irqsave(&adaptive_lock, flags);
         adaptive_job_arrival(task);
@@ -895,90 +868,6 @@ static long adaptive_tear_down(struct task_struct * t)
         return 0;
 }
 
-static long adaptive_pi_block(struct pi_semaphore *sem,
-                            struct task_struct *new_waiter)
-{
-        /* This callback has to handle the situation where a new waiter is 
-         * added to the wait queue of the semaphore.
-         * 
-         * We must check if has a higher priority than the currently 
-         * highest-priority task, and then potentially reschedule.
-         */
-
-        BUG_ON(!new_waiter);
-
-        if (edf_higher_prio(new_waiter, sem->hp.task)) {
-                TRACE_TASK(new_waiter, " boosts priority\n");
-                /* called with IRQs disabled */
-                queue_lock(&adaptive_lock);
-                /* store new highest-priority task */
-                sem->hp.task = new_waiter;
-                if (sem->holder) {
-                        /* let holder inherit */
-                        sem->holder->rt_param.inh_task = new_waiter;
-                        unlink(sem->holder);
-                        adaptive_job_arrival(sem->holder);
-                }
-                queue_unlock(&adaptive_lock);   
-        }
-
-        return 0;
-}
-
-static long adaptive_inherit_priority(struct pi_semaphore *sem,
-                                    struct task_struct *new_owner)
-{
-        /* We don't need to acquire the adaptive_lock since at the time of this
-         * call new_owner isn't actually scheduled yet (it's still sleeping) 
-         * and since the calling function already holds sem->wait.lock, which 
-         * prevents concurrent sem->hp.task changes.
-         */
-
-        if (sem->hp.task && sem->hp.task != new_owner) {        
-                new_owner->rt_param.inh_task = sem->hp.task;
-                TRACE_TASK(new_owner, "inherited priority from %s/%d\n", 
-                           sem->hp.task->comm, sem->hp.task->pid);
-        } else
-                TRACE_TASK(new_owner, 
-                           "cannot inherit priority, "
-                           "no higher priority job waits.\n");
-        return 0;
-}
-
-/* This function is called on a semaphore release, and assumes that
- * the current task is also the semaphore holder.
- */
-static long adaptive_return_priority(struct pi_semaphore *sem)
-{
-        struct task_struct* t = current;
-        int ret = 0;
-
-        /* Find new highest-priority semaphore task
-         * if holder task is the current hp.task.
-         *
-         * Calling function holds sem->wait.lock.
-         */
-        if (t == sem->hp.task)
-                edf_set_hp_task(sem);
-
-        TRACE_CUR("adaptive_return_priority for lock %p\n", sem);
-
-        if (t->rt_param.inh_task) {
-                /* interrupts already disabled by PI code */
-                queue_lock(&adaptive_lock);
-                
-                /* Reset inh_task to NULL. */
-                t->rt_param.inh_task = NULL;
-                
-                /* Check if rescheduling is necessary */
-                unlink(t);
-                adaptive_job_arrival(t);
-                queue_unlock(&adaptive_lock);
-        }       
-
-        return ret;
-}
-
 static int adaptive_mode_change(int new_mode)
 {
         unsigned long flags;
@@ -1034,9 +923,6 @@ static sched_plugin_t s_plugin __cacheline_aligned_in_smp = {
         .mode_change            = adaptive_mode_change,         \
         .wake_up_task           = adaptive_wake_up_task,        \
         .task_blocks            = adaptive_task_blocks,         \
-        .inherit_priority       = adaptive_inherit_priority,    \
-        .return_priority        = adaptive_return_priority,     \
-        .pi_block               = adaptive_pi_block             \
 }
 
 
@@ -1045,6 +931,7 @@ sched_plugin_t *__init init_adaptive_plugin(void)
         int cpu;
         cpu_entry_t *entry;
 
+        /* magic values given in the paper */
         fc_a = _frac(  102, 1000);
         fc_b = _frac(-1975, 1000);