adaptive: debugging

2 files changed, 69 insertions, 27 deletions

diff --git a/kernel/litmus.c b/kernel/litmus.c
index 131fc5039e..e837850998 100644
--- a/kernel/litmus.c
+++ b/kernel/litmus.c
@@ -218,12 +218,6 @@ asmlinkage long sys_set_service_levels(pid_t pid,
         target->rt_param.service_level     = NULL;
         target->rt_param.no_service_levels = 0; 
 
-        /* count == 0 means tear down service levels*/
-        if (count == 0) {
-                retval = 0;
-                goto out;
-        }
-
         if (wt_y && wt_slope) {
                 if (copy_from_user(&target->rt_param.wt_y, wt_y, 
                                    sizeof(fp_t))) {
@@ -238,7 +232,7 @@ asmlinkage long sys_set_service_levels(pid_t pid,
                         target->rt_param.wt_slope = FP(1);
                         goto out;
                 }
-                if (_leq(target->rt_param.wt_y, FP(0)) ||
+                if (_lt(target->rt_param.wt_y, FP(0)) ||
                     _leq(target->rt_param.wt_slope, FP(0))) {
                         retval = -EINVAL;
                         target->rt_param.wt_y     = FP(0);
@@ -250,6 +244,15 @@ asmlinkage long sys_set_service_levels(pid_t pid,
                 target->rt_param.wt_slope = FP(1);
         }
 
+        TRACE_TASK(target, "set slope=" _FP_ ", y=" _FP_ "\n", 
+                   target->rt_param.wt_slope, target->rt_param.wt_y);
+
+        /* count == 0 means tear down service levels*/
+        if (count == 0) {
+                retval = 0;
+                goto out;
+        }
+
         klevels = kmalloc(sizeof(service_level_t) * count, GFP_KERNEL);
         if (!klevels) {
                 retval = -ENOMEM;
@@ -262,12 +265,18 @@ asmlinkage long sys_set_service_levels(pid_t pid,
                         kfree(klevels);
                         goto out;
                 }
-                if (level.period <= 0)
+                if (level.period <= 0) {
+                        TRACE("service level %d period <= 0\n", i);
                         goto out;
-                if (_leq(level.weight, last_weight))
+                }
+                if (_leq(level.weight, last_weight)) {
+                        TRACE("service level %d weight non-increase\n", i);
                         goto out;
-                if (_leq(level.value, last_value))
+                }
+                if (_leq(level.value, last_value)) {
+                        TRACE("service level %d value non-increase\n", i);
                         goto out;
+                }
                 last_value  = level.value;
                 last_weight = level.weight;
                 klevels[i] = level;
@@ -679,6 +688,7 @@ void exit_litmus(struct task_struct *dead_tsk)
         curr_sched_plugin->tear_down(dead_tsk);
 }
 
+
 void list_qsort(struct list_head* list, list_cmp_t less_than)
 {
         struct list_head lt;
@@ -694,6 +704,7 @@ void list_qsort(struct list_head* list, list_cmp_t less_than)
         INIT_LIST_HEAD(&geq);
 
         pivot = list->next;
+        list_del(pivot);
         list_for_each_safe(pos, extra, list) {
                 list_del(pos);
                 if (less_than(pos, pivot)) {
@@ -705,17 +716,14 @@ void list_qsort(struct list_head* list, list_cmp_t less_than)
                 }
         }
         if (n_lt < n_geq) {
-                if (n_lt > 1)
-                        list_qsort(&lt, less_than);
-                if (n_geq > 1)
-                        list_qsort(&geq, less_than);
+                list_qsort(&lt, less_than);
+                list_qsort(&geq, less_than);
         } else {
-                if (n_geq > 1)
-                        list_qsort(&geq, less_than);
-                if (n_lt > 1)
-                        list_qsort(&lt, less_than);
+                list_qsort(&geq, less_than);
+                list_qsort(&lt, less_than);
         }
         list_splice(&geq, list);
+        list_add(pivot, list);
         list_splice(&lt, list);
 }
 
diff --git a/kernel/sched_adaptive.c b/kernel/sched_adaptive.c
index a91e607105..24095e02d8 100644
--- a/kernel/sched_adaptive.c
+++ b/kernel/sched_adaptive.c
@@ -93,6 +93,11 @@
  * __take_ready).
  */
 
+/* TODO: 
+ *      - export weight error on task completion
+ *      - 
+ */
+
 
 /* cpu_entry_t - maintain the linked and scheduled state
  */
@@ -208,12 +213,12 @@ void adaptive_optimize(void)
         struct list_head *p, *extra;    
         cpu_entry_t *cpu;
         struct task_struct* t;
-        fp_t M = FP(0), w0, wl, new_M, estU = FP(0), _M;
+        fp_t M = FP(0), w0, wl, tmp, estU = FP(0), _M;
         int i;
         unsigned int l;
         jiffie_t enactment_time;
 
-        TRACE("running adaptive optimizer\n");
+        TRACE(":::::: running adaptive optimizer\n");
         opt_time = jiffies;
 
         INIT_LIST_HEAD(&list);
@@ -233,6 +238,7 @@ void adaptive_optimize(void)
         for_each_online_cpu(i)
                 M = _add(M, FP(1));     
         _M = M;
+        TRACE("opt: system capacity: " _FP_ "\n", fp2str(M));
 
         /* 3) Compute L value for all tasks, 
          *    and set tasks to service level 0, 
@@ -241,11 +247,17 @@ void adaptive_optimize(void)
          */
         list_for_each(p, &list) {
                 t  = list_entry(p, struct task_struct, rt_param.opt_list);
-                t->rt_param.opt_order = linear_metric(t);
+                t->rt_param.opt_order = linear_metric(t);               
+                TRACE_TASK(t, "est_w = " _FP_ " L = " _FP_ "\n", 
+                           get_est_weight(t),
+                           fp2str(t->rt_param.opt_order));
                 t->rt_param.opt_level = 0;
                 M = _sub(M, est_weight_at(t, 0));
                 estU = _add(estU, get_est_weight(t));
         }
+        TRACE("opt: estimated utilization: " _FP_ "\n", fp2str(estU));
+        TRACE("opt: estimated capacity at all sl=0: " _FP_ "\n", fp2str(M));
+
         
         /* 4) sort list by decreasing linear metric */
         list_qsort(&list, by_linear_metric);
@@ -258,13 +270,18 @@ void adaptive_optimize(void)
                 while (l > 1) {
                         l--;
                         wl = est_weight_at(t, l);
-                        new_M = _sub(M, _sub(wl, w0));
-                        if (_leq(FP(0), new_M)) {
+                        tmp = _sub(M, _sub(wl, w0));
+                        if (_leq(FP(0), tmp)) {
                                 /* this level fits in */
-                                M = new_M;
+                                M = tmp;
                                 t->rt_param.opt_level = l;
-                                t->rt_param.opt_dw    = _sub(get_est_weight(t), wl);
+                                t->rt_param.opt_dw    = _sub(wl, 
+                                                             get_est_weight(t));
                                 t->rt_param.opt_nw    = wl;
+                                TRACE_TASK(t, " will run at sl=%u, "
+                                           "prior=%ud dw=" _FP_ "\n",
+                                           l, get_cur_sl(t),
+                                           fp2str(t->rt_param.opt_dw));
                                 break; /* proceed to next task */
                         }
                 }
@@ -301,6 +318,7 @@ void adaptive_optimize(void)
         /* Very ugly jump, but we need to force enactment_time = 0
          * during the first iteration.
          */
+        M = _M;
         enactment_time = 0;
         goto first_iteration; 
 
@@ -321,6 +339,10 @@ void adaptive_optimize(void)
                                 /* opt_dw is negative */
                                 estU = _add(estU, t->rt_param.opt_dw);
                                 list_add(p, &list);
+                                TRACE_TASK(t, " weight decrease at %ld => estU=" 
+                                           _FP_ "\n", enactment_time, 
+                                           fp2str(estU));
+
                         } else
                                 /* stop decrease loop */
                                 break;
@@ -331,12 +353,16 @@ void adaptive_optimize(void)
                         p  = inc.next;
                         t  = list_entry(p, struct task_struct, 
                                         rt_param.opt_list);
-                        if (_leq(_add(estU, t->rt_param.opt_dw), M)) {
+                        tmp = _add(estU, t->rt_param.opt_dw)
+                        if (_leq(tmp, M)) {
                                 /* it fits */
-                                estU = _add(estU, t->rt_param.opt_dw);
+                                estU = tmp;
                                 t->rt_param.opt_change = enactment_time;
                                 list_del(p);
                                 list_add(p, &list);
+                                TRACE_TASK(t, " weight increase at %ld => estU=" 
+                                           _FP_ "\n", enactment_time, 
+                                           fp2str(estU));
                         } else
                                 /* stop increase loop */
                                 break;
@@ -369,6 +395,7 @@ void adaptive_optimize(void)
         }
 
         last_optimizer_run = jiffies;
+        
 }
 
 /* update_cpu_position - Move the cpu entry to the correct place to maintain 
@@ -800,6 +827,13 @@ static long adaptive_prepare_task(struct task_struct * t)
 
                 t->rt_param.scheduled_on       = NO_CPU;
                 t->rt_param.linked_on          = NO_CPU;
+                if (t->rt_param.no_service_levels) {
+                        t->rt_param.predictor_state.estimate = 
+                                get_sl(t, 0).weight;
+                } else
+                        t->rt_param.predictor_state.estimate = 
+                                _frac(get_exec_cost(t), get_rt_period(t));
+                
                 if (get_rt_mode() == MODE_RT_RUN)
                         /* The action is already on. 
                          * Prepare immediate release