#include "Capability.h"
#include "Trace.h"
-BEGIN_RTS_PRIVATE
+#include "BeginPrivate.h"
/* initScheduler(), exitScheduler()
* Called from STG : no
void initScheduler (void);
void exitScheduler (rtsBool wait_foreign);
void freeScheduler (void);
+void markScheduler (evac_fn evac, void *user);
// Place a new thread on the run queue of the current Capability
void scheduleThread (Capability *cap, StgTSO *tso);
StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception);
/* findRetryFrameHelper */
-StgWord findRetryFrameHelper (StgTSO *tso);
+StgWord findRetryFrameHelper (Capability *cap, StgTSO *tso);
/* Entry point for a new worker */
void scheduleWorker (Capability *cap, Task *task);
extern StgTSO *sleeping_queue;
#endif
-/* Set to rtsTrue if there are threads on the blackhole_queue, and
- * it is possible that one or more of them may be available to run.
- * This flag is set to rtsFalse after we've checked the queue, and
- * set to rtsTrue just before we run some Haskell code. It is used
- * to decide whether we should yield the Capability or not.
- * Locks required : none (see scheduleCheckBlackHoles()).
- */
-extern rtsBool blackholes_need_checking;
-
extern rtsBool heap_overflow;
#if defined(THREADED_RTS)
ASSERT(tso->_link == END_TSO_QUEUE);
if (cap->run_queue_hd == END_TSO_QUEUE) {
cap->run_queue_hd = tso;
+ tso->block_info.prev = END_TSO_QUEUE;
} else {
setTSOLink(cap, cap->run_queue_tl, tso);
+ setTSOPrev(cap, tso, cap->run_queue_tl);
}
cap->run_queue_tl = tso;
traceEventThreadRunnable (cap, tso);
/* Push a thread on the beginning of the run queue.
* ASSUMES: cap->running_task is the current task.
*/
-INLINE_HEADER void
+EXTERN_INLINE void
+pushOnRunQueue (Capability *cap, StgTSO *tso);
+
+EXTERN_INLINE void
pushOnRunQueue (Capability *cap, StgTSO *tso)
{
setTSOLink(cap, tso, cap->run_queue_hd);
+ tso->block_info.prev = END_TSO_QUEUE;
+ if (cap->run_queue_hd != END_TSO_QUEUE) {
+ setTSOPrev(cap, cap->run_queue_hd, tso);
+ }
cap->run_queue_hd = tso;
if (cap->run_queue_tl == END_TSO_QUEUE) {
cap->run_queue_tl = tso;
StgTSO *t = cap->run_queue_hd;
ASSERT(t != END_TSO_QUEUE);
cap->run_queue_hd = t->_link;
+ if (t->_link != END_TSO_QUEUE) {
+ t->_link->block_info.prev = END_TSO_QUEUE;
+ }
t->_link = END_TSO_QUEUE; // no write barrier req'd
if (cap->run_queue_hd == END_TSO_QUEUE) {
cap->run_queue_tl = END_TSO_QUEUE;
return t;
}
+extern void removeFromRunQueue (Capability *cap, StgTSO *tso);
+
/* Add a thread to the end of the blocked queue.
*/
#if !defined(THREADED_RTS)
#endif /* !IN_STG_CODE */
-END_RTS_PRIVATE
+#include "EndPrivate.h"
#endif /* SCHEDULE_H */