let ServiceData::getRegexCountersOptimized use folly::RegexMatchCache

Reviewed By: mdas7

Differential Revision: D54708756

fbshipit-source-id: e849f26017efb8827b014233dda087cebb06cadd

Author: yfeldblum

fb303/BUCK

@@ -37,6 +37,7 @@ cpp_library(
         "//folly:range",
         "//folly:synchronized",
         "//folly/container:f14_hash",
+        "//folly/container:regex_match_cache",
         "//folly/container:reserve",
         "//folly/synchronization:relaxed_atomic",
     ],
@@ -196,6 +197,7 @@ cpp_library(
         "//folly:indestructible",
         "//folly:map_util",
         "//folly:string",
+        "//folly/container:reserve",
     ],
     exported_deps = [
         ":dynamic_counters",
@@ -207,6 +209,7 @@ cpp_library(
         "//folly:range",
         "//folly:synchronized",
         "//folly/container:f14_hash",
+        "//folly/container:regex_match_cache",
         "//folly/synchronization:relaxed_atomic",
     ],
     external_deps = [

fb303/CallbackValuesMap-inl.h

@@ -77,8 +77,9 @@ void CallbackValuesMap<T>::getKeys(std::vector<std::string>* keys) const {
 template <typename T>
 void CallbackValuesMap<T>::getRegexKeys(
     std::vector<std::string>& keys,
-    const std::string& regex) const {
-  detail::getRegexKeysImpl(keys, regex, callbackMap_);
+    const std::string& regex,
+    const folly::RegexMatchCache::time_point now) const {
+  detail::cachedFindMatches(keys, callbackMap_, regex, now);
 }
 
 template <typename T>
@@ -91,11 +92,9 @@ void CallbackValuesMap<T>::registerCallback(
     folly::StringPiece name,
     const Callback& cob) {
   auto wlock = callbackMap_.wlock();
-  wlock->map[std::string(name)] = std::make_shared<CallbackEntry>(cob);
+  auto iter = detail::cachedAddString(*wlock, name, nullptr);
 
-  // avoid fetch_add() to avoid extra fences, since we hold the lock already
-  uint64_t epoch = wlock->mapEpoch.load();
-  wlock->mapEpoch.store(epoch + 1);
+  iter->second = std::make_shared<CallbackEntry>(cob);
 }
 
 template <typename T>
@@ -107,11 +106,7 @@ bool CallbackValuesMap<T>::unregisterCallback(folly::StringPiece name) {
   }
   auto callbackCopy = std::move(entry->second);
 
-  // avoid fetch_add() to avoid extra fences, since we hold the lock already
-  uint64_t epoch = wlock->mapEpoch.load();
-  wlock->mapEpoch.store(epoch + 1);
-
-  wlock->map.erase(entry);
+  detail::cachedEraseString(*wlock, entry);
   VLOG(5) << "Unregistered  callback: " << name;
 
   // clear the callback after releasing the lock
@@ -126,10 +121,7 @@ void CallbackValuesMap<T>::clear() {
   for (auto& entry : wlock->map) {
     entry.second->clear();
   }
-  // avoid fetch_add() to avoid extra fences, since we hold the lock already
-  uint64_t epoch = wlock->mapEpoch.load();
-  wlock->mapEpoch.store(epoch + 1);
-  wlock->map.clear();
+  detail::cachedClearStrings(*wlock);
 }
 
 template <typename T>

fb303/CallbackValuesMap.h

@@ -24,6 +24,7 @@
 #include <folly/Range.h>
 #include <folly/Synchronized.h>
 #include <folly/container/F14Map.h>
+#include <folly/container/RegexMatchCache.h>
 #include <folly/synchronization/RelaxedAtomic.h>
 
 namespace facebook {
@@ -57,7 +58,14 @@ class CallbackValuesMap {
 
   /* Returns the keys in the map that matches regex pattern */
   void getRegexKeys(std::vector<std::string>& keys, const std::string& regex)
-      const;
+      const {
+    const auto now = folly::RegexMatchCache::clock::now();
+    getRegexKeys(keys, regex, now);
+  }
+  void getRegexKeys(
+      std::vector<std::string>& keys,
+      const std::string& regex,
+      const folly::RegexMatchCache::time_point now) const;
 
   /** Returns the number of keys present in the map */
   size_t getNumKeys() const;
@@ -83,6 +91,10 @@ class CallbackValuesMap {
    */
   void clear();
 
+  void trimRegexCache(folly::RegexMatchCache::time_point expiry) {
+    callbackMap_.wlock()->matches.purge(expiry);
+  }
+
   class CallbackEntry {
    public:
     explicit CallbackEntry(const Callback& callback);
@@ -107,12 +119,8 @@ class CallbackValuesMap {
   // match, cache is valid.
   template <typename Mapped>
   struct MapWithKeyCache {
-    folly::F14FastMap<std::string, Mapped> map;
-    mutable folly::F14FastMap<std::string, std::vector<std::string>> regexCache;
-    mutable folly::relaxed_atomic_uint64_t mapEpoch{0};
-    mutable folly::relaxed_atomic_uint64_t cacheEpoch{0};
-    mutable folly::chrono::coarse_system_clock::time_point cacheClearTime{
-        std::chrono::seconds(0)};
+    folly::F14NodeMap<std::string, Mapped> map;
+    folly::RegexMatchCache matches; // requires map to have reference stability
   };
 
   using CallbackMap = MapWithKeyCache<std::shared_ptr<CallbackEntry>>;

fb303/ServiceData.cpp

@@ -25,6 +25,7 @@
 #include <folly/Indestructible.h>
 #include <folly/MapUtil.h>
 #include <folly/String.h>
+#include <folly/container/Reserve.h>
 #include <gflags/gflags.h>
 
 using folly::StringPiece;
@@ -76,14 +77,7 @@ void ServiceData::flushAllData() {
 
 void ServiceData::resetAllData() {
   options_.wlock()->clear();
-  {
-    auto countersWLock = counters_.wlock();
-    countersWLock->map.clear();
-
-    // avoid fetch_add() to avoid extra fences, since we hold the lock already
-    uint64_t epoch = countersWLock->mapEpoch.load();
-    countersWLock->mapEpoch.store(epoch + 1);
-  }
+  detail::cachedClearStrings(*counters_.wlock());
   exportedValues_.wlock()->clear();
 
   statsMap_.forgetAllStats();
@@ -317,11 +311,7 @@ int64_t ServiceData::incrementCounter(StringPiece key, int64_t amount) {
 
   //  pessimistically, the key is possibly absent; upsert under wlock
   auto countersWLock = counters_.wlock();
-  auto& ref = (countersWLock->map)[std::string(key)];
-
-  // avoid fetch_add() to avoid extra fences, since we hold the lock already
-  uint64_t epoch = countersWLock->mapEpoch.load();
-  countersWLock->mapEpoch.store(epoch + 1);
+  auto& ref = detail::cachedAddString(*countersWLock, key, 0)->second;
 
   return ref.fetch_add(amount, std::memory_order_relaxed) + amount;
 }
@@ -340,24 +330,16 @@ int64_t ServiceData::setCounter(StringPiece key, int64_t value) {
 
   //  pessimistically, the key is possibly absent; upsert under wlock
   auto countersWLock = counters_.wlock();
-  auto& ref = (countersWLock->map)[std::string(key)];
-
-  // avoid fetch_add() to avoid extra fences, since we hold the lock already
-  uint64_t epoch = countersWLock->mapEpoch.load();
-  countersWLock->mapEpoch.store(epoch + 1);
+  auto& ref = detail::cachedAddString(*countersWLock, key, 0)->second;
 
   ref.store(value, std::memory_order_relaxed);
   return value;
 }
 
 void ServiceData::clearCounter(StringPiece key) {
   auto countersWLock = counters_.wlock();
-  auto it = countersWLock->map.find(key);
-  if (it != countersWLock->map.end()) {
-    // avoid fetch_add() to avoid extra fences, since we hold the lock already
-    uint64_t epoch = countersWLock->mapEpoch.load();
-    countersWLock->mapEpoch.store(epoch + 1);
-    countersWLock->map.erase(it);
+  if (auto it = countersWLock->map.find(key); it != countersWLock->map.end()) {
+    detail::cachedEraseString(*countersWLock, it);
   }
 }
 
@@ -494,10 +476,11 @@ void ServiceData::getRegexCounters(
 void ServiceData::getRegexCountersOptimized(
     map<string, int64_t>& output,
     const string& regex) const {
+  const auto now = folly::RegexMatchCache::clock::now();
   std::vector<std::string> keys;
-  detail::getRegexKeysImpl(keys, regex, counters_);
-  quantileMap_.getRegexKeys(keys, regex);
-  dynamicCounters_.getRegexKeys(keys, regex);
+  detail::cachedFindMatches(keys, counters_, regex, now);
+  quantileMap_.getRegexKeys(keys, regex, now);
+  dynamicCounters_.getRegexKeys(keys, regex, now);
   getSelectedCounters(output, keys);
 }
 
@@ -514,6 +497,14 @@ map<string, int64_t> ServiceData::getRegexCountersOptimized(
   return output;
 }
 
+void ServiceData::trimRegexCache(const std::chrono::seconds maxstale) {
+  const auto now = folly::RegexMatchCache::clock::now();
+  const auto expiry = now - maxstale;
+  counters_.wlock()->matches.purge(expiry);
+  quantileMap_.trimRegexCache(expiry);
+  dynamicCounters_.trimRegexCache(expiry);
+}
+
 bool ServiceData::hasCounter(StringPiece key) const {
   if (dynamicCounters_.contains(key)) {
     return true;

fb303/ServiceData.h

@@ -26,6 +26,7 @@
 #include <folly/Range.h>
 #include <folly/Synchronized.h>
 #include <folly/container/F14Map.h>
+#include <folly/container/RegexMatchCache.h>
 #include <folly/synchronization/RelaxedAtomic.h>
 
 #include <atomic>
@@ -473,6 +474,7 @@ class ServiceData {
       const std::string& regex) const;
   std::map<std::string, int64_t> getRegexCountersOptimized(
       const std::string& regex) const;
+  void trimRegexCache(std::chrono::seconds maxstale);
   /*** Returns true if a counter exists with the specified name */
   bool hasCounter(folly::StringPiece key) const;
 
@@ -570,7 +572,8 @@ class ServiceData {
 
  private:
   struct Counter : std::atomic<int64_t> {
-    Counter() : std::atomic<int64_t>{0} {}
+    Counter() noexcept : std::atomic<int64_t>{0} {}
+    explicit Counter(int64_t v) noexcept : std::atomic<int64_t>{v} {}
     Counter(Counter&& other) noexcept
         : std::atomic<int64_t>{other.load(std::memory_order_relaxed)} {}
   };
@@ -588,11 +591,7 @@ class ServiceData {
   template <typename Mapped>
   struct MapWithKeyCache {
     std::map<std::string, Mapped, std::less<>> map;
-    mutable folly::F14FastMap<std::string, std::vector<std::string>> regexCache;
-    mutable folly::relaxed_atomic_uint64_t mapEpoch{0};
-    mutable folly::relaxed_atomic_uint64_t cacheEpoch{0};
-    mutable folly::chrono::coarse_system_clock::time_point cacheClearTime{
-        std::chrono::seconds(0)};
+    folly::RegexMatchCache matches; // requires map to have reference stability
   };
   folly::Synchronized<MapWithKeyCache<Counter>> counters_;
 

fb303/ThreadCachedServiceData.cpp

@@ -19,11 +19,16 @@
 #include <folly/Indestructible.h>
 #include <folly/Singleton.h>
 
+using namespace std::literals;
+
 using std::chrono::milliseconds;
 
 namespace {
 static const std::string kFunctionId =
     "ThreadCachedStatsMap::aggregateAcrossAllThreads";
+static const std::string kPurgeFunctionId = "ServiceData::trimRegexCache";
+static const auto kPurgeInterval = 600s;
+static const auto kPurgeMaxStale = 3600s;
 } // namespace
 
 namespace facebook::fb303 {
@@ -41,6 +46,14 @@ class PublisherManager {
           [] { ThreadCachedServiceData::getInternal().publishStats(); },
           ThreadCachedServiceData::getInternal().getPublisherInterval(),
           kFunctionId);
+      fs_.addFunction(
+          [] {
+            ThreadCachedServiceData::getInternal()
+                .getServiceData()
+                ->trimRegexCache(kPurgeMaxStale);
+          },
+          kPurgeInterval,
+          kPurgeFunctionId);
       fs_.setThreadName("servicedata-pub");
       fs_.start();
     }

fb303/detail/BUCK

@@ -22,6 +22,7 @@ cpp_library(
         "//folly:optional",
         "//folly:synchronized",
         "//folly/container:f14_hash",
+        "//folly/container:regex_match_cache",
         "//folly/synchronization:relaxed_atomic",
     ],
     exported_external_deps = [
@@ -60,6 +61,8 @@ cpp_library(
         "//folly:chrono",
         "//folly:map_util",
         "//folly/container:f14_hash",
+        "//folly/container:regex_match_cache",
+        "//folly/container:reserve",
     ],
     external_deps = [
         ("boost", None, "boost_regex"),

fb303/detail/QuantileStatMap-inl.h

@@ -179,8 +179,9 @@ void BasicQuantileStatMap<ClockT>::getKeys(
 template <typename ClockT>
 void BasicQuantileStatMap<ClockT>::getRegexKeys(
     std::vector<std::string>& keys,
-    const std::string& regex) const {
-  getRegexKeysImpl(keys, regex, counters_);
+    const std::string& regex,
+    const folly::RegexMatchCache::time_point now) const {
+  detail::cachedFindMatches(keys, counters_, regex, now);
 }
 
 template <typename ClockT>
@@ -221,19 +222,16 @@ BasicQuantileStatMap<ClockT>::registerQuantileStat(
     CounterMapEntry entry;
     entry.stat = stat;
     entry.statDef = statDef;
-    countersWLock->map.emplace(makeKey(name, statDef, folly::none), entry);
+    detail::cachedAddString(
+        *countersWLock, makeKey(name, statDef, folly::none), entry);
 
     auto slidingWindowLengths = stat->getSlidingWindowLengths();
 
     for (auto slidingWindowLength : slidingWindowLengths) {
       entry.slidingWindowLength = slidingWindowLength;
-      countersWLock->map.emplace(
-          makeKey(name, statDef, slidingWindowLength), entry);
+      detail::cachedAddString(
+          *countersWLock, makeKey(name, statDef, slidingWindowLength), entry);
     }
-
-    // avoid fetch_add() to avoid extra fences, since we hold the lock already
-    uint64_t epoch = countersWLock->mapEpoch.load();
-    countersWLock->mapEpoch.store(epoch + 1);
   }
   StatMapEntry statMapEntry;
   statMapEntry.stat = stat;