Revisions based on review comments.wip-arbit-deadline

8 files changed, 64 insertions, 44 deletions

diff --git a/bin/base_mt_task.c b/bin/base_mt_task.c
index 802ef0b..78446e3 100644
--- a/bin/base_mt_task.c
+++ b/bin/base_mt_task.c
@@ -11,6 +11,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* Include gettid() */
 #include <sys/types.h>
@@ -21,9 +22,11 @@
 /* Include the LITMUS^RT API.*/
 #include "litmus.h"
 
-#define PERIOD       100
-#define REL_DEADLINE 100
-#define EXEC_COST    10
+#define PERIOD            100
+#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.
@@ -123,6 +126,15 @@ void* rt_thread(void *tcontext)
 {
         int do_exit;
         struct thread_context *ctx = (struct thread_context *) 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;
+        param.cls = RT_CLASS_SOFT;
+        param.budget_policy = NO_ENFORCEMENT;
 
         /* Make presence visible. */
         printf("RT Thread %d active.\n", ctx->id);
@@ -131,7 +143,16 @@ void* rt_thread(void *tcontext)
          * 1) Initialize real-time settings.
          */
         CALL( init_rt_thread() );
-        CALL( sporadic_global(EXEC_COST, PERIOD, REL_DEADLINE) );
+
+        /* To specify a partition, do
+         *
+         * param.cpu = CPU;
+         * be_migrate_to(CPU);
+         *
+         * where CPU ranges from 0 to "Number of CPUs" - 1 before calling
+         * set_rt_task_param().
+         */
+        CALL( set_rt_task_param(gettid(), &param) );
 
         /*****
          * 2) Transition to real-time mode.
diff --git a/bin/base_task.c b/bin/base_task.c
index b2408ac..8baf3c8 100644
--- a/bin/base_task.c
+++ b/bin/base_task.c
@@ -12,6 +12,7 @@
  */
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 /* Second, we include the LITMUS^RT user space library header.
  * This header, part of liblitmus, provides the user space API of
@@ -22,10 +23,14 @@
 /* Next, we define period and execution cost to be constant. 
  * These are only constants for convenience in this example, they can be
  * determined at run time, e.g., from command line parameters.
+ *
+ * These are in milliseconds.
  */
-#define PERIOD       100
-#define REL_DEADLINE 100
-#define EXEC_COST    10
+#define PERIOD            100
+#define RELATIVE_DEADLINE 100
+#define EXEC_COST         10
+
+#define NS_PER_MS         1e6
 
 /* Catch errors.
  */
@@ -61,6 +66,15 @@ int job(void);
 int main(int argc, char** argv)
 {
         int do_exit;
+        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;
+        param.cls = RT_CLASS_SOFT;
+        param.budget_policy = NO_ENFORCEMENT;
 
         /* The task is in background mode upon startup. */              
 
@@ -86,16 +100,16 @@ int main(int argc, char** argv)
          *    to the first partition (since partitioning is performed offline).
          */
         CALL( init_litmus() );
-        CALL( sporadic_global(EXEC_COST, PERIOD, REL_DEADLINE) );
 
-        /* To specify a partition, use sporadic_partitioned().
-         * Example:
+        /* To specify a partition, do
          *
-         *              sporadic_partitioned(EXEC_COST, PERIOD, CPU);
+         * param.cpu = CPU;
+         * be_migrate_to(CPU);
          *
-         * where CPU ranges from 0 to "Number of CPUs" - 1.
+         * where CPU ranges from 0 to "Number of CPUs" - 1 before calling
+         * set_rt_task_param().
          */
-
+        CALL( set_rt_task_param(gettid(), &param) );
 
 
         /*****
diff --git a/bin/rtspin.c b/bin/rtspin.c
index 48b8379..ae76941 100644
--- a/bin/rtspin.c
+++ b/bin/rtspin.c
@@ -274,7 +274,7 @@ int main(int argc, char** argv)
                         bail_out("could not migrate to target partition");
         }
 
-        ret = sporadic_task_ns(wcet, period, 0, 0, cpu, class,
+        ret = sporadic_task_ns(wcet, period, 0, cpu, class,
                                want_enforcement ? PRECISE_ENFORCEMENT
                                                 : NO_ENFORCEMENT,
                                migrate);
diff --git a/include/litmus.h b/include/litmus.h
index 2c33f0c..4c85d28 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -31,36 +31,21 @@ int get_rt_task_param(pid_t pid, struct rt_task* param);
 
 /* times are given in ms */
 int sporadic_task(
-                lt_t e, lt_t p, lt_t d, lt_t phase,
+                lt_t e, lt_t p, lt_t phase,
                 int partition, task_class_t cls,
                 budget_policy_t budget_policy, int set_cpu_set);
 
 /* times are given in ns */
 int sporadic_task_ns(
-                lt_t e, lt_t p, lt_t d, lt_t phase,
+                lt_t e, lt_t p, lt_t phase,
                 int cpu, task_class_t cls,
                 budget_policy_t budget_policy, int set_cpu_set);
 
-/* implicit deadline macros */
-#define sporadic_implicit_task(e, p, phase, \
-                                partition, cls, \
-                                budget_policy, set_cpu_set) \
-        sporadic_task(e, p, 0, phase, partition, cls, budget_policy, set_cpu_set)
-#define sporadic_implicit_task_ns(e, p, phase, \
-                                partition, cls, \
-                                budget_policy, set_cpu_set) \
-        sporadic_task_ns(e, p, 0, phase, partition, cls, budget_policy, set_cpu_set)
-
-
 /* budget enforcement off by default in these macros */
-#define sporadic_global(e, p, d) \
-        sporadic_task(e, p, d, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
-#define sporadic_partitioned(e, p, d, cpu) \
-        sporadic_task(e, p, d, 0, cpu, RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
-#define sporadic_implicit_global(e, p) \
-        sporadic_implicit_task(e, p, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
-#define sporadic_implicit_partitioned(e, p, cpu) \
-        sporadic_implicit_task(e, p, 0, cpu, RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
+#define sporadic_global(e, p) \
+        sporadic_task(e, p, 0, 0, RT_CLASS_SOFT, NO_ENFORCEMENT, 0)
+#define sporadic_partitioned(e, p, cpu) \
+        sporadic_task(e, p, 0, cpu, RT_CLASS_SOFT, NO_ENFORCEMENT, 1)
 
 /* file descriptor attached shared objects support */
 typedef enum  {
diff --git a/src/litmus.c b/src/litmus.c
index 907317a..d78a9eb 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -41,16 +41,15 @@ int be_migrate_to(int target_cpu)
         return sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set);
 }
 
-int sporadic_task(lt_t e, lt_t p, lt_t d, lt_t phase,
+int sporadic_task(lt_t e, lt_t p, lt_t phase,
                   int cpu, task_class_t cls,
                   budget_policy_t budget_policy, int set_cpu_set)
 {
-        return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS,
-                                d * NS_PER_MS, phase * NS_PER_MS,
+        return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS, phase * NS_PER_MS,
                                 cpu, cls, budget_policy, set_cpu_set);
 }
 
-int sporadic_task_ns(lt_t e, lt_t p, lt_t d, lt_t phase,
+int sporadic_task_ns(lt_t e, lt_t p, lt_t phase,
                         int cpu, task_class_t cls,
                         budget_policy_t budget_policy, int set_cpu_set)
 {
@@ -64,7 +63,7 @@ int sporadic_task_ns(lt_t e, lt_t p, lt_t d, lt_t phase,
 
         param.exec_cost = e;
         param.period    = p;
-        param.rdeadline = (d == 0) ? p : d; /* implicit deadline if d == 0 */
+        param.relative_deadline = p; /* implicit deadline */
         param.cpu       = cpu;
         param.cls       = cls;
         param.phase     = phase;
diff --git a/tests/core_api.c b/tests/core_api.c
index 61463fc..425bb99 100644
--- a/tests/core_api.c
+++ b/tests/core_api.c
@@ -20,6 +20,7 @@ TESTCASE(set_rt_task_param_invalid_params, ALL,
         struct rt_task params;
         params.cpu        = 0;
         params.period     = 100;
+        params.relative_deadline = params.period;
         params.phase      = 0;
         params.cls        = RT_CLASS_HARD;
         params.budget_policy = NO_ENFORCEMENT;
@@ -61,7 +62,7 @@ TESTCASE(rt_fork_non_rt, LITMUS,
         unsigned int pid, job_no;
         int status;
 
-        SYSCALL( sporadic_implicit_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         pid = fork();
diff --git a/tests/fdso.c b/tests/fdso.c
index 15c643f..8a2a0d0 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_implicit_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         if (pid == 0) {
diff --git a/tests/locks.c b/tests/locks.c
index 4d9934f..65b932a 100644
--- a/tests/locks.c
+++ b/tests/locks.c
@@ -53,7 +53,7 @@ TESTCASE(lock_srp, PSN_EDF,
 
         SYSCALL( fd = open(".srp_locks", O_RDONLY | O_CREAT) );
 
-        SYSCALL( sporadic_implicit_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(10, 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,
 
         SYSCALL( fd = open(".fmlp_locks", O_RDONLY | O_CREAT) );
 
-        SYSCALL( sporadic_implicit_partitioned(10, 100, 0) );
+        SYSCALL( sporadic_partitioned(10, 100, 0) );
         SYSCALL( task_mode(LITMUS_RT_TASK) );
 
         SYSCALL( od = open_fmlp_sem(fd, 0) );