1 files changed, 24 insertions, 27 deletions

diff --git a/rts/WSDeque.h b/rts/WSDeque.h
index 2936c281fe..0104884bdb 100644
--- a/rts/WSDeque.h
+++ b/rts/WSDeque.h
@@ -11,24 +11,19 @@
 typedef struct WSDeque_ {
     // Size of elements array. Used for modulo calculation: we round up
     // to powers of 2 and use the dyadic log (modulo == bitwise &)
-    StgWord size;
+    StgInt size;
     StgWord moduloSize; /* bitmask for modulo */
 
     // top, index where multiple readers steal() (protected by a cas)
-    volatile StgWord top;
+    StgInt top;
 
     // bottom, index of next free place where one writer can push
     // elements. This happens unsynchronised.
-    volatile StgWord bottom;
+    StgInt bottom;
 
     // both top and bottom are continuously incremented, and used as
     // an index modulo the current array size.
 
-    // lower bound on the current top value. This is an internal
-    // optimisation to avoid unnecessarily accessing the top field
-    // inside pushBottom
-    volatile StgWord topBound;
-
     // The elements array
     void ** elements;
 
@@ -39,18 +34,17 @@ typedef struct WSDeque_ {
 } WSDeque;
 
 /* INVARIANTS, in this order: reasonable size,
-   topBound consistent, space pointer, space accessible to us.
+   space pointer, space accessible to us.
 
    NB. This is safe to use only (a) on a spark pool owned by the
    current thread, or (b) when there's only one thread running, or no
    stealing going on (e.g. during GC).
 */
-#define ASSERT_WSDEQUE_INVARIANTS(p)         \
-  ASSERT((p)->size > 0);                        \
-  ASSERT((p)->topBound <= (p)->top);            \
-  ASSERT((p)->elements != NULL);                \
-  ASSERT(*((p)->elements) || 1);                \
-  ASSERT(*((p)->elements - 1  + ((p)->size)) || 1);
+#define ASSERT_WSDEQUE_INVARIANTS(p)                                  \
+    ASSERT((p)->size > 0);                                            \
+    ASSERT(RELAXED_LOAD(&(p)->elements) != NULL);                     \
+    ASSERT(RELAXED_LOAD(&(p)->elements[0]) || 1);                     \
+    ASSERT(RELAXED_LOAD(&(p)->elements[(p)->size - 1]) || 1);
 
 // No: it is possible that top > bottom when using pop()
 //  ASSERT((p)->bottom >= (p)->top);
@@ -69,15 +63,15 @@ typedef struct WSDeque_ {
 WSDeque * newWSDeque  (uint32_t size);
 void      freeWSDeque (WSDeque *q);
 
-// Take an element from the "write" end of the pool.  Can be called
+// (owner-only) Take an element from the "write" end of the pool.  Can be called
 // by the pool owner only.
 void* popWSDeque (WSDeque *q);
 
-// Push onto the "write" end of the pool.  Return true if the push
+// (owner-only) Push onto the "write" end of the pool.  Return true if the push
 // succeeded, or false if the deque is full.
 bool pushWSDeque (WSDeque *q, void *elem);
 
-// Removes all elements from the deque
+// (owner-only) Removes all elements from the deque.
 EXTERN_INLINE void discardElements (WSDeque *q);
 
 // Removes an element of the deque from the "read" end, or returns
@@ -90,23 +84,27 @@ void * stealWSDeque_ (WSDeque *q);
 void * stealWSDeque (WSDeque *q);
 
 // "guesses" whether a deque is empty. Can return false negatives in
-//  presence of concurrent steal() calls, and false positives in
-//  presence of a concurrent pushBottom().
+// presence of concurrent steal() calls, and false positives in
+// presence of a concurrent pushBottom().
 EXTERN_INLINE bool looksEmptyWSDeque (WSDeque* q);
 
-EXTERN_INLINE long dequeElements   (WSDeque *q);
+// "guesses" how many elements are present on the deque. Like
+// looksEmptyWSDeque, this may suggest that the deque is empty when it's not
+// and vice-versa.
+EXTERN_INLINE StgInt dequeElements   (WSDeque *q);
 
 /* -----------------------------------------------------------------------------
  * PRIVATE below here
  * -------------------------------------------------------------------------- */
 
-EXTERN_INLINE long
+EXTERN_INLINE StgInt
 dequeElements (WSDeque *q)
 {
-    StgWord t = q->top;
-    StgWord b = q->bottom;
+    StgWord t = ACQUIRE_LOAD(&q->top);
+    StgWord b = ACQUIRE_LOAD(&q->bottom);
     // try to prefer false negatives by reading top first
-    return ((long)b - (long)t);
+    StgInt n = (StgInt)b - (StgInt)t;
+    return n > 0 ? n : 0;
 }
 
 EXTERN_INLINE bool
@@ -118,6 +116,5 @@ looksEmptyWSDeque (WSDeque *q)
 EXTERN_INLINE void
 discardElements (WSDeque *q)
 {
-    q->top = q->bottom;
-//    pool->topBound = pool->top;
+    RELAXED_STORE(&q->top, RELAXED_LOAD(&q->bottom));
 }