4 files changed, 97 insertions, 27 deletions

diff --git a/Makefile b/Makefile
index 24c7d2a..8dd3698 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-CFLAGS=-Wall -g -Iinclude/
+CFLAGS=-Wall -g -Iinclude/ -D_XOPEN_SOURCE=600
 CPPFLAGS=-Wall -g
 
 LIBS= ./liblitmus.a
diff --git a/include/adaptive.h b/include/adaptive.h
index a67c540..21e1dfd 100644
--- a/include/adaptive.h
+++ b/include/adaptive.h
@@ -1,23 +1,35 @@
 #ifndef ADAPTIVE_H
 #define ADAPTIVE_H
 
-#define MAX_SERVICE_LEVELS 10
+#define FP_SHIFT 16
+typedef struct
+{
+        long long val;
+} fp_t;
+
+static inline fp_t f2fp(double f)
+{
+        return (fp_t) {f * (1 << FP_SHIFT)};
+}
 
+#define MAX_SERVICE_LEVELS 10
 typedef struct {
-        unsigned long   exec_cost;      
+        fp_t            weight;
         unsigned long   period;
-        /* fixed point */
-        unsigned long   utility;
+        fp_t            value;
 } service_level_t;
 
 int set_service_levels(pid_t pid, 
                        unsigned int nr_levels,
-                       service_level_t* levels);
+                       service_level_t* levels,
+                       fp_t *wt_y, 
+                       fp_t *wt_slope);
 
 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);
+                            unsigned int no_levels, service_level_t* levels,    
+                            fp_t wt_y, fp_t wt_slope);
 
 
 #endif
diff --git a/src/adaptive.c b/src/adaptive.c
index ebf662d..8dfb27b 100644
--- a/src/adaptive.c
+++ b/src/adaptive.c
@@ -11,9 +11,11 @@
 
 int set_service_levels(pid_t pid, 
                        unsigned int nr_levels,
-                       service_level_t* levels)
+                       service_level_t* levels,
+                       fp_t *wt_y, 
+                       fp_t *wt_slope)
 {
-        return syscall(__NR_set_service_levels, pid, nr_levels, levels);
+        return syscall(__NR_set_service_levels, pid, nr_levels, levels, wt_y, wt_slope);
 }
 
 
@@ -26,19 +28,25 @@ int get_cur_service_level(void)
 struct adaptive_param {
         unsigned int            no_levels;
         service_level_t*        levels;
+        fp_t                    wt_y;
+        fp_t                    wt_slope;
 };
 
 int setup_adaptive(int pid, struct adaptive_param* arg)
 {
-        return set_service_levels(pid, arg->no_levels, arg->levels);
+        return set_service_levels(pid, arg->no_levels, arg->levels, 
+                                  &arg->wt_y, &arg->wt_slope);
 }
 
 int create_adaptive_rt_task(rt_fn_t rt_prog, void *arg, 
-                            unsigned int no_levels, service_level_t* levels) 
+                            unsigned int no_levels, service_level_t* levels,
+                            fp_t wt_y, fp_t wt_slope) 
 {
         struct adaptive_param p;
         p.no_levels = no_levels;
         p.levels    = levels;
+        p.wt_y      = wt_y;
+        p.wt_slope  = wt_slope;
         return __launch_rt_task(rt_prog, arg,
                                 (rt_setup_fn_t) setup_adaptive, &p);
 }
diff --git a/src/rt_launch.c b/src/rt_launch.c
index cd98ad3..b76cb8c 100644
--- a/src/rt_launch.c
+++ b/src/rt_launch.c
@@ -22,39 +22,78 @@ int launch(void *task_info_p) {
 }
 
 void usage(char *error) {
-        fprintf(stderr, "%s\nUsage: launch_rt [-c {hrt|srt|be}] [-p <cpu>]"
-                "{<wcet> <period>|{-a wcet/period/utility}+}"
-                " program arg1 arg2 ...\n",
+        fprintf(stderr, "%s\nUsage: \nlaunch_rt supports one of two modes:\n"
+                "\n\tlaunch_rt <SPORADIC OPTIONS> program arg1 arg2 ...\n"
+                "\n\tlaunch_rt <ADAPTIVE OPTIONS> program arg1 arg2 ...\n"
+                "\nwhere:"
+                "\n\t <SPORADIC OPTIONS> = "
+                "[-c {hrt|srt|be}] [-p <cpu>] <wcet> <period>\n"
+                "\n\t <ADAPTIVE OPTIONS> = "
+                "(-a weight/period/utility)+ [-w <y intercept>+<slope>v]\n"
+                "\nExamples:"
+                "\n\trt_launch -p 2 10 100 cpu_job"
+                "\n\t  => Launch cpu_job a hard real-time task with period 100 and weight 0.1"
+                "\n\t     on CPU 2.\n"
+                "\n\trt_launch -a 0.1/100/0.4 -a 0.2/75/0.5 -w 0.2+0.3v adaptive_job"
+                "\n\t  => Launch adaptive_job with two service levels and a custom "
+                "\n\t     weight-transfer function."
+                "\n\n",
                 error);
         exit(1);
 }
 
-/* argument format should be wcet/period/utility */
+/* argument format should be weight/period/utility */
 static int parse_service_level(service_level_t* level, char* str) 
 {
-        char *wcet, *period, *utility;
-        double u;
-        wcet    = strtok(str, "/");
+        char *weight, *period, *utility;
+        double u, w;
+        weight    = strtok(str, "/");
         period  = strtok(NULL, "/");
         utility = strtok(NULL, "/");
         str     = strtok(NULL, "/");
 
-        if (str || !utility || !period || !wcet)
+        if (str || !utility || !period || !weight)
                 return 0;
 
-        level->exec_cost = atol(wcet);
-        level->period    = atol(period);
+        w = atof(weight);
         u = atof(utility);
+        level->weight = f2fp(w);
+        level->period = atol(period);
+        level->value   = f2fp(u);
+        
+        if (level->period == 0  ||
+            u <= 0.0 || u > 1.0 || w <= 0.0 || w > 1.0)
+                return 0;
+        return 1;
+}
 
-        if (level->exec_cost == 0 || level->period < level->exec_cost ||
-            u <= 0.0 || u > 1.0)
+/* argument format should be <y intercept>+<slope>v */
+static int parse_wt(fp_t *_y, fp_t *_slope, char* str) 
+{
+        char *y, *slope;
+        double yf, sf;
+        y     = strtok(str, "+");
+        slope = strtok(NULL, "v");
+        str   = strtok(NULL, "/"); /* If we find anyting at all then the
+                                    * string is malformed.
+                                    */
+        if (str || !y || !slope)
                 return 0;
 
-        level->utility = (unsigned long)  ULONG_MAX * u;
+        yf = strtof(y, &y);
+        sf = strtof(slope, &slope);     
+
+        if (*y  || *slope ||
+            yf < 0.0 || sf <= 0.0)
+                return 0;
+        
+        *_y     = f2fp(yf);
+        *_slope = f2fp(sf);
         return 1;
 }
 
-#define OPTSTR "p:c:a:"
+
+#define OPTSTR "p:c:a:w:"
 
 int main(int argc, char** argv) 
 {
@@ -69,7 +108,13 @@ int main(int argc, char** argv)
         int adaptive = 0;
         unsigned int level = 0;
         service_level_t slevel[MAX_SERVICE_LEVELS];
+        fp_t wt_y;     /* weight-transfer y intercept */
+        fp_t wt_slope; /* weight-transfer slope       */
         
+
+        wt_y     = f2fp(0.0);
+        wt_slope = f2fp(1.0);
+
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
                 switch (opt) {
                 case 'a':                                               
@@ -79,6 +124,10 @@ int main(int argc, char** argv)
                         if (!parse_service_level(slevel + level++, optarg))
                                 usage("Bad service level.");                    
                         break;
+                case 'w':
+                        if (!parse_wt(&wt_y, &wt_slope, optarg))
+                                usage("Bad weight transfer function.");
+                        break;
                 case 'p':
                         cpu = atoi(optarg);
                         break;
@@ -93,7 +142,7 @@ int main(int argc, char** argv)
                         break;
                 case '?':
                 default:
-                        usage("Unknown flag.");
+                        usage("Bad argument.");
                         break;
                 }
         }
@@ -120,7 +169,8 @@ int main(int argc, char** argv)
                         usage("Arguments missing.");       
                 info.exec_path = argv[optind];
                 info.argv      = argv + optind;
-                ret = create_adaptive_rt_task(launch, &info, level, slevel);
+                ret = create_adaptive_rt_task(launch, &info, level, slevel, 
+                                              wt_y, wt_slope);
         }