experimental changes to support GPUs under SRPwip-gpu-rtss12-srp

Seems to fail due to locking within GPU driver.

2 files changed, 126 insertions, 3 deletions

diff --git a/litmus/litmus_pai_softirq.c b/litmus/litmus_pai_softirq.c
index 300571a81bbd..1ee5f73a2991 100644
--- a/litmus/litmus_pai_softirq.c
+++ b/litmus/litmus_pai_softirq.c
@@ -17,9 +17,29 @@
 #include <litmus/litmus_softirq.h>
 
 
+static void __do_lit_tasklet(struct tasklet_struct* tasklet)
+{
+        if (!atomic_read(&tasklet->count)) {
+                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 : -1,
+                          (tasklet->owner) ? 0 : 1);
+                tasklet->func(tasklet->data);
+                tasklet_unlock(tasklet);
+        }
+        else {
+                BUG();
+        }
+}
+
 
 int __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
 {
+#if 0
         int ret = 0; /* assume failure */
     if(unlikely((t->owner == NULL) || !is_realtime(t->owner)))
     {
@@ -28,8 +48,11 @@ int __litmus_tasklet_schedule(struct tasklet_struct *t, unsigned int k_id)
     }
 
     ret = litmus->enqueue_pai_tasklet(t);
-
         return(ret);
+#else
+        __do_lit_tasklet(t);
+        return(1);
+#endif
 }
 
 EXPORT_SYMBOL(__litmus_tasklet_schedule);
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 8e4a22dd8d6a..573214d74794 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -22,6 +22,22 @@
 #include <litmus/sched_trace.h>
 #include <litmus/trace.h>
 
+
+#ifdef CONFIG_LITMUS_SOFTIRQD
+#include <litmus/litmus_softirq.h>
+#endif
+
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+#include <linux/interrupt.h>
+#include <litmus/trace.h>
+#endif
+
+#ifdef CONFIG_LITMUS_NVIDIA
+#include <litmus/nvidia_info.h>
+#endif
+
+
+
 typedef struct {
         rt_domain_t             domain;
         int                     cpu;
@@ -130,6 +146,73 @@ static void unboost_priority(struct task_struct* t)
         raw_spin_unlock_irqrestore(&pedf->slock, flags);
 }
 
+
+
+
+
+
+
+
+#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 : -1,
+                          (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 psnedf_run_tasklets(struct task_struct* sched_task)
+{
+        // stub
+}
+
+
+
+static int psnedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
+{
+        // kludge: we run all nvidia tasklets immediatly
+        TRACE("%s: Running tasklet on CPU where it was received.\n", __FUNCTION__);
+        __do_lit_tasklet(tasklet, 0ul);
+
+        return(1); // success
+}
+
+static void psnedf_change_prio_pai_tasklet(struct task_struct *old_prio,
+                                                                                 struct task_struct *new_prio)
+{
+        // stub
+}
+
+#endif  // PAI
+
+
+
+
+
+
 #endif
 
 /* This check is trivial in partioned systems as we only have to consider
@@ -259,10 +342,10 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
                         next = prev;
 
         if (next) {
-                TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
+//              TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
                 set_rt_flags(next, RT_F_RUNNING);
         } else {
-                TRACE("becoming idle at %llu\n", litmus_clock());
+//              TRACE("becoming idle at %llu\n", litmus_clock());
         }
 
         pedf->scheduled = next;
@@ -590,6 +673,10 @@ static long psnedf_activate_plugin(void)
 #ifdef CONFIG_LITMUS_LOCKING
         get_srp_prio = psnedf_get_srp_prio;
 #endif
+        
+#ifdef CONFIG_LITMUS_NVIDIA
+        init_nvidia_info();
+#endif  
 
         return 0;
 }
@@ -622,6 +709,11 @@ static struct sched_plugin psn_edf_plugin __cacheline_aligned_in_smp = {
 #ifdef CONFIG_LITMUS_LOCKING
         .allocate_lock          = psnedf_allocate_lock,
 #endif
+#ifdef CONFIG_LITMUS_PAI_SOFTIRQD
+        .enqueue_pai_tasklet = psnedf_enqueue_pai_tasklet,
+        .change_prio_pai_tasklet = psnedf_change_prio_pai_tasklet,
+        .run_tasklets = psnedf_run_tasklets,
+#endif  
 };
 
 
@@ -641,5 +733,13 @@ static int __init init_psn_edf(void)
         return register_sched_plugin(&psn_edf_plugin);
 }
 
+static void clean_psn_edf(void)
+{
+#ifdef CONFIG_LITMUS_NVIDIA
+        shutdown_nvidia_info();
+#endif
+}
+
 module_init(init_psn_edf);
+module_exit(clean_psn_edf);