MIP log cleanup

cpp/src/branch_and_bound/branch_and_bound.hpp

@@ -261,6 +261,7 @@ class branch_and_bound_t {
   omp_atomic_t<f_t> lower_bound_numerical_;
   std::function<void(f_t)> user_bound_callback_;
 
+  void print_table_header();
   void report_heuristic(f_t obj);
   void report(char symbol,
               f_t obj,

cpp/src/branch_and_bound/symmetry.hpp

@@ -684,6 +684,8 @@ std::unique_ptr<mip_symmetry_t<i_t, f_t>> detect_symmetry(
   const simplex::simplex_solver_settings_t<i_t, f_t>& settings,
   bool& has_symmetry)
 {
+  settings.log.printf("\nRunning symmetry detection...\n");
+
   has_symmetry = false;
 
   f_t start_time = simplex::tic();

cpp/src/cuts/cuts.cpp

@@ -3610,6 +3610,8 @@ variable_bounds_t<i_t, f_t>::variable_bounds_t(const lp_problem_t<i_t, f_t>& lp,
   }
   f_t start_time = tic();
 
+  settings.log.printf("Computing variable bounds...");
+
   std::vector<i_t> num_integer_in_row(lp.num_rows, 0);
 
   // Construct the slack map
@@ -3780,8 +3782,9 @@ variable_bounds_t<i_t, f_t>::variable_bounds_t(const lp_problem_t<i_t, f_t>& lp,
       }
     }
   }
+
   upper_offsets[lp.num_cols] = upper_edges;
-  settings.log.printf("%d variable upper bounds in %.2f seconds\n", upper_edges, toc(start_time));
+  settings.log.print_format("{} variable upper bounds in {:.2f}s\n", upper_edges, toc(start_time));
 
   // Now go through all continuous variables and use the activiites to get lower variable bounds
   i_t lower_edges = 0;
@@ -3871,8 +3874,9 @@ variable_bounds_t<i_t, f_t>::variable_bounds_t(const lp_problem_t<i_t, f_t>& lp,
       }
     }
   }
+
   lower_offsets[lp.num_cols] = lower_edges;
-  settings.log.printf("%d variable lower bounds in %.2f seconds\n", lower_edges, toc(start_time));
+  settings.log.print_format("{} variable lower bounds in {:.2f}s\n", lower_edges, toc(start_time));
 }
 
 template <typename i_t, typename f_t>

cpp/src/dual_simplex/logger.hpp

@@ -16,6 +16,8 @@
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
+#include <format>
+#include <utility>
 
 namespace cuopt::mathematical_optimization::simplex {
 
@@ -84,6 +86,29 @@ class logger_t {
     }
   }
 
+  template <typename... Args>
+  void print_format(std::format_string<Args...> fmt, Args&&... args)
+  {
+    if (log) {
+      std::string msg = std::format(fmt, std::forward<Args>(args)...);
+      if (log_to_console) {
+#ifdef CUOPT_LOG_ACTIVE_LEVEL
+        std::string msg_no_newline = msg;
+        if (msg_no_newline.size() > 0 && msg.ends_with("\n")) { msg_no_newline.pop_back(); }
+
+        CUOPT_LOG_INFO("%s%s", log_prefix.c_str(), msg_no_newline.c_str());
+#else
+        std::printf("%s", msg.c_str());
+        fflush(stdout);
+#endif
+      }
+      if (log_to_file && log_file != nullptr) {
+        std::fprintf(log_file, "%s", msg.c_str());
+        fflush(log_file);
+      }
+    }
+  }
+
   void debug([[maybe_unused]] const char* fmt, ...)
   {
     if (log) {
@@ -118,6 +143,28 @@ class logger_t {
     }
   }
 
+  template <typename... Args>
+  void debug_format(std::format_string<Args...> fmt, Args&&... args)
+  {
+    if (log) {
+      std::string msg = std::format(fmt, std::forward<Args>(args)...);
+      if (log_to_console) {
+#ifdef CUOPT_LOG_DEBUG
+        std::string msg_no_newline = msg;
+        if (msg_no_newline.size() > 0 && msg.ends_with("\n")) { msg_no_newline.pop_back(); }
+        CUOPT_LOG_TRACE("%s%s", log_prefix.c_str(), msg_no_newline.c_str());
+#else
+        std::printf("%s", msg.c_str());
+        fflush(stdout);
+#endif
+      }
+      if (log_to_file && log_file != nullptr) {
+        std::fprintf(log_file, "%s", msg.c_str());
+        fflush(log_file);
+      }
+    }
+  }
+
   bool log;
   bool log_to_console;
   std::string log_prefix;

cpp/src/mip_heuristics/diversity/diversity_manager.cu

@@ -223,7 +223,7 @@ template <typename i_t, typename f_t>
 bool diversity_manager_t<i_t, f_t>::run_presolve(f_t time_limit, timer_t global_timer)
 {
   raft::common::nvtx::range fun_scope("run_presolve");
-  CUOPT_LOG_INFO("Starting cuOpt presolve");
+  CUOPT_LOG_INFO("\nRunning cuOpt presolve");
   timer_t presolve_timer(time_limit);
 
   auto term_crit = ls.constraint_prop.bounds_update.solve(*problem_ptr);

cpp/src/mip_heuristics/presolve/third_party_presolve.cpp

@@ -683,12 +683,12 @@ third_party_presolve_result_t<i_t, f_t> third_party_presolve_t<i_t, f_t>::apply(
 
   papilo::Problem<f_t> papilo_problem = build_papilo_problem(op_problem, category, maximize_);
 
-  CUOPT_LOG_INFO("Original problem: %d constraints, %d variables, %d nonzeros",
-                 papilo_problem.getNRows(),
-                 papilo_problem.getNCols(),
-                 papilo_problem.getConstraintMatrix().getNnz());
+  CUOPT_LOG_DEBUG("Original problem: %d constraints, %d variables, %d nonzeros",
+                  papilo_problem.getNRows(),
+                  papilo_problem.getNCols(),
+                  papilo_problem.getConstraintMatrix().getNnz());
 
-  CUOPT_LOG_INFO("Calling Papilo presolver (git hash %s)", PAPILO_GITHASH);
+  CUOPT_LOG_INFO("\nRunning Papilo presolve (git hash %s)", PAPILO_GITHASH);
   if (category == problem_category_t::MIP) { dual_postsolve = false; }
   papilo::Presolve<f_t> papilo_presolver;
   set_presolve_methods(papilo_presolver, category, dual_postsolve);
@@ -735,7 +735,7 @@ third_party_presolve_result_t<i_t, f_t> third_party_presolve_t<i_t, f_t>::apply(
 
   // Check if presolve found the optimal solution (problem fully reduced)
   if (papilo_problem.getNRows() == 0 && papilo_problem.getNCols() == 0) {
-    CUOPT_LOG_INFO("Optimal solution found during presolve");
+    status = third_party_presolve_status_t::OPTIMAL;
   }
 
   auto opt_problem = build_optimization_problem<i_t, f_t>(

cpp/src/mip_heuristics/solve.cu

@@ -149,7 +149,6 @@ mip_solution_t<i_t, f_t> run_mip_solver(
       auto stats = solver_stats_t<i_t, f_t>{};
       stats.set_solution_bound(solution.get_user_objective());
       // log the objective for scripts which need it
-      CUOPT_LOG_INFO("Best feasible: %f", solution.get_user_objective());
       for (auto callback : settings.get_mip_callbacks()) {
         if (callback->get_type() == internals::base_solution_callback_type::GET_SOLUTION) {
           auto temp_sol(solution);
@@ -593,6 +592,10 @@ mip_solution_t<i_t, f_t> solve_mip_helper(optimization_problem_t<i_t, f_t>& op_p
         CUOPT_LOG_INFO("%d implied integers", presolve_result_opt->implied_integer_indices.size());
       }
       CUOPT_LOG_INFO("Papilo presolve time: %.2f", presolve_time);
+
+      if (result.status == mip::third_party_presolve_status_t::OPTIMAL) {
+        CUOPT_LOG_INFO("Optimal solution found during presolve.");
+      }
     }
 
     // Stop early GPU FJ now that Papilo presolve is complete
@@ -747,10 +750,7 @@ mip_solution_t<i_t, f_t> solve_mip_helper(optimization_problem_t<i_t, f_t>& op_p
       }
     }
 
-    if (sol.get_termination_status() == mip_termination_status_t::FeasibleFound ||
-        sol.get_termination_status() == mip_termination_status_t::Optimal) {
-      sol.log_detailed_summary();
-    }
+    sol.log_detailed_summary();
 
     if (settings.sol_file != "") {
       CUOPT_LOG_INFO("Writing solution to file %s", settings.sol_file.c_str());

cpp/src/mip_heuristics/solver.cu

@@ -183,7 +183,7 @@ void extract_probing_implied_bounds(const problem_t<i_t, f_t>& op_problem,
     }
   }
 
-  CUOPT_LOG_INFO("Probing implied bounds: %d zero entries, %d one entries", zero_nnz, one_nnz);
+  CUOPT_LOG_INFO("\nProbing implied bounds: %d zero entries, %d one entries", zero_nnz, one_nnz);
 }
 
 template <typename i_t, typename f_t>

cpp/src/mip_heuristics/solver_solution.cu

@@ -238,21 +238,39 @@ void mip_solution_t<i_t, f_t>::log_summary() const
 template <typename i_t, typename f_t>
 void mip_solution_t<i_t, f_t>::log_detailed_summary() const
 {
-  CUOPT_LOG_INFO(
-    "Solution objective: %f , relative_mip_gap %f solution_bound %f presolve_time %f "
-    "total_solve_time %f "
-    "max constraint violation %f max int violation %f max var bounds violation %f "
-    "nodes %d simplex_iterations %d",
-    objective_,
-    mip_gap_,
-    stats_.get_solution_bound(),
-    stats_.presolve_time,
-    stats_.total_solve_time,
-    max_constraint_violation_,
-    max_int_violation_,
-    max_variable_bound_violation_,
-    stats_.num_nodes,
-    stats_.num_simplex_iterations);
+  switch (termination_status_) {
+    case mip_termination_status_t::Optimal:
+    case mip_termination_status_t::FeasibleFound:
+      CUOPT_LOG_INFO("%s\n",
+                     std::format("Best objective {:.6e}, best bound {:.6e}, gap {:.2f}%.",
+                                 objective_,
+                                 stats_.get_solution_bound(),
+                                 mip_gap_ * 100)
+                       .c_str());
+      break;
+
+    case mip_termination_status_t::Infeasible:
+      CUOPT_LOG_INFO("Problem has no integer feasible solution.\n");
+      break;
+
+    case mip_termination_status_t::TimeLimit:
+      CUOPT_LOG_INFO("No feasible solution was found within the time limit.\n");
+      break;
+
+    case mip_termination_status_t::WorkLimit:
+      CUOPT_LOG_INFO("No feasible solution was found within the work limit.\n");
+      break;
+
+    case mip_termination_status_t::Unbounded: CUOPT_LOG_INFO("The problem is unbounded.\n"); break;
+
+    case mip_termination_status_t::UnboundedOrInfeasible:
+      CUOPT_LOG_INFO("The problem is unbounded or infeasible.\n");
+      break;
+
+    case mip_termination_status_t::NoTermination:
+      CUOPT_LOG_INFO("Warning: The solver did not terminate successfully.\n");
+      break;
+  }
 }
 
 #if MIP_INSTANTIATE_FLOAT || PDLP_INSTANTIATE_FLOAT

python/cuopt/cuopt/tests/linear_programming/test_cpu_only_execution.py

@@ -120,9 +120,9 @@ def _parse_cli_output(output):
             result["status"] = "Optimal"
             continue
 
-        # MIP solution: "Solution objective: 2.000000 , ..."
+        # MIP solution: "Best objective 2.000000 , ..."
         m = re.match(
-            r"Solution objective:\s*([+-]?\d+\.?\d*(?:[eE][+-]?\d+)?)",
+            r"Best objective \s*([+-]?\d+\.?\d*(?:[eE][+-]?\d+)?)",
             stripped,
         )
         if m:

python/libcuopt/libcuopt/tests/test_cli.sh

@@ -30,4 +30,4 @@ cuopt_cli "${RAPIDS_DATASET_ROOT_DIR}"/linear_programming/good-mps-1.lp.bz2 | gr
 
 # Add a for mixed integer programming test with options
 
-cuopt_cli "${RAPIDS_DATASET_ROOT_DIR}"/mip/sample.mps --mip-absolute-gap 0.01 --time-limit 10 | grep -q "Solution objective" || (echo "Expected solution objective not found" && exit 1)
+cuopt_cli "${RAPIDS_DATASET_ROOT_DIR}"/mip/sample.mps --mip-absolute-gap 0.01 --time-limit 10 | grep -q "Best objective" || (echo "Expected solution objective not found" && exit 1)