add real PDLP_DEBUG_LOG

Author: Yanyu000

check/TestPdlp.cpp

@@ -342,7 +342,7 @@ TEST_CASE("pdlp-restart-add-row", "[pdlp]") {
 }
 
 TEST_CASE("hi-pdlp", "[pdlp]") {
-  std::string model = "neso-2005";  //"adlittle";//"afiro";// shell// stair
+  std::string model = "afiro";  //"adlittle";//"afiro";// shell// stair
                                  ////25fv47 //fit2p //avgas //neso-2245 //neso-2005
   std::string model_file =
       //std::string(HIGHS_DIR) + "/srv/" + model + ".mps.gz";
@@ -357,7 +357,7 @@ TEST_CASE("hi-pdlp", "[pdlp]") {
   HighsInt pdlp_features_off = 0
       //+kPdlpScalingOff
       //+kPdlpRestartOff
-      //+kPdlpAdaptiveStepSizeOff
+      +kPdlpAdaptiveStepSizeOff
       ;
   h.setOptionValue("pdlp_features_off", pdlp_features_off);
 
@@ -366,9 +366,9 @@ TEST_CASE("hi-pdlp", "[pdlp]") {
       //+ kPdlpScalingL2
       + kPdlpScalingPC;
   h.setOptionValue("pdlp_scaling_mode", pdlp_scaling);
-  h.setOptionValue("pdlp_step_size_strategy", 1);
+  h.setOptionValue("pdlp_step_size_strategy", 0);
   h.setOptionValue("pdlp_restart_strategy", 2);
-  h.setOptionValue("pdlp_iteration_limit", 20000);
+  h.setOptionValue("pdlp_iteration_limit", 20);
   //h.setOptionValue("pdlp_time_limit", 60);
   //   h.setOptionValue("log_dev_level", kHighsLogDevLevelVerbose);
   auto start_hipdlp = std::chrono::high_resolution_clock::now();

highs/pdlp/cupdlp/cupdlp_defs.h

@@ -41,7 +41,7 @@ extern "C" {
 #define CUPDLP_DUMP_LINESEARCH_STATS (1)
 #define CUPDLP_INEXACT_EPS (1e-4)
 
-#define PDLP_DEBUG_LOG (1)
+#define PDLP_DEBUG_LOG (0)
 
 typedef struct CUPDLP_CUDA_DENSE_VEC CUPDLPvec;
 typedef struct CUPDLP_DENSE_MATRIX CUPDLPdense;

highs/pdlp/hipdlp/pdhg.cc

@@ -513,8 +513,12 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
 
   // --- 1. Initialization ---
   restart_scheme_.passLogOptions(&working_params.log_options_);
+
+#ifdef PDLP_DEBUG_LOG
   restart_scheme_.passDebugPdlpLogFile(debug_pdlp_log_file_);
   restart_scheme_.passDebugPdlpData(&debug_pdlp_data_);
+#endif
+
   initialize();  // Sets initial x, y and results_
   restart_scheme_.passParams(&working_params);
   restart_scheme_.Initialize(results_);
@@ -550,17 +554,22 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
   logger_.print_iteration_header();
 
   // --- 2. Main PDHG Loop ---
+#ifdef PDLP_DEBUG_LOG
   debugPdlpIterHeaderLog(debug_pdlp_log_file_);
   debugPdlpDataInitialise(&debug_pdlp_data_);
   debug_pdlp_data_.ax_average_norm = 0.0;
   debug_pdlp_data_.aty_average_norm = 0.0;
   debug_pdlp_data_.x_average_norm = 0.0;
   debug_pdlp_data_.ax_norm = linalg::vector_norm(Ax_cache_);
+#endif
 
   for (int iter = 0; iter < params_.max_iterations; ++iter) {
+    std::cout << "PDHG Iteration " << iter << std::endl;
+#ifdef PDLP_DEBUG_LOG
     debugPdlpIterLog(debug_pdlp_log_file_, iter, &debug_pdlp_data_,
                      restart_scheme_.getBeta(), stepsize_.primal_step,
                      stepsize_.dual_step);
+#endif
 
     // Check time limit
     if (solver_timer.read() > params_.time_limit) {
@@ -809,6 +818,7 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
                           cudaMemcpyDeviceToDevice));
     CUDA_CHECK(cudaMemcpy(d_y_next_, d_y_current_, a_num_rows_ * sizeof(double),
                           cudaMemcpyDeviceToDevice));
+    #ifdef PDLP_DEBUG_LOG
     // Copy Ax and ATy cache to host
     CUDA_CHECK(cudaMemcpy(Ax_cache_.data(), d_ax_current_,
                           a_num_rows_ * sizeof(double),
@@ -818,11 +828,15 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
                           cudaMemcpyDeviceToHost));
     debug_pdlp_data_.ax_norm = linalg::vector_norm(Ax_cache_);
     debug_pdlp_data_.aty_norm = linalg::vector_norm(ATy_cache_);
+    #endif
 #else
     x_next_ = x_current_;
     y_next_ = y_current_;
+
+   #ifdef PDLP_DEBUG_LOG 
     debug_pdlp_data_.ax_norm = linalg::vector_norm(Ax_cache_);
     debug_pdlp_data_.aty_norm = linalg::vector_norm(ATy_cache_);
+   #endif
 #endif
 
     switch (params_.step_size_strategy) {
@@ -992,7 +1006,9 @@ void PDLPSolver::computeAverageIterate(std::vector<double>& ax_avg,
   for (size_t i = 0; i < y_avg_.size(); ++i) y_avg_[i] = y_sum_[i] * dDualScale;
   hipdlpTimerStop(kHipdlpClockAverageIterateComputeY);
 
+#ifdef PDLP_DEBUG_LOG
   debug_pdlp_data_.x_average_norm = linalg::vector_norm_squared(x_avg_);
+#endif
 
   hipdlpTimerStart(kHipdlpClockAverageIterateMatrixMultiply);
   linalg::Ax(lp_, x_avg_, ax_avg);
@@ -1002,8 +1018,10 @@ void PDLPSolver::computeAverageIterate(std::vector<double>& ax_avg,
   linalg::ATy(lp_, y_avg_, aty_avg);
   hipdlpTimerStop(kHipdlpClockAverageIterateMatrixTransposeMultiply);
 
+#ifdef PDLP_DEBUG_LOG
   debug_pdlp_data_.ax_average_norm = linalg::vector_norm_squared(ax_avg);
   debug_pdlp_data_.aty_average_norm = linalg::vector_norm_squared(aty_avg);
+#endif
 }
 
 // lambda = c - proj_{\Lambda}(c - K^T y)
@@ -1224,10 +1242,12 @@ bool PDLPSolver::checkConvergence(
       std::abs(duality_gap) / (1.0 + std::abs(primal_obj) + std::abs(dual_obj));
   results.relative_obj_gap = relative_obj_gap;
 
+#ifdef PDLP_DEBUG_LOG
   debugPdlpFeasOptLog(debug_pdlp_log_file_, iter, primal_obj, dual_obj,
                       relative_obj_gap,
                       primal_feasibility / (1.0 + unscaled_rhs_norm_),
                       dual_feasibility / (1.0 + unscaled_c_norm_), type);
+#endif
 
   // Check convergence criteria (matching cuPDLP)
   bool primal_feasible =
@@ -1673,6 +1693,9 @@ void PDLPSolver::updateIteratesFixed() {
       vecDiff(ax_next_gpu, Ax_next_, 1e-10, "UpdateIteratesFixed Ax");
   bool aty_match =
       vecDiff(aty_next_gpu, ATy_next_, 1e-10, "UpdateIteratesFixed ATy");
+
+#else 
+
 #endif
 }
 
@@ -2237,11 +2260,13 @@ bool PDLPSolver::checkConvergenceGpu(const int iter, const double* d_x,
   results.relative_obj_gap =
       std::abs(duality_gap) / (1.0 + std::abs(primal_obj) + std::abs(dual_obj));
 
+#ifdef PDLP_DEBUG_LOG
   debugPdlpFeasOptLog(debug_pdlp_log_file_, iter, primal_obj, dual_obj,
                       results.relative_obj_gap,
                       results.primal_feasibility / (1.0 + unscaled_rhs_norm_),
                       results.dual_feasibility / (1.0 + unscaled_c_norm_),
                       type);
+#endif
 
   bool primal_feasible =
       results.primal_feasibility < epsilon * (1.0 + unscaled_rhs_norm_);
@@ -2300,12 +2325,13 @@ void PDLPSolver::computeAverageIterateGpu() {
   // Recompute Ax_avg and ATy_avg on GPU
   linalgGpuAx(d_x_avg_, d_ax_avg_);
   linalgGpuATy(d_y_avg_, d_aty_avg_);
+
+#ifdef PDLP_DEBUG_LOG
   // copy x_avg to host
   CUDA_CHECK(cudaMemcpy(x_avg_.data(), d_x_avg_, a_num_cols_ * sizeof(double),
                         cudaMemcpyDeviceToHost));
   debug_pdlp_data_.x_average_norm = linalg::vector_norm_squared(x_avg_);
-
-  // debug_pdlp_data_.ax_average_norm = computeDiffNormCuBLAS;
+#endif
 }
 
 double PDLPSolver::computeMovementGpu(const double* d_x_new,

highs/pdlp/hipdlp/pdhg.hpp

@@ -16,6 +16,8 @@
 #include <cusparse.h>
 #endif
 
+#define DEBUG_MODE 1
+
 #include <algorithm>
 #include <cmath>
 #include <iostream>
@@ -53,10 +55,11 @@ class PDLPSolver {
   int getnCol() const { return lp_.num_col_; }
   int getnRow() const { return lp_.num_row_; }
 
+#ifdef PDLP_DEBUG_LOG
   // --- Debugging ---
   FILE* debug_pdlp_log_file_ = nullptr;
   DebugPdlpData debug_pdlp_data_;
-
+#endif
   void reportHipdlpTimer();
   void closeDebugLog();