Merge branch 'wip-gpu-rtas12' into wip-slave-threads

Conflicts:
	Makefile
	src/syscalls.c

4 files changed, 206 insertions, 8 deletions

diff --git a/src/litmus.c b/src/litmus.c
index d3cc6bb..3bab483 100644
--- a/src/litmus.c
+++ b/src/litmus.c
@@ -26,7 +26,7 @@ task_class_t str2class(const char* str)
         else if (!strcmp(str, "be"))
                 return RT_CLASS_BEST_EFFORT;
         else
-                return -1;
+                return (task_class_t)(-1);
 }
 
 #define NS_PER_MS 1000000
@@ -43,15 +43,19 @@ int be_migrate_to(int target_cpu)
 
 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)
+                  budget_policy_t budget_policy,
+                  budget_signal_policy_t budget_signal_policy,
+                  int set_cpu_set)
 {
         return sporadic_task_ns(e * NS_PER_MS, p * NS_PER_MS, phase * NS_PER_MS,
-                                cpu, cls, budget_policy, set_cpu_set);
+                                cpu, cls, budget_policy, budget_signal_policy, set_cpu_set);
 }
 
 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)
+                        budget_policy_t budget_policy,
+                        budget_signal_policy_t budget_signal_policy,
+                        int set_cpu_set)
 {
         struct rt_task param;
         int ret;
@@ -67,6 +71,7 @@ int sporadic_task_ns(lt_t e, lt_t p, lt_t phase,
         param.cls       = cls;
         param.phase     = phase;
         param.budget_policy = budget_policy;
+        param.budget_signal_policy = budget_signal_policy;
 
         if (set_cpu_set) {
                 ret = be_migrate_to(cpu);
@@ -100,3 +105,74 @@ void exit_litmus(void)
 {
         /* nothing to do in current version */
 }
+
+int open_kfmlp_gpu_sem(int fd, int name, int num_gpus, int gpu_offset, int num_simult_users, int affinity_aware)
+{
+        int lock_od;
+        int affinity_od;
+        int num_replicas;
+        struct gpu_affinity_observer_args aff_args;
+        int aff_type;
+        
+        // number of GPU tokens
+        num_replicas = num_gpus * num_simult_users;
+
+        // create the GPU token lock
+        lock_od = open_kfmlp_sem(fd, name, (void*)&num_replicas);
+        if(lock_od < 0) {
+                perror("open_kfmlp_sem");
+                return -1;
+        }
+        
+        // create the affinity method to use.
+        // "no affinity" -> KFMLP_SIMPLE_GPU_AFF_OBS
+        aff_args.obs.lock_od = lock_od;
+        aff_args.replica_to_gpu_offset = gpu_offset;
+        aff_args.nr_simult_users = num_simult_users;
+        
+        aff_type = (affinity_aware) ? KFMLP_GPU_AFF_OBS : KFMLP_SIMPLE_GPU_AFF_OBS;
+        affinity_od = od_openx(fd, aff_type, name+1, &aff_args);
+        if(affinity_od < 0) {
+                perror("open_kfmlp_aff");
+                return -1;
+        }       
+        
+        return lock_od;
+}
+
+
+
+int open_ikglp_gpu_sem(int fd, int name, int num_gpus, int gpu_offset, int num_simult_users, int affinity_aware, int relax_max_fifo_len)
+{
+        int lock_od;
+        int affinity_od;
+        int num_replicas;
+        struct gpu_affinity_observer_args aff_args;
+        int aff_type;
+
+        // number of GPU tokens
+        num_replicas = num_gpus * num_simult_users;
+        
+        // create the GPU token lock
+        lock_od = open_ikglp_sem(fd, name, (void*)&num_replicas);
+        if(lock_od < 0) {
+                perror("open_ikglp_sem");
+                return -1;
+        }
+        
+        // create the affinity method to use.
+        // "no affinity" -> KFMLP_SIMPLE_GPU_AFF_OBS
+        aff_args.obs.lock_od = lock_od;
+        aff_args.replica_to_gpu_offset = gpu_offset;
+        aff_args.nr_simult_users = num_simult_users;
+        aff_args.relaxed_rules = (relax_max_fifo_len) ? 1 : 0;
+        
+        aff_type = (affinity_aware) ? IKGLP_GPU_AFF_OBS : IKGLP_SIMPLE_GPU_AFF_OBS;
+        affinity_od = od_openx(fd, aff_type, name+1, &aff_args);
+        if(affinity_od < 0) {
+                perror("open_ikglp_aff");
+                return -1;
+        }       
+        
+        return lock_od;
+}
diff --git a/src/signal.c b/src/signal.c
new file mode 100644
index 0000000..bfe18b9
--- /dev/null
+++ b/src/signal.c
@@ -0,0 +1,107 @@
+#include <stdio.h>
+#include <string.h>
+
+#include "litmus.h"
+#include "internal.h"
+
+/* setjmp calls are stored on a singlely link list,
+ * one stack per thread.
+ */
+static __thread litmus_sigjmp_t *g_sigjmp_tail = 0;
+
+void push_sigjmp(litmus_sigjmp_t *buf)
+{
+        buf->prev = g_sigjmp_tail;
+        g_sigjmp_tail = buf;
+}
+
+litmus_sigjmp_t* pop_sigjmp(void)
+{
+        litmus_sigjmp_t* ret;
+        ret = g_sigjmp_tail;
+        g_sigjmp_tail = (ret) ? ret->prev : NULL;
+        return ret;
+}
+
+static void reg_litmus_signals(unsigned long litmus_sig_mask,
+                struct sigaction *pAction)
+{
+        int ret;
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) { 
+                ret = sigaction(SIG_BUDGET, pAction, NULL);
+                check("SIG_BUDGET");
+        }
+        /* more signals ... */
+}
+
+void ignore_litmus_signals(unsigned long litmus_sig_mask)
+{
+        activate_litmus_signals(litmus_sig_mask, SIG_IGN);
+}
+
+void activate_litmus_signals(unsigned long litmus_sig_mask,
+        litmus_sig_handler_t handle)
+{
+        struct sigaction action;
+        memset(&action, 0, sizeof(action));
+        action.sa_handler = handle;
+
+        reg_litmus_signals(litmus_sig_mask, &action);
+}
+
+void activate_litmus_signal_actions(unsigned long litmus_sig_mask,
+                litmus_sig_actions_t handle)
+{
+        struct sigaction action;
+        memset(&action, 0, sizeof(action));
+        action.sa_sigaction = handle;
+        action.sa_flags = SA_SIGINFO;
+
+        reg_litmus_signals(litmus_sig_mask, &action);
+}
+
+void block_litmus_signals(unsigned long litmus_sig_mask)
+{
+        int ret;
+        sigset_t sigs;
+        sigemptyset(&sigs);
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) {
+                sigaddset(&sigs, SIG_BUDGET);
+        }
+        /* more signals ... */
+
+        ret = sigprocmask(SIG_BLOCK, &sigs, NULL);
+        check("SIG_BLOCK litmus signals");
+}
+
+void unblock_litmus_signals(unsigned long litmus_sig_mask)
+{
+        int ret;
+        sigset_t sigs;
+        sigemptyset(&sigs);
+
+        if (litmus_sig_mask | SIG_BUDGET_MASK) {
+                sigaddset(&sigs, SIG_BUDGET);
+        }
+        /* more ... */
+
+        ret = sigprocmask(SIG_UNBLOCK, &sigs, NULL);
+        check("SIG_UNBLOCK litmus signals");
+}
+
+
+void longjmp_on_litmus_signal(int signum)
+{
+        /* We get signal!  Main screen turn on! */
+        litmus_sigjmp_t *lit_env;
+        lit_env = pop_sigjmp();
+        if (lit_env) {
+                /* What you say?! */
+                siglongjmp(lit_env->env, signum); /* restores signal mask */
+        }
+        else {
+                /* silently ignore the signal */
+        }
+}
diff --git a/src/syscalls.c b/src/syscalls.c
index 44d5808..56ad218 100644..100755
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -52,6 +52,16 @@ int litmus_unlock(int od)
         return syscall(__NR_litmus_unlock, od);
 }
 
+int litmus_dgl_lock(int *ods, int dgl_size)
+{
+        return syscall(__NR_litmus_dgl_lock, ods, dgl_size);
+}
+
+int litmus_dgl_unlock(int *ods, int dgl_size)
+{
+        return syscall(__NR_litmus_dgl_unlock, ods, dgl_size);
+}
+
 int get_job_no(unsigned int *job_no)
 {
         return syscall(__NR_query_job_no, job_no);
@@ -87,7 +97,12 @@ int null_call(cycles_t *timestamp)
         return syscall(__NR_null_call, timestamp);
 }
 
-int slave_non_rt_threads(void)
+int enable_aux_rt_tasks(int flags)
+{
+        return syscall(__NR_set_aux_tasks, flags | AUX_ENABLE);
+}
+
+int disable_aux_rt_tasks(int flags)
 {
-        return syscall(__NR_slave_non_rt_threads);
+        return syscall(__NR_set_aux_tasks, flags & ~AUX_ENABLE);
 }
diff --git a/src/task.c b/src/task.c
index 4d237bd..26fc15a 100644
--- a/src/task.c
+++ b/src/task.c
@@ -41,13 +41,13 @@ int __launch_rt_task(rt_fn_t rt_prog, void *rt_arg, rt_setup_fn_t setup,
 }
 
 int __create_rt_task(rt_fn_t rt_prog, void *arg, int cpu, int wcet, int period,
-                     task_class_t class)
+                     task_class_t rt_class)
 {
         struct rt_task params;
         params.cpu       = cpu;
         params.period    = period;
         params.exec_cost = wcet;
-        params.cls       = class;
+        params.cls       = rt_class;
         params.phase     = 0;
         /* enforce budget for tasks that might not use sleep_next_period() */
         params.budget_policy = QUANTUM_ENFORCEMENT;