From f7a9e6111362b6a685288537f8b6599429e736e5 Mon Sep 17 00:00:00 2001
From: bdemsky <bdemsky>
Date: Wed, 13 Oct 2010 03:33:47 +0000
Subject: [PATCH] changes

---
 Robust/src/Runtime/oooJava/Queue_RCR.c   | 55 ++++++++++--------------
 Robust/src/Runtime/oooJava/Queue_RCR.h   |  2 -
 Robust/src/Runtime/oooJava/rcr_runtime.c |  8 ++++
 Robust/src/Runtime/oooJava/rcr_runtime.h |  8 ++++
 Robust/src/Runtime/oooJava/trqueue.c     | 42 ++++++++++++++++++
 Robust/src/Runtime/oooJava/trqueue.h     | 18 ++++++++
 6 files changed, 99 insertions(+), 34 deletions(-)
 create mode 100644 Robust/src/Runtime/oooJava/rcr_runtime.c
 create mode 100644 Robust/src/Runtime/oooJava/rcr_runtime.h
 create mode 100644 Robust/src/Runtime/oooJava/trqueue.c
 create mode 100644 Robust/src/Runtime/oooJava/trqueue.h

diff --git a/Robust/src/Runtime/oooJava/Queue_RCR.c b/Robust/src/Runtime/oooJava/Queue_RCR.c
index c7400f6d..f9449b0a 100644
--- a/Robust/src/Runtime/oooJava/Queue_RCR.c
+++ b/Robust/src/Runtime/oooJava/Queue_RCR.c
@@ -4,51 +4,42 @@
 
 __thread struct RCRQueue myRCRQueue;
 
-void resetRCRQueue()
-{
+void resetRCRQueue() {
   myRCRQueue.head = 0;
   myRCRQueue.tail = 0;
-  myRCRQueue.size = 0;
 }
 
-
 //0 would mean sucess
 //1 would mean fail
 //since if we reach SIZE, we will stop operation, it doesn't matter
 //that we overwrite the element in the queue
-int enqueueRCRQueue(void * ptr)
-{
-  myRCRQueue.elements[myRCRQueue.head++] =  ptr;
-
-  if(myRCRQueue.head & SIZE)
-    myRCRQueue.head = 0;
-
-  return myRCRQueue.size++ == SIZE;
+int enqueueRCRQueue(void * ptr) {
+  unsigned int head=myRCRQueue.head+1;
+  if (head&SIZE)
+    head=0;
+
+  if (head==myRCRQueue.tail)
+    return 1;
+  
+  myRCRQueue.elements[head] = ptr;
+  myRCRQueue.head=head;
+  return 0;
 }
 
-void * dequeueRCRQueue()
-{  
-  if(myRCRQueue.size) {
-    void * ptr = myRCRQueue.elements[myRCRQueue.tail++];
-
-    if(myRCRQueue.tail & SIZE)
-      myRCRQueue.tail =  0;
-    
-
-    myRCRQueue.size--;
-    return ptr;
-  } else
+void * dequeueRCRQueue() {
+  if(myRCRQueue.head==myRCRQueue.tail)
     return NULL;
+  unsigned int tail=myRCRQueue.tail;
+  void * ptr = myRCRQueue.elements[tail];
+  tail++;
+  if(tail & SIZE)
+    tail =  0;
+  myRXRQueue.tail=tail;
+  return ptr;
 }
 
-int isEmptyRCRQueue()
-{
-  return !myRCRQueue.size;
-}
-
-int getSizeRCRQueue()
-{
-  return myRCRQueue.size;
+int isEmptyRCRQueue() {
+  return myRCRQueue.head=myRCRQueue.tail;
 }
 
 
diff --git a/Robust/src/Runtime/oooJava/Queue_RCR.h b/Robust/src/Runtime/oooJava/Queue_RCR.h
index 5f1f059e..a500cce8 100644
--- a/Robust/src/Runtime/oooJava/Queue_RCR.h
+++ b/Robust/src/Runtime/oooJava/Queue_RCR.h
@@ -9,7 +9,6 @@ struct RCRQueue {
   void * elements[SIZE];
   unsigned int head;
   unsigned int tail;
-  unsigned int size;
 };
 
 int enqueueRCRQueue(void * ptr);
@@ -17,5 +16,4 @@ void * dequeueRCRQueue();
 void resetRCRQueue();
 int isEmptyRCRQueue();
 int getSizeRCRQueue();
-
 #endif
diff --git a/Robust/src/Runtime/oooJava/rcr_runtime.c b/Robust/src/Runtime/oooJava/rcr_runtime.c
new file mode 100644
index 00000000..f0382d66
--- /dev/null
+++ b/Robust/src/Runtime/oooJava/rcr_runtime.c
@@ -0,0 +1,8 @@
+#include "rcr_runtime.h"
+
+void workerTR(void *x) {
+  struct trQueue * queue=(struct trQueue *)x;
+  while(true) {
+    
+  }
+}
diff --git a/Robust/src/Runtime/oooJava/rcr_runtime.h b/Robust/src/Runtime/oooJava/rcr_runtime.h
new file mode 100644
index 00000000..bcc90a01
--- /dev/null
+++ b/Robust/src/Runtime/oooJava/rcr_runtime.h
@@ -0,0 +1,8 @@
+#ifndef RCR_RUNTIME_H
+#define RCR_RUNTIME_H
+
+extern __thread struct trqueue * TRqueue;
+
+void workerTR(void *);
+
+#endif
diff --git a/Robust/src/Runtime/oooJava/trqueue.c b/Robust/src/Runtime/oooJava/trqueue.c
new file mode 100644
index 00000000..d58a33f1
--- /dev/null
+++ b/Robust/src/Runtime/oooJava/trqueue.c
@@ -0,0 +1,42 @@
+#include "trqueue.h"
+#include "stdlib.h"
+#include "stdio.h"
+
+//0 would mean sucess
+//1 would mean fail
+//since if we reach SIZE, we will stop operation, it doesn't matter
+//that we overwrite the element in the queue
+void enqueueTR(trQueue *q, void * ptr) {
+  unsigned int head=q->head+1;
+  if (head&TRSIZE)
+    head=0;
+
+  while (head==q->tail)
+    sched_yield();
+  
+  q->elements[head] = ptr;
+  BARRIER();
+  q->head=head;
+  return 0;
+}
+
+void * dequeueTR(trQueue *q) {
+  unsigned int tail=q->tail;
+  if(q->head==tail)
+    return NULL;
+
+  void * ptr = q->elements[tail];
+  tail++;
+  if(tail & TRSIZE)
+    tail =  0;
+  q->tail=tail;
+  return ptr;
+}
+
+struct trQueue * allocTR() {
+  struct trQueue *ptr=malloc(sizeof(struct trQueue));
+  ptr->head=0;
+  ptr->tail=0;
+  return ptr;
+}
+
diff --git a/Robust/src/Runtime/oooJava/trqueue.h b/Robust/src/Runtime/oooJava/trqueue.h
new file mode 100644
index 00000000..c1f83c2e
--- /dev/null
+++ b/Robust/src/Runtime/oooJava/trqueue.h
@@ -0,0 +1,18 @@
+#ifndef TRQUEUE_H_
+#define TRQUEUE_H_
+
+//NOTE: SIZE MUST BE A POWER OF TWO;
+//SIZE is used as mask to check overflow
+#define SIZE 16384
+
+struct trQueue {
+  void * elements[SIZE];
+  volatile unsigned int head;
+  char buffer[60];//buffer us to the next cache line
+  volatile unsigned int tail;
+};
+
+void enqueueTR(struct trQueue *, void * ptr);
+void * dequeueTR(struct trQueue *);
+struct trQueue * allocTR();
+#endif
-- 
2.34.1