Final touches

Author: avevad

crypto/vm/cells/CellUsageContainer.h

@@ -5,36 +5,40 @@
 #include <vector>
 #include <mutex>
 
+/**
+ * Thread-safe container for storing cell usage tree nodes.
+ * @tparam T node type
+ */
 template <typename T>
-class DynamicArray {
-  static constexpr size_t kBlockSize = std::max(1ul, 4096 / sizeof(T));
-  static constexpr size_t kDefaultSize = 512;
+class CellUsageContainer {
+  static constexpr size_t BLOCK_SIZE = std::max(1ul, 4096 / sizeof(T));
+  static constexpr size_t DEFAULT_CAP = 512;
 
  public:
-  explicit DynamicArray(size_t initial_size) : size_(0), cap_(0) {
+  explicit CellUsageContainer(size_t initial_size) : size_(0), cap_(0) {
     static_assert(std::atomic<T**>::is_always_lock_free);
-    resize(0, (std::max(kDefaultSize, initial_size) + kBlockSize - 1) / kBlockSize);
+    ensure_capacity(0, (std::max(DEFAULT_CAP, initial_size) + BLOCK_SIZE - 1) / BLOCK_SIZE);
     size_ = initial_size;
   }
 
   const T& operator[](size_t i) const {
-    return pointer_[i / kBlockSize][i % kBlockSize];
+    return pointer_[i / BLOCK_SIZE][i % BLOCK_SIZE];
   }
 
   T& operator[](size_t i) {
-    return pointer_[i / kBlockSize][i % kBlockSize];
+    return pointer_[i / BLOCK_SIZE][i % BLOCK_SIZE];
   }
 
   size_t emplace_back() {
     size_t pos = size_.fetch_add(1);
     size_t current_cap;
-    while (pos / kBlockSize >= (current_cap = cap_.load())) {
-      resize(current_cap, 2 * current_cap);
+    while (pos / BLOCK_SIZE >= (current_cap = cap_.load())) {
+      ensure_capacity(current_cap, 2 * current_cap);
     }
     return pos;
   }
 
-  ~DynamicArray() {
+  ~CellUsageContainer() {
     for (size_t i = 0; i < cap_; ++i) {
       delete[] pointer_[i];
     }
@@ -53,7 +57,7 @@ class DynamicArray {
 
   std::vector<T**> storage_;
 
-  void resize(size_t current_cap, size_t target_cap) {
+  void ensure_capacity(size_t current_cap, size_t target_cap) {
     std::lock_guard lock(resize_lock_);
     if (current_cap != cap_) {
       return;
@@ -64,7 +68,7 @@ class DynamicArray {
       new_data[i] = pointer_[i];
     }
     for (size_t i = cap_; i < target_cap; ++i) {
-      new_data[i] = new T[kBlockSize];
+      new_data[i] = new T[BLOCK_SIZE];
     }
     storage_.emplace_back(new_data);
     pointer_.store(new_data);

crypto/vm/cells/CellUsageTree.cpp

@@ -19,8 +19,6 @@
 #include "vm/cells/CellUsageTree.h"
 #include "DataCell.h"
 
-#include <mutex>
-
 namespace vm {
 //
 // CellUsageTree::NodePtr

crypto/vm/cells/CellUsageTree.h

@@ -87,7 +87,7 @@ class CellUsageTree : public std::enable_shared_from_this<CellUsageTree> {
     std::array<td::uint32, CellTraits::max_refs> children{};
   };
   bool use_mark_{false};
-  DynamicArray<Node> nodes_{2};
+  CellUsageContainer<Node> nodes_{2};
   std::function<void(const LoadedCell&)> cell_load_callback_;
 
   void on_load(NodeId node_id, const LoadedCell& loaded_cell);

crypto/vm/dict.cpp

@@ -180,7 +180,7 @@ bool DictionaryBase::append_dict_to_bool(CellBuilder& cb) && {
   return cb.store_maybe_ref(std::move(root_cell));
 }
 
-bool DictionaryBase::append_dict_to_bool(CellBuilder& cb) const& {
+bool DictionaryBase::append_dict_to_bool(CellBuilder& cb) const & {
   return is_valid() && cb.store_maybe_ref(root_cell);
 }
 
@@ -1102,8 +1102,8 @@ Ref<CellSlice> Dictionary::lookup_set_gen(td::ConstBitPtr key, int key_len, cons
 }
 
 Ref<CellSlice> Dictionary::lookup_set(td::ConstBitPtr key, int key_len, Ref<CellSlice> value, SetMode mode) {
-  return lookup_set_gen(
-      key, key_len, [value](CellBuilder& cb) { return cell_builder_add_slice_bool(cb, *value); }, mode);
+  return lookup_set_gen(key, key_len, [value](CellBuilder& cb) { return cell_builder_add_slice_bool(cb, *value); },
+                      mode);
 }
 
 Ref<Cell> Dictionary::lookup_set_ref(td::ConstBitPtr key, int key_len, Ref<Cell> val_ref, SetMode mode) {
@@ -2282,7 +2282,7 @@ bool DictionaryFixed::dict_check_for_each(Ref<Cell> dict, td::BitPtr key_buffer,
   if (l) {
     invert_first = false;
   }
-  bool invert = shuffle ? td::Random::fast(0, 1) == 1 : invert_first;
+  bool invert = shuffle ? td::Random::fast(0, 1) == 1: invert_first;
   if (invert) {
     std::swap(c1, c2);
   }
@@ -2804,7 +2804,7 @@ Ref<CellSlice> AugmentedDictionary::extract_root() && {
   return std::move(root);
 }
 
-bool AugmentedDictionary::append_dict_to_bool(CellBuilder& cb) const& {
+bool AugmentedDictionary::append_dict_to_bool(CellBuilder& cb) const & {
   if (!is_valid()) {
     return false;
   }

crypto/vm/dict.h

@@ -138,7 +138,7 @@ class DictionaryBase {
     return std::move(root_cell);
   }
   bool append_dict_to_bool(CellBuilder& cb) &&;
-  bool append_dict_to_bool(CellBuilder& cb) const&;
+  bool append_dict_to_bool(CellBuilder& cb) const &;
   int get_key_bits() const {
     return key_bits;
   }
@@ -575,7 +575,7 @@ class AugmentedDictionary final : public DictionaryFixed {
   Ref<Cell> get_wrapped_dict_root() const;
   Ref<CellSlice> extract_root() &&;
   bool append_dict_to_bool(CellBuilder& cb) &&;
-  bool append_dict_to_bool(CellBuilder& cb) const&;
+  bool append_dict_to_bool(CellBuilder& cb) const &;
   Ref<CellSlice> get_root_extra() const;
   Ref<CellSlice> lookup(td::ConstBitPtr key, int key_len);
   Ref<Cell> lookup_ref(td::ConstBitPtr key, int key_len);

validator-engine/validator-engine.cpp

@@ -5483,7 +5483,7 @@ int main(int argc, char *argv[]) {
       });
   p.add_option(
       '\0', "celldb-disable-bloom-filter",
-      "disable using bloom filter in CellDb. Enabled bloom filter reduces read latency, but increases memory usage", 
+      "disable using bloom filter in CellDb. Enabled bloom filter reduces read latency, but increases memory usage",
       [&]() {
         acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_celldb_disable_bloom_filter, true); });
       });
@@ -5598,13 +5598,9 @@ int main(int argc, char *argv[]) {
                          }
                          return td::Status::OK();
                        });
-  p.add_option(
-      '\0', "parallel-accounts-validation",
-      "parallel validation over different accounts",
-      [&]() {
-        acts.push_back(
-            [&x]() { td::actor::send_closure(x, &ValidatorEngine::set_parallel_accounts_validation, true); });
-      });
+  p.add_option('\0', "parallel-accounts-validation", "parallel validation over different accounts", [&]() {
+    acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_parallel_accounts_validation, true); });
+  });
   auto S = p.run(argc, argv);
   if (S.is_error()) {
     LOG(ERROR) << "failed to parse options: " << S.move_as_error();