Manage multithreads logs

src/solver/optimisation/opt_appel_solveur_lineaire.cpp

@@ -97,15 +97,15 @@ struct SimplexResult
     mpsWriterFactory mps_writer_factory;
 };
 
-static SimplexResult OPT_TryToCallSimplex(
-        const OptimizationOptions& options,
-        PROBLEME_HEBDO* problemeHebdo,
-        Optimization::PROBLEME_SIMPLEXE_NOMME& Probleme,
-        const int NumIntervalle,
-        const int optimizationNumber,
-        const OptPeriodStringGenerator& optPeriodStringGenerator,
-        bool PremierPassage,
-        IResultWriter& writer)
+static SimplexResult OPT_TryToCallSimplex(const OptimizationOptions& options,
+                                          PROBLEME_HEBDO* problemeHebdo,
+                                          Optimization::PROBLEME_SIMPLEXE_NOMME& Probleme,
+                                          const int NumIntervalle,
+                                          const int optimizationNumber,
+                                          const OptPeriodStringGenerator& optPeriodStringGenerator,
+                                          bool PremierPassage,
+                                          IResultWriter& writer,
+                                          OrtoolsLogHandler& ortools_logger)
 {
     const auto& ProblemeAResoudre = problemeHebdo->ProblemeAResoudre;
     auto ProbSpx
@@ -225,7 +225,8 @@ static SimplexResult OPT_TryToCallSimplex(
     {
         solver = ORTOOLS_ConvertIfNeeded(options.solverName, &Probleme, solver);
     }
-    const std::string filename = createMPSfilename(optPeriodStringGenerator, optimizationNumber);
+
+        const std::string filename = createMPSfilename(optPeriodStringGenerator, optimizationNumber);
 
     mpsWriterFactory mps_writer_factory(problemeHebdo->ExportMPS,
                                         problemeHebdo->exportMPSOnError,
@@ -241,6 +242,13 @@ static SimplexResult OPT_TryToCallSimplex(
     if (options.useOrtools)
     {
         const bool keepBasis = (optimizationNumber == PREMIERE_OPTIMISATION);
+        // std::ofstream log_writer; // one per thread
+
+        // std::vector<std::ostream*> log_streams;
+        if (Probleme.SolverLogs())
+        {
+            setOrtoolsSolverLogs(solver, ortools_logger);
+        }
         solver = ORTOOLS_Simplexe(&Probleme, solver, keepBasis);
         if (solver != nullptr)
         {
@@ -308,16 +316,30 @@ bool OPT_AppelDuSimplexe(const OptimizationOptions& options,
                                                    problemeHebdo->solverLogs);
 
     bool PremierPassage = true;
-
-    struct SimplexResult simplexResult =
-        OPT_TryToCallSimplex(options, problemeHebdo, Probleme, NumIntervalle, optimizationNumber,
-                optPeriodStringGenerator, PremierPassage, writer);
+    // tmp
+    OrtoolsLogHandler ortools_logger;
+    struct SimplexResult simplexResult = OPT_TryToCallSimplex(options,
+                                                              problemeHebdo,
+                                                              Probleme,
+                                                              NumIntervalle,
+                                                              optimizationNumber,
+                                                              optPeriodStringGenerator,
+                                                              PremierPassage,
+                                                              writer,
+                                                              ortools_logger);
 
     if (!simplexResult.success)
     {
         PremierPassage = false;
-        simplexResult = OPT_TryToCallSimplex(options, problemeHebdo, Probleme,  NumIntervalle, optimizationNumber,
-                optPeriodStringGenerator, PremierPassage, writer);
+        simplexResult = OPT_TryToCallSimplex(options,
+                                             problemeHebdo,
+                                             Probleme,
+                                             NumIntervalle,
+                                             optimizationNumber,
+                                             optPeriodStringGenerator,
+                                             PremierPassage,
+                                             writer,
+                                             ortools_logger);
     }
 
     long long solveTime = simplexResult.solveTime;
@@ -372,8 +394,13 @@ bool OPT_AppelDuSimplexe(const OptimizationOptions& options,
 
         Probleme.SetUseNamedProblems(true);
 
-        auto MPproblem = std::shared_ptr<MPSolver>(ProblemSimplexeNommeConverter(options.solverName, &Probleme).Convert());
+        auto MPproblem = std::shared_ptr<MPSolver>(
+          ProblemSimplexeNommeConverter(options.solverName, &Probleme).Convert());
 
+        if (Probleme.SolverLogs())
+        {
+            setOrtoolsSolverLogs(MPproblem.get(), ortools_logger);
+        }
         auto analyzer = makeUnfeasiblePbAnalyzer();
         analyzer->run(MPproblem.get());
         analyzer->printReport();

src/solver/utils/ortools_utils.cpp

@@ -4,6 +4,7 @@
 #include <antares/exception/AssertionError.hpp>
 #include <antares/Enum.hpp>
 #include <filesystem>
+#include <thread>
 
 using namespace operations_research;
 
@@ -31,10 +32,25 @@ namespace Antares
 {
 namespace Optimization
 {
+void setOrtoolsSolverLogs(MPSolver* solver, OrtoolsLogHandler& ortools_logger)
+{
+    solver->EnableOutput(&ortools_logger);
+}
+
+OrtoolsLogHandler::OrtoolsLogHandler()
+{
+    std::filesystem::path log_file = logs.logfile().c_str();
+    auto log_directory = log_file.parent_path();
+    auto myid = std::this_thread::get_id();
+    std::stringstream ss;
+    ss << myid;
+    auto log_file_per_thread = log_directory / (std::string("thread_") + ss.str() + ".log");
+    log_writer_.open(log_file_per_thread, std::ofstream::out | std::ofstream::app);
+}
 ProblemSimplexeNommeConverter::ProblemSimplexeNommeConverter(
-        const std::string& solverName,
-        const Antares::Optimization::PROBLEME_SIMPLEXE_NOMME* problemeSimplexe)
-    : solverName_(solverName), problemeSimplexe_(problemeSimplexe)
+  const std::string& solverName,
+  const Antares::Optimization::PROBLEME_SIMPLEXE_NOMME* problemeSimplexe) :
+ solverName_(solverName), problemeSimplexe_(problemeSimplexe)
 {
     if (problemeSimplexe_->UseNamedProblems())
     {
@@ -55,10 +71,6 @@ MPSolver* ProblemSimplexeNommeConverter::Convert()
     CopyRows(solver);
 
     CopyMatrix(solver);
-    if (problemeSimplexe_->SolverLogs())
-    {
-        solver->EnableOutput();
-    }
 
     return solver;
 }

src/solver/utils/ortools_utils.h

@@ -2,6 +2,7 @@
 
 #include <map>
 #include <string>
+#include <fstream>
 
 #include <antares/writer/i_writer.h>
 
@@ -48,6 +49,26 @@ namespace Antares
 namespace Optimization
 {
 
+class OrtoolsLogHandler : public LogHandlerInterface
+{
+public:
+    // tmp test with std::cout
+    explicit OrtoolsLogHandler();
+    void message(const char* msg) override
+    {
+        log_writer_ << msg << std::endl;
+    }
+
+private:
+    // TODO won't work in ci, needs ortools update
+    // see https://github.com/rte-france/or-tools/pull/112
+
+    // // TODO
+    std::ofstream log_writer_;
+    // log_writer.open(log_file_per_thread, std::ofstream::out | std::ofstream::app);
+    // log_streams.push_back(&log_writer);
+};
+void setOrtoolsSolverLogs(MPSolver* solver, OrtoolsLogHandler &ortools_logger);
 class Nomenclature
 {
 public: