Move logger entirely within PDLPSolver

Author: jajhall

highs/pdlp/HiPdlpWrapper.cpp

@@ -15,9 +15,6 @@
 #include "pdlp/hipdlp/pdhg.hpp"
 #include "pdlp/hipdlp/restart.hpp"
 
-void getHiPpdlpParamsFromOptions(const HighsOptions& options, HighsTimer& timer,
-                                 PrimalDualParams& params);
-
 HighsStatus solveLpHiPdlp(HighsLpSolverObject& solver_object) {
   return solveLpHiPdlp(solver_object.options_, solver_object.timer_,
                        solver_object.lp_, solver_object.basis_,
@@ -33,23 +30,11 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   // Indicate that no imprecise solution has (yet) been found
   resetModelStatusAndHighsInfo(model_status, highs_info);
 
-  std::string log_filename = "";
-  LogLevel log_level;
-  if (options.log_dev_level == kHighsLogDevLevelInfo) {
-    log_level = LogLevel::kInfo;
-  } else if (options.log_dev_level == kHighsLogDevLevelDetailed) {
-    log_level = LogLevel::kVerbose;
-  } else if (options.log_dev_level == kHighsLogDevLevelVerbose) {
-    log_level = LogLevel::kDebug;
-  } else {
-    log_level = LogLevel::kNone;
-  }
-  // --- Initialize Logger ---
-  Logger logger(log_level);
-  if (!log_filename.empty()) logger.set_log_file(log_filename);
+  Logger logger;
+  logger.setLevel(options.log_dev_level);
+  logger.passHighsLogOptions(options.log_options);
   logger.print_header();
 
-  Timer total_timer;
   /*** Order of operations
    * Preprocess with HiPdlp
    * Scale with HiPdlp
@@ -62,7 +47,6 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   pdlp.setParams(options, timer);
   HighsLp preprocessed_lp;
   pdlp.passLp(&lp);
-  // logger_.info("Preprocessing LP to handle ranged constraints...");
   pdlp.preprocessLp();
 
   // 3. Scale with HiPdlp
@@ -81,16 +65,15 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   // return x, y
 
   // --- Print Summary ---
-  logger.print_summary(pdlp.getResults(), pdlp.getIterationCount(),
-                       total_timer.read());
+  pdlp.logSummary();
 
   highs_info.pdlp_iteration_count = pdlp.getIterationCount();
 
   model_status = HighsModelStatus::kUnknown;
   highs_solution.clear();
   highs_basis.valid = false;
 
-  const TerminationStatus termination_status = pdlp.getResults().term_code;
+  const TerminationStatus termination_status = pdlp.getTerminationCode();
   switch (termination_status) {
     case TerminationStatus::OPTIMAL: {
       model_status = HighsModelStatus::kOptimal;
@@ -142,35 +125,3 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   return HighsStatus::kOk;
 }
 
-void PrimalDualParams::initialise() {
-  this->eta = 0;
-  this->omega = 0;
-  this->tolerance = 0;
-  this->max_iterations = 0;
-  this->device_type = Device::CPU;
-  this->time_limit = 3600.0;
-  this->restart_strategy = RestartStrategy::NO_RESTART;
-  this->fixed_restart_interval = 0;
-  this->use_halpern_restart = false;
-  this->scaling_method = ScalingMethod::NONE;
-  this->use_ruiz_scaling = false;
-  this->use_pc_scaling = false;
-  this->use_l2_scaling = false;
-  this->ruiz_iterations = 10;
-  this->ruiz_norm = INFINITY;
-  this->pc_alpha = 1.0;
-  this->step_size_strategy = StepSizeStrategy::FIXED;
-  this->malitsky_pock_params.initialise();
-  this->adaptive_linesearch_params.initialise();
-}
-
-void MalitskyPockParams::initialise() {
-  this->step_size_interpolation = 0.5;  // Between 0 and 1
-  this->step_size_downscaling_factor = 0.7;
-  this->linesearch_contraction_factor = 0.99;
-}
-
-void AdaptiveLinesearchParams::initialise() {
-  this->step_size_reduction_exponent = 0.3;
-  this->step_size_growth_exponent = 0.6;
-}

highs/pdlp/hipdlp/defs.hpp

@@ -69,6 +69,7 @@ struct PrimalDualParams {
 
   MalitskyPockParams malitsky_pock_params;
   AdaptiveLinesearchParams adaptive_linesearch_params;
+  HighsLogOptions log_options_;
   void initialise();
 };
 

highs/pdlp/hipdlp/logger.cc

@@ -31,22 +31,21 @@ double Timer::read() {
 }
 
 // Logger implementation
-Logger::Logger(LogLevel level) : console_level_(level) {}
-
-void Logger::set_log_file(const std::string& filename) {
-  log_file_.open(filename, std::ios::out | std::ios::trunc);
-  if (!log_file_.is_open()) {
-    std::cerr << "Error: Could not open log file: " << filename << std::endl;
+void Logger::setLevel(const HighsInt log_dev_level) {
+  if (log_dev_level == kHighsLogDevLevelVerbose) {
+    console_level_ = LogLevel::kDebug;
+  } else if (log_dev_level == kHighsLogDevLevelDetailed) {
+    console_level_ = LogLevel::kVerbose;
+  } else if (log_dev_level == kHighsLogDevLevelInfo) {
+    console_level_ = LogLevel::kInfo;
+  } else {
+    console_level_ = LogLevel::kInfo;//None;
   }
 }
 
 void Logger::log(LogLevel level, const std::string& message) {
-  if (level <= console_level_) {
-    std::cout << message << std::endl;
-  }
-  if (log_file_.is_open()) {
-    log_file_ << message << std::endl;
-  }
+  if (level <= console_level_) 
+    highsLogUser(log_options_, HighsLogType::kInfo, "%s\n", message.c_str());
 }
 
 void Logger::info(const std::string& message) { log(LogLevel::kInfo, message); }

highs/pdlp/hipdlp/logger.hpp

@@ -41,7 +41,8 @@ class Timer {
 
 class Logger {
  public:
-  Logger(LogLevel level = LogLevel::kInfo);
+  void setLevel(const HighsInt log_dev_level);
+  void passHighsLogOptions(const HighsLogOptions log_options) { log_options_ = log_options;}
   void set_log_file(const std::string& filename);
   LogLevel getLogLevel() const { return console_level_; }
   // Logging methods for different levels
@@ -61,7 +62,8 @@ class Logger {
  private:
   void log(LogLevel level, const std::string& message);
   LogLevel console_level_;
-  std::ofstream log_file_;
+  HighsLogOptions log_options_;
+  
 };
 
 #endif  // PDLP_HIPDLP_LOGGER_HPP

highs/pdlp/hipdlp/pdhg.cc

@@ -24,8 +24,6 @@
 
 using namespace std;
 
-int PDLPSolver::getIterationCount() const { return final_iter_count_; }
-
 void PDLPSolver::preprocessLp() {
   logger_.info(
       "Preprocessing LP using cupdlp formulation (slack variables for "
@@ -950,6 +948,8 @@ void PDLPSolver::setParams(const HighsOptions& options, HighsTimer& timer) {
   //  parse_options_file
   scaling_.passParams(&params_);
   restart_scheme_.passParams(&params_);
+  // Copy what's needed to use HiGHS logging
+  params_.log_options_ = options.log_options;
 }
 
 void PDLPSolver::scaleProblem() {
@@ -962,3 +962,40 @@ void PDLPSolver::unscaleSolution(std::vector<double>& x,
                                  std::vector<double>& y) const {
   scaling_.unscaleSolution(x, y);
 }
+void PDLPSolver::logSummary() {
+  logger_.print_summary(results_, final_iter_count_, total_timer.read());
+}
+
+void PrimalDualParams::initialise() {
+  this->eta = 0;
+  this->omega = 0;
+  this->tolerance = 0;
+  this->max_iterations = 0;
+  this->device_type = Device::CPU;
+  this->time_limit = 3600.0;
+  this->restart_strategy = RestartStrategy::NO_RESTART;
+  this->fixed_restart_interval = 0;
+  this->use_halpern_restart = false;
+  this->scaling_method = ScalingMethod::NONE;
+  this->use_ruiz_scaling = false;
+  this->use_pc_scaling = false;
+  this->use_l2_scaling = false;
+  this->ruiz_iterations = 10;
+  this->ruiz_norm = INFINITY;
+  this->pc_alpha = 1.0;
+  this->step_size_strategy = StepSizeStrategy::FIXED;
+  this->malitsky_pock_params.initialise();
+  this->adaptive_linesearch_params.initialise();
+  this->log_options_.clear();
+}
+
+void MalitskyPockParams::initialise() {
+  this->step_size_interpolation = 0.5;  // Between 0 and 1
+  this->step_size_downscaling_factor = 0.7;
+  this->linesearch_contraction_factor = 0.99;
+}
+
+void AdaptiveLinesearchParams::initialise() {
+  this->step_size_reduction_exponent = 0.3;
+  this->step_size_growth_exponent = 0.6;
+}

highs/pdlp/hipdlp/pdhg.hpp

@@ -47,9 +47,10 @@ class PDLPSolver {
   void getSolution(std::vector<double>& col_value,
                    std::vector<double>& row_dual);
 
-  const SolverResults& getResults() const { return results_; }
   void passLp(const HighsLp* lp) { original_lp_ = lp; }
-  int getIterationCount() const;
+  TerminationStatus getTerminationCode() const { return results_.term_code; }
+  int getIterationCount() const { return final_iter_count_; }
+  void logSummary();
 
  private:
   // Problem data
@@ -93,6 +94,7 @@ class PDLPSolver {
   std::vector<double> dSlackNeg_;
 
   FILE* pdlp_log_file_ = nullptr;
+  Timer total_timer;
 
   // Helper functions
   void solveReturn();