Merge branch 'prop/robust-tie-break' into wip-gpu-rtas12

Conflicts:
	include/litmus/binheap.h
	include/litmus/fdso.h
	include/litmus/litmus.h
	litmus/Makefile
	litmus/binheap.c
	litmus/edf_common.c
	litmus/fdso.c
	litmus/jobs.c
	litmus/locking.c

1 files changed, 29 insertions, 2 deletions

diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 04239c747f06..419ff0c88a65 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -26,7 +26,6 @@ static inline int lt_after_eq(lt_t a, lt_t b)
 typedef enum {
         RT_CLASS_HARD,
         RT_CLASS_SOFT,
-        RT_CLASS_SOFT_W_SLIP,
         RT_CLASS_BEST_EFFORT
 } task_class_t;
 
@@ -36,11 +35,33 @@ typedef enum {
         PRECISE_ENFORCEMENT  /* budgets are enforced with hrtimers */
 } budget_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,
+ * with priority 1 being the highest priority. Priority 0 is reserved for
+ * priority boosting. LITMUS_MAX_PRIORITY denotes the maximum priority value
+ * range.
+ */
+
+#define LITMUS_MAX_PRIORITY     512
+#define LITMUS_HIGHEST_PRIORITY   1
+#define LITMUS_LOWEST_PRIORITY    (LITMUS_MAX_PRIORITY - 1)
+
+/* Provide generic comparison macros for userspace,
+ * in case that we change this later. */
+#define litmus_higher_fixed_prio(a, b)  (a < b)
+#define litmus_lower_fixed_prio(a, b)   (a > b)
+#define litmus_is_valid_fixed_prio(p)           \
+        ((p) >= LITMUS_HIGHEST_PRIORITY &&      \
+         (p) <= LITMUS_LOWEST_PRIORITY)
+
 struct rt_task {
         lt_t            exec_cost;
         lt_t            period;
+        lt_t            relative_deadline;
         lt_t            phase;
         unsigned int    cpu;
+        unsigned int    priority;
         task_class_t    cls;
         budget_policy_t budget_policy; /* ignored by pfair */
 };
@@ -107,6 +128,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
@@ -237,7 +264,7 @@ struct rt_param {
 
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         raw_spinlock_t                  hp_blocked_tasks_lock;
-        struct binheap_handle   hp_blocked_tasks;
+        struct binheap                  hp_blocked_tasks;
 
         /* pointer to lock upon which is currently blocked */
         struct litmus_lock* blocked_lock;