Add rt_launch_edfwm launcher

As rtspin_edfwm rt_launch_edfwm reads each task information from a text
file (same format as rtspin_edfwm).

4 files changed, 194 insertions, 0 deletions

diff --git a/SConstruct b/SConstruct
index 1f4770a..9935396 100644
--- a/SConstruct
+++ b/SConstruct
@@ -214,6 +214,7 @@ rt.Program('rtspin_npsf', ['bin/rtspin_npsf.c', 'bin/common.c'])
 rt.Program('npsf_add_server', ['bin/npsf_add_server.c', 'bin/common.c'])
 rt.Program('rt_launch_npsf', ['bin/rt_launch_npsf.c', 'bin/common.c'])
 rt.Program('rtspin_edfwm', ['bin/rtspin_edfwm.c', 'bin/common.c'])
+rt.Program('rt_launch_edfwm', ['bin/rt_launch_edfwm.c', 'bin/common.c'])
 rt.Program('release_ts', 'bin/release_ts.c')
 rtm.Program('measure_syscall', 'bin/null_call.c')
 
diff --git a/bin/rt_launch_edfwm.c b/bin/rt_launch_edfwm.c
new file mode 100644
index 0000000..de65585
--- /dev/null
+++ b/bin/rt_launch_edfwm.c
@@ -0,0 +1,182 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <signal.h>
+
+#include "litmus.h"
+#include "common.h"
+typedef struct {
+        int  wait;
+        char * exec_path;
+        char ** argv;
+} startup_info_t;
+
+
+int launch(void *task_info_p) {
+        startup_info_t *info = (startup_info_t*) task_info_p;
+        int ret;
+        if (info->wait) {
+                ret = wait_for_ts_release();
+                if (ret != 0)
+                        perror("wait_for_ts_release()");
+        }
+        ret = execvp(info->exec_path, info->argv);
+        perror("execv failed");
+        return ret;
+}
+
+void usage(char *error) {
+        fprintf(stderr, "%s\nUsage: rt_launch [-w] task_parameters_file "
+                        "program [arg1 arg2 ...]\n"
+                        "\t-w\tSynchronous release\n"
+                        "\tprogram to be launched\n",
+                        error);
+        exit(1);
+}
+
+#define fms_to_ns(x)    (lt_t)(((x) * __NS_PER_MS))
+/*
+ * <task_id, cpu, deadline (from job release), budget, offset> .
+ */
+int parse_edfwm_slice(FILE *ts, int slices_no, int task_id,
+                struct edf_wm_params *wm)
+{
+        int i, tid;
+        unsigned int cpu;
+        double deadline, budget, offset;
+
+        for (i = 0; i < slices_no; i++) {
+
+                if (fscanf(ts, "%d %u %lf %lf %lf\n", &tid, &cpu,
+                                &deadline, &budget, &offset) != EOF) {
+
+                        printf("slice(tid, cpu, d, e, ph) = (%d, %u, %lf, %lf, %lf)\n",
+                                        tid, cpu, deadline, budget, offset);
+
+                        if (task_id != tid) {
+                                fprintf(stderr, "task_id %d != tid %d\n",
+                                                task_id, tid);
+                                return -1;
+                        }
+
+                        wm->slices[i].deadline = fms_to_ns(deadline);
+                        wm->slices[i].budget = fms_to_ns(budget);
+                        wm->slices[i].offset = fms_to_ns(offset);
+                }
+                if (ferror(ts)) {
+                        fprintf(stderr, "Cannot read file\n");
+                        return -1;
+                }
+        }
+        return 1;
+}
+
+/* Custom format to read parameters for tasks from a plain text file:
+ *      <task_id, execution_cost, period, phase, cpu, slices_number> .
+ * If the task is split on multiple slices, slices_number is non 0
+ * and we scan a list of slice parameters up to slices_number:
+ *      <task_id, cpu, deadline (from job release), budget, offset> .
+ * The offset is the start time for the slice relative to the job release.
+ *
+ * FIXME: this function should go in a separate file where all the parsing
+ * funtions for the semi-part plugins are. It will help in later testing with
+ * "tasks" programs.
+ */
+int parse_edfwm_ts_file(FILE *ts, struct rt_task *rt)
+{
+        int task_id, ret = 1;
+        unsigned int cpu, sliceno;
+        double fwcet, fperiod, fphase;
+
+        ret = fscanf(ts, "%d %lf %lf %lf %d %d\n",
+                        &task_id, &fwcet, &fperiod, &fphase, &cpu, &sliceno);
+
+        if (ret != EOF) {
+
+                printf("(tid, wcet, period, ph, cpu, slices) = "
+                        "(%d, %.2f, %.2f, %.2f, %u, %u)\n",
+                        task_id, fwcet, fperiod, fphase, cpu, sliceno);
+
+                rt->exec_cost = fms_to_ns(fwcet);
+                rt->period = fms_to_ns(fperiod);
+                rt->phase = fms_to_ns(fphase);
+                rt->cpu = cpu;
+                rt->cls = RT_CLASS_HARD;
+                rt->budget_policy = PRECISE_ENFORCEMENT;
+                if (sliceno > 0) {
+                        ret = parse_edfwm_slice(ts, sliceno, task_id,
+                                (struct edf_wm_params*) &rt->semi_part);
+                        if (ret < 0)
+                                goto err;
+                }
+        }
+        if (ferror(ts))
+                goto err;
+
+        return EOF;
+
+err:
+        fprintf(stderr, "Error parsing file\n");
+        return -1;
+}
+
+#define OPTSTR "w"
+
+int main(int argc, char** argv) 
+{
+        int ret;
+        int wait = 0;
+        int opt;
+        startup_info_t info;
+
+        struct rt_task rt;
+        FILE *file;
+
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'w':
+                        wait = 1;
+                        break;
+                case ':':
+                        usage("Argument missing.");
+                        break;
+                case '?':
+                default:
+                        usage("Bad argument.");
+                        break;
+                }
+        }
+
+        signal(SIGUSR1, SIG_IGN);
+
+        if (argc - optind < 2)
+                usage("Arguments missing.");
+
+        if ((file = fopen(argv[optind + 0], "r")) == NULL) {
+                fprintf(stderr, "Cannot open %s\n", argv[1]);
+                return -1;
+        }
+
+        memset(&rt, 0, sizeof(struct rt_task));
+
+        while (parse_edfwm_ts_file(file, &rt) != EOF) {
+
+                if (sporadic_task_ns_semi(&rt) < 0)
+                        bail_out("could not setup rt task params");
+        }
+
+        fclose(file);
+
+        info.exec_path = argv[optind + 1];
+        info.argv      = argv + optind + 1;
+        info.wait      = wait;
+
+        ret = create_rt_task_semi(launch, &info, &rt);
+
+        if (ret < 0)
+                bail_out("could not create rt child process");
+
+        return 0;
+}
diff --git a/include/litmus.h b/include/litmus.h
index fd40e87..9179ca6 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -105,6 +105,12 @@ int __create_rt_task_edffm(rt_fn_t rt_prog, void *arg, int cpu, int wcet,
 int __create_rt_task_npsf(rt_fn_t rt_prog, void *arg, int cpu, int wcet,
                 int period, int npsf_id, task_class_t class);
 
+/* wrapper to mask __launch_rt_task() for semi-partitioned algorithms
+ * (it can be extended to cover all algorithms that directly submit
+ * an rt_task structure instead of a set of values).
+ */
+int create_rt_task_semi(rt_fn_t rt_prog, void *arg, struct rt_task *params);
+
 /*      per-task modes */
 enum rt_task_mode_t {
         BACKGROUND_TASK = 0,
diff --git a/src/task.c b/src/task.c
index 9f6db5e..8621aa2 100644
--- a/src/task.c
+++ b/src/task.c
@@ -106,6 +106,11 @@ 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_semi(rt_fn_t rt_prog, void *arg, struct rt_task *params)
+{
+        return __launch_rt_task(rt_prog, arg,
+                        (rt_setup_fn_t) set_rt_task_param, params);
+}
 
 #define SCHED_NORMAL 0
 #define SCHED_LITMUS 6