Merge branch 'prop/rt_task-init-final' into temp

Conflicts:
	bin/base_mt_task.c
	bin/rt_launch.c
	bin/rtspin.c
	include/litmus.h
	src/litmus.c
	src/task.c

3 files changed, 233 insertions, 47 deletions

diff --git a/src/litmus.c b/src/litmus.c
index 7cdffcc..213ac3f 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -88,6 +88,34 @@ void show_rt_param(struct rt_task* tp)
                tp->exec_cost, tp->period, tp->cpu);
 }
 
+void init_rt_task_param(struct rt_task* tp)
+{
+        /* Defaults:
+         *  - implicit deadline (t->relative_deadline == 0)
+         *  - phase = 0
+         *  - class = RT_CLASS_SOFT
+         *  - budget policy = NO_ENFORCEMENT
+         *  - fixed priority = LITMUS_LOWEST_PRIORITY
+         *  - release policy = SPORADIC
+         *  - cpu assignment = 0
+         *
+         * User must still set the following fields to non-zero values:
+         *  - tp->exec_cost
+         *  - tp->period
+         *
+         * User must set tp->cpu to the appropriate value for non-global
+         * schedulers. For clusters, set tp->cpu to the first CPU in the
+         * assigned cluster.
+         */
+
+        memset(tp, 0, sizeof(*tp));
+
+        tp->cls = RT_CLASS_SOFT;
+        tp->priority = LITMUS_LOWEST_PRIORITY;
+        tp->budget_policy = NO_ENFORCEMENT;
+        tp->release_policy = SPORADIC;
+}
+
 task_class_t str2class(const char* str)
 {
         if      (!strcmp(str, "hrt"))
@@ -102,57 +130,50 @@ task_class_t str2class(const char* str)
 
 #define NS_PER_MS 1000000
 
-/* only for best-effort execution: migrate to target_cpu */
-int be_migrate_to(int target_cpu)
+int sporadic_global(lt_t e_ns, lt_t p_ns)
 {
-        cpu_set_t cpu_set;
+        struct rt_task param;
+
+        init_rt_task_param(&param);
+        param.exec_cost = e_ns;
+        param.period = p_ns;
 
-        CPU_ZERO(&cpu_set);
-        CPU_SET(target_cpu, &cpu_set);
-        return sched_setaffinity(0, sizeof(cpu_set_t), &cpu_set);
+        return set_rt_task_param(gettid(), &param);
 }
 
-int sporadic_task(lt_t e, lt_t p, lt_t phase,
-                  int cpu, unsigned int priority,
-                  task_class_t cls,
-                  budget_policy_t budget_policy,
-                  budget_signal_policy_t budget_signal_policy,
-                  int set_cpu_set)
+int sporadic_partitioned(lt_t e_ns, lt_t p_ns, int partition)
 {
-        return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS, phase * NS_PER_MS,
-                                cpu, priority, cls, budget_policy, budget_signal_policy,
-                                set_cpu_set);
+        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_task_ns(lt_t e, lt_t p, lt_t phase,
-                        int cpu, unsigned int priority,
-                        task_class_t cls,
-                        budget_policy_t budget_policy,
-                        budget_signal_policy_t budget_signal_policy,
-                        int set_cpu_set)
+int sporadic_clustered(lt_t e_ns, lt_t p_ns, int cluster, int cluster_size)
 {
-        struct rt_task param;
         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       = cpu;
-        param.cls       = cls;
-        param.phase     = phase;
-        param.budget_policy = budget_policy;
-        param.budget_signal_policy = budget_signal_policy;
-        param.priority  = priority;
-
-        if (set_cpu_set) {
-                ret = be_migrate_to(cpu);
-                check("migrate to cpu");
-        }
         return set_rt_task_param(gettid(), &param);
 }
 
diff --git a/src/migration.c b/src/migration.c
new file mode 100644
index 0000000..152d81b
--- /dev/null
+++ b/src/migration.c
@@ -0,0 +1,162 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sched.h> /* for cpu sets */
+#include <unistd.h>
+
+#include "migration.h"
+
+extern ssize_t read_file(const char* fname, void* buf, size_t maxlen);
+
+int release_master()
+{
+        static const char NO_CPU[] = "NO_CPU";
+        char buf[5] = {0}; /* up to 9999 CPUs */
+        int master = -1;
+
+        int ret = read_file("/proc/litmus/release_master", &buf, sizeof(buf)-1);
+
+        if ((ret > 0) && (strncmp(buf, NO_CPU, sizeof(NO_CPU)-1) != 0))
+                master = atoi(buf);
+
+        return master;
+}
+
+int num_online_cpus()
+{
+        return sysconf(_SC_NPROCESSORS_ONLN);
+}
+
+int partition_to_cpu(int partition)
+{
+        int cpu = partition;
+        int master = release_master();
+        if (master != -1 && master <= cpu) {
+                ++cpu; /* skip over the release master */
+        }
+        return cpu;
+}
+
+int cluster_to_first_cpu(int cluster, int cluster_sz)
+{
+        int first_cpu;
+        int master;
+
+        if (cluster_sz == 1)
+                return partition_to_cpu(cluster);
+
+        master = release_master();
+        first_cpu = cluster * cluster_sz;
+
+        if (master == first_cpu)
+                ++first_cpu;
+
+        return first_cpu;
+}
+
+int be_migrate_thread_to_cpu(pid_t tid, int target_cpu)
+{
+        cpu_set_t *cpu_set;
+        size_t sz;
+        int num_cpus;
+        int ret;
+
+        /* TODO: Error check to make sure that tid is not a real-time task. */
+
+        if (target_cpu < 0)
+                return -1;
+
+        num_cpus = num_online_cpus();
+        if (num_cpus == -1)
+                return -1;
+
+        if (target_cpu >= num_cpus)
+                return -1;
+
+        cpu_set = CPU_ALLOC(num_cpus);
+        sz = CPU_ALLOC_SIZE(num_cpus);
+        CPU_ZERO_S(sz, cpu_set);
+        CPU_SET_S(target_cpu, sz, cpu_set);
+
+        /* apply to caller */
+        if (tid == 0)
+                tid = gettid();
+
+        ret = sched_setaffinity(tid, sz, cpu_set);
+
+        CPU_FREE(cpu_set);
+
+        return ret;
+}
+
+int be_migrate_thread_to_cluster(pid_t tid, int cluster, int cluster_sz)
+{
+        return __be_migrate_thread_to_cluster(tid, cluster, cluster_sz, 0);
+}
+
+int __be_migrate_thread_to_cluster(pid_t tid, int cluster, int cluster_sz,
+                                                 int ignore_rm)
+{
+        int first_cpu = cluster * cluster_sz; /* first CPU in cluster */
+        int last_cpu = first_cpu + cluster_sz - 1;
+        int master;
+        int num_cpus;
+        cpu_set_t *cpu_set;
+        size_t sz;
+        int i;
+        int ret;
+
+        /* TODO: Error check to make sure that tid is not a real-time task. */
+
+        if (cluster_sz == 1) {
+                /* we're partitioned */
+                return be_migrate_thread_to_partition(tid, cluster);
+        }
+
+        master = (ignore_rm) ? -1 : release_master();
+        num_cpus = num_online_cpus();
+
+        if (num_cpus == -1 || last_cpu >= num_cpus || first_cpu < 0)
+                return -1;
+
+        cpu_set = CPU_ALLOC(num_cpus);
+        sz = CPU_ALLOC_SIZE(num_cpus);
+        CPU_ZERO_S(sz, cpu_set);
+
+        for (i = first_cpu; i <= last_cpu; ++i) {
+                if (i != master) {
+                        CPU_SET_S(i, sz, cpu_set);
+                }
+        }
+
+        /* apply to caller */
+        if (tid == 0)
+                tid = gettid();
+
+        ret = sched_setaffinity(tid, sz, cpu_set);
+
+        CPU_FREE(cpu_set);
+
+        return ret;
+}
+
+int be_migrate_thread_to_partition(pid_t tid, int partition)
+{
+        return be_migrate_thread_to_cpu(tid, partition_to_cpu(partition));
+}
+
+
+int be_migrate_to_cpu(int target_cpu)
+{
+        return be_migrate_thread_to_cpu(0, target_cpu);
+}
+
+int be_migrate_to_cluster(int cluster, int cluster_sz)
+{
+        return be_migrate_thread_to_cluster(0, cluster, cluster_sz);
+}
+
+int be_migrate_to_partition(int partition)
+{
+        return be_migrate_thread_to_partition(0, partition);
+}
diff --git a/src/task.c b/src/task.c
index 9317cc7..ef4bf79 100644
--- a/src/task.c
+++ b/src/task.c
@@ -40,11 +40,12 @@ int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, rt_setup_fn_t setup,
         return rt_task;
 }
 
-int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, lt_t wcet, lt_t period,
-                     unsigned int priority, task_class_t cls)
+int __create_rt_task(rt_fn_t rt_prog, void *arg, int cluster, int cluster_size,
+                lt_t wcet, lt_t period, unsigned int priority, task_class_t cls)
 {
         struct rt_task params;
-        params.cpu       = cpu;
+        init_rt_task_param(&params);
+        params.cpu       = cluster_to_first_cpu(cluster, cluster_size);
         params.period    = period;
         params.exec_cost = wcet;
         params.cls       = cls;
@@ -57,9 +58,11 @@ int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, lt_t wcet, lt_t period
                                 (rt_setup_fn_t) set_rt_task_param, &params);
 }
 
-int create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, lt_t wcet, lt_t period,
-                   unsigned int priority) {
-        return __create_rt_task(rt_prog, arg, cpu, wcet, period, priority, RT_CLASS_HARD);
+int create_rt_task(rt_fn_t rt_prog, void *arg, int cluster, int cluster_size,
+                lt_t wcet, lt_t period, unsigned int prio)
+{
+        return __create_rt_task(rt_prog, arg, cluster, cluster_size, wcet, period,
+                                prio, RT_CLASS_HARD);
 }