summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--rts/RaiseAsync.c456
1 files changed, 227 insertions, 229 deletions
diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index a5440e40ad..10585c89fa 100644
--- a/rts/RaiseAsync.c
+++ b/rts/RaiseAsync.c
@@ -34,7 +34,7 @@ static void removeFromQueues(Capability *cap, StgTSO *tso);
static void removeFromMVarBlockedQueue (StgTSO *tso);
static void throwToSendMsg (Capability *cap USED_IF_THREADS,
- Capability *target_cap USED_IF_THREADS,
+ Capability *target_cap USED_IF_THREADS,
MessageThrowTo *msg USED_IF_THREADS);
/* -----------------------------------------------------------------------------
@@ -42,7 +42,7 @@ static void throwToSendMsg (Capability *cap USED_IF_THREADS,
This version of throwTo is safe to use if and only if one of the
following holds:
-
+
- !THREADED_RTS
- all the other threads in the system are stopped (eg. during GC).
@@ -55,7 +55,7 @@ static void throwToSendMsg (Capability *cap USED_IF_THREADS,
-------------------------------------------------------------------------- */
static void
-throwToSingleThreaded__ (Capability *cap, StgTSO *tso, StgClosure *exception,
+throwToSingleThreaded__ (Capability *cap, StgTSO *tso, StgClosure *exception,
rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
{
// Thread already dead?
@@ -128,13 +128,13 @@ suspendComputation (Capability *cap, StgTSO *tso, StgUpdateFrame *stop_here)
its parent container (e.g. the MVar) and then raise the exception.
We might change these cases to be more message-passing-like in the
future.
-
- Returns:
+
+ Returns:
NULL exception was raised, ok to continue
MessageThrowTo * exception was not raised; the source TSO
- should now put itself in the state
+ should now put itself in the state
BlockedOnMsgThrowTo, and when it is ready
it should unlock the mssage using
unlockClosure(msg, &stg_MSG_THROWTO_info);
@@ -145,10 +145,10 @@ suspendComputation (Capability *cap, StgTSO *tso, StgUpdateFrame *stop_here)
-------------------------------------------------------------------------- */
MessageThrowTo *
-throwTo (Capability *cap, // the Capability we hold
- StgTSO *source, // the TSO sending the exception (or NULL)
- StgTSO *target, // the TSO receiving the exception
- StgClosure *exception) // the exception closure
+throwTo (Capability *cap, // the Capability we hold
+ StgTSO *source, // the TSO sending the exception (or NULL)
+ StgTSO *target, // the TSO receiving the exception
+ StgClosure *exception) // the exception closure
{
MessageThrowTo *msg;
@@ -175,7 +175,7 @@ throwTo (Capability *cap, // the Capability we hold
return msg;
}
}
-
+
nat
throwToMsg (Capability *cap, MessageThrowTo *msg)
@@ -194,14 +194,14 @@ check_target:
ASSERT(target != END_TSO_QUEUE);
// Thread already dead?
- if (target->what_next == ThreadComplete
- || target->what_next == ThreadKilled) {
- return THROWTO_SUCCESS;
+ if (target->what_next == ThreadComplete
+ || target->what_next == ThreadKilled) {
+ return THROWTO_SUCCESS;
}
debugTraceCap(DEBUG_sched, cap,
"throwTo: from thread %lu to thread %lu",
- (unsigned long)msg->source->id,
+ (unsigned long)msg->source->id,
(unsigned long)msg->target->id);
#ifdef DEBUG
@@ -215,7 +215,7 @@ check_target:
}
status = target->why_blocked;
-
+
switch (status) {
case NotBlocked:
{
@@ -276,8 +276,8 @@ check_target:
goto retry;
}
- if ((target->flags & TSO_BLOCKEX) &&
- ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+ if ((target->flags & TSO_BLOCKEX) &&
+ ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
unlockClosure((StgClosure*)m, i);
blockedThrowTo(cap,target,msg);
return THROWTO_BLOCKED;
@@ -293,17 +293,17 @@ check_target:
case BlockedOnMVar:
case BlockedOnMVarRead:
{
- /*
- To establish ownership of this TSO, we need to acquire a
- lock on the MVar that it is blocked on.
- */
- StgMVar *mvar;
- StgInfoTable *info USED_IF_THREADS;
-
- mvar = (StgMVar *)target->block_info.closure;
-
- // ASSUMPTION: tso->block_info must always point to a
- // closure. In the threaded RTS it does.
+ /*
+ To establish ownership of this TSO, we need to acquire a
+ lock on the MVar that it is blocked on.
+ */
+ StgMVar *mvar;
+ StgInfoTable *info USED_IF_THREADS;
+
+ mvar = (StgMVar *)target->block_info.closure;
+
+ // ASSUMPTION: tso->block_info must always point to a
+ // closure. In the threaded RTS it does.
switch (get_itbl((StgClosure *)mvar)->type) {
case MVAR_CLEAN:
case MVAR_DIRTY:
@@ -312,47 +312,47 @@ check_target:
goto retry;
}
- info = lockClosure((StgClosure *)mvar);
+ info = lockClosure((StgClosure *)mvar);
// we have the MVar, let's check whether the thread
- // is still blocked on the same MVar.
- if ((target->why_blocked != BlockedOnMVar && target->why_blocked != BlockedOnMVarRead)
- || (StgMVar *)target->block_info.closure != mvar) {
- unlockClosure((StgClosure *)mvar, info);
- goto retry;
- }
+ // is still blocked on the same MVar.
+ if ((target->why_blocked != BlockedOnMVar && target->why_blocked != BlockedOnMVarRead)
+ || (StgMVar *)target->block_info.closure != mvar) {
+ unlockClosure((StgClosure *)mvar, info);
+ goto retry;
+ }
if (target->_link == END_TSO_QUEUE) {
// the MVar operation has already completed. There is a
// MSG_TRY_WAKEUP on the way, but we can just wake up the
// thread now anyway and ignore the message when it
// arrives.
- unlockClosure((StgClosure *)mvar, info);
+ unlockClosure((StgClosure *)mvar, info);
tryWakeupThread(cap, target);
goto retry;
}
- if ((target->flags & TSO_BLOCKEX) &&
- ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+ if ((target->flags & TSO_BLOCKEX) &&
+ ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
blockedThrowTo(cap,target,msg);
- unlockClosure((StgClosure *)mvar, info);
- return THROWTO_BLOCKED;
- } else {
+ unlockClosure((StgClosure *)mvar, info);
+ return THROWTO_BLOCKED;
+ } else {
// revoke the MVar operation
removeFromMVarBlockedQueue(target);
- raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
- unlockClosure((StgClosure *)mvar, info);
- return THROWTO_SUCCESS;
- }
+ raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+ unlockClosure((StgClosure *)mvar, info);
+ return THROWTO_SUCCESS;
+ }
}
case BlockedOnBlackHole:
{
- if (target->flags & TSO_BLOCKEX) {
+ if (target->flags & TSO_BLOCKEX) {
// BlockedOnBlackHole is not interruptible.
blockedThrowTo(cap,target,msg);
- return THROWTO_BLOCKED;
- } else {
+ return THROWTO_BLOCKED;
+ } else {
// Revoke the message by replacing it with IND. We're not
// locking anything here, so we might still get a TRY_WAKEUP
// message from the owner of the blackhole some time in the
@@ -365,23 +365,23 @@ check_target:
}
case BlockedOnSTM:
- lockTSO(target);
- // Unblocking BlockedOnSTM threads requires the TSO to be
- // locked; see STM.c:unpark_tso().
- if (target->why_blocked != BlockedOnSTM) {
- unlockTSO(target);
- goto retry;
- }
- if ((target->flags & TSO_BLOCKEX) &&
- ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+ lockTSO(target);
+ // Unblocking BlockedOnSTM threads requires the TSO to be
+ // locked; see STM.c:unpark_tso().
+ if (target->why_blocked != BlockedOnSTM) {
+ unlockTSO(target);
+ goto retry;
+ }
+ if ((target->flags & TSO_BLOCKEX) &&
+ ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
blockedThrowTo(cap,target,msg);
- unlockTSO(target);
- return THROWTO_BLOCKED;
- } else {
- raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
- unlockTSO(target);
- return THROWTO_SUCCESS;
- }
+ unlockTSO(target);
+ return THROWTO_BLOCKED;
+ } else {
+ raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+ unlockTSO(target);
+ return THROWTO_SUCCESS;
+ }
case BlockedOnCCall_Interruptible:
#ifdef THREADED_RTS
@@ -409,8 +409,8 @@ check_target:
}
#endif
case BlockedOnCCall:
- blockedThrowTo(cap,target,msg);
- return THROWTO_BLOCKED;
+ blockedThrowTo(cap,target,msg);
+ return THROWTO_BLOCKED;
#ifndef THREADEDED_RTS
case BlockedOnRead:
@@ -419,15 +419,15 @@ check_target:
#if defined(mingw32_HOST_OS)
case BlockedOnDoProc:
#endif
- if ((target->flags & TSO_BLOCKEX) &&
- ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
- blockedThrowTo(cap,target,msg);
- return THROWTO_BLOCKED;
- } else {
- removeFromQueues(cap,target);
- raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
- return THROWTO_SUCCESS;
- }
+ if ((target->flags & TSO_BLOCKEX) &&
+ ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+ blockedThrowTo(cap,target,msg);
+ return THROWTO_BLOCKED;
+ } else {
+ removeFromQueues(cap,target);
+ raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+ return THROWTO_SUCCESS;
+ }
#endif
case ThreadMigrating:
@@ -450,9 +450,9 @@ check_target:
static void
throwToSendMsg (Capability *cap STG_UNUSED,
- Capability *target_cap USED_IF_THREADS,
+ Capability *target_cap USED_IF_THREADS,
MessageThrowTo *msg USED_IF_THREADS)
-
+
{
#ifdef THREADED_RTS
debugTraceCap(DEBUG_sched, cap, "throwTo: sending a throwto message to cap %lu", (unsigned long)target_cap->no);
@@ -510,17 +510,17 @@ maybePerformBlockedException (Capability *cap, StgTSO *tso)
}
}
- if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE &&
+ if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE &&
(tso->flags & TSO_BLOCKEX) != 0) {
debugTraceCap(DEBUG_sched, cap, "throwTo: thread %lu has blocked exceptions but is inside block", (unsigned long)tso->id);
}
if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE
- && ((tso->flags & TSO_BLOCKEX) == 0
- || ((tso->flags & TSO_INTERRUPTIBLE) && interruptible(tso)))) {
+ && ((tso->flags & TSO_BLOCKEX) == 0
+ || ((tso->flags & TSO_INTERRUPTIBLE) && interruptible(tso)))) {
- // We unblock just the first thread on the queue, and perform
- // its throw immediately.
+ // We unblock just the first thread on the queue, and perform
+ // its throw immediately.
loop:
msg = tso->blocked_exceptions;
if (msg == END_BLOCKED_EXCEPTIONS_QUEUE) return 0;
@@ -562,7 +562,7 @@ awakenBlockedExceptionQueue (Capability *cap, StgTSO *tso)
}
}
tso->blocked_exceptions = END_BLOCKED_EXCEPTIONS_QUEUE;
-}
+}
/* -----------------------------------------------------------------------------
Remove a thread from blocking queues.
@@ -673,7 +673,7 @@ removeFromQueues(Capability *cap, StgTSO *tso)
case BlockedOnDelay:
removeThreadFromQueue(cap, &sleeping_queue, tso);
- goto done;
+ goto done;
#endif
default:
@@ -696,11 +696,11 @@ removeFromQueues(Capability *cap, StgTSO *tso)
* TSO blocked_exception queues.
*
* We strip the stack down to the innermost CATCH_FRAME, building
- * thunks in the heap for all the active computations, so they can
+ * thunks in the heap for all the active computations, so they can
* be restarted if necessary. When we reach a CATCH_FRAME, we build
* an application of the handler to the exception, and push it on
* the top of the stack.
- *
+ *
* How exactly do we save all the active computations? We create an
* AP_STACK for every UpdateFrame on the stack. Entering one of these
* AP_STACKs pushes everything from the corresponding update frame
@@ -711,7 +711,7 @@ removeFromQueues(Capability *cap, StgTSO *tso)
* exactly as it did when we killed the TSO and we can continue
* execution by entering the closure on top of the stack.
*
- * We can also kill a thread entirely - this happens if either (a) the
+ * We can also kill a thread entirely - this happens if either (a) the
* exception passed to raiseAsync is NULL, or (b) there's no
* CATCH_FRAME on the stack. In either case, we strip the entire
* stack and replace the thread with a zombie.
@@ -724,8 +724,8 @@ removeFromQueues(Capability *cap, StgTSO *tso)
* -------------------------------------------------------------------------- */
static StgTSO *
-raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
- rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
+raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
+ rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
{
StgRetInfoTable *info;
StgPtr sp, frame;
@@ -735,12 +735,12 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
debugTraceCap(DEBUG_sched, cap,
"raising exception in thread %ld.", (long)tso->id);
-
+
#if defined(PROFILING)
- /*
+ /*
* Debugging tool: on raising an exception, show where we are.
* See also Exception.cmm:stg_raisezh.
- * This wasn't done for asynchronous exceptions originally; see #1450
+ * This wasn't done for asynchronous exceptions originally; see #1450
*/
if (RtsFlags.ProfFlags.showCCSOnException && exception != NULL)
{
@@ -749,10 +749,10 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
#endif
// ASSUMES: the thread is not already complete or dead
// Upper layers should deal with that.
- ASSERT(tso->what_next != ThreadComplete &&
+ ASSERT(tso->what_next != ThreadComplete &&
tso->what_next != ThreadKilled);
- // only if we own this TSO (except that deleteThread() calls this
+ // only if we own this TSO (except that deleteThread() calls this
ASSERT(tso->cap == cap);
stack = tso->stackobj;
@@ -762,7 +762,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
dirty_STACK(cap, stack);
sp = stack->sp;
-
+
if (stop_here != NULL) {
updatee = stop_here->updatee;
} else {
@@ -773,69 +773,69 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
// the top of the stack, so we have to arrange that this is the case...
//
if (sp[0] == (W_)&stg_enter_info) {
- sp++;
+ sp++;
} else {
- sp--;
- sp[0] = (W_)&stg_dummy_ret_closure;
+ sp--;
+ sp[0] = (W_)&stg_dummy_ret_closure;
}
frame = sp + 1;
while (stop_here == NULL || frame < (StgPtr)stop_here) {
- // 1. Let the top of the stack be the "current closure"
- //
- // 2. Walk up the stack until we find either an UPDATE_FRAME or a
- // CATCH_FRAME.
- //
- // 3. If it's an UPDATE_FRAME, then make an AP_STACK containing the
- // current closure applied to the chunk of stack up to (but not
- // including) the update frame. This closure becomes the "current
- // closure". Go back to step 2.
- //
- // 4. If it's a CATCH_FRAME, then leave the exception handler on
- // top of the stack applied to the exception.
- //
- // 5. If it's a STOP_FRAME, then kill the thread.
- //
+ // 1. Let the top of the stack be the "current closure"
+ //
+ // 2. Walk up the stack until we find either an UPDATE_FRAME or a
+ // CATCH_FRAME.
+ //
+ // 3. If it's an UPDATE_FRAME, then make an AP_STACK containing the
+ // current closure applied to the chunk of stack up to (but not
+ // including) the update frame. This closure becomes the "current
+ // closure". Go back to step 2.
+ //
+ // 4. If it's a CATCH_FRAME, then leave the exception handler on
+ // top of the stack applied to the exception.
+ //
+ // 5. If it's a STOP_FRAME, then kill the thread.
+ //
// 6. If it's an UNDERFLOW_FRAME, then continue with the next
// stack chunk.
//
// NB: if we pass an ATOMICALLY_FRAME then abort the associated
// transaction
-
+
info = get_ret_itbl((StgClosure *)frame);
- switch (info->i.type) {
-
- case UPDATE_FRAME:
- {
- StgAP_STACK * ap;
- nat words;
-
- // First build an AP_STACK consisting of the stack chunk above the
- // current update frame, with the top word on the stack as the
- // fun field.
- //
- words = frame - sp - 1;
- ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
-
- ap->size = words;
- ap->fun = (StgClosure *)sp[0];
- sp++;
- for(i=0; i < (nat)words; ++i) {
- ap->payload[i] = (StgClosure *)*sp++;
- }
-
- SET_HDR(ap,&stg_AP_STACK_info,
- ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
- TICK_ALLOC_UP_THK(WDS(words+1),0);
-
- //IF_DEBUG(scheduler,
- // debugBelch("sched: Updating ");
- // printPtr((P_)((StgUpdateFrame *)frame)->updatee);
- // debugBelch(" with ");
- // printObj((StgClosure *)ap);
- // );
+ switch (info->i.type) {
+
+ case UPDATE_FRAME:
+ {
+ StgAP_STACK * ap;
+ nat words;
+
+ // First build an AP_STACK consisting of the stack chunk above the
+ // current update frame, with the top word on the stack as the
+ // fun field.
+ //
+ words = frame - sp - 1;
+ ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
+
+ ap->size = words;
+ ap->fun = (StgClosure *)sp[0];
+ sp++;
+ for(i=0; i < (nat)words; ++i) {
+ ap->payload[i] = (StgClosure *)*sp++;
+ }
+
+ SET_HDR(ap,&stg_AP_STACK_info,
+ ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
+ TICK_ALLOC_UP_THK(WDS(words+1),0);
+
+ //IF_DEBUG(scheduler,
+ // debugBelch("sched: Updating ");
+ // printPtr((P_)((StgUpdateFrame *)frame)->updatee);
+ // debugBelch(" with ");
+ // printObj((StgClosure *)ap);
+ // );
if (((StgUpdateFrame *)frame)->updatee == updatee) {
// If this update frame points to the same closure as
@@ -848,37 +848,37 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
// Perform the update
// TODO: this may waste some work, if the thunk has
// already been updated by another thread.
- updateThunk(cap, tso,
+ updateThunk(cap, tso,
((StgUpdateFrame *)frame)->updatee, (StgClosure *)ap);
}
- sp += sizeofW(StgUpdateFrame) - 1;
- sp[0] = (W_)ap; // push onto stack
- frame = sp + 1;
- continue; //no need to bump frame
- }
+ sp += sizeofW(StgUpdateFrame) - 1;
+ sp[0] = (W_)ap; // push onto stack
+ frame = sp + 1;
+ continue; //no need to bump frame
+ }
case UNDERFLOW_FRAME:
{
- StgAP_STACK * ap;
- nat words;
-
- // First build an AP_STACK consisting of the stack chunk above the
- // current update frame, with the top word on the stack as the
- // fun field.
- //
- words = frame - sp - 1;
- ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
-
- ap->size = words;
- ap->fun = (StgClosure *)sp[0];
- sp++;
- for(i=0; i < (nat)words; ++i) {
- ap->payload[i] = (StgClosure *)*sp++;
- }
-
+ StgAP_STACK * ap;
+ nat words;
+
+ // First build an AP_STACK consisting of the stack chunk above the
+ // current update frame, with the top word on the stack as the
+ // fun field.
+ //
+ words = frame - sp - 1;
+ ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
+
+ ap->size = words;
+ ap->fun = (StgClosure *)sp[0];
+ sp++;
+ for(i=0; i < (nat)words; ++i) {
+ ap->payload[i] = (StgClosure *)*sp++;
+ }
+
SET_HDR(ap,&stg_AP_STACK_NOUPD_info,
- ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
+ ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
TICK_ALLOC_SE_THK(WDS(words+1),0);
stack->sp = sp;
@@ -893,40 +893,40 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
}
case STOP_FRAME:
- {
- // We've stripped the entire stack, the thread is now dead.
- tso->what_next = ThreadKilled;
+ {
+ // We've stripped the entire stack, the thread is now dead.
+ tso->what_next = ThreadKilled;
stack->sp = frame + sizeofW(StgStopFrame);
goto done;
- }
-
- case CATCH_FRAME:
- // If we find a CATCH_FRAME, and we've got an exception to raise,
- // then build the THUNK raise(exception), and leave it on
- // top of the CATCH_FRAME ready to enter.
- //
- {
- StgCatchFrame *cf = (StgCatchFrame *)frame;
- StgThunk *raise;
-
- if (exception == NULL) break;
-
- // we've got an exception to raise, so let's pass it to the
- // handler in this frame.
- //
- raise = (StgThunk *)allocate(cap,sizeofW(StgThunk)+1);
- TICK_ALLOC_SE_THK(WDS(1),0);
- SET_HDR(raise,&stg_raise_info,cf->header.prof.ccs);
- raise->payload[0] = exception;
-
- // throw away the stack from Sp up to the CATCH_FRAME.
- //
- sp = frame - 1;
-
- /* Ensure that async exceptions are blocked now, so we don't get
- * a surprise exception before we get around to executing the
- * handler.
- */
+ }
+
+ case CATCH_FRAME:
+ // If we find a CATCH_FRAME, and we've got an exception to raise,
+ // then build the THUNK raise(exception), and leave it on
+ // top of the CATCH_FRAME ready to enter.
+ //
+ {
+ StgCatchFrame *cf = (StgCatchFrame *)frame;
+ StgThunk *raise;
+
+ if (exception == NULL) break;
+
+ // we've got an exception to raise, so let's pass it to the
+ // handler in this frame.
+ //
+ raise = (StgThunk *)allocate(cap,sizeofW(StgThunk)+1);
+ TICK_ALLOC_SE_THK(WDS(1),0);
+ SET_HDR(raise,&stg_raise_info,cf->header.prof.ccs);
+ raise->payload[0] = exception;
+
+ // throw away the stack from Sp up to the CATCH_FRAME.
+ //
+ sp = frame - 1;
+
+ /* Ensure that async exceptions are blocked now, so we don't get
+ * a surprise exception before we get around to executing the
+ * handler.
+ */
tso->flags |= TSO_BLOCKEX;
if ((cf->exceptions_blocked & TSO_INTERRUPTIBLE) == 0) {
tso->flags &= ~TSO_INTERRUPTIBLE;
@@ -934,20 +934,20 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
tso->flags |= TSO_INTERRUPTIBLE;
}
- /* Put the newly-built THUNK on top of the stack, ready to execute
- * when the thread restarts.
- */
- sp[0] = (W_)raise;
- sp[-1] = (W_)&stg_enter_info;
+ /* Put the newly-built THUNK on top of the stack, ready to execute
+ * when the thread restarts.
+ */
+ sp[0] = (W_)raise;
+ sp[-1] = (W_)&stg_enter_info;
stack->sp = sp-1;
- tso->what_next = ThreadRunGHC;
+ tso->what_next = ThreadRunGHC;
goto done;
- }
-
- case ATOMICALLY_FRAME:
- if (stop_at_atomically) {
- ASSERT(tso->trec->enclosing_trec == NO_TREC);
- stmCondemnTransaction(cap, tso -> trec);
+ }
+
+ case ATOMICALLY_FRAME:
+ if (stop_at_atomically) {
+ ASSERT(tso->trec->enclosing_trec == NO_TREC);
+ stmCondemnTransaction(cap, tso -> trec);
stack->sp = frame - 2;
// The ATOMICALLY_FRAME expects to be returned a
// result from the transaction, which it stores in the
@@ -961,7 +961,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
stack->sp[0] = (W_)&stg_ret_p_info;
tso->what_next = ThreadRunGHC;
goto done;
- }
+ }
else
{
// Freezing an STM transaction. Just aborting the
@@ -1009,33 +1009,33 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
}
case CATCH_STM_FRAME:
- case CATCH_RETRY_FRAME:
+ case CATCH_RETRY_FRAME:
// CATCH frames within an atomically block: abort the
// inner transaction and continue. Eventually we will
// hit the outer transaction that will get frozen (see
// above).
//
// In this case (unlike ordinary exceptions) we do not care
- // whether the transaction is valid or not because its
- // possible validity cannot have caused the exception
- // and will not be visible after the abort.
+ // whether the transaction is valid or not because its
+ // possible validity cannot have caused the exception
+ // and will not be visible after the abort.
{
StgTRecHeader *trec = tso -> trec;
StgTRecHeader *outer = trec -> enclosing_trec;
- debugTraceCap(DEBUG_stm, cap,
+ debugTraceCap(DEBUG_stm, cap,
"found atomically block delivering async exception");
stmAbortTransaction(cap, trec);
- stmFreeAbortedTRec(cap, trec);
+ stmFreeAbortedTRec(cap, trec);
tso -> trec = outer;
break;
};
- default:
- break;
- }
+ default:
+ break;
+ }
- // move on to the next stack frame
- frame += stack_frame_sizeW((StgClosure *)frame);
+ // move on to the next stack frame
+ frame += stack_frame_sizeW((StgClosure *)frame);
}
done:
@@ -1045,9 +1045,7 @@ done:
if (tso->why_blocked != NotBlocked) {
tso->why_blocked = NotBlocked;
appendToRunQueue(cap,tso);
- }
+ }
return tso;
}
-
-