Implementation of the EDZL scheduler.wip-edzl-final

Implementation of the EDZL scheduler.  Zero-laxity points are
tracked by timers while jobs are in the pending state.  Locking
primatives are not supported.

1 files changed, 3 insertions, 67 deletions

diff --git a/litmus/sched_gsn_edf.c b/litmus/sched_gsn_edf.c
index 7876d707d939..e4d17da0160a 100644
--- a/litmus/sched_gsn_edf.c
+++ b/litmus/sched_gsn_edf.c
@@ -63,76 +63,12 @@ static struct sched_global_plugin gsn_edf_plugin __cacheline_aligned_in_smp = {
     .take_ready = __take_ready,
     .add_ready = __add_ready,
     .job_arrival = gblv_job_arrival,
-    .job_completion = gbl_job_completion
+    .job_completion = gbl_job_completion,
+    .preemption_needed = gblv_preemption_needed
 };
 
 
 #ifdef CONFIG_FMLP
-/* Update the queue position of a task that got it's priority boosted via
- * priority inheritance. */
-static void update_queue_position(struct task_struct *holder)
-{
-        /* We don't know whether holder is in the ready queue. It should, but
-         * on a budget overrun it may already be in a release queue.  Hence,
-         * calling unlink() is not possible since it assumes that the task is
-         * not in a release queue.  However, we can safely check whether
-         * sem->holder is currently in a queue or scheduled after locking both
-         * the release and the ready queue lock. */
-
-        /* Assumption: caller holds gsnedf_lock */
-
-        int check_preempt = 0;
-
-        if (tsk_rt(holder)->linked_on != NO_CPU) {
-                TRACE_TASK(holder, "%s: linked  on %d\n",
-                           __FUNCTION__, tsk_rt(holder)->linked_on);
-                /* Holder is scheduled; need to re-order CPUs.
-                 * We can't use heap_decrease() here since
-                 * the cpu_heap is ordered in reverse direction, so
-                 * it is actually an increase. */
-                bheap_delete(gbl_cpu_lower_prio, &gsn_edf_plugin.cpu_heap,
-                            gsn_edf_plugin.cpus[tsk_rt(holder)->linked_on]->hn);
-                bheap_insert(gbl_cpu_lower_prio, &gsn_edf_plugin.cpu_heap,
-                            gsn_edf_plugin.cpus[tsk_rt(holder)->linked_on]->hn);
-        } else {
-                /* holder may be queued: first stop queue changes */
-                raw_spin_lock(&gsn_edf_plugin.domain.release_lock);
-                if (is_queued(holder)) {
-                        TRACE_TASK(holder, "%s: is queued\n",
-                                   __FUNCTION__);
-                        /* We need to update the position
-                         * of holder in some heap. Note that this
-                         * may be a release heap. */
-                        check_preempt =
-                                !bheap_decrease(edf_ready_order,
-                                               tsk_rt(holder)->heap_node);
-                } else {
-                        /* Nothing to do: if it is not queued and not linked
-                         * then it is currently being moved by other code
-                         * (e.g., a timer interrupt handler) that will use the
-                         * correct priority when enqueuing the task. */
-                        TRACE_TASK(holder, "%s: is NOT queued => Done.\n",
-                                   __FUNCTION__);
-                }
-                raw_spin_unlock(&gsn_edf_plugin.domain.release_lock);
-
-                /* If holder was enqueued in a release heap, then the following
-                 * preemption check is pointless, but we can't easily detect
-                 * that case. If you want to fix this, then consider that
-                 * simply adding a state flag requires O(n) time to update when
-                 * releasing n tasks, which conflicts with the goal to have
-                 * O(log n) merges. */
-                if (check_preempt) {
-                        /* heap_decrease() hit the top level of the heap: make
-                         * sure preemption checks get the right task, not the
-                         * potentially stale cache. */
-                        bheap_uncache_min(gbl_ready_order,
-                                         &gsn_edf_plugin.domain.ready_queue);
-                        gbl_check_for_preemptions();
-                }
-        }
-}
-
 static long gsnedf_pi_block(struct pi_semaphore *sem,
                             struct task_struct *new_waiter)
 {
@@ -158,7 +94,7 @@ static long gsnedf_pi_block(struct pi_semaphore *sem,
                                    new_waiter->comm, new_waiter->pid);
                         /* let holder inherit */
                         sem->holder->rt_param.inh_task = new_waiter;
-                        update_queue_position(sem->holder);
+                        gbl_update_queue_position(sem->holder);
                 }
                 raw_spin_unlock(&gsnedf_lock);
         }