*/
void initScheduler (void);
void exitScheduler (void);
+void freeScheduler (void);
// Place a new thread on the run queue of the current Capability
void scheduleThread (Capability *cap, StgTSO *tso);
* Called from STG : yes
* Locks assumed : we own the Capability.
*/
-StgTSO * unblockOne(Capability *cap, StgTSO *tso);
-
-/* raiseAsync()
- *
- * Raises an exception asynchronously in the specified thread.
- *
- * Called from STG : yes
- * Locks assumed : none
- */
-void raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception);
-
-/* suspendComputation()
- *
- * A variant of raiseAsync(), this strips the stack of the specified
- * thread down to the stop_here point, leaving a current closure on
- * top of the stack at [stop_here - 1].
- */
-void suspendComputation(Capability *cap, StgTSO *tso, StgPtr stop_here);
+StgTSO * unblockOne (Capability *cap, StgTSO *tso);
/* raiseExceptionHelper */
StgWord raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception);
extern Mutex RTS_VAR(sched_mutex);
#endif
-StgBool isThreadBound(StgTSO *tso);
-
SchedulerStatus rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret);
/* Called by shutdown_handler(). */
void print_bqe (StgBlockingQueueElement *bqe);
#endif
-void labelThread(StgPtr tso, char *label);
-
/* -----------------------------------------------------------------------------
* Some convenient macros/inline functions...
*/
* NOTE: tso->link should be END_TSO_QUEUE before calling this macro.
* ASSUMES: cap->running_task is the current task.
*/
-STATIC_INLINE void
+INLINE_HEADER void
appendToRunQueue (Capability *cap, StgTSO *tso)
{
ASSERT(tso->link == END_TSO_QUEUE);
* newly awakened threads, so they get run as soon as possible.
* ASSUMES: cap->running_task is the current task.
*/
-STATIC_INLINE void
+INLINE_HEADER void
pushOnRunQueue (Capability *cap, StgTSO *tso)
{
tso->link = cap->run_queue_hd;
/* Pop the first thread off the runnable queue.
*/
-STATIC_INLINE StgTSO *
+INLINE_HEADER StgTSO *
popRunQueue (Capability *cap)
{
StgTSO *t = cap->run_queue_hd;
/* Add a thread to the end of the blocked queue.
*/
#if !defined(THREADED_RTS)
-STATIC_INLINE void
+INLINE_HEADER void
appendToBlockedQueue(StgTSO *tso)
{
ASSERT(tso->link == END_TSO_QUEUE);
#endif
#if defined(THREADED_RTS)
-STATIC_INLINE void
+INLINE_HEADER void
appendToWakeupQueue (Capability *cap, StgTSO *tso)
{
ASSERT(tso->link == END_TSO_QUEUE);
/* Check whether various thread queues are empty
*/
-STATIC_INLINE rtsBool
+INLINE_HEADER rtsBool
emptyQueue (StgTSO *q)
{
return (q == END_TSO_QUEUE);
}
-STATIC_INLINE rtsBool
+INLINE_HEADER rtsBool
emptyRunQueue(Capability *cap)
{
return emptyQueue(cap->run_queue_hd);
}
#if defined(THREADED_RTS)
-STATIC_INLINE rtsBool
+INLINE_HEADER rtsBool
emptyWakeupQueue(Capability *cap)
{
return emptyQueue(cap->wakeup_queue_hd);
#define EMPTY_SLEEPING_QUEUE() (emptyQueue(sleeping_queue))
#endif
-STATIC_INLINE rtsBool
+INLINE_HEADER rtsBool
emptyThreadQueues(Capability *cap)
{
return emptyRunQueue(cap)
#endif /* !IN_STG_CODE */
-STATIC_INLINE void
+INLINE_HEADER void
dirtyTSO (StgTSO *tso)
{
tso->flags |= TSO_DIRTY;