Generalized GPU cost predictors + EWMA. (untested)wip-gpu-rtas12

1 files changed, 172 insertions, 22 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index d368202ab8c3..8380c0f6a393 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -332,28 +332,183 @@ asmlinkage long sys_null_call(cycles_t __user *ts)
 }
 
 #if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
-void init_gpu_affinity_state(struct task_struct* p)
+static void create_gpu_cc_mr_avg(obs_history_t* obs, uint16_t window_size)
 {
-        // under-damped
-        //p->rt_param.gpu_fb_param_a = _frac(14008, 10000);
-        //p->rt_param.gpu_fb_param_b = _frac(16024, 10000);
+        obs->window_size = window_size;
+        obs->observations = kmalloc(sizeof(lt_t)*window_size, GFP_KERNEL);
+        obs->range = kmalloc(sizeof(lt_t)*(window_size-1), GFP_KERNEL);
+}
 
-#if 0
-        // emperical;
-        p->rt_param.gpu_fb_param_a[0] = _frac(7550, 10000);
-        p->rt_param.gpu_fb_param_b[0] = _frac(45800, 10000);
+static void create_gpu_cc_brute_avg(obs_history_t* obs, uint16_t window_size)
+{
+        obs->window_size = window_size;
+        obs->observations = kmalloc(sizeof(lt_t)*window_size, GFP_KERNEL);
+        obs->range = NULL;
+}
 
-        p->rt_param.gpu_fb_param_a[1] = _frac(8600, 10000);
-        p->rt_param.gpu_fb_param_b[1] = _frac(40000, 10000);
+static void create_gpu_simple_avg(obs_history_t* obs, uint16_t window_size)
+{
+        obs->window_size = 0;
+        obs->observations = NULL;
+        obs->range = NULL;
+}
 
-        p->rt_param.gpu_fb_param_a[2] = _frac(6890, 10000);
-        p->rt_param.gpu_fb_param_b[2] = _frac(40000, 10000);
+static void destroy_obs_history(obs_history_t* obs)
+{
+        if (obs->observations)
+                kfree(obs->observations);
+        if (obs->range)
+                kfree(obs->range);
+}
+
+static void create_gpu_cc_mr_ewma(obs_history_t* obs, uint16_t window_size)
+{
+        obs->window_size = window_size;
+        obs->observations = NULL;
+        obs->range = kmalloc(sizeof(lt_t)*(window_size-1), GFP_KERNEL);
+}
+
+static void create_gpu_cc_brute_ewma(obs_history_t* obs, uint16_t window_size)
+{
+        obs->window_size = window_size;
+        obs->observations = kmalloc(sizeof(lt_t)*window_size, GFP_KERNEL);
+        obs->range = NULL;
+}
+
+static void create_gpu_simple_ewma(obs_history_t* obs, uint16_t window_size)
+{
+        obs->window_size = 0;
+        obs->observations = NULL;
+        obs->range = NULL;
+}
+
+
+static void create_gpu_affinity_state(struct task_struct* p, uint8_t sigmas, uint16_t window_size)
+{
+        int i;
 
-        p->rt_param.gpu_fb_param_a[3] = _frac(7580, 10000);
-        p->rt_param.gpu_fb_param_b[3] = _frac(34590, 10000);
-#endif
         p->rt_param.gpu_migration = MIG_NONE;
         p->rt_param.last_gpu = -1;
+
+        switch (p->rt_param.prediction_mode) {
+                case SIMPLE_AVG:
+                case CC_BRUTE_AVG:
+                case CC_MR_AVG:
+                        memset(&p->rt_param.gpu_avg_est, 0, sizeof(p->rt_param.gpu_avg_est));
+                        break;
+                case SIMPLE_EWMA:
+                case CC_BRUTE_EWMA:
+                case CC_MR_EWMA:
+                        memset(&p->rt_param.gpu_ewma_est, 0, sizeof(p->rt_param.gpu_ewma_est));
+                        break;
+                default:
+                        BUG();
+                        break;
+        }
+
+        for (i = 0; i <= MIG_LAST; ++i) {
+                switch (p->rt_param.prediction_mode) {
+                        case SIMPLE_AVG:
+                                create_gpu_simple_avg(&p->rt_param.gpu_avg_est[i].history, window_size);
+                                break;
+                        case CC_BRUTE_AVG:
+                                p->rt_param.gpu_avg_est[i].sigmas = sigmas;
+                                create_gpu_cc_brute_avg(&p->rt_param.gpu_avg_est[i].history, window_size);
+                                break;
+                        case CC_MR_AVG:
+                                p->rt_param.gpu_avg_est[i].sigmas = sigmas;
+                                create_gpu_cc_mr_avg(&p->rt_param.gpu_avg_est[i].history, window_size);
+                                break;
+                        case SIMPLE_EWMA:
+                                create_gpu_simple_ewma(&p->rt_param.gpu_avg_est[i].history, window_size);
+                                break;
+                        case CC_BRUTE_EWMA:
+                                p->rt_param.gpu_ewma_est[i].sigmas = sigmas;
+                                create_gpu_cc_brute_ewma(&p->rt_param.gpu_ewma_est[i].history, window_size);
+                                break;
+                        case CC_MR_EWMA:
+                                p->rt_param.gpu_ewma_est[i].sigmas = sigmas;
+                                create_gpu_cc_mr_ewma(&p->rt_param.gpu_ewma_est[i].history, window_size);
+                                break;
+                        default:
+                                BUG();
+                                break;
+                }
+        }
+}
+
+static void destroy_gpu_affinity_state(struct task_struct* p)
+{
+        int i;
+
+        if (p->rt_param.prediction_mode == CC_BRUTE_AVG ||
+                p->rt_param.prediction_mode == CC_MR_AVG) {
+                for (i = 0; i <= MIG_LAST; ++i) {
+                        destroy_obs_history(&p->rt_param.gpu_avg_est[i].history);
+                }
+        }
+        else if (p->rt_param.prediction_mode == CC_BRUTE_EWMA ||
+                         p->rt_param.prediction_mode == CC_MR_EWMA) {
+                for (i = 0; i <= MIG_LAST; ++i) {
+                        destroy_obs_history(&p->rt_param.gpu_ewma_est[i].history);
+                }
+        }
+}
+
+asmlinkage long sys_config_gpu_affinity_predictor(void* __user arg)
+{
+        struct task_struct *t = current;
+        predictor_t params;
+
+        if (!access_ok(VERIFY_READ, arg, sizeof(params))) {
+                return -EINVAL;
+        }
+        if (__copy_from_user(&params, arg, sizeof(params))) {
+                return -EINVAL;
+        }
+
+        if (params.type != SIMPLE_AVG &&
+                params.type != SIMPLE_EWMA &&
+                params.type != CC_BRUTE_AVG &&
+                params.type != CC_BRUTE_EWMA &&
+                params.type != CC_MR_AVG &&
+                params.type != CC_MR_EWMA) {
+                return -EINVAL;
+        }
+
+        if (params.type != SIMPLE_AVG && params.type != SIMPLE_EWMA) {
+                if (params.window_size <= 10) {
+                        return -EINVAL;
+                }
+        }
+
+        if (params.type == SIMPLE_EWMA ||
+                params.type == CC_BRUTE_EWMA ||
+                params.type == CC_MR_EWMA) {
+                if (params.alpha_num > params.alpha_denom) {
+                        return -EINVAL;
+                }
+                if (params.alpha_num == 0) {
+                        return -EINVAL;
+                }
+                if (params.alpha_denom == 0) {
+                        params.alpha_denom = 1;
+                }
+        }
+
+        if (t->rt_param.prediction_mode != 0) {
+                destroy_gpu_affinity_state(t);
+        }
+
+        t->rt_param.prediction_mode = params.type;
+        create_gpu_affinity_state(t, params.sigmas, params.window_size);
+
+        return 0;
+}
+#else
+asmlinkage long sys_config_gpu_affinity_predictor(void* __user arg)
+{
+        return -EINVAL;
 }
 #endif
 
@@ -426,10 +581,6 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
                 p->rt_param.ctrl_page   = ctrl_page;
         }
 
-#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
-        init_gpu_affinity_state(p);
-#endif
-
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         INIT_BINHEAP_HANDLE(&p->rt_param.hp_blocked_tasks, prio_order);
         raw_spin_lock_init(&p->rt_param.hp_blocked_tasks_lock);
@@ -467,9 +618,6 @@ long __litmus_admit_task(struct task_struct* tsk)
 #ifdef CONFIG_LITMUS_NVIDIA
         atomic_set(&tsk_rt(tsk)->nv_int_count, 0);
 #endif
-#if defined(CONFIG_LITMUS_NVIDIA) && defined(CONFIG_LITMUS_AFFINITY_LOCKING)
-        init_gpu_affinity_state(tsk);
-#endif
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         tsk_rt(tsk)->blocked_lock = NULL;
         raw_spin_lock_init(&tsk_rt(tsk)->hp_blocked_tasks_lock);
@@ -539,6 +687,8 @@ void litmus_exit_task(struct task_struct* tsk)
                 bheap_node_free(tsk_rt(tsk)->heap_node);
                 release_heap_free(tsk_rt(tsk)->rel_heap);
 
+                destroy_gpu_affinity_state(tsk);
+
                 atomic_dec(&rt_task_count);
                 reinit_litmus_state(tsk, 1);
         }