celldb in-memory mode, stats for actors, perf counters, minor fix in …

…rldp2 (ton-blockchain#1164) * getactorstats query for validator-engine-console * celldb in-memory mode (--celldb-in-memory option) * rldp2: bugfix - do not estimate speed while nothing is sent * add simple ed25519 benchmark * fix compilation errors of different platforms and move to c++20 * fix some warnings * turn on TON_USE_ABSEIL for glibc 2.27 nix build --------- Co-authored-by: birydrad <>
zjg555543 · Oct 21, 2024 · 8d978f0 · 8d978f0
1 parent 921aa29
commit 8d978f0
Show file tree

Hide file tree

Showing 102 changed files with 3,465 additions and 358 deletions.
diff --git a/.gitignore b/.gitignore
@@ -23,3 +23,4 @@ libsodium-1.0.18-stable-msvc.zip
 libmicrohttpd-0.9.77-w32-bin.zip
 openssl-3.1.4.zip
 readline-5.0-1-lib.zip
+build-macos-shared.sh
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -79,7 +79,7 @@ else()
   set(HAVE_SSE42 FALSE)
 endif()
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_CXX_EXTENSIONS FALSE)
 
@@ -333,6 +333,10 @@ add_cxx_compiler_flag("-Wno-sign-conversion")
 add_cxx_compiler_flag("-Qunused-arguments")
 add_cxx_compiler_flag("-Wno-unused-private-field")
 add_cxx_compiler_flag("-Wno-redundant-move")
+
+#add_cxx_compiler_flag("-Wno-unused-function")
+#add_cxx_compiler_flag("-Wno-unused-variable")
+#add_cxx_compiler_flag("-Wno-shorten-64-to-32")
 #add_cxx_compiler_flag("-Werror")
 
 #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -isystem /usr/include/c++/v1")

diff --git a/assembly/nix/linux-x86-64-tonlib.nix b/assembly/nix/linux-x86-64-tonlib.nix
@@ -60,7 +60,7 @@ stdenv227.mkDerivation {
   dontAddStaticConfigureFlags = false;
 
   cmakeFlags = [
-    "-DTON_USE_ABSEIL=OFF"
+    "-DTON_USE_ABSEIL=ON"
     "-DNIX=ON"
   ];
 

diff --git a/catchain/catchain-receiver.cpp b/catchain/catchain-receiver.cpp
@@ -27,6 +27,8 @@
 
 #include "catchain-receiver.hpp"
 
+#include "td/utils/ThreadSafeCounter.h"
+
 namespace ton {
 
 namespace catchain {
@@ -369,7 +371,7 @@ void CatChainReceiverImpl::add_block(td::BufferSlice payload, std::vector<CatCha
 
   int height = prev->height_ + 1;
   auto max_block_height = get_max_block_height(opts_, sources_.size());
-  if (height > max_block_height) {
+  if (td::narrow_cast<td::uint64>(height) > max_block_height) {
     VLOG(CATCHAIN_WARNING) << this << ": cannot create block: max height exceeded (" << max_block_height << ")";
     active_send_ = false;
     return;
@@ -685,6 +687,7 @@ void CatChainReceiverImpl::receive_query_from_overlay(adnl::AdnlNodeIdShort src,
     promise.set_error(td::Status::Error(ErrorCode::notready, "db not read"));
     return;
   }
+  TD_PERF_COUNTER(catchain_query_process);
   td::PerfWarningTimer t{"catchain query process", 0.05};
   auto F = fetch_tl_object<ton_api::Function>(data.clone(), true);
   if (F.is_error()) {

diff --git a/common/delay.h b/common/delay.h
@@ -49,4 +49,29 @@ template <typename T>
 void delay_action(T promise, td::Timestamp timeout) {
   DelayedAction<T>::create(std::move(promise), timeout);
 }
+
+template <typename PromiseT, typename ValueT>
+class AsyncApply : public td::actor::Actor {
+ public:
+  AsyncApply(PromiseT promise, ValueT value) : promise_(std::move(promise)), value_(std::move(value)){
+  }
+
+  void start_up() override {
+    promise_(std::move(value_));
+    stop();
+  }
+
+  static void create(td::Slice name, PromiseT promise, ValueT value ) {
+    td::actor::create_actor<AsyncApply>(PSLICE() << "async:" << name, std::move(promise), std::move(value)).release();
+  }
+
+ private:
+  PromiseT promise_;
+  ValueT value_;
+};
+
+template <class PromiseT, class ValueT>
+void async_apply(td::Slice name, PromiseT &&promise, ValueT &&value) {
+  AsyncApply<PromiseT, ValueT>::create(name, std::forward<PromiseT>(promise), std::forward<ValueT>(value));
+}
 }  // namespace ton
diff --git a/crypto/CMakeLists.txt b/crypto/CMakeLists.txt
@@ -151,6 +151,7 @@ set(TON_DB_SOURCE
   vm/db/CellHashTable.h
   vm/db/CellStorage.h
   vm/db/TonDb.h
+  vm/db/InMemoryBagOfCellsDb.cpp
 )
 
 set(FIFT_SOURCE

diff --git a/crypto/block/mc-config.cpp b/crypto/block/mc-config.cpp
@@ -320,7 +320,7 @@ ton::ValidatorSessionConfig Config::get_consensus_config() const {
     c.max_block_size = r.max_block_bytes;
     c.max_collated_data_size = r.max_collated_bytes;
   };
-  auto set_v2 = [&] (auto& r) {
+  auto set_v2 = [&](auto& r) {
     set_v1(r);
     c.new_catchain_ids = r.new_catchain_ids;
   };
@@ -1940,7 +1940,7 @@ td::Result<SizeLimitsConfig> Config::get_size_limits_config() const {
 td::Result<SizeLimitsConfig> Config::do_get_size_limits_config(td::Ref<vm::CellSlice> cs) {
   SizeLimitsConfig limits;
   if (cs.is_null()) {
-    return limits; // default values
+    return limits;  // default values
   }
   auto unpack_v1 = [&](auto& rec) {
     limits.max_msg_bits = rec.max_msg_bits;
@@ -2299,17 +2299,14 @@ td::Result<Ref<vm::Tuple>> ConfigInfo::get_prev_blocks_info() const {
     if (shard->sgn() < 0) {
       shard &= ((td::make_refint(1) << 64) - 1);
     }
-    return vm::make_tuple_ref(
-        td::make_refint(block_id.id.workchain),
-        std::move(shard),
-        td::make_refint(block_id.id.seqno),
-        td::bits_to_refint(block_id.root_hash.bits(), 256),
-        td::bits_to_refint(block_id.file_hash.bits(), 256));
+    return vm::make_tuple_ref(td::make_refint(block_id.id.workchain), std::move(shard),
+                              td::make_refint(block_id.id.seqno), td::bits_to_refint(block_id.root_hash.bits(), 256),
+                              td::bits_to_refint(block_id.file_hash.bits(), 256));
   };
   std::vector<vm::StackEntry> last_mc_blocks;
 
   last_mc_blocks.push_back(block_id_to_tuple(block_id));
-  for (ton::BlockSeqno seqno = block_id.id.seqno; seqno > 0 && last_mc_blocks.size() < 16; ) {
+  for (ton::BlockSeqno seqno = block_id.id.seqno; seqno > 0 && last_mc_blocks.size() < 16;) {
     --seqno;
     ton::BlockIdExt block_id;
     if (!get_old_mc_block_id(seqno, block_id)) {
@@ -2323,9 +2320,8 @@ td::Result<Ref<vm::Tuple>> ConfigInfo::get_prev_blocks_info() const {
   if (!get_last_key_block(last_key_block, last_key_block_lt)) {
     return td::Status::Error("cannot fetch last key block");
   }
-  return vm::make_tuple_ref(
-      td::make_cnt_ref<std::vector<vm::StackEntry>>(std::move(last_mc_blocks)),
-      block_id_to_tuple(last_key_block));
+  return vm::make_tuple_ref(td::make_cnt_ref<std::vector<vm::StackEntry>>(std::move(last_mc_blocks)),
+                            block_id_to_tuple(last_key_block));
 }
 
 td::optional<PrecompiledContractsConfig::Contract> PrecompiledContractsConfig::get_contract(

diff --git a/crypto/block/mc-config.h b/crypto/block/mc-config.h
@@ -197,6 +197,7 @@ struct McShardHash : public McShardHashI {
       : blk_(blk), start_lt_(start_lt), end_lt_(end_lt) {
   }
   McShardHash(const McShardHash&) = default;
+  McShardHash& operator=(const McShardHash&) = default;
   bool is_valid() const {
     return blk_.is_valid();
   }
@@ -545,7 +546,10 @@ class Config {
   };
 
  public:
-  enum { needValidatorSet = 16, needSpecialSmc = 32, needWorkchainInfo = 256, needCapabilities = 512 };
+  static constexpr int needValidatorSet = 16;
+  static constexpr int needSpecialSmc = 32;
+  static constexpr int needWorkchainInfo = 256;
+  static constexpr int needCapabilities = 512;
   int mode{0};
   ton::BlockIdExt block_id;
 
@@ -682,14 +686,12 @@ class Config {
 
 class ConfigInfo : public Config, public ShardConfig {
  public:
-  enum {
-    needStateRoot = 1,
-    needLibraries = 2,
-    needStateExtraRoot = 4,
-    needShardHashes = 8,
-    needAccountsRoot = 64,
-    needPrevBlocks = 128
-  };
+  static constexpr int needStateRoot = 1;
+  static constexpr int needLibraries = 2;
+  static constexpr int needStateExtraRoot = 4;
+  static constexpr int needShardHashes = 8;
+  static constexpr int needAccountsRoot = 64;
+  static constexpr int needPrevBlocks = 128;
   ton::BlockSeqno vert_seqno{~0U};
   int global_id_{0};
   ton::UnixTime utime{0};

diff --git a/crypto/block/transaction.cpp b/crypto/block/transaction.cpp
@@ -2860,22 +2860,26 @@ td::Status Transaction::check_state_limits(const SizeLimitsConfig& size_limits,
   vm::CellStorageStat storage_stat;
   storage_stat.limit_cells = size_limits.max_acc_state_cells;
   storage_stat.limit_bits = size_limits.max_acc_state_bits;
-  td::Timer timer;
-  auto add_used_storage = [&](const td::Ref<vm::Cell>& cell) -> td::Status {
-    if (cell.not_null()) {
-      TRY_RESULT(res, storage_stat.add_used_storage(cell));
-      if (res.max_merkle_depth > max_allowed_merkle_depth) {
-        return td::Status::Error("too big merkle depth");
+  {
+    TD_PERF_COUNTER(transaction_storage_stat_a);
+    td::Timer timer;
+    auto add_used_storage = [&](const td::Ref<vm::Cell>& cell) -> td::Status {
+      if (cell.not_null()) {
+        TRY_RESULT(res, storage_stat.add_used_storage(cell));
+        if (res.max_merkle_depth > max_allowed_merkle_depth) {
+          return td::Status::Error("too big merkle depth");
+        }
       }
+      return td::Status::OK();
+    };
+    TRY_STATUS(add_used_storage(new_code));
+    TRY_STATUS(add_used_storage(new_data));
+    TRY_STATUS(add_used_storage(new_library));
+    if (timer.elapsed() > 0.1) {
+      LOG(INFO) << "Compute used storage took " << timer.elapsed() << "s";
     }
-    return td::Status::OK();
-  };
-  TRY_STATUS(add_used_storage(new_code));
-  TRY_STATUS(add_used_storage(new_data));
-  TRY_STATUS(add_used_storage(new_library));
-  if (timer.elapsed() > 0.1) {
-    LOG(INFO) << "Compute used storage took " << timer.elapsed() << "s";
   }
+
   if (acc_status == Account::acc_active) {
     storage_stat.clear_limit();
   } else {
@@ -3156,6 +3160,7 @@ bool Transaction::compute_state() {
   if (new_stats) {
     stats = new_stats.unwrap();
   } else {
+    TD_PERF_COUNTER(transaction_storage_stat_b);
     td::Timer timer;
     stats.add_used_storage(Ref<vm::Cell>(storage)).ensure();
     if (timer.elapsed() > 0.1) {

diff --git a/crypto/common/bigint.hpp b/crypto/common/bigint.hpp
@@ -2294,11 +2294,11 @@ std::string AnyIntView<Tr>::to_dec_string_destroy_any() {
     stack.push_back(divmod_short_any(Tr::max_pow10));
   } while (sgn());
   char slice[word_bits * 97879 / 325147 + 2];
-  std::sprintf(slice, "%lld", stack.back());
+  std::snprintf(slice, sizeof(slice), "%lld", stack.back());
   s += slice;
   stack.pop_back();
   while (stack.size()) {
-    std::sprintf(slice, "%018lld", stack.back());
+    std::snprintf(slice, sizeof(slice), "%018lld", stack.back());
     s += slice;
     stack.pop_back();
   }

diff --git a/crypto/common/refcnt.cpp b/crypto/common/refcnt.cpp
@@ -29,6 +29,7 @@ Ref<CntObject> CntObject::clone() const {
 namespace detail {
 struct SafeDeleter {
  public:
+  thread_local static td::int64 delete_count;
   void retire(const CntObject *ptr) {
     if (is_active_) {
       to_delete_.push_back(ptr);
@@ -39,9 +40,11 @@ struct SafeDeleter {
       is_active_ = false;
     };
     delete ptr;
+    delete_count++;
     while (!to_delete_.empty()) {
       auto *ptr = to_delete_.back();
       to_delete_.pop_back();
+      delete_count++;
       delete ptr;
     }
   }
@@ -50,11 +53,15 @@ struct SafeDeleter {
   std::vector<const CntObject *> to_delete_;
   bool is_active_{false};
 };
+thread_local td::int64 SafeDeleter::delete_count{0};
 
 TD_THREAD_LOCAL SafeDeleter *deleter;
 void safe_delete(const CntObject *ptr) {
   init_thread_local<SafeDeleter>(deleter);
   deleter->retire(ptr);
 }
 }  // namespace detail
+int64 ref_get_delete_count() {
+  return detail::SafeDeleter::delete_count;
+}
 }  // namespace td
diff --git a/crypto/common/refcnt.hpp b/crypto/common/refcnt.hpp
@@ -472,5 +472,6 @@ template <class T>
 void swap(Ref<T>& r1, Ref<T>& r2) {
   r1.swap(r2);
 }
+int64 ref_get_delete_count();
 
 }  // namespace td
diff --git a/crypto/fift/words.cpp b/crypto/fift/words.cpp
@@ -3425,7 +3425,7 @@ void import_cmdline_args(Dictionary& d, std::string arg0, int n, const char* con
   cmdline_args->set(std::move(list));
   for (int i = 1; i <= n; i++) {
     char buffer[14];
-    sprintf(buffer, "$%d ", i);
+    snprintf(buffer, sizeof(buffer), "$%d ", i);
     d.def_stack_word(buffer, std::bind(interpret_get_fixed_cmdline_arg, _1, i));
   }
 }

diff --git a/crypto/func/analyzer.cpp b/crypto/func/analyzer.cpp
@@ -81,7 +81,7 @@ bool CodeBlob::compute_used_code_vars(std::unique_ptr<Op>& ops_ptr, const VarDes
     func_assert(ops_ptr->cl == Op::_Nop);
     return ops_ptr->set_var_info(var_info);
   }
-  return compute_used_code_vars(ops_ptr->next, var_info, edit) | ops_ptr->compute_used_vars(*this, edit);
+  return int(compute_used_code_vars(ops_ptr->next, var_info, edit)) | int(ops_ptr->compute_used_vars(*this, edit));
 }
 
 bool operator==(const VarDescrList& x, const VarDescrList& y) {
@@ -584,7 +584,7 @@ bool prune_unreachable(std::unique_ptr<Op>& ops) {
         ops = std::move(op.block1);
         return prune_unreachable(ops);
       } else {
-        reach = prune_unreachable(op.block0) | prune_unreachable(op.block1);
+        reach = int(prune_unreachable(op.block0)) | int(prune_unreachable(op.block1));
       }
       break;
     }
@@ -660,7 +660,7 @@ bool prune_unreachable(std::unique_ptr<Op>& ops) {
       break;
     }
     case Op::_TryCatch: {
-      reach = prune_unreachable(op.block0) | prune_unreachable(op.block1);
+      reach = int(prune_unreachable(op.block0)) | int(prune_unreachable(op.block1));
       break;
     }
     default:
@@ -892,15 +892,15 @@ bool Op::mark_noreturn() {
       return set_noreturn(true);
     case _If:
     case _TryCatch:
-      return set_noreturn((block0->mark_noreturn() & (block1 && block1->mark_noreturn())) | next->mark_noreturn());
+      return set_noreturn((int(block0->mark_noreturn()) & int(block1 && block1->mark_noreturn())) | int(next->mark_noreturn()));
     case _Again:
       block0->mark_noreturn();
       return set_noreturn(true);
     case _Until:
-      return set_noreturn(block0->mark_noreturn() | next->mark_noreturn());
+      return set_noreturn(int(block0->mark_noreturn()) | int(next->mark_noreturn()));
     case _While:
       block1->mark_noreturn();
-      return set_noreturn(block0->mark_noreturn() | next->mark_noreturn());
+      return set_noreturn(int(block0->mark_noreturn()) | int(next->mark_noreturn()));
     case _Repeat:
       block0->mark_noreturn();
       return set_noreturn(next->mark_noreturn());

diff --git a/crypto/openssl/digest.hpp b/crypto/openssl/digest.hpp
@@ -48,6 +48,7 @@ struct OpensslEVP_SHA512 {
 
 template <typename H>
 class HashCtx {
+  EVP_MD_CTX *base_ctx{nullptr};
   EVP_MD_CTX *ctx{nullptr};
   void init();
   void clear();
@@ -77,16 +78,20 @@ class HashCtx {
 template <typename H>
 void HashCtx<H>::init() {
   ctx = EVP_MD_CTX_create();
+  base_ctx = EVP_MD_CTX_create();
+  EVP_DigestInit_ex(base_ctx, H::get_evp(), 0);
   reset();
 }
 
 template <typename H>
 void HashCtx<H>::reset() {
-  EVP_DigestInit_ex(ctx, H::get_evp(), 0);
+  EVP_MD_CTX_copy_ex(ctx, base_ctx);
 }
 
 template <typename H>
 void HashCtx<H>::clear() {
+  EVP_MD_CTX_destroy(base_ctx);
+  base_ctx = nullptr;
   EVP_MD_CTX_destroy(ctx);
   ctx = nullptr;
 }