add RDS logging by category on OOMs and via admin endpoint

Summary: TSIA: expose a little more to allow userland perf work.

Reviewed By: paulbiss

Differential Revision: D95246808

fbshipit-source-id: 6c1ef1b0f6b8a0860ec55f2da617f19fe23d4176

Author: nt591

hphp/doc/configs.specification

@@ -910,6 +910,12 @@ The format can be found in hphp/tools/configs/generate_configs.rs
 
 - double Eval.RDSReorderThreshold = 0.0005, UNKNOWN
 
+- bool Eval.LogRDSOnOOM = false, nzthomas
+
+  When enabled, log a per-category RDS usage breakdown before crashing on RDS
+  OOM. Iterates the RDS symbol table under lock, so should not be enabled in
+  production unless actively debugging RDS exhaustion.
+
 - uint32_t Eval.ProfileGlobalsLimit = 200, UNKNOWN
 
 - double Eval.ProfileGlobalsSlowExitThreshold = 0.98, UNKNOWN

hphp/runtime/base/rds.cpp

@@ -15,6 +15,7 @@
 */
 #include "hphp/runtime/base/rds.h"
 
+#include <algorithm>
 #include <atomic>
 #include <cassert>
 #include <cstdio>
@@ -153,10 +154,29 @@ std::string profilingKeyForSymbol(const Symbol& s) {
   return symbol_kind(s) + "->" + symbol_rep(s);
 }
 
+/*
+ * Cache of per-category ServiceData counters to avoid repeated lookups.
+ */
+folly_concurrent_hash_map_simd<std::string, ServiceData::ExportedCounter*>
+  s_categoryCounters;
+
+ServiceData::ExportedCounter* getCategoryCounter(const std::string& kind) {
+  auto it = s_categoryCounters.find(kind);
+  if (it != s_categoryCounters.end()) return it->second;
+  auto counter = ServiceData::createCounter("admin.rds_usage." + kind);
+  s_categoryCounters.insert(kind, counter);
+  return counter;
+}
+
+static auto s_anonymousCounter =
+  ServiceData::createCounter("admin.rds_usage.Anonymous");
+
 }
 
 //////////////////////////////////////////////////////////////////////
 
+namespace { void logRDSUsageBreakdown(); }
+
 namespace detail {
 
 static auto byte_counter = ServiceData::createCounter("admin.vm-tcspace.RDS");
@@ -348,6 +368,9 @@ Handle alloc(Mode mode, size_t numBytes,
             s_normal_frontier - oldFrontier
           );
         }
+        if (UNLIKELY(s_normal_frontier >= s_local_frontier)) {
+          if (Cfg::Eval::LogRDSOnOOM) logRDSUsageBreakdown();
+        }
         always_assert_flog(
           s_normal_frontier < s_local_frontier,
           "Ran out of RDS space (mode=Normal)"
@@ -397,6 +420,7 @@ Handle alloc(Mode mode, size_t numBytes,
       // We reserved plenty of space in s_persistent_free_lists in the beginning
       // of the process, but maybe it is time to increase the size in the
       // config.
+      if (Cfg::Eval::LogRDSOnOOM) logRDSUsageBreakdown();
       always_assert_flog(
         false,
         "Ran out of RDS space (mode=Persistent)"
@@ -416,6 +440,9 @@ Handle alloc(Mode mode, size_t numBytes,
         frontier -= numBytes;
         frontier &= ~(align - 1);
 
+        if (UNLIKELY(frontier < s_normal_frontier)) {
+          if (Cfg::Eval::LogRDSOnOOM) logRDSUsageBreakdown();
+        }
         always_assert_flog(
           frontier >= s_normal_frontier,
           "Ran out of RDS space (mode=Local)"
@@ -443,7 +470,11 @@ Handle allocUnlocked(Mode mode, size_t numBytes,
                      size_t align, type_scan::Index tyIndex,
                      const Symbol* symbol) {
   Guard g(s_allocMutex);
-  return alloc(mode, numBytes, align, tyIndex, symbol);
+  auto const handle = alloc(mode, numBytes, align, tyIndex, symbol);
+  if (!symbol) {
+    s_anonymousCounter->addValue(numBytes);
+  }
+  return handle;
 }
 
 Handle bindImpl(Symbol key, Mode mode, size_t sizeBytes,
@@ -456,6 +487,7 @@ Handle bindImpl(Symbol key, Mode mode, size_t sizeBytes,
 
   auto const handle = alloc(mode, sizeBytes, align, tyIndex, &key);
   recordRds(handle, sizeBytes, key);
+  getCategoryCounter(symbol_kind(key))->addValue(sizeBytes);
 
   if (shouldProfileAccesses() && !std::visit(IsProfile(), key)) {
     // Allocate an integer in the local section to profile this
@@ -504,6 +536,7 @@ void bindOnLinkImpl(std::atomic<Handle>& handle,
     // we flipped it from kUninitHandle, so we get to fill in the value.
     auto const h = allocUnlocked(mode, size, align, tsi, &sym);
     recordRds(h, size, sym);
+    getCategoryCounter(symbol_kind(sym))->addValue(size);
 
     if (shouldProfileAccesses() && !std::visit(IsProfile(), sym)) {
       // Allocate an integer in the local section to profile this
@@ -733,6 +766,98 @@ size_t usedPersistentBytes() {
   return s_persistent_usage;
 }
 
+namespace {
+
+std::vector<CategoryUsage> usageByCategoryLocked() {
+  struct Agg {
+    size_t bytes{0};
+    size_t count{0};
+  };
+  using Key = std::pair<std::string, Mode>;
+  std::map<Key, Agg> catMap;
+
+  size_t normalAttributed = 0;
+  size_t localAttributed = 0;
+  size_t persistentAttributed = 0;
+
+  s_linkTable.rehash();
+  for (auto const& entry : s_linkTable) {
+    auto const& sym = entry.first;
+    auto const h = entry.second.handle;
+    auto const sz = entry.second.size;
+    auto const kind = symbol_kind(sym);
+
+    Mode mode;
+    if (isPersistentHandle(h)) {
+      mode = Mode::Persistent;
+      persistentAttributed += sz;
+    } else if (isNormalHandle(h)) {
+      mode = Mode::Normal;
+      normalAttributed += sz;
+    } else {
+      mode = Mode::Local;
+      localAttributed += sz;
+    }
+
+    auto& agg = catMap[{kind, mode}];
+    agg.bytes += sz;
+    agg.count++;
+  }
+
+  auto const normalTotal = usedBytes();
+  auto const localTotal = usedLocalBytes();
+  auto const persistentTotal = usedPersistentBytes();
+
+  if (normalTotal > normalAttributed) {
+    catMap[{"Anonymous", Mode::Normal}].bytes += normalTotal - normalAttributed;
+  }
+  if (localTotal > localAttributed) {
+    catMap[{"Anonymous", Mode::Local}].bytes += localTotal - localAttributed;
+  }
+  if (persistentTotal > persistentAttributed) {
+    catMap[{"Anonymous", Mode::Persistent}].bytes +=
+      persistentTotal - persistentAttributed;
+  }
+
+  std::vector<CategoryUsage> result;
+  result.reserve(catMap.size());
+  for (auto& [key, agg] : catMap) {
+    result.push_back({key.first, agg.bytes, agg.count, key.second});
+  }
+  std::sort(result.begin(), result.end(),
+            [](const CategoryUsage& a, const CategoryUsage& b) {
+              return a.bytes > b.bytes;
+            });
+  return result;
+}
+
+void logRDSUsageBreakdown() {
+  auto const usage = usageByCategoryLocked();
+  Logger::FError("RDS usage breakdown:");
+  Logger::FError("  Normal:     {} bytes used", usedBytes());
+  Logger::FError("  Local:      {} bytes used", usedLocalBytes());
+  Logger::FError("  Persistent: {} bytes used", usedPersistentBytes());
+  for (auto const& cat : usage) {
+    auto const modeName = [&] {
+      switch (cat.mode) {
+        case Mode::Normal:     return "Normal";
+        case Mode::Local:      return "Local";
+        case Mode::Persistent: return "Persistent";
+        default:               return "Unknown";
+      }
+    }();
+    Logger::FError("  {:>30s} ({:10s}): {:>10} bytes, {:>6} entries",
+                   cat.category, modeName, cat.bytes, cat.count);
+  }
+}
+
+} // namespace
+
+std::vector<CategoryUsage> usageByCategory() {
+  Guard g(s_allocMutex);
+  return usageByCategoryLocked();
+}
+
 folly::Range<const char*> normalSection() {
   return {(const char*)tl_base, usedBytes()};
 }

hphp/runtime/base/rds.h

@@ -29,6 +29,7 @@
 #include <cstdlib>
 #include <string>
 #include <type_traits>
+#include <vector>
 
 #ifndef RDS_FIXED_PERSISTENT_BASE
 // If RDS_FIXED_PERSISTENT_BASE is defined from compiler command line, don't
@@ -192,6 +193,17 @@ constexpr bool pure(Mode mask) {
   return !(static_cast<ModeU>(mask) & (static_cast<ModeU>(mask) - 1));
 }
 
+/*
+ * Per-category RDS usage breakdown.
+ */
+struct CategoryUsage {
+  std::string category;
+  size_t bytes;
+  size_t count;
+  Mode mode;
+};
+std::vector<CategoryUsage> usageByCategory();
+
 /*
  * Handles into Request Data Segment.
  *

hphp/runtime/server/admin-request-handler.cpp

@@ -431,6 +431,7 @@ void AdminRequestHandler::handleRequest(Transport *transport) {
 #endif
         "/vm-tcspace:      show space used by translator caches\n"
         "/vm-tcaddr:       show addresses of translation cache sections\n"
+        "/vm-rds-usage:    show RDS usage breakdown by category (JSON)\n"
         "/vm-dump-tc:      dump translation cache to /tmp/tc_dump_a and\n"
         "                  /tmp/tc_dump_astub\n"
         "/vm-namedentities:show combined size of the NamedType and\n"
@@ -519,6 +520,7 @@ void AdminRequestHandler::handleRequest(Transport *transport) {
           (strncmp(cmd.c_str(), "static-strings", 14) == 0) ||
           cmd == "hugepage" || cmd == "pcre-cache-size" ||
           cmd == "vm-tcspace" || cmd == "vm-tcaddr" ||
+          cmd == "vm-rds-usage" ||
           cmd == "vm-namedentities" || cmd == "jemalloc-stats") {
         needs_password = false;
       }
@@ -1467,6 +1469,11 @@ bool AdminRequestHandler::handleVMRequest(const std::string &cmd,
     transport->sendString(jit::tc::getTCSpace());
     return true;
   }
+  if (cmd == "vm-rds-usage") {
+    transport->replaceHeader("Content-Type", "application/json");
+    transport->sendString(jit::tc::getRDSUsageJSON());
+    return true;
+  }
   if (cmd == "vm-tcaddr") {
     transport->sendString(jit::tc::getTCAddrs());
     return true;

hphp/runtime/vm/jit/tc-info.cpp

@@ -17,6 +17,7 @@
 #include "hphp/runtime/vm/jit/tc.h"
 #include "hphp/runtime/vm/jit/tc-internal.h"
 
+#include "hphp/runtime/base/rds.h"
 #include "hphp/runtime/vm/runtime-compiler.h"
 #include "hphp/runtime/vm/jit/code-cache.h"
 #include "hphp/runtime/vm/jit/mcgen.h"
@@ -28,6 +29,8 @@
 #include "hphp/util/build-info.h"
 
 #include <folly/Format.h>
+#include <folly/json/dynamic.h>
+#include <folly/json/json.h>
 
 #include <algorithm>
 #include <string>
@@ -260,4 +263,57 @@ std::vector<TCMemInfo> getTCMemoryUsage() {
   return ret;
 }
 
+std::string getRDSUsageJSON() {
+  auto const normalCap = Cfg::Eval::RDSSize * 3 / 4;
+  auto const localCap = normalCap;
+  auto const persistentCap = Cfg::Eval::RDSSize / 4;
+
+  folly::dynamic summary = folly::dynamic::object
+    ("normal", folly::dynamic::object
+      ("used", rds::usedBytes())
+      ("capacity", normalCap))
+    ("local", folly::dynamic::object
+      ("used", rds::usedLocalBytes())
+      ("capacity", localCap))
+    ("persistent", folly::dynamic::object
+      ("used", rds::usedPersistentBytes())
+      ("capacity", persistentCap));
+
+  auto const categories = rds::usageByCategory();
+  folly::dynamic catArray = folly::dynamic::array;
+  for (auto const& cat : categories) {
+    auto const modeName = [&] {
+      switch (cat.mode) {
+        case rds::Mode::Normal:     return "Normal";
+        case rds::Mode::Local:      return "Local";
+        case rds::Mode::Persistent: return "Persistent";
+        default:                    return "Unknown";
+      }
+    }();
+
+    size_t regionUsed = 0;
+    switch (cat.mode) {
+      case rds::Mode::Normal:     regionUsed = rds::usedBytes(); break;
+      case rds::Mode::Local:      regionUsed = rds::usedLocalBytes(); break;
+      case rds::Mode::Persistent: regionUsed = rds::usedPersistentBytes(); break;
+      default: break;
+    }
+    double pct = regionUsed > 0
+      ? 100.0 * cat.bytes / regionUsed
+      : 0.0;
+
+    catArray.push_back(folly::dynamic::object
+      ("category", cat.category)
+      ("mode", modeName)
+      ("bytes", cat.bytes)
+      ("count", cat.count)
+      ("pct_of_region", pct));
+  }
+
+  folly::dynamic result = folly::dynamic::object
+    ("summary", std::move(summary))
+    ("categories", std::move(catArray));
+  return folly::toJson(result);
+}
+
 }

hphp/runtime/vm/jit/tc.h

@@ -450,6 +450,11 @@ std::vector<UsageInfo> getUsageInfo();
  */
 std::string getTCSpace();
 
+/*
+ * Return RDS usage breakdown as a JSON string, categorized by symbol type.
+ */
+std::string getRDSUsageJSON();
+
 /*
  * Return a string containing the names and start addresses of all TC code
  * sections.