1 files changed, 161 insertions, 100 deletions

diff --git a/bin/rtspin.c b/bin/rtspin.c
index 20ce734..28c4a4e 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -4,40 +4,98 @@
 #include <stdlib.h>
 #include <unistd.h>
 #include <time.h>
+#include <assert.h>
 
 
 #include "litmus.h"
 #include "common.h"
 
 
-static double cputime()
+
+static void usage(char *error) {
+        fprintf(stderr, "Error: %s\n", error);
+        fprintf(stderr,
+                "Usage:\n"
+                "       rt_spin [COMMON-OPTS] WCET PERIOD DURATION\n"
+                "       rt_spin [COMMON-OPTS] -f FILE [-o COLUMN] WCET PERIOD\n"
+                "       rt_spin -l\n"
+                "\n"
+                "COMMON-OPTS = [-w] [-p PARTITION] [-c CLASS] [-s SCALE]\n"
+                "\n"
+                "WCET and PERIOD are milliseconds, DURATION is seconds.\n");
+        exit(EXIT_FAILURE);
+}
+
+/*
+ * returns the character that made processing stop, newline or EOF
+ */
+static int skip_to_next_line(FILE *fstream)
 {
-        struct timespec ts;
-        int err;
-        err = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
-        if (err != 0)
-                perror("clock_gettime");
-        return (ts.tv_sec + 1E-9 * ts.tv_nsec);
+        int ch;
+        for (ch = fgetc(fstream); ch != EOF && ch != '\n'; ch = fgetc(fstream));
+        return ch;
 }
 
-static double wctime()
+static void skip_comments(FILE *fstream)
 {
-        struct timeval tv;
-        gettimeofday(&tv, NULL);
-        return (tv.tv_sec + 1E-6 * tv.tv_usec);
+        int ch;
+        for (ch = fgetc(fstream); ch == '#'; ch = fgetc(fstream))
+                skip_to_next_line(fstream);
+        ungetc(ch, fstream);
 }
 
-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");
-        exit(1);
+static void get_exec_times(const char *file, const int column,
+                           int *num_jobs,    double **exec_times)
+{
+        FILE *fstream;
+        int  cur_job, cur_col, ch;
+        *num_jobs = 0;
+
+        fstream = fopen(file, "r");
+        if (!fstream)
+                bail_out("could not open execution time file");
+
+        /* figure out the number of jobs */
+        do {
+                skip_comments(fstream);
+                ch = skip_to_next_line(fstream);
+                if (ch != EOF)
+                        ++(*num_jobs);
+        } while (ch != EOF);
+
+        if (-1 == fseek(fstream, 0L, SEEK_SET))
+                bail_out("rewinding file failed");
+
+        /* allocate space for exec times */
+        *exec_times = calloc(*num_jobs, sizeof(*exec_times));
+        if (!*exec_times)
+                bail_out("couldn't allocate memory");
+
+        for (cur_job = 0; cur_job < *num_jobs && !feof(fstream); ++cur_job) {
+
+                skip_comments(fstream);
+
+                for (cur_col = 1; cur_col < column; ++cur_col) {
+                        /* discard input until we get to the column we want */
+                        fscanf(fstream, "%*s,");
+                }
+
+                /* get the desired exec. time */
+                if (1 != fscanf(fstream, "%lf", (*exec_times)+cur_job)) {
+                        fprintf(stderr, "invalid execution time near line %d\n",
+                                        cur_job);
+                        exit(EXIT_FAILURE);
+                }
+
+                skip_to_next_line(fstream);
+        }
+
+        assert(cur_job == *num_jobs);
+        fclose(fstream);
 }
 
 #define NUMS 4096
 static int num[NUMS];
-static double loop_length = 1.0;
 static char* progname;
 
 static int loop_once(void)
@@ -48,74 +106,40 @@ static int loop_once(void)
         return j;
 }
 
-static int loop_for(double exec_time)
+static int loop_for(double exec_time, double emergency_exit)
 {
-        double t = 0;
-        int tmp = 0;    
-/*      while (t + loop_length < exec_time) {
-                tmp += loop_once();
-                t += loop_length;
-        }
-*/
+        double last_loop = 0, loop_start;
+        int tmp = 0;
+
         double start = cputime();
         double now = cputime();
-        while (now + loop_length < start + exec_time) {
+
+        while (now + last_loop < start + exec_time) {
+                loop_start = now;
                 tmp += loop_once();
-                t += loop_length;
                 now = cputime();
+                last_loop = now - loop_start;
+                if (emergency_exit && wctime() > emergency_exit) {
+                        /* Oops --- this should only be possible if the execution time tracking
+                         * is broken in the LITMUS^RT kernel. */
+                        fprintf(stderr, "!!! rtspin/%d emergency exit!\n", getpid());
+                        fprintf(stderr, "Something is seriously wrong! Do not ignore this.\n");
+                        break;
+                }
         }
 
         return tmp;
 }
 
-static void fine_tune(double interval)
-{
-        double start, end, delta;
-
-        start = wctime();
-        loop_for(interval);
-        end = wctime();
-        delta = (end - start - interval) / interval;
-        if (delta != 0)
-                loop_length = loop_length / (1 - delta);
-}
-
-static void configure_loop(void)
-{
-        double start;
-
-        /* prime cache */
-        loop_once();
-        loop_once();
-        loop_once();
-
-        /* measure */
-        start = wctime();
-        loop_once(); /* hope we didn't get preempted  */
-        loop_length = wctime();
-        loop_length -= start;
-
-        /* fine tune */
-        fine_tune(0.1);
-        fine_tune(0.1);
-        fine_tune(0.1);
-}
-
-static void show_loop_length(void)
-{
-        printf("%s/%d: loop_length=%f (%ldus)\n",
-               progname, getpid(), loop_length,
-               (long) (loop_length * 1000000));
-}
 
 static void debug_delay_loop(void)
 {
         double start, end, delay;
-        show_loop_length();
+
         while (1) {
                 for (delay = 0.5; delay > 0.01; delay -= 0.01) {
                         start = wctime();
-                        loop_for(delay);
+                        loop_for(delay, 0);
                         end = wctime();
                         printf("%6.4fs: looped for %10.8fs, delta=%11.8fs, error=%7.4f%%\n",
                                delay,
@@ -126,16 +150,20 @@ static void debug_delay_loop(void)
         }
 }
 
-static int job(double exec_time)
+static int job(double exec_time, double program_end)
 {
-        loop_for(exec_time);
-        sleep_next_period();
-        return 0;
+        if (wctime() > program_end)
+                return 0;
+        else {
+                loop_for(exec_time, program_end + 1);
+                sleep_next_period();
+                return 1;
+        }
 }
 
-#define OPTSTR "p:c:m:wld:ve"
+#define OPTSTR "p:c:wldveo:f:s:m:"
 
-int main(int argc, char** argv) 
+int main(int argc, char** argv)
 {
         int ret;
         lt_t wcet;
@@ -146,11 +174,14 @@ int main(int argc, char** argv)
         int opt;
         int wait = 0;
         int test_loop = 0;
-        int skip_config = 0;
-        int verbose = 0;
+        int column = 1;
+        const char *file = NULL;
         int want_enforcement = 0;
-        double duration, start;
+        double duration = 0, start;
+        double *exec_times = NULL;
+        double scale = 1.0;
         task_class_t class = RT_CLASS_HARD;
+        int cur_job, num_jobs;
         crit_level_t crit = CRIT_LEVEL_C;
 
         progname = argv[0];
@@ -179,14 +210,14 @@ int main(int argc, char** argv)
                 case 'l':
                         test_loop = 1;
                         break;
-                case 'd':
-                        /* manually configure delay per loop iteration 
-                         * unit: microseconds */
-                        loop_length = atof(optarg) / 1000000;
-                        skip_config = 1;
+                case 'o':
+                        column = atoi(optarg);
+                        break;
+                case 'f':
+                        file = optarg;
                         break;
-                case 'v':
-                        verbose = 1;
+                case 's':
+                        scale = atof(optarg);
                         break;
                 case ':':
                         usage("Argument missing.");
@@ -198,32 +229,50 @@ int main(int argc, char** argv)
                 }
         }
 
-
-        if (!skip_config)
-                configure_loop();
-
         if (test_loop) {
                 debug_delay_loop();
                 return 0;
         }
 
-        if (argc - optind < 3)
-                usage("Arguments missing.");
+        if (file) {
+                get_exec_times(file, column, &num_jobs, &exec_times);
+
+                if (argc - optind < 2)
+                        usage("Arguments missing.");
+
+                for (cur_job = 0; cur_job < num_jobs; ++cur_job) {
+                        /* convert the execution time to seconds */
+                        duration += exec_times[cur_job] * 0.001;
+                }
+        } else {
+                /*
+                 * if we're not reading from the CSV file, then we need
+                 * three parameters
+                 */
+                if (argc - optind < 3)
+                        usage("Arguments missing.");
+        }
+
         wcet_ms   = atof(argv[optind + 0]);
         period_ms = atof(argv[optind + 1]);
-        duration  = atof(argv[optind + 2]);
+
         wcet   = wcet_ms * __NS_PER_MS;
         period = period_ms * __NS_PER_MS;
         if (wcet <= 0)
                 usage("The worst-case execution time must be a "
-                      "positive number.");
+                                "positive number.");
         if (period <= 0)
                 usage("The period must be a positive number.");
-        if (wcet > period) {
+        if (!file && wcet > period) {
                 usage("The worst-case execution time must not "
-                      "exceed the period.");
+                                "exceed the period.");
         }
 
+        if (!file)
+                duration  = atof(argv[optind + 2]);
+        else if (file && num_jobs > 1)
+                duration += period_ms * 0.001 * (num_jobs - 1);
+
         if (migrate) {
                 ret = be_migrate_to(cpu);
                 if (ret < 0)
@@ -238,9 +287,6 @@ int main(int argc, char** argv)
         if (ret < 0)
                 bail_out("could not setup rt task params");
 
-        if (verbose)
-                show_loop_length();
-
         init_litmus();
 
         ret = task_mode(LITMUS_RT_TASK);
@@ -255,9 +301,24 @@ int main(int argc, char** argv)
 
         start = wctime();
 
-        while (start + duration > wctime()) {
-                job(wcet_ms * 0.0009); /* 90% wcet, in seconds */
+        if (file) {
+                /* use times read from the CSV file */
+                for (cur_job = 0; cur_job < num_jobs; ++cur_job) {
+                        /* convert job's length to seconds */
+                        job(exec_times[cur_job] * 0.001 * scale,
+                                        start + duration);
+                }
+        } else {
+                /* conver to seconds and scale */
+                while (job(wcet_ms * 0.001 * scale, start + duration));
         }
 
+        ret = task_mode(BACKGROUND_TASK);
+        if (ret != 0)
+                bail_out("could not become regular task (huh?)");
+
+        if (file)
+                free(exec_times);
+
         return 0;
 }