DGL testing.wip-nested-locking

3 files changed, 45 insertions, 169 deletions

diff --git a/bin/dgl_test.c b/bin/dgl_test.c
deleted file mode 100644
index 22a13ae..0000000
--- a/bin/dgl_test.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/* 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/bin/dglspin.c b/bin/dglspin.c
index 805fd85..5999662 100644
--- a/bin/dglspin.c
+++ b/bin/dglspin.c
@@ -6,6 +6,7 @@
 #include <time.h>
 #include <assert.h>
 #include <fcntl.h>
+#include <strings.h>
 
 
 #include "litmus.h"
@@ -110,16 +111,31 @@ static int loop_once(void)
 static int loop_for(double exec_time, double emergency_exit, int mask)
 {
         double last_loop = 0, loop_start;
-        int tmp = 0;
+        int tmp = 0, locks = 1, locked=0, phase=0;
 
         double start = cputime();
         double now = cputime();
 
         while (now + last_loop < start + exec_time) {
-                loop_start = now;
-        dynamic_group_lock(mask);
-                tmp += loop_once();
-        dynamic_group_unlock(mask);
+
+        loop_start = now;
+
+        if(now + last_loop > start + phase * (exec_time / (2*locks))){
+            if(locked){
+                locked = 0;
+                printf("unlock\n");
+                dynamic_group_unlock(mask);
+            }
+            else{
+                dynamic_group_lock(mask);
+                printf("lock\n");
+                locked = 1;
+            }
+            phase += 1;
+        }
+
+        tmp += loop_once();
+
                 now = cputime();
                 last_loop = now - loop_start;
                 if (emergency_exit && wctime() > emergency_exit) {
@@ -131,6 +147,10 @@ static int loop_for(double exec_time, double emergency_exit, int mask)
                 }
         }
 
+    if(locked){
+        dynamic_group_unlock(mask);
+    }
+
         return tmp;
 }
 
@@ -164,7 +184,8 @@ static int job(double exec_time, double program_end, int mask)
         }
 }
 
-#define OPTSTR "p:c:wlveo:f:s:q:"
+#define OPTSTR "p:c:wlveo:f:s:q:r:"
+#define MAX_RESOURCES 10
 
 int main(int argc, char** argv)
 {
@@ -187,7 +208,10 @@ int main(int argc, char** argv)
         task_class_t class = RT_CLASS_HARD;
         int cur_job, num_jobs;
 
-    int fd, od_org, od_new, mask;
+    int fd, i;
+    int mask = 0;
+    char* resources;
+    int ods[MAX_RESOURCES];
 
         progname = argv[0];
 
@@ -225,6 +249,9 @@ int main(int argc, char** argv)
                 case 's':
                         scale = atof(optarg);
                         break;
+        case 'r':
+            resources = optarg;
+            break;
                 case ':':
                         usage("Argument missing.");
                         break;
@@ -306,9 +333,16 @@ int main(int argc, char** argv)
                         bail_out("wait_for_ts_release()");
         }
 
-    od_org = open_new_dgl_sem(fd, 0);
-    od_new = attach_dgl_sem(fd, 1, od_org);
-    mask = (1<<od_org) & (1<<od_new);
+    for(i = 0; i < MAX_RESOURCES; i++){
+        if(i==0)
+            ods[i] = open_new_dgl_sem(fd, i);
+        else
+            ods[i] = attach_dgl_sem(fd, i, ods[0]);
+
+        if(resources[i]=='1'){
+            mask |= (1 << ods[i]);
+        }
+    }
 
         start = wctime();
 
@@ -320,7 +354,7 @@ int main(int argc, char** argv)
                                         start + duration, mask);
                 }
         } else {
-                /* conver to seconds and scale */
+                /* convert to seconds and scale */
                 while (job(wcet_ms * 0.001 * scale, start + duration, mask));
         }
 
diff --git a/src/syscalls.c b/src/syscalls.c
index 2c38a04..c9f4d2b 100644
--- a/src/syscalls.c
+++ b/src/syscalls.c
@@ -55,7 +55,6 @@ int litmus_unlock(int od)
 
 int dynamic_group_lock(int mask)
 {
-    printf("Calling dynamic group lock!!!");
     return syscall(__NR_dynamic_group_lock, mask);
 }