seems to be working like this

4 files changed, 144 insertions, 18 deletions

diff --git a/include/linux/sched_trace.h b/include/linux/sched_trace.h
index 88d19e2903..308cc7dd8d 100644
--- a/include/linux/sched_trace.h
+++ b/include/linux/sched_trace.h
@@ -75,6 +75,7 @@ typedef struct {
         u16                     period;
         u16                     wcet;
         int                     tardiness;
+        unsigned int            job_no;
 } completion_record_t;
 
 typedef struct {
@@ -93,7 +94,10 @@ typedef struct {
 typedef struct {
         trace_header_t          header;
         task_info_t             task;
+        unsigned int            from:16;
+        unsigned int            to:16;
         service_level_t         new_level;
+        service_level_t         old_level;
 } service_level_change_record_t;
 
 typedef struct {
@@ -134,7 +138,9 @@ void sched_trace_server_completion(int id, unsigned int budget,
 void sched_trace_server_scheduled(int id, task_class_t class,
                                   unsigned int budget, jiffie_t deadline);
 
-void sched_trace_service_level_change(struct task_struct* t);
+void sched_trace_service_level_change(struct task_struct* t,
+                                      unsigned int from,
+                                      unsigned int to);
                                       
 void sched_trace_weight_error(struct task_struct* t, fp_t actual);
 
@@ -155,7 +161,7 @@ void sched_trace_weight_error(struct task_struct* t, fp_t actual);
 #define sched_trace_server_completion(id, budget, deadline, class)
 #define sched_trace_server_scheduled(id, class, budget, deadline)
 
-#define sched_trace_service_level_change(t)
+#define sched_trace_service_level_change(t, a, b)
 
 #define sched_trace_weight_error(x, y)
 
diff --git a/kernel/rt_domain.c b/kernel/rt_domain.c
index 53c5346411..4875c53076 100644
--- a/kernel/rt_domain.c
+++ b/kernel/rt_domain.c
@@ -98,6 +98,10 @@ struct task_struct* __take_ready_rq(rt_domain_t* rt, runqueue_t* rq, int cpu)
  */
 void __add_release(rt_domain_t* rt, struct task_struct *task) 
 {
+        TRACE("rt: adding %s/%d (%u, %u) rel=%d to release queue\n", 
+              task->comm, task->pid, get_exec_cost(task), get_rt_period(task),
+              get_release(task));
+        
         list_insert(&task->rt_list, &rt->release_queue, release_order);
 }
 
diff --git a/kernel/sched_adaptive.c b/kernel/sched_adaptive.c
index 0f00903fad..1dd2b7763c 100644
--- a/kernel/sched_adaptive.c
+++ b/kernel/sched_adaptive.c
@@ -25,6 +25,7 @@
 #include <linux/sched_plugin.h>
 #include <linux/edf_common.h>
 #include <linux/sched_trace.h>
+#include <asm/uaccess.h>
 
 #include <linux/fpmath.h>
 
@@ -132,9 +133,14 @@ static fp_t fc_a, fc_b;
 
 /* optimizer trigger */
 static jiffie_t last_optimizer_run;
+static jiffie_t optimizer_min_invocation_sep;
 static jiffie_t optimizer_period;
 static fp_t     task_error_threshold;
 
+static fp_t     system_capacity;
+/* total actual weight of the task system */
+static fp_t     total_weight; 
+
 /* optimizer time snapshot */
 jiffie_t        opt_time;
 
@@ -256,8 +262,10 @@ static noinline fp_t linear_metric(struct task_struct* t)
                     _sub(gmax, g1));
 }
 
-static noinline  unsigned long reweighted_period(fp_t ow, fp_t nw, unsigned long alloc,
-                                                 jiffie_t deadline, jiffie_t release) 
+static noinline  unsigned long reweighted_period(fp_t ow, fp_t nw, 
+                                                 unsigned long alloc,
+                                                 jiffie_t deadline, 
+                                                 jiffie_t release) 
 {
         fp_t dl;
         dl = _mul(FP(deadline - release), ow);
@@ -351,9 +359,11 @@ static int by_enactment_time(struct list_head* a, struct list_head* b)
 static void set_service_level(struct task_struct* t, unsigned int level)
 {
         service_level_t *new;
+        unsigned int old;
         BUG_ON(!t);
         BUG_ON(t->rt_param.no_service_levels <= level);
         
+        old = t->rt_param.cur_service_level;
         t->rt_param.cur_service_level  = level;
         new = t->rt_param.service_level + level;
         t->rt_param.basic_params.period = new->period;    
@@ -362,7 +372,7 @@ static void set_service_level(struct task_struct* t, unsigned int level)
 
         scheduler_signal(t, SIGUSR1);
 
-        sched_trace_service_level_change(t);
+        sched_trace_service_level_change(t, old, level);
         OPT_DBG_T(t, "service level %u activated\n", level);
 }
 
@@ -384,7 +394,8 @@ static void update_weight_estimate(struct task_struct* t)
                 get_deadline(t), get_last_release(t), exec_time, sl_period);
 
         t->rt_param.predictor_state.estimate = nw;
-        OPT_DBG_T(t, "update_weight_estimate from " _FP_ " to "_FP_"\n", fp2str(ow), fp2str(nw));
+        OPT_DBG_T(t, "update_weight_estimate from " _FP_ " to "_FP_"\n", 
+                  fp2str(ow), fp2str(nw));
         
 
         OPT_DBG_T(t, " update_weight_estimate: " _FP_ " => " _FP_ "\n", 
@@ -499,6 +510,10 @@ static void change_weight(struct task_struct* t)
                 increase_weight(t);
         else
                 decrease_weight(t);
+        OPT_DBG_T(t, "after change_weight: last_rel:%d rel:%d dl:%d\n",
+                  get_last_release(t),
+                  get_release(t),
+                  get_deadline(t));
 }
 
 /******************************************************************************/
@@ -518,6 +533,10 @@ void adaptive_optimize(void)
         unsigned int l;
         jiffie_t enactment_time;
 
+        if (time_before(jiffies, 
+                        last_optimizer_run + optimizer_min_invocation_sep))
+                return; 
+
         OPT_DBG(":::::: running adaptive optimizer\n");
         opt_time = jiffies;
 
@@ -535,8 +554,7 @@ void adaptive_optimize(void)
         }
         
         /* 2) determine current system capacity */
-        for_each_online_cpu(i)
-                M = _add(M, FP(1));     
+        M = system_capacity;
         _M = M;
         OPT_DBG("opt: system capacity: " _FP_ "\n", fp2str(M));
 
@@ -863,6 +881,12 @@ static void adaptive_job_arrival(struct task_struct* task)
         BUG_ON(list_empty(&adaptive_cpu_queue));
         BUG_ON(!task);
 
+        TRACE_TASK(task, "job_arrival: last_rel=%d rel=%d dl=%d now=%d\n",
+                   get_last_release(task), get_release(task), 
+                   get_deadline(task),
+                   jiffies);
+
+
         /* first queue arriving job */
         requeue(task);
 
@@ -892,6 +916,8 @@ static noinline  void adaptive_release_jobs(void)
         list_for_each_safe(pos, save, &adaptive.release_queue) {
                 queued = list_entry(pos, struct task_struct, rt_list);
                 if (likely(is_released(queued))) {
+                        TRACE_TASK(queued, "released rel=%d now=%d\n", 
+                                   get_release(queued), jiffies);
                         /* this one is ready to go*/
                         list_del(pos);
                         set_rt_flags(queued, RT_F_RUNNING);
@@ -972,8 +998,18 @@ static noinline void job_completion(struct task_struct *t)
         fp_t actual_weight, old_estimate;
         unsigned int lcurr = get_cur_sl(t);
         fp_t v = t->rt_param.service_level[lcurr].value;
+
+        int  non_zero_weight;
+        fp_t error_percentage;
+        int  exceeds_threshold;
+
         BUG_ON(!t);
 
+        TRACE_TASK(t, " completion, last_rel=%d rel=%d dl=%d now=%d "
+                   "period=%d\n",
+                   get_last_release(t), get_release(t), get_deadline(t),
+                   jiffies, get_rt_period(t));
+
         sched_trace_job_completion(t);
         delta = t->rt_param.times.exec_time - 
                 t->rt_param.basic_params.exec_cost;
@@ -993,18 +1029,45 @@ static noinline void job_completion(struct task_struct *t)
                   _FP_ " => " _FP_ "\n",t->rt_param.times.job_no, v,
                    _sub(get_est_weight(t), old_estimate),
                    old_estimate, get_est_weight(t));
-                        
-        if ( (!_eq(get_est_weight(t),FP(0))) && 
-             (_gt(_div(_abs(_sub(get_est_weight(t), old_estimate)),
-              get_est_weight(t)), task_error_threshold))) {
+
+        /* Now we have determined the task error.
+         * Next we release the next job. 
+         * Then we optimize. It's easier for the optimizer to deal
+         * with just-released jobs.
+         */
+
+        /* prepare for next period */
+        edf_prepare_for_next_period(t); 
+
+        TRACE_TASK(t, " prepped, last_rel=%d rel=%d dl=%d now=%d\n",
+                   get_last_release(t), get_release(t), get_deadline(t),
+                   jiffies);
+
+        if (is_released(t)) {
+                /* set flags */
+                /* prevent fake completions */
+                set_rt_flags(t, RT_F_RUNNING);
+                t->rt_param.times.last_release = 
+                        t->rt_param.times.release;              
+        }
+
+
+        non_zero_weight = !_eq(get_est_weight(t),FP(0));
+        if (non_zero_weight)
+                error_percentage = _div(_abs(_sub(get_est_weight(t), 
+                                                  old_estimate)),
+                                        get_est_weight(t));
+        else
+                error_percentage = FP(0);
+        exceeds_threshold = _gt(error_percentage, task_error_threshold);
+
+
+        if (exceeds_threshold) {
                 OPT_DBG("adaptive: optimizing due to task error threshold\n");
                 adaptive_optimize();
         }
 
-        /* set flags */
-        set_rt_flags(t, RT_F_SLEEP);
-        /* prepare for next period */
-        edf_prepare_for_next_period(t); 
+
         /* unlink */
         unlink(t);
         /* requeue
@@ -1250,12 +1313,27 @@ static int adaptive_mode_change(int new_mode)
         unsigned long flags;
         int cpu;
         cpu_entry_t *entry;
+        struct task_struct* t;
+        struct list_head* pos;
 
         if (new_mode == MODE_RT_RUN) {
                 queue_lock_irqsave(&adaptive_lock, flags);
 
+                system_capacity = FP(0);
+                for_each_online_cpu(cpu)
+                        system_capacity = _add(system_capacity, FP(1));
+
                 __rerelease_all(&adaptive, edf_release_at);
 
+                total_weight    = FP(0);
+                list_for_each(pos, &adaptive.release_queue) {
+                        t = list_entry(pos, struct task_struct, rt_list);
+                        total_weight = _add(total_weight, get_est_weight(t));
+                }
+                TRACE("adaptive: total weight: "  _FP_ 
+                      " (at mode change)\n", total_weight);
+
+
                 /* get old cruft out of the way in case we reenter real-time
                  * mode for a second time
                  */
@@ -1279,6 +1357,35 @@ static int adaptive_mode_change(int new_mode)
 }
 
 
+typedef enum {  
+        ADAPTIVE_SET_MIN_OPT_SEP = 1
+} adaptive_cmds_t;
+
+
+static int adaptive_setup(int cmd, void __user *up)
+{
+        unsigned int error = -EINVAL;
+        unsigned int val;
+
+        if (copy_from_user(&val, up, sizeof(unsigned int))) {
+                error = -EFAULT;
+                goto out;
+        }
+
+        switch (cmd) {
+        case ADAPTIVE_SET_MIN_OPT_SEP: 
+                optimizer_min_invocation_sep = val;
+                TRACE("adaptive: min opt sep set to %d\n", 
+                      optimizer_min_invocation_sep);
+                return 0;
+                break;          
+        }
+
+out:
+        return error;
+}
+
+
 /*      Plugin object   */
 static sched_plugin_t s_plugin __cacheline_aligned_in_smp = {
         .ready_to_use = 0 
@@ -1300,6 +1407,7 @@ static sched_plugin_t s_plugin __cacheline_aligned_in_smp = {
         .mode_change            = adaptive_mode_change,         \
         .wake_up_task           = adaptive_wake_up_task,        \
         .task_blocks            = adaptive_task_blocks,         \
+        .scheduler_setup        = adaptive_setup                \
 }
 
 
@@ -1313,6 +1421,7 @@ sched_plugin_t *__init init_adaptive_plugin(void)
         fc_b = _frac(  303, 1000);
         
         optimizer_period = 1000;
+        optimizer_min_invocation_sep = 50;
         task_error_threshold = _frac(1, 2);
 
         if (!s_plugin.ready_to_use)
diff --git a/kernel/sched_trace.c b/kernel/sched_trace.c
index d41c6e6b74..4cfe0c4e63 100644
--- a/kernel/sched_trace.c
+++ b/kernel/sched_trace.c
@@ -635,6 +635,7 @@ void sched_trace_job_completion(struct task_struct *t)
         tinfo(rec.task, t);
         rtinfo(rec, t);
         rec.tardiness = jiffies - t->rt_param.times.deadline;
+        rec.job_no = t->rt_param.times.job_no;
         TRACE_TASK(t, "AAATardiness : %d\n", rec.tardiness);
         put_trace(rec);
 }
@@ -724,13 +725,19 @@ void sched_trace_capacity_alloc_srv(pid_t srv, u32 srv_dl, task_class_t cls,
         put_trace(rec);
 }
 
-void sched_trace_service_level_change(struct task_struct *t)
+void sched_trace_service_level_change(struct task_struct *t, 
+                                      unsigned int from,
+                                      unsigned int to)
 {
         service_level_change_record_t rec;
         header(rec, ST_SERVICE_LEVEL_CHANGE);
         tinfo(rec.task, t);
+        rec.to = to;
+        rec.from = from;
         rec.new_level = 
-                t->rt_param.service_level[t->rt_param.cur_service_level];
+                t->rt_param.service_level[to];
+        rec.old_level = 
+                t->rt_param.service_level[from];
         put_trace(rec);
 }