12 files changed, 113 insertions, 120 deletions

diff --git a/bin/base_mt_task.c b/bin/base_mt_task.c
index 8090cc3..aec79a4 100644
--- a/bin/base_mt_task.c
+++ b/bin/base_mt_task.c
@@ -26,8 +26,6 @@
 #define RELATIVE_DEADLINE 100
 #define EXEC_COST         10
 
-#define NS_PER_MS         1e6
-
 /* Let's create 10 threads in the example, 
  * for a total utilization of 1.
  */
@@ -129,10 +127,10 @@ void* rt_thread(void *tcontext)
         struct rt_task param;
 
         /* Set up task parameters */
-        memset(&param, 0, sizeof(param));
-        param.exec_cost = EXEC_COST * NS_PER_MS;
-        param.period = PERIOD * NS_PER_MS;
-        param.relative_deadline = RELATIVE_DEADLINE * NS_PER_MS;
+        init_rt_task_param(&param);
+        param.exec_cost = ms2ns(EXEC_COST);
+        param.period = ms2ns(PERIOD);
+        param.relative_deadline = ms2ns(RELATIVE_DEADLINE);
 
         /* What to do in the case of budget overruns? */
         param.budget_policy = NO_ENFORCEMENT;
diff --git a/bin/base_task.c b/bin/base_task.c
index df0c5a2..09edba9 100644
--- a/bin/base_task.c
+++ b/bin/base_task.c
@@ -30,8 +30,6 @@
 #define RELATIVE_DEADLINE 100
 #define EXEC_COST         10
 
-#define NS_PER_MS         1e6
-
 /* Catch errors.
  */
 #define CALL( exp ) do { \
@@ -69,10 +67,10 @@ int main(int argc, char** argv)
         struct rt_task param;
 
         /* Setup task parameters */
-        memset(&param, 0, sizeof(param));
-        param.exec_cost = EXEC_COST * NS_PER_MS;
-        param.period = PERIOD * NS_PER_MS;
-        param.relative_deadline = RELATIVE_DEADLINE * NS_PER_MS;
+        init_rt_task_param(&param);
+        param.exec_cost = ms2ns(EXEC_COST);
+        param.period = ms2ns(PERIOD);
+        param.relative_deadline = ms2ns(RELATIVE_DEADLINE);
 
         /* What to do in the case of budget overruns? */
         param.budget_policy = NO_ENFORCEMENT;
diff --git a/bin/release_ts.c b/bin/release_ts.c
index c2f6d4c..feca5ef 100644
--- a/bin/release_ts.c
+++ b/bin/release_ts.c
@@ -10,7 +10,6 @@
 #include "internal.h"
 
 #define OPTSTR "d:wf:"
-#define NS_PER_MS 1000000
 
 #define LITMUS_STATS_FILE "/proc/litmus/stats"
 
@@ -44,7 +43,7 @@ void wait_until_ready(int expected)
 int main(int argc, char** argv)
 {
         int released;
-        lt_t delay = ms2lt(1000);
+        lt_t delay = ms2ns(1000);
         int wait = 0;
         int expected = 0;
         int opt;
@@ -52,7 +51,7 @@ int main(int argc, char** argv)
         while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
                 switch (opt) {
                 case 'd':
-                        delay = ms2lt(atoi(optarg));
+                        delay = ms2ns(atoi(optarg));
                         break;
                 case 'w':
                         wait = 1;
diff --git a/bin/rt_launch.c b/bin/rt_launch.c
index ae68601..93f10d5 100644
--- a/bin/rt_launch.c
+++ b/bin/rt_launch.c
@@ -99,8 +99,8 @@ int main(int argc, char** argv)
 
         if (argc - optind < 3)
                 usage("Arguments missing.");
-        wcet   = ms2lt(atoi(argv[optind + 0]));
-        period = ms2lt(atoi(argv[optind + 1]));
+        wcet   = ms2ns(atoi(argv[optind + 0]));
+        period = ms2ns(atoi(argv[optind + 1]));
         if (wcet <= 0)
         usage("The worst-case execution time must be a "
               "positive number.");
diff --git a/bin/rtspin.c b/bin/rtspin.c
index b05c17c..167741d 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -185,7 +185,6 @@ static int job(double exec_time, double program_end, int lock_od, double cs_leng
 }
 
 #define OPTSTR "p:z:c:wlveo:f:s:q:X:L:Q:"
-
 int main(int argc, char** argv)
 {
         int ret;
@@ -207,6 +206,7 @@ int main(int argc, char** argv)
         double scale = 1.0;
         task_class_t class = RT_CLASS_HARD;
         int cur_job = 0, num_jobs = 0;
+        struct rt_task param;
 
         /* locking */
         int lock_od = -1;
@@ -308,8 +308,8 @@ int main(int argc, char** argv)
         wcet_ms   = atof(argv[optind + 0]);
         period_ms = atof(argv[optind + 1]);
 
-        wcet   = wcet_ms * __NS_PER_MS;
-        period = period_ms * __NS_PER_MS;
+        wcet   = ms2ns(wcet_ms);
+        period = ms2ns(period_ms);
         if (wcet <= 0)
                 usage("The worst-case execution time must be a "
                                 "positive number.");
@@ -325,11 +325,22 @@ int main(int argc, char** argv)
         else if (file && num_jobs > 1)
                 duration += period_ms * 0.001 * (num_jobs - 1);
 
-        ret = sporadic_task_ns(wcet, period, 0, cluster, cluster_size,
-                               priority, class,
-                               want_enforcement ? PRECISE_ENFORCEMENT
-                                                : NO_ENFORCEMENT,
-                               migrate);
+        if (migrate) {
+                ret = be_migrate_to_cluster(cluster, cluster_size);
+                if (ret < 0)
+                        bail_out("could not migrate to target partition or cluster.");
+        }
+
+        init_rt_task_param(&param);
+        param.exec_cost = wcet;
+        param.period = period;
+        param.priority = priority;
+        param.cls = class;
+        param.budget_policy = (want_enforcement) ?
+                        PRECISE_ENFORCEMENT : NO_ENFORCEMENT;
+        if (migrate)
+                param.cpu = cluster_to_first_cpu(cluster, cluster_size);
+        ret = set_rt_task_param(gettid(), &param);
         if (ret < 0)
                 bail_out("could not setup rt task params");
 
diff --git a/include/litmus.h b/include/litmus.h
index 429e614..1009805 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -18,7 +18,6 @@ extern "C" {
 
 #include "migration.h"
 
-
 void init_rt_task_param(struct rt_task* param);
 int set_rt_task_param(pid_t pid, struct rt_task* param);
 int get_rt_task_param(pid_t pid, struct rt_task* param);
@@ -30,40 +29,21 @@ int get_rt_task_param(pid_t pid, struct rt_task* param);
 int partition_to_cpu(int partition);
 int cluster_to_first_cpu(int cluster, int cluster_size);
 
-/* setup helper */
-
-/* Times are given in ms. The 'priority' parameter
- * is only relevant under fixed-priority scheduling (and
- * ignored by other plugins). The task_class_t parameter
- * is ignored by most plugins.
- */
-int sporadic_task(
-                lt_t e, lt_t p, lt_t phase,
-                int cluster, int cluster_size, unsigned int priority,
-                task_class_t cls,
-                budget_policy_t budget_policy, int be_migrate);
-
-/* Times are given in ns. The 'priority' parameter
- * is only relevant under fixed-priority scheduling (and
- * ignored by other plugins). The task_class_t parameter
- * is ignored by most plugins.
- */
-int sporadic_task_ns(
-                lt_t e, lt_t p, lt_t phase,
-                int cluster, int cluster_size, unsigned int priority,
-                task_class_t cls,
-                budget_policy_t budget_policy, int be_migrate);
-
-/* Convenience macros. Budget enforcement off by default in these macros. */
-#define sporadic_global(e, p) \
-        sporadic_task(e, p, 0, 0, 0, LITMUS_LOWEST_PRIORITY, \
-                RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
-#define sporadic_partitioned(e, p, partition) \
-        sporadic_task(e, p, 0, partition, 1, LITMUS_LOWEST_PRIORITY, \
-                RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
-#define sporadic_clustered(e, p, cluster, cluster_size) \
-        sporadic_task(e, p, 0, cluster, cluster_size, LITMUS_LOWEST_PRIORITY, \
-                RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
+/* Convenience functions for setting up real-time tasks.
+ * Default behaviors set by init_rt_task_params() used.
+ * Also sets affinity masks for clustered/partitions
+ * functions. Time units in nanoseconds. */
+int sporadic_global(lt_t e_ns, lt_t p_ns);
+int sporadic_partitioned(lt_t e_ns, lt_t p_ns, int partition);
+int sporadic_clustered(lt_t e_ns, lt_t p_ns, int cluster, int cluster_size);
+
+/* simple time unit conversion macros */
+#define s2ns(s)   ((s)*1000000000LL)
+#define s2us(s)   ((s)*1000000LL)
+#define s2ms(s)   ((s)*1000LL)
+#define ms2ns(ms) ((ms)*1000000LL)
+#define ms2us(ms) ((ms)*1000LL)
+#define us2ns(us) ((us)*1000LL)
 
 /* file descriptor attached shared objects support */
 typedef enum  {
@@ -140,13 +120,6 @@ int release_ts(lt_t *delay);
 int get_nr_ts_release_waiters(void);
 int read_litmus_stats(int *ready, int *total);
 
-#define __NS_PER_MS 1000000
-
-static inline lt_t ms2lt(unsigned long milliseconds)
-{
-        return __NS_PER_MS * milliseconds;
-}
-
 /* sleep for some number of nanoseconds */
 int lt_sleep(lt_t timeout);
 
diff --git a/src/litmus.c b/src/litmus.c
index 09f9dc6..93a1c7f 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -119,42 +119,50 @@ task_class_t str2class(const char* str)
 
 #define NS_PER_MS 1000000
 
-int sporadic_task(lt_t e, lt_t p, lt_t phase,
-                  int cluster, int cluster_size, unsigned int priority,
-                  task_class_t cls,
-                  budget_policy_t budget_policy, int set_cpu_set)
+int sporadic_global(lt_t e_ns, lt_t p_ns)
 {
-        return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS, phase * NS_PER_MS,
-                                cluster, cluster_size, priority, cls,
-                                budget_policy, set_cpu_set);
+        struct rt_task param;
+
+        init_rt_task_param(&param);
+        param.exec_cost = e_ns;
+        param.period = p_ns;
+
+        return set_rt_task_param(gettid(), &param);
 }
 
-int sporadic_task_ns(lt_t e, lt_t p, lt_t phase,
-                     int cluster, int cluster_size, unsigned int priority,
-                     task_class_t cls,
-                     budget_policy_t budget_policy, int migrate)
+int sporadic_partitioned(lt_t e_ns, lt_t p_ns, int partition)
 {
+        int ret;
         struct rt_task param;
+
+        ret = be_migrate_to_partition(partition);
+        check("be_migrate_to_partition()");
+        if (ret != 0)
+                return ret;
+
+        init_rt_task_param(&param);
+        param.exec_cost = e_ns;
+        param.period = p_ns;
+        param.cpu = partition_to_cpu(partition);
+
+        return set_rt_task_param(gettid(), &param);
+}
+
+int sporadic_clustered(lt_t e_ns, lt_t p_ns, int cluster, int cluster_size)
+{
         int ret;
+        struct rt_task param;
+
+        ret = be_migrate_to_cluster(cluster, cluster_size);
+        check("be_migrate_to_cluster()");
+        if (ret != 0)
+                return ret;
+
+        init_rt_task_param(&param);
+        param.exec_cost = e_ns;
+        param.period = p_ns;
+        param.cpu = cluster_to_first_cpu(cluster, cluster_size);
 
-        /* Zero out first --- this is helpful when we add plugin-specific
-         * parameters during development.
-         */
-        memset(&param, 0, sizeof(param));
-
-        param.exec_cost = e;
-        param.period    = p;
-        param.relative_deadline = p; /* implicit deadline */
-        param.cpu       = cluster_to_first_cpu(cluster, cluster_size);
-        param.cls       = cls;
-        param.phase     = phase;
-        param.budget_policy = budget_policy;
-        param.priority  = priority;
-
-        if (migrate) {
-                ret = be_migrate_to_cluster(cluster, cluster_size);
-                check("migrate to cluster");
-        }
         return set_rt_task_param(gettid(), &param);
 }
 
diff --git a/tests/core_api.c b/tests/core_api.c
index b57e278..fc4deb9 100644
--- a/tests/core_api.c
+++ b/tests/core_api.c
@@ -18,6 +18,7 @@ TESTCASE(set_rt_task_param_invalid_params, ALL,
          "reject invalid rt_task values")
 {
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
         params.period     = 100;
         params.relative_deadline = params.period;
@@ -53,6 +54,7 @@ TESTCASE(reject_bad_priorities, P_FP,
          "reject invalid priorities")
 {
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
         params.exec_cost  =  10;
         params.period     = 100;
@@ -79,6 +81,7 @@ TESTCASE(accept_valid_priorities, P_FP,
          "accept lowest and highest valid priorities")
 {
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
         params.exec_cost  =  10;
         params.period     = 100;
@@ -120,7 +123,7 @@ TESTCASE(rt_fork_non_rt, LITMUS,
         unsigned int pid, job_no;
         int status;
 
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         pid = fork();
diff --git a/tests/fdso.c b/tests/fdso.c
index fda343f..570ea4a 100644
--- a/tests/fdso.c
+++ b/tests/fdso.c
@@ -66,7 +66,7 @@ TESTCASE(not_inherit_od, GSN_EDF | PSN_EDF,
         ASSERT( pid != -1 );
 
         /* must be an RT task to lock at all */
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         if (pid == 0) {
diff --git a/tests/locks.c b/tests/locks.c
index 9a928b3..c3eba4e 100644
--- a/tests/locks.c
+++ b/tests/locks.c
@@ -53,7 +53,7 @@ TESTCASE(lock_srp, PSN_EDF | P_FP,
 
         SYSCALL( fd = open(".srp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
 
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_srp_sem(fd, 0) );
@@ -85,7 +85,7 @@ TESTCASE(lock_fmlp, PSN_EDF | GSN_EDF | P_FP,
 
         SYSCALL( fd = open(".fmlp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
 
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_fmlp_sem(fd, 0) );
diff --git a/tests/pcp.c b/tests/pcp.c
index cff4240..19009a3 100644
--- a/tests/pcp.c
+++ b/tests/pcp.c
@@ -15,7 +15,7 @@ TESTCASE(lock_pcp, P_FP,
 
         SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
 
-        SYSCALL( sporadic_partitioned(10, 100, cpu) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), cpu) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_pcp_sem(fd, 0, cpu) );
@@ -45,13 +45,14 @@ TESTCASE(pcp_inheritance, P_FP,
         int fd, od, cpu = 0;
 
         int child_hi, child_lo, child_middle, status, waiters;
-        lt_t delay = ms2lt(100);
+        lt_t delay = ms2ns(100);
         double start, stop;
 
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
-        params.exec_cost  =  ms2lt(10000);
-        params.period     = ms2lt(100000);
+        params.exec_cost  =  ms2ns(10000);
+        params.period     = ms2ns(100000);
         params.relative_deadline = params.period;
         params.phase      = 0;
         params.cls        = RT_CLASS_HARD;
@@ -82,7 +83,7 @@ TESTCASE(pcp_inheritance, P_FP,
 
         child_middle = FORK_TASK(
                 params.priority = LITMUS_HIGHEST_PRIORITY + 1;
-                params.phase    = ms2lt(100);
+                params.phase    = ms2ns(100);
 
                 SYSCALL( set_rt_task_param(gettid(), &params) );
                 SYSCALL( be_migrate_to_cpu(params.cpu) );
@@ -99,7 +100,7 @@ TESTCASE(pcp_inheritance, P_FP,
 
         child_hi = FORK_TASK(
                 params.priority = LITMUS_HIGHEST_PRIORITY;
-                params.phase    = ms2lt(50);
+                params.phase    = ms2ns(50);
 
                 SYSCALL( set_rt_task_param(gettid(), &params) );
                 SYSCALL( be_migrate_to_cpu(params.cpu) );
@@ -150,13 +151,14 @@ TESTCASE(srp_ceiling_blocking, P_FP | PSN_EDF,
         int fd, od;
 
         int child_hi, child_lo, child_middle, status, waiters;
-        lt_t delay = ms2lt(100);
+        lt_t delay = ms2ns(100);
         double start, stop;
 
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
-        params.exec_cost  =  ms2lt(10000);
-        params.period     = ms2lt(100000);
+        params.exec_cost  =  ms2ns(10000);
+        params.period     = ms2ns(100000);
         params.relative_deadline = params.period;
         params.phase      = 0;
         params.cls        = RT_CLASS_HARD;
@@ -185,8 +187,8 @@ TESTCASE(srp_ceiling_blocking, P_FP | PSN_EDF,
 
         child_middle = FORK_TASK(
                 params.priority = LITMUS_HIGHEST_PRIORITY + 1;
-                params.phase    = ms2lt(100);
-                params.relative_deadline -= ms2lt(110);
+                params.phase    = ms2ns(100);
+                params.relative_deadline -= ms2ns(110);
 
                 SYSCALL( set_rt_task_param(gettid(), &params) );
                 SYSCALL( be_migrate_to_cpu(params.cpu) );
@@ -202,8 +204,8 @@ TESTCASE(srp_ceiling_blocking, P_FP | PSN_EDF,
 
         child_hi = FORK_TASK(
                 params.priority = LITMUS_HIGHEST_PRIORITY;
-                params.phase    = ms2lt(50);
-                params.relative_deadline -= ms2lt(200);
+                params.phase    = ms2ns(50);
+                params.relative_deadline -= ms2ns(200);
 
                 SYSCALL( set_rt_task_param(gettid(), &params) );
                 SYSCALL( be_migrate_to_cpu(params.cpu) );
@@ -252,7 +254,7 @@ TESTCASE(lock_dpcp, P_FP,
 
         SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
 
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_dpcp_sem(fd, 0, cpu) );
@@ -305,7 +307,7 @@ TESTCASE(lock_mpcp, P_FP,
 
         SYSCALL( fd = open(".pcp_locks", O_RDONLY | O_CREAT, S_IRUSR) );
 
-        SYSCALL( sporadic_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(ms2ns(10), ms2ns(100), 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_mpcp_sem(fd, 0) );
diff --git a/tests/sched.c b/tests/sched.c
index 713fde2..6726b46 100644
--- a/tests/sched.c
+++ b/tests/sched.c
@@ -9,13 +9,14 @@ TESTCASE(preempt_on_resume, P_FP | PSN_EDF,
          "preempt lower-priority task when a higher-priority task resumes")
 {
         int child_hi, child_lo, status, waiters;
-        lt_t delay = ms2lt(100);
+        lt_t delay = ms2ns(100);
         double start, stop;
 
         struct rt_task params;
+        init_rt_task_param(&params);
         params.cpu        = 0;
-        params.exec_cost  =  ms2lt(10000);
-        params.period     = ms2lt(100000);
+        params.exec_cost  = ms2ns(10000);
+        params.period     = ms2ns(100000);
         params.relative_deadline = params.period;
         params.phase      = 0;
         params.cls        = RT_CLASS_HARD;
@@ -51,14 +52,14 @@ TESTCASE(preempt_on_resume, P_FP | PSN_EDF,
                         ;
 
                 start = wctime();
-                SYSCALL( lt_sleep(ms2lt(100)) );
+                SYSCALL( lt_sleep(ms2ns(100)) );
                 stop = wctime();
 
                 SYSCALL( kill(child_lo, SIGUSR2) );
 
                 if (stop - start >= 0.2)
                         fprintf(stderr, "\nHi-prio delay = %fsec\n",
-                                stop - start - (ms2lt(100) / 1E9));
+                                stop - start - (ms2ns(100) / (float)s2ns(1)));
 
                 /* Assert we woke up 'soonish' after the sleep. */
                 ASSERT( stop - start < 0.2 );