slack stealing

7 files changed, 237 insertions, 43 deletions

diff --git a/include/litmus/mc2_common.h b/include/litmus/mc2_common.h
index bdc3a6d82a56..e3c0af28f1b9 100644
--- a/include/litmus/mc2_common.h
+++ b/include/litmus/mc2_common.h
@@ -21,6 +21,8 @@ struct mc2_task {
 
 #include <litmus/reservation.h>
 
+#define tsk_mc2_data(t)         (tsk_rt(t)->mc2_data)
+
 long mc2_task_client_init(struct task_client *tc, struct mc2_task *mc2_param, struct task_struct *tsk,
                                                         struct reservation *res);
         
diff --git a/include/litmus/reservation.h b/include/litmus/reservation.h
index 4eecd3f088e8..5ccb20055a56 100644
--- a/include/litmus/reservation.h
+++ b/include/litmus/reservation.h
@@ -126,6 +126,9 @@ struct reservation {
         struct reservation_ops *ops;
 
         struct list_head clients;
+        
+        /* for global env. */
+        int scheduled_on;
 };
 
 void reservation_init(struct reservation *res);
@@ -185,10 +188,51 @@ struct sup_reservation_environment {
 void sup_init(struct sup_reservation_environment* sup_env);
 void sup_add_new_reservation(struct sup_reservation_environment* sup_env,
         struct reservation* new_res);
+void sup_scheduler_update_after(struct sup_reservation_environment* sup_env,
+        lt_t timeout);
 void sup_update_time(struct sup_reservation_environment* sup_env, lt_t now);
 struct task_struct* sup_dispatch(struct sup_reservation_environment* sup_env);
 
 struct reservation* sup_find_by_id(struct sup_reservation_environment* sup_env,
         unsigned int id);
+        
+/* A global multiprocessor reservation environment. */
 
+struct next_timer_event {
+        lt_t next_update;
+        int timer_armed_on;
+        unsigned int id;
+        struct list_head list;
+};
+
+struct gmp_reservation_environment {
+        raw_spinlock_t lock;
+        struct reservation_environment env;
+
+        /* ordered by priority */
+        struct list_head active_reservations;
+
+        /* ordered by next_replenishment */
+        struct list_head depleted_reservations;
+
+        /* unordered */
+        struct list_head inactive_reservations;
+
+        /* timer event ordered by next_update */
+        struct list_head next_events;
+        /* (schedule_now == true) means call gmp_dispatch() now */
+        bool schedule_now;
+        /* set to true if a call to gmp_dispatch() is imminent */
+        bool will_schedule;
+};
+/*
+void gmp_init(struct gmp_reservation_environment* gmp_env);
+void gmp_add_new_reservation(struct gmp_reservation_environment* gmp_env,
+        struct reservation* new_res);
+void gmp_update_time(struct gmp_reservation_environment* gmp_env, lt_t now);
+struct task_struct* gmp_dispatch(struct gmp_reservation_environment* gmp_env);
+
+struct reservation* gmp_find_by_id(struct gmp_reservation_environment* gmp_env,
+        unsigned int id);
+*/
 #endif
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index e626bbbe60d5..284b89e95a51 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -206,6 +206,7 @@ struct rt_job {
 };
 
 struct pfair_param;
+struct mc2_task;
 
 /*      RT task parameters for scheduling extensions
  *      These parameters are inherited during clone and therefore must
@@ -322,6 +323,9 @@ struct rt_param {
 
         /* Pointer to the page shared between userspace and kernel. */
         struct control_page * ctrl_page;
+        
+        /* Mixed-criticality specific data */
+        struct mc2_task* mc2_data;
 };
 
 #endif
diff --git a/litmus/jobs.c b/litmus/jobs.c
index 547222c3387a..e523e29ea8a6 100644
--- a/litmus/jobs.c
+++ b/litmus/jobs.c
@@ -45,6 +45,7 @@ void release_at(struct task_struct *t, lt_t start)
 {
         BUG_ON(!t);
         setup_release(t, start);
+        TRACE("RELEASE!!\n");
         tsk_rt(t)->completed = 0;
 }
 
diff --git a/litmus/polling_reservations.c b/litmus/polling_reservations.c
index 4c07ee74bf39..941a371c26e9 100644
--- a/litmus/polling_reservations.c
+++ b/litmus/polling_reservations.c
@@ -19,11 +19,19 @@ static void periodic_polling_client_arrives(
         switch (res->state) {
                 case RESERVATION_INACTIVE:
                         /* Figure out next replenishment time. */
-                        tmp = res->env->current_time - res->env->time_zero;
-                        instances =  div64_u64(tmp, pres->period);
-                        res->next_replenishment =
-                                (instances + 1) * pres->period + pres->offset;
-
+                        if (res->env->time_zero == 0) {
+                                tmp = res->env->current_time - res->env->time_zero;
+                                instances =  div64_u64(tmp, pres->period);
+                                res->next_replenishment =
+                                        (instances + 1) * pres->period + pres->offset;
+                        }
+                        else {
+                                tmp = res->env->current_time - res->env->time_zero;
+                                instances =  div64_u64(tmp, pres->period);
+                                res->next_replenishment = res->env->time_zero + instances * pres->period;
+                        }
+                                
+                        TRACE("ENV_TIME_ZERO %llu\n", res->env->time_zero);
                         TRACE("pol-res: activate tmp=%llu instances=%llu period=%llu nextrp=%llu cur=%llu\n",
                                 tmp, instances, pres->period, res->next_replenishment,
                                 res->env->current_time);
@@ -62,9 +70,10 @@ static void periodic_polling_client_departs(
                 case RESERVATION_ACTIVE:
                         if (list_empty(&res->clients)) {
                                 res->env->change_state(res->env, res,
-                                        did_signal_job_completion ?
-                                                RESERVATION_DEPLETED :
                                                 RESERVATION_ACTIVE_IDLE);
+//                                      did_signal_job_completion ?
+//                                              RESERVATION_DEPLETED :
+//                                              RESERVATION_ACTIVE_IDLE);
                         } /* else: nothing to do, more clients ready */
                         break;
 
@@ -86,6 +95,7 @@ static void periodic_polling_on_replenishment(
         res->next_replenishment += pres->period;
         res->budget_consumed = 0;
 
+        TRACE("polling_replenish(%u): next_replenishment=%llu\n", res->id, res->next_replenishment);
         switch (res->state) {
                 case RESERVATION_DEPLETED:
                 case RESERVATION_INACTIVE:
@@ -270,6 +280,7 @@ void polling_reservation_init(
         pres->period = period;
         pres->deadline = deadline;
         pres->offset = offset;
+        TRACE_TASK(current, "polling_reservation_init: periodic %d, use_edf %d\n", use_periodic_polling, use_edf_prio);
         if (use_periodic_polling) {
                 if (use_edf_prio)
                         pres->res.ops = &periodic_polling_ops_edf;
@@ -460,7 +471,8 @@ static void td_drain_budget(
         switch (res->state) {
                 case RESERVATION_DEPLETED:
                 case RESERVATION_INACTIVE:
-                        BUG();
+                        //BUG();
+                        TRACE("TD_DRAIN!!!!!!!!! RES_STATE = %d\n", res->state);
                         break;
 
                 case RESERVATION_ACTIVE_IDLE:
diff --git a/litmus/reservation.c b/litmus/reservation.c
index 0e43479ff2e1..2dc3dc2b4688 100644
--- a/litmus/reservation.c
+++ b/litmus/reservation.c
@@ -48,11 +48,12 @@ static void sup_scheduler_update_at(
         struct sup_reservation_environment* sup_env,
         lt_t when)
 {
+        TRACE("SCHEDULER_UPDATE_AT update: %llu > when %llu\n", sup_env->next_scheduler_update, when);
         if (sup_env->next_scheduler_update > when)
                 sup_env->next_scheduler_update = when;
 }
 
-static void sup_scheduler_update_after(
+void sup_scheduler_update_after(
         struct sup_reservation_environment* sup_env,
         lt_t timeout)
 {
@@ -192,10 +193,13 @@ static void sup_charge_budget(
                 /* charge all ACTIVE_IDLE up to the first ACTIVE reservation */
                 res = list_entry(pos, struct reservation, list);
                 if (res->state == RESERVATION_ACTIVE) {
-                        res->ops->drain_budget(res, delta);
+                        TRACE("sup_charge_budget ACTIVE R%u drain %llu\n", res->id, delta);
+                        if (encountered_active == 0)
+                                res->ops->drain_budget(res, delta);
                         encountered_active = 1;
                 } else {
                         BUG_ON(res->state != RESERVATION_ACTIVE_IDLE);
+                        TRACE("sup_charge_budget INACTIVE R%u drain %llu\n", res->id, delta);
                         res->ops->drain_budget(res, delta);
                 }
                 if (res->state == RESERVATION_ACTIVE ||
@@ -207,9 +211,9 @@ static void sup_charge_budget(
                                 res->id, res->cur_budget);
                          sup_scheduler_update_after(sup_env, res->cur_budget);
                 }
-                if (encountered_active)
+                //if (encountered_active == 2)
                         /* stop at the first ACTIVE reservation */
-                        break;
+                //      break;
         }
         //TRACE("finished charging budgets\n");
 }
@@ -246,7 +250,7 @@ void sup_update_time(
         /* If the time didn't advance, there is nothing to do.
          * This check makes it safe to call sup_advance_time() potentially
          * multiple times (e.g., via different code paths. */
-        //TRACE("(sup_update_time) now: %llu, current_time: %llu\n", now, sup_env->env.current_time);
+        TRACE("(sup_update_time) now: %llu, current_time: %llu\n", now, sup_env->env.current_time);
         if (unlikely(now <= sup_env->env.current_time))
                 return;
 
@@ -258,9 +262,11 @@ void sup_update_time(
                 sup_env->next_scheduler_update = SUP_NO_SCHEDULER_UPDATE;
 
         /* deplete budgets by passage of time */
+        TRACE("CHARGE###\n");
         sup_charge_budget(sup_env, delta);
 
         /* check if any budgets where replenished */
+        TRACE("REPLENISH###\n");
         sup_replenish_budgets(sup_env);
 }
 
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index b9f05238461b..6b29d527fa3a 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -22,15 +22,22 @@ struct mc2_task_state {
         struct mc2_task mc2_param;
 };
 
+struct crit_entry {
+        enum crit_level level;
+        struct task_struct *running;
+        struct hrtimer ghost_timer;
+};
+
 struct mc2_cpu_state {
         raw_spinlock_t lock;
 
         struct sup_reservation_environment sup_env;
         struct hrtimer timer;
+        struct hrtimer g_timer;
 
         int cpu;
         struct task_struct* scheduled;
-        enum crit_level run_level;
+        struct crit_entry crit_entries[NUM_CRIT_LEVELS];
 };
 
 static DEFINE_PER_CPU(struct mc2_cpu_state, mc2_cpu_state);
@@ -42,30 +49,53 @@ static struct mc2_task_state* get_mc2_state(struct task_struct *tsk)
 {
         return (struct mc2_task_state*) tsk_rt(tsk)->plugin_state;
 }
+static enum crit_level get_task_crit_level(struct task_struct *tsk)
+{
+        struct mc2_task_state *tinfo = get_mc2_state(tsk);
+        if (!tinfo)
+                return NUM_CRIT_LEVELS;
+        else
+                return tinfo->mc2_param.crit;
+}
 
 static void task_departs(struct task_struct *tsk, int job_complete)
 {
-        struct mc2_task_state* state = get_mc2_state(tsk);
+        struct mc2_task_state* tinfo = get_mc2_state(tsk);
+        struct mc2_cpu_state* state = local_cpu_state();
         struct reservation* res;
         struct reservation_client *client;
 
-        res    = state->res_info.client.reservation;
-        client = &state->res_info.client;
+        res    = tinfo->res_info.client.reservation;
+        client = &tinfo->res_info.client;
 
         res->ops->client_departs(res, client, job_complete);
-        state->has_departed = true;
+        tinfo->has_departed = true;
+        TRACE_TASK(tsk, "CLIENT DEPART with budget %llu\n", res->cur_budget);
+        if (job_complete && res->cur_budget) {
+                struct crit_entry* ce;
+                enum crit_level lv = tinfo->mc2_param.crit;
+                //lt_t now = litmus_clock();
+                
+                ce = &state->crit_entries[lv];
+                ce->running = tsk;
+                TRACE_TASK(tsk, "BECOME GHOST at %llu\n", litmus_clock());
+                
+                BUG_ON(hrtimer_active(&ce->ghost_timer));
+                //TRACE("setting GHOST timer %llu\n", ns_to_ktime(now + res->cur_budget));
+                //__hrtimer_start_range_ns(&ce->ghost_timer, ns_to_ktime(now + res->cur_budget), 0, HRTIMER_MODE_ABS_PINNED, 0);
+        }               
 }
 
 static void task_arrives(struct task_struct *tsk)
 {
-        struct mc2_task_state* state = get_mc2_state(tsk);
+        struct mc2_task_state* tinfo = get_mc2_state(tsk);
         struct reservation* res;
         struct reservation_client *client;
 
-        res    = state->res_info.client.reservation;
-        client = &state->res_info.client;
+        res    = tinfo->res_info.client.reservation;
+        client = &tinfo->res_info.client;
 
-        state->has_departed = false;
+        tinfo->has_departed = false;
         res->ops->client_arrives(res, client);
 }
 
@@ -94,7 +124,7 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
                 /* Reprogram only if not already set correctly. */
                 if (!hrtimer_active(&state->timer) ||
                     ktime_to_ns(hrtimer_get_expires(&state->timer)) != update) {
-                        TRACE("canceling timer...\n");
+                        TRACE("canceling timer...at %llu\n", ktime_to_ns(hrtimer_get_expires(&state->timer)));
                         hrtimer_cancel(&state->timer);
                         TRACE("setting scheduler timer for %llu\n", update);
                         /* We cannot use hrtimer_start() here because the
@@ -127,6 +157,49 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
         }
 }
 
+static void mc2_update_ghost_state(struct mc2_cpu_state *state)
+{
+        int lv = 0;
+        struct crit_entry* ce;
+        struct reservation *res;
+        struct mc2_task_state *tinfo;
+        
+        for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
+                ce = &state->crit_entries[lv];
+                if (ce->running != NULL) {
+                        tinfo = get_mc2_state(ce->running);
+                        if (lv != CRIT_LEVEL_C)
+                                res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                        else
+                                continue;
+                        TRACE("LV %d running id %d budget %llu\n", lv, tinfo->mc2_param.res_id, res->cur_budget);
+                        if (!res->cur_budget) {
+                                TRACE("GHOST FINISH id %d at %llu\n", tinfo->mc2_param.res_id, litmus_clock());
+                                ce->running = NULL;
+                        }
+                }
+        }
+}                       
+
+static enum hrtimer_restart on_ghost_timer(struct hrtimer *timer)
+{
+        struct crit_entry *ce;
+        struct mc2_cpu_state *state;
+        
+        ce = container_of(timer, struct crit_entry, ghost_timer);
+        state = container_of(ce, struct mc2_cpu_state, crit_entries[ce->level]);
+        
+        TRACE("GHOST_TIMER FIRED at %llu\n", litmus_clock());
+        
+        raw_spin_lock(&state->lock);
+        sup_update_time(&state->sup_env, litmus_clock());
+        mc2_update_ghost_state(state);
+        
+        raw_spin_unlock(&state->lock);
+        
+        return HRTIMER_NORESTART;
+}
+        
 static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
 {
         unsigned long flags;
@@ -144,9 +217,11 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
          */
         BUG_ON(state->cpu != raw_smp_processor_id());
 
+        TRACE("TIMER FIRED at %llu\n", litmus_clock());
         raw_spin_lock_irqsave(&state->lock, flags);
         sup_update_time(&state->sup_env, litmus_clock());
-
+        mc2_update_ghost_state(state);
+        
         update = state->sup_env.next_scheduler_update;
         now = state->sup_env.env.current_time;
 
@@ -165,6 +240,36 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
         return restart;
 }
 
+struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, struct mc2_cpu_state* state)
+{
+        struct reservation *res, *next;
+        struct task_struct *tsk = NULL;
+        struct crit_entry *ce;
+        enum crit_level lv;
+        lt_t time_slice;
+
+        list_for_each_entry_safe(res, next, &sup_env->active_reservations, list) {
+                if (res->state == RESERVATION_ACTIVE) {
+                        tsk = res->ops->dispatch_client(res, &time_slice);
+                        if (likely(tsk)) {
+                                lv = get_task_crit_level(tsk);
+                                if (lv == NUM_CRIT_LEVELS) {
+                                        sup_scheduler_update_after(sup_env, res->cur_budget);
+                                        return tsk;
+                                } else {
+                                        ce = &state->crit_entries[lv];
+                                        if (likely(!ce->running)) {
+                                                sup_scheduler_update_after(sup_env, res->cur_budget);
+                                                return tsk;
+                                        }
+                                }
+                        }
+                }
+        }
+
+        return NULL;
+}
+
 static struct task_struct* mc2_schedule(struct task_struct * prev)
 {
         /* next == NULL means "schedule background work". */
@@ -178,14 +283,17 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
 
         /* update time */
         state->sup_env.will_schedule = true;
+        TRACE_TASK(prev, "MC2_SCHEDULE sup_update_time ####\n");
         sup_update_time(&state->sup_env, litmus_clock());
-
+        TRACE_TASK(prev, "MC2_SCHEDULE sup_update_time !!!!\n");
+        mc2_update_ghost_state(state);
+        
         /* remove task from reservation if it blocks */
         if (is_realtime(prev) && !is_running(prev))
                 task_departs(prev, is_completed(prev));
 
         /* figure out what to schedule next */
-        state->scheduled = sup_dispatch(&state->sup_env);
+        state->scheduled = mc2_dispatch(&state->sup_env, state);
 
         /* Notify LITMUS^RT core that we've arrived at a scheduling decision. */
         sched_state_task_picked();
@@ -197,7 +305,6 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
 
         if (prev != state->scheduled && is_realtime(prev)) {
                 TRACE_TASK(prev, "descheduled.\n");
-                state->run_level = NUM_CRIT_LEVELS;
         }
         if (state->scheduled) {
                 TRACE_TASK(state->scheduled, "scheduled.\n");
@@ -242,9 +349,10 @@ static void mc2_task_resume(struct task_struct  *tsk)
                  * since we might not actually be executing on tinfo->cpu
                  * at the moment. */
                 sup_update_time(&state->sup_env, litmus_clock());
+                mc2_update_ghost_state(state);
                 task_arrives(tsk);
                 /* NOTE: drops state->lock */
-                TRACE("mc2_resume()\n");
+                TRACE_TASK(tsk, "mc2_resume()\n");
                 mc2_update_timer_and_unlock(state);
                 local_irq_restore(flags);
         } else {
@@ -263,34 +371,36 @@ static long mc2_complete_job(void)
         struct mc2_cpu_state *state = local_cpu_state();
         struct reservation_environment *env = &(state->sup_env.env);
         struct mc2_task_state *tinfo = get_mc2_state(current);
+        struct reservation *res;
         
+        res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+        if (!res)
+                ; // find in global env
         
-        TRACE_CUR("mc2_complete_job at %llu (deadline: %llu)\n", litmus_clock(),
-                get_deadline(current));
+        TRACE_CUR("mc2_complete_job at %llu (deadline: %llu) (cur->budget: %llu)\n", litmus_clock(),
+                get_deadline(current), res->cur_budget);
 
         tsk_rt(current)->completed = 1;
         
         if (tsk_rt(current)->sporadic_release) {
                 env->time_zero = tsk_rt(current)->sporadic_release_time;
-        
+                res->next_replenishment = tsk_rt(current)->sporadic_release_time;
+                res->cur_budget = 0;
+                res->env->change_state(res->env, res, RESERVATION_DEPLETED);
+                
                 if (tinfo->mc2_param.crit == CRIT_LEVEL_A) {
-                        struct reservation *res;
                         struct table_driven_reservation *tdres;
                         
-                        sup_update_time(&state->sup_env, litmus_clock());
-                        res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
+                        //sup_update_time(&state->sup_env, litmus_clock());
+                        //res = sup_find_by_id(&state->sup_env, tinfo->mc2_param.res_id);
                         tdres = container_of(res, struct table_driven_reservation, res);
                         tdres->next_interval = 0;
                         tdres->major_cycle_start = tsk_rt(current)->sporadic_release_time;
-                        res->next_replenishment = tsk_rt(current)->sporadic_release_time;
-                        res->next_replenishment += tdres->intervals[0].start;
-                        res->env->change_state(res->env, res, RESERVATION_DEPLETED);
-                                                
-                        TRACE_CUR("CHANGE NEXT_REP = %llu\n NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env.next_scheduler_update);
+                        res->next_replenishment += tdres->intervals[0].start;                   
                 }
-                
+                TRACE_CUR("CHANGE NEXT_REP = %llu\n NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env.next_scheduler_update);
         }
-                
+        
         prepare_for_next_period(current);
         next_release = ns_to_ktime(get_release(current));
         preempt_disable();
@@ -385,6 +495,7 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 /* Assumption: litmus_clock() is synchronized across cores
                  * [see comment in pres_task_resume()] */
                 sup_update_time(&state->sup_env, litmus_clock());
+                mc2_update_ghost_state(state);
                 task_arrives(tsk);
                 /* NOTE: drops state->lock */
                 TRACE("mc2_new()\n");
@@ -456,18 +567,26 @@ static void mc2_task_exit(struct task_struct *tsk)
         unsigned long flags;
         struct mc2_task_state* tinfo = get_mc2_state(tsk);
         struct mc2_cpu_state *state = cpu_state_for(tinfo->cpu);
+        enum crit_level lv = tinfo->mc2_param.crit;
+        struct crit_entry* ce;  
 
         raw_spin_lock_irqsave(&state->lock, flags);
 
         if (state->scheduled == tsk)
                 state->scheduled = NULL;
 
+        ce = &state->crit_entries[lv];
+        if (ce->running == tsk)
+                ce->running = NULL;
+        
         /* remove from queues */
         if (is_running(tsk)) {
                 /* Assumption: litmus_clock() is synchronized across cores
                  * [see comment in pres_task_resume()] */
                 sup_update_time(&state->sup_env, litmus_clock());
+                mc2_update_ghost_state(state);
                 task_departs(tsk, 0);
+                
                 /* NOTE: drops state->lock */
                 TRACE("mc2_exit()\n");
                 mc2_update_timer_and_unlock(state);
@@ -729,7 +848,7 @@ static void mc2_setup_domain_proc(void)
 
 static long mc2_activate_plugin(void)
 {
-        int cpu;
+        int cpu, lv;
         struct mc2_cpu_state *state;
 
         for_each_online_cpu(cpu) {
@@ -740,7 +859,13 @@ static long mc2_activate_plugin(void)
                 raw_spin_lock_init(&state->lock);
                 state->cpu = cpu;
                 state->scheduled = NULL;
-
+                for (lv = 0; lv < NUM_CRIT_LEVELS; lv++) {
+                        struct crit_entry *ce = &state->crit_entries[lv];
+                        ce->level = lv;
+                        ce->running = NULL;
+                        hrtimer_init(&ce->ghost_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);
+                        ce->ghost_timer.function = on_ghost_timer;
+                }
                 sup_init(&state->sup_env);
 
                 hrtimer_init(&state->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);