Merge branch 'wip-gpu-rtas12' into wip-slave-threads

Conflicts:
	include/litmus/unistd_32.h
	include/litmus/unistd_64.h
	litmus/litmus.c

1 files changed, 145 insertions, 16 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 2300281b6b30..83e8ef3f42af 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -21,6 +21,10 @@
 #include <litmus/affinity.h>
 #endif
 
+#ifdef CONFIG_LITMUS_NVIDIA
+#include <litmus/nvidia_info.h>
+#endif
+
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
 static DEFINE_RAW_SPINLOCK(task_transition_lock);
@@ -51,6 +55,28 @@ void bheap_node_free(struct bheap_node* hn)
 struct release_heap* release_heap_alloc(int gfp_flags);
 void release_heap_free(struct release_heap* rh);
 
+#ifdef CONFIG_LITMUS_NVIDIA
+/*
+ * sys_register_nv_device
+ * @nv_device_id: The Nvidia device id that the task want to register
+ * @reg_action: set to '1' to register the specified device. zero otherwise.
+ * Syscall for register task's designated nvidia device into NV_DEVICE_REG array
+ * Returns EFAULT  if nv_device_id is out of range.
+ *         0       if success
+ */
+asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
+{
+        /* register the device to caller (aka 'current') */
+        return(reg_nv_device(nv_device_id, reg_action, current));
+}
+#else
+asmlinkage long sys_register_nv_device(int nv_device_id, int reg_action)
+{
+        return(-EINVAL);
+}
+#endif
+
+
 /*
  * sys_set_task_rt_param
  * @pid: Pid of the task which scheduling parameters must be changed
@@ -136,6 +162,16 @@ asmlinkage long sys_set_rt_task_param(pid_t pid, struct rt_task __user * param)
                        pid, tp.budget_policy);
                 goto out_unlock;
         }
+        if (tp.budget_signal_policy != NO_SIGNALS &&
+            tp.budget_signal_policy != QUANTUM_SIGNALS &&
+            tp.budget_signal_policy != PRECISE_SIGNALS)
+        {
+                printk(KERN_INFO "litmus: real-time task %d rejected "
+                       "because unsupported budget signalling policy "
+                       "specified (%d)\n",
+                       pid, tp.budget_signal_policy);
+                goto out_unlock;
+        }
 
         target->rt_param.task_params = tp;
 
@@ -273,6 +309,7 @@ asmlinkage long sys_query_job_no(unsigned int __user *job)
         return retval;
 }
 
+
 /* sys_null_call() is only used for determining raw system call
  * overheads (kernel entry, kernel exit). It has no useful side effects.
  * If ts is non-NULL, then the current Feather-Trace time is recorded.
@@ -291,14 +328,6 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
 }
 
 
-
-
-
-
-
-
-
-
 long __litmus_admit_task(struct task_struct* tsk);
 
 asmlinkage long sys_slave_non_rt_threads(void)
@@ -310,8 +339,6 @@ asmlinkage long sys_slave_non_rt_threads(void)
 
         read_lock_irq(&tasklist_lock);
 
-        is_realtime(target)
-
         t = leader;
         do {
                 TRACE_CUR("threads in %s/%d: %s/%d:\n", leader->comm, leader->pid, t->comm, t->pid);
@@ -324,8 +351,10 @@ asmlinkage long sys_slave_non_rt_threads(void)
                         /* hasn't been admitted into rt. make it a slave. */
                         tsk_rt(t)->slave = 1;
                 }
-                else if (is_realtime(t))
-                        if (litmus->compare(t, hp)) {
+                else {
+                        tsk_rt(t)->has_slaves = 1;
+
+                        if (is_realtime(t) && litmus->compare(t, hp)) {
                                 hp = t;
                         }
                 }
@@ -334,8 +363,17 @@ asmlinkage long sys_slave_non_rt_threads(void)
         } while(t != leader);
 
         if (hp) {
+                TRACE_CUR("found hp in group: %s/%d\n", hp->comm, hp->pid);
+
                 /* set up inheritance */
-                
+                leader->hp_group = hp;
+
+                t = leader;
+                do {
+                        if (tsk_rt(t)->slave) {
+                                litmus->increase_prio(t);
+                        }
+                } while(t != leader);
         }
 
         read_unlock_irq(&tasklist_lock);
@@ -343,6 +381,31 @@ asmlinkage long sys_slave_non_rt_threads(void)
         return 0;
 }
 
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
+void init_gpu_affinity_state(struct task_struct* p)
+{
+        // under-damped
+        //p->rt_param.gpu_fb_param_a = _frac(14008, 10000);
+        //p->rt_param.gpu_fb_param_b = _frac(16024, 10000);
+
+#if 0           
+        // emperical;
+        p->rt_param.gpu_fb_param_a[0] = _frac(7550, 10000);
+        p->rt_param.gpu_fb_param_b[0] = _frac(45800, 10000);
+
+        p->rt_param.gpu_fb_param_a[1] = _frac(8600, 10000);
+        p->rt_param.gpu_fb_param_b[1] = _frac(40000, 10000);
+
+        p->rt_param.gpu_fb_param_a[2] = _frac(6890, 10000);
+        p->rt_param.gpu_fb_param_b[2] = _frac(40000, 10000);
+
+        p->rt_param.gpu_fb_param_a[3] = _frac(7580, 10000);
+        p->rt_param.gpu_fb_param_b[3] = _frac(34590, 10000);
+#endif
+        p->rt_param.gpu_migration = MIG_NONE;
+        p->rt_param.last_gpu = -1;
+}
+#endif
 
 /* p is a real-time task. Re-init its state as a best-effort task. */
 static void reinit_litmus_state(struct task_struct* p, int restore)
@@ -350,6 +413,10 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
         struct rt_task  user_config = {};
         void*  ctrl_page     = NULL;
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        binheap_order_t prio_order = NULL;
+#endif
+
         if (restore) {
                 /* Safe user-space provided configuration data.
                  * and allocated page. */
@@ -357,11 +424,38 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
                 ctrl_page   = p->rt_param.ctrl_page;
         }
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        prio_order = p->rt_param.hp_blocked_tasks.compare;
+#endif
+
         /* We probably should not be inheriting any task's priority
          * at this point in time.
          */
         WARN_ON(p->rt_param.inh_task);
 
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        WARN_ON(p->rt_param.blocked_lock);
+    WARN_ON(!binheap_empty(&p->rt_param.hp_blocked_tasks));
+#endif
+
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        /* We probably should not have any tasklets executing for
+     * us at this time.
+         */
+    WARN_ON(p->rt_param.cur_klitirqd);
+        WARN_ON(atomic_read(&p->rt_param.klitirqd_sem_stat) == HELD);
+
+        if(p->rt_param.cur_klitirqd)
+                flush_pending(p->rt_param.cur_klitirqd, p);
+
+        if(atomic_read(&p->rt_param.klitirqd_sem_stat) == HELD)
+                up_and_set_stat(p, NOT_HELD, &p->rt_param.klitirqd_sem);
+#endif
+
+#ifdef CONFIG_LITMUS_NVIDIA
+        WARN_ON(p->rt_param.held_gpus != 0);
+#endif
+
         /* Cleanup everything else. */
         memset(&p->rt_param, 0, sizeof(p->rt_param));
 
@@ -370,6 +464,15 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
                 p->rt_param.task_params = user_config;
                 p->rt_param.ctrl_page   = ctrl_page;
         }
+
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
+        init_gpu_affinity_state(p);
+#endif
+
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        INIT_BINHEAP_HANDLE(&p->rt_param.hp_blocked_tasks, prio_order);
+        raw_spin_lock_init(&p->rt_param.hp_blocked_tasks_lock);
+#endif
 }
 
 long __litmus_admit_task(struct task_struct* tsk)
@@ -398,6 +501,25 @@ long __litmus_admit_task(struct task_struct* tsk)
                 bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
 
+#ifdef CONFIG_LITMUS_NVIDIA
+        atomic_set(&tsk_rt(tsk)->nv_int_count, 0);
+#endif
+#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
+        init_gpu_affinity_state(tsk);
+#endif
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        tsk_rt(tsk)->blocked_lock = NULL;
+        raw_spin_lock_init(&tsk_rt(tsk)->hp_blocked_tasks_lock);
+        //INIT_BINHEAP_HANDLE(&tsk_rt(tsk)->hp_blocked_tasks, prio_order);  // done by scheduler
+#endif
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        /* proxy thread off by default */
+        tsk_rt(tsk)is_proxy_thread = 0;
+    tsk_rt(tsk)cur_klitirqd = NULL;
+        mutex_init(&tsk_rt(tsk)->klitirqd_sem);
+        atomic_set(&tsk_rt(tsk)->klitirqd_sem_stat, NOT_HELD);
+#endif
+
         retval = litmus->admit_task(tsk);
 
         if (!retval) {
@@ -475,7 +597,7 @@ static void synch_on_plugin_switch(void* info)
  */
 int switch_sched_plugin(struct sched_plugin* plugin)
 {
-        unsigned long flags;
+        //unsigned long flags;
         int ret = 0;
 
         BUG_ON(!plugin);
@@ -489,8 +611,15 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         while (atomic_read(&cannot_use_plugin) < num_online_cpus())
                 cpu_relax();
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        if(!klitirqd_is_dead())
+        {
+                kill_klitirqd();
+        }
+#endif
+
         /* stop task transitions */
-        raw_spin_lock_irqsave(&task_transition_lock, flags);
+        //raw_spin_lock_irqsave(&task_transition_lock, flags);
 
         /* don't switch if there are active real-time tasks */
         if (atomic_read(&rt_task_count) == 0) {
@@ -508,7 +637,7 @@ int switch_sched_plugin(struct sched_plugin* plugin)
         } else
                 ret = -EBUSY;
 out:
-        raw_spin_unlock_irqrestore(&task_transition_lock, flags);
+        //raw_spin_unlock_irqrestore(&task_transition_lock, flags);
         atomic_set(&cannot_use_plugin, 0);
         return ret;
 }