Add per-thread single-entry name cache to fb303 getStats to skip F14 lookup

Reviewed By: yfeldblum

Differential Revision: D115968601

fbshipit-source-id: ec8afd2ae00eb23b9e8b7dc7c3997b4bd98d154b

Author: generatedunixname1395027625275998

fb303/TFunctionStatHandler.cpp

@@ -282,7 +282,7 @@ int32_t TFunctionStatHandler::consolidateThread(
     time_t now,
     TStatsAggregator& functionMap) {
   auto calls = 0;
-  for (auto& stats : functionMap) {
+  for (auto& stats : functionMap.map) {
     if (!stats.second) {
       continue;
     }
@@ -426,11 +426,16 @@ TStatsPerThread* TFunctionStatHandler::getStats(std::string_view fnName) {
     std::unique_lock lock(statMutex_);
     tlFunctionMap_.reset(mapPtr, deleter);
   }
+  // Single-entry cache: repeated lookups of the same function name skip the
+  // map find. Matched by content, so any caller name buffer is safe.
+  if (mapPtr->cachedStats != nullptr && fnName == mapPtr->cachedFnName) {
+    return mapPtr->cachedStats;
+  }
   // Find TStatsPerThread in TStatsAggregator's map - the map is only updated
   // from one thread (the current one, owner of the TStatsAggregator); no
   // update should be needed in the common case, so we just use statMutex_
   // to guard it
-  auto& map = *mapPtr;
+  auto& map = mapPtr->map;
   auto it = map.find(fnName);
   if (it == map.end()) {
     auto stats = createStatsPerThread(fnName);
@@ -439,10 +444,14 @@ TStatsPerThread* TFunctionStatHandler::getStats(std::string_view fnName) {
 
     // we're going to be writing the map, so lock out stat aggregation ftm
     std::unique_lock lock(statMutex_);
-    map[fnName] = stats;
-    return stats.get();
+    it = map.emplace(fnName, std::move(stats)).first;
   }
-  return it->second.get();
+  // Cache a view of the owning map key (no copy) and the raw stats pointer.
+  // Both stay valid until the next getStats() call on this thread, the only
+  // path that mutates the map.
+  mapPtr->cachedFnName = it->first;
+  mapPtr->cachedStats = it->second.get();
+  return mapPtr->cachedStats;
 }
 
 namespace {

fb303/TFunctionStatHandler.h

@@ -189,10 +189,22 @@ class TFunctionStatHandler
 
   /**
    * Mapping from thrift functions to their respective
-   * TStatsPerThread objects for a single thread
+   * TStatsPerThread objects for a single thread, plus a single-entry
+   * cache (a view of the most recent getStats() lookup).
    */
-  using TStatsAggregator =
-      folly::F14FastMap<std::string, std::shared_ptr<TStatsPerThread>>;
+  struct TStatsAggregator {
+    folly::F14FastMap<std::string, std::shared_ptr<TStatsPerThread>> map;
+
+    // Single-entry cache of the last getStats() lookup. cachedFnName is a
+    // non-owning view of the map key (no per-call string copy). Both members
+    // stay valid because the map is only ever mutated by getStats() on this
+    // same thread and the cache is refreshed immediately after any insert, so
+    // no rehash can invalidate them between calls. cachedStats points at the
+    // heap-allocated TStatsPerThread owned by the map's shared_ptr, which never
+    // moves.
+    std::string_view cachedFnName;
+    TStatsPerThread* cachedStats = nullptr;
+  };
 
   class Tag;
   folly::ThreadLocalPtr<TStatsAggregator, Tag> tlFunctionMap_;