updated submodules, bugfixes

- added new fift/func code for validator complaint creation
- bugfixes in validator
- updates in tonlib
- new versions of rocksdb/abseil
- hardfork support

tdactor/td/actor/core/CpuWorker.cpp

@@ -32,6 +32,7 @@ void CpuWorker::run() {
 
   MpmcWaiter::Slot slot;
   waiter_.init_slot(slot, thread_id);
+  auto &debug = dispatcher.get_debug();
   while (true) {
     SchedulerMessage message;
     if (try_pop(message, thread_id)) {
@@ -39,6 +40,7 @@ void CpuWorker::run() {
       if (!message) {
         return;
       }
+      auto lock = debug.start(message->get_name());
       ActorExecutor executor(*message, dispatcher, ActorExecutor::Options().with_from_queue());
     } else {
       waiter_.wait(slot);

tdactor/td/actor/core/IoWorker.cpp

@@ -19,6 +19,7 @@
 #include "td/actor/core/IoWorker.h"
 
 #include "td/actor/core/ActorExecutor.h"
+#include "td/actor/core/Scheduler.h"
 
 namespace td {
 namespace actor {
@@ -42,6 +43,7 @@ bool IoWorker::run_once(double timeout) {
   auto &poll = SchedulerContext::get()->get_poll();
 #endif
   auto &heap = SchedulerContext::get()->get_heap();
+  auto &debug = SchedulerContext::get()->get_debug();
 
   auto now = Time::now();  // update Time::now_cached()
   while (!heap.empty() && heap.top_key() <= now) {
@@ -49,6 +51,7 @@ bool IoWorker::run_once(double timeout) {
     auto *actor_info = ActorInfo::from_heap_node(heap_node);
 
     auto id = actor_info->unpin();
+    auto lock = debug.start(actor_info->get_name());
     ActorExecutor executor(*actor_info, dispatcher, ActorExecutor::Options().with_has_poll(true));
     if (executor.can_send_immediate()) {
       executor.send_immediate(ActorSignals::one(ActorSignals::Alarm));
@@ -68,6 +71,7 @@ bool IoWorker::run_once(double timeout) {
       dispatcher.set_alarm_timestamp(message);
       continue;
     }
+    auto lock = debug.start(message->get_name());
     ActorExecutor executor(*message, dispatcher, ActorExecutor::Options().with_from_queue().with_has_poll(true));
   }
   queue_.reader_flush();

tdactor/td/actor/core/Scheduler.cpp

@@ -25,6 +25,15 @@ namespace td {
 namespace actor {
 namespace core {
 
+std::atomic<bool> debug;
+void set_debug(bool flag) {
+  debug = flag;
+}
+
+bool need_debug() {
+  return debug.load(std::memory_order_relaxed);
+}
+
 Scheduler::Scheduler(std::shared_ptr<SchedulerGroupInfo> scheduler_group_info, SchedulerId id, size_t cpu_threads_count)
     : scheduler_group_info_(std::move(scheduler_group_info)), cpu_threads_(cpu_threads_count) {
   scheduler_group_info_->active_scheduler_count++;
@@ -128,13 +137,14 @@ void Scheduler::do_stop() {
 }
 
 Scheduler::ContextImpl::ContextImpl(ActorInfoCreator *creator, SchedulerId scheduler_id, CpuWorkerId cpu_worker_id,
-                                    SchedulerGroupInfo *scheduler_group, Poll *poll, KHeap<double> *heap)
+                                    SchedulerGroupInfo *scheduler_group, Poll *poll, KHeap<double> *heap, Debug *debug)
     : creator_(creator)
     , scheduler_id_(scheduler_id)
     , cpu_worker_id_(cpu_worker_id)
     , scheduler_group_(scheduler_group)
     , poll_(poll)
-    , heap_(heap) {
+    , heap_(heap)
+    , debug_(debug) {
 }
 
 SchedulerId Scheduler::ContextImpl::get_scheduler_id() const {
@@ -184,6 +194,9 @@ KHeap<double> &Scheduler::ContextImpl::get_heap() {
   CHECK(has_heap());
   return *heap_;
 }
+Debug &Scheduler::ContextImpl::get_debug() {
+  return *debug_;
+}
 
 void Scheduler::ContextImpl::set_alarm_timestamp(const ActorInfoPtr &actor_info_ptr) {
   // Ideas for optimization

tdactor/td/actor/core/Scheduler.h

@@ -31,6 +31,7 @@
 #include "td/actor/core/SchedulerId.h"
 #include "td/actor/core/SchedulerMessage.h"
 
+#include "td/utils/AtomicRead.h"
 #include "td/utils/Closure.h"
 #include "td/utils/common.h"
 #include "td/utils/format.h"
@@ -65,6 +66,54 @@ namespace actor {
 namespace core {
 class IoWorker;
 
+struct DebugInfo {
+  bool is_active{false};
+  double start_at{0};
+  static constexpr size_t name_size{32};
+  char name[name_size] = {};
+  void set_name(td::Slice from) {
+    from.truncate(name_size - 1);
+    std::memcpy(name, from.data(), from.size());
+    name[from.size()] = 0;
+  }
+};
+
+void set_debug(bool flag);
+bool need_debug();
+
+struct Debug {
+ public:
+  bool is_on() const {
+    return need_debug();
+  }
+  struct Destructor {
+    void operator()(Debug *info) {
+      info->info_.lock().value().is_active = false;
+    }
+  };
+
+  void read(DebugInfo &info) {
+    info_.read(info);
+  }
+
+  std::unique_ptr<Debug, Destructor> start(td::Slice name) {
+    if (!is_on()) {
+      return {};
+    }
+    {
+      auto lock = info_.lock();
+      auto &value = lock.value();
+      value.is_active = true;
+      value.start_at = Time::now();
+      value.set_name(name);
+    }
+    return std::unique_ptr<Debug, Destructor>(this);
+  }
+
+ private:
+  AtomicRead<DebugInfo> info_;
+};
+
 struct WorkerInfo {
   enum class Type { Io, Cpu } type{Type::Io};
   WorkerInfo() = default;
@@ -73,6 +122,7 @@ struct WorkerInfo {
   }
   ActorInfoCreator actor_info_creator;
   CpuWorkerId cpu_worker_id;
+  Debug debug;
 };
 
 template <class T>
@@ -195,7 +245,7 @@ class Scheduler {
   class ContextImpl : public SchedulerContext {
    public:
     ContextImpl(ActorInfoCreator *creator, SchedulerId scheduler_id, CpuWorkerId cpu_worker_id,
-                SchedulerGroupInfo *scheduler_group, Poll *poll, KHeap<double> *heap);
+                SchedulerGroupInfo *scheduler_group, Poll *poll, KHeap<double> *heap, Debug *debug);
 
     SchedulerId get_scheduler_id() const override;
     void add_to_queue(ActorInfoPtr actor_info_ptr, SchedulerId scheduler_id, bool need_poll) override;
@@ -208,6 +258,8 @@ class Scheduler {
     bool has_heap() override;
     KHeap<double> &get_heap() override;
 
+    Debug &get_debug() override;
+
     void set_alarm_timestamp(const ActorInfoPtr &actor_info_ptr) override;
 
     bool is_stop_requested() override;
@@ -225,6 +277,8 @@ class Scheduler {
     Poll *poll_;
 
     KHeap<double> *heap_;
+
+    Debug *debug_;
   };
 
   template <class F>
@@ -234,7 +288,8 @@ class Scheduler {
 #endif
     bool is_io_worker = worker_info.type == WorkerInfo::Type::Io;
     ContextImpl context(&worker_info.actor_info_creator, info_->id, worker_info.cpu_worker_id,
-                        scheduler_group_info_.get(), is_io_worker ? &poll_ : nullptr, is_io_worker ? &heap_ : nullptr);
+                        scheduler_group_info_.get(), is_io_worker ? &poll_ : nullptr, is_io_worker ? &heap_ : nullptr,
+                        &worker_info.debug);
     SchedulerContext::Guard guard(&context);
     f();
   }

tdactor/td/actor/core/SchedulerContext.h

@@ -37,6 +37,7 @@ class SchedulerDispatcher {
   virtual void set_alarm_timestamp(const ActorInfoPtr &actor_info_ptr) = 0;
 };
 
+struct Debug;
 class SchedulerContext : public Context<SchedulerContext>, public SchedulerDispatcher {
  public:
   virtual ~SchedulerContext() = default;
@@ -55,6 +56,9 @@ class SchedulerContext : public Context<SchedulerContext>, public SchedulerDispa
   // Stop all schedulers
   virtual bool is_stop_requested() = 0;
   virtual void stop() = 0;
+
+  // Debug
+  virtual Debug &get_debug() = 0;
 };
 }  // namespace core
 }  // namespace actor