resolve comments

Signed-off-by: Martijn Govers <[email protected]>

Author: mgovers

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

@@ -4,7 +4,7 @@
 
 #pragma once
 
-#include "logging_impl.hpp"
+#include "dummy_logging.hpp"
 
 #include <mutex>
 

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

@@ -59,20 +59,6 @@ class JobDispatch {
 
         return BatchParameter{};
     }
-    template <typename Adapter, typename ResultDataset, typename UpdateDataset>
-        requires std::is_base_of_v<JobInterface<Adapter>, Adapter>
-    static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
-                                            UpdateDataset const& update_data, Idx threading) {
-        common::logging::NoMultiThreadedLogger no_log{};
-        return batch_calculation(adapter, result_data, update_data, threading,
-                                 static_cast<common::logging::MultiThreadedLogger&>(no_log));
-    }
-    template <typename Adapter, typename ResultDataset, typename UpdateDataset>
-        requires std::is_base_of_v<JobInterface<Adapter>, Adapter>
-    static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
-                                            UpdateDataset const& update_data) {
-        return batch_calculation(adapter, result_data, update_data, sequential);
-    }
 
     // Lippincott pattern
     static auto scenario_exception_handler(std::vector<std::string>& messages) {
@@ -98,27 +84,27 @@ class JobDispatch {
         return [&base_adapter, &exceptions, &result_data, &update_data, &base_log](Idx start, Idx stride,
                                                                                    Idx n_scenarios) {
             assert(n_scenarios <= narrow_cast<Idx>(exceptions.size()));
-            auto thread_info_ptr = base_log.create_child();
-            Logger& thread_info = *thread_info_ptr;
+            auto thread_log_ptr = base_log.create_child();
+            Logger& thread_log = *thread_log_ptr;
 
-            Timer t_total{thread_info, LogEvent::total_batch_calculation_in_thread};
+            Timer t_total{thread_log, LogEvent::total_batch_calculation_in_thread};
 
-            auto const copy_adapter_functor = [&base_adapter, &thread_info]() {
-                Timer const t_copy_adapter_functor{thread_info, LogEvent::copy_model};
+            auto const copy_adapter_functor = [&base_adapter, &thread_log]() {
+                Timer const t_copy_adapter_functor{thread_log, LogEvent::copy_model};
                 auto result = Adapter{base_adapter};
-                result.set_logger(thread_info);
+                result.set_logger(thread_log);
                 return result;
             };
 
             auto adapter = copy_adapter_functor();
 
-            auto setup = [&adapter, &update_data, &thread_info](Idx scenario_idx) {
-                Timer const t_update_model{thread_info, LogEvent::update_model};
+            auto setup = [&adapter, &update_data, &thread_log](Idx scenario_idx) {
+                Timer const t_update_model{thread_log, LogEvent::update_model};
                 adapter.setup(update_data, scenario_idx);
             };
 
-            auto winddown = [&adapter, &thread_info]() {
-                Timer const t_restore_model{thread_info, LogEvent::restore_model};
+            auto winddown = [&adapter, &thread_log]() {
+                Timer const t_restore_model{thread_log, LogEvent::restore_model};
                 adapter.winddown();
             };
 
@@ -135,7 +121,7 @@ class JobDispatch {
                                                                   std::move(recover_from_bad));
 
             for (Idx scenario_idx = start; scenario_idx < n_scenarios; scenario_idx += stride) {
-                Timer const t_total_single{thread_info, LogEvent::total_single_calculation_in_thread};
+                Timer const t_total_single{thread_log, LogEvent::total_single_calculation_in_thread};
                 calculate_scenario(scenario_idx);
             }
 

power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -6,8 +6,8 @@
 
 // batch dispatch interface class
 
-#include "common/calculation_info.hpp"
 #include "common/common.hpp"
+#include "common/logging.hpp"
 
 #include <concepts>
 #include <type_traits>

power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -8,6 +8,8 @@
 #include "job_dispatch.hpp"
 #include "main_model_impl.hpp"
 
+#include "common/calculation_info.hpp"
+
 #include <memory>
 
 namespace power_grid_model {

power_grid_model_c/power_grid_model/include/power_grid_model/main_model.hpp

@@ -15,6 +15,7 @@
 
 // common
 #include "common/common.hpp"
+#include "common/dummy_logging.hpp"
 #include "common/exception.hpp"
 #include "common/timer.hpp"
 

power_grid_model_c/power_grid_model/include/power_grid_model/main_model_impl.hpp

@@ -156,6 +156,13 @@ class MultiThreadedTestLogger : public common::logging::MultiThreadedLoggerImpl<
 
     Data const& report() const { return get().report(); }
 };
+
+using common::logging::MultiThreadedLogger;
+
+MultiThreadedLogger& no_logger() {
+    static common::logging::NoMultiThreadedLogger instance;
+    return instance;
+}
 } // namespace
 
 TEST_CASE("Test job dispatch logic") {
@@ -166,13 +173,13 @@ TEST_CASE("Test job dispatch logic") {
         auto adapter = JobAdapterMock{counter};
         auto result_data = MockResultDataset{};
         auto const expected_result = BatchParameter{};
-        auto const logger = MultiThreadedTestLogger{};
         SUBCASE("No update data") {
             bool const has_data = false;
             Idx const n_scenarios = 9; // arbitrary non-zero value
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
-            auto const actual_result = JobDispatch::batch_calculation(adapter, result_data, update_data);
+            auto const actual_result =
+                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
             CHECK(expected_result == actual_result);
             CHECK(adapter.get_calculate_counter() == 1);
             CHECK(adapter.get_cache_calculate_counter() == 0); // no cache calculation in this case
@@ -184,7 +191,8 @@ TEST_CASE("Test job dispatch logic") {
             Idx const n_scenarios = 0;
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
-            auto const actual_result = JobDispatch::batch_calculation(adapter, result_data, update_data);
+            auto const actual_result =
+                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
             CHECK(expected_result == actual_result);
             // no calculations should be done
             CHECK(adapter.get_calculate_counter() == 0);
@@ -198,7 +206,7 @@ TEST_CASE("Test job dispatch logic") {
             auto const update_data = MockUpdateDataset(has_data, n_scenarios);
             adapter.reset_counters();
             auto const actual_result =
-                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential);
+                JobDispatch::batch_calculation(adapter, result_data, update_data, JobDispatch::sequential, no_logger());
             CHECK(expected_result == actual_result);
             // n_scenarios calculations should be done as we run sequentially
             CHECK(adapter.get_calculate_counter() == n_scenarios);

tests/cpp_unit_tests/test_job_dispatch.cpp

@@ -8,7 +8,7 @@
 
 #include "test_math_solver_common.hpp"
 
-#include <power_grid_model/common/logging_impl.hpp>
+#include <power_grid_model/common/dummy_logging.hpp>
 #include <power_grid_model/math_solver/sparse_lu_solver.hpp>
 #include <power_grid_model/math_solver/y_bus.hpp>
 

tests/cpp_unit_tests/test_math_solver_pf.hpp

@@ -8,8 +8,8 @@
 
 #include "test_math_solver_common.hpp"
 
+#include <power_grid_model/common/dummy_logging.hpp>
 #include <power_grid_model/common/exception.hpp>
-#include <power_grid_model/common/logging_impl.hpp>
 #include <power_grid_model/math_solver/sparse_lu_solver.hpp>
 #include <power_grid_model/math_solver/y_bus.hpp>