getactorstats query for validator-engine-console

tdutils/td/utils/StealingQueue.h

@@ -115,6 +115,22 @@ class StealingQueue {
     std::atomic_thread_fence(std::memory_order_seq_cst);
   }
 
+  size_t size() const {
+    while (true) {
+      auto head = head_.load();
+      auto tail = tail_.load(std::memory_order_acquire);
+
+      if (tail < head) {
+        continue;
+      }
+      size_t n = tail - head;
+      if (n > N) {
+        continue;
+      }
+      return n;
+    }
+  }
+
  private:
   std::atomic<td::int64> head_{0};
   std::atomic<td::int64> tail_{0};

tdutils/td/utils/ThreadSafeCounter.h

@@ -137,4 +137,55 @@ class NamedThreadSafeCounter {
   Counter counter_;
 };
 
+// another class for simplicity, it
+struct NamedPerfCounter {
+ public:
+  static NamedPerfCounter &get_default() {
+    static NamedPerfCounter res;
+    return res;
+  }
+  struct PerfCounterRef {
+    NamedThreadSafeCounter::CounterRef count;
+    NamedThreadSafeCounter::CounterRef duration;
+  };
+  PerfCounterRef get_counter(Slice name) {
+    return {.count = counter_.get_counter(PSLICE() << name << ".count"),
+            .duration = counter_.get_counter(PSLICE() << name << ".duration")};
+  }
+
+  struct ScopedPerfCounterRef : public NoCopyOrMove {
+    PerfCounterRef perf_counter;
+    uint64 started_at_ticks{td::Clocks::rdtsc()};
+
+    ~ScopedPerfCounterRef() {
+      perf_counter.count.add(1);
+      perf_counter.duration.add(td::Clocks::rdtsc() - started_at_ticks);
+    }
+  };
+
+  template <class F>
+  void for_each(F &&f) const {
+    counter_.for_each(f);
+  }
+
+  void clear() {
+    counter_.clear();
+  }
+
+  friend StringBuilder &operator<<(StringBuilder &sb, const NamedPerfCounter &counter) {
+    return sb << counter.counter_;
+  }
+ private:
+  NamedThreadSafeCounter counter_;
+};
+
 }  // namespace td
+
+#define TD_PERF_COUNTER(name)                                                    \
+  static auto perf_##name = td::NamedPerfCounter::get_default().get_counter(td::Slice(#name)); \
+  auto scoped_perf_##name = td::NamedPerfCounter::ScopedPerfCounterRef{.perf_counter = perf_##name};
+
+#define TD_PERF_COUNTER_SINCE(name, since)                                       \
+  static auto perf_##name = td::NamedPerfCounter::get_default().get_counter(td::Slice(#name)); \
+  auto scoped_perf_##name =                                                      \
+      td::NamedPerfCounter::ScopedPerfCounterRef{.perf_counter = perf_##name, .started_at_ticks = since};

tdutils/td/utils/common.h

@@ -127,4 +127,12 @@ struct Auto {
   }
 };
 
+struct NoCopyOrMove {
+  NoCopyOrMove() = default;
+  NoCopyOrMove(NoCopyOrMove &&) = delete;
+  NoCopyOrMove(const NoCopyOrMove &) = delete;
+  NoCopyOrMove &operator=(NoCopyOrMove &&) = delete;
+  NoCopyOrMove &operator=(const NoCopyOrMove &) = delete;
+};
+
 }  // namespace td

tdutils/td/utils/logging.cpp

@@ -18,6 +18,7 @@
 */
 #include "td/utils/logging.h"
 
+#include "ThreadSafeCounter.h"
 #include "td/utils/port/Clocks.h"
 #include "td/utils/port/StdStreams.h"
 #include "td/utils/port/thread_local.h"
@@ -127,6 +128,9 @@ Logger::~Logger() {
       slice = MutableCSlice(slice.begin(), slice.begin() + slice.size() - 1);
     }
     log_.append(slice, log_level_);
+
+    // put stats here to avoid conflict with PSTRING and PSLICE
+    TD_PERF_COUNTER_SINCE(logger, start_at_);
   } else {
     log_.append(as_cslice(), log_level_);
   }
@@ -301,5 +305,4 @@ ScopedDisableLog::~ScopedDisableLog() {
     set_verbosity_level(sdl_verbosity);
   }
 }
-
 }  // namespace td

tdutils/td/utils/logging.h

@@ -40,6 +40,7 @@
 #include "td/utils/Slice.h"
 #include "td/utils/StackAllocator.h"
 #include "td/utils/StringBuilder.h"
+#include "td/utils/port/Clocks.h"
 
 #include <atomic>
 #include <type_traits>
@@ -251,7 +252,8 @@ class Logger {
       , log_(log)
       , sb_(buffer_.as_slice())
       , options_(options)
-      , log_level_(log_level) {
+      , log_level_(log_level)
+      , start_at_(Clocks::rdtsc()) {
   }
 
   Logger(LogInterface &log, const LogOptions &options, int log_level, Slice file_name, int line_num, Slice comment);
@@ -283,6 +285,7 @@ class Logger {
   StringBuilder sb_;
   const LogOptions &options_;
   int log_level_;
+  td::uint64 start_at_;
 };
 
 namespace detail {
@@ -346,5 +349,4 @@ class TsLog : public LogInterface {
     lock_.clear(std::memory_order_release);
   }
 };
-
 }  // namespace td

tdutils/td/utils/port/Clocks.h

@@ -17,6 +17,7 @@
     Copyright 2017-2020 Telegram Systems LLP
 */
 #pragma once
+#include "td/utils/int_types.h"
 
 namespace td {
 
@@ -26,6 +27,62 @@ struct Clocks {
   static double system();
 
   static int tz_offset();
+
+#if defined(__i386__)
+  static __inline__ td::uint64 rdtsc(void) {
+    unsigned long long int x;
+    __asm__ volatile("rdtsc" : "=A"(x));
+    return x;
+  }
+
+  static constexpr td::uint64 rdtsc_frequency(void) {
+    return 2000'000'000;
+  }
+
+  static constexpr double ticks_per_second() {
+    return 2e9;
+  }
+
+  static constexpr double inv_ticks_per_second() {
+    return 0.5e-9;
+  }
+#elif defined(__x86_64__)
+  static __inline__ td::uint64 rdtsc(void) {
+    unsigned hi, lo;
+    __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi));
+    return ((unsigned long long)lo) | (((unsigned long long)hi) << 32);
+  }
+  static constexpr td::uint64 rdtsc_frequency(void) {
+    return 2000'000'000;
+  }
+
+  static constexpr double ticks_per_second() {
+    return 2e9;
+  }
+
+  static constexpr double inv_ticks_per_second() {
+    return 0.5e-9;
+  }
+#elif defined(__aarch64__)
+  static __inline__ td::uint64 rdtsc(void) {
+    unsigned long long val;
+    asm volatile("mrs %0, cntvct_el0" : "=r"(val));
+    return val;
+  }
+  static __inline__ td::uint64 rdtsc_frequency(void) {
+    unsigned long long val;
+    asm volatile("mrs %0, cntfrq_el0" : "=r"(val));
+    return val;
+  }
+
+  static double ticks_per_second() {
+    return static_cast<double>(rdtsc_frequency());
+  }
+
+  static double inv_ticks_per_second() {
+    return 1.0 / static_cast<double>(rdtsc_frequency());
+  }
+#endif
 };
 
 }  // namespace td