Rollback celldb optimization (#658)

crypto/vm/db/CellHashTable.h

@@ -43,7 +43,7 @@ class CellHashTable {
   template <class F>
   void for_each(F &&f) {
     for (auto &info : set_) {
-      f(const_cast<InfoT &>(info));
+      f(info);
     }
   }
   template <class F>

crypto/vm/db/CellStorage.cpp

@@ -150,20 +150,6 @@ td::Result<CellLoader::LoadResult> CellLoader::load(td::Slice hash, bool need_da
   return res;
 }
 
-td::Result<CellLoader::LoadResult> CellLoader::load_refcnt(td::Slice hash) {
-  LoadResult res;
-  std::string serialized;
-  TRY_RESULT(get_status, reader_->get(hash, serialized));
-  if (get_status != KeyValue::GetStatus::Ok) {
-    DCHECK(get_status == KeyValue::GetStatus::NotFound);
-    return res;
-  }
-  res.status = LoadResult::Ok;
-  td::TlParser parser(serialized);
-  td::parse(res.refcnt_, parser);
-  return res;
-}
-
 CellStorer::CellStorer(KeyValue &kv) : kv_(kv) {
 }
 

crypto/vm/db/CellStorage.h

@@ -48,7 +48,6 @@ class CellLoader {
   };
   CellLoader(std::shared_ptr<KeyValueReader> reader);
   td::Result<LoadResult> load(td::Slice hash, bool need_data, ExtCellCreator &ext_cell_creator);
-  td::Result<LoadResult> load_refcnt(td::Slice hash);  // This only loads refcnt_, cell_ == null
 
  private:
   std::shared_ptr<KeyValueReader> reader_;

crypto/vm/db/DynamicBagOfCellsDb.cpp

@@ -27,9 +27,6 @@
 #include "td/utils/ThreadSafeCounter.h"
 
 #include "vm/cellslice.h"
-#include <queue>
-#include "td/actor/actor.h"
-#include "common/delay.h"
 
 namespace vm {
 namespace {
@@ -558,177 +555,6 @@ class DynamicBagOfCellsDbImpl : public DynamicBagOfCellsDb, private ExtCellCreat
                                               DynamicBocExtCellExtra{cell_db_reader_}));
     return std::move(res);
   }
-
-  struct PrepareCommitAsyncState {
-    size_t remaining_ = 0;
-    std::shared_ptr<AsyncExecutor> executor_;
-    td::Promise<td::Unit> promise_;
-
-    struct CellInfo2 {
-      CellInfo *info;
-      std::vector<CellInfo2 *> parents;
-      unsigned remaining_children = 0;
-      Cell::Hash key() const {
-        return info->key();
-      }
-      bool operator<(const CellInfo2 &other) const {
-        return key() < other.key();
-      }
-
-      friend bool operator<(const CellInfo2 &a, td::Slice b) {
-        return a.key().as_slice() < b;
-      }
-
-      friend bool operator<(td::Slice a, const CellInfo2 &b) {
-        return a < b.key().as_slice();
-      }
-    };
-
-    CellHashTable<CellInfo2> cells_;
-  };
-  std::unique_ptr<PrepareCommitAsyncState> pca_state_;
-
-  void prepare_commit_async(std::shared_ptr<AsyncExecutor> executor, td::Promise<td::Unit> promise) override {
-    if (pca_state_) {
-      promise.set_error(td::Status::Error("Other prepare_commit_async is not finished"));
-      return;
-    }
-    if (is_prepared_for_commit()) {
-      promise.set_result(td::Unit());
-      return;
-    }
-    pca_state_ = std::make_unique<PrepareCommitAsyncState>();
-    pca_state_->executor_ = std::move(executor);
-    pca_state_->promise_ = std::move(promise);
-    for (auto &new_cell : to_inc_) {
-      dfs_new_cells_in_db_async(new_cell);
-    }
-    pca_state_->cells_.for_each([&](PrepareCommitAsyncState::CellInfo2 &info) {
-      ++pca_state_->remaining_;
-      if (info.remaining_children == 0) {
-        pca_load_from_db(&info);
-      }
-    });
-    if (pca_state_->remaining_ == 0) {
-      prepare_commit_async_cont();
-    }
-  }
-
-  void dfs_new_cells_in_db_async(const td::Ref<vm::Cell> &cell, PrepareCommitAsyncState::CellInfo2 *parent = nullptr) {
-    bool exists = true;
-    pca_state_->cells_.apply(cell->get_hash().as_slice(), [&](PrepareCommitAsyncState::CellInfo2 &info) {
-      if (info.info == nullptr) {
-        exists = false;
-        info.info = &get_cell_info(cell);
-      }
-    });
-    auto info = pca_state_->cells_.get_if_exists(cell->get_hash().as_slice());
-    if (parent) {
-      info->parents.push_back(parent);
-      ++parent->remaining_children;
-    }
-    if (exists) {
-      return;
-    }
-    if (cell->is_loaded()) {
-      vm::CellSlice cs(vm::NoVm{}, cell);
-      for (unsigned i = 0; i < cs.size_refs(); i++) {
-        dfs_new_cells_in_db_async(cs.prefetch_ref(i), info);
-      }
-    }
-  }
-
-  void pca_load_from_db(PrepareCommitAsyncState::CellInfo2 *info) {
-    pca_state_->executor_->execute_async(
-        [db = this, info, executor = pca_state_->executor_, loader = *loader_]() mutable {
-          auto res = loader.load_refcnt(info->info->cell->get_hash().as_slice()).move_as_ok();
-          executor->execute_sync([db, info, res = std::move(res)]() {
-            db->pca_set_in_db(info, std::move(res));
-          });
-        });
-  }
-
-  void pca_set_in_db(PrepareCommitAsyncState::CellInfo2 *info, CellLoader::LoadResult result) {
-    info->info->sync_with_db = true;
-    if (result.status == CellLoader::LoadResult::Ok) {
-      info->info->in_db = true;
-      info->info->db_refcnt = result.refcnt();
-    } else {
-      info->info->in_db = false;
-    }
-    for (PrepareCommitAsyncState::CellInfo2 *parent_info : info->parents) {
-      if (parent_info->info->sync_with_db) {
-        continue;
-      }
-      if (!info->info->in_db) {
-        pca_set_in_db(parent_info, {});
-      } else if (--parent_info->remaining_children == 0) {
-        pca_load_from_db(parent_info);
-      }
-    }
-    if (--pca_state_->remaining_ == 0) {
-      prepare_commit_async_cont();
-    }
-  }
-
-  void prepare_commit_async_cont() {
-    for (auto &new_cell : to_inc_) {
-      auto &new_cell_info = get_cell_info(new_cell);
-      dfs_new_cells(new_cell_info);
-    }
-
-    CHECK(pca_state_->remaining_ == 0);
-    for (auto &old_cell : to_dec_) {
-      auto &old_cell_info = get_cell_info(old_cell);
-      dfs_old_cells_async(old_cell_info);
-    }
-    if (pca_state_->remaining_ == 0) {
-      prepare_commit_async_cont2();
-    }
-  }
-
-  void dfs_old_cells_async(CellInfo &info) {
-    if (!info.was) {
-      info.was = true;
-      visited_.push_back(&info);
-      if (!info.sync_with_db) {
-        ++pca_state_->remaining_;
-        load_cell_async(
-            info.cell->get_hash().as_slice(), pca_state_->executor_,
-            [executor = pca_state_->executor_, db = this, info = &info](td::Result<td::Ref<vm::DataCell>> R) {
-              R.ensure();
-              executor->execute_sync([db, info]() {
-                CHECK(info->sync_with_db);
-                db->dfs_old_cells_async(*info);
-                if (--db->pca_state_->remaining_ == 0) {
-                  db->prepare_commit_async_cont2();
-                }
-              });
-            });
-        return;
-      }
-    }
-    info.refcnt_diff--;
-    if (!info.sync_with_db) {
-      return;
-    }
-    auto new_refcnt = info.refcnt_diff + info.db_refcnt;
-    CHECK(new_refcnt >= 0);
-    if (new_refcnt != 0) {
-      return;
-    }
-
-    for_each(info, [this](auto &child_info) { dfs_old_cells_async(child_info); });
-  }
-
-  void prepare_commit_async_cont2() {
-    save_diff_prepare();
-    to_inc_.clear();
-    to_dec_.clear();
-    pca_state_->promise_.set_result(td::Unit());
-    pca_state_ = {};
-  }
-
 };
 }  // namespace
 

crypto/vm/db/DynamicBagOfCellsDb.h

@@ -75,7 +75,6 @@ class DynamicBagOfCellsDb {
 
   virtual void load_cell_async(td::Slice hash, std::shared_ptr<AsyncExecutor> executor,
                                td::Promise<Ref<DataCell>> promise) = 0;
-  virtual void prepare_commit_async(std::shared_ptr<AsyncExecutor> executor, td::Promise<td::Unit> promise) = 0;
 };
 
 }  // namespace vm