X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FPrimOps.cmm;h=6a2b36f3b90245887ee36c247be90ed26298730e;hb=04db0e9fa47ce4dfbcb73ec1752d94195f3b394e;hp=abd71fe14cf29ff6390b781a76d96d6aa3b82e6a;hpb=1819bc7393c38e7a452b237d2355c27737fbe637;p=ghc-hetmet.git

diff --git a/ghc/rts/PrimOps.cmm b/ghc/rts/PrimOps.cmm
index abd71fe..6a2b36f 100644
--- a/ghc/rts/PrimOps.cmm
+++ b/ghc/rts/PrimOps.cmm
@@ -49,7 +49,7 @@ newByteArrayzh_fast
     n = R1;
     payload_words = ROUNDUP_BYTES_TO_WDS(n);
     words = BYTES_TO_WDS(SIZEOF_StgArrWords) + payload_words;
-    "ptr" p = foreign "C" allocateLocal(BaseReg "ptr",words) [];
+    "ptr" p = foreign "C" allocateLocal(MyCapability() "ptr",words) [];
     TICK_ALLOC_PRIM(SIZEOF_StgArrWords,WDS(payload_words),0);
     SET_HDR(p, stg_ARR_WORDS_info, W_[CCCS]);
     StgArrWords_words(p) = payload_words;
@@ -97,10 +97,10 @@ newArrayzh_fast
     MAYBE_GC(R2_PTR,newArrayzh_fast);
 
     words = BYTES_TO_WDS(SIZEOF_StgMutArrPtrs) + n;
-    "ptr" arr = foreign "C" allocateLocal(BaseReg "ptr",words) [];
+    "ptr" arr = foreign "C" allocateLocal(MyCapability() "ptr",words) [R2];
     TICK_ALLOC_PRIM(SIZEOF_StgMutArrPtrs, WDS(n), 0);
 
-    SET_HDR(arr, stg_MUT_ARR_PTRS_info, W_[CCCS]);
+    SET_HDR(arr, stg_MUT_ARR_PTRS_DIRTY_info, W_[CCCS]);
     StgMutArrPtrs_ptrs(arr) = n;
 
     // Initialise all elements of the the array with the value in R2
@@ -126,21 +126,25 @@ unsafeThawArrayzh_fast
   // the mutable list is not easy, because the mut_list is only singly-linked).
   // 
   // So that we can tell whether a MUT_ARR_PTRS_FROZEN is on the mutable list,
-  // when we freeze it we set the info ptr to be MUT_ARR_PTRS_FROZEN0 to indicate
-  // that it is still on the mutable list.
-
+  // when we freeze it we set the info ptr to be MUT_ARR_PTRS_FROZEN0
+  // to indicate that it is still on the mutable list.
+  //
   // So, when we thaw a MUT_ARR_PTRS_FROZEN, we must cope with two cases:
   // either it is on a mut_list, or it isn't.  We adopt the convention that
-  // the mut_link field is NULL if it isn't on a mut_list, and the GC
-  // maintains this invariant.
+  // the closure type is MUT_ARR_PTRS_FROZEN0 if it is on the mutable list,
+  // and MUT_ARR_PTRS_FROZEN otherwise.  In fact it wouldn't matter if
+  // we put it on the mutable list more than once, but it would get scavenged
+  // multiple times during GC, which would be unnecessarily slow.
   //
-  if (%INFO_TYPE(%GET_STD_INFO(R1)) != HALF_W_(MUT_ARR_PTRS_FROZEN0)) {
+  if (StgHeader_info(R1) != stg_MUT_ARR_PTRS_FROZEN0_info) {
+	SET_INFO(R1,stg_MUT_ARR_PTRS_DIRTY_info);
 	foreign "C" recordMutableLock(R1 "ptr") [R1];
+	// must be done after SET_INFO, because it ASSERTs closure_MUTABLE()
+	RET_P(R1);
+  } else {
+	SET_INFO(R1,stg_MUT_ARR_PTRS_DIRTY_info);
+	RET_P(R1);
   }
-
-  SET_INFO(R1,stg_MUT_ARR_PTRS_info);
-
-  RET_P(R1);
 }
 
 /* -----------------------------------------------------------------------------
@@ -155,7 +159,7 @@ newMutVarzh_fast
     ALLOC_PRIM( SIZEOF_StgMutVar, R1_PTR, newMutVarzh_fast);
 
     mv = Hp - SIZEOF_StgMutVar + WDS(1);
-    SET_HDR(mv,stg_MUT_VAR_info,W_[CCCS]);
+    SET_HDR(mv,stg_MUT_VAR_DIRTY_info,W_[CCCS]);
     StgMutVar_var(mv) = R1;
     
     RET_P(mv);
@@ -202,8 +206,8 @@ atomicModifyMutVarzh_fast
 
    HP_CHK_GEN_TICKY(SIZE, R1_PTR & R2_PTR, atomicModifyMutVarzh_fast);
 
-#if defined(SMP)
-    foreign "C" ACQUIRE_LOCK(sm_mutex "ptr");
+#if defined(THREADED_RTS)
+    foreign "C" ACQUIRE_LOCK(atomic_modify_mutvar_mutex "ptr") [R1,R2];
 #endif
 
    x = StgMutVar_var(R1);
@@ -224,6 +228,7 @@ atomicModifyMutVarzh_fast
    StgThunk_payload(y,0) = z;
 
    StgMutVar_var(R1) = y;
+   foreign "C" dirty_MUT_VAR(BaseReg "ptr", R1 "ptr") [R1];
 
    TICK_ALLOC_THUNK_1();
    CCCS_ALLOC(THUNK_1_SIZE);
@@ -232,8 +237,8 @@ atomicModifyMutVarzh_fast
    LDV_RECORD_CREATE(r);
    StgThunk_payload(r,0) = z;
 
-#if defined(SMP)
-    foreign "C" RELEASE_LOCK(sm_mutex "ptr") [];
+#if defined(THREADED_RTS)
+    foreign "C" RELEASE_LOCK(atomic_modify_mutvar_mutex "ptr") [];
 #endif
 
    RET_P(r);
@@ -507,7 +512,7 @@ word64ToIntegerzh_fast
 
 /* ToDo: this is shockingly inefficient */
 
-#ifndef SMP
+#ifndef THREADED_RTS
 section "bss" {
   mp_tmp1:
     bits8 [SIZEOF_MP_INT];
@@ -529,7 +534,7 @@ section "bss" {
 }
 #endif
 
-#ifdef SMP
+#ifdef THREADED_RTS
 #define FETCH_MP_TEMP(X) \
 W_ X; \
 X = BaseReg + (OFFSET_StgRegTable_r ## X);
@@ -650,7 +655,7 @@ GMP_TAKE1_RET1(complementIntegerzh_fast, mpz_com)
 GMP_TAKE2_RET2(quotRemIntegerzh_fast, mpz_tdiv_qr)
 GMP_TAKE2_RET2(divModIntegerzh_fast,  mpz_fdiv_qr)
 
-#ifndef SMP
+#ifndef THREADED_RTS
 section "bss" {
   mp_tmp_w:  W_; // NB. mp_tmp_w is really an here mp_limb_t
 }
@@ -875,9 +880,10 @@ forkzh_fast
   MAYBE_GC(R1_PTR, forkzh_fast);
 
   // create it right now, return ThreadID in R1
-  "ptr" R1 = foreign "C" createIOThread( RtsFlags_GcFlags_initialStkSize(RtsFlags), 
-				   R1 "ptr");
-  foreign "C" scheduleThread(R1 "ptr");
+  "ptr" R1 = foreign "C" createIOThread( MyCapability() "ptr", 
+				RtsFlags_GcFlags_initialStkSize(RtsFlags), 
+				R1 "ptr") [R1];
+  foreign "C" scheduleThread(MyCapability() "ptr", R1 "ptr") [R1];
 
   // switch at the earliest opportunity
   CInt[context_switch] = 1 :: CInt;
@@ -902,7 +908,7 @@ labelThreadzh_fast
 	R1 = ThreadId#
 	R2 = Addr# */
 #ifdef DEBUG
-  foreign "C" labelThread(R1 "ptr", R2 "ptr");
+  foreign "C" labelThread(R1 "ptr", R2 "ptr") [];
 #endif
   jump %ENTRY_CODE(Sp(0));
 }
@@ -972,7 +978,7 @@ INFO_TABLE_RET(stg_catch_retry_frame,
    frame = Sp;
    trec = StgTSO_trec(CurrentTSO);
    "ptr" outer = foreign "C" stmGetEnclosingTRec(trec "ptr") [];
-   r = foreign "C" stmCommitNestedTransaction(BaseReg "ptr", trec "ptr") [];
+   r = foreign "C" stmCommitNestedTransaction(MyCapability() "ptr", trec "ptr") [];
    if (r) {
      /* Succeeded (either first branch or second branch) */
      StgTSO_trec(CurrentTSO) = outer;
@@ -982,7 +988,7 @@ INFO_TABLE_RET(stg_catch_retry_frame,
    } else {
      /* Did not commit: retry */
      W_ new_trec;
-     "ptr" new_trec = foreign "C" stmStartTransaction(BaseReg "ptr", outer "ptr") [];
+     "ptr" new_trec = foreign "C" stmStartTransaction(MyCapability() "ptr", outer "ptr") [];
      StgTSO_trec(CurrentTSO) = new_trec;
      if (StgCatchRetryFrame_running_alt_code(frame)) {
        R1 = StgCatchRetryFrame_alt_code(frame);
@@ -990,8 +996,7 @@ INFO_TABLE_RET(stg_catch_retry_frame,
        R1 = StgCatchRetryFrame_first_code(frame);
        StgCatchRetryFrame_first_code_trec(frame) = new_trec;
      }
-     Sp_adj(-1);
-     jump RET_LBL(stg_ap_v);
+     jump stg_ap_v_fast;
    }
 }
 
@@ -1016,11 +1021,11 @@ ATOMICALLY_FRAME_ERROR(stg_atomically_frame_7_ret)
 #endif
 
 #if defined(PROFILING)
-#define ATOMICALLY_FRAME_BITMAP 7
-#define ATOMICALLY_FRAME_WORDS  4
+#define ATOMICALLY_FRAME_BITMAP 3
+#define ATOMICALLY_FRAME_WORDS  3
 #else
-#define ATOMICALLY_FRAME_BITMAP 1
-#define ATOMICALLY_FRAME_WORDS  2
+#define ATOMICALLY_FRAME_BITMAP 0
+#define ATOMICALLY_FRAME_WORDS  1
 #endif
 
 
@@ -1036,50 +1041,64 @@ INFO_TABLE_RET(stg_atomically_frame,
 	       stg_atomically_frame_6_ret,
 	       stg_atomically_frame_7_ret)
 {
-   W_ frame, trec, valid;
-   IF_NOT_REG_R1(W_ rval;  rval = Sp(0);  Sp_adj(1); )
+  W_ frame, trec, valid;
+  IF_NOT_REG_R1(W_ rval;  rval = Sp(0);  Sp_adj(1); )
 
-   frame = Sp;
-   trec = StgTSO_trec(CurrentTSO);
-   if (StgAtomicallyFrame_waiting(frame)) {
-     /* The TSO is currently waiting: should we stop waiting? */
-     valid = foreign "C" stmReWait(CurrentTSO "ptr");
-     if (valid) {
-       /* Previous attempt is still valid: no point trying again yet */
+  frame = Sp;
+  trec = StgTSO_trec(CurrentTSO);
+
+  /* The TSO is not currently waiting: try to commit the transaction */
+  valid = foreign "C" stmCommitTransaction(MyCapability() "ptr", trec "ptr") [];
+  if (valid) {
+    /* Transaction was valid: commit succeeded */
+    StgTSO_trec(CurrentTSO) = NO_TREC;
+    Sp = Sp + SIZEOF_StgAtomicallyFrame;
+    IF_NOT_REG_R1(Sp_adj(-1); Sp(0) = rval;)
+    jump %ENTRY_CODE(Sp(SP_OFF));
+  } else {
+    /* Transaction was not valid: try again */
+    "ptr" trec = foreign "C" stmStartTransaction(MyCapability() "ptr", NO_TREC "ptr") [];
+    StgTSO_trec(CurrentTSO) = trec;
+    R1 = StgAtomicallyFrame_code(frame);
+    jump stg_ap_v_fast;
+  }
+}
+
+INFO_TABLE_RET(stg_atomically_waiting_frame,
+	       ATOMICALLY_FRAME_WORDS, ATOMICALLY_FRAME_BITMAP,
+	       ATOMICALLY_FRAME,
+	       stg_atomically_frame_0_ret,
+	       stg_atomically_frame_1_ret,
+	       stg_atomically_frame_2_ret,
+	       stg_atomically_frame_3_ret,
+	       stg_atomically_frame_4_ret,
+	       stg_atomically_frame_5_ret,
+	       stg_atomically_frame_6_ret,
+	       stg_atomically_frame_7_ret)
+{
+  W_ frame, trec, valid;
+  IF_NOT_REG_R1(W_ rval;  rval = Sp(0);  Sp_adj(1); )
+
+  frame = Sp;
+
+  /* The TSO is currently waiting: should we stop waiting? */
+  valid = foreign "C" stmReWait(MyCapability() "ptr", CurrentTSO "ptr") [];
+  if (valid) {
+    /* Previous attempt is still valid: no point trying again yet */
 	  IF_NOT_REG_R1(Sp_adj(-2);
 			Sp(1) = stg_NO_FINALIZER_closure;
 		  	Sp(0) = stg_ut_1_0_unreg_info;)
-       jump stg_block_noregs;
-     } else {
-       /* Previous attempt is no longer valid: try again */
-       "ptr" trec = foreign "C" stmStartTransaction(BaseReg "ptr", NO_TREC "ptr");
-       StgTSO_trec(CurrentTSO) = trec;
-       StgAtomicallyFrame_waiting(frame) = 0 :: CInt; /* false; */
-       R1 = StgAtomicallyFrame_code(frame);
-       Sp_adj(-1);
-       jump RET_LBL(stg_ap_v);
-     }
-   } else {
-     /* The TSO is not currently waiting: try to commit the transaction */
-     valid = foreign "C" stmCommitTransaction(BaseReg "ptr", trec "ptr");
-     if (valid) {
-       /* Transaction was valid: commit succeeded */
-       StgTSO_trec(CurrentTSO) = NO_TREC;
-       Sp = Sp + SIZEOF_StgAtomicallyFrame;
-       IF_NOT_REG_R1(Sp_adj(-1); Sp(0) = rval;)
-       jump %ENTRY_CODE(Sp(SP_OFF));
-     } else {
-       /* Transaction was not valid: try again */
-       "ptr" trec = foreign "C" stmStartTransaction(BaseReg "ptr", NO_TREC "ptr");
-       StgTSO_trec(CurrentTSO) = trec;
-       R1 = StgAtomicallyFrame_code(frame);
-       Sp_adj(-1);
-       jump RET_LBL(stg_ap_v);
-     }
-   }
+    jump stg_block_noregs;
+  } else {
+    /* Previous attempt is no longer valid: try again */
+    "ptr" trec = foreign "C" stmStartTransaction(MyCapability() "ptr", NO_TREC "ptr") [];
+    StgTSO_trec(CurrentTSO) = trec;
+    StgHeader_info(frame) = stg_atomically_frame_info;
+    R1 = StgAtomicallyFrame_code(frame);
+    jump stg_ap_v_fast;
+  }
 }
 
-
 // STM catch frame --------------------------------------------------------------
 
 #define CATCH_STM_FRAME_ENTRY_TEMPLATE(label,ret)          \
@@ -1151,23 +1170,27 @@ atomicallyzh_fast
   /* Args: R1 = m :: STM a */
   STK_CHK_GEN(SIZEOF_StgAtomicallyFrame + WDS(1), R1_PTR, atomicallyzh_fast);
 
+  old_trec = StgTSO_trec(CurrentTSO);
+
+  /* Nested transactions are not allowed; raise an exception */
+  if (old_trec != NO_TREC) {
+     R1 = GHCziIOBase_NestedAtomically_closure;
+     jump raisezh_fast;
+  }
+
   /* Set up the atomically frame */
   Sp = Sp - SIZEOF_StgAtomicallyFrame;
   frame = Sp;
 
   SET_HDR(frame,stg_atomically_frame_info, W_[CCCS]);
-  StgAtomicallyFrame_waiting(frame) = 0 :: CInt; // False
   StgAtomicallyFrame_code(frame) = R1;
 
   /* Start the memory transcation */
-  old_trec = StgTSO_trec(CurrentTSO);
-  ASSERT(old_trec == NO_TREC);
-  "ptr" new_trec = foreign "C" stmStartTransaction(BaseReg "ptr", old_trec "ptr");
+  "ptr" new_trec = foreign "C" stmStartTransaction(MyCapability() "ptr", old_trec "ptr") [R1];
   StgTSO_trec(CurrentTSO) = new_trec;
 
   /* Apply R1 to the realworld token */
-  Sp_adj(-1);
-  jump RET_LBL(stg_ap_v);
+  jump stg_ap_v_fast;
 }
 
 
@@ -1187,8 +1210,7 @@ catchSTMzh_fast
   StgCatchSTMFrame_handler(frame) = R2;
 
   /* Apply R1 to the realworld token */
-  Sp_adj(-1);
-  jump RET_LBL(stg_ap_v);
+  jump stg_ap_v_fast;
 }
 
 
@@ -1207,7 +1229,7 @@ catchRetryzh_fast
 
   /* Start a nested transaction within which to run the first code */
   trec = StgTSO_trec(CurrentTSO);
-  "ptr" new_trec = foreign "C" stmStartTransaction(BaseReg "ptr", trec "ptr");
+  "ptr" new_trec = foreign "C" stmStartTransaction(MyCapability() "ptr", trec "ptr") [R1,R2];
   StgTSO_trec(CurrentTSO) = new_trec;
 
   /* Set up the catch-retry frame */
@@ -1221,8 +1243,7 @@ catchRetryzh_fast
   StgCatchRetryFrame_first_code_trec(frame) = new_trec;
 
   /* Apply R1 to the realworld token */
-  Sp_adj(-1);
-  jump RET_LBL(stg_ap_v);  
+  jump stg_ap_v_fast;
 }
 
 
@@ -1239,9 +1260,9 @@ retryzh_fast
   // Find the enclosing ATOMICALLY_FRAME or CATCH_RETRY_FRAME
 retry_pop_stack:
   trec = StgTSO_trec(CurrentTSO);
-  "ptr" outer = foreign "C" stmGetEnclosingTRec(trec "ptr");
+  "ptr" outer = foreign "C" stmGetEnclosingTRec(trec "ptr") [];
   StgTSO_sp(CurrentTSO) = Sp;
-  frame_type = foreign "C" findRetryFrameHelper(CurrentTSO "ptr");
+  frame_type = foreign "C" findRetryFrameHelper(CurrentTSO "ptr") [];
   Sp = StgTSO_sp(CurrentTSO);
   frame = Sp;
 
@@ -1250,19 +1271,20 @@ retry_pop_stack:
     ASSERT(outer != NO_TREC);
     if (!StgCatchRetryFrame_running_alt_code(frame)) {
       // Retry in the first code: try the alternative
-      "ptr" trec = foreign "C" stmStartTransaction(BaseReg "ptr", outer "ptr");
+      "ptr" trec = foreign "C" stmStartTransaction(MyCapability() "ptr", outer "ptr") [];
       StgTSO_trec(CurrentTSO) = trec;
       StgCatchRetryFrame_running_alt_code(frame) = 1 :: CInt; // true;
       R1 = StgCatchRetryFrame_alt_code(frame);
-      Sp_adj(-1);
-      jump RET_LBL(stg_ap_v);
+      jump stg_ap_v_fast;
     } else {
       // Retry in the alternative code: propagate
       W_ other_trec;
       other_trec = StgCatchRetryFrame_first_code_trec(frame);
-      r = foreign "C" stmCommitNestedTransaction(BaseReg "ptr", other_trec "ptr");
+      r = foreign "C" stmCommitNestedTransaction(MyCapability() "ptr", other_trec "ptr") [];
       if (r) {
-        r = foreign "C" stmCommitNestedTransaction(BaseReg "ptr", trec "ptr");
+        r = foreign "C" stmCommitNestedTransaction(MyCapability() "ptr", trec "ptr") [];
+      } else {
+        foreign "C" stmAbortTransaction(MyCapability() "ptr", trec "ptr") [];
       }
       if (r) {
         // Merge between siblings succeeded: commit it back to enclosing transaction
@@ -1272,13 +1294,12 @@ retry_pop_stack:
         goto retry_pop_stack;
       } else {
         // Merge failed: we musn't propagate the retry.  Try both paths again.
-        "ptr" trec = foreign "C" stmStartTransaction(BaseReg "ptr", outer "ptr");
+        "ptr" trec = foreign "C" stmStartTransaction(MyCapability() "ptr", outer "ptr") [];
         StgCatchRetryFrame_first_code_trec(frame) = trec;
         StgCatchRetryFrame_running_alt_code(frame) = 0 :: CInt; // false;
         StgTSO_trec(CurrentTSO) = trec;
         R1 = StgCatchRetryFrame_first_code(frame);
-        Sp_adj(-1);
-        jump RET_LBL(stg_ap_v);
+        jump stg_ap_v_fast;
       }
     }
   }
@@ -1286,24 +1307,24 @@ retry_pop_stack:
   // We've reached the ATOMICALLY_FRAME: attempt to wait 
   ASSERT(frame_type == ATOMICALLY_FRAME);
   ASSERT(outer == NO_TREC);
-  r = foreign "C" stmWait(BaseReg "ptr", CurrentTSO "ptr", trec "ptr");
+  r = foreign "C" stmWait(MyCapability() "ptr", CurrentTSO "ptr", trec "ptr") [];
   if (r) {
     // Transaction was valid: stmWait put us on the TVars' queues, we now block
-    StgAtomicallyFrame_waiting(frame) = 1 :: CInt; // true
+    StgHeader_info(frame) = stg_atomically_waiting_frame_info;
     Sp = frame;
     // Fix up the stack in the unregisterised case: the return convention is different.
     IF_NOT_REG_R1(Sp_adj(-2); 
 		  Sp(1) = stg_NO_FINALIZER_closure;
 		  Sp(0) = stg_ut_1_0_unreg_info;)
-    jump stg_block_noregs;
+    R3 = trec; // passing to stmWaitUnblock()
+    jump stg_block_stmwait;
   } else {
     // Transaction was not valid: retry immediately
-    "ptr" trec = foreign "C" stmStartTransaction(BaseReg "ptr", outer "ptr");
+    "ptr" trec = foreign "C" stmStartTransaction(MyCapability() "ptr", outer "ptr") [];
     StgTSO_trec(CurrentTSO) = trec;
     R1 = StgAtomicallyFrame_code(frame);
     Sp = frame;
-    Sp_adj(-1);
-    jump RET_LBL(stg_ap_v);
+    jump stg_ap_v_fast;
   }
 }
 
@@ -1317,7 +1338,7 @@ newTVarzh_fast
 
   MAYBE_GC (R1_PTR, newTVarzh_fast); 
   new_value = R1;
-  tv = foreign "C" stmNewTVar(BaseReg "ptr", new_value "ptr");
+  "ptr" tv = foreign "C" stmNewTVar(MyCapability() "ptr", new_value "ptr") [];
   RET_P(tv);
 }
 
@@ -1333,7 +1354,7 @@ readTVarzh_fast
   MAYBE_GC (R1_PTR, readTVarzh_fast); // Call to stmReadTVar may allocate
   trec = StgTSO_trec(CurrentTSO);
   tvar = R1;
-  "ptr" result = foreign "C" stmReadTVar(BaseReg "ptr", trec "ptr", tvar "ptr") [];
+  "ptr" result = foreign "C" stmReadTVar(MyCapability() "ptr", trec "ptr", tvar "ptr") [];
 
   RET_P(result);
 }
@@ -1352,7 +1373,7 @@ writeTVarzh_fast
   trec = StgTSO_trec(CurrentTSO);
   tvar = R1;
   new_value = R2;
-  foreign "C" stmWriteTVar(BaseReg "ptr", trec "ptr", tvar "ptr", new_value "ptr") [];
+  foreign "C" stmWriteTVar(MyCapability() "ptr", trec "ptr", tvar "ptr", new_value "ptr") [];
 
   jump %ENTRY_CODE(Sp(0));
 }
@@ -1439,8 +1460,8 @@ takeMVarzh_fast
     /* args: R1 = MVar closure */
     mvar = R1;
 
-#if defined(SMP)
-    "ptr" info = foreign "C" lockClosure(mvar "ptr");
+#if defined(THREADED_RTS)
+    "ptr" info = foreign "C" lockClosure(mvar "ptr") [];
 #else
     info = GET_INFO(mvar);
 #endif
@@ -1481,7 +1502,8 @@ takeMVarzh_fast
       "ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar),mvar) [];
       StgMVar_head(mvar) = tso;
 #else
-      "ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr") [];
+      "ptr" tso = foreign "C" unblockOne(MyCapability() "ptr", 
+				         StgMVar_head(mvar) "ptr") [];
       StgMVar_head(mvar) = tso;
 #endif
 
@@ -1489,8 +1511,8 @@ takeMVarzh_fast
 	  StgMVar_tail(mvar) = stg_END_TSO_QUEUE_closure;
       }
 
-#if defined(SMP)
-      foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info);
+#if defined(THREADED_RTS)
+      foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info) [];
 #endif
       RET_P(val);
   } 
@@ -1499,8 +1521,8 @@ takeMVarzh_fast
       /* No further putMVars, MVar is now empty */
       StgMVar_value(mvar) = stg_END_TSO_QUEUE_closure;
  
-#if defined(SMP)
-      foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info);
+#if defined(THREADED_RTS)
+      foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info) [];
 #else
       SET_INFO(mvar,stg_EMPTY_MVAR_info);
 #endif
@@ -1518,15 +1540,15 @@ tryTakeMVarzh_fast
 
     mvar = R1;
 
-#if defined(SMP)
-    "ptr" info = foreign "C" lockClosure(mvar "ptr");
+#if defined(THREADED_RTS)
+    "ptr" info = foreign "C" lockClosure(mvar "ptr") [];
 #else
     info = GET_INFO(mvar);
 #endif
 
     if (info == stg_EMPTY_MVAR_info) {
-#if defined(SMP)
-        foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info);
+#if defined(THREADED_RTS)
+        foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info) [];
 #endif
 	/* HACK: we need a pointer to pass back, 
 	 * so we abuse NO_FINALIZER_closure
@@ -1553,23 +1575,24 @@ tryTakeMVarzh_fast
 	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr", mvar "ptr") [];
 	StgMVar_head(mvar) = tso;
 #else
-	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr") [];
+	"ptr" tso = foreign "C" unblockOne(MyCapability() "ptr",
+					   StgMVar_head(mvar) "ptr") [];
 	StgMVar_head(mvar) = tso;
 #endif
 
 	if (StgMVar_head(mvar) == stg_END_TSO_QUEUE_closure) {
 	    StgMVar_tail(mvar) = stg_END_TSO_QUEUE_closure;
 	}
-#if defined(SMP)
-        foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info);
+#if defined(THREADED_RTS)
+        foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info) [];
 #endif
     }
     else 
     {
 	/* No further putMVars, MVar is now empty */
 	StgMVar_value(mvar) = stg_END_TSO_QUEUE_closure;
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info) [];
 #else
 	SET_INFO(mvar,stg_EMPTY_MVAR_info);
 #endif
@@ -1586,8 +1609,8 @@ putMVarzh_fast
     /* args: R1 = MVar, R2 = value */
     mvar = R1;
 
-#if defined(SMP)
-    "ptr" info = foreign "C" lockClosure(mvar "ptr");
+#if defined(THREADED_RTS)
+    "ptr" info = foreign "C" lockClosure(mvar "ptr") [R2];
 #else
     info = GET_INFO(mvar);
 #endif
@@ -1618,10 +1641,10 @@ putMVarzh_fast
       
 #if defined(GRAN) || defined(PAR)
 	/* ToDo: check 2nd arg (mvar) is right */
-	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr",mvar "ptr") [];
+	"ptr" tso = foreign "C" unblockOne(MyCapability() "ptr", StgMVar_head(mvar) "ptr",mvar "ptr") [];
 	StgMVar_head(mvar) = tso;
 #else
-	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr") [];
+	"ptr" tso = foreign "C" unblockOne(MyCapability() "ptr", StgMVar_head(mvar) "ptr") [];
 	StgMVar_head(mvar) = tso;
 #endif
 
@@ -1629,8 +1652,8 @@ putMVarzh_fast
 	    StgMVar_tail(mvar) = stg_END_TSO_QUEUE_closure;
 	}
 
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info) [];
 #endif
 	jump %ENTRY_CODE(Sp(0));
     }
@@ -1639,8 +1662,8 @@ putMVarzh_fast
 	/* No further takes, the MVar is now full. */
 	StgMVar_value(mvar) = R2;
 
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info) [];
 #else
 	SET_INFO(mvar,stg_FULL_MVAR_info);
 #endif
@@ -1658,15 +1681,15 @@ tryPutMVarzh_fast
     /* args: R1 = MVar, R2 = value */
     mvar = R1;
 
-#if defined(SMP)
-    "ptr" info = foreign "C" lockClosure(mvar "ptr");
+#if defined(THREADED_RTS)
+    "ptr" info = foreign "C" lockClosure(mvar "ptr") [R2];
 #else
     info = GET_INFO(mvar);
 #endif
 
     if (info == stg_FULL_MVAR_info) {
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info) [];
 #endif
 	RET_N(0);
     }
@@ -1683,10 +1706,10 @@ tryPutMVarzh_fast
       
 #if defined(GRAN) || defined(PAR)
 	/* ToDo: check 2nd arg (mvar) is right */
-	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr",mvar "ptr") [];
+	"ptr" tso = foreign "C" unblockOne(MyCapability() "ptr", StgMVar_head(mvar) "ptr",mvar "ptr") [];
 	StgMVar_head(mvar) = tso;
 #else
-	"ptr" tso = foreign "C" unblockOne(StgMVar_head(mvar) "ptr") [];
+	"ptr" tso = foreign "C" unblockOne(MyCapability() "ptr", StgMVar_head(mvar) "ptr") [];
 	StgMVar_head(mvar) = tso;
 #endif
 
@@ -1694,24 +1717,23 @@ tryPutMVarzh_fast
 	    StgMVar_tail(mvar) = stg_END_TSO_QUEUE_closure;
 	}
 
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_EMPTY_MVAR_info) [];
 #endif
-	jump %ENTRY_CODE(Sp(0));
     }
     else
     {
 	/* No further takes, the MVar is now full. */
 	StgMVar_value(mvar) = R2;
 
-#if defined(SMP)
-    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info);
+#if defined(THREADED_RTS)
+    	foreign "C" unlockClosure(mvar "ptr", stg_FULL_MVAR_info) [];
 #else
 	SET_INFO(mvar,stg_FULL_MVAR_info);
 #endif
-	jump %ENTRY_CODE(Sp(0));
     }
     
+    RET_N(1);
     /* ToDo: yield afterward for better communication performance? */
 }
 
@@ -1853,7 +1875,7 @@ waitReadzh_fast
     /* args: R1 */
 #ifdef THREADED_RTS
     foreign "C" barf("waitRead# on threaded RTS");
-#endif
+#else
 
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
     StgTSO_why_blocked(CurrentTSO) = BlockedOnRead::I16;
@@ -1862,6 +1884,7 @@ waitReadzh_fast
     // threaded RTS anyway.
     APPEND_TO_BLOCKED_QUEUE(CurrentTSO);
     jump stg_block_noregs;
+#endif
 }
 
 waitWritezh_fast
@@ -1869,7 +1892,7 @@ waitWritezh_fast
     /* args: R1 */
 #ifdef THREADED_RTS
     foreign "C" barf("waitWrite# on threaded RTS");
-#endif
+#else
 
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
     StgTSO_why_blocked(CurrentTSO) = BlockedOnWrite::I16;
@@ -1878,6 +1901,7 @@ waitWritezh_fast
     // threaded RTS anyway.
     APPEND_TO_BLOCKED_QUEUE(CurrentTSO);
     jump stg_block_noregs;
+#endif
 }
 
 
@@ -1893,7 +1917,7 @@ delayzh_fast
 
 #ifdef THREADED_RTS
     foreign "C" barf("delay# on threaded RTS");
-#endif
+#else
 
     /* args: R1 (microsecond delay amount) */
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
@@ -1943,6 +1967,7 @@ while:
     }
     jump stg_block_noregs;
 #endif
+#endif /* !THREADED_RTS */
 }
 
 
@@ -1955,7 +1980,7 @@ asyncReadzh_fast
 
 #ifdef THREADED_RTS
     foreign "C" barf("asyncRead# on threaded RTS");
-#endif
+#else
 
     /* args: R1 = fd, R2 = isSock, R3 = len, R4 = buf */
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
@@ -1963,14 +1988,16 @@ asyncReadzh_fast
 
     /* could probably allocate this on the heap instead */
     "ptr" ares = foreign "C" stgMallocBytes(SIZEOF_StgAsyncIOResult,
-					    stg_asyncReadzh_malloc_str);
-    reqID = foreign "C" addIORequest(R1, 0/*FALSE*/,R2,R3,R4 "ptr");
+					    stg_asyncReadzh_malloc_str)
+			[R1,R2,R3,R4];
+    reqID = foreign "C" addIORequest(R1, 0/*FALSE*/,R2,R3,R4 "ptr") [];
     StgAsyncIOResult_reqID(ares)   = reqID;
     StgAsyncIOResult_len(ares)     = 0;
     StgAsyncIOResult_errCode(ares) = 0;
     StgTSO_block_info(CurrentTSO)  = ares;
     APPEND_TO_BLOCKED_QUEUE(CurrentTSO);
     jump stg_block_async;
+#endif
 }
 
 STRING(stg_asyncWritezh_malloc_str, "asyncWritezh_fast")
@@ -1981,15 +2008,16 @@ asyncWritezh_fast
 
 #ifdef THREADED_RTS
     foreign "C" barf("asyncWrite# on threaded RTS");
-#endif
+#else
 
     /* args: R1 = fd, R2 = isSock, R3 = len, R4 = buf */
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
     StgTSO_why_blocked(CurrentTSO) = BlockedOnWrite::I16;
 
     "ptr" ares = foreign "C" stgMallocBytes(SIZEOF_StgAsyncIOResult,
-					    stg_asyncWritezh_malloc_str);
-    reqID = foreign "C" addIORequest(R1, 1/*TRUE*/,R2,R3,R4 "ptr");
+					    stg_asyncWritezh_malloc_str)
+			[R1,R2,R3,R4];
+    reqID = foreign "C" addIORequest(R1, 1/*TRUE*/,R2,R3,R4 "ptr") [];
 
     StgAsyncIOResult_reqID(ares)   = reqID;
     StgAsyncIOResult_len(ares)     = 0;
@@ -1997,6 +2025,7 @@ asyncWritezh_fast
     StgTSO_block_info(CurrentTSO)  = ares;
     APPEND_TO_BLOCKED_QUEUE(CurrentTSO);
     jump stg_block_async;
+#endif
 }
 
 STRING(stg_asyncDoProczh_malloc_str, "asyncDoProczh_fast")
@@ -2005,20 +2034,26 @@ asyncDoProczh_fast
     W_ ares;
     CInt reqID;
 
+#ifdef THREADED_RTS
+    foreign "C" barf("asyncDoProc# on threaded RTS");
+#else
+
     /* args: R1 = proc, R2 = param */
     ASSERT(StgTSO_why_blocked(CurrentTSO) == NotBlocked::I16);
     StgTSO_why_blocked(CurrentTSO) = BlockedOnDoProc::I16;
 
     /* could probably allocate this on the heap instead */
     "ptr" ares = foreign "C" stgMallocBytes(SIZEOF_StgAsyncIOResult,
-					    stg_asyncDoProczh_malloc_str);
-    reqID = foreign "C" addDoProcRequest(R1 "ptr",R2 "ptr");
+					    stg_asyncDoProczh_malloc_str) 
+				[R1,R2];
+    reqID = foreign "C" addDoProcRequest(R1 "ptr",R2 "ptr") [];
     StgAsyncIOResult_reqID(ares)   = reqID;
     StgAsyncIOResult_len(ares)     = 0;
     StgAsyncIOResult_errCode(ares) = 0;
     StgTSO_block_info(CurrentTSO) = ares;
     APPEND_TO_BLOCKED_QUEUE(CurrentTSO);
     jump stg_block_async;
+#endif
 }
 #endif