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

…rldp2 (#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 <>
ton-blockchain · Sep 23, 2024 · 72020c0 · 72020c0
1 parent 5f51d3d
commit 72020c0
Show file tree

Hide file tree

Showing 100 changed files with 3,406 additions and 358 deletions.
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;
 }