mip

Author: Yanyu000

check/TestPdlp.cpp

@@ -3,6 +3,7 @@
 #include "Highs.h"
 #include "SpecialLps.h"
 #include "catch.hpp"
+#include <chrono>
 
 const bool dev_run = false;
 const double double_equal_tolerance = 1e-3;
@@ -333,30 +334,42 @@ TEST_CASE("pdlp-restart-add-row", "[pdlp]") {
 }
 
 TEST_CASE("hi-pdlp", "[pdlp]") {
-  std::string model = "afiro";  //"adlittle";//"afiro";//
+  std::string model = "adlittle";  //"adlittle";//"afiro";// shell// stair //25fv47 //fit2p
   std::string model_file =
       std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
   Highs h;
   // h.setOptionValue("output_flag", dev_run);
   REQUIRE(h.readModel(model_file) == HighsStatus::kOk);
   h.setOptionValue("solver", kHiPdlpString);
   h.setOptionValue("kkt_tolerance", kkt_tolerance);
+  h.setOptionValue("presolve", "off");
 
-  HighsInt pdlp_features_off =
-      // kPdlpScalingOff +
-      kPdlpRestartOff + kPdlpAdaptiveStepSizeOff;
+  HighsInt pdlp_features_off = 
+      //kPdlpScalingOff +
+      //kPdlpRestartOff 
+      kPdlpAdaptiveStepSizeOff
+      ;
   h.setOptionValue("pdlp_features_off", pdlp_features_off);
 
   HighsInt pdlp_scaling =  // 0;
       kPdlpScalingRuiz
       //+ kPdlpScalingL2
       + kPdlpScalingPC;
   h.setOptionValue("pdlp_scaling_mode", pdlp_scaling);
-  h.setOptionValue("pdlp_step_size_strategy", 0);
+  h.setOptionValue("pdlp_step_size_strategy", 1);
   h.setOptionValue("pdlp_restart_strategy", 2);
-  //  h.setOptionValue("pdlp_iteration_limit", 15);
+  h.setOptionValue("pdlp_iteration_limit",3520);
   //  h.setOptionValue("log_dev_level", kHighsLogDevLevelVerbose);
+  auto start_hipdlp = std::chrono::high_resolution_clock::now();
   HighsStatus run_status = h.run();
+  auto end_hipdlp = std::chrono::high_resolution_clock::now();
+  auto duration_hipdlp = std::chrono::duration_cast<std::chrono::milliseconds>(end_hipdlp - start_hipdlp);
+  std::cout << "\n--- HiPDLP Results ---" << std::endl;
+  std::cout << "Status: " << h.modelStatusToString(h.getModelStatus()) << std::endl;
+  std::cout << "Iterations: " << h.getInfo().pdlp_iteration_count << std::endl;
+  std::cout << "Wall time: " << duration_hipdlp.count() / 1000.0 << " seconds" << std::endl;
+  std::cout << "Objective: " << h.getInfo().objective_function_value << std::endl;
+  
   //  REQUIRE(run_status == HighsStatus::kOk);
   //  REQUIRE(h.getModelStatus() == HighsModelStatus::kOptimal);
   //  REQUIRE(h.getInfo().pdlp_iteration_count == 11880);
@@ -365,7 +378,15 @@ TEST_CASE("hi-pdlp", "[pdlp]") {
     h.clearSolver();
     h.setOptionValue("solver", kCuPdlpString);
     h.setOptionValue("pdlp_log_level", 2);
+    auto start_cupdlp = std::chrono::high_resolution_clock::now();
     run_status = h.run();
+    auto end_cupdlp = std::chrono::high_resolution_clock::now();
+    auto duration_cupdlp = std::chrono::duration_cast<std::chrono::milliseconds>(end_cupdlp - start_cupdlp);
+    std::cout << "\n--- cuPDLP Results ---" << std::endl;
+    std::cout << "Status: " << h.modelStatusToString(h.getModelStatus()) << std::endl;
+    std::cout << "Iterations: " << h.getInfo().pdlp_iteration_count << std::endl;
+    std::cout << "Wall time: " << duration_cupdlp.count() / 1000.0 << " seconds" << std::endl;
+    std::cout << "Objective: " <<  h.getInfo().objective_function_value << std::endl;
   }
   h.resetGlobalScheduler(true);
 }

cmake/sources-python.cmake

@@ -242,7 +242,6 @@ set(highs_sources_python
     highs/pdlp/hipdlp/pdhg.cc
     highs/pdlp/hipdlp/restart.cc
     highs/pdlp/hipdlp/scaling.cc
-    highs/pdlp/hipdlp/step.cc
     highs/presolve/HighsPostsolveStack.cpp
     highs/presolve/HighsSymmetry.cpp
     highs/presolve/HPresolve.cpp
@@ -381,7 +380,6 @@ set(highs_headers_python
     highs/pdlp/hipdlp/restart.hpp
     highs/pdlp/hipdlp/scaling.hpp
     highs/pdlp/hipdlp/solver_results.hpp
-    highs/pdlp/hipdlp/step.hpp
     highs/presolve/HighsPostsolveStack.h
     highs/presolve/HighsSymmetry.h
     highs/presolve/HPresolve.h

cmake/sources.cmake

@@ -326,7 +326,6 @@ set(highs_sources
     pdlp/hipdlp/pdhg.cc
     pdlp/hipdlp/restart.cc
     pdlp/hipdlp/scaling.cc
-    pdlp/hipdlp/step.cc
     presolve/HighsPostsolveStack.cpp
     presolve/HighsSymmetry.cpp
     presolve/HPresolve.cpp
@@ -468,7 +467,6 @@ set(highs_headers
     pdlp/hipdlp/restart.hpp
     pdlp/hipdlp/scaling.hpp
     pdlp/hipdlp/solver_results.hpp
-    pdlp/hipdlp/step.hpp
     presolve/HighsPostsolveStack.h
     presolve/HighsSymmetry.h
     presolve/HPresolve.h

highs/meson.build

@@ -259,7 +259,6 @@ _srcs = [
     'pdlp/hipdlp/pdhg.cc',
     'pdlp/hipdlp/restart.cc',
     'pdlp/hipdlp/scaling.cc',
-    'pdlp/hipdlp/step.cc',
     'presolve/HPresolve.cpp',
     'presolve/HPresolveAnalysis.cpp',
     'presolve/HighsPostsolveStack.cpp',

highs/pdlp/HiPdlpWrapper.cpp

@@ -56,7 +56,11 @@ HighsStatus solveLpHiPdlp(const HighsOptions& options, HighsTimer& timer,
   std::vector<double> x, y;
   x.resize(pdlp.getnCol(),0.0);
   y.resize(pdlp.getnRow(), 0.0);
+  auto solve_start = std::chrono::high_resolution_clock::now();
   pdlp.solve(x, y);
+  auto solve_end = std::chrono::high_resolution_clock::now();
+  pdlp.timings_.total_time = std::chrono::duration<double>(solve_end - solve_start).count();
+  pdlp.timings_.print("HiPdlp :");
 
   // 5. Unscale with HiPdlp
   pdlp.unscaleSolution(x, y);

highs/pdlp/cupdlp/cupdlp_solver.c

@@ -1003,24 +1003,23 @@ cupdlp_retcode PDHG_Solve(const cupdlp_int* has_variables, CUPDLPwork *pdhg) {
       }
 
       if (PDHG_Check_Termination_Average(pdhg, termination_print)) {
-	// cupdlp_printf("Optimal average solution.\n");
-	
-    cupdlp_int iter = pdhg->timers->nIter;
-    CUPDLPvec *x = iterates->x[iter % 2];
-    CUPDLPvec *y = iterates->y[iter % 2];
-    CUPDLPvec *ax = iterates->ax[iter % 2];
-    CUPDLPvec *aty = iterates->aty[iter % 2];
-
-    CUPDLP_COPY_VEC(x->data, iterates->xAverage->data, cupdlp_float, problem->nCols);
-    CUPDLP_COPY_VEC(y->data, iterates->yAverage->data, cupdlp_float, problem->nRows);
-    CUPDLP_COPY_VEC(ax->data, iterates->axAverage->data, cupdlp_float, problem->nRows);
-    CUPDLP_COPY_VEC(aty->data, iterates->atyAverage->data, cupdlp_float, problem->nCols);
-    CUPDLP_COPY_VEC(resobj->dSlackPos, resobj->dSlackPosAverage, cupdlp_float, problem->nCols);
-    CUPDLP_COPY_VEC(resobj->dSlackNeg, resobj->dSlackNegAverage, cupdlp_float, problem->nCols);
-
-	resobj->termIterate = AVERAGE_ITERATE;
-	resobj->termCode = OPTIMAL;
-	break;
+      // cupdlp_printf("Optimal average solution.\n");
+        cupdlp_int iter = pdhg->timers->nIter;
+        CUPDLPvec *x = iterates->x[iter % 2];
+        CUPDLPvec *y = iterates->y[iter % 2];
+        CUPDLPvec *ax = iterates->ax[iter % 2];
+        CUPDLPvec *aty = iterates->aty[iter % 2];
+
+        CUPDLP_COPY_VEC(x->data, iterates->xAverage->data, cupdlp_float, problem->nCols);
+        CUPDLP_COPY_VEC(y->data, iterates->yAverage->data, cupdlp_float, problem->nRows);
+        CUPDLP_COPY_VEC(ax->data, iterates->axAverage->data, cupdlp_float, problem->nRows);
+        CUPDLP_COPY_VEC(aty->data, iterates->atyAverage->data, cupdlp_float, problem->nCols);
+        CUPDLP_COPY_VEC(resobj->dSlackPos, resobj->dSlackPosAverage, cupdlp_float, problem->nCols);
+        CUPDLP_COPY_VEC(resobj->dSlackNeg, resobj->dSlackNegAverage, cupdlp_float, problem->nCols);
+
+        resobj->termIterate = AVERAGE_ITERATE;
+        resobj->termCode = OPTIMAL;
+        break;
       }
 
       if (PDHG_Check_Infeasibility(pdhg, 0) == INFEASIBLE_OR_UNBOUNDED) {
@@ -1061,8 +1060,7 @@ cupdlp_retcode PDHG_Solve(const cupdlp_int* has_variables, CUPDLPwork *pdhg) {
     double debug_pdlp_data_aty_norm = 0.0;
     cupdlp_twoNorm(pdhg, problem->nCols, aty->data, &debug_pdlp_data_aty_norm);
     pdhg->debug_pdlp_data_.aty_norm = debug_pdlp_data_aty_norm;
-
-
+    
     // CUPDLP_CALL(PDHG_Update_Iterate(pdhg));
     if (PDHG_Update_Iterate(pdhg) == RETCODE_FAILED) {
       // cupdlp_printf("Time limit reached.\n");

highs/pdlp/hipdlp/defs.hpp

@@ -162,4 +162,37 @@ namespace pdlp_iterate_ops {
 // Compute z_new = z_old -
 };
 
+struct DetailedTimings {
+  double total_time = 0.0;
+  double iterate_update_time = 0.0;
+  double matrix_multiply_time = 0.0;  // Ax and ATy
+  double convergence_check_time = 0.0;
+  double restart_check_time = 0.0;
+  double average_iterate_time = 0.0;
+  double projection_time = 0.0;
+  double step_size_adjustment_time = 0.0;
+  double other_time = 0.0;
+  
+  void print(const std::string& solver_name) const {
+    std::cout << "\n=== " << solver_name << " Detailed Timings ===" << std::endl;
+    std::cout << "Total time:              " << total_time << " s" << std::endl;
+    std::cout << "Iterate update:          " << iterate_update_time 
+              << " s (" << (iterate_update_time/total_time*100) << "%)" << std::endl;
+    std::cout << "  - Matrix multiply:     " << matrix_multiply_time 
+              << " s (" << (matrix_multiply_time/total_time*100) << "%)" << std::endl;
+    std::cout << "  - Projection:          " << projection_time 
+              << " s (" << (projection_time/total_time*100) << "%)" << std::endl;
+    std::cout << "  - Step size adjust:    " << step_size_adjustment_time 
+              << " s (" << (step_size_adjustment_time/total_time*100) << "%)" << std::endl;
+    std::cout << "Convergence check:       " << convergence_check_time 
+              << " s (" << (convergence_check_time/total_time*100) << "%)" << std::endl;
+    std::cout << "Restart check:           " << restart_check_time 
+              << " s (" << (restart_check_time/total_time*100) << "%)" << std::endl;
+    std::cout << "Average iterate comp:    " << average_iterate_time 
+              << " s (" << (average_iterate_time/total_time*100) << "%)" << std::endl;
+    std::cout << "Other:                   " << other_time 
+              << " s (" << (other_time/total_time*100) << "%)" << std::endl;
+  }
+};
+
 #endif