Remove StickyFlags now that all surprise flags are sticky

Summary:
Now that all surprise flags are individually cleared at their handling sites, the StickyFlags concept is redundant — every flag is sticky.

This removes the StickyFlags enum value and simplifies fetchAndClearSurpriseFlags() into fetchSurpriseFlags(), which is now a plain atomic load instead of a fetch_and that preserved sticky flags (which was all of them, making it a no-op). The conditional `if (StickyFlags & Flag)` guards in handle_request_surprise() are also removed since they were always true.

Reviewed By: ricklavoie

Differential Revision: D92776193

fbshipit-source-id: ff146afe88a60416b8da3563995e8e7b7fd99fa2

Author: jano

hphp/runtime/base/request-info.cpp

@@ -272,7 +272,7 @@ size_t handle_request_surprise(c_WaitableWaitHandle* wh, size_t mask) {
   auto& info = RI();
   auto& p = info.m_reqInjectionData;
 
-  auto flags = fetchAndClearSurpriseFlags() & mask;
+  auto flags = fetchSurpriseFlags() & mask;
   auto const debugging = p.getDebuggerAttached();
 
   // Start with any pending exception that might be on the request.
@@ -321,7 +321,6 @@ size_t handle_request_surprise(c_WaitableWaitHandle* wh, size_t mask) {
   }
 
   if (flags & MemExceededFlag) {
-    assertx(MemExceededFlag & StickyFlags);
     if (p.hostOOMFlag() && !pendingException) {
       // When the host is running out of memory, don't abort all requests.
       // Instead, only kill a request if it uses a nontrivial amount of memory.
@@ -354,19 +353,13 @@ size_t handle_request_surprise(c_WaitableWaitHandle* wh, size_t mask) {
     // we'll disable specific flags to make sure Xenon (or other)
     // re-entrant code doesn't interfere with debugging.
     if (flags & XenonSignalFlag) {
-      if (StickyFlags & XenonSignalFlag) {
-        clearSurpriseFlag(XenonSignalFlag);
-      }
+      clearSurpriseFlag(XenonSignalFlag);
     }
     if (flags & HeapSamplingFlag) {
-      if (StickyFlags & HeapSamplingFlag) {
-        clearSurpriseFlag(HeapSamplingFlag);
-      }
+      clearSurpriseFlag(HeapSamplingFlag);
     }
     if (flags & IntervalTimerFlag) {
-      if (StickyFlags & IntervalTimerFlag) {
-        clearSurpriseFlag(IntervalTimerFlag);
-      }
+      clearSurpriseFlag(IntervalTimerFlag);
     }
   }
   if (flags & CLIClientTerminated) {
@@ -377,9 +370,7 @@ size_t handle_request_surprise(c_WaitableWaitHandle* wh, size_t mask) {
     }
   }
   if (flags & PendingGCFlag) {
-    if (StickyFlags & PendingGCFlag) {
-      clearSurpriseFlag(PendingGCFlag);
-    }
+    clearSurpriseFlag(PendingGCFlag);
     if (tl_heap->isGCEnabled()) {
       tl_heap->collect("surprise");
     } else {
@@ -392,9 +383,7 @@ size_t handle_request_surprise(c_WaitableWaitHandle* wh, size_t mask) {
   }
 
   if (flags & PendingPerfEventFlag) {
-    if (StickyFlags & PendingPerfEventFlag) {
-      clearSurpriseFlag(PendingPerfEventFlag);
-    }
+    clearSurpriseFlag(PendingPerfEventFlag);
     perf_event_consume(record_perf_mem_event);
   }
 

hphp/runtime/base/surprise-flags.h

@@ -73,32 +73,12 @@ enum SurpriseFlag : size_t {
   /* Set when executing a CLI-server request and the client has vanished. */
   CLIClientTerminated = 1ull << 63,
 
-  /*
-   * Flags that shouldn't be cleared by fetchAndClearSurpriseFlags, because
-   * fetchAndClearSurpriseFlags is only supposed to touch flags related to
-   * PHP-visible signals/exceptions and resource limits.
-   */
   ResourceFlags =
     MemExceededFlag |
     TimedOutFlag |
     PendingGCFlag |
     PendingPerfEventFlag,
 
-  StickyFlags =
-    AsyncEventHookFlag |
-    DebuggerHookFlag |
-    DebuggerSignalFlag |
-    EventHookFlag |
-    InterceptFlag |
-    PendingExceptionFlag |
-    SignaledFlag |
-    XenonSignalFlag |
-    HeapSamplingFlag |
-    IntervalTimerFlag |
-    MemThresholdFlag |
-    CLIClientTerminated |
-    ResourceFlags,
-
   /*
    * Flags that should only be checked at MemoryManager safe points.
    */
@@ -174,9 +154,9 @@ inline void clearSurpriseFlag(SurpriseFlag flag) {
   stackLimitAndSurprise().fetch_and(~flag);
 }
 
-inline size_t fetchAndClearSurpriseFlags() {
-  return stackLimitAndSurprise().
-    fetch_and(StickyFlags | kSurpriseFlagStackMask) & kSurpriseFlagMask;
+inline size_t fetchSurpriseFlags() {
+  return stackLimitAndSurprise().load(std::memory_order_acquire) &
+    kSurpriseFlagMask;
 }
 
 ///////////////////////////////////////////////////////////////////////////////