1 files changed, 0 insertions, 343 deletions

diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index 00dabbf65af7..69bba98dc664 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -75,10 +75,6 @@
 #include <litmus/litmus_softirq.h>
 #endif
 
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-#include <linux/interrupt.h>
-#endif
-
 #ifdef CONFIG_LITMUS_NVIDIA
 #include <litmus/nvidia_info.h>
 #endif
@@ -136,10 +132,6 @@ typedef struct clusterdomain {
 
 #define cluster_lock domain.ready_lock
 
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-        struct tasklet_head pending_tasklets;
-#endif
-
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         raw_spinlock_t dgl_lock;
 #endif
@@ -1103,303 +1095,6 @@ static void cedf_tick(struct task_struct* t)
         }
 }
 
-
-
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-
-static void __do_lit_tasklet(struct tasklet_struct* tasklet, unsigned long flushed)
-{
-        if (!atomic_read(&tasklet->count)) {
-                if(tasklet->owner) {
-                        sched_trace_tasklet_begin(tasklet->owner);
-                }
-
-                if (!test_and_clear_bit(TASKLET_STATE_SCHED, &tasklet->state))
-                {
-                        BUG();
-                }
-                TRACE("%s: Invoking tasklet with owner pid = %d (flushed = %d).\n",
-                          __FUNCTION__,
-                          (tasklet->owner) ? tasklet->owner->pid : 0,
-                          (tasklet->owner) ? 0 : 1);
-                tasklet->func(tasklet->data);
-                tasklet_unlock(tasklet);
-
-                if(tasklet->owner) {
-                        sched_trace_tasklet_end(tasklet->owner, flushed);
-                }
-        }
-        else {
-                BUG();
-        }
-}
-
-
-static void do_lit_tasklets(cedf_domain_t* cluster, struct task_struct* sched_task)
-{
-        int work_to_do = 1;
-        struct tasklet_struct *tasklet = NULL;
-        unsigned long flags;
-
-        while(work_to_do) {
-
-                TS_NV_SCHED_BOTISR_START;
-
-                raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
-
-                if(cluster->pending_tasklets.head != NULL) {
-                        // remove tasklet at head.
-                        struct tasklet_struct *prev = NULL;
-                        tasklet = cluster->pending_tasklets.head;
-
-                        // find a tasklet with prio to execute; skip ones where
-                        // sched_task has a higher priority.
-                        // We use the '!edf' test instead of swaping function arguments since
-                        // both sched_task and owner could be NULL.  In this case, we want to
-                        // still execute the tasklet.
-                        while(tasklet && !edf_higher_prio(tasklet->owner, sched_task)) {
-                                prev = tasklet;
-                                tasklet = tasklet->next;
-                        }
-
-                        if(tasklet) {  // found something to execuite
-                                // remove the tasklet from the queue
-                                if(prev) {
-                                        prev->next = tasklet->next;
-                                        if(prev->next == NULL) {
-                                                TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
-                                                cluster->pending_tasklets.tail = &(prev);
-                                        }
-                                }
-                                else {
-                                        cluster->pending_tasklets.head = tasklet->next;
-                                        if(tasklet->next == NULL) {
-                                                TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
-                                                cluster->pending_tasklets.tail = &(cluster->pending_tasklets.head);
-                                        }
-                                }
-                        }
-                        else {
-                                TRACE("%s: No tasklets with eligible priority.\n", __FUNCTION__);
-                        }
-                }
-                else {
-                        TRACE("%s: Tasklet queue is empty.\n", __FUNCTION__);
-                }
-
-                raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
-
-                if(tasklet) {
-                        __do_lit_tasklet(tasklet, 0ul);
-                        tasklet = NULL;
-                }
-                else {
-                        work_to_do = 0;
-                }
-
-                TS_NV_SCHED_BOTISR_END;
-        }
-}
-
-static void __add_pai_tasklet(struct tasklet_struct* tasklet, cedf_domain_t* cluster)
-{
-        struct tasklet_struct* step;
-
-        tasklet->next = NULL;  // make sure there are no old values floating around
-
-        step = cluster->pending_tasklets.head;
-        if(step == NULL) {
-                TRACE("%s: tasklet queue empty.  inserting tasklet for %d at head.\n", __FUNCTION__, tasklet->owner->pid);
-                // insert at tail.
-                *(cluster->pending_tasklets.tail) = tasklet;
-                cluster->pending_tasklets.tail = &(tasklet->next);
-        }
-        else if((*(cluster->pending_tasklets.tail) != NULL) &&
-                        edf_higher_prio((*(cluster->pending_tasklets.tail))->owner, tasklet->owner)) {
-                // insert at tail.
-                TRACE("%s: tasklet belongs at end.  inserting tasklet for %d at tail.\n", __FUNCTION__, tasklet->owner->pid);
-
-                *(cluster->pending_tasklets.tail) = tasklet;
-                cluster->pending_tasklets.tail = &(tasklet->next);
-        }
-        else {
-
-                // insert the tasklet somewhere in the middle.
-
-        TRACE("%s: tasklet belongs somewhere in the middle.\n", __FUNCTION__);
-
-                while(step->next && edf_higher_prio(step->next->owner, tasklet->owner)) {
-                        step = step->next;
-                }
-
-                // insert tasklet right before step->next.
-
-                TRACE("%s: inserting tasklet for %d between %d and %d.\n", __FUNCTION__,
-                          tasklet->owner->pid,
-                          (step->owner) ?
-                          step->owner->pid :
-                          -1,
-                          (step->next) ?
-                          ((step->next->owner) ?
-                           step->next->owner->pid :
-                           -1) :
-                          -1);
-
-                tasklet->next = step->next;
-                step->next = tasklet;
-
-                // patch up the head if needed.
-                if(cluster->pending_tasklets.head == step)
-                {
-                        TRACE("%s: %d is the new tasklet queue head.\n", __FUNCTION__, tasklet->owner->pid);
-                        cluster->pending_tasklets.head = tasklet;
-                }
-        }
-}
-
-static void cedf_run_tasklets(struct task_struct* sched_task)
-{
-        cedf_domain_t* cluster;
-
-        preempt_disable();
-
-        cluster = (is_realtime(sched_task)) ?
-                task_cpu_cluster(sched_task) :
-                remote_cluster(smp_processor_id());
-
-        if(cluster && cluster->pending_tasklets.head != NULL) {
-                TRACE("%s: There are tasklets to process.\n", __FUNCTION__);
-                do_lit_tasklets(cluster, sched_task);
-        }
-
-        preempt_enable_no_resched();
-}
-
-
-
-static int cedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
-{
-#if 0
-        cedf_domain_t *cluster = NULL;
-        cpu_entry_t *targetCPU = NULL;
-        int thisCPU;
-        int runLocal = 0;
-        int runNow = 0;
-        unsigned long flags;
-
-    if(unlikely((tasklet->owner == NULL) || !is_realtime(tasklet->owner)))
-    {
-        TRACE("%s: No owner associated with this tasklet!\n", __FUNCTION__);
-                return 0;
-    }
-
-        cluster = task_cpu_cluster(tasklet->owner);
-
-        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
-
-        thisCPU = smp_processor_id();
-
-#ifdef CONFIG_SCHED_CPU_AFFINITY
-        {
-                cpu_entry_t* affinity = NULL;
-
-                // use this CPU if it is in our cluster and isn't running any RT work.
-                if(cpu_isset(thisCPU, *cluster->cpu_map) && (__get_cpu_var(cedf_cpu_entries).linked == NULL)) {
-                        affinity = &(__get_cpu_var(cedf_cpu_entries));
-                }
-                else {
-                        // this CPU is busy or shouldn't run tasklet in this cluster.
-                        // look for available near by CPUs.
-                        // NOTE: Affinity towards owner and not this CPU.  Is this right?
-                        affinity =
-                                cedf_get_nearest_available_cpu(cluster,
-                                                                &per_cpu(cedf_cpu_entries, task_cpu(tasklet->owner)));
-                }
-
-                targetCPU = affinity;
-        }
-#endif
-
-        if (targetCPU == NULL) {
-                targetCPU = lowest_prio_cpu(cluster);
-        }
-
-        if (edf_higher_prio(tasklet->owner, targetCPU->linked)) {
-                if (thisCPU == targetCPU->cpu) {
-                        TRACE("%s: Run tasklet locally (and now).\n", __FUNCTION__);
-                        runLocal = 1;
-                        runNow = 1;
-                }
-                else {
-                        TRACE("%s: Run tasklet remotely (and now).\n", __FUNCTION__);
-                        runLocal = 0;
-                        runNow = 1;
-                }
-        }
-        else {
-                runLocal = 0;
-                runNow = 0;
-        }
-
-        if(!runLocal) {
-                // enqueue the tasklet
-                __add_pai_tasklet(tasklet, cluster);
-        }
-
-        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
-
-
-        if (runLocal /*&& runNow */) {  // runNow == 1 is implied
-                TRACE("%s: Running tasklet on CPU where it was received.\n", __FUNCTION__);
-                __do_lit_tasklet(tasklet, 0ul);
-        }
-        else if (runNow /*&& !runLocal */) {  // runLocal == 0 is implied
-                TRACE("%s: Triggering CPU %d to run tasklet.\n", __FUNCTION__, targetCPU->cpu);
-                preempt(targetCPU);  // need to be protected by cluster_lock?
-        }
-        else {
-                TRACE("%s: Scheduling of tasklet was deferred.\n", __FUNCTION__);
-        }
-#else
-        TRACE("%s: Running tasklet on CPU where it was received.\n", __FUNCTION__);
-        __do_lit_tasklet(tasklet, 0ul);
-#endif
-        return(1); // success
-}
-
-static void cedf_change_prio_pai_tasklet(struct task_struct *old_prio,
-                                                                                 struct task_struct *new_prio)
-{
-        struct tasklet_struct* step;
-        unsigned long flags;
-        cedf_domain_t *cluster;
-        struct task_struct *probe;
-
-        // identify the cluster by the assignment of these tasks.  one should
-        // be non-NULL.
-        probe = (old_prio) ? old_prio : new_prio;
-
-        if(probe) {
-                cluster = task_cpu_cluster(probe);
-
-                if(cluster->pending_tasklets.head != NULL) {
-                        raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
-                        for(step = cluster->pending_tasklets.head; step != NULL; step = step->next) {
-                                if(step->owner == old_prio) {
-                                        TRACE("%s: Found tasklet to change: %d\n", __FUNCTION__, step->owner->pid);
-                                        step->owner = new_prio;
-                                }
-                        }
-                        raw_readyq_unlock_irqrestore(&cluster->cluster_lock, flags);
-                }
-        }
-        else {
-                TRACE("%s: Both priorities were NULL\n");
-        }
-}
-
-#endif  // PAI
-
 #ifdef CONFIG_LITMUS_LOCKING
 static int __increase_priority_inheritance(struct task_struct* t, struct task_struct* prio_inh);
 #endif
@@ -1791,10 +1486,6 @@ static void cedf_task_exit(struct task_struct * t)
         unsigned long flags;
         cedf_domain_t *cluster = task_cpu_cluster(t);
 
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-        cedf_change_prio_pai_tasklet(t, NULL);
-#endif
-
         /* unlink if necessary */
         raw_readyq_lock_irqsave(&cluster->cluster_lock, flags);
 
@@ -2120,17 +1811,6 @@ static void increase_priority_inheritance(struct task_struct* t, struct task_str
         __increase_priority_inheritance(t, prio_inh);
 
         raw_readyq_unlock(&cluster->cluster_lock);
-
-#if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
-        if(tsk_rt(t)->held_gpus) {
-                int i;
-                for(i = find_first_bit(&tsk_rt(t)->held_gpus, BITS_PER_BYTE*sizeof(tsk_rt(t)->held_gpus));
-                        i < NV_DEVICE_NUM;
-                        i = find_next_bit(&tsk_rt(t)->held_gpus, BITS_PER_BYTE*sizeof(tsk_rt(t)->held_gpus), i+1)) {
-                        pai_check_priority_increase(t, i);
-                }
-        }
-#endif
 }
 
 /* called with IRQs off */
@@ -2294,17 +1974,6 @@ static void decrease_priority_inheritance(struct task_struct* t,
         __decrease_priority_inheritance(t, prio_inh, budget_tiggered);
 
         raw_readyq_unlock(&cluster->cluster_lock);
-
-#if defined(CONFIG_LITMUS_PAI_SOFTIRQD) && defined(CONFIG_LITMUS_NVIDIA)
-        if(tsk_rt(t)->held_gpus) {
-                int i;
-                for(i = find_first_bit(&tsk_rt(t)->held_gpus, BITS_PER_BYTE*sizeof(tsk_rt(t)->held_gpus));
-                        i < NV_DEVICE_NUM;
-                        i = find_next_bit(&tsk_rt(t)->held_gpus, BITS_PER_BYTE*sizeof(tsk_rt(t)->held_gpus), i+1)) {
-                        pai_check_priority_decrease(t, i);
-                }
-        }
-#endif
 }
 
 
@@ -2740,13 +2409,6 @@ static long cedf_activate_plugin(void)
                 INIT_BINHEAP_HANDLE(&(cedf[i].cpu_heap), cpu_lower_prio);
                 edf_domain_init(&(cedf[i].domain), NULL, cedf_release_jobs);
 
-
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-                cedf[i].pending_tasklets.head = NULL;
-                cedf[i].pending_tasklets.tail = &(cedf[i].pending_tasklets.head);
-#endif
-
-
                 if(!zalloc_cpumask_var(&cedf[i].cpu_map, GFP_ATOMIC))
                         return -ENOMEM;
 #ifdef CONFIG_RELEASE_MASTER
@@ -2864,11 +2526,6 @@ static struct sched_plugin cedf_plugin __cacheline_aligned_in_smp = {
 #ifdef CONFIG_LITMUS_AFFINITY_LOCKING
         .allocate_aff_obs = cedf_allocate_affinity_observer,
 #endif
-#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
-        .enqueue_pai_tasklet = cedf_enqueue_pai_tasklet,
-        .change_prio_pai_tasklet = cedf_change_prio_pai_tasklet,
-        .run_tasklets = cedf_run_tasklets,
-#endif
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_SOFTIRQD)
         .map_gpu_to_cpu = cedf_map_gpu_to_cpu,
 #endif