Added mc2spin

5 files changed, 554 insertions, 2 deletions

diff --git a/Makefile b/Makefile
index 34c428f..70e79d4 100644
--- a/Makefile
+++ b/Makefile
@@ -73,7 +73,7 @@ AR  := ${CROSS_COMPILE}${AR}
 
 all     = lib ${rt-apps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
-          base_mt_task uncache runtests resctrl
+          base_mt_task uncache runtests resctrl mc2spin
 
 .PHONY: all lib clean dump-config TAGS tags cscope help doc
 
@@ -168,7 +168,8 @@ litmus-headers = \
         include/litmus/rt_param.h \
         include/litmus/fpmath.h \
         include/litmus/unistd_32.h \
-        include/litmus/unistd_64.h
+        include/litmus/unistd_64.h \
+        include/litmus/mc2_common.h
 
 unistd-headers = \
   $(foreach file,${unistd-${ARCH}},arch/${include-${ARCH}}/include/$(file))
@@ -236,6 +237,8 @@ lib-measure_syscall = -lm
 
 obj-resctrl = resctrl.o
 
+obj-mc2spin = mc2spin.o common.o
+lib-mc2spin = -lrt
 
 # ##############################################################################
 # Build everything that depends on liblitmus.
diff --git a/bin/mc2spin.c b/bin/mc2spin.c
new file mode 100644
index 0000000..1ef3082
--- /dev/null
+++ b/bin/mc2spin.c
@@ -0,0 +1,541 @@
+#include <sys/time.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <assert.h>
+#include <limits.h>
+
+
+#include "litmus.h"
+#include "common.h"
+
+
+
+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] [-s SCALE]\n"
+                "              [-p PARTITION/CLUSTER [-z CLUSTER SIZE]] [-c CLASS] [-m CRITICALITY LEVEL]\n"
+                "              [-X LOCKING-PROTOCOL] [-L CRITICAL SECTION LENGTH] [-Q RESOURCE-ID]\n"
+                "              [-i [start,end]:[start,end]...]\n"
+                "\n"
+                "WCET and PERIOD are milliseconds, DURATION is seconds.\n"
+                "CRITICAL SECTION LENGTH is in milliseconds.\n");
+        exit(EXIT_FAILURE);
+}
+
+/*
+ * returns the character that made processing stop, newline or EOF
+ */
+static int skip_to_next_line(FILE *fstream)
+{
+        int ch;
+        for (ch = fgetc(fstream); ch != EOF && ch != '\n'; ch = fgetc(fstream));
+        return ch;
+}
+
+static void skip_comments(FILE *fstream)
+{
+        int ch;
+        for (ch = fgetc(fstream); ch == '#'; ch = fgetc(fstream))
+                skip_to_next_line(fstream);
+        ungetc(ch, fstream);
+}
+
+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 */
+                        int unused __attribute__ ((unused)) = 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 char* progname;
+
+static int loop_once(void)
+{
+        int i, j = 0;
+        for (i = 0; i < NUMS; i++)
+                j += num[i]++;
+        return j;
+}
+
+static int loop_for(double exec_time, double emergency_exit)
+{
+        double last_loop = 0, loop_start;
+        int tmp = 0;
+
+        double start = cputime();
+        double now = cputime();
+
+        while (now + last_loop < start + exec_time) {
+                loop_start = now;
+                tmp += loop_once();
+                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 debug_delay_loop(void)
+{
+        double start, end, delay;
+
+        while (1) {
+                for (delay = 0.5; delay > 0.01; delay -= 0.01) {
+                        start = wctime();
+                        loop_for(delay, 0);
+                        end = wctime();
+                        printf("%6.4fs: looped for %10.8fs, delta=%11.8fs, error=%7.4f%%\n",
+                               delay,
+                               end - start,
+                               end - start - delay,
+                               100 * (end - start - delay) / delay);
+                }
+        }
+}
+
+static int job(double exec_time, double program_end, int lock_od, double cs_length)
+{
+        double chunk1, chunk2;
+
+        if (wctime() > program_end)
+                return 0;
+        else {
+                if (lock_od >= 0) {
+                        /* simulate critical section somewhere in the middle */
+                        chunk1 = drand48() * (exec_time - cs_length);
+                        chunk2 = exec_time - cs_length - chunk1;
+
+                        /* non-critical section */
+                        loop_for(chunk1, program_end + 1);
+
+                        /* critical section */
+                        litmus_lock(lock_od);
+                        loop_for(cs_length, program_end + 1);
+                        litmus_unlock(lock_od);
+
+                        /* non-critical section */
+                        loop_for(chunk2, program_end + 2);
+                } else {
+                        loop_for(exec_time, program_end + 1);
+                }
+                sleep_next_period();
+                return 1;
+        }
+}
+
+struct lt_interval* parse_td_intervals(int num, char* optarg, unsigned int *num_intervals)
+{
+        int i, matched;
+        struct lt_interval *slots = malloc(sizeof(slots[0]) * num);
+        char** arg = (char**)malloc(sizeof(char*) * num);
+        char *token, *saveptr;
+        double start, end;
+        
+        for (i = 0; i < num; i++) {
+                arg[i] = (char*)malloc(sizeof(char)*100);
+        }
+        
+        i = 0;
+        token = strtok_r(optarg, ":", &saveptr);
+        while(token != NULL) {
+                sprintf(arg[i++], "%s", token);
+                token = strtok_r(NULL, ":", &saveptr);
+        }
+        
+        *num_intervals = 0;
+        
+        for (i=0; i<num; i++) {
+                matched = sscanf(arg[i], "[%lf,%lf]", &start, &end);
+                if (matched != 2) {
+                        fprintf(stderr, "could not parse '%s' as interval\n", arg[i]);
+                        exit(5);
+                }
+                if (start < 0) {
+                        fprintf(stderr, "interval %s: must not start before zero\n", arg[i]);
+                        exit(5);
+                }
+                if (end <= start) {
+                        fprintf(stderr, "interval %s: end before start\n", arg[i]);
+                        exit(5);
+                }
+
+                slots[i].start = ms2ns(start);
+                slots[i].end   = ms2ns(end);
+
+                if (i > 0 && slots[i - 1].end >= slots[i].start) {
+                        fprintf(stderr, "interval %s: overlaps with previous interval\n", arg[i]);
+                        exit(5);
+                }
+
+                (*num_intervals)++;
+        }
+        
+        for (i=0; i<num; i++) {
+                free(arg[i]);
+        }
+        free(arg);
+        return slots;
+}
+
+#define OPTSTR "p:c:wlveo:f:s:q:X:L:Q:vh:m:i:b:"
+int main(int argc, char** argv)
+{
+        int ret;
+        lt_t wcet;
+        lt_t period;
+        lt_t hyperperiod;
+        lt_t budget;
+        double wcet_ms, period_ms, hyperperiod_ms, budget_ms;
+        unsigned int priority = LITMUS_LOWEST_PRIORITY;
+        int migrate = 0;
+        int cluster = 0;
+        int opt;
+        int wait = 0;
+        int test_loop = 0;
+        int column = 1;
+        const char *file = NULL;
+        int want_enforcement = 0;
+        double duration = 0, start = 0;
+        double *exec_times = NULL;
+        double scale = 1.0;
+        task_class_t class = RT_CLASS_HARD;
+        int cur_job = 0, num_jobs = 0;
+        struct rt_task param;
+        struct mc2_task mc2_param;
+        struct reservation_config config;
+        int res_type = SPORADIC_POLLING;
+        int n_str, num_int = 0;
+
+        int verbose = 0;
+        unsigned int job_no;
+
+        /* locking */
+        int lock_od = -1;
+        int resource_id = 0;
+        const char *lock_namespace = "./rtspin-locks";
+        int protocol = -1;
+        double cs_length = 1; /* millisecond */
+
+        progname = argv[0];
+
+        /* default for reservation */
+        config.id = 0;
+        config.priority = LITMUS_NO_PRIORITY; /* use EDF by default */
+        config.cpu = 0;
+        
+        mc2_param.crit = CRIT_LEVEL_C;
+        
+        hyperperiod_ms = 1000;
+        budget_ms = 10;
+        
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'w':
+                        wait = 1;
+                        break;
+                case 'p':
+                        cluster = atoi(optarg);
+                        migrate = 1;
+                        config.cpu = cluster;
+                        break;
+                case 'q':
+                        priority = atoi(optarg);
+                        if (!litmus_is_valid_fixed_prio(priority))
+                                usage("Invalid priority.");
+                        break;
+                case 'c':
+                        class = str2class(optarg);
+                        if (class == -1)
+                                usage("Unknown task class.");
+                        break;
+                case 'e':
+                        want_enforcement = 1;
+                        break;
+                case 'l':
+                        test_loop = 1;
+                        break;
+                case 'o':
+                        column = atoi(optarg);
+                        break;
+                case 'f':
+                        file = optarg;
+                        break;
+                case 's':
+                        scale = atof(optarg);
+                        break;
+                case 'X':
+                        protocol = lock_protocol_for_name(optarg);
+                        if (protocol < 0)
+                                usage("Unknown locking protocol specified.");
+                        break;
+                case 'L':
+                        cs_length = atof(optarg);
+                        if (cs_length <= 0)
+                                usage("Invalid critical section length.");
+                        break;
+                case 'Q':
+                        resource_id = atoi(optarg);
+                        if (resource_id <= 0 && strcmp(optarg, "0"))
+                                usage("Invalid resource ID.");
+                        break;
+                case 'v':
+                        verbose = 1;
+                        break;
+                case 'm':
+                        mc2_param.crit = atoi(optarg);
+                        if (mc2_param.crit == CRIT_LEVEL_A) {
+                                res_type = TABLE_DRIVEN;
+                        }
+                        else if (mc2_param.crit == CRIT_LEVEL_B) {
+                                res_type = PERIODIC_POLLING;
+                        }
+                        else
+                                usage("Invalid criticality level.");
+                        break;
+                case 'h':
+                        hyperperiod_ms = atof(optarg);
+                        break;
+                case 'b':
+                        budget_ms = atof(optarg);
+                        break;
+                case 'i':
+                        n_str = strlen(optarg);
+                        while(n_str--) {
+                                if (optarg[n_str] == ',')
+                                        num_int++;
+                        }
+                        if (!num_int)
+                                usage("Bad argument.");
+                        config.table_driven_params.intervals = parse_td_intervals(num_int, optarg, &config.table_driven_params.num_intervals);
+                        break;
+                case ':':
+                        usage("Argument missing.");
+                        break;
+                case '?':
+                default:
+                        usage("Bad argument.");
+                        break;
+                }
+        }
+
+        if (test_loop) {
+                debug_delay_loop();
+                return 0;
+        }
+
+        srand(getpid());
+
+        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]);
+
+        wcet   = ms2ns(wcet_ms);
+        period = ms2ns(period_ms);
+        budget = ms2ns(budget_ms);
+        hyperperiod = ms2ns(hyperperiod_ms);
+        
+        if (wcet <= 0)
+                usage("The worst-case execution time must be a "
+                                "positive number.");
+        if (period <= 0)
+                usage("The period must be a positive number.");
+        if (!file && wcet > period) {
+                usage("The worst-case execution time must not "
+                                "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_domain(cluster);
+                if (ret < 0)
+                        bail_out("could not migrate to target partition or cluster.");
+        }
+
+        /* reservation config */
+        config.id = gettid();
+        
+        if (hyperperiod%period != 0 ) {
+                bail_out("hyperperiod must be multiple of period");
+        }
+        
+        if (mc2_param.crit == CRIT_LEVEL_A) {
+                config.table_driven_params.major_cycle_length = period;
+        }
+        else if (mc2_param.crit == CRIT_LEVEL_B) {
+                config.polling_params.budget = budget;
+                config.polling_params.period = period;
+                config.polling_params.offset = 0;
+                config.polling_params.relative_deadline = 0;
+                if (config.polling_params.budget > config.polling_params.period) {
+                        usage("The budget must not exceed the period.");
+                }
+        }
+        
+        /* create a reservation */
+        ret = reservation_create(res_type, &config);
+        if (ret < 0) {
+                bail_out("failed to create reservation.");
+        }
+        
+        init_rt_task_param(&param);
+        param.exec_cost = wcet;
+        param.period = period;
+        param.priority = priority;
+        param.cls = class;
+        param.release_policy = TASK_PERIODIC;
+        param.budget_policy = (want_enforcement) ?
+                        PRECISE_ENFORCEMENT : NO_ENFORCEMENT;
+        if (migrate) {
+                param.cpu = gettid();
+        }
+        ret = set_rt_task_param(gettid(), &param);
+        if (ret < 0)
+                bail_out("could not setup rt task params");
+        
+        mc2_param.pid = gettid();
+        mc2_param.hyperperiod = hyperperiod;
+        ret = set_mc2_task_param(gettid(), &mc2_param);
+        if (ret < 0)
+                bail_out("could not setup mc2 task params");
+        init_litmus();
+
+        start = wctime();
+        ret = task_mode(LITMUS_RT_TASK);
+        if (ret != 0)
+                bail_out("could not become RT task");
+
+        if (protocol >= 0) {
+                /* open reference to semaphore */
+                lock_od = litmus_open_lock(protocol, resource_id, lock_namespace, &cluster);
+                if (lock_od < 0) {
+                        perror("litmus_open_lock");
+                        usage("Could not open lock.");
+                }
+        }
+
+
+        if (wait) {
+                ret = wait_for_ts_release();
+                if (ret != 0)
+                        bail_out("wait_for_ts_release()");
+                start = wctime();
+        }
+
+        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,
+                            lock_od, cs_length * 0.001);
+                }
+        } else {
+                do {
+                        if (verbose) {
+                                get_job_no(&job_no);
+                                printf("rtspin/%d:%u @ %.4fms\n", gettid(),
+                                        job_no, (wctime() - start) * 1000);
+                        }
+                        /* convert to seconds and scale */
+                } while (job(wcet_ms * 0.001 * scale, start + duration,
+                           lock_od, cs_length * 0.001));
+        }
+
+        ret = task_mode(BACKGROUND_TASK);
+        if (ret != 0)
+                bail_out("could not become regular task (huh?)");
+
+        if (file)
+                free(exec_times);
+
+        reservation_destroy(gettid(), config.cpu);
+        if (mc2_param.crit == CRIT_LEVEL_A) {
+                free(config.table_driven_params.intervals);
+        }
+        return 0;
+}
diff --git a/include/litmus.h b/include/litmus.h
index 3bd6b92..b90a83d 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -40,6 +40,8 @@ extern "C" {
 
 #include "migration.h"
 
+#include "litmus/mc2_common.h"
+
 /**
  * @private
  * Number of semaphore protocol object types
@@ -420,6 +422,7 @@ int reservation_create(int rtype, void *config);
 
 int reservation_destroy(unsigned int reservation_id, int cpu);
 
+int set_mc2_task_param(pid_t pid, struct mc2_task* param);
 
 #ifdef __cplusplus
 }
diff --git a/mc2spin b/mc2spin
new file mode 100755
index 0000000..00b20c0
--- /dev/null
+++ b/mc2spin
diff --git a/src/syscalls.c b/src/syscalls.c
index fbb8604..b07d135 100644
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -96,3 +96,8 @@ int reservation_destroy(unsigned int reservation_id, int cpu)
 {
         return syscall(__NR_reservation_destroy, reservation_id, cpu);
 }
+
+int set_mc2_task_param(pid_t pid, struct mc2_task *param)
+{
+        return syscall(__NR_set_mc2_task_param, pid, param);
+}
\ No newline at end of file