[metric][benchmark]Add more benchmark (#759)

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 project(yaLanTingLibs
-        VERSION 0.3.6
+        VERSION 0.3.7
         DESCRIPTION "yaLanTingLibs"
         HOMEPAGE_URL "https://github.com/alibaba/yalantinglibs"
         LANGUAGES CXX

include/ylt/metric/counter.hpp

@@ -286,7 +286,7 @@ class basic_dynamic_counter : public dynamic_metric {
 
     auto now = std::chrono::system_clock::now();
     std::lock_guard lock(mtx_);
-    std::erase_if(value_map_, [&now](auto &pair) {
+    std::erase_if(value_map_, [&now](auto &pair) mutable {
       bool r = std::chrono::duration_cast<std::chrono::seconds>(
                    now - pair.second.get_created_time())
                    .count() >= ylt_label_max_age.count();

include/ylt/metric/summary.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <algorithm>
 #include <atomic>
 
 #include "detail/time_window_quantiles.hpp"
@@ -67,7 +68,8 @@ class summary_t : public static_metric {
   }
 
   void observe(double value) {
-    if (block_->sample_queue_.size_approx() >= 20000000) {
+    int64_t max_limit = (std::min)(ylt_label_capacity, (int64_t)1000000);
+    if (block_->sample_queue_.size_approx() >= max_limit) {
       g_summary_failed_count++;
       return;
     }
@@ -197,7 +199,7 @@ class summary_t : public static_metric {
 
   async_simple::coro::Lazy<void> start(std::shared_ptr<block_t> block) {
     double sample;
-    size_t count = 1000000;
+    size_t count = 100000;
     while (!block->stop_) {
       size_t index = 0;
       while (block->sample_queue_.try_dequeue(sample)) {
@@ -282,7 +284,8 @@ class basic_dynamic_summary : public dynamic_metric {
   }
 
   void observe(std::array<std::string, N> labels_value, double value) {
-    if (labels_block_->sample_queue_.size_approx() >= 20000000) {
+    int64_t max_limit = (std::min)(ylt_label_capacity, (int64_t)1000000);
+    if (labels_block_->sample_queue_.size_approx() >= max_limit) {
       g_summary_failed_count++;
       return;
     }
@@ -295,6 +298,8 @@ class basic_dynamic_summary : public dynamic_metric {
     }
   }
 
+  size_t size_approx() { return labels_block_->sample_queue_.size_approx(); }
+
   async_simple::coro::Lazy<std::vector<double>> get_rates(
       const std::array<std::string, N> &labels_value, double &sum,
       uint64_t &count) {
@@ -350,7 +355,7 @@ class basic_dynamic_summary : public dynamic_metric {
   async_simple::coro::Lazy<void> start(
       std::shared_ptr<labels_block_t<N>> label_block) {
     summary_label_sample<N> sample;
-    size_t count = 1000000;
+    size_t count = 100000;
     while (!label_block->stop_) {
       size_t index = 0;
       while (label_block->sample_queue_.try_dequeue(sample)) {

include/ylt/version.hpp

@@ -20,4 +20,4 @@
 // YLT_VERSION % 100 is the sub-minor version
 // YLT_VERSION / 100 % 1000 is the minor version
 // YLT_VERSION / 100000 is the major version
-#define YLT_VERSION 306  // 0.3.6
+#define YLT_VERSION 307  // 0.3.7

src/metric/benchmark/main.cpp

@@ -10,8 +10,8 @@
 using namespace std::chrono_literals;
 using namespace ylt::metric;
 
-void bench_static_counter(size_t thd_num, std::chrono::seconds duration,
-                          size_t dupli_count = 2) {
+void bench_static_counter_qps(size_t thd_num, std::chrono::seconds duration,
+                              size_t dupli_count = 2) {
   counter_t counter("qps", "", dupli_count);
   std::vector<std::thread> vec;
   std::atomic<bool> stop = false;
@@ -49,8 +49,8 @@ auto get_random(size_t range = 10000) {
   return distr(gen);
 }
 
-void bench_dynamic_counter(size_t thd_num, std::chrono::seconds duration,
-                           size_t dupli_count = 2) {
+void bench_dynamic_counter_qps(size_t thd_num, std::chrono::seconds duration,
+                               size_t dupli_count = 2) {
   dynamic_counter_t counter("qps2", "", {"url", "code"}, dupli_count);
   std::atomic<bool> stop = false;
   std::vector<std::thread> vec;
@@ -86,22 +86,194 @@ void bench_dynamic_counter(size_t thd_num, std::chrono::seconds duration,
   }
 }
 
+void bench_many_metric_serialize(size_t COUNT, size_t LABEL_COUNT,
+                                 bool to_json = false) {
+  std::vector<std::shared_ptr<metric_t>> vec;
+  for (size_t i = 0; i < COUNT; i++) {
+    auto counter = std::make_shared<dynamic_counter_t>(
+        std::string("qps"), "", std::array<std::string, 2>{"url", "code"});
+    for (size_t j = 0; j < LABEL_COUNT; j++) {
+      counter->inc({"test_label_value", std::to_string(j)});
+    }
+    vec.push_back(counter);
+  }
+
+  std::cout << "begin test\n";
+
+  std::string str;
+
+  auto start = std::chrono::system_clock::now();
+  if (to_json) {
+    str = manager_helper::serialize_to_json(vec);
+  }
+  else {
+    str = manager_helper::serialize(vec);
+  }
+
+  auto end = std::chrono::system_clock::now();
+  auto elaps =
+      std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+          .count();
+  std::cout << "string size: " << str.size() << ", " << elaps << "ms\n";
+}
+
+void bench_many_labels_serialize(size_t COUNT, bool to_json = false) {
+  dynamic_counter_t counter("qps2", "", {"url", "code"});
+  std::string val(36, ' ');
+  for (size_t i = 0; i < COUNT; i++) {
+    strcpy(val.data(), std::to_string(i).data());
+    counter.inc({"123e4567-e89b-12d3-a456-426614174000", val});
+  }
+
+  std::string str;
+  auto start = std::chrono::system_clock::now();
+  if (to_json) {
+    counter.serialize_to_json(str);
+  }
+  else {
+    counter.serialize(str);
+  }
+
+  auto end = std::chrono::system_clock::now();
+  auto elaps =
+      std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+          .count();
+  std::cout << elaps << "ms\n";
+  std::cout << "label value count: " << counter.label_value_count()
+            << " string size: " << str.size() << "\n";
+}
+
+void bench_many_labels_qps_summary(size_t thd_num,
+                                   std::chrono::seconds duration) {
+  dynamic_summary_2 summary(
+      "qps2", "",
+      summary_t::Quantiles{
+          {0.5, 0.05}, {0.9, 0.01}, {0.95, 0.005}, {0.99, 0.001}},
+      std::array<std::string, 2>{"method", "url"});
+  std::atomic<bool> stop = false;
+  std::vector<std::thread> vec;
+  std::array<std::string, 2> arr{"/test", "200"};
+  thread_local_value<uint64_t> local_val(thd_num);
+  auto start = std::chrono::system_clock::now();
+  std::string val(36, ' ');
+  for (size_t i = 0; i < thd_num; i++) {
+    vec.push_back(std::thread([&, i] {
+      while (!stop) {
+        strcpy(val.data(), std::to_string(i).data());
+        summary.observe({"/test", std::to_string(get_random())},
+                        get_random(100));
+        local_val.inc();
+      }
+    }));
+  }
+  std::this_thread::sleep_for(duration);
+  stop = true;
+  auto end = std::chrono::system_clock::now();
+
+  auto elaps =
+      std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+          .count();
+
+  double seconds = double(elaps) / 1000;
+  std::cout << "run " << elaps << "ms, " << seconds << " seconds\n";
+
+  auto qps = local_val.value() / seconds;
+  std::cout << "thd num: " << thd_num << ", qps: " << (int64_t)qps << "\n";
+  for (auto& thd : vec) {
+    thd.join();
+  }
+
+  start = std::chrono::system_clock::now();
+  size_t last = summary.size_approx();
+  std::cout << "total size: " << last << "\n";
+  while (true) {
+    std::this_thread::sleep_for(1s);
+    size_t current = summary.size_approx();
+    if (current == 0) {
+      break;
+    }
+
+    std::cout << last - current << "\n";
+    last = current;
+  }
+  end = std::chrono::system_clock::now();
+  elaps = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+              .count();
+  std::cout << "consume " << elaps << "ms\n";
+}
+
+void bench_many_labels_serialize_summary(size_t COUNT, bool to_json = false) {
+  dynamic_summary_2 summary(
+      "qps2", "",
+      summary_t::Quantiles{
+          {0.5, 0.05}, {0.9, 0.01}, {0.95, 0.005}, {0.99, 0.001}},
+      std::array<std::string, 2>{"method", "url"});
+  std::string val(36, ' ');
+  for (size_t i = 0; i < COUNT; i++) {
+    strcpy(val.data(), std::to_string(i).data());
+    summary.observe({"123e4567-e89b-12d3-a456-426614174000", val},
+                    get_random(100));
+  }
+
+  std::string str;
+  auto start = std::chrono::system_clock::now();
+  if (to_json) {
+    async_simple::coro::syncAwait(summary.serialize_to_json_async(str));
+  }
+  else {
+    async_simple::coro::syncAwait(summary.serialize_async(str));
+  }
+
+  auto end = std::chrono::system_clock::now();
+  auto elaps =
+      std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
+          .count();
+  std::cout << elaps << "ms\n";
+  std::cout << "label value count: " << summary.label_value_count()
+            << " string size: " << str.size() << "\n";
+}
+
 int main() {
-  bench_static_counter(1, 5s);
-  bench_static_counter(2, 5s);
-  bench_static_counter(8, 5s);
-  bench_static_counter(16, 5s);
-  bench_static_counter(32, 5s);
-  bench_static_counter(96, 5s);
-  bench_static_counter(32, 5s, 32);
-  bench_static_counter(96, 5s, 96);
-
-  bench_dynamic_counter(1, 5s);
-  bench_dynamic_counter(2, 5s);
-  bench_dynamic_counter(8, 5s);
-  bench_dynamic_counter(16, 5s);
-  bench_dynamic_counter(32, 5s);
-  bench_dynamic_counter(96, 10s);
-  bench_dynamic_counter(32, 5s, 32);
-  bench_dynamic_counter(96, 5s, 96);
+  bench_many_labels_serialize_summary(100000);
+  bench_many_labels_serialize_summary(1000000);
+
+  bench_many_labels_serialize_summary(100000, true);
+  bench_many_labels_serialize_summary(1000000, true);
+
+  bench_many_labels_qps_summary(1, 5s);
+  bench_many_labels_qps_summary(2, 5s);
+  bench_many_labels_qps_summary(8, 5s);
+  bench_many_labels_qps_summary(16, 5s);
+  bench_many_labels_qps_summary(32, 5s);
+  bench_many_labels_qps_summary(96, 5s);
+
+  bench_many_labels_serialize(100000);
+  bench_many_labels_serialize(1000000);
+  bench_many_labels_serialize(10000000);
+  bench_many_labels_serialize(100000, true);
+  bench_many_labels_serialize(1000000, true);
+  bench_many_labels_serialize(10000000, true);
+
+  bench_many_metric_serialize(100000, 10);
+  bench_many_metric_serialize(1000000, 10);
+  bench_many_metric_serialize(100000, 10, true);
+  bench_many_metric_serialize(1000000, 10, true);
+
+  bench_static_counter_qps(1, 5s);
+  bench_static_counter_qps(2, 5s);
+  bench_static_counter_qps(8, 5s);
+  bench_static_counter_qps(16, 5s);
+  bench_static_counter_qps(32, 5s);
+  bench_static_counter_qps(96, 5s);
+  bench_static_counter_qps(32, 5s, 32);
+  bench_static_counter_qps(96, 5s, 96);
+
+  bench_dynamic_counter_qps(1, 5s);
+  bench_dynamic_counter_qps(2, 5s);
+  bench_dynamic_counter_qps(8, 5s);
+  bench_dynamic_counter_qps(16, 5s);
+  bench_dynamic_counter_qps(32, 5s);
+  bench_dynamic_counter_qps(96, 10s);
+  bench_dynamic_counter_qps(32, 5s, 32);
+  bench_dynamic_counter_qps(96, 5s, 96);
 }