Added sched_trace for request and forced res_id's to be same for single task

5 files changed, 142 insertions, 64 deletions

diff --git a/include/litmus/mc2_common.h b/include/litmus/mc2_common.h
index 74a0527a20e3..fcc0652c4a43 100644
--- a/include/litmus/mc2_common.h
+++ b/include/litmus/mc2_common.h
@@ -16,7 +16,7 @@ enum crit_level {
 
 struct mc2_task {
         enum crit_level crit;
-        unsigned int res_id[NR_MODES];
+        unsigned int res_id;
         uint32_t mode_mask;
 };
 
diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index 626eb95bba34..dfc496f3054a 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -85,6 +85,11 @@ struct st_enact_mode_data {
         u8      __unused[8];
 };
 
+struct st_request_mode_data {
+        u64     when;
+        u8      __unused[8];
+};
+
 #define DATA(x) struct st_ ## x ## _data x;
 
 typedef enum {
@@ -100,7 +105,8 @@ typedef enum {
         ST_RESUME,
         ST_ACTION,
         ST_SYS_RELEASE,
-        ST_ENACT_MODE
+        ST_ENACT_MODE,
+        ST_REQUEST_MODE
 } st_event_record_type_t;
 
 struct st_event_record {
@@ -120,6 +126,7 @@ struct st_event_record {
                 DATA(action);
                 DATA(sys_release);
                 DATA(enact_mode);
+                DATA(request_mode);
         } data;
 };
 
@@ -165,6 +172,9 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
 feather_callback void do_sched_trace_enact_mode(unsigned long id,
                                                 struct task_struct* task);
 
+feather_callback void do_sched_trace_request_mode(unsigned long id,
+                                                struct task_struct* task);
+
 #endif
 
 #else
@@ -190,6 +200,7 @@ feather_callback void do_sched_trace_enact_mode(unsigned long id,
 #define trace_litmus_task_resume(t)
 #define trace_litmus_sys_release(start)
 #define trace_litmus_enact_mode(t)
+#define trace_litmus_request_mode(t)
 
 #endif
 
@@ -265,13 +276,19 @@ feather_callback void do_sched_trace_enact_mode(unsigned long id,
 
 #define sched_trace_quantum_boundary() /* NOT IMPLEMENTED */
 
-#define sched_trace_enact_mode(when)                                    \
+#define sched_trace_enact_mode(t)                                       \
         do {                                                            \
                 SCHED_TRACE(SCHED_TRACE_BASE_ID + 11,                   \
-                        do_sched_trace_enact_mode, when);               \
-                trace_litmus_enact_mode(when);                          \
+                        do_sched_trace_enact_mode, t);                  \
+                trace_litmus_enact_mode(t);                             \
         } while (0)
 
+#define sched_trace_request_mode(t)                                     \
+        do {                                                            \
+                SCHED_TRACE(SCHED_TRACE_BASE_ID + 12,                   \
+                        do_sched_trace_request_mode, t);                \
+                trace_litmus_request_mode(t);                           \
+        } while (0)
 #endif /* __KERNEL__ */
 
 #endif
diff --git a/include/trace/events/litmus.h b/include/trace/events/litmus.h
index 0fffcee02be0..fc89b23068b1 100644
--- a/include/trace/events/litmus.h
+++ b/include/trace/events/litmus.h
@@ -225,6 +225,46 @@ TRACE_EVENT(litmus_sys_release,
         TP_printk("SynRelease(%Lu) at %Lu\n", __entry->rel, __entry->when)
 );
 
+/*
+ * Trace enact mode
+ */
+TRACE_EVENT(litmus_enact_mode,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field( lt_t,          when    )
+        ),
+
+        TP_fast_assign(
+                __entry->when   = litmus_clock();
+        ),
+
+        TP_printk("Mode Enact at %Lu\n", __entry->when)
+);
+
+/*
+ * Trace notice mode request
+ */
+TRACE_EVENT(litmus_request_mode,
+
+        TP_PROTO(struct task_struct *t),
+
+        TP_ARGS(t),
+
+        TP_STRUCT__entry(
+                __field( lt_t,          when    )
+        ),
+
+        TP_fast_assign(
+                __entry->when   = litmus_clock();
+        ),
+
+        TP_printk("Mode request at %Lu\n", __entry->when)
+);      
+
 #endif /* _SCHED_TASK_TRACEPOINT_H */
 
 /* Must stay outside the protection */
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 525af34f0875..9949791e2d7a 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -111,7 +111,11 @@ raw_spinlock_t mode_lock;
 unsigned int mode_sizes[NR_MODES];
 unsigned int res_reported;
 bool cpu_0_spin_flag;
+bool seen_once;
 #define in_mode(t, modenum)     (tsk_mc2_data(t)->mode_mask & (1 << modenum))
+#define pending                 mode != requested_mode
+#define ready                   !res_reported
+
 /*
  * To be called from level A task's with period equal to
  * A and B hyperperiod
@@ -120,38 +124,21 @@ bool cpu_0_spin_flag;
 asmlinkage long sys_enact_mode(void)
 {
         struct mc2_cpu_state *state = local_cpu_state();
-        struct list_head *pos;
         struct reservation *res;
+        struct list_head *pos;
         hrtimer_cancel(&state->timer);//stop listening to old mode timers
         //lt_t now = litmus_clock();
         if (state->cpu == 0){
                 raw_spin_lock(&global_lock);
                 raw_spin_lock(&mode_lock); 
-                if (mode != requested_mode //MCR has entered 
-                        if( !res_reported){ //and C is throttled
-                                mode = requested_mode;
-                                _global_env = &_global_env_modes[mode];
-                                //set res->reported for new global tasks
-                                list_for_each(pos, &_global_env->active_reservations){
-                                        res = list_entry(pos, struct reservation, list);
-                                        res->reported = 0;
-                                }
-                                list_for_each(pos, &_global_env->depleted_reservations){
-                                        res = list_entry(pos, struct reservation, list);
-                                        res->reported = 0;
-                                }
-                                list_for_each(pos, &_global_env->inactive_reservations){
-                                        res = list_entry(pos, struct reservation, list);
-                                        res->reported = 0;
-                                        res->env->change_state(res->env, res, RESERVATION_ACTIVE);
-                                }
-                                //gmp_update_time(_global_env, now);
-                        }
-                        else{
+                if (pending){ //MCR has entered 
+                        if (!seen_once){
+                                sched_trace_request_mode(current);
+                                //clean up jobs that are already done
+                                //after this jobs report themselves
                                 list_for_each(pos, &_global_env->active_reservations){
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed){
-                                                res->env->change_state(res->env, res, RESERVATION_INACTIVE);
                                                 res->reported = 1;
                                                 res_reported--;
                                         }
@@ -159,7 +146,6 @@ asmlinkage long sys_enact_mode(void)
                                 list_for_each(pos, &_global_env->depleted_reservations){
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed){
-                                                res->env->change_state(res->env, res, RESERVATION_INACTIVE);
                                                 res->reported = 1;
                                                 res_reported--;
                                         }
@@ -168,12 +154,32 @@ asmlinkage long sys_enact_mode(void)
                                 list_for_each(pos, &_global_env->inactive_reservations){
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed){
-                                                res->env->change_state(res->env, res, RESERVATION_INACTIVE);
                                                 res->reported = 1;
                                                 res_reported--;
                                         }
                                 }
+                                seen_once = true;
+                        }
+                        if( ready ){ //C is throttled
+                                mode = requested_mode;
+                                _global_env = &_global_env_modes[mode];
+                                //set res->reported for new global tasks
+                                list_for_each(pos, &_global_env->active_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        res->reported = 0;
+                                }
+                                list_for_each(pos, &_global_env->depleted_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        res->reported = 0;
+                                }
+                                list_for_each(pos, &_global_env->inactive_reservations){
+                                        res = list_entry(pos, struct reservation, list);
+                                        res->reported = 0;
+                                }
+                                //gmp_update_time(_global_env, now);
+                                sched_trace_enact_mode(current);
                         }
+                        
                 
                 }
                 raw_spin_unlock(&mode_lock);
@@ -203,12 +209,17 @@ asmlinkage long sys_enact_mode(void)
  */
 asmlinkage long sys_request_mode(int new_mode){
         raw_spin_lock(&mode_lock);
-        if (mode != requested_mode){
+        if (pending){
                 raw_spin_unlock(&mode_lock);
                 return -EAGAIN;
         }
+        if (mode == new_mode){
+                raw_spin_unlock(&mode_lock);
+                return 0;
+        }
         requested_mode = new_mode;
         res_reported = mode_sizes[mode];
+        seen_once = false;
         raw_spin_unlock(&mode_lock);
         return 0;
 }
@@ -670,14 +681,14 @@ static long mc2_complete_job(void)
                         state = cpu_state_for(tinfo->cpu);
                         raw_spin_lock(&state->lock);
                         env = &(state->sup_env->env);
-                        res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id[mode]);
+                        res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id);
                         env->time_zero = tsk_rt(current)->sporadic_release_time;
                 }
                 else if (lv == CRIT_LEVEL_C) {
                         state = local_cpu_state();              
                         raw_spin_lock(&state->lock);
                         raw_spin_lock(&global_lock);
-                        res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id[mode]);
+                        res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id);
                         _global_env->env.time_zero = tsk_rt(current)->sporadic_release_time;
                 }
                 else
@@ -726,16 +737,15 @@ static long mc2_complete_job(void)
          */
 
         raw_spin_lock(&mode_lock);
-        if (lv == CRIT_LEVEL_C && mode != requested_mode){
+        if (lv == CRIT_LEVEL_C && pending){
                 struct reservation *res = NULL;
-                res = gmp_find_by_id(_global_env, tsk_mc2_data(current)->res_id[mode]);
+                res = gmp_find_by_id(_global_env, tsk_mc2_data(current)->res_id);
                 if (res && !res->reported){
                         res_reported--;
                 
                         res->reported = 1;
                         //Current task doesn't exist in new mode
                         if ( !in_mode(current, requested_mode)  ){
-                                res->env->change_state(res->env, res, RESERVATION_INACTIVE);
                                 raw_spin_unlock(&mode_lock);
                                 litmus_reschedule_local();
                         }
@@ -810,10 +820,14 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
         enum crit_level lv;
         lt_t time_slice;
         
+        raw_spin_lock(&mode_lock);
         list_for_each_entry_safe(res, next, &_global_env->active_reservations, list) {
                 BUG_ON(!res);
                 if (res->state == RESERVATION_ACTIVE && res->scheduled_on == NO_CPU) {
                         tsk = res->ops->dispatch_client(res, &time_slice);
+                        if (pending && res->reported && !in_mode(tsk, requested_mode)){
+                                continue;
+                        }
                         if (likely(tsk)) {
                                 lv = get_task_crit_level(tsk);
                                 if (lv == NUM_CRIT_LEVELS) {
@@ -824,6 +838,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                                         res->blocked_by_ghost = 0;
                                         res->is_ghost = NO_CPU;
                                         res->scheduled_on = state->cpu;
+                                        raw_spin_unlock(&mode_lock);
                                         return tsk;
                                 } else if (lv == CRIT_LEVEL_C) {
                                         //ce = &state->crit_entries[lv];
@@ -835,6 +850,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                                                 res->blocked_by_ghost = 0;
                                                 res->is_ghost = NO_CPU;
                                                 res->scheduled_on = state->cpu;
+                                                raw_spin_unlock(&mode_lock);
                                                 return tsk;
                                         //} else {
                                         //      res->blocked_by_ghost = 1;
@@ -847,7 +863,7 @@ struct task_struct* mc2_global_dispatch(struct mc2_cpu_state* state)
                         }
                 }
         }
-        
+        raw_spin_unlock(&mode_lock);
         return NULL;
 }
 
@@ -1145,19 +1161,19 @@ static long mc2_admit_task(struct task_struct *tsk)
                 tinfo->mc2_param.crit = mp->crit;
                 tinfo->cpu = task_cpu(tsk);
                 tinfo->has_departed = true;
-
+                tinfo->mc2_param.res_id = mp->res_id;
+                
                 for(i = 0; i < NR_MODES; i++){
                         if (!in_mode(tsk, i)){
                                 //task not present in mode
                                 continue;
                         }
 
-                        res = sup_find_by_id(&(state->sup_env_modes[i]), mp->res_id[i]);
+                        res = sup_find_by_id(&(state->sup_env_modes[i]), mp->res_id);
         
                         /* found the appropriate reservation */
                         if (res) {
                                 TRACE_TASK(tsk, "SUP FOUND RES ID\n");                  
-                                tinfo->mc2_param.res_id[i] = mp->res_id[i];
                                 
                                 /* initial values */
                                 err = err? err:mc2_task_client_init(&tinfo->res_info[i], &tinfo->mc2_param, tsk, res);
@@ -1186,19 +1202,19 @@ static long mc2_admit_task(struct task_struct *tsk)
         
                 tinfo->mc2_param.crit = mp->crit;
                 tinfo->cpu = -1;
-                tinfo->has_departed = true;
-                
+                tinfo->has_departed = true;     
+                tinfo->mc2_param.res_id = mp->res_id;
+        
                 for(i = 0; i < NR_MODES; i++){
                         if (!in_mode(tsk, i)) continue;
-                        res = gmp_find_by_id(_global_env, mp->res_id[mode]);
+                        res = gmp_find_by_id(_global_env, mp->res_id);
 
                         /* found the appropriate reservation (or vCPU) */
                         if (res) {
                                 TRACE_TASK(tsk, "GMP FOUND RES ID\n");
-                                tinfo->mc2_param.res_id[i] = mp->res_id[i];
                                 
                                 /* initial values */
-                                err = err? err:mc2_task_client_init(&tinfo->res_info[mode], &tinfo->mc2_param, tsk, res);
+                                err = err? err:mc2_task_client_init(&tinfo->res_info[i], &tinfo->mc2_param, tsk, res);
         
                         }
                 }
@@ -1265,10 +1281,10 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
 
         if (lv == CRIT_LEVEL_C) {
                 raw_spin_lock(&global_lock);
-                res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id[mode]);
+                res = gmp_find_by_id(_global_env, tinfo->mc2_param.res_id);
         }
         else {
-                res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id[mode]);
+                res = sup_find_by_id(state->sup_env, tinfo->mc2_param.res_id);
         }
         //res = res_find_by_id(state, tinfo->mc2_param.res_id);
         release = res->next_replenishment;
@@ -1328,6 +1344,7 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
 
                 /* if the reservation is global reservation */
                 //state = local_cpu_state();
+                //delete reservation id in all modes
                 for(i = 0; i < NR_MODES; i++){
                         //raw_spin_lock(&state->lock);
                 
@@ -1361,7 +1378,6 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
                         }
 
                         //raw_spin_unlock(&state->lock);
-                        if (found) break;
                 }
                 raw_spin_unlock(&global_lock);
                 local_irq_restore(flags);
@@ -1424,7 +1440,6 @@ static long mc2_reservation_destroy(unsigned int reservation_id, int cpu)
 
                         raw_spin_unlock(&state->lock);
                         local_irq_restore(flags);
-                        if (found) break;
                 }
         }
         
@@ -1531,7 +1546,6 @@ static long create_polling_reservation(
         struct reservation_config *config)
 {
         struct mc2_cpu_state *state;
-        int i;
         //struct reservation* res = NULL;
         struct polling_reservation *pres;
         unsigned long flags;
@@ -1579,13 +1593,9 @@ static long create_polling_reservation(
                 //raw_spin_lock_irqsave(&_global_env.lock, flags);
                 state = cpu_state_for(config->cpu);
                 raw_spin_lock_irqsave(&state->lock, flags);
-                //for the sake of reservation_destroy format, force id's unique across
-                //all modes
-                for(i = 0; i < NR_MODES; i++){
-                        if( sup_find_by_id(&(state->sup_env_modes[i]), config->id) ){
-                                resExist = true;
-                                break;
-                        }
+                //force reservation id unique inside of res_config->mode
+                if( sup_find_by_id(&(state->sup_env_modes[config->mode]), config->id) ){
+                        resExist = true;
                 }
                 if (!resExist) {
                         polling_reservation_init(pres, use_edf, periodic,
@@ -1615,12 +1625,9 @@ static long create_polling_reservation(
         } else {
                 raw_spin_lock_irqsave(&global_lock, flags);
                 
-                //force id's unique across all modes
-                for(i = 0; i < NR_MODES; i++){
-                        if (gmp_find_by_id(&(_global_env_modes[i]), config->id)){
-                                resExist = true;
-                                break;
-                        }
+                //force id's unique within desired mode
+                if (gmp_find_by_id(&(_global_env_modes[config->mode]), config->id)){
+                        resExist = true;
                 }
                 if (!resExist) {
                         polling_reservation_init(pres, use_edf, periodic,
@@ -1856,6 +1863,8 @@ static long mc2_activate_plugin(void)
         raw_spin_lock_init(&_lowest_prio_cpu.lock);
         raw_spin_lock_init(&mode_lock);
 
+        seen_once = false;
+
         for_each_online_cpu(cpu) {
                 TRACE("Initializing CPU%d...\n", cpu);
 
diff --git a/litmus/sched_task_trace.c b/litmus/sched_task_trace.c
index 67b5da0cb0ad..90d3fc9a299c 100644
--- a/litmus/sched_task_trace.c
+++ b/litmus/sched_task_trace.c
@@ -241,7 +241,7 @@ feather_callback void do_sched_trace_action(unsigned long id,
         }
 }
 
-feather_callback void do_sched_trace_enact(unsigned long id,
+feather_callback void do_sched_trace_enact_mode(unsigned long id,
                                                 unsigned long _task)
 {
         struct task_struct *t = (struct task_struct*) _task;
@@ -252,3 +252,15 @@ feather_callback void do_sched_trace_enact(unsigned long id,
                 put_record(rec);
         }
 }
+
+feather_callback void do_sched_trace_request_mode(unsigned long id,
+                                                unsigned long_ task)
+{
+        struct task_struct *t = (struct task_struct*) _task;
+        struct st_event_record* rec = get_record(ST_REQUEST_MODE, t);
+
+        if (rec){
+                rec->data.request_mode.when = now();
+                put_record(rec);
+        }
+}