Prune time tracking

src/core/algorithms/algebraic_constraints/ac_algorithm.cpp

@@ -315,12 +315,11 @@ RangesCollection ACAlgorithm::ReconstructRangesByColumns(size_t lhs_i, size_t rh
                             std::move(ranges), lhs_i, rhs_i};
 }
 
-unsigned long long ACAlgorithm::ExecuteInternal() {
+void ACAlgorithm::ExecuteInternal() {
     std::vector<model::TypedColumnData> const& data = typed_relation_->GetColumnData();
     if (data.empty()) {
         throw std::runtime_error("Empty table was given.");
     }
-    auto start_time = std::chrono::system_clock::now();
 
     for (size_t col_i = 0; col_i < data.size() - 1; ++col_i) {
         if (!data.at(col_i).GetType().IsNumeric()) continue;
@@ -345,10 +344,7 @@ unsigned long long ACAlgorithm::ExecuteInternal() {
         }
     }
 
-    auto elapsed_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now() - start_time);
     PrintRanges(data);
-    return elapsed_milliseconds.count();
 }
 
 }  // namespace algos

src/core/algorithms/algebraic_constraints/ac_algorithm.h

@@ -114,7 +114,7 @@ class ACAlgorithm : public Algorithm {
         ac_exception_finder_->CollectExceptions(this);
     }
 
-    unsigned long long ExecuteInternal() override;
+    void ExecuteInternal() override;
 
     ACAlgorithm();
 };

src/core/algorithms/algorithm.cpp

@@ -80,20 +80,19 @@ void Algorithm::LoadData() {
     ExecutePrepare();
 }
 
-unsigned long long Algorithm::Execute() {
+void Algorithm::Execute() {
     if (!data_loaded_) {
         throw std::logic_error("Data must be processed before execution.");
     }
     if (!AllRequiredOptionsAreSet())
         throw std::logic_error("All options need to be set before execution.");
     ResetState();
-    auto time_ms = ExecuteInternal();
+    ExecuteInternal();
     for (auto const& opt_name : available_options_) {
         possible_options_.at(opt_name)->Unset();
     }
     ClearOptions();
     MakeExecuteOptsAvailable();
-    return time_ms;
 }
 
 void Algorithm::SetOption(std::string_view option_name, boost::any const& value) {

src/core/algorithms/algorithm.h

@@ -35,7 +35,7 @@ class Algorithm {
     void ExcludeOptions(std::string_view parent_option) noexcept;
     void ClearOptions() noexcept;
     virtual void LoadDataInternal() = 0;
-    virtual unsigned long long ExecuteInternal() = 0;
+    virtual void ExecuteInternal() = 0;
     bool AllRequiredOptionsAreSet() const noexcept;
 
 protected:
@@ -77,7 +77,7 @@ class Algorithm {
 
     void LoadData();
 
-    unsigned long long Execute();
+    void Execute();
 
     void SetOption(std::string_view option_name, boost::any const& value = {});
     bool OptionIsRequired(std::string_view option_name) const;

src/core/algorithms/ar/apriori/apriori.cpp

@@ -120,9 +120,7 @@ void Apriori::ResetStateAr() {
     root_ = Node();
 }
 
-unsigned long long Apriori::FindFrequent() {
-    auto start_time = std::chrono::system_clock::now();
-
+void Apriori::FindFrequent() {
     CreateFirstLevelCandidates();
     while (!candidates_.empty()) {
         unsigned candidates_count = 0;
@@ -140,17 +138,9 @@ unsigned long long Apriori::FindFrequent() {
         candidates_.clear();
         GenerateNextCandidateLevel();
     }
-
-    auto elapsed_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now() - start_time);
-    long long millis = elapsed_milliseconds.count();
-
-    return millis;
 }
 
-unsigned long long Apriori::GenerateAllRules() {
-    auto start_time = std::chrono::system_clock::now();
-
+void Apriori::GenerateAllRules() {
     std::queue<Node const*> path;
     UpdatePath(path, root_.children);
     unsigned long long frequent_count = 0;
@@ -166,12 +156,7 @@ unsigned long long Apriori::GenerateAllRules() {
         UpdatePath(path, curr_node->children);
     }
 
-    auto elapsed_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now() - start_time);
-    long long millis = elapsed_milliseconds.count();
-
     LOG_INFO("> Count of frequent itemsets: {}", frequent_count);
-    return millis;
 }
 
 std::list<std::set<std::string>> Apriori::GetFrequentList() const {

src/core/algorithms/ar/apriori/apriori.h

@@ -34,8 +34,8 @@ class Apriori : public ARAlgorithm {
     static void UpdatePath(std::stack<Node const*>& path, std::vector<Node> const& vertices);
 
     double GetSupport(std::vector<unsigned> const& frequent_itemset) const override;
-    unsigned long long GenerateAllRules() override;
-    unsigned long long FindFrequent() override;
+    void GenerateAllRules() override;
+    void FindFrequent() override;
 
     void ResetStateAr() final;
 

src/core/algorithms/ar/ar_algorithm.cpp

@@ -54,12 +54,11 @@ void ARAlgorithm::LoadDataInternal() {
     }
 }
 
-unsigned long long ARAlgorithm::ExecuteInternal() {
-    auto time = FindFrequent();
-    time += GenerateAllRules();
+void ARAlgorithm::ExecuteInternal() {
+    FindFrequent();
+    GenerateAllRules();
 
     LOG_INFO("> Count of association rules: {}", ar_collection_.size());
-    return time;
 }
 
 void ARAlgorithm::UpdatePath(std::stack<RuleNode*>& path, std::list<RuleNode>& vertices) {

src/core/algorithms/ar/ar_algorithm.h

@@ -51,11 +51,11 @@ class ARAlgorithm : public Algorithm {
     void GenerateRulesFrom(std::vector<unsigned> const& frequent_itemset, double support);
 
     virtual double GetSupport(std::vector<unsigned> const& frequent_itemset) const = 0;
-    virtual unsigned long long GenerateAllRules() = 0;
-    virtual unsigned long long FindFrequent() = 0;
+    virtual void GenerateAllRules() = 0;
+    virtual void FindFrequent() = 0;
     void LoadDataInternal() final;
     void MakeExecuteOptsAvailable() final;
-    unsigned long long ExecuteInternal() final;
+    void ExecuteInternal() final;
 
 public:
     ARAlgorithm();

src/core/algorithms/ar/ar_verifier/ar_verifier.cpp

@@ -9,7 +9,6 @@
 #include "core/model/transaction/input_format_type.h"
 #include "core/util/enum_to_str.h"
 #include "core/util/logger.h"
-#include "core/util/timed_invoke.h"
 
 namespace algos::ar_verifier {
 ARVerifier::ARVerifier() {
@@ -74,7 +73,7 @@ void ARVerifier::LoadDataInternal() {
     }
 }
 
-unsigned long long ARVerifier::ExecuteInternal() {
+void ARVerifier::ExecuteInternal() {
     ar_ids_ = ::model::ArIDs(string_rule_left_, string_rule_right_, transactional_data_.get(),
                              minconf_, minsup_);
     LOG_DEBUG("Parameters of ARVerifier:");
@@ -83,15 +82,9 @@ unsigned long long ARVerifier::ExecuteInternal() {
     LOG_DEBUG("\tARule to verify: {}",
               ::model::ARStrings(ar_ids_, transactional_data_.get()).ToString());
 
-    auto const verification_time = ::util::TimedInvoke(&ARVerifier::VerifyAR, this);
+    VerifyAR();
 
-    LOG_DEBUG("AR verification took {} ms", std::to_string(verification_time));
-
-    auto const stats_calculation_time = ::util::TimedInvoke(&ARVerifier::CalculateStatistics, this);
-
-    LOG_DEBUG("Statistics calculation took {} ms", std::to_string(stats_calculation_time));
-
-    return verification_time + stats_calculation_time;
+    CalculateStatistics();
 }
 
 void ARVerifier::VerifyAR() {

src/core/algorithms/ar/ar_verifier/ar_verifier.h

@@ -33,7 +33,7 @@ class ARVerifier final : public Algorithm {
     void RegisterOptions();
     void LoadDataInternal() override;
     void MakeExecuteOptsAvailable() override;
-    unsigned long long ExecuteInternal() override;
+    void ExecuteInternal() override;
 
     void ResetState() override {
         stats_calculator_.ResetState();

src/core/algorithms/cfd/cfd_verifier/cfd_verifier.cpp

@@ -6,7 +6,6 @@
 #include "core/config/option_using.h"
 #include "core/config/tabular_data/input_table/option.h"
 #include "core/util/logger.h"
-#include "core/util/timed_invoke.h"
 
 namespace algos::cfd_verifier {
 
@@ -67,7 +66,7 @@ void CFDVerifier::MakeExecuteOptsAvailable() {
     MakeOptionsAvailable({kCFDRuleLeft, kCFDRuleRight, kCfdMinimumSupport, kCfdMinimumConfidence});
 }
 
-unsigned long long CFDVerifier::ExecuteInternal() {
+void CFDVerifier::ExecuteInternal() {
     auto build_item_ids =
             [this](std::vector<CFDAttributeValuePair> const& rule_part) -> cfd::Itemset {
         cfd::Itemset item_ids;
@@ -92,13 +91,9 @@ unsigned long long CFDVerifier::ExecuteInternal() {
     LOG_DEBUG("Starting CFD verification...");
     LOG_DEBUG("\tRule to verify: {}", cfd::Output::CFDToString(cfd_, relation_));
 
-    auto verification_time = ::util::TimedInvoke(&CFDVerifier::VerifyCFD, this);
-    LOG_DEBUG("CFD verification took {} ms", verification_time);
+    VerifyCFD();
 
-    auto stats_calculation_time = ::util::TimedInvoke(&CFDVerifier::CalculateStatistics, this);
-    LOG_DEBUG("Statistics calculation took {} ms ", stats_calculation_time);
-
-    return verification_time + stats_calculation_time;
+    CalculateStatistics();
 }
 
 void CFDVerifier::VerifyCFD() {

src/core/algorithms/cfd/cfd_verifier/cfd_verifier.h

@@ -41,7 +41,7 @@ class CFDVerifier : public Algorithm {
 protected:
     void LoadDataInternal() override;
     void MakeExecuteOptsAvailable() override;
-    unsigned long long ExecuteInternal() override;
+    void ExecuteInternal() override;
 
 public:
     CFDVerifier();

src/core/algorithms/cfd/fd_first_algorithm.cpp

@@ -41,17 +41,11 @@ void FDFirstAlgorithm::ResetStateCFD() {
     rules_.clear();
 }
 
-unsigned long long FDFirstAlgorithm::ExecuteInternal() {
+void FDFirstAlgorithm::ExecuteInternal() {
     max_cfd_size_ = max_lhs_ + 1;
     CheckForIncorrectInput();
-    auto start_time = std::chrono::system_clock::now();
     FdsFirstDFS();
-    auto elapsed_milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
-            std::chrono::system_clock::now() - start_time);
-    unsigned long long apriori_millis = elapsed_milliseconds.count();
     LOG_INFO("> CFD COUNT: {}", cfd_list_.size());
-
-    return apriori_millis;
 }
 
 void FDFirstAlgorithm::CheckForIncorrectInput() const {

src/core/algorithms/cfd/fd_first_algorithm.h

@@ -64,7 +64,7 @@ class FDFirstAlgorithm : public algos::cfd::CFDDiscovery {
 protected:
     void RegisterOptions();
     void MakeExecuteOptsAvailable() override;
-    unsigned long long ExecuteInternal() final;
+    void ExecuteInternal() final;
 
 public:
     FDFirstAlgorithm();

src/core/algorithms/cind/cind_algorithm.cpp

@@ -16,7 +16,6 @@
 #include "core/config/mem_limit/option.h"
 #include "core/config/tabular_data/input_tables/option.h"
 #include "core/config/thread_number/option.h"
-#include "core/util/timed_invoke.h"
 
 namespace algos::cind {
 CindAlgorithm::CindAlgorithm() {
@@ -40,8 +39,7 @@ void CindAlgorithm::RegisterSpiderOptions() {
 }
 
 void CindAlgorithm::LoadDataInternal() {
-    timings_.load =
-            static_cast<std::uint64_t>(util::TimedInvoke(&Algorithm::LoadData, spider_algo_));
+    spider_algo_->LoadData();
     CreateCindMinerAlgo();
 }
 
@@ -80,20 +78,10 @@ void CindAlgorithm::AddSpecificNeededOptions(
     previous_options.insert(spider_options.begin(), spider_options.end());
 }
 
-unsigned long long CindAlgorithm::ExecuteInternal() {
-    auto const spider_exec_time = static_cast<std::uint64_t>(spider_algo_->Execute());
-    auto const cind_exec_time =
-            static_cast<std::uint64_t>(cind_miner_->Execute(spider_algo_->INDList()));
-
-    timings_.compute = spider_exec_time + cind_exec_time;
-    timings_.total = timings_.load + timings_.compute;
-
-    return static_cast<unsigned long long>(timings_.total);
+void CindAlgorithm::ExecuteInternal() {
+    spider_algo_->Execute();
+    cind_miner_->Execute(spider_algo_->INDList());
 }
 
-void CindAlgorithm::ResetState() {
-    timings_.load = 0;
-    timings_.compute = 0;
-    timings_.total = 0;
-}
+void CindAlgorithm::ResetState() {}
 }  // namespace algos::cind

src/core/algorithms/cind/cind_algorithm.h

@@ -23,10 +23,9 @@ class CindAlgorithm final : public Algorithm {
     std::unique_ptr<Spider> spider_algo_;
     std::unique_ptr<CindMiner> cind_miner_;
     AlgoType algo_type_{AlgoType::kPliCind};
-    StageTimings timings_{};
 
     void LoadDataInternal() final;
-    unsigned long long ExecuteInternal() final;
+    void ExecuteInternal() final;
     void ResetState() final;
 
     void CreateSpiderAlgo();
@@ -41,10 +40,6 @@ class CindAlgorithm final : public Algorithm {
 public:
     CindAlgorithm();
 
-    [[nodiscard]] std::uint64_t TimeTaken() const noexcept {
-        return timings_.total;
-    }
-
     [[nodiscard]] auto const& AINDList() const noexcept {
         return spider_algo_->INDList();
     }

src/core/algorithms/cind/cind_verifier/cind_verifier.cpp

@@ -26,7 +26,6 @@
 #include "core/model/table/encoded_column_data.h"
 #include "core/model/table/encoded_tables.h"
 #include "core/model/table/tuple_index.h"
-#include "core/util/timed_invoke.h"
 
 namespace algos::cind {
 namespace {
@@ -151,11 +150,7 @@ void CINDVerifier::LoadDataInternal() {
     }
 }
 
-unsigned long long CINDVerifier::ExecuteInternal() {
-    return util::TimedInvoke(&CINDVerifier::VerifyCIND, this);
-}
-
-void CINDVerifier::VerifyCIND() {
+void CINDVerifier::ExecuteInternal() {
     model::TableIndex const lhs_table_idx = 0;
     model::TableIndex const rhs_table_idx =
             (input_tables_.size() == 1) ? 0

src/core/algorithms/cind/cind_verifier/cind_verifier.h

@@ -52,9 +52,7 @@ class CINDVerifier final : public Algorithm {
     void ResetState() final;
 
     void LoadDataInternal() final;
-    unsigned long long ExecuteInternal() final;
-
-    void VerifyCIND();
+    void ExecuteInternal() final;
 
 public:
     CINDVerifier();

src/core/algorithms/cind/condition_miners/cind_miner.cpp

@@ -4,7 +4,6 @@
 
 #include "core/algorithms/cind/types.h"
 #include "core/model/table/encoded_tables.h"
-#include "core/util/timed_invoke.h"
 
 namespace algos::cind {
 CindMiner::CindMiner(config::InputTables& input_tables)
@@ -48,14 +47,11 @@ CindMiner::Attributes CindMiner::ClassifyAttributes(model::IND const& aind) cons
     return result;
 }
 
-unsigned long long CindMiner::Execute(std::list<model::IND> const& aind_list) {
-    auto const execute = [&] {
-        cind_collection_.Clear();
-        for (auto const& aind : aind_list) {
-            cind_collection_.Register(ExecuteSingle(aind));
-        }
-    };
-    return util::TimedInvoke(execute);
+void CindMiner::Execute(std::list<model::IND> const& aind_list) {
+    cind_collection_.Clear();
+    for (auto const& aind : aind_list) {
+        cind_collection_.Register(ExecuteSingle(aind));
+    }
 }
 
 std::vector<std::string> CindMiner::GetConditionalAttributesNames(