Merge pull request #1107 from PowerGridModel/feature/dependency-inversion-main-model-impl-info

Cleanup main model: dependency inversion main model impl info

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/common/calculation_info.hpp

@@ -4,13 +4,13 @@
 
 #pragma once
 
-#include "logging_impl.hpp"
+#include "multi_threaded_logging.hpp"
 
 #include <map>
 
 namespace power_grid_model {
 namespace common::logging {
-class CalculationInfo final : public Logger {
+class CalculationInfo : public Logger {
     using Data = std::map<LogEvent, double>;
 
   public:
@@ -85,8 +85,28 @@ class CalculationInfo final : public Logger {
   public:
     Report report() const { return data_; }
     void clear() { data_.clear(); }
+
+    template <std::derived_from<Logger> T> T& merge_into(T& destination) const {
+        if (&destination == this) {
+            return destination; // nothing to do
+        }
+        for (const auto& [tag, value] : report()) {
+            destination.log(tag, value);
+        }
+        return destination;
+    }
+};
+
+class MultiThreadedCalculationInfo : public MultiThreadedLoggerImpl<CalculationInfo> {
+  public:
+    using MultiThreadedLoggerImpl<CalculationInfo>::MultiThreadedLoggerImpl;
+    using Report = CalculationInfo::Report;
+
+    Report report() const { return get().report(); }
+    void clear() { get().clear(); }
 };
 } // namespace common::logging
 
 using common::logging::CalculationInfo;
+using common::logging::MultiThreadedCalculationInfo;
 } // namespace power_grid_model

power_grid_model_c/power_grid_model/include/power_grid_model/common/common.hpp

@@ -6,6 +6,7 @@
 
 #include <cmath>
 #include <complex>
+#include <concepts>
 #include <cstddef>
 #include <cstdint>
 #include <limits>

power_grid_model_c/power_grid_model/include/power_grid_model/common/logging_impl.hpp renamed to power_grid_model_c/power_grid_model/include/power_grid_model/common/dummy_logging.hpp

@@ -24,6 +24,8 @@ class NoLogger : public Logger {
     void log(LogEvent /*tag*/, Idx /*value*/) override {
         // no logging
     }
+
+    template <std::derived_from<Logger> T> T& merge_into(T& destination) const { return destination; }
 };
 
 } // namespace power_grid_model::common::logging

power_grid_model_c/power_grid_model/include/power_grid_model/common/logging.hpp

@@ -60,6 +60,10 @@ class Logger {
     Logger& operator=(Logger const&) = default;
 };
 
+struct MultiThreadedLogger : public Logger {
+    virtual std::unique_ptr<Logger> create_child() = 0;
+};
+
 } // namespace common::logging
 
 using common::logging::LogEvent;

power_grid_model_c/power_grid_model/include/power_grid_model/common/multi_threaded_logging.hpp

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "dummy_logging.hpp"
+
+#include <cassert>
+#include <mutex>
+
+namespace power_grid_model::common::logging {
+
+template <std::derived_from<Logger> LoggerType>
+    requires requires(LoggerType& destination, LoggerType const& source) {
+        { source.merge_into(destination) };
+    }
+class MultiThreadedLoggerImpl : public MultiThreadedLogger {
+  public:
+    class ThreadLogger : public LoggerType {
+      public:
+        ThreadLogger(MultiThreadedLoggerImpl& parent) : parent_{&parent} {}
+        ThreadLogger(ThreadLogger const&) = default;
+        ThreadLogger& operator=(ThreadLogger const&) = default;
+        ThreadLogger(ThreadLogger&&) noexcept = default;
+        ThreadLogger& operator=(ThreadLogger&&) noexcept = default;
+        ~ThreadLogger() override { sync(); }
+        void sync() const { parent_->sync(*this); }
+
+      private:
+        MultiThreadedLoggerImpl* parent_;
+    };
+
+    std::unique_ptr<Logger> create_child() override { return std::make_unique<ThreadLogger>(*this); }
+    LoggerType& get() { return log_; }
+    LoggerType const& get() const { return log_; }
+
+    void log(LogEvent tag) override { log_.log(tag); }
+    void log(LogEvent tag, std::string_view message) override { log_.log(tag, message); }
+    void log(LogEvent tag, double value) override { log_.log(tag, value); }
+    void log(LogEvent tag, Idx value) override { log_.log(tag, value); }
+
+  private:
+    friend class ThreadLogger;
+
+    LoggerType log_;
+    std::mutex mutex_;
+
+    void sync(ThreadLogger const& logger) {
+        assert(&logger != &log_);
+
+        std::lock_guard const lock{mutex_};
+        logger.merge_into(log_);
+    }
+};
+
+using NoMultiThreadedLogger = MultiThreadedLoggerImpl<NoLogger>;
+
+} // namespace power_grid_model::common::logging

power_grid_model_c/power_grid_model/include/power_grid_model/common/timer.hpp

@@ -17,13 +17,13 @@ using Duration = std::chrono::duration<double>;
 
 class Timer {
   private:
-    Logger* info_;
+    Logger* log_;
     LogEvent code_;
     Clock::time_point start_;
 
   public:
-    Timer() : info_{nullptr}, code_{LogEvent::unknown} {};
-    Timer(Logger& info, LogEvent code) : info_{&info}, code_{code}, start_{Clock::now()} {}
+    Timer() : log_{nullptr}, code_{LogEvent::unknown} {};
+    Timer(Logger& log, LogEvent code) : log_{&log}, code_{code}, start_{Clock::now()} {}
 
     Timer(Timer const&) = delete;
     Timer(Timer&&) = default;
@@ -34,29 +34,29 @@ class Timer {
         stop();
 
         // Copy/move members
-        info_ = timer.info_;
+        log_ = timer.log_;
         code_ = timer.code_;
         start_ = timer.start_;
 
         // Disable original timer
-        timer.info_ = nullptr;
+        timer.log_ = nullptr;
 
         // Return reference
         return *this;
     }
 
     ~Timer() {
-        if (info_ != nullptr) {
+        if (log_ != nullptr) {
             stop();
         }
     }
 
     void stop() {
-        if (info_ != nullptr) {
+        if (log_ != nullptr) {
             auto const now = Clock::now();
             auto const duration = Duration(now - start_);
-            info_->log(code_, duration.count());
-            info_ = nullptr;
+            log_->log(code_, duration.count());
+            log_ = nullptr;
         }
     }
 };

power_grid_model_c/power_grid_model/include/power_grid_model/component/asym_line.hpp

@@ -15,7 +15,6 @@
 #include "../common/matrix_utils.hpp"
 #include "../common/three_phase_tensor.hpp"
 
-#include <iostream>
 #include <numeric>
 
 namespace power_grid_model {

power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -10,7 +10,6 @@
 #include "job_interface.hpp"
 #include "main_model_fwd.hpp"
 
-#include "main_core/calculation_info.hpp"
 #include "main_core/update.hpp"
 
 namespace power_grid_model {
@@ -23,15 +22,19 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
   public:
     JobAdapter(std::reference_wrapper<MainModel> model_reference,
                std::reference_wrapper<MainModelOptions const> options)
-        : model_reference_{model_reference}, options_{options} {}
+        : model_reference_{model_reference}, options_{options} {
+        reset_logger_impl();
+    }
     JobAdapter(JobAdapter const& other)
         : model_copy_{std::make_unique<MainModel>(other.model_reference_.get())},
           model_reference_{std::ref(*model_copy_)},
           options_{std::ref(other.options_)},
           components_to_update_{other.components_to_update_},
           update_independence_{other.update_independence_},
           independence_flags_{other.independence_flags_},
-          all_scenarios_sequence_{other.all_scenarios_sequence_} {}
+          all_scenarios_sequence_{other.all_scenarios_sequence_} {
+        reset_logger_impl();
+    }
     JobAdapter& operator=(JobAdapter const& other) {
         if (this != &other) {
             model_copy_ = std::make_unique<MainModel>(other.model_reference_.get());
@@ -41,6 +44,8 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             update_independence_ = other.update_independence_;
             independence_flags_ = other.independence_flags_;
             all_scenarios_sequence_ = other.all_scenarios_sequence_;
+
+            reset_logger_impl();
         }
         return *this;
     }
@@ -51,7 +56,9 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
           components_to_update_{std::move(other.components_to_update_)},
           update_independence_{std::move(other.update_independence_)},
           independence_flags_{std::move(other.independence_flags_)},
-          all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {}
+          all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {
+        reset_logger_impl();
+    }
     JobAdapter& operator=(JobAdapter&& other) noexcept {
         if (this != &other) {
             model_copy_ = std::move(other.model_copy_);
@@ -61,10 +68,15 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             update_independence_ = std::move(other.update_independence_);
             independence_flags_ = std::move(other.independence_flags_);
             all_scenarios_sequence_ = std::move(other.all_scenarios_sequence_);
+
+            reset_logger_impl();
         }
         return *this;
     }
-    ~JobAdapter() { model_copy_.reset(); }
+    ~JobAdapter() {
+        reset_logger_impl();
+        model_copy_.reset();
+    }
 
   private:
     // Grant the CRTP base (JobInterface<JobAdapter>) access to
@@ -83,7 +95,7 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
     // current_scenario_sequence_cache_ is calculated per scenario, so it is excluded from the constructors.
     main_core::utils::SequenceIdx<ComponentType...> current_scenario_sequence_cache_{};
 
-    std::mutex calculation_info_mutex_;
+    Logger* log_{nullptr};
 
     void calculate_impl(MutableDataset const& result_data, Idx scenario_idx) const {
         MainModel::calculator(options_.get(), model_reference_.get(), result_data.get_individual_scenario(scenario_idx),
@@ -135,14 +147,6 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
         std::ranges::for_each(current_scenario_sequence_cache_, [](auto& comp_seq_idx) { comp_seq_idx.clear(); });
     }
 
-    CalculationInfo get_calculation_info_impl() const { return model_reference_.get().calculation_info(); }
-    void reset_calculation_info_impl() { model_reference_.get().reset_calculation_info(); }
-
-    void thread_safe_add_calculation_info_impl(CalculationInfo const& info) {
-        std::lock_guard const lock{calculation_info_mutex_};
-        model_reference_.get().merge_calculation_info(info);
-    }
-
     auto get_current_scenario_sequence_view_() const {
         return main_core::utils::run_functor_with_all_types_return_array<ComponentType...>([this]<typename CT>() {
             constexpr auto comp_idx = main_core::utils::index_of_component<CT, ComponentType...>;
@@ -152,5 +156,14 @@ class JobAdapter<MainModel, ComponentList<ComponentType...>>
             return std::span<Idx2D const>{std::get<comp_idx>(current_scenario_sequence_cache_)};
         });
     }
+
+    void reset_logger_impl() {
+        log_ = nullptr;
+        model_reference_.get().reset_logger();
+    }
+    void set_logger_impl(Logger& log) {
+        log_ = &log;
+        model_reference_.get().set_logger(*log_);
+    }
 };
 } // namespace power_grid_model