patches

6 files changed, 84 insertions, 62 deletions

diff --git a/include/litmus/trace.h b/include/litmus/trace.h
index 24ca412e1184..eb0a07f4ba04 100644
--- a/include/litmus/trace.h
+++ b/include/litmus/trace.h
@@ -143,6 +143,9 @@ feather_callback void save_cpu_task_latency(unsigned long event, unsigned long w
 #define TS_ISR_START                    CPU_TIMESTAMP_CUR(192)
 #define TS_ISR_END                              CPU_TIMESTAMP_CUR(193)
 
+#define TS_MODE_CHANGE_START    CPU_TIMESTAMP(194)
+#define TS_MODE_CHANGE_END              CPU_TIMESTAMP(195)
+
 #define TS_RELEASE_LATENCY(when)    CPU_LTIMESTAMP(208, &(when))
 #define TS_RELEASE_LATENCY_A(when)  CPU_LTIMESTAMP(209, &(when))
 #define TS_RELEASE_LATENCY_B(when)  CPU_LTIMESTAMP(210, &(when))
diff --git a/litmus/bank_proc.c b/litmus/bank_proc.c
index 9bf3dfa99cb2..6f54b770079f 100644
--- a/litmus/bank_proc.c
+++ b/litmus/bank_proc.c
@@ -19,6 +19,9 @@
 #include <litmus/sched_trace.h>
 #include <litmus/litmus.h>
 
+//#define TRACE(fmt, args...) do {} while (false)
+//#define TRACE_TASK(fmt, args...) do {} while (false)
+
 #define LITMUS_LOCKDEP_NAME_MAX_LEN 50
 
 // This Address Decoding is used in imx6-sabredsd platform
@@ -27,7 +30,7 @@
 #define CACHE_MASK  0x0000f000      
 #define CACHE_SHIFT 12
 
-#define PAGES_PER_COLOR 1024
+#define PAGES_PER_COLOR 1000
 unsigned int NUM_PAGE_LIST;  //8*16
 
 unsigned int number_banks;
@@ -245,8 +248,8 @@ static int do_add_pages(void)
                 counter[color]++;
         //      printk("page(%d) = color %x, bank %x, [color] =%d \n", color, page_color(page), page_bank(page), atomic_read(&color_groups[color].nr_pages));
                 //show_nr_pages();
-                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR && color>=32) {
-                //if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR) {
+                //if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR && color>=32) {
+                if (atomic_read(&color_groups[color].nr_pages) < PAGES_PER_COLOR) {
                 //if ( PAGES_PER_COLOR && color>=16*2) {
                         add_page_to_color_list(page);
         //              printk("add page(%d) = color %x, bank %x\n", color, page_color(page), page_bank(page));
@@ -364,6 +367,7 @@ struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
         struct color_group *cgroup;
         struct page *rPage = NULL;
         unsigned int color;
+        int try = 0;
         
 
         unsigned int idx = 0;
@@ -373,9 +377,20 @@ struct page *new_alloc_page(struct page *page, unsigned long node, int **x)
 
         rPage =  new_alloc_page_color(idx);
         
-            
         set_index[node] = (set_index[node]+1) % counting_one_set(set_partition[node]);
         bank_index[node] = (bank_index[node]+1) % counting_one_set(bank_partition[node]);
+        while (!rPage)  {
+                try++;
+                if (try>=16)
+                        break;
+                idx = 0;
+                idx += num_by_bitmask_index(set_partition[node], set_index[node]);
+        idx += number_cachecolors* num_by_bitmask_index(bank_partition[node], bank_index[node]);
+                rPage =  new_alloc_page_color(idx);
+                set_index[node] = (set_index[node]+1) % counting_one_set(set_partition[node]);
+        bank_index[node] = (bank_index[node]+1) % counting_one_set(bank_partition[node]);
+        }
+    
         return rPage; 
 }
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 7fccc585dedd..f9ad1f405518 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -37,6 +37,9 @@
 #include <trace/events/litmus.h>
 #endif
 
+//#define TRACE(fmt, args...) do {} while (false)
+//#define TRACE_TASK(fmt, args...) do {} while (false)
+
 extern void l2c310_flush_all(void);
 
 /* Number of RT tasks that exist in the system */
diff --git a/litmus/polling_reservations.c b/litmus/polling_reservations.c
index 1cfd09169959..c6e10eb681c9 100644
--- a/litmus/polling_reservations.c
+++ b/litmus/polling_reservations.c
@@ -4,6 +4,8 @@
 #include <litmus/reservation.h>
 #include <litmus/polling_reservations.h>
 
+//#define TRACE(fmt, args...) do {} while (false)
+//#define TRACE_TASK(fmt, args...) do {} while (false)
 
 static void periodic_polling_client_arrives(
         struct reservation* res,
diff --git a/litmus/sched_mc2.c b/litmus/sched_mc2.c
index 3ccee282ffdf..ec8a92440f2b 100644
--- a/litmus/sched_mc2.c
+++ b/litmus/sched_mc2.c
@@ -128,17 +128,21 @@ asmlinkage long sys_enact_mode(void)
         struct mc2_cpu_state *state = local_cpu_state();
         struct reservation *res;
         struct list_head *pos;
+        unsigned long flags;
         //lt_t now = litmus_clock();
         TRACE_TASK(current, "ENACTING MODE TASK\n");
         if (state->cpu == 0){
-                preempt_disable();
-                raw_spin_lock(&global_lock);
-                raw_spin_lock(&mode_lock); 
+                //preempt_disable();
                 mode_changed = false;
+                local_irq_save(flags);
+        
+                raw_spin_lock(&global_lock);
+                raw_spin_lock(&mode_lock);
                 if (pending){ //MCR has entered 
                         if (!seen_once){
-                                TRACE_TASK(current, "NOTICED MCR in mode %d\n", mode);
+                                TRACE_TASK(current, "REQUEST = %llu\n", litmus_clock());
                                 sched_trace_request_mode(current);
+                                TS_MODE_CHANGE_START;
                                 //clean up jobs that are already done
                                 //after this jobs report themselves
                                 list_for_each(pos, &_global_env->active_reservations){
@@ -162,7 +166,7 @@ asmlinkage long sys_enact_mode(void)
                                         res = list_entry(pos, struct reservation, list);
                                         if (tsk_rt(res->tsk)->completed && res->mode == mode){
                                                 res->reported = 1;
-                                                TRACE_CUR("R%d RES_REPORTED_INACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
+                                                //TRACE_CUR("R%d RES_REPORTED_INACTIVE = %d mode %d\n", res->id, res_reported, res->mode);
                                                 res_reported--;
                                         }
                                 }
@@ -170,8 +174,8 @@ asmlinkage long sys_enact_mode(void)
                         }
                         if( ready ){ //C is throttled
                                 lt_t new_mode_basetime = get_release(current);
-                                
-                                TRACE("Timer canceled\n");
+                                lt_t t;
+                                //TRACE("Timer canceled\n");
                                 hrtimer_cancel(&state->timer);//stop listening to old mode timers
                                 mode = requested_mode;
                                 TRACE("Mode has been changed.\n");
@@ -210,19 +214,18 @@ asmlinkage long sys_enact_mode(void)
                                         release_at(res->tsk, new_mode_basetime);
                                 }
                                 //raw_spin_unlock(&state->lock);
-                
+                                t=litmus_clock();
                                 sched_trace_enact_mode(current);
+                                TS_MODE_CHANGE_END;
+                                TRACE(KERN_ALERT "ENACT = %llu\n", t);
                         }
                         
                 
                 }
                 raw_spin_unlock(&mode_lock);
                 raw_spin_unlock(&global_lock);
-                //release other CPUs
+                local_irq_restore(flags);
                 cpu_0_spin_flag = !cpu_0_spin_flag;
-
-                preempt_enable();
-                TRACE_CUR("flag = %d\n",cpu_0_spin_flag);
         }
         else if (cpu_0_task_exist) {
                 //spin, wait for CPU 0 to stabilize mode decision
@@ -242,9 +245,11 @@ asmlinkage long sys_enact_mode(void)
                 //TRACE("CPU%d flag check. %d\n",state->cpu, mode_changed);
                 if (mode_changed) {
                         lt_t new_mode_basetime = get_release(current);
-                        TRACE("CPU%d mode changed\n",state->cpu);
+                        //TRACE("CPU%d mode changed\n",state->cpu);
                         hrtimer_cancel(&state->timer); //stop listening to old mode timers
                         //preempt_disable();
+                        local_irq_save(flags);
+        
                         raw_spin_lock(&state->lock);
                         state->sup_env = &state->sup_env_modes[mode];
                         list_for_each(pos, &state->sup_env->active_reservations){
@@ -260,20 +265,24 @@ asmlinkage long sys_enact_mode(void)
                                 release_at(res->tsk, new_mode_basetime);
                         }
                         raw_spin_unlock(&state->lock);
+                        local_irq_restore(flags);
+        
                         //preempt_enable();
                 }
                 state->spin_flag = !state->spin_flag;
         }
         else {
-                TRACE("CPU%d no cpu_0_task_exist.%d\n",state->cpu, mode_changed);
+                //TRACE("CPU%d no cpu_0_task_exist.%d\n",state->cpu, mode_changed);
+                local_irq_restore(flags);
                 return 0;
         }
-        TRACE("CPU%d everyone should get this.%d\n",state->cpu, mode_changed);
+        TRACE("CPU%d enact syscall ends m_c? %d\n",state->cpu, mode_changed);
         //if mode didn't change this has no effect on what's being scheduled
-        raw_spin_lock(&state->lock);
+        //raw_spin_lock(&state->lock);
         state->sup_env = &state->sup_env_modes[mode];
-        raw_spin_unlock(&state->lock);
+        //raw_spin_unlock(&state->lock);
         //sup_update_time(state->sup_env, litmus_clock());
+
         return 0;
 }
 
@@ -451,6 +460,9 @@ static int get_lowest_prio_cpu(lt_t priority)
         int cpu, ret = NO_CPU;
         lt_t latest_deadline = 0;
         
+        if (priority == LITMUS_NO_PRIORITY)
+                return ret;
+
         ce = &_lowest_prio_cpu.cpu_entries[local_cpu_state()->cpu];
         if (!ce->will_schedule && !ce->scheduled) {
                 TRACE("CPU %d (local) is the lowest!\n", ce->cpu);
@@ -529,8 +541,8 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
                 if (event->next_update < litmus_clock()) {
                         if (event->timer_armed_on == NO_CPU) {
                                 struct reservation *res = gmp_find_by_id(_global_env, event->id);
-                                int cpu = get_lowest_prio_cpu(res?res->priority:0);
-                                TRACE("GLOBAL EVENT PASSED!! poking CPU %d to reschedule\n", cpu);
+                                int cpu = get_lowest_prio_cpu(res?res->priority:LITMUS_NO_PRIORITY);
+                                //TRACE("GLOBAL EVENT PASSED!! poking CPU %d to reschedule\n", cpu);
                                 list_del(&event->list);
                                 kfree(event);
                                 if (cpu != NO_CPU) {
@@ -594,17 +606,15 @@ static void mc2_update_timer_and_unlock(struct mc2_cpu_state *state)
                  */
                 TRACE("mc2_update_timer for remote CPU %d (update=%llu, "
                       "active:%d, set:%llu)\n",
-                        state->cpu,
-                        update,
-                        hrtimer_active(&state->timer),
+                        state->cpu, update, hrtimer_active(&state->timer),
                         ktime_to_ns(hrtimer_get_expires(&state->timer)));
                 if (!hrtimer_active(&state->timer) ||
                     ktime_to_ns(hrtimer_get_expires(&state->timer)) > update) {
                         TRACE("poking CPU %d so that it can update its "
-                               "scheduling timer (active:%d, set:%llu)\n",
-                               state->cpu,
-                               hrtimer_active(&state->timer),
-                               ktime_to_ns(hrtimer_get_expires(&state->timer)));
+                              "scheduling timer (active:%d, set:%llu)\n",
+                              state->cpu,
+                              hrtimer_active(&state->timer),
+                              ktime_to_ns(hrtimer_get_expires(&state->timer)));
                         //litmus_reschedule(state->cpu);
 /*
                         raw_spin_lock(&state->lock);
@@ -679,7 +689,6 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
         TS_ISR_START;
         
         TRACE("Timer fired at %llu\n", litmus_clock());
-        //raw_spin_lock_irqsave(&_global_env.lock, flags);
         raw_spin_lock_irqsave(&state->lock, flags);
         now = litmus_clock();
         sup_update_time(state->sup_env, now);
@@ -718,7 +727,6 @@ static enum hrtimer_restart on_scheduling_timer(struct hrtimer *timer)
         } 
         raw_spin_unlock(&global_lock);
         raw_spin_unlock_irqrestore(&state->lock, flags);
-        //raw_spin_unlock_irqrestore(&_global_env.lock, flags);
         
         TS_ISR_END;
         
@@ -811,7 +819,7 @@ static long mc2_complete_job(void)
                 res->cur_budget = 0;
                 res->env->change_state(res->env, res, RESERVATION_DEPLETED);
                 
-                TRACE_CUR("CHANGE NEXT_REP = %llu NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env->next_scheduler_update);
+        //      TRACE_CUR("CHANGE NEXT_REP = %llu NEXT_UPDATE = %llu\n", res->next_replenishment, state->sup_env->next_scheduler_update);
                 
                 //if (lv < CRIT_LEVEL_C)
 //                      raw_spin_unlock(&state->lock);
@@ -901,7 +909,6 @@ struct task_struct* mc2_dispatch(struct sup_reservation_environment* sup_env, st
                                         sup_scheduler_update_after(sup_env, res->cur_budget);
                                         return tsk;
                                 } else {
-                                        TRACE_TASK(tsk, "@@@@@DISPATCH@@@@@@@ init_finished? %s\n", is_init_finished(tsk)?"true":"false");
                                         if (!is_init_finished(tsk)) {
                                                 //ce = &state->crit_entries[lv];
                                                 sup_scheduler_update_after(sup_env, res->cur_budget);
@@ -1132,7 +1139,6 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
         if (prev != state->scheduled && is_realtime(prev)) {
                 struct mc2_task_state* tinfo = get_mc2_state(prev);
                 struct reservation* res = tinfo->res_info[mode].client.reservation;
-                TRACE_TASK(prev, "PREEPT_COUNT %d\n", preempt_count());
                 if (res) {
                         TRACE_TASK(prev, "PREV JOB was scheduled_on = P%d\n", res->scheduled_on);
                         res->scheduled_on = NO_CPU;
@@ -1142,7 +1148,7 @@ static struct task_struct* mc2_schedule(struct task_struct * prev)
                 if (tinfo->has_departed == false && get_task_crit_level(prev) == CRIT_LEVEL_C) {
                         int cpu;
                         raw_spin_lock(&global_lock);
-                        cpu = get_lowest_prio_cpu(res?res->priority:0);
+                        cpu = get_lowest_prio_cpu(res?res->priority:LITMUS_NO_PRIORITY);
                         if (cpu != NO_CPU && _lowest_prio_cpu.cpu_entries[cpu].will_schedule == false) {
                                 //raw_spin_lock(&_lowest_prio_cpu.lock);
                                 _lowest_prio_cpu.cpu_entries[cpu].will_schedule = true;
@@ -1195,7 +1201,6 @@ static void resume_legacy_task_model_updates(struct task_struct *tsk)
                 now = litmus_clock();
                 if (is_tardy(tsk, now)) {
                         release_at(tsk, now);
-                        //sched_trace_task_release(tsk);
                 }
         }
 }
@@ -1224,7 +1229,7 @@ static void mc2_task_resume(struct task_struct  *tsk)
         if (tinfo->has_departed)
         {
                 /* We don't want to consider jobs before synchronous releases */
-                if (tsk_rt(tsk)->job_params.job_no > 4) {
+                if (tsk_rt(tsk)->job_params.job_no > 3) {
                         switch(get_task_crit_level(tsk)) {
                                 case CRIT_LEVEL_A:
                                         TS_RELEASE_LATENCY_A(get_release(tsk));
@@ -1238,7 +1243,7 @@ static void mc2_task_resume(struct task_struct  *tsk)
                                 default:
                                         break;
                         }
-                        TRACE_CUR("INIT_FINISHED is SET\n");
+                //      TRACE_CUR("INIT_FINISHED is SET\n");
                         tsk_mc2_data(tsk)->init_finished = 1;
                 }
 
@@ -1293,14 +1298,11 @@ static long mc2_admit_task(struct task_struct *tsk)
                 return -ENOMEM;
 
         if (!mp) {
-                printk(KERN_ERR "mc2_admit_task: criticality level has not been set\n");
                 TRACE("mc2_admit_task: criticality level has not been set\n");
                 return -ESRCH;
         }
         
         lv = mp->crit;
-        preempt_disable();
-
 
         if (lv < CRIT_LEVEL_C) {
                 state = cpu_state_for(task_cpu(tsk));
@@ -1312,14 +1314,14 @@ static long mc2_admit_task(struct task_struct *tsk)
                 tinfo->mc2_param.res_id = mp->res_id;
                 tinfo->mc2_param.mode_mask = mp->mode_mask;
                 tinfo->mc2_param.init_finished = 0;
-                TRACE_TASK(tsk, "mode_mask = %x\n", mp->mode_mask);
+//              TRACE_TASK(tsk, "mode_mask = %x\n", mp->mode_mask);
                 
-                TRACE_TASK(tsk, "Mode 0\n");
+//              TRACE_TASK(tsk, "Mode 0\n");
                 res = sup_find_by_id(&(state->sup_env_modes[0]), mp->res_id);
         
                 /* found the appropriate reservation */
                 if (res) {
-                        TRACE_TASK(tsk, "SUP FOUND RES ID in mode 0\n");                        
+//                      TRACE_TASK(tsk, "SUP FOUND RES ID in mode 0\n");                        
                         
                         /* initial values */
                         err = err? err:mc2_task_client_init(&tinfo->res_info[0], &tinfo->mc2_param, tsk, res);
@@ -1334,12 +1336,12 @@ static long mc2_admit_task(struct task_struct *tsk)
                                 //task not present in mode
                                 continue;
                         }
-                        TRACE_TASK(tsk, "Mode %d\n",i);
+//                      TRACE_TASK(tsk, "Mode %d\n",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 in mode %d\n", i);                    
+        //                      TRACE_TASK(tsk, "SUP FOUND RES ID in mode %d\n", i);                    
                                 
                                 /* initial values */
                                 err = err? err:mc2_task_client_init(&tinfo->res_info[i], &tinfo->mc2_param, tsk, res);
@@ -1355,18 +1357,16 @@ static long mc2_admit_task(struct task_struct *tsk)
                         tsk_rt(tsk)->plugin_state = tinfo;
                         tsk_rt(tsk)->task_params.budget_policy = NO_ENFORCEMENT;
                 }
-                TRACE_CUR("ctrl_page mode_poll_task %d, cpu = %d, tsk_rt->ctrl_page = %x\n", tsk_rt(tsk)->ctrl_page->mode_poll_task, tinfo->cpu, tsk_rt(tsk)->ctrl_page);
+
                 if (is_mode_poll_task(tsk) && tinfo->cpu == 0) {
-                        TRACE_CUR("CPU0_TASK_EXIST set\n");
                         cpu_0_task_exist = true;
                 }
 
                 raw_spin_unlock_irqrestore(&state->lock, flags);
         } else if (lv == CRIT_LEVEL_C) {
-                TRACE_TASK(tsk, "Task being admitted is Level C\n");
+//              TRACE_TASK(tsk, "Task being admitted is Level C\n");
                 state = local_cpu_state();
                 raw_spin_lock_irqsave(&state->lock, flags);
-                raw_spin_lock(&global_lock);
                 //state = local_cpu_state();
                 
                 //raw_spin_lock(&state->lock);
@@ -1378,14 +1378,16 @@ static long mc2_admit_task(struct task_struct *tsk)
                 tinfo->mc2_param.mode_mask = mp->mode_mask;
                 tinfo->mc2_param.init_finished = 0;
                 
-                TRACE_TASK(tsk, "mode_mask = %x\n", mp->mode_mask);
+        //      TRACE_TASK(tsk, "mode_mask = %x\n", mp->mode_mask);
                 
-                TRACE_TASK(tsk, "Mode 0\n");
+//              TRACE_TASK(tsk, "Mode 0\n");
+
+                raw_spin_lock(&global_lock);
                 res = gmp_find_by_id(&(_global_env_modes[0]), mp->res_id);
         
                 /* found the appropriate reservation */
                 if (res) {
-                        TRACE_TASK(tsk, "GMP FOUND RES ID in mode 0\n");                        
+                //      TRACE_TASK(tsk, "GMP FOUND RES ID in mode 0\n");                        
                         
                         /* initial values */
                         err = err? err:mc2_task_client_init(&tinfo->res_info[0], &tinfo->mc2_param, tsk, res);
@@ -1428,12 +1430,11 @@ static long mc2_admit_task(struct task_struct *tsk)
                 raw_spin_unlock_irqrestore(&state->lock, flags);        
         }
         
-        preempt_enable();
 
         if (err)
                 kfree(tinfo);
 
-        TRACE_TASK(tsk, "MC2 task admitted %d\n", err);
+        //TRACE_TASK(tsk, "MC2 task admitted %d\n", err);
         return err;
 }
 
@@ -1460,7 +1461,6 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
         else 
                 state = cpu_state_for(tinfo->cpu);
         
-        local_irq_save(flags);
         
         /* acquire the lock protecting the state and disable interrupts */
         //raw_spin_lock(&_global_env.lock);
@@ -1471,6 +1471,7 @@ static void mc2_task_new(struct task_struct *tsk, int on_runqueue,
                 litmus_reschedule_local();
         }
         
+        local_irq_save(flags);
         raw_spin_lock(&state->lock);
 
         if (lv == CRIT_LEVEL_C) {
@@ -1778,8 +1779,7 @@ static long create_polling_reservation(
         /* sanity checks */
         if (config->polling_params.budget >
             config->polling_params.period) {
-                printk(KERN_ERR "invalid polling reservation (%u): "
-                       "budget > period\n", config->id);
+                printk(KERN_ERR "invalid polling reservation (%u): "   "budget > period\n", config->id);
                 return -EINVAL;
         }
         if (config->polling_params.budget >
@@ -2160,7 +2160,7 @@ static long mc2_activate_plugin(void)
         }
         _global_env = &_global_env_modes[0];
         
-        raw_spin_lock_init(&_lowest_prio_cpu.lock);
+        //raw_spin_lock_init(&_lowest_prio_cpu.lock);
         raw_spin_lock_init(&mode_lock);
         raw_spin_lock_init(&global_lock);
 
@@ -2188,7 +2188,6 @@ static long mc2_activate_plugin(void)
                 //      cr_entry->level = lv;
                 //      cr_entry->running = NULL;
                 //}
-                
                 for(i = 0; i < NR_MODES; i++){
                         sup_init(&(state->sup_env_modes[i]));
                 }
diff --git a/litmus/sync.c b/litmus/sync.c
index 5d180603f46b..5955c5777786 100644
--- a/litmus/sync.c
+++ b/litmus/sync.c
@@ -52,7 +52,7 @@ static long do_wait_for_ts_release(void)
         if (!ret) {
                 /* Completion succeeded, setup release time. */
                 ret = litmus->wait_for_release_at(
-                        wait.ts_release_time + get_rt_phase(current));
+                        wait.ts_release_time + get_rt_phase(current)+1000000000);
         } else {
                 /* We were interrupted, must cleanup list. */
                 mutex_lock(&task_release_lock);