[NPS-F] Add rtspin and utility to add notional processors

- add syscall to add notional processors (servers)
- add rtspin_npsf program to run on specified (npsf_id, cpu)
- add npsf_add_server as wrapper on the syscall

6 files changed, 350 insertions, 0 deletions

diff --git a/SConstruct b/SConstruct
index c0a5f6e..0888e90 100644
--- a/SConstruct
+++ b/SConstruct
@@ -209,6 +209,8 @@ mtrt.Program('base_mt_task', 'bin/base_mt_task.c')
 rt.Program('rt_launch', ['bin/rt_launch.c', 'bin/common.c'])
 rt.Program('rtspin', ['bin/rtspin.c', 'bin/common.c'])
 rt.Program('rtspin_edffm', ['bin/rtspin_edffm.c', 'bin/common.c'])
+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_edffm', ['bin/rt_launch_edffm.c', 'bin/common.c'])
 rt.Program('release_ts', 'bin/release_ts.c')
 rtm.Program('measure_syscall', 'bin/null_call.c')
diff --git a/bin/npsf_add_server.c b/bin/npsf_add_server.c
new file mode 100644
index 0000000..3983e77
--- /dev/null
+++ b/bin/npsf_add_server.c
@@ -0,0 +1,45 @@
+/* wrapper for sys_add_server */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "litmus.h"
+#include "common.h"
+
+void usage(char *error) {
+        fprintf(stderr, "Error: %s\n", error);
+        fprintf(stderr,
+                "Usage: npsf_add_server NPSF-ID UTIL SLOT-SIZE(ms) CPU \n");
+        exit(1);
+}
+
+int main(int argc, char** argv)
+{
+        int ret;
+        int cpu = 0;
+        int npsf_id = 0;
+        double util = 0;
+        int slot_ms = 0;
+        lt_t budget_ns = 0;
+
+        if (argc < 5)
+                usage("Arguments missing.");
+        npsf_id = atoi(argv[1]);
+        util    = atof(argv[2]);
+        slot_ms = atoi(argv[3]);
+        cpu     = atoi(argv[4]);
+
+        if (util > 1)
+                usage("Utilization > 1");
+
+        budget_ns = (lt_t)((__NS_PER_MS * util) * slot_ms);
+
+        printf("Trying to add NP(%d): budget = %f\n", npsf_id, (double)(budget_ns) / __NS_PER_MS);
+
+        ret = add_server(&npsf_id, &budget_ns, &cpu);
+
+        if (ret < 0)
+                bail_out("Cannot add Notional Processor: ");
+
+        return 0;
+}
diff --git a/bin/rtspin_npsf.c b/bin/rtspin_npsf.c
new file mode 100644
index 0000000..87eb52f
--- /dev/null
+++ b/bin/rtspin_npsf.c
@@ -0,0 +1,252 @@
+#include <sys/time.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+
+
+#include "litmus.h"
+#include "common.h"
+
+
+static double cputime()
+{
+        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);
+}
+
+static double wctime()
+{
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        return (tv.tv_sec + 1E-6 * tv.tv_usec);
+}
+
+void usage(char *error) {
+        fprintf(stderr, "Error: %s\n", error);
+        fprintf(stderr,
+                "Usage: rt_spin [-w] WCET PERIOD DURATION CPU NPSF-ID\n"
+                "       rt_spin -l\n");
+        exit(1);
+}
+
+#define NUMS 4096
+static int num[NUMS];
+static double loop_length = 1.0;
+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 t = 0;
+        int tmp = 0;
+/*      while (t + loop_length < exec_time) {
+                tmp += loop_once();
+                t += loop_length;
+        }
+*/
+        double start = cputime();
+        double now = cputime();
+        while (now + loop_length < start + exec_time) {
+                tmp += loop_once();
+                t += loop_length;
+                now = cputime();
+        }
+
+        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);
+                        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)
+{
+        loop_for(exec_time);
+        sleep_next_period();
+        return 0;
+}
+
+#define OPTSTR "c:wld:v"
+
+int main(int argc, char** argv)
+{
+        int ret;
+        lt_t wcet;
+        lt_t period;
+        double wcet_ms, period_ms;
+        int migrate = 0;
+        int cpu = 0;
+        int npsf_id = 0;
+        int opt;
+        int wait = 0;
+        int test_loop = 0;
+        int skip_config = 0;
+        int verbose = 0;
+        double duration, start;
+        task_class_t class = RT_CLASS_HARD;
+
+        progname = argv[0];
+
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'w':
+                        wait = 1;
+                        break;
+                case 'c':
+                        class = str2class(optarg);
+                        if (class == -1)
+                                usage("Unknown task class.");
+                        break;
+                case 'l':
+                        test_loop = 1;
+                        break;
+                case 'd':
+                        /* manually configure delay per loop iteration
+                         * unit: microseconds */
+                        loop_length = atof(optarg) / 1000000;
+                        skip_config = 1;
+                        break;
+                case 'v':
+                        verbose = 1;
+                        break;
+                case ':':
+                        usage("Argument missing.");
+                        break;
+                case '?':
+                default:
+                        usage("Bad argument.");
+                        break;
+                }
+        }
+
+
+        if (!skip_config)
+                configure_loop();
+
+        if (test_loop) {
+                debug_delay_loop();
+                return 0;
+        }
+
+        if (argc - optind < 3)
+                usage("Arguments missing.");
+        wcet_ms   = atof(argv[optind + 0]);
+        period_ms = atof(argv[optind + 1]);
+        duration  = atof(argv[optind + 2]);
+        cpu = atoi(argv[optind + 3]);
+        migrate = 1;
+        npsf_id = atoi(argv[optind + 4]);
+        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.");
+        if (period <= 0)
+                usage("The period must be a positive number.");
+        if (wcet > period) {
+                usage("The worst-case execution time must not "
+                      "exceed the period.");
+        }
+
+        if (migrate) {
+                ret = be_migrate_to(cpu);
+                if (ret < 0)
+                        bail_out("could not migrate to target partition");
+        }
+
+        ret = sporadic_task_ns_npsf(wcet, period, 0, cpu, class, npsf_id,
+                        NO_ENFORCEMENT, migrate);
+
+        if (ret < 0)
+                bail_out("could not setup rt task params");
+
+        if (verbose)
+                show_loop_length();
+
+        init_litmus();
+
+        ret = task_mode(LITMUS_RT_TASK);
+        if (ret != 0)
+                bail_out("could not become RT task");
+
+        if (wait) {
+                ret = wait_for_ts_release();
+                if (ret != 0)
+                        bail_out("wait_for_ts_release()");
+        }
+
+        start = wctime();
+
+        while (start + duration > wctime()) {
+                job(wcet_ms * 0.0009); /* 90% wcet, in seconds */
+        }
+
+        return 0;
+}
diff --git a/include/litmus.h b/include/litmus.h
index 3aa790f..d7f7b99 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -45,6 +45,11 @@ int sporadic_task_ns_edffm(lt_t e, lt_t p, lt_t phase, int cpu,
                 task_class_t cls, budget_policy_t budget_policy,
                 int set_cpu_set);
 
+int sporadic_task_ns_npsf(
+                lt_t e, lt_t p, lt_t phase,
+                int cpu, task_class_t cls, int npsf_id,
+                budget_policy_t budget_policy, int set_cpu_set);
+
 /* budget enforcement off by default in these macros */
 #define sporadic_global(e, p) \
         sporadic_task(e, p, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
@@ -142,6 +147,26 @@ int null_call(cycles_t *timestamp);
  */
 struct control_page* get_ctrl_page(void);
 
+/* NPS-F syscall to add a notional processor (a server) to a cpu.
+ * A notional processor may span across multiple cpu. If the NP.
+ * spans multiple cpus, each "segment" must be initialized indipendently
+ * with the proper fraction of budget of the original NP. For example:
+ *
+ * NP1 = 0.75 = inflated utilization; it spans on CPU0 and CPU1:
+ * NP1_0 = 0.2; NP1_1 = 0.55
+ *
+ * So, we have to initialize a segment (0.2 * slot_length) on CPU0
+ * and a segment (0.55 * slot_length) on CPU1 (both should have
+ * the same npsf_id).
+ *
+ * @npsf_id:    a "unique" identifier for the notional processor.
+ * @budget:     the length of the segment for this NP. on this CPU (in ns).
+ * @cpu:        the cpu that holds this NP segment.
+ *
+ * Currently implemented on x86_64 only.
+ */
+int add_server(int *npsf_id, lt_t *budget, int *cpu);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/litmus.c b/src/litmus.c
index d253368..65f711a 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -101,6 +101,27 @@ int sporadic_task_ns_edffm(lt_t e, lt_t p, lt_t phase, int cpu,
         return set_rt_task_param(gettid(), &param);
 }
 
+int sporadic_task_ns_npsf(lt_t e, lt_t p, lt_t phase,
+                int cpu, task_class_t cls, int npsf_id,
+                budget_policy_t budget_policy, int set_cpu_set)
+{
+        struct rt_task param;
+        int ret;
+        param.exec_cost = e;
+        param.period    = p;
+        param.cpu       = cpu;
+        param.cls       = cls;
+        param.phase     = phase;
+        param.budget_policy = budget_policy;
+        param.npsf_id = npsf_id;
+
+        if (set_cpu_set) {
+                ret = be_migrate_to(cpu);
+                check("migrate to cpu");
+        }
+        return set_rt_task_param(gettid(), &param);
+}
+
 int init_kernel_iface(void);
 
 int init_litmus(void)
diff --git a/src/syscalls.c b/src/syscalls.c
index 77a6277..58d7151 100644
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -95,3 +95,8 @@ int null_call(cycles_t *timestamp)
 {
         return syscall(__NR_null_call, timestamp);
 }
+
+int add_server(int *npsf_id, lt_t *budget, int *cpu)
+{
+        return syscall(__NR_add_server, npsf_id, budget, cpu);
+}