Use local mut lists in UPD_IND(), also clean up Updates.h

diff --git a/rts/Interpreter.c b/rts/Interpreter.c
index d1b11ae..9071912 100644 (file)
--- a/rts/Interpreter.c
+++ b/rts/Interpreter.c
@@ -443,7 +443,7 @@ do_return:
         // to a PAP by the GC, violating the invariant that PAPs
         // always contain a tagged pointer to the function.
        INTERP_TICK(it_retto_UPDATE);
-       UPD_IND(((StgUpdateFrame *)Sp)->updatee, tagged_obj); 
+       UPD_IND(cap, ((StgUpdateFrame *)Sp)->updatee, tagged_obj); 
        Sp += sizeofW(StgUpdateFrame);
        goto do_return;
 

diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index 15e6f8f..ca5e5ea 100644 (file)
--- a/rts/RaiseAsync.c
+++ b/rts/RaiseAsync.c
@@ -834,7 +834,7 @@ 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.
-                UPD_IND(((StgUpdateFrame *)frame)->updatee, (StgClosure *)ap);
+                UPD_IND(cap, ((StgUpdateFrame *)frame)->updatee, (StgClosure *)ap);
             }
 
            sp += sizeofW(StgUpdateFrame) - 1;

diff --git a/rts/Schedule.c b/rts/Schedule.c
index 72086e8..7c1d9fb 100644 (file)
--- a/rts/Schedule.c
+++ b/rts/Schedule.c
@@ -2550,7 +2550,8 @@ raiseExceptionHelper (StgRegTable *reg, StgTSO *tso, StgClosure *exception)
                SET_HDR(raise_closure, &stg_raise_info, CCCS);
                raise_closure->payload[0] = exception;
            }
-           UPD_IND(((StgUpdateFrame *)p)->updatee,(StgClosure *)raise_closure);
+           UPD_IND(cap, ((StgUpdateFrame *)p)->updatee,
+                    (StgClosure *)raise_closure);
            p = next;
            continue;
 

diff --git a/rts/ThreadPaused.c b/rts/ThreadPaused.c
index 96a2367..93ec960 100644 (file)
--- a/rts/ThreadPaused.c
+++ b/rts/ThreadPaused.c
@@ -28,7 +28,7 @@
 struct stack_gap { StgWord gap_size; struct stack_gap *next_gap; };
 
 static void
-stackSqueeze(StgTSO *tso, StgPtr bottom)
+stackSqueeze(Capability *cap, StgTSO *tso, StgPtr bottom)
 {
     StgPtr frame;
     rtsBool prev_was_update_frame;
@@ -75,7 +75,7 @@ stackSqueeze(StgTSO *tso, StgPtr bottom)
                 * screw us up if we don't check.
                 */
                if (upd->updatee != updatee && !closure_IND(upd->updatee)) {
-                   UPD_IND(upd->updatee, updatee);
+                   UPD_IND(cap, upd->updatee, updatee);
                }
 
                // now mark this update frame as a stack gap.  The gap
@@ -316,7 +316,7 @@ end:
     // number of stack words we squeeze away by doing so.
     if (RtsFlags.GcFlags.squeezeUpdFrames == rtsTrue &&
        ((weight <= 5 && words_to_squeeze > 0) || weight < words_to_squeeze)) {
-       stackSqueeze(tso, (StgPtr)frame);
+       stackSqueeze(cap, tso, (StgPtr)frame);
         tso->flags |= TSO_SQUEEZED;
         // This flag tells threadStackOverflow() that the stack was
         // squeezed, because it may not need to be expanded.

diff --git a/rts/Updates.cmm b/rts/Updates.cmm
index fadf63b..e0fd7c3 100644 (file)
--- a/rts/Updates.cmm
+++ b/rts/Updates.cmm
@@ -42,7 +42,10 @@
          /* ToDo: it might be a PAP, so we should check... */          \
          TICK_UPD_CON_IN_NEW(sizeW_fromITBL(%GET_STD_INFO(updatee)));  \
                                                                        \
-         UPD_SPEC_IND(updatee, stg_IND_direct_info, R1, jump %ENTRY_CODE(Sp(0))); \
+          updateWithIndirection(stg_IND_direct_info,                    \
+                               updatee,                                \
+                               R1,                                     \
+                               jump %ENTRY_CODE(Sp(0)));               \
        }
 
 #if defined(PROFILING)

diff --git a/rts/Updates.h b/rts/Updates.h
index bf4f89d..2b3c35d 100644 (file)
--- a/rts/Updates.h
+++ b/rts/Updates.h
@@ -15,62 +15,6 @@ BEGIN_RTS_PRIVATE
 
 /* -----------------------------------------------------------------------------
    Updates
-
-   We have two layers of update macros.  The top layer, UPD_IND() and
-   friends perform all the work of an update.  In detail:
-
-      - if the closure being updated is a blocking queue, then all the
-        threads waiting on the blocking queue are updated.
-
-      - then the lower level updateWithIndirection() macro is invoked 
-        to actually replace the closure with an indirection (see below).
-
-   -------------------------------------------------------------------------- */
-
-#  define SEMI ;
-# define UPD_IND(updclosure, heapptr) \
-   UPD_REAL_IND(updclosure,INFO_PTR(stg_IND_info),heapptr,SEMI)
-# define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
-   UPD_REAL_IND(updclosure,ind_info,heapptr,and_then)
-
-/* These macros have to work in both C and C--, so here's the
- * impedance matching:
- */
-#ifdef CMINUSMINUS
-#define BLOCK_BEGIN
-#define BLOCK_END
-#define INFO_PTR(info)      info
-#else
-#define BLOCK_BEGIN         {
-#define BLOCK_END           }
-#define INFO_PTR(info)      &info
-#define StgBlockingQueue_blocking_queue(closure) \
-    (((StgBlockingQueue *)closure)->blocking_queue)
-#endif
-
-/* krc: there used to be an UPD_REAL_IND and an
-   UPD_PERM_IND, the latter of which was used for
-   ticky and cost-centre profiling.
-   for now, we just have UPD_REAL_IND. */
-#define UPD_REAL_IND(updclosure, ind_info, heapptr, and_then)  \
-        BLOCK_BEGIN                                            \
-       updateWithIndirection(ind_info,                         \
-                             updclosure,                       \
-                             heapptr,                          \
-                             and_then);                        \
-       BLOCK_END
-
-/* -----------------------------------------------------------------------------
-   Awaken any threads waiting on a blocking queue (BLACKHOLE_BQ).
-   -------------------------------------------------------------------------- */
-
-/* -----------------------------------------------------------------------------
-   Updates: lower-level macros which update a closure with an
-   indirection to another closure.
-
-   There are several variants of this code.
-
-       PROFILING:
    -------------------------------------------------------------------------- */
 
 /* LDV profiling:
@@ -182,7 +126,7 @@ no_slop:
  * invert the optimisation.  Grrrr --SDM).
  */
 #ifdef CMINUSMINUS
-#define generation(n) (W_[generations] + n*SIZEOF_generation)
+
 #define updateWithIndirection(ind_info, p1, p2, and_then)      \
     W_ bd;                                                     \
                                                                \
@@ -203,33 +147,42 @@ no_slop:
       TICK_UPD_NEW_IND();                                      \
       and_then;                                                        \
   }
-#else
-#define updateWithIndirection(ind_info, p1, p2, and_then)      \
-  {                                                            \
-    bdescr *bd;                                                        \
-                                                               \
-    ASSERT( (P_)p1 != (P_)p2 );                                 \
-    /* not necessarily true: ASSERT( !closure_IND(p1) ); */     \
-    /* occurs in RaiseAsync.c:raiseAsync() */                   \
-    DEBUG_FILL_SLOP(p1);                                       \
-    LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                     \
-    ((StgInd *)p1)->indirectee = p2;                           \
-    write_barrier();                                           \
-    bd = Bdescr((P_)p1);                                       \
-    if (bd->gen_no != 0) {                                     \
-      recordMutableGenLock(p1, bd->gen_no);                    \
-      SET_INFO(p1, &stg_IND_OLDGEN_info);                      \
-      TICK_UPD_OLD_IND();                                      \
-      and_then;                                                        \
-    } else {                                                   \
-      SET_INFO(p1, ind_info);                                  \
-      LDV_RECORD_CREATE(p1);                                   \
-      TICK_UPD_NEW_IND();                                      \
-      and_then;                                                        \
-    }                                                          \
-  }
+
+#else /* !CMINUSMINUS */
+
+INLINE_HEADER void updateWithIndirection (Capability *cap, 
+                                          const StgInfoTable *ind_info, 
+                                          StgClosure *p1, 
+                                          StgClosure *p2)
+{
+    bdescr *bd;
+    
+    ASSERT( (P_)p1 != (P_)p2 );
+    /* not necessarily true: ASSERT( !closure_IND(p1) ); */
+    /* occurs in RaiseAsync.c:raiseAsync() */
+    DEBUG_FILL_SLOP(p1);
+    LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);
+    ((StgInd *)p1)->indirectee = p2;
+    write_barrier();
+    bd = Bdescr((StgPtr)p1);
+    if (bd->gen_no != 0) {
+        recordMutableCap(p1, cap, bd->gen_no);
+        SET_INFO(p1, &stg_IND_OLDGEN_info);
+        TICK_UPD_OLD_IND();
+    } else {
+        SET_INFO(p1, ind_info);
+        LDV_RECORD_CREATE(p1);
+        TICK_UPD_NEW_IND();
+    }
+}
+
 #endif /* CMINUSMINUS */
 
+#define UPD_IND(cap, updclosure, heapptr)        \
+    updateWithIndirection(cap, &stg_IND_info,    \
+                          updclosure,            \
+                          heapptr)
+
 #ifndef CMINUSMINUS
 END_RTS_PRIVATE
 #endif