Make globals use sharedCAF
[ghc.git] / rts / Updates.cmm
index 6265f90..b3b6b20 100644 (file)
 
 
 #include "Cmm.h"
+#include "rts/prof/LDV.h"
+
 #include "Updates.h"
-#include "StgLdvProf.h"
 
 /*
-  The update frame return address must be *polymorphic*, that means
-  we have to cope with both vectored and non-vectored returns.  This
-  is done by putting the return vector right before the info table, and
-  having a standard direct return address after the info table (pointed
-  to by the return address itself, as usual).
-
-  Each entry in the vector table points to a specialised entry code fragment
-  that knows how to return after doing the update.  It would be possible to
-  use a single generic piece of code that simply entered the return value
-  to return, but it's quicker this way.  The direct return code of course
-  just does another direct return when it's finished.
-*/
-
-/* on entry to the update code
-   (1) R1 points to the closure being returned
-   (2) Sp points to the update frame
-*/
-
-/* The update fragment has been tuned so as to generate good
-   code with gcc, which accounts for some of the strangeness in the
-   way it is written.  
-
-   In particular, the JMP_(ret) bit is passed down and pinned on the
-   end of each branch (there end up being two major branches in the
-   code), since we don't mind duplicating this jump.
-*/
-
-#define UPD_FRAME_ENTRY_TEMPLATE(label,ind_info,ret)                   \
-        label                                                          \
-       {                                                               \
-          W_ updatee;                                                  \
-                                                                       \
-          updatee = StgUpdateFrame_updatee(Sp);                                \
-                                                                       \
-         /* remove the update frame from the stack */                  \
-         Sp = Sp + SIZEOF_StgUpdateFrame;                              \
-                                                                       \
-         /* 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, ind_info, R1, jump (ret));              \
-       }
+ * The update code is PERFORMANCE CRITICAL, if you make any changes
+ * here make sure you eyeball the assembly and check that the fast
+ * path (update in generation 0) is optimal.
+ *
+ * The return(ret) bit is passed down and pinned on the end of each
+ * branch (there end up being two major branches in the code), since
+ * we don't mind duplicating this jump.
+ */
+INFO_TABLE_RET ( stg_upd_frame, UPDATE_FRAME,
+                 UPDATE_FRAME_FIELDS(W_,P_,info_ptr,_ccs,_unused,updatee) )
+    return (P_ ret) /* the closure being returned */
+{
+    ASSERT(HpAlloc == 0); // Note [HpAlloc]
 
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_0_ret,stg_IND_0_info,%RET_VEC(Sp(0),0))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_1_ret,stg_IND_1_info,%RET_VEC(Sp(0),1))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_2_ret,stg_IND_2_info,%RET_VEC(Sp(0),2))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_3_ret,stg_IND_3_info,%RET_VEC(Sp(0),3))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_4_ret,stg_IND_4_info,%RET_VEC(Sp(0),4))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_5_ret,stg_IND_5_info,%RET_VEC(Sp(0),5))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_6_ret,stg_IND_6_info,%RET_VEC(Sp(0),6))
-UPD_FRAME_ENTRY_TEMPLATE(stg_upd_frame_7_ret,stg_IND_7_info,%RET_VEC(Sp(0),7))
+    /* ToDo: it might be a PAP, so we should check... */
+    TICK_UPD_CON_IN_NEW(sizeW_fromITBL(%GET_STD_INFO(updatee)));
 
-#if MAX_VECTORED_RTN > 8
-#error MAX_VECTORED_RTN has changed: please modify stg_upd_frame too.
-#endif
+    updateWithIndirection(updatee, ret, return (ret));
+}
 
 /*
-  Make sure this table is big enough to handle the maximum vectored
-  return size!
-  */
-
-#if defined(PROFILING)
-#define UPD_FRAME_BITMAP 3
-#define UPD_FRAME_WORDS  3
-#else
-#define UPD_FRAME_BITMAP 0
-#define UPD_FRAME_WORDS  1
-#endif
-
-/* this bitmap indicates that the first word of an update frame is a
- * non-pointer - this is the update frame link.  (for profiling,
- * there's a cost-centre-stack in there too).
+ * An update frame where the updatee has been replaced by a BLACKHOLE
+ * closure by threadPaused.  We may have threads to wake up, and we
+ * also have to check whether the blackhole has been updated by
+ * another thread in the meantime.
  */
+INFO_TABLE_RET ( stg_marked_upd_frame, UPDATE_FRAME,
+                 UPDATE_FRAME_FIELDS(W_,P_,info_ptr,_ccs,_unused,updatee) )
+    return (P_ ret) /* the closure being returned */
+{
+    W_ v;
 
-INFO_TABLE_RET( stg_upd_frame, 
-           UPD_FRAME_WORDS, UPD_FRAME_BITMAP, UPDATE_FRAME,
-           stg_upd_frame_0_ret,
-           stg_upd_frame_1_ret,
-           stg_upd_frame_2_ret,
-           stg_upd_frame_3_ret,
-           stg_upd_frame_4_ret,
-           stg_upd_frame_5_ret,
-           stg_upd_frame_6_ret,
-           stg_upd_frame_7_ret
-           )
-UPD_FRAME_ENTRY_TEMPLATE(,stg_IND_direct_info,%ENTRY_CODE(Sp(0)))
-
-
-INFO_TABLE_RET( stg_marked_upd_frame, 
-           UPD_FRAME_WORDS, UPD_FRAME_BITMAP, UPDATE_FRAME,
-           stg_upd_frame_0_ret,
-           stg_upd_frame_1_ret,
-           stg_upd_frame_2_ret,
-           stg_upd_frame_3_ret,
-           stg_upd_frame_4_ret,
-           stg_upd_frame_5_ret,
-           stg_upd_frame_6_ret,
-           stg_upd_frame_7_ret
-           )
-UPD_FRAME_ENTRY_TEMPLATE(,stg_IND_direct_info,%ENTRY_CODE(Sp(0)))
+    ASSERT(HpAlloc == 0); // Note [HpAlloc]
 
-/*-----------------------------------------------------------------------------
-  Seq frames 
+    // we know the closure is a BLACKHOLE
+    v = StgInd_indirectee(updatee);
 
-  We don't have a primitive seq# operator: it is just a 'case'
-  expression whose scrutinee has either a polymorphic or function type
-  (constructor types can be handled by normal 'case' expressions).
+    if (GETTAG(v) != 0) {
+        // updated by someone else: discard our value and use the
+        // other one to increase sharing, but check the blocking
+        // queues to see if any threads were waiting on this BLACKHOLE.
+        ccall checkBlockingQueues(MyCapability() "ptr", CurrentTSO "ptr");
+        return (v);
+    }
 
-  To handle a polymorphic/function typed seq, we push a SEQ frame on
-  the stack.  This is a polymorphic activation record that just pops
-  itself and returns (in a non-vectored way) when entered.  The
-  purpose of the SEQ frame is to avoid having to make a polymorphic return
-  point for each polymorphic case expression.  
+    // common case: it is still our BLACKHOLE
+    if (v == CurrentTSO) {
+        updateWithIndirection(updatee, ret, return (ret));
+    }
 
-  Another way of looking at it: the SEQ frame turns a vectored return
-  into a direct one.
-  -------------------------------------------------------------------------- */
+    // The other cases are all handled by the generic code
+    ccall updateThunk (MyCapability() "ptr", CurrentTSO "ptr",
+                       updatee "ptr", ret "ptr");
 
-#if MAX_VECTORED_RTN > 8
-#error MAX_VECTORED_RTN has changed: please modify stg_seq_frame too.
-#endif
+    return (ret);
+}
 
-INFO_TABLE_RET( stg_seq_frame, 0/* words */, 0/* bitmap */, RET_SMALL,
-       RET_LBL(stg_seq_frame), /* 0 */
-       RET_LBL(stg_seq_frame), /* 1 */
-       RET_LBL(stg_seq_frame), /* 2 */
-       RET_LBL(stg_seq_frame), /* 3 */
-       RET_LBL(stg_seq_frame), /* 4 */
-       RET_LBL(stg_seq_frame), /* 5 */
-       RET_LBL(stg_seq_frame), /* 6 */
-       RET_LBL(stg_seq_frame)  /* 7 */
-       )
+/*
+ * Special update frame code for CAFs and eager-blackholed thunks: it
+ * knows how to update blackholes, but is distinct from
+ * stg_marked_upd_frame so that lazy blackholing won't treat it as the
+ * high watermark.
+ */
+INFO_TABLE_RET ( stg_bh_upd_frame, UPDATE_FRAME,
+                 UPDATE_FRAME_FIELDS(W_,P_,info_ptr,ccs,_unused,updatee) )
+    return (P_ ret) /* the closure being returned */
 {
-   Sp_adj(1);
-   jump %ENTRY_CODE(Sp(0));
+    // This all compiles away to a single jump instruction (sigh)
+    jump RET_LBL(stg_marked_upd_frame)
+        ( UPDATE_FRAME_FIELDS(,,info_ptr,ccs,_unused,updatee) )
+        (ret);
 }
+
+/* Note [HpAlloc]
+ *
+ * HpAlloc is required to be zero unless we just bumped Hp and failed
+ * the heap check: see HeapStackCheck.cmm.  Failures that result from
+ * HpAlloc being non-zero are very hard to track down, because they
+ * manifest as spurious heap corruption that happens only with +RTS
+ * -N2 or greater (because then we have a lot more
+ * interruptCapability() calls happening).  Hence, we assert
+ * HpAlloc==0 as often as possible, and in the update code is a good
+ * place to do that.
+ */