Merge branch 'wip-gpu-cleanup' into wip-2012.3-gpu

Conflicts:
	include/litmus/fpmath.h
	include/litmus/litmus.h
	include/litmus/rt_param.h
	include/litmus/trace.h
	kernel/sched.c
	kernel/softirq.c
	litmus/edf_common.c
	litmus/jobs.c
	litmus/litmus.c
	litmus/locking.c
	litmus/preempt.c
	litmus/sched_cedf.c
	litmus/sched_gsn_edf.c
	litmus/sched_litmus.c
	litmus/sync.c

1 files changed, 196 insertions, 4 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 4cd06dd32906..39685a351cb1 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -1,9 +1,11 @@
+#ifndef _LINUX_RT_PARAM_H_
+#define _LINUX_RT_PARAM_H_
 /*
  * Definition of the scheduler plugin interface.
  *
  */
-#ifndef _LINUX_RT_PARAM_H_
-#define _LINUX_RT_PARAM_H_
+
+#include <litmus/fpmath.h>
 
 /* Litmus time type. */
 typedef unsigned long long lt_t;
@@ -30,9 +32,43 @@ typedef enum {
 typedef enum {
         NO_ENFORCEMENT,      /* job may overrun unhindered */
         QUANTUM_ENFORCEMENT, /* budgets are only checked on quantum boundaries */
-        PRECISE_ENFORCEMENT  /* budgets are enforced with hrtimers */
+        PRECISE_ENFORCEMENT, /* budgets are enforced with hrtimers */
 } budget_policy_t;
 
+typedef enum {
+        NO_SIGNALS,                     /* job receives no signals when it exhausts its budget */
+        QUANTUM_SIGNALS,        /* budget signals are only sent on quantum boundaries */
+        PRECISE_SIGNALS,        /* budget signals are triggered with hrtimers */
+} budget_signal_policy_t;
+
+typedef enum {
+        AUX_ENABLE      = 0x1,
+        AUX_CURRENT = (AUX_ENABLE<<1),
+        AUX_FUTURE      = (AUX_CURRENT<<2)
+} aux_flags_t;
+
+/* mirror of st_event_record_type_t
+ * Assume all are UNsupported, unless otherwise stated. */
+typedef enum {
+        ST_INJECT_NAME = 1,                             /* supported */
+        ST_INJECT_PARAM,                                /* supported */
+        ST_INJECT_RELEASE,                              /* supported */
+        ST_INJECT_ASSIGNED,
+        ST_INJECT_SWITCH_TO,
+        ST_INJECT_SWITCH_AWAY,
+        ST_INJECT_COMPLETION,                   /* supported */
+        ST_INJECT_BLOCK,
+        ST_INJECT_RESUME,
+        ST_INJECT_ACTION,
+        ST_INJECT_SYS_RELEASE,                  /* supported */
+} sched_trace_injection_events_t;
+
+struct st_inject_args {
+        lt_t release;
+        lt_t deadline;
+        unsigned int job_no;
+};
+
 /* We use the common priority interpretation "lower index == higher priority",
  * which is commonly used in fixed-priority schedulability analysis papers.
  * So, a numerically lower priority value implies higher scheduling priority,
@@ -62,6 +98,7 @@ struct rt_task {
         unsigned int    priority;
         task_class_t    cls;
         budget_policy_t budget_policy; /* ignored by pfair */
+        budget_signal_policy_t budget_signal_policy; /* currently ignored by pfair */
 };
 
 union np_flag {
@@ -74,6 +111,19 @@ union np_flag {
         } np;
 };
 
+struct affinity_observer_args
+{
+        int lock_od;
+};
+
+struct gpu_affinity_observer_args
+{
+        struct affinity_observer_args obs;
+        int replica_to_gpu_offset;
+        int nr_simult_users;
+        int relaxed_rules;
+};
+
 /* The definition of the data that is shared between the kernel and real-time
  * tasks via a shared page (see litmus/ctrldev.c).
  *
@@ -115,6 +165,13 @@ struct control_page {
 /* don't export internal data structures to user space (liblitmus) */
 #ifdef __KERNEL__
 
+#include <litmus/binheap.h>
+#include <linux/semaphore.h>
+
+#ifdef CONFIG_LITMUS_SOFTIRQD
+#include <linux/interrupt.h>
+#endif
+
 struct _rt_domain;
 struct bheap_node;
 struct release_heap;
@@ -142,10 +199,82 @@ struct rt_job {
          * Increase this sequence number when a job is released.
          */
         unsigned int    job_no;
+
+        /* bits:
+         * 0th: Set if a budget exhaustion signal has already been sent for
+         *      the current job. */
+        unsigned long   flags;
 };
 
+#define RT_JOB_SIG_BUDGET_SENT  0
+
 struct pfair_param;
 
+enum klmirqd_sem_status
+{
+        NEED_TO_REACQUIRE,
+        REACQUIRING,
+        NOT_HELD,
+        HELD
+};
+
+typedef enum gpu_migration_dist
+{
+        // TODO: Make this variable against NR_NVIDIA_GPUS
+        MIG_LOCAL = 0,
+        MIG_NEAR = 1,
+        MIG_MED = 2,
+        MIG_FAR = 3,    // 8 GPUs in a binary tree hierarchy
+        MIG_NONE = 4,
+
+        MIG_LAST = MIG_NONE
+} gpu_migration_dist_t;
+
+typedef struct feedback_est{
+        fp_t est;
+        fp_t accum_err;
+} feedback_est_t;
+
+
+#define AVG_EST_WINDOW_SIZE 20
+
+typedef int (*notify_rsrc_exit_t)(struct task_struct* tsk);
+
+typedef struct avg_est{
+        lt_t history[AVG_EST_WINDOW_SIZE];
+        uint16_t count;
+        uint16_t idx;
+        lt_t sum;
+        lt_t std;
+        lt_t avg;
+} avg_est_t;
+
+
+
+#ifdef CONFIG_LITMUS_SOFTIRQD
+struct klmirqd_info
+{
+        struct task_struct*             klmirqd;
+    struct task_struct*     current_owner;
+    unsigned int                        terminating:1;
+
+        raw_spinlock_t                  lock;
+
+        u32                                             pending;
+        atomic_t                                num_hi_pending;
+        atomic_t                                num_low_pending;
+        atomic_t                                num_work_pending;
+
+        /* in order of priority */
+        struct tasklet_head     pending_tasklets_hi;
+        struct tasklet_head             pending_tasklets;
+        struct list_head                worklist;
+
+        struct list_head                klmirqd_reg;
+};
+#endif
+
+
 /*      RT task parameters for scheduling extensions
  *      These parameters are inherited during clone and therefore must
  *      be explicitly set up before the task set is launched.
@@ -163,6 +292,40 @@ struct rt_param {
         /* has the task completed? */
         unsigned int            completed:1;
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+    /* proxy threads have minimum priority by default */
+    unsigned int        is_interrupt_thread:1;
+
+        /* pointer to data used by klmirqd thread.
+         *
+         * ptr only valid if is_interrupt_thread == 1
+         */
+        struct klmirqd_info* klmirqd_info;
+#endif
+
+#ifdef CONFIG_LITMUS_NVIDIA
+        /* number of top-half interrupts handled on behalf of current job */
+        atomic_t                                        nv_int_count;
+        long unsigned int                       held_gpus;  // bitmap of held GPUs.
+        struct binheap_node                     gpu_owner_node; // just one GPU for now...
+        unsigned int                            hide_from_gpu:1;
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        avg_est_t gpu_migration_est[MIG_LAST+1];
+
+        gpu_migration_dist_t    gpu_migration;
+        int                             last_gpu;
+
+        notify_rsrc_exit_t      rsrc_exit_cb;
+        void* rsrc_exit_cb_args;
+
+        lt_t accum_gpu_time;
+        lt_t gpu_time_stamp;
+
+        unsigned int suspend_gpu_tracker_on_block:1;
+#endif
+#endif
+
 #ifdef CONFIG_LITMUS_LOCKING
         /* Is the task being priority-boosted by a locking protocol? */
         unsigned int            priority_boosted:1;
@@ -182,7 +345,26 @@ struct rt_param {
          * could point to self if PI does not result in
          * an increased task priority.
          */
-         struct task_struct*    inh_task;
+        struct task_struct*     inh_task;
+
+#ifdef CONFIG_LITMUS_NESTED_LOCKING
+        raw_spinlock_t                  hp_blocked_tasks_lock;
+        struct binheap                  hp_blocked_tasks;
+
+        /* pointer to lock upon which is currently blocked */
+        struct litmus_lock* blocked_lock;
+#endif
+
+
+#ifdef CONFIG_REALTIME_AUX_TASKS
+        unsigned int            is_aux_task:1;
+        unsigned int            has_aux_tasks:1;
+        unsigned int            hide_from_aux_tasks:1;
+
+        struct list_head        aux_task_node;
+        struct binheap_node     aux_task_owner_node;
+#endif
+
 
 #ifdef CONFIG_NP_SECTION
         /* For the FMLP under PSN-EDF, it is required to make the task
@@ -248,6 +430,16 @@ struct rt_param {
         struct control_page * ctrl_page;
 };
 
+#ifdef CONFIG_REALTIME_AUX_TASKS
+struct aux_data
+{
+        struct list_head        aux_tasks;
+        struct binheap          aux_task_owners;
+        unsigned int            initialized:1;
+        unsigned int            aux_future:1;
+};
 #endif
 
+#endif  /* __KERNEL */
+
 #endif