Add FMLP Test Task

2 files changed, 285 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index 2109a45..031a3ac 100644
--- a/Makefile
+++ b/Makefile
@@ -70,7 +70,7 @@ AR  := ${CROSS_COMPILE}${AR}
 # Targets
 
 all     = lib ${rt-apps}
-rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
+rt-apps = cycles base_task rt_launch rtspin fmlp_test_task release_ts measure_syscall \
           base_mt_task runtests
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
@@ -211,6 +211,9 @@ obj-rt_launch = rt_launch.o common.o
 obj-rtspin = rtspin.o common.o
 lib-rtspin = -lrt
 
+obj-fmlp_test_task = fmlp_test_task.o common.o
+lib-fmlp_test_task = -lrt
+
 obj-release_ts = release_ts.o
 
 obj-measure_syscall = null_call.o
diff --git a/bin/fmlp_test_task.c b/bin/fmlp_test_task.c
new file mode 100644
index 0000000..6f8e2ec
--- /dev/null
+++ b/bin/fmlp_test_task.c
@@ -0,0 +1,281 @@
+/* based_mt_task.c -- A basic multi-threaded real-time task skeleton. 
+ *
+ * This (by itself useless) task demos how to setup a multi-threaded LITMUS^RT
+ * real-time task. Familiarity with the single threaded example (base_task.c)
+ * is assumed.
+ *
+ * Currently, liblitmus still lacks automated support for real-time
+ * tasks, but internaly it is thread-safe, and thus can be used together
+ * with pthreads.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+/* Extras */
+#include <stdint.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+/* Include gettid() */
+#include <sys/types.h>
+
+/* Include threading support. */
+#include <pthread.h>
+
+/* Include the LITMUS^RT API.*/
+#include "litmus.h"
+
+/* Let's create 4 threads in the example,
+ */
+#define NUM_THREADS      4
+#define MAX_PHASES      10
+
+/* The information passed to each thread. Could be anything. */
+struct thread_context {
+        int id;
+        int fd;
+        int semaphore;
+        lt_t exec;
+        lt_t period;
+        int split;
+        int phases;
+        double initial_phase;
+        double locked[MAX_PHASES];
+        double unlocked[MAX_PHASES];
+};
+
+/* The real-time thread program. Doesn't have to be the same for
+ * all threads. Here, we only have one that will invoke job().
+ */
+void* rt_thread(void *tcontext);
+
+/* Declare the periodically invoked job. 
+ * Returns 1 -> task should exit.
+ *         0 -> task should continue.
+ */
+int job(struct thread_context* ctx);
+
+
+/* Catch errors.
+ */
+#if 0
+#define CALL( exp ) do { \
+                int ret; \
+                ret = exp; \
+                if (ret != 0) \
+                        fprintf(stderr, "%s failed: %m\n", #exp);\
+                else \
+                        fprintf(stderr, "%s ok.\n", #exp); \
+        } while (0)
+#endif
+#define CALL( exp ) exp
+
+/* Basic setup is the same as in the single-threaded example. However, 
+ * we do some thread initiliazation first before invoking the job.
+ */
+int main(int argc, char** argv)
+{
+        int i;
+        struct thread_context ctx[NUM_THREADS];
+        pthread_t             task[NUM_THREADS];
+        int fd;
+
+        /* The task is in background mode upon startup. */              
+
+
+        /*****
+         * 1) Command line paramter parsing would be done here.
+         */
+
+
+       
+        /*****
+         * 2) Work environment (e.g., global data structures, file data, etc.) would
+         *    be setup here.
+         */
+
+
+
+        /*****
+         * 3) Initialize LITMUS^RT.
+         *    Task parameters will be specified per thread.
+         */
+        fd = open("semaphores", O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR);
+        CALL( init_litmus() );
+
+
+        /***** 
+         * 4) Launch threads.
+         */
+
+        ctx[0].id = 0;
+        ctx[0].fd = fd;
+        ctx[0].exec = 10000000;
+        ctx[0].period = 20000000;
+        ctx[0].split = 5;
+        ctx[0].phases = 1;
+        ctx[0].initial_phase = .0025;
+        ctx[0].locked[0] = .003;
+        ctx[0].unlocked[0] = .0045;
+
+        ctx[1].id = 1;
+        ctx[1].fd = fd;
+        ctx[1].exec = 10000000;
+        ctx[1].period = 20000000;
+        ctx[1].split = 5;
+        ctx[1].phases = 1;
+        ctx[1].initial_phase = .003;
+        ctx[1].locked[0] = .002;
+        ctx[1].unlocked[0] = .005;
+
+        ctx[2].id = 2;
+        ctx[2].fd = fd;
+        ctx[2].exec = 4000000;
+        ctx[2].period = 10000000;
+        ctx[2].split = 1;
+        ctx[2].phases = 0;
+        ctx[2].initial_phase = .004;
+
+        ctx[3].id = 3;
+        ctx[3].fd = fd;
+        ctx[3].exec = 4000000;
+        ctx[3].period = 10000000;
+        ctx[3].split = 1;
+        ctx[3].phases = 0;
+        ctx[3].initial_phase = .004;
+
+        for (i = 0; i < NUM_THREADS; i++){
+                pthread_create(task + i, NULL, rt_thread, (void *) (ctx + i));
+        }
+
+        
+        /*****
+         * 5) Wait for RT threads to terminate.
+         */
+        for (i = 0; i < NUM_THREADS; i++)
+                pthread_join(task[i], NULL);
+        
+
+        /***** 
+         * 6) Clean up, maybe print results and stats, and exit.
+         */
+        return 0;
+}
+
+
+
+/* A real-time thread is very similar to the main function of a single-threaded
+ * real-time app. Notice, that init_rt_thread() is called to initialized per-thread
+ * data structures of the LITMUS^RT user space libary.
+ */
+void* rt_thread(void *tcontext)
+{
+        int do_exit = 0;
+        struct thread_context *ctx = (struct thread_context *) tcontext;
+
+        /* Make presence visible. */
+        printf("RT Thread %d active.\n", ctx->id);
+
+        /*****
+         * 1) Initialize real-time settings.
+         */
+        CALL( init_rt_thread() );
+        
+        ctx->semaphore = open_fmlp_sem(ctx->fd, 0);
+        CALL( sporadic_task_ns(ctx->exec, ctx->period, 0, ctx->split, 0,
+                                   RT_CLASS_HARD, PRECISE_ENFORCEMENT, 0));
+
+
+        /*****
+         * 2) Transition to real-time mode.
+         */
+        CALL( task_mode(LITMUS_RT_TASK) );
+
+        /* The task is now executing as a real-time task if the call didn't fail. 
+         */
+
+        printf("[%d] Waiting for TS release.\n ", ctx->id);
+        wait_for_ts_release();
+
+
+        /*****
+         * 3) Invoke real-time jobs.
+         */
+        do {
+                /* Wait until the next job is released. */
+                sleep_next_period();
+                /* Invoke job. */
+                do_exit = job(ctx);             
+        } while (!do_exit);
+
+
+        
+        /*****
+         * 4) Transition to background mode.
+         */
+        CALL( task_mode(BACKGROUND_TASK) );
+
+
+        return NULL;
+}
+
+#define NUMS 4096
+static int num[NUMS];
+
+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 emergency_exit)
+{
+        double last_loop = 0, loop_start;
+        int tmp = 0;
+
+        double start = cputime();
+        double now = cputime();
+        while (now + last_loop < start + exec_time) {
+                loop_start = now;
+                tmp += loop_once();
+                now = cputime();
+                last_loop = now - loop_start;
+                if (emergency_exit && wctime() > emergency_exit) {
+                        /* Oops --- this should only be possible if the execution time tracking
+                         * is broken in the LITMUS^RT kernel. */
+                        fprintf(stderr, "!!! fmlp_test_task/%d emergency exit!\n", getpid());
+                        fprintf(stderr, "Something is seriously wrong! Do not ignore this.\n");
+                        break;
+                }
+        }
+
+        return tmp;
+}
+
+int job(struct thread_context* ctx) 
+{
+        int i;
+        /* Do real-time calculation. */
+        double emergency_exit = ctx->initial_phase;
+        for (i = 0; i < ctx->phases; i++) {
+                emergency_exit += ctx->locked[i];
+                emergency_exit += ctx->unlocked[i];
+        }
+        emergency_exit *= 200;
+        emergency_exit += wctime();
+        loop_for(ctx->initial_phase, emergency_exit);
+        for (i = 0; i < ctx->phases; i++) {
+                CALL( litmus_lock( 0 ));
+                loop_for(ctx->locked[i], emergency_exit);
+                CALL( litmus_unlock( 0 ));
+                loop_for(ctx->unlocked[i], emergency_exit);
+        }
+        /* Don't exit. */
+        return 0;
+}