Add example real-time task skeleton base_task.c .

2 files changed, 137 insertions, 1 deletions

diff --git a/Makefile b/Makefile
index d067933..9124b4d 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,7 @@ LIBS= ./liblitmus.a
 LIB_OBJ=  litmus.o syscalls.o sched_trace.o adaptive.o edf-hsb.o task.o kernel_iface.o
 
 TARGETS = showsched iotest set_rt_mode  run timeout rt_launch edfhsb liblitmus.a \
-          wait_test np_test stdump mode_test
+          wait_test np_test stdump mode_test base_task
 
 vpath %.h include/
 vpath %.c src/ bin/
@@ -15,6 +15,9 @@ all: ${TARGETS}
 clean:
         rm -f *.o *~  ${TARGETS}
 
+base_task: base_task.o liblitmus.a
+        cc -static -o base_task base_task.o  ${LIBS}
+
 wait_test: wait_test.o litmus.h liblitmus.a
         cc -static -o wait_test wait_test.o  ${LIBS}
 
diff --git a/bin/base_task.c b/bin/base_task.c
new file mode 100644
index 0000000..e5f50b1
--- /dev/null
+++ b/bin/base_task.c
@@ -0,0 +1,133 @@
+/* based_task.c -- A basic real-time task skeleton. 
+ *
+ * This (by itself useless) task demos how to setup LITMUS^RT real-time task.
+ *
+ * Compile:
+ *
+ */
+
+
+/* First, we include standard headers.
+ * Generally speaking, a LITMUS^RT real-time task can perform any
+ * system call, etc., but no real-time guarantees can be made if a
+ * system call blocks. To be on the safe side, only use I/O for debugging
+ * purposes and from non-real-time sections.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+
+/* Second, we include the LITMUS^RT user space library header.
+ * This header, part of liblitmus, provides the user space API of
+ * LITMUS^RT.
+ */
+#include "litmus.h"
+
+/* 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.
+ */
+#define PERIOD          100
+#define EXEC_COST        10
+
+/* Declare the periodically invoked job. 
+ * Returns 1 -> task should exit.
+ *         0 -> task should continue.
+ */
+int job(void);
+
+/* typically, main() does a couple of things: 
+ *      1) parse command line parameters, etc.
+ *      2) Setup work environment.
+ *      3) Setup real-time parameters.
+ *      4) Transition to real-time mode.
+ *      5) Invoke periodic or sporadic jobs.
+ *      6) Transition to background mode.
+ *      7) Clean up and exit.
+ *
+ * The following main() function provides the basic skeleton of a single-threaded
+ * LITMUS^RT real-time task. In a real program, all the return values should be 
+ * checked for errors.
+ */
+int main(int argc, char** argv)
+{
+        int do_exit;
+
+        /* 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) Setup real-time parameters. 
+         *    In this example, we create a sporadic task that does not specify a 
+         *    target partition (and thus is intended to run under global scheduling). 
+         *    If this were to execute under a partitioned scheduler, it would be assigned
+         *    to the first partition (since partitioning is performed offline).
+         */
+        init_litmus();
+        sporadic_global(EXEC_COST, PERIOD);
+
+        /* To specify a partition, use sporadic_partitioned().
+         * Example:
+         *
+         *              sporadic_partitioned(EXEC_COST, PERIOD, CPU);
+         *
+         * where CPU ranges from 0 to "Number of CPUs" - 1.
+         */
+
+
+
+        /*****
+         * 4) Transition to real-time mode.
+         */
+        task_mode(LITMUS_RT_TASK);
+
+        /* The task is now executing as a real-time task if the call didn't fail. 
+         */
+
+
+
+        /*****
+         * 5) Invoke real-time jobs.
+         */
+        do {
+                /* Wait until the next job is released. */
+                sleep_next_period();
+                /* Invoke job. */
+                do_exit = job();                
+        } while (!do_exit);
+
+
+        
+        /*****
+         * 6) Transition to background mode.
+         */
+        task_mode(BACKGROUND_TASK);
+
+
+
+        /***** 
+         * 7) Clean up and exit.
+         */
+        return 0;
+}
+
+
+int job(void) 
+{
+        /* Do real-time calculation. */
+
+        /* Don't exit. */
+        return 0;
+}