More progress.

7 files changed, 98 insertions, 46 deletions

diff --git a/bin/.rwrnlp.c.swp b/bin/.rwrnlp.c.swp
deleted file mode 100644
index 207edbb..0000000
--- a/bin/.rwrnlp.c.swp
+++ /dev/null
diff --git a/bin/rwrnlp.c b/bin/rwrnlp.c
index 157fcf4..c3221d8 100644
--- a/bin/rwrnlp.c
+++ b/bin/rwrnlp.c
@@ -228,6 +228,8 @@ void* rt_thread(void *tcontext)
 
         CALL( set_rt_task_param(gettid(), &param) );
 
+    fprintf(stderr, "Thread %d on processor %d\n", gettid(), ctx->processor);
+
         /*****
          * 2) Transition to real-time mode.
          */
@@ -272,7 +274,7 @@ static int loop_for(double exec_time, double emergency_exit)
                 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, "!!! rtspin/%d emergency exit!\n", getpid());
+                        fprintf(stderr, "!!! rtspin/%d emergency exit!\n", gettid());
                         fprintf(stderr, "Something is seriously wrong! Do not ignore this.\n");
                         break;
                 }
@@ -295,21 +297,21 @@ static int job(struct thread_context *ctx, double program_end)
                 loop_for(ncs_length, program_end + 1);
 
         if(ctx->type == read_req){
-            printf("%d read locking...\n", getpid());
+            printf("%d:%d read locking...\n", __sync_fetch_and_add(&events,1), gettid());
             rwrnlp_read_lock(&rw_lock, ctx->resources, ctx->processor);
-            printf("%d read CS...\n", getpid());
-            loop_for(ctx->cs_length, program_end + 1);
-            printf("%d read unlocking...\n", getpid());
+            printf("%d:%d read CS...\n", __sync_fetch_and_add(&events, 1), gettid());
+            loop_for(ctx->cs_length*S_PER_MS, program_end + 1);
+            printf("%d:%d read unlocking...\n", __sync_fetch_and_add(&events,1), gettid());
             rwrnlp_read_unlock(&rw_lock, ctx->processor);
-            printf("%d ncs...\n", getpid());
+            printf("%d:%d ncs...\n", __sync_fetch_and_add(&events,1), gettid());
         }else{
-            printf("%d write locking...\n", getpid());
+            printf("%d:%d write locking %lu\n", __sync_fetch_and_add(&events,1), gettid(), ctx->resources);
             rwrnlp_write_lock(&rw_lock, ctx->resources, ctx->processor);
-            printf("%d write CS...\n", getpid());
-            loop_for(ctx->cs_length, program_end + 1);
-            printf("%d write unlocking...\n", getpid());
+            printf("%d:%d write CS...\n", __sync_fetch_and_add(&events,1), gettid());
+            loop_for(ctx->cs_length*S_PER_MS, program_end + 1);
+            printf("%d:%d write unlocking...\n", __sync_fetch_and_add(&events,1), gettid());
             rwrnlp_write_unlock(&rw_lock, ctx->processor);
-            printf("%d ncs...\n", getpid());
+            printf("%d:%d ncs...\n", __sync_fetch_and_add(&events,1), gettid());
         }
 
 
diff --git a/include/spinlocks.h b/include/spinlocks.h
index 9871685..d83a0d8 100644
--- a/include/spinlocks.h
+++ b/include/spinlocks.h
@@ -4,9 +4,11 @@
 #define NR_CPUS 4
 #define NR_RESOURCES sizeof(resource_mask_t)*8
 
+extern int events;
+
 typedef enum {read_req, write_req} request_type;
 typedef enum {waiting, acquired, entitled} request_status;
-typedef long resource_mask_t;
+typedef unsigned long resource_mask_t;
 
 typedef struct request_struct {
     resource_mask_t resources;
@@ -26,7 +28,7 @@ typedef struct rwrnlp_struct {
 
     int enter[NR_CPUS];
     int leave[NR_CPUS];
-    request* requests[NR_CPUS];
+    request requests[NR_CPUS];
 
     request* wqueue[NR_RESOURCES][NR_CPUS];
     unsigned int whead[NR_RESOURCES];
diff --git a/multi.csv b/multi.csv
new file mode 100644
index 0000000..acf5a3c
--- /dev/null
+++ b/multi.csv
@@ -0,0 +1,6 @@
+0 10.0 17.0 3.0 0 1
+1 12.0 19.0 8.0 0 3
+3 17.0 23.0 8.0 1 4
+2 10.0 17.0 3.0 0 5
+1 12.0 29.0 8.0 1 1
+3 17.0 21.0 8.0 1 4
diff --git a/simple.csv b/simple.csv
new file mode 100644
index 0000000..6a166b1
--- /dev/null
+++ b/simple.csv
@@ -0,0 +1,4 @@
+0 10.0 17.0 3.0 0 3
+1 12.0 19.0 8.0 1 2
+2 17.0 23.0 8.0 1 1
+3 17.0 23.0 8.0 1 3
diff --git a/src/spinlocks.c b/src/spinlocks.c
index 16e1f06..9847aac 100644
--- a/src/spinlocks.c
+++ b/src/spinlocks.c
@@ -2,10 +2,13 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "litmus.h"
 #include "spinlocks.h"
 
 #define NR_RESOURCES sizeof(resource_mask_t)*8
 
+int events;
+
 void spin_init(spinlock_t *lock){
     lock->serving = 0;
     lock->next_ticket = 0;
@@ -13,6 +16,8 @@ void spin_init(spinlock_t *lock){
 
 void spin_lock(spinlock_t *lock){
     int ticket = __sync_fetch_and_add(&(lock->next_ticket), 1);
+    printf("%d:%d waiting for ticket %d serving %d\n",
+            __sync_fetch_and_add(&events,1), gettid(), ticket, lock->serving);
     while(lock->serving != ticket);
 }
 
@@ -23,6 +28,7 @@ void spin_unlock(spinlock_t *lock){
 void rwrnlp_init(rwrnlp *lock)
 {
     int i;
+    events = 0;
     lock->wlocked     = 0;
     lock->wentitled   = 0;
     lock->unavailable = 0;
@@ -43,43 +49,57 @@ void rwrnlp_init(rwrnlp *lock)
 
 void rwrnlp_read_lock(rwrnlp *lock, resource_mask_t resources, int processor)
 {
-    request req;
-    req.resources = resources;
-    req.type = read_req;
-    req.status = waiting;
+    request *req;
+    
+    enter_np();
+
+    req = &lock->requests[processor];
+    req->resources = resources;
+    req->type      = read_req;
+    req->status    = waiting;
     lock->enter[processor]+=1;
-    lock->requests[processor] = &req;
+
+    printf("%d:%d rwrnlp_read_lock %lu\n",__sync_fetch_and_add(&events,1), gettid(), req->resources);
 
     spin_lock(lock->state);
-    if((req.resources & lock->unavailable) == 0){
-        req.status = acquired;
+    if((req->resources & lock->unavailable) == 0){
+        req->status = acquired;
     }
     spin_unlock(lock->state);
 
-    if(req.status != acquired){
-        while((req.resources & lock->wentitled) != 0);
-        req.status = entitled;
-        while((req.resources & lock->wlocked) != 0);
+    if(req->status != acquired){
+        printf("%d:%d waiting to become entitled\n",__sync_fetch_and_add(&events,1), gettid());
+        while((req->resources & lock->wentitled) != 0);
+        req->status = entitled;
+        printf("%d:%d waiting to acquire\n", __sync_fetch_and_add(&events,1), gettid());
+        while((req->resources & lock->wlocked) != 0);
     }
+    
+    printf("%d:%d reader satisfied\n", __sync_fetch_and_add(&events,1), gettid());
 }
 
 void rwrnlp_write_lock(rwrnlp *lock, resource_mask_t resources, int processor)
 {
     int r,i,start,end;
-    request req;
-    request* contender;
+    request *req, *contender;
     resource_mask_t tmp = resources;
-    req.resources = resources;
-    req.type = read_req;
-    req.status = waiting;
+
+    enter_np();
+
+    printf("%d:%d rwrnlp_write_lock\n", __sync_fetch_and_add(&events,1), gettid());
+
+    req = &lock->requests[processor];
+
+    req->resources = resources;
+    req->type = write_req;
+    req->status = waiting;
     lock->enter[processor]+=1;
-    lock->requests[processor] = &req;
 
     spin_lock(lock->enqueue);
     r = ffsl(tmp);
     while(r != 0){
         r = r-1; // ffsl gives 1-indexed, since 0 is the return value for 0.
-        lock->wqueue[r][lock->wtail[r]] = &req;
+        lock->wqueue[r][lock->wtail[r]] = req;
         lock->wtail[r] = (lock->wtail[r] + 1) % NR_CPUS;
         tmp &= ~(1<<r);
         r = ffsl(tmp);
@@ -87,53 +107,74 @@ void rwrnlp_write_lock(rwrnlp *lock, resource_mask_t resources, int processor)
     spin_unlock(lock->enqueue);
 
     tmp = resources;
+    r = ffsl(tmp);
     while(r != 0){
         r = r-1;
-        while(lock->wqueue[r][lock->whead[r]] != &req);
+        printf("%d:%d write waiting to become head of %d\n", __sync_fetch_and_add(&events,1), gettid(), r);
+        while(lock->wqueue[r][lock->whead[r]] != req);
         tmp &= ~(1<<r);
         r = ffsl(tmp);
     }
 
     spin_lock(lock->state);
-    lock->unavailable |= req.resources;
-    req.status = entitled;
+    lock->unavailable |= req->resources;
+    req->status = entitled;
     spin_unlock(lock->state);
     
     for(i = 0; i < NR_CPUS; i++){
         if(i != processor){
             start = lock->enter[i];
-            contender = lock->requests[i];
+            contender = &lock->requests[i];
             end = lock->leave[i];
             if(start <= end ||
                contender->type == write_req ||
                contender->status == waiting ||
-               (contender->resources & req.resources) == 0)
+               (contender->resources & req->resources) == 0)
                 continue;
 
+            printf("%d:%d waiting for reader on processor %d\n", __sync_fetch_and_add(&events,1), gettid(), i);
             while(lock->leave[i] < start);
         }
     }
 
     spin_lock(lock->state);
-    lock->wentitled &= ~req.resources;
-    lock->wlocked |= req.resources;
+    lock->wentitled &= ~(req->resources);
+    lock->wlocked |= req->resources;
     spin_unlock(lock->state);
+
+    printf("%d:%d writer satisfied\n", __sync_fetch_and_add(&events,1), gettid());
 }
 
 void rwrnlp_read_unlock(rwrnlp *lock, int processor)
 {
     lock->leave[processor] += 1;
-    lock->requests[processor] = NULL;
+    printf("%d:%d rwrnlp_read_unlock\n", __sync_fetch_and_add(&events,1), gettid());
+    exit_np();
 }
 
 void rwrnlp_write_unlock(rwrnlp *lock, int processor)
 {
-    request *req = lock->requests[processor];
+    int r;
+    request *req = &lock->requests[processor];
+    resource_mask_t tmp = req->resources;
+
+    printf("%d:%d rwrnlp_write_unlock\n", __sync_fetch_and_add(&events,1), gettid());
+
     lock->leave[processor] += 1;
-    lock->requests[processor] = NULL;
 
     spin_lock(lock->state);
-    lock->wlocked &= ~req->resources;
-    lock->unavailable &= ~req->resources;
+    r = ffsl(tmp);
+    while(r != 0){
+        r = r-1; // ffsl gives 1-indexed, since 0 is the return value for 0.
+        lock->whead[r] = (lock->whead[r] + 1) % NR_CPUS;
+        tmp &= ~(1<<r);
+        r = ffsl(tmp);
+    }
+    lock->wlocked &= ~(req->resources);
+    lock->unavailable &= ~(req->resources);
     spin_unlock(lock->state);
+    
+    printf("%d:%d write unlocked %lu\n", __sync_fetch_and_add(&events,1), gettid(), req->resources);
+    printf("unavailable %lu\nwentitled %lu\nwlocked %lu\n", lock->unavailable, lock->wentitled, lock->wlocked);
+    exit_np();
 }
diff --git a/test.csv b/test.csv
deleted file mode 100644
index 37bf459..0000000
--- a/test.csv
+++ /dev/null
@@ -1,3 +0,0 @@
-0 10.0 100.0 1.0 0 0110
-1 10.0 100.0 1.0 0 0110
-3 10.0 100.0 1.0 1 0010