Feature/low level logs

cmake/dependencies/CMakeLists.txt

@@ -9,7 +9,7 @@ if (NOT antares-solver_FOUND)
 
     set(REPOSITORY "https://github.com/AntaresSimulatorTeam/Antares_Simulator.git")
     set(TAG "v${ANTARES_VERSION_TAG}")
-    set(CMAKE_ARGS "-DBUILD_UI=OFF -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DDEPS_INSTALL_DIR=${DEPS_INSTALL_DIR} -DBUILD_not_system=OFF -DBUILD_ortools=ON")
+    set(CMAKE_ARGS "-DBUILD_UI=OFF -DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE} -DDEPS_INSTALL_DIR=${DEPS_INSTALL_DIR} -DBUILD_not_system=OFF -DBUILD_ortools=ON -DCMAKE_PREFIX_PATH=${DEPS_INSTALL_DIR}/../antares-xpansion/vcpkg_installed")
 
     if (CMAKE_BUILD_TYPE STREQUAL "Debug")
       set(ANTARES_BUILD_TYPE "debug")

src/cpp/benders/benders_by_batch/BendersByBatch.cpp

@@ -8,10 +8,11 @@
 #include "BatchCollection.h"
 #include "RandomBatchShuffler.h"
 #include "glog/logging.h"
-BendersByBatch::BendersByBatch(BendersBaseOptions const &options, Logger logger,
-                               Writer writer, mpi::environment &env,
-                               mpi::communicator &world)
-    : BendersMpi(options, logger, writer, env, world) {}
+BendersByBatch::BendersByBatch(
+    BendersBaseOptions const &options, Logger logger, Writer writer,
+    mpi::environment &env, mpi::communicator &world,
+    std::shared_ptr<MathLoggerDriver> mathLoggerDriver)
+    : BendersMpi(options, logger, writer, env, world, mathLoggerDriver) {}
 
 void BendersByBatch::InitializeProblems() {
   MatchProblemToId();
@@ -124,6 +125,7 @@ void BendersByBatch::MasterLoop() {
     _logger->LogSubproblemsSolvingCumulativeCpuTime(
         GetSubproblemsCumulativeCpuTime());
     _logger->LogSubproblemsSolvingWalltime(GetSubproblemsWalltime());
+    mathLoggerDriver_->Print(_data);
     _logger->display_message(
         "\\________________________________________________________________"
         "________");
@@ -135,13 +137,15 @@ void BendersByBatch::SeparationLoop() {
   batch_counter_ = 0;
   while (misprice_ && batch_counter_ < number_of_batch_) {
     _data.it++;
+    ResetSimplexIterationsBounds();
 
     _logger->log_at_initialization(_data.it + GetNumIterationsBeforeRestart());
     ComputeXCut();
     _logger->log_iteration_candidates(bendersDataToLogData(_data));
     BroadcastXCut();
     UpdateRemainingEpsilon();
     SolveBatches();
+
     if (Rank() == rank_0) {
       UpdateTrace();
       SaveCurrentBendersData();
@@ -229,6 +233,7 @@ void BendersByBatch::BuildCut(
   for (const auto &subproblem_map : gathered_subproblem_map) {
     for (auto &&[_, subproblem_data] : subproblem_map) {
       SetSubproblemCost(GetSubproblemCost() + subproblem_data.subproblem_cost);
+      BoundSimplexIterations(subproblem_data.simplex_iter);
     }
   }
   for (const auto &subproblem_map : gathered_subproblem_map) {

src/cpp/benders/benders_by_batch/include/BendersByBatch.h

@@ -9,8 +9,8 @@ class BendersByBatch : public BendersMpi {
 
  public:
   BendersByBatch(BendersBaseOptions const &options, Logger logger,
-                 Writer writer, mpi::environment &env,
-                 mpi::communicator &world);
+                 Writer writer, mpi::environment &env, mpi::communicator &world,
+                 std::shared_ptr<MathLoggerDriver> mathLoggerDriver);
   ~BendersByBatch() override = default;
   void Run() override;
   void BuildCut(const std::vector<std::string> &batch_sub_problems,

src/cpp/benders/benders_core/BendersBase.cpp

@@ -13,12 +13,14 @@
 #include "solver_utils.h"
 
 BendersBase::BendersBase(BendersBaseOptions options, Logger logger,
-                         Writer writer)
+                         Writer writer,
+                         std::shared_ptr<MathLoggerDriver> mathLoggerDriver)
     : _options(std::move(options)),
       _csv_file_path(std::filesystem::path(_options.OUTPUTROOT) /
                      (_options.CSV_NAME + ".csv")),
       _logger(std::move(logger)),
-      _writer(std::move(writer)) {}
+      _writer(std::move(writer)),
+      mathLoggerDriver_(mathLoggerDriver) {}
 
 /*!
  *  \brief Initialize set of data used in the loop
@@ -773,6 +775,24 @@ void BendersBase::SetSubproblemCost(const double &subproblem_cost) {
   _data.subproblem_cost = subproblem_cost;
 }
 
+/*!
+*	\brief Update maximum and minimum of simplex iterations
+*
+*	\param subproblem_iterations : number of iterations done with the subproblem
+*
+*/
+void BendersBase::BoundSimplexIterations(int subproblem_iterations){
+
+  _data.max_simplexiter = (_data.max_simplexiter < subproblem_iterations) ? subproblem_iterations : _data.max_simplexiter; 
+  _data.min_simplexiter = (_data.min_simplexiter > subproblem_iterations) ? subproblem_iterations : _data.min_simplexiter; 
+
+}
+
+void BendersBase::ResetSimplexIterationsBounds()
+{
+	_data.max_simplexiter = 0;
+	_data.min_simplexiter = std::numeric_limits<int>::max();
+}
 bool BendersBase::IsResumeMode() const { return _options.RESUME; }
 
 void BendersBase::UpdateMaxNumberIterationResumeMode(

src/cpp/benders/benders_core/BendersMathLogger.cpp

@@ -0,0 +1,20 @@
+#include "BendersMathLogger.h"
+
+void MathLoggerDriver::add_logger(
+    std::shared_ptr<MathLoggerImplementation> logger) {
+  if (logger) {
+    math_loggers_.push_back(logger);
+  }
+}
+
+void MathLoggerDriver::Print(const CurrentIterationData& data) {
+  for (auto logger : math_loggers_) {
+    logger->Print(data);
+  }
+}
+
+void MathLoggerDriver::write_header() {
+  for (auto logger : math_loggers_) {
+    logger->write_header();
+  }
+}

src/cpp/benders/benders_core/BendersStructsDatas.cpp

@@ -8,3 +8,4 @@ Point WorkerMasterData::get_x_cut() const { return *_x_cut; }
 Point WorkerMasterData::get_min_invest() const { return *_min_invest; }
 
 Point WorkerMasterData::get_max_invest() const { return *_max_invest; }
+

src/cpp/benders/benders_core/CMakeLists.txt

@@ -26,7 +26,9 @@ add_library (benders_core STATIC
 	${CMAKE_CURRENT_SOURCE_DIR}/LastIterationWriter.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/LastIterationReader.cpp 
 	${CMAKE_CURRENT_SOURCE_DIR}/LastIterationPrinter.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/StartUp.cpp)
+	${CMAKE_CURRENT_SOURCE_DIR}/StartUp.cpp
+	${CMAKE_CURRENT_SOURCE_DIR}/BendersMathLogger.cpp
+	)
 
 get_target_property(JSON_INC_PATH jsoncpp_lib INTERFACE_INCLUDE_DIRECTORIES)
 

src/cpp/benders/benders_core/SimulationOptions.cpp

@@ -112,7 +112,7 @@ void SimulationOptions::set_weights() {
 void SimulationOptions::print(std::ostream &stream) const {
 #define BENDERS_OPTIONS_MACRO(name__, type__, default__, \
                               deserialization_method__)  \
-  stream << std::setw(30) << #name__ << std::setw(50) << name__ << std::endl;
+  stream << std::setw(30) << #name__ << std::setw(50)<<std::boolalpha << name__ << std::endl;
 #include "SimulationOptions.hxx"
 #undef BENDERS_OPTIONS_MACRO
   stream << std::endl;

src/cpp/benders/benders_core/include/BendersBase.h

@@ -3,6 +3,7 @@
 #include <execution>
 #include <filesystem>
 
+#include "BendersMathLogger.h"
 #include "BendersStructsDatas.h"
 #include "ILogger.h"
 #include "OutputWriter.h"
@@ -29,7 +30,8 @@ auto selectPolicy(lambda f, bool shouldParallelize) {
 class BendersBase {
  public:
   virtual ~BendersBase() = default;
-  BendersBase(BendersBaseOptions options, Logger logger, Writer writer);
+  BendersBase(BendersBaseOptions options, Logger logger, Writer writer,
+              std::shared_ptr<MathLoggerDriver> mathLoggerDriver);
   virtual void launch() = 0;
   void set_log_file(const std::filesystem::path &log_name);
   [[nodiscard]] std::filesystem::path log_name() const { return _log_name; }
@@ -40,6 +42,7 @@ class BendersBase {
   CurrentIterationData _data;
   VariableMap master_variable_map;
   CouplingMap coupling_map;
+  std::shared_ptr<MathLoggerDriver> mathLoggerDriver_;
 
  protected:
   virtual void free() = 0;
@@ -136,6 +139,9 @@ class BendersBase {
     return cumulative_number_of_subproblem_resolved_before_resume;
   }
 
+  void BoundSimplexIterations(int subproblem_iteration);
+  void ResetSimplexIterationsBounds();
+
   SolverLogManager solver_log_manager_;
 
  private:

src/cpp/benders/benders_core/include/BendersMathLogger.h

@@ -0,0 +1,139 @@
+#pragma once
+
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <memory>
+
+#include "BendersStructsDatas.h"
+#include "common.h"
+const std::string MATHLOGGERCONTEXT = "Benders";
+
+inline std::string Indent(int size) { return std::string(size, ' '); }
+const std::string ITERATION = Indent(10) + "ITERATION";
+const std::string LB = Indent(20) + "LB";
+const std::string UB = Indent(20) + "UB";
+const std::string BESTUB = Indent(20) + "BESTUB";
+const std::string ABSOLUTE_GAP = Indent(15) + "ABSOLUTE GAP";
+const std::string RELATIVE_GAP = Indent(15) + "RELATIVE GAP";
+const std::string MINSIMPLEX = Indent(15) + "MINSIMPLEX";
+const std::string MAXSIMPLEX = Indent(15) + "MAXSIMPLEX";
+const std::string TIMEMASTER = Indent(15) + "TIMEMASTER";
+const std::string SUB_PROBLEMS_TIME_CPU =
+    Indent(15) + "SUB-PROBLEMS TIME (CPU)";
+const std::string SUB_PROBLEMS_TIME_WALL =
+    Indent(15) + "SUB-PROBLEMS TIME (WALL)";
+const std::string TIME_NOT_DOING_MASTER_OR_SUB_PROBLEMS_WALL =
+    Indent(15) + "TIME NOT DOING MASTER OR SUB-PROBLEMS (WALL)";
+class LogDestination {
+ public:
+  explicit LogDestination(std::ostream* stream) : stream_(stream) {}
+
+  // for std::endl
+  std::ostream& operator<<(std::ostream& (*function)(std::ostream&)) {
+    // write obj to stream
+    return function(*stream_);
+  }
+
+  template <class T>
+  std::ostream& operator<<(const T& obj);
+
+ private:
+  std::ostream* stream_;
+};
+template <class T>
+std::ostream& LogDestination::operator<<(const T& obj) {
+  // write obj to stream
+  return (*stream_) << std::left << obj;
+}
+
+struct MathLoggerBehaviour {
+  void write_header() {
+    setHeadersList();
+    for (const auto& header : Headers()) {
+      LogsDestination() << header;
+    }
+    LogsDestination() << std::endl;
+  }
+  virtual void Print(const CurrentIterationData& data) = 0;
+  virtual std::list<std::string> Headers() const = 0;
+  virtual LogDestination& LogsDestination() = 0;
+  virtual void setHeadersList() = 0;
+};
+
+struct MathLogger : public MathLoggerBehaviour {
+  explicit MathLogger(std::ostream* stream) : log_destination_(stream) {}
+  explicit MathLogger() : log_destination_(&std::cout) {}
+  virtual void Print(const CurrentIterationData& data) = 0;
+  std::list<std::string> Headers() const override { return headers_; }
+  virtual LogDestination& LogsDestination() { return log_destination_; }
+  virtual void setHeadersList() = 0;
+
+ protected:
+  void setHeadersList(const std::list<std::string>& headers);
+
+ private:
+  std::list<std::string> headers_;
+  LogDestination log_destination_;
+};
+
+struct MathLoggerBase : public MathLogger {
+  using MathLogger::MathLogger;
+  void Print(const CurrentIterationData& data) override;
+
+  void setHeadersList() override;
+};
+
+struct MathLoggerBendersByBatch : public MathLogger {
+  using MathLogger::MathLogger;
+  void Print(const CurrentIterationData& data) override;
+
+  void setHeadersList() override;
+};
+
+class MathLoggerImplementation : public MathLoggerBehaviour {
+ public:
+  explicit MathLoggerImplementation(const BENDERSMETHOD& method,
+                                    std::ostream* stream) {
+    if (method == BENDERSMETHOD::BENDERS) {
+      implementation_ = std::make_shared<MathLoggerBase>(stream);
+    } else if (method == BENDERSMETHOD::BENDERSBYBATCH) {
+      implementation_ = std::make_shared<MathLoggerBendersByBatch>(stream);
+    }
+    // else
+  }
+  explicit MathLoggerImplementation(const BENDERSMETHOD& method) {
+    if (method == BENDERSMETHOD::BENDERS) {
+      implementation_ = std::make_shared<MathLoggerBase>();
+    } else if (method == BENDERSMETHOD::BENDERSBYBATCH) {
+      implementation_ = std::make_shared<MathLoggerBendersByBatch>();
+    }
+    // else }
+  }
+
+  void Print(const CurrentIterationData& data) { implementation_->Print(data); }
+
+ protected:
+  void setHeadersList() override { implementation_->setHeadersList(); }
+  std::list<std::string> Headers() const override {
+    return implementation_->Headers();
+  }
+  virtual LogDestination& LogsDestination() {
+    return implementation_->LogsDestination();
+  }
+
+ private:
+  std::shared_ptr<MathLogger> implementation_;
+};
+
+class MathLoggerDriver {
+ public:
+  MathLoggerDriver() = default;
+  void write_header();
+
+  void add_logger(std::shared_ptr<MathLoggerImplementation> logger);
+  void Print(const CurrentIterationData& data);
+
+ private:
+  std::list<std::shared_ptr<MathLoggerImplementation>> math_loggers_;
+};

src/cpp/benders/benders_core/include/BendersStructsDatas.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include "ILogger.h"
 #include "SubproblemCut.h"
 #include "Worker.h"
 #include "common.h"
-#include "ILogger.h"
 
 struct CurrentIterationData {
   double subproblems_walltime;
@@ -32,6 +32,8 @@ struct CurrentIterationData {
   StoppingCriterion stopping_criterion;
   bool is_in_initial_relaxation;
   int number_of_subproblem_resolved;
+  int min_simplexiter;
+  int max_simplexiter;
 };
 /*!
  * \class WorkerMasterData

src/cpp/benders/benders_core/include/common.h

@@ -49,6 +49,8 @@ typedef std::vector<ActiveCut> ActiveCutStorage;
 typedef std::pair<std::string, std::string> mps_coupling;
 typedef std::list<mps_coupling> mps_coupling_list;
 
+enum class BENDERSMETHOD { BENDERS, BENDERSBYBATCH, MERGEMPS };
+
 struct Predicate {
   bool operator()(PointPtr const &lhs, PointPtr const &rhs) const {
     return *lhs < *rhs;