Implement user space adaptive task launching interface.

6 files changed, 191 insertions, 34 deletions

diff --git a/Makefile b/Makefile
index 10f57dd..24c7d2a 100644
--- a/Makefile
+++ b/Makefile
@@ -39,5 +39,5 @@ rt_launch: liblitmus.a litmus.h rt_launch.o
 edfhsb: liblitmus.a edf-hsb.o litmus.h edf-hsb.h hrt.o
         cc -o edfhsb hrt.o edf-hsb.o  ${LIBS}
 
-liblitmus.a: litmus.o litmus.h edf-hsb.o edf-hsb.h
-        ${AR} rcs liblitmus.a litmus.o edf-hsb.o 
+liblitmus.a: litmus.o adaptive.o adaptive.h litmus.h edf-hsb.o edf-hsb.h
+        ${AR} rcs liblitmus.a litmus.o adaptive.o edf-hsb.o 
diff --git a/include/adaptive.h b/include/adaptive.h
new file mode 100644
index 0000000..a67c540
--- /dev/null
+++ b/include/adaptive.h
@@ -0,0 +1,23 @@
+#ifndef ADAPTIVE_H
+#define ADAPTIVE_H
+
+#define MAX_SERVICE_LEVELS 10
+
+typedef struct {
+        unsigned long   exec_cost;      
+        unsigned long   period;
+        /* fixed point */
+        unsigned long   utility;
+} service_level_t;
+
+int set_service_levels(pid_t pid, 
+                       unsigned int nr_levels,
+                       service_level_t* levels);
+
+int get_cur_service_level(void);
+
+int create_adaptive_rt_task(rt_fn_t rt_prog, void *arg, 
+                            unsigned int no_levels, service_level_t* levels);
+
+
+#endif
diff --git a/include/litmus.h b/include/litmus.h
index 3595919..01503aa 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -8,6 +8,7 @@
 #define CLONE_REALTIME          0x10000000      
 
 typedef int (*rt_fn_t)(void*);
+typedef int (*rt_setup_fn_t)(int pid, void* arg);
 
 /*      Litmus scheduling policies      */
 typedef enum {
@@ -99,6 +100,7 @@ void init_litmus(void);
 #define exit_litmus() {}
 
 
+
 int create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period);
 int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, 
                      int period, task_class_t cls);
@@ -111,4 +113,10 @@ void exit_np(void);
 
 int litmus_task_active();
 
+
+/* low level operations, not intended for API use */
+int fork_rt(void);
+int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, 
+                     rt_setup_fn_t setup, void* setup_arg);
+
 #endif
diff --git a/src/adaptive.c b/src/adaptive.c
new file mode 100644
index 0000000..ebf662d
--- /dev/null
+++ b/src/adaptive.c
@@ -0,0 +1,45 @@
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "litmus.h"
+#include "adaptive.h"
+
+#define __NR_set_service_levels         346
+#define __NR_get_cur_service_level      347
+
+
+
+int set_service_levels(pid_t pid, 
+                       unsigned int nr_levels,
+                       service_level_t* levels)
+{
+        return syscall(__NR_set_service_levels, pid, nr_levels, levels);
+}
+
+
+int get_cur_service_level(void)
+{
+        return syscall(__NR_get_cur_service_level);
+}
+
+
+struct adaptive_param {
+        unsigned int            no_levels;
+        service_level_t*        levels;
+};
+
+int setup_adaptive(int pid, struct adaptive_param* arg)
+{
+        return set_service_levels(pid, arg->no_levels, arg->levels);
+}
+
+int create_adaptive_rt_task(rt_fn_t rt_prog, void *arg, 
+                            unsigned int no_levels, service_level_t* levels) 
+{
+        struct adaptive_param p;
+        p.no_levels = no_levels;
+        p.levels    = levels;
+        return __launch_rt_task(rt_prog, arg,
+                                (rt_setup_fn_t) setup_adaptive, &p);
+}
+
diff --git a/src/litmus.c b/src/litmus.c
index 9a2ebea..b39da7f 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -63,6 +63,12 @@ type name(type1 arg1,type2 arg2) \
 
 _syscall2(int, raw_clone, unsigned long, flags, unsigned long, child_stack)
 
+int fork_rt(void) 
+{
+        int rt_task = raw_clone(CLONE_LITMUS, 0);
+        return rt_task;
+}
+
 
 const char* get_scheduler_name(spolicy scheduler) 
 {
@@ -103,27 +109,20 @@ const char* get_scheduler_name(spolicy scheduler)
         return name;
 }
 
-int create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period) {
-        return __create_rt_task(rt_prog, arg, cpu, wcet, period, RT_CLASS_HARD);
-}
 
-int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
-                     task_class_t class) 
+/* common launch routine */
+int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, rt_setup_fn_t setup, 
+                     void* setup_arg) 
 {
         int ret;
-        rt_param_t params;
-        int rt_task = raw_clone(CLONE_LITMUS, 0);
+        int rt_task = fork_rt();
 
         if (rt_task < 0) 
                 return rt_task;
 
         if (rt_task > 0) {
                 /* we are the controller task */                        
-                params.period      = period;
-                params.exec_cost   = wcet;
-                params.cpu         = cpu;
-                params.cls         = class;
-                ret = set_rt_task_param(rt_task, &params);
+                ret = setup(rt_task, setup_arg);
                 if (ret < 0) {
                         /* we have a problem: we created the task but
                          * for some stupid reason we cannot set the real-time
@@ -138,7 +137,7 @@ int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
                 ret = prepare_rt_task(rt_task);
                 if (ret < 0) {
                         /* same problem as above*/
-                        //kill(rt_task, SIGKILL);
+                        kill(rt_task, SIGKILL);
                         rt_task = -1;
                 }
                 return rt_task;
@@ -148,10 +147,43 @@ int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
                  * launch task and die when it is done
                  */             
                 
-                exit(rt_prog(arg));
+                exit(rt_prog(rt_arg));
         }
 }
 
+struct create_rt_param {
+        int cpu;
+        int wcet;
+        int period;
+        task_class_t class;
+};
+
+int setup_create_rt(int pid, struct create_rt_param* arg)
+{
+        rt_param_t params;
+        params.period      = arg->period;
+        params.exec_cost   = arg->wcet;
+        params.cpu         = arg->cpu;
+        params.cls         = arg->class;
+        return set_rt_task_param(pid, &params);
+}
+
+int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
+                     task_class_t class) 
+{
+        struct create_rt_param params;
+        params.cpu = cpu;
+        params.period = period;
+        params.wcet = wcet;
+        params.class = class;