Remove FMLP support from C-EDF.

There is no published protocol for FMLP/C-EDF.

1 files changed, 0 insertions, 163 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 4c22e26241d9..c715ec1e0ee2 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -582,163 +582,6 @@ static void cedf_task_exit(struct task_struct * t)
         TRACE_TASK(t, "RIP\n");
 }
 
-#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 cedf_lock */
-
-        int check_preempt = 0;
-        cedf_domain_t *cluster = task_cpu_cluster(holder);
-
-        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(cpu_lower_prio, &cluster->cpu_heap,
-                            cluster->cpus[tsk_rt(holder)->linked_on]->hn);
-                bheap_insert(cpu_lower_prio, &cluster->cpu_heap,
-                            cluster->cpus[tsk_rt(holder)->linked_on]->hn);
-        } else {
-                /* holder may be queued: first stop queue changes */
-                spin_lock(&cluster->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__);
-                }
-                spin_unlock(&cluster->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(edf_ready_order,
-                                         &cluster->domain.ready_queue);
-                        check_for_preemptions(cluster);
-                }
-        }
-}
-
-static long cedf_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 via %p\n", sem);
-                /* called with IRQs disabled */
-                spin_lock(&task_cpu_cluster(new_waiter)->lock);
-                /* store new highest-priority task */
-                sem->hp.task = new_waiter;
-                if (sem->holder) {
-                        TRACE_TASK(sem->holder,
-                                   " holds %p and will inherit from %s/%d\n",
-                                   sem,
-                                   new_waiter->comm, new_waiter->pid);
-                        /* let holder inherit */
-                        sem->holder->rt_param.inh_task = new_waiter;
-                        update_queue_position(sem->holder);
-                }
-                spin_unlock(&task_cpu_cluster(new_waiter)->lock);
-        }
-
-        return 0;
-}
-
-static long cedf_inherit_priority(struct pi_semaphore *sem,
-                                    struct task_struct *new_owner)
-{
-        /* We don't need to acquire the cedf_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 cedf_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("cedf_return_priority for lock %p\n", sem);
-
-        if (t->rt_param.inh_task) {
-                /* interrupts already disabled by PI code */
-                spin_lock(&task_cpu_cluster(t)->lock);
-
-                /* Reset inh_task to NULL. */
-                t->rt_param.inh_task = NULL;
-
-                /* Check if rescheduling is necessary */
-                unlink(t);
-                cedf_job_arrival(t);
-                spin_unlock(&task_cpu_cluster(t)->lock);
-        }
-
-        return ret;
-}
-
-#endif
-
 static long cedf_admit_task(struct task_struct* tsk)
 {
         return 0;
@@ -893,12 +736,6 @@ static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
         .schedule               = cedf_schedule,
         .task_wake_up           = cedf_task_wake_up,
         .task_block             = cedf_task_block,
-#ifdef CONFIG_FMLP
-        .fmlp_active            = 1,
-        .pi_block               = cedf_pi_block,
-        .inherit_priority       = cedf_inherit_priority,
-        .return_priority        = cedf_return_priority,
-#endif
         .admit_task             = cedf_admit_task,
         .activate_plugin        = cedf_activate_plugin,
         .deactivate_plugin      = cedf_deactivate_plugin,