Change unionStorage.

Signed-off-by: Markuu-s <[email protected]>

Author: Markuu-s

core/miner/storage_fsm/commit_batcher.hpp

@@ -21,7 +21,6 @@ namespace fc::mining {
     RegisteredSealProof spt;
   };
 
-
   class CommitBatcher {
    public:
     virtual ~CommitBatcher() = default;

core/miner/storage_fsm/impl/commit_batcher_impl.cpp

@@ -9,14 +9,12 @@
 #include "vm/actor/builtin/v5/miner/miner_actor.hpp"
 
 namespace fc::mining {
-  using vm::actor::builtin::types::miner::kChainFinality;
-  using PairStorage = CommitBatcherImpl::UnionStorage::PairStorage;
   using fc::primitives::ActorId;
   using primitives::BigInt;
   using primitives::sector::AggregateSealVerifyInfo;
+  using vm::actor::builtin::types::miner::kChainFinality;
   using vm::actor::builtin::types::miner::SectorPreCommitOnChainInfo;
   using vm::actor::builtin::v5::miner::ProveCommitAggregate;
-  namespace vm::actor::builtin::types::miner::SectorPreCommitOnChainInfo;
 
   CommitBatcherImpl::CommitBatcherImpl(
       const std::chrono::milliseconds &max_time,
@@ -32,10 +30,12 @@ namespace fc::mining {
       const SectorInfo &sector_info,
       const AggregateInput &aggregate_input,
       const CommitCallback &callback) {
+    std::unique_lock<std::mutex> locker(mutex_storage_);
+
     const SectorNumber &sector_number = sector_info.sector_number;
     OUTCOME_TRY(head, api_->ChainHead());
 
-    union_storage_.push(sector_number, PairStorage(aggregate_input, callback));
+    union_storage_[sector_number] = PairStorage{aggregate_input, callback};
 
     if (union_storage_.size() >= max_size_callback_) {
       sendCallbacks();
@@ -49,7 +49,12 @@ namespace fc::mining {
   void CommitBatcherImpl::forceSend() {}
 
   void CommitBatcherImpl::sendCallbacks() {
-    UnionStorage union_storage_for_send_(std::move(union_storage_));
+    std::unique_lock<std::mutex> locker(mutex_storage_);
+    MapPairStorage union_storage_for_send_(
+        std::make_move_iterator(union_storage_.begin()),
+        std::make_move_iterator(union_storage_.end()));
+    locker.unlock();
+
     const auto maybe_result = sendBatch(union_storage_for_send_);
     for (const auto &[key, pair_storage] : union_storage_for_send_) {
       pair_storage.commit_callback(maybe_result);
@@ -62,8 +67,8 @@ namespace fc::mining {
   }
 
   outcome::result<CID> CommitBatcherImpl::sendBatch(
-      UnionStorage &union_storage_for_send) {
-    if (not union_storage_for_send.size()) {
+      MapPairStorage &union_storage_for_send) {
+    if (union_storage_for_send.empty()) {
       cutoff_start_ = std::chrono::system_clock::now();
       return ERROR_TEXT("Empty Batcher");
     }
@@ -80,26 +85,24 @@ namespace fc::mining {
     BigInt collateral = 0;
 
     for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
-
-
-      TokenAmount sc = getSectorCollateral(head, sector_number, *head.get());
+      OUTCOME_TRY(sc, getSectorCollateral(sector_number, head->key));
       collateral = collateral + sc;
 
       params.sectors.insert(sector_number);
     }
 
-
-
     for (const auto &[sector_number, pair_storage] : union_storage_for_send) {
-      proofs.push_back(
-          pair_storage.aggregate_input.proof);
+      proofs.push_back(pair_storage.aggregate_input.proof);
     }
 
     const ActorId mid = miner_address_.getId();
     // TODO maybe long (AggregateSealProofs)
-    params.proof = proof_->AggregateSealProofs(); // OUTCOME_TRY
 
-    // TODO CBOR::ENCODE params
+    // TODO params.proof = proof_->AggregateSealProofs(); // OUTCOME_TRY
+    OUTCOME_TRY(a, proof_->AggregateSealProofs());
+
+    auto enc = codec::cbor::encode(params);
+    OUTCOME_TRY(mi, api_->StateMinerInfo(miner_address_, head->key));
 
     // BigDiv usage вместо /(обычное деление)
 
@@ -115,16 +118,16 @@ namespace fc::mining {
      */
     // OTCOME_TRY(mi, api_->StateMinerInfo());
 
-    OUTCOME_TRY(bf, api_->ChainBaseFee(head));
-    OUTCOME_TRY(nv, api_->StateNetworkVersion(/*NetworkVersion*/, head));
+    // TODO OUTCOME_TRY(bf, api_->ChainBaseFee(head));
+    OUTCOME_TRY(nv, api_->StateNetworkVersion(head->key));
   }
 
   void CommitBatcherImpl::setCommitCutoff(const ChainEpoch &current_epoch,
                                           const SectorInfo &sector_info) {
     ChainEpoch cutoff_epoch =
         sector_info.ticket_epoch
         + static_cast<int64_t>(kEpochsInDay + kChainFinality);
-    ChainEpoch start_epoch{};
+    ChainEpoch start_epoch;
     for (const auto &piece : sector_info.pieces) {
       if (!piece.deal_info) {
         continue;
@@ -150,58 +153,20 @@ namespace fc::mining {
     }
   }
 
-  TokenAmount CommitBatcherImpl::getSectorCollateral(
-      std::shared_ptr<const Tipset> &head,
-      const SectorNumber &sector_number,
-      const TipsetKey &tip_set_key) {
+  outcome::result<TokenAmount> CommitBatcherImpl::getSectorCollateral(
+      const SectorNumber &sector_number, const TipsetKey &tip_set_key) {
     OUTCOME_TRY(pci,
                 api_->StateSectorPreCommitInfo(
                     miner_address_, sector_number, tip_set_key));
+
     OUTCOME_TRY(collateral,
                 api_->StateMinerInitialPledgeCollateral(
-                    miner_address_, head->key, pci.info, tip_set_key));
+                    miner_address_, pci.info, tip_set_key));
 
-    collateral = collateral + pci.PreCommitDeposit;
-    collateral = max(0, collateral);
+    collateral = collateral + pci.precommit_deposit;
+    collateral = std::max(BigInt(0), collateral);
 
     return collateral;
   }
 
-  void CommitBatcherImpl::UnionStorage::push(const SectorNumber &sector_number,
-                                             const PairStorage &pair_storage) {
-    std::unique_lock<std::mutex> locker(mutex_);
-    storage_[sector_number] = pair_storage;
-  }
-
-  CommitBatcherImpl::UnionStorage::UnionStorage(
-      CommitBatcherImpl::UnionStorage &&union_storage1) {
-    std::unique_lock<std::mutex> locker(union_storage1.mutex_);
-    storage_.insert(std::make_move_iterator(union_storage1.storage_.begin()),
-                    std::make_move_iterator(union_storage1.storage_.end()));
-  }
-
-  size_t CommitBatcherImpl::UnionStorage::size()  {
-    std::unique_lock<std::mutex> locker(mutex_);
-    return storage_.size();
-  }
-
-  CommitBatcherImpl::UnionStorage::PairStorage::PairStorage(
-      const AggregateInput &aggregate_input,
-      const CommitCallback &commit_callback)
-      : aggregate_input(aggregate_input), commit_callback(commit_callback) {}
-
-  std::map<SectorNumber, CommitBatcherImpl::UnionStorage::PairStorage>::iterator
-  CommitBatcherImpl::UnionStorage::begin() {
-    return storage_.begin();
-  }
-
-  std::map<SectorNumber, CommitBatcherImpl::UnionStorage::PairStorage>::iterator
-  CommitBatcherImpl::UnionStorage::end() {
-    return storage_.end();
-  }
-
-  PairStorage CommitBatcherImpl::UnionStorage::get(const int index) {
-    std::unique_lock<std::mutex> locker(mutex_);
-    return storage_[index];
-  }
 }  // namespace fc::mining

core/miner/storage_fsm/impl/commit_batcher_impl.hpp

@@ -14,43 +14,16 @@ namespace fc::mining {
   using primitives::address::Address;
   using primitives::tipset::Tipset;
   using primitives::tipset::TipsetKey;
-  using types::FeeConfig;
   using proofs::ProofEngine;
+  using types::FeeConfig;
 
   class CommitBatcherImpl : public CommitBatcher {
    public:
-    class UnionStorage {
-     public:
-      UnionStorage() = default;
-      UnionStorage(UnionStorage &&);
-
-      UnionStorage(const UnionStorage &) = delete;
-
-      ~UnionStorage() = default;
-
-      struct PairStorage {
-        AggregateInput aggregate_input;
-        CommitCallback commit_callback;
-
-        PairStorage(const AggregateInput &aggregate_input,
-                    const CommitCallback &commit_callback);
-      };
-
-      void push(const SectorNumber &sector_number,
-                const PairStorage &pair_storage);
-
-      size_t size();
-
-      PairStorage get(const int index);
-
-      std::map<SectorNumber, PairStorage>::iterator begin();
-      std::map<SectorNumber, PairStorage>::iterator end();
-
-     private:
-      std::mutex mutex_;
-
-      std::map<SectorNumber, PairStorage> storage_;
-    }; // TODO вынести PairStorage и удалить UnionStorage. storage_;
+    struct PairStorage {
+      AggregateInput aggregate_input;
+      CommitCallback commit_callback;
+    };
+    typedef std::map<SectorNumber, PairStorage> MapPairStorage;
 
     CommitBatcherImpl(const std::chrono::milliseconds &max_time,
                       const size_t &max_size_callback,
@@ -72,19 +45,19 @@ namespace fc::mining {
     std::chrono::milliseconds closest_cutoff_;
     std::chrono::system_clock::time_point cutoff_start_;
     size_t max_size_callback_;
-    UnionStorage union_storage_;
+    MapPairStorage union_storage_;
     std::shared_ptr<FullNodeApi> api_;
     Address miner_address_;
     std::shared_ptr<FeeConfig> fee_config_;
     std::shared_ptr<ProofEngine> proof_;
+    std::mutex mutex_storage_;
 
     void sendCallbacks();
 
-    outcome::result<CID> sendBatch(UnionStorage &union_storage_for_send);
+    outcome::result<CID> sendBatch(MapPairStorage &union_storage_for_send);
 
-    TokenAmount getSectorCollateral(std::shared_ptr<const Tipset> &head,
-                                    const SectorNumber &sector_number,
-                                    const TipsetKey &tip_set_key);
+    outcome::result<TokenAmount> getSectorCollateral(
+        const SectorNumber &sector_number, const TipsetKey &tip_set_key);
   };
 
 }  // namespace fc::mining