use sharded map

include/ylt/metric/dynamic_metric.hpp

@@ -1,5 +1,9 @@
 #pragma once
+#include <thread>
+
 #include "metric.hpp"
+#include "ylt/util/map_sharded.hpp"
+
 namespace ylt::metric {
 
 class dynamic_metric : public metric_t {
@@ -9,11 +13,11 @@ class dynamic_metric : public metric_t {
 
 template <typename core_type, uint8_t N>
 class dynamic_metric_impl : public dynamic_metric {
+  template <size_t seed = 131>
   struct my_hash {
     using is_transparent = void;
     std::size_t operator()(
         const std::span<const std::string, N>& s) const noexcept {
-      unsigned int seed = 131;
       unsigned int hash = 0;
       for (const auto& str : s) {
         for (auto ch : str) {
@@ -24,7 +28,6 @@ class dynamic_metric_impl : public dynamic_metric {
     }
     std::size_t operator()(
         const std::span<std::string_view, N>& s) const noexcept {
-      unsigned int seed = 131;
       unsigned int hash = 0;
       for (const auto& str : s) {
         for (auto ch : str) {
@@ -78,37 +81,28 @@ class dynamic_metric_impl : public dynamic_metric {
 
  public:
   using dynamic_metric::dynamic_metric;
-  size_t size() const {
-    std::lock_guard guard(mtx_);
-    return table.size();
-  }
+  size_t size() const { return map_.size(); }
   size_t empty() const { return !size(); }
   size_t label_value_count() const { return size(); }
 
   std::vector<std::shared_ptr<metric_pair>> copy() const {
-    std::lock_guard guard(mtx_);
-    std::vector<std::shared_ptr<metric_pair>> ret;
-    ret.reserve(table.size());
-    for (auto& e : table) {
-      ret.push_back(e.second);
-    }
-    return ret;
+    return map_.template copy<std::shared_ptr<metric_pair>>();
   }
 
  protected:
   template <typename Key, typename... Args>
   std::shared_ptr<metric_pair> try_emplace(Key&& key, Args&&... args) {
-    std::lock_guard guard(mtx_);
     std::span<const std::string, N> view = key;
-    auto iter = table.try_emplace(view, std::forward<Key>(key),
-                                  std::forward<Args>(args)...);
+    auto iter =
+        map_.try_emplace(view, std::forward<Key>(key),  // rehash problem
+                         std::forward<Args>(args)...);
     if (iter.second) {
-      *const_cast<std::span<const std::string, N>*>(&iter.first->first) =
-          iter.first->second->label;
+      *const_cast<std::span<const std::string, N>*>(&iter.first.first) =
+          iter.first.second->label;
     }
-    return table
+    return map_
         .try_emplace(view, std::forward<Key>(key), std::forward<Args>(args)...)
-        .first->second;
+        .first.second;
   }
   void clean_expired_label() override {
     erase_if([now = std::chrono::steady_clock::now()](auto& pair) mutable {
@@ -118,29 +112,16 @@ class dynamic_metric_impl : public dynamic_metric {
       return r;
     });
   }
-  std::shared_ptr<metric_pair> find(std::span<const std::string, N> key) {
-    std::lock_guard guard(mtx_);
-    auto iter = table.find(key);
-    if (iter != table.end()) {
-      return iter->second;
-    }
-    else {
-      return nullptr;
-    }
-  }
-  size_t erase(std::span<const std::string, N> key) {
-    std::lock_guard guard(mtx_);
-    return table.erase(key);
-  }
-  void erase_if(auto&& op) {
-    std::lock_guard guard(mtx_);
-    std::erase_if(table, op);
+  std::shared_ptr<metric_pair> find(std::span<const std::string, N> key) const {
+    return map_.find(key);
   }
+  size_t erase(std::span<const std::string, N> key) { return map_.erase(key); }
+  size_t erase_if(auto&& op) { return map_.erase_if(op); }
 
  private:
-  mutable std::mutex mtx_;
-  std::unordered_map<std::span<const std::string, N>, value_type, my_hash,
-                     my_equal>
-      table;
+  util::map_sharded_t<std::unordered_map<std::span<const std::string, N>,
+                                         value_type, my_hash<131>, my_equal>,
+                      my_hash<137>>
+      map_{std::min<unsigned>(128u, std::thread::hardware_concurrency())};
 };
 }  // namespace ylt::metric