Cleaned up testing script for DGLs.

4 files changed, 170 insertions, 3 deletions

diff --git a/Makefile b/Makefile
index 391dc65..7def948 100644
--- a/Makefile
+++ b/Makefile
@@ -71,7 +71,7 @@ AR  := ${CROSS_COMPILE}${AR}
 
 all     = lib ${rt-apps}
 rt-apps = cycles base_task rt_launch rtspin release_ts measure_syscall \
-          base_mt_task runtests
+          base_mt_task runtests dgl_test
 
 .PHONY: all lib clean dump-config TAGS tags cscope help
 
@@ -203,6 +203,8 @@ obj-cycles = cycles.o
 
 obj-base_task = base_task.o
 
+obj-dgl_test = dgl_test.o
+
 obj-base_mt_task = base_mt_task.o
 ldf-base_mt_task = -pthread
 
diff --git a/bin/dgl_test.c b/bin/dgl_test.c
new file mode 100644
index 0000000..22a13ae
--- /dev/null
+++ b/bin/dgl_test.c
@@ -0,0 +1,157 @@
+/* based_task.c -- A basic real-time task skeleton. 
+ *
+ * This (by itself useless) task demos how to setup a 
+ * single-threaded LITMUS^RT real-time task.
+ */
+
+/* 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>
+#include <fcntl.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
+
+/* Catch errors.
+ */
+#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)
+
+
+/* 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;
+    int fd, od_org, od_new;
+    int* resource;
+    int mask;
+
+        /* 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.
+         */
+    
+    CALL(fd = open(".dgl_locks", O_RDONLY | O_CREAT) );
+    resource = (int*)malloc(sizeof(int));
+    *resource = -1;
+
+        /*****
+         * 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).
+         */
+
+        CALL( init_litmus() );
+        //CALL( sporadic_global(EXEC_COST, PERIOD) );
+        CALL( sporadic_partitioned(EXEC_COST, PERIOD, 0) );
+
+        /* 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.
+         */
+        CALL( task_mode(LITMUS_RT_TASK) );
+
+        /* The task is now executing as a real-time task if the call didn't fail. 
+         */
+    
+    CALL(od_org = open_new_dgl_sem(fd, 0) );
+    CALL(od_new = attach_dgl_sem(fd, 1, od_org) );
+
+    mask = (1<<od_org) & (1<<od_new);
+
+
+    //CALL( dynamic_group_lock(0) );
+    dynamic_group_lock(mask);
+
+        /*****
+         * 5) Invoke real-time jobs.
+         */
+        //do {
+        //      /* Wait until the next job is released. */
+        //      sleep_next_period();
+        //      /* Invoke job. */
+        //      do_exit = job();                
+        //} while (!do_exit);
+    
+    //do_exit=0;
+    //do_exit++;
+    //od++;
+
+        
+        /*****
+         * 6) Transition to background mode.
+         */
+        //CALL( task_mode(BACKGROUND_TASK) );
+
+
+
+        /***** 
+         * 7) Clean up, maybe print results and stats, and exit.
+         */
+        return 0;
+}
+
+
+//int job(void) 
+//{
+//      /* Do real-time calculation. */
+//    
+//
+//      /* Don't exit. */
+//      return 0;
+//}
diff --git a/include/litmus.h b/include/litmus.h
index fd9c7e3..e8e07dc 100644
--- a/include/litmus.h
+++ b/include/litmus.h
@@ -145,9 +145,15 @@ static inline int open_fmlp_sem(int fd, int name)
         return od_open(fd, FMLP_SEM, name);
 }
 
-static inline int open_dgl_sem(int fd, int name)
+static inline int open_new_dgl_sem(int fd, int name)
 {
-    return od_open(fd, DGL_SEM, name);
+    int tmp = -1;
+    return od_openx(fd, DGL_SEM, name, &tmp);
+}
+
+static inline int attach_dgl_sem(int fd, int name, int resource)
+{
+    return od_openx(fd, DGL_SEM, name, &resource);
 }
 
 static inline int open_srp_sem(int fd, int name)
diff --git a/src/syscalls.c b/src/syscalls.c
index e82d987..2c38a04 100644
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -7,6 +7,7 @@
 
 /* for syscall() */
 #include <unistd.h>
+#include <stdio.h>
 
 #include "litmus.h"
 
@@ -54,6 +55,7 @@ int litmus_unlock(int od)
 
 int dynamic_group_lock(int mask)
 {
+    printf("Calling dynamic group lock!!!");
     return syscall(__NR_dynamic_group_lock, mask);
 }