1 files changed, 130 insertions, 2 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 21430623a940..02b750a9570b 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -5,6 +5,8 @@
 #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,15 @@ 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;
+
 /* 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 +70,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 +83,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).
  *
@@ -97,6 +119,9 @@ struct control_page {
 /* don't export internal data structures to user space (liblitmus) */
 #ifdef __KERNEL__
 
+#include <litmus/binheap.h>
+#include <linux/semaphore.h>
+
 struct _rt_domain;
 struct bheap_node;
 struct release_heap;
@@ -110,6 +135,12 @@ struct rt_job {
         /* How much service has this job received so far? */
         lt_t    exec_time;
 
+        /* By how much did the prior job miss its deadline by?
+         * Value differs from tardiness in that lateness may
+         * be negative (when job finishes before its deadline).
+         */
+        long long       lateness;
+
         /* Which job is this. This is used to let user space
          * specify which job to wait for, which is important if jobs
          * overrun. If we just call sys_sleep_next_period() then we
@@ -118,10 +149,54 @@ 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 klitirqd_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 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;
+
 /*      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.
@@ -136,6 +211,50 @@ struct rt_param {
         /* is the task present? (true if it can be scheduled) */
         unsigned int            present:1;
 
+#ifdef CONFIG_LITMUS_SOFTIRQD
+    /* proxy threads have minimum priority by default */
+    unsigned int        is_proxy_thread:1;
+
+        /* pointer to klitirqd currently working on this
+           task_struct's behalf.  only set by the task pointed
+           to by klitirqd.
+
+           ptr only valid if is_proxy_thread == 0
+         */
+        struct task_struct* cur_klitirqd;
+
+        /* Used to implement mutual execution exclusion between
+         * job and klitirqd execution.  Job must always hold
+         * it's klitirqd_sem to execute.  klitirqd instance
+         * must hold the semaphore before executing on behalf
+         * of a job.
+         */
+        struct mutex                            klitirqd_sem;
+
+        /* status of held klitirqd_sem, even if the held klitirqd_sem is from
+           another task (only proxy threads do this though).
+         */
+        atomic_t                                        klitirqd_sem_stat;
+#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.
+
+#ifdef CONFIG_LITMUS_AFFINITY_LOCKING
+        avg_est_t gpu_migration_est[MIG_LAST+1];
+
+        gpu_migration_dist_t    gpu_migration;
+        int                             last_gpu;
+
+        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;
@@ -155,11 +274,20 @@ 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
 
         
          struct task_struct*    hp_group;
          unsigned int                   is_slave:1;
+         unsigned int                   has_slaves:1;
 
 
 #ifdef CONFIG_NP_SECTION