vectorize projection

Author: Yanyu000

check/TestPdlp.cpp

@@ -336,7 +336,7 @@ TEST_CASE("pdlp-restart-add-row", "[pdlp]") {
 
 TEST_CASE("hi-pdlp", "[pdlp]") {
   std::string model =
-      "adlittle";  //"adlittle";//"afiro";// shell// stair //25fv47 //fit2p
+      "25fv47";  //"adlittle";//"afiro";// shell// stair //25fv47 //fit2p
   std::string model_file =
       std::string(HIGHS_DIR) + "/check/instances/" + model + ".mps";
   Highs h;
@@ -346,20 +346,19 @@ TEST_CASE("hi-pdlp", "[pdlp]") {
   h.setOptionValue("kkt_tolerance", kkt_tolerance);
   h.setOptionValue("presolve", "off");
 
-  HighsInt pdlp_features_off =
+  HighsInt pdlp_features_off = 0 
       // kPdlpScalingOff +
       // kPdlpRestartOff
-      kPdlpAdaptiveStepSizeOff;
+      //+ 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", 1);
-  h.setOptionValue("pdlp_restart_strategy", 2);
-  h.setOptionValue("pdlp_iteration_limit", 3520);
+  //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();

highs/pdlp/hipdlp/linalg.cc

@@ -22,14 +22,7 @@ double project_non_negative(double x) { return std::max(0.0, x); }
 
 void project_bounds(const HighsLp& lp, std::vector<double>& x) {
   for (HighsInt i = 0; i < lp.num_col_; ++i) {
-    // Project to upper bound
-    if (x[i] > lp.col_upper_[i]) {
-      x[i] = lp.col_upper_[i];
-    }
-    // Project to lower bound
-    if (x[i] < lp.col_lower_[i]) {
-      x[i] = lp.col_lower_[i];
-    }
+    x[i] = std::max(lp.col_lower_[i], std::min(x[i], lp.col_upper_[i]));
   }
 }
 

highs/pdlp/hipdlp/pdhg.cc

@@ -635,8 +635,12 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
 
         restart_scheme_.last_restart_iter_ = iter;
         // Recompute Ax and ATy for the restarted iterates
+        hipdlpTimerStart(kHipdlpClockMatrixMultiply);
         linalg::Ax(lp, x_current_, Ax_cache_);
+        hipdlpTimerStop(kHipdlpClockMatrixMultiply);
+        hipdlpTimerStart(kHipdlpClockMatrixTransposeMultiply);
         linalg::ATy(lp, y_current_, ATy_cache_);
+        hipdlpTimerStop(kHipdlpClockMatrixTransposeMultiply);
 
         restart_scheme_.SetLastRestartIter(iter);
       }
@@ -679,9 +683,12 @@ void PDLPSolver::solve(std::vector<double>& x, std::vector<double>& y) {
 
     // Compute ATy for the new iterate
     Ax_cache_ = Ax_next_;
+    /*
     hipdlpTimerStart(kHipdlpClockMatrixTransposeMultiply);
     linalg::ATy(lp, y_next_, ATy_cache_);
     hipdlpTimerStop(kHipdlpClockMatrixTransposeMultiply);
+    */
+    ATy_cache_ = ATy_next_;
 
     hipdlpTimerStop(kHipdlpClockIterateUpdate);
 
@@ -1400,6 +1407,10 @@ void PDLPSolver::updateIteratesFixed() {
   hipdlpTimerStart(kHipdlpClockProjectY);
   y_next_ = updateY(y_current_, Ax_cache_, Ax_next_, stepsize_.dual_step);
   hipdlpTimerStop(kHipdlpClockProjectY);
+
+  hipdlpTimerStart(kHipdlpClockMatrixTransposeMultiply);
+  linalg::ATy(lp_, y_next_, ATy_next_);
+  hipdlpTimerStop(kHipdlpClockMatrixTransposeMultiply);
 }
 
 void PDLPSolver::updateIteratesAdaptive() {