Feature: Allow rtspin to change its execution time dynamically

New controls added to rtspin that allow the user to specify different
execution time behaviors for rtspin.  Behaviors are characterized by
waveforms.  For example, execution time may follow a sine-wave pattern
over time.  Supported waveforms are: flat, sin, triangle, box, sawtooth,
and reverse sawtooth.

2 files changed, 214 insertions, 8 deletions

diff --git a/SConstruct b/SConstruct
index c41e41e..94d5194 100644
--- a/SConstruct
+++ b/SConstruct
@@ -177,7 +177,7 @@ if not (env.GetOption('clean') or env.GetOption('help')):
 
 # link with liblitmus
 rt = env.Clone(
-    LIBS     = Split('litmus rt'),
+    LIBS     = Split('litmus rt m'),
     LIBPATH  = '.'
 )
 rt.Append(LINKFLAGS = '-static')
diff --git a/bin/rtspin.c b/bin/rtspin.c
index 650fcb3..939d507 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -4,7 +4,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <time.h>
-
+#include <math.h>
 
 #include "litmus.h"
 #include "common.h"
@@ -30,8 +30,14 @@ static double wctime()
 void usage(char *error) {
         fprintf(stderr, "Error: %s\n", error);
         fprintf(stderr,
-                "Usage: rt_spin [-w] [-p PARTITION] [-c CLASS] WCET PERIOD DURATION\n"
-                "       rt_spin -l\n");
+                "Usage: rt_spin [-w] [-p PARTITION] [-c CLASS] [-A fp# -B fp# -W wave# -M max_wcet -P #jobs [-D #jobs]] WCET PERIOD DURATION\n"
+                "       rt_spin -l\n"
+                "  -A: Feedback control 'A' parameter\n"
+                "  -B: Feedback control 'B' parameter\n"
+                "  -W: 0 = flat; 1 = sine; 2 = triangle; 3 = box; 4 = sawtooth; 5 = reverse sawtooth\n"
+                "  -M: max wcet (WCET is assumed min wcet)\n"
+                "  -P: period of execution behavior wave\n"
+                "  -D: Number of jobs wave should hold at extrema points (default = 0)\n");
         exit(1);
 }
 
@@ -133,7 +139,107 @@ static int job(double exec_time)
         return 0;
 }
 
-#define OPTSTR "p:c:wld:ve"
+fp_t float_to_frac(double f)
+{
+        fpbuf_t num;
+        fpbuf_t denom = 1000; /* express in 1000ths */
+
+        num = (fpbuf_t)f * denom;
+        if(f != floor(f))
+        {
+                num += (fpbuf_t)(f - floor(f)) * denom;
+        }
+
+        return(_frac(num, denom));
+}
+
+#define OPTSTR "p:c:wld:veA:B:W:M:P:D:"
+
+struct wave_data;
+typedef double(*wave_func)(int, struct wave_data*);
+
+struct wave_data
+{
+        double min_wcet_ms;
+        double max_wcet_ms;
+        double amplitude;
+        int period;
+        int extrema_delay;
+        int min_point;
+        int max_point;
+        wave_func f;
+};
+
+double flat_wave(int count, struct wave_data* w)
+{
+        return(w->min_wcet_ms);
+}
+
+double sin_wave(int count, struct wave_data* w)
+{
+        double step = count % w->period;
+        double exe = w->min_wcet_ms + w->amplitude * sin(M_PI*step/w->period);
+        return(exe);
+}
+
+double tri_wave(int count, struct wave_data* w)
+{
+        double step = count % w->period;
+        double v = 2.0 * (step/w->period - floor(step/w->period + 0.5));
+        double exe = w->min_wcet_ms + w->amplitude * abs(v);
+        return(exe);
+}
+
+double box_wave(int count, struct wave_data* w)
+{
+        double step = count % w->period;
+        double exe = w->min_wcet_ms + w->amplitude *((step/w->period < 0.5) ? 0 : 1);
+        return(exe);
+}
+
+double saw_wave(int count, struct wave_data* w)
+{
+        double step = (count % w->period)/2.0;
+        double v = 2.0 * (step/w->period - floor(step/w->period + 0.5));
+        double exe;
+        if(v < 0) v += 1.0;
+        exe = w->min_wcet_ms + w->amplitude * v;
+        return(exe);
+}
+
+double rsaw_wave(int count, struct wave_data* w)
+{
+        double step = (count % w->period)/2.0;
+        double v = 2.0 * (step/w->period - floor(step/w->period + 0.5));
+        double exe;
+        if(v < 0) v += 1.0;
+        exe = w->max_wcet_ms - w->amplitude * v;
+        return(exe);
+}
+
+double get_execution_time(int count, struct wave_data* w)
+{
+        static int skips = 0;
+        static int delay_count = 0;
+
+        if(w->extrema_delay)
+        {
+                int at_max = (((count - skips) % w->period) == w->max_point);
+                int at_min = (((count - skips) % w->period) == w->min_point);
+
+                if((at_max || at_min) && delay_count++ < w->extrema_delay)
+                {
+                        ++skips;
+                        return((at_max) ? w->max_wcet_ms : w->min_wcet_ms);
+                }
+                else
+                {
+                        delay_count = 0;
+                }
+        }
+
+        return(w->f(count - skips, w));
+}
 
 int main(int argc, char** argv) 
 {
@@ -152,6 +258,18 @@ int main(int argc, char** argv)
         double duration, start;
         task_class_t class = RT_CLASS_HARD;
 
+        fp_t A = LITMUS_FP_ZERO, B = LITMUS_FP_ZERO;
+        struct wave_data wave = {
+                        .min_wcet_ms = 0.0,
+                        .max_wcet_ms = 0.0,
+                        .amplitude = 0.0,
+                        .period = 0,
+                        .extrema_delay = 0,
+                        .max_point = 0,
+                        .min_point = 0,
+                        .f = NULL
+        };
+
         progname = argv[0];
 
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
@@ -183,6 +301,49 @@ int main(int argc, char** argv)
                 case 'v':
                         verbose = 1;
                         break;
+                case 'A':
+                        A = float_to_frac(atof(optarg));
+                        break;
+                case 'B':
+                        B = float_to_frac(atof(optarg));
+                        break;
+                case 'W':
+                        switch(atoi(optarg))
+                        {
+                                case 0:
+                                        wave.f = flat_wave;
+                                        break;
+                                case 1:
+                                        wave.f = sin_wave;
+                                        break;
+                                case 2:
+                                        wave.f = tri_wave;
+                                        break;
+                                case 3:
+                                        wave.f = box_wave;
+                                        break;
+                                case 4:
+                                        wave.f = saw_wave;
+                                        break;
+                                case 5:
+                                        wave.f = rsaw_wave;
+                                        break;
+                                default:
+                                        usage("Bad wave identifier.");
+                                        break;
+                        }
+                        break;
+                case 'M':
+                        wave.max_wcet_ms = atof(optarg);
+                        break;
+                case 'P':
+                        wave.period = atoi(optarg);
+                        if(wave.period <= 0)
+                                usage("Execution behavior period must be a positive number.");
+                        break;
+                case 'D':
+                        wave.extrema_delay = atoi(optarg);
+                        break;
                 case ':':
                         usage("Argument missing.");
                         break;
@@ -219,6 +380,42 @@ int main(int argc, char** argv)
                       "exceed the period.");
         }
 
+        if(wave.f != NULL)
+        {
+                wave.min_wcet_ms = wcet_ms;
+                wave.amplitude = wave.max_wcet_ms - wave.min_wcet_ms;
+                if(wave.amplitude < 0.0)
+                {
+                        usage("The max wcet must be greater than min wcet.");
+                }
+
+                if(wave.f == flat_wave)
+                {
+                        wave.max_point = 0;
+                        wave.min_point = 0;
+                }
+                else if((wave.f == sin_wave) || (wave.f == tri_wave) || (wave.f == box_wave))
+                {
+                        wave.max_point = wave.period/2;
+                        wave.min_point = 0;
+                }
+                else if(wave.f == saw_wave)
+                {
+                        wave.max_point = wave.period-1;
+                        wave.min_point = 0;
+                }
+                else if(wave.f == rsaw_wave)
+                {
+                        wave.max_point = 0;
+                        wave.min_point = wave.period-1;
+                }
+
+                if((wave.f == flat_wave) || (wave.f == box_wave))
+                {
+                        wave.extrema_delay = 0;
+                }
+        }
+
         if (migrate) {
                 ret = be_migrate_to(cpu);
                 if (ret < 0)
@@ -226,7 +423,7 @@ int main(int argc, char** argv)
         }
 
         ret = sporadic_task_ns(wcet, period, 0,
-                                   LITMUS_FP_ZERO, LITMUS_FP_ZERO,
+                                   A, B,
                                    cpu, class,
                                want_enforcement ? PRECISE_ENFORCEMENT
                                                 : NO_ENFORCEMENT,
@@ -252,8 +449,17 @@ int main(int argc, char** argv)
 
         start = wctime();
 
-        while (start + duration > wctime()) {
-                job(wcet_ms * 0.0009); /* 90% wcet, in seconds */
+        int count = 0;
+        while (start + duration > wctime())
+        {
+                if(wave.f == NULL)
+                {
+                        job(wcet_ms * 0.0009); /* 90% wcet, in seconds */
+                }
+                else
+                {
+                        job(get_execution_time(count++, &wave) * 0.0009);
+                }
         }
 
         return 0;