EventLog: Factor out ensureRoomFor*Event
[ghc.git] / rts / Sparks.h
index 9696889..98ee3c8 100644 (file)
 /* -----------------------------------------------------------------------------
  *
- * (c) The GHC Team, 2000-2006
+ * (c) The GHC Team, 2000-2009
  *
- * Sparking support for GRAN, PAR and THREADED_RTS versions of the RTS.
+ * Sparking support for PAR and THREADED_RTS versions of the RTS.
  * 
  * ---------------------------------------------------------------------------*/
 
 #ifndef SPARKS_H
 #define SPARKS_H
 
-#if defined(PARALLEL_HASKELL)
-#error Sparks.c using new internal structure, needs major overhaul!
-#endif
+#include "WSDeque.h"
+
+#include "BeginPrivate.h"
 
 /* typedef for SparkPool in RtsTypes.h */
 
+/* Stats on spark creation/conversion */
+typedef struct {
+    StgWord created;
+    StgWord dud;
+    StgWord overflowed;
+    StgWord converted;
+    StgWord gcd;
+    StgWord fizzled;
+} SparkCounters;
+
 #if defined(THREADED_RTS)
 
-/* Spark pools: used to store pending sparks 
- *  (THREADED_RTS & PARALLEL_HASKELL only)
- * Implementation uses a DeQue to enable concurrent read accesses at
- * the top end.
- */
-typedef struct  SparkPool_ {
-  /* Size of elements array. Used for modulo calculation: we round up
-     to powers of 2 and use the dyadic log (modulo == bitwise &) */
-  StgWord size; 
-  StgWord moduloSize; /* bitmask for modulo */
-
-  /* top, index where multiple readers steal() (protected by a cas) */
-  volatile StgWord top;
-
-  /* bottom, index of next free place where one writer can push
-     elements. This happens unsynchronised. */
-  volatile StgWord bottom;
-  /* both position indices 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 */
-  StgClosurePtr* elements;
-  /*  Please note: the dataspace cannot follow the admin fields
-      immediately, as it should be possible to enlarge it without
-      disposing the old one automatically (as realloc would)! */
-
-} SparkPool;
-
-
-/* INVARIANTS, in this order: bottom/top consistent, reasonable size,
-   topBound consistent, space pointer, space accessible to us */
-#define ASSERT_SPARK_POOL_INVARIANTS(p)         \
-  ASSERT((p)->bottom >= (p)->top);              \
-  ASSERT((p)->size > 0);                        \
-  ASSERT((p)->size > (p)->bottom - (p)->top);  \
-  ASSERT((p)->topBound <= (p)->top);            \
-  ASSERT((p)->elements != NULL);                \
-  ASSERT(*((p)->elements) || 1);                \
-  ASSERT(*((p)->elements - 1  + ((p)->size)) || 1);
+typedef WSDeque SparkPool;
 
 // Initialisation
-void initSparkPools (void);
+SparkPool *allocSparkPool (void);
 
 // Take a spark from the "write" end of the pool.  Can be called
 // by the pool owner only.
-StgClosure* reclaimSpark(SparkPool *pool);
+INLINE_HEADER StgClosure* reclaimSpark(SparkPool *pool);
 
 // Returns True if the spark pool is empty (can give a false positive
 // if the pool is almost empty).
-rtsBool looksEmpty(SparkPool* deque);
+INLINE_HEADER rtsBool looksEmpty(SparkPool* deque);
+
+INLINE_HEADER StgClosure * tryStealSpark (SparkPool *pool);
+INLINE_HEADER rtsBool      fizzledSpark  (StgClosure *);
 
-StgClosure * tryStealSpark     (Capability *cap);
 void         freeSparkPool     (SparkPool *pool);
 void         createSparkThread (Capability *cap);
 void         traverseSparkQueue(evac_fn evac, void *user, Capability *cap);
-void         pruneSparkQueue   (evac_fn evac, void *user, Capability *cap);
+void         pruneSparkQueue   (Capability *cap);
 
 INLINE_HEADER void discardSparks  (SparkPool *pool);
-INLINE_HEADER nat  sparkPoolSize  (SparkPool *pool);
-#endif
+INLINE_HEADER long sparkPoolSize  (SparkPool *pool);
 
 /* -----------------------------------------------------------------------------
  * PRIVATE below here
  * -------------------------------------------------------------------------- */
 
-#if defined(PARALLEL_HASKELL) || defined(THREADED_RTS)
+INLINE_HEADER StgClosure* reclaimSpark(SparkPool *pool)
+{
+    return popWSDeque(pool);
+}
 
-INLINE_HEADER rtsBool  
-emptySparkPool (SparkPool *pool) 
-{ return looksEmpty(pool); }
+INLINE_HEADER rtsBool looksEmpty(SparkPool* deque)
+{
+    return looksEmptyWSDeque(deque);
+}
 
-INLINE_HEADER nat
-sparkPoolSize (SparkPool *pool) 
-{ return (pool->bottom - pool->top); }
+INLINE_HEADER long sparkPoolSize (SparkPool *pool) 
+{ 
+    return dequeElements(pool);
+}
 
-INLINE_HEADER void
-discardSparks (SparkPool *pool)
+INLINE_HEADER void discardSparks (SparkPool *pool)
 {
-    pool->top = pool->topBound = pool->bottom = 0;
+    discardElements(pool);
 }
 
-#endif
+/* ----------------------------------------------------------------------------
+ * 
+ * tryStealSpark: try to steal a spark from a Capability.
+ *
+ * Returns either:
+ *  (a) a useful spark;
+ *  (b) a fizzled spark (use fizzledSpark to check);
+ *  (c) or NULL if the pool was empty, and can occasionally return NULL
+ *      if there was a race with another thread stealing from the same
+ *      pool.  In this case, try again later.
+ *
+ -------------------------------------------------------------------------- */
+
+INLINE_HEADER StgClosure * tryStealSpark (SparkPool *pool)
+{
+    return stealWSDeque_(pool);
+    // use the no-loopy version, stealWSDeque_(), since if we get a
+    // spurious NULL here the caller may want to try stealing from
+    // other pools before trying again.
+}
+
+INLINE_HEADER rtsBool fizzledSpark (StgClosure *spark)
+{
+    return (GET_CLOSURE_TAG(spark) != 0 || !closure_SHOULD_SPARK(spark));
+}
+
+#endif // THREADED_RTS
+
+#include "EndPrivate.h"
 
 #endif /* SPARKS_H */