Extend the barrier solver for Second-Order Cone Programming (SOCP)

ci/test_cpp.sh

@@ -57,7 +57,7 @@ set +e
 export RAPIDS_TESTS_DIR
 
 rapids-logger "Run gtests"
-timeout 50m ./ci/run_ctests.sh || FAILED_STEPS+=("gtests (run_ctests.sh)")
+timeout 60m ./ci/run_ctests.sh || FAILED_STEPS+=("gtests (run_ctests.sh)")
 
 rapids-logger "Generate nightly test report"
 source "$(dirname "$(realpath "${BASH_SOURCE[0]}")")/utils/nightly_report_helper.sh"

ci/validate_wheel.sh

@@ -22,7 +22,7 @@ PYDISTCHECK_ARGS=(
 if [[ "${package_dir}" == "python/libcuopt" ]]; then
     if [[ "${RAPIDS_CUDA_MAJOR}" == "12" ]]; then
         PYDISTCHECK_ARGS+=(
-            --max-allowed-size-compressed '680Mi'
+            --max-allowed-size-compressed '690Mi'
         )
     else
         PYDISTCHECK_ARGS+=(

cpp/include/cuopt/linear_programming/cpu_optimization_problem.hpp

@@ -14,6 +14,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -130,16 +131,11 @@ class cpu_optimization_problem_t : public optimization_problem_interface_t<i_t,
   void set_quadratic_constraints(std::vector<quadratic_constraint_t> constraints) override;
   void add_quadratic_constraint(char constraint_row_type,
                                 f_t rhs_value,
-                                const f_t* quadratic_values,
-                                i_t size_quadratic_values,
-                                const i_t* quadratic_indices,
-                                i_t size_quadratic_indices,
-                                const i_t* quadratic_offsets,
-                                i_t size_quadratic_offsets,
-                                const f_t* linear_values,
-                                i_t size_linear_values,
-                                const i_t* linear_indices,
-                                i_t size_linear_indices) override;
+                                std::span<const i_t> row_index,
+                                std::span<const i_t> col_index,
+                                std::span<const f_t> coeff,
+                                std::span<const f_t> linear_values,
+                                std::span<const i_t> linear_indices) override;
   bool has_quadratic_constraints() const override;
   const std::vector<quadratic_constraint_t>& get_quadratic_constraints() const override;
 

cpp/include/cuopt/linear_programming/io/data_model_view.hpp

@@ -434,9 +434,9 @@ class data_model_view_t {
          std::vector<f_t>(qc.linear_values.begin(), qc.linear_values.end()),
          std::vector<i_t>(qc.linear_indices.begin(), qc.linear_indices.end()),
          static_cast<f_t>(qc.rhs_value),
-         std::vector<f_t>(qc.quadratic_values.begin(), qc.quadratic_values.end()),
-         std::vector<i_t>(qc.quadratic_indices.begin(), qc.quadratic_indices.end()),
-         std::vector<i_t>(qc.quadratic_offsets.begin(), qc.quadratic_offsets.end())});
+         std::vector<i_t>(qc.rows.begin(), qc.rows.end()),
+         std::vector<i_t>(qc.cols.begin(), qc.cols.end()),
+         std::vector<f_t>(qc.vals.begin(), qc.vals.end())});
     }
   }
 

cpp/include/cuopt/linear_programming/io/mps_data_model.hpp

@@ -239,7 +239,7 @@ class mps_data_model_t {
    * - row identity and type (from ROWS),
    * - sparse linear coefficients (from COLUMNS),
    * - RHS value (from RHS),
-   * - quadratic matrix Q in CSR (from QCMATRIX).
+   * - quadratic matrix Q in COO (SoA: row, col, value) from QCMATRIX — one triplet per nonzero.
    */
   struct quadratic_constraint_t {
     /** ROWS declaration index (among all constraint rows), not an index into the linear CSR. */
@@ -251,29 +251,31 @@ class mps_data_model_t {
     std::vector<f_t> linear_values{};
     std::vector<i_t> linear_indices{};
     f_t rhs_value{f_t(0)};
-    std::vector<f_t> quadratic_values{};
-    std::vector<i_t> quadratic_indices{};
-    std::vector<i_t> quadratic_offsets{};
+    /** Q nonzeros: parallel arrays, same length (COO / SoA). Sorted by (row, col) in append. */
+    std::vector<i_t> rows{};
+    std::vector<i_t> cols{};
+    std::vector<f_t> vals{};
   };
 
   /**
    * @brief Append one complete quadratic constraint (row + linear + rhs + quadratic Q).
    * @note All span inputs are host memory; the model copies this data.
    * @param linear_values, linear_indices Same nnz; can be empty for a purely quadratic row (rare).
-   * @param quadratic_values, quadratic_indices CSR nnz; may be empty if Q is empty.
-   * @param quadratic_offsets CSR row starts; must be non-empty.
-   * @param constraint_row_type MPS ROWS type; must be 'L'. 'G' and 'E' quadratic rows are not
-   *        supported.
+   * @param vals, rows, cols COO triplets for Q; same length; may all be empty if Q is empty.
+   *        Stored sorted by (row, col).
+   * @param constraint_row_type MPS ROWS type: 'L' (<=) or 'G' (>=). Stored as given; 'G' rows are
+   *        converted to '<=' form when building the SOCP for the barrier solver. Equality ('E') is
+   *        not supported.
    */
   void append_quadratic_constraint(i_t constraint_row_index,
                                    const std::string& constraint_row_name,
                                    char constraint_row_type,
                                    std::span<const f_t> linear_values,
                                    std::span<const i_t> linear_indices,
                                    f_t rhs_value,
-                                   std::span<const f_t> quadratic_values,
-                                   std::span<const i_t> quadratic_indices,
-                                   std::span<const i_t> quadratic_offsets);
+                                   std::span<const f_t> vals,
+                                   std::span<const i_t> rows,
+                                   std::span<const i_t> cols);
 
   const std::vector<quadratic_constraint_t>& get_quadratic_constraints() const;
 

cpp/include/cuopt/linear_programming/optimization_problem.hpp

@@ -16,6 +16,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -212,16 +213,11 @@ class optimization_problem_t : public optimization_problem_interface_t<i_t, f_t>
   void set_quadratic_constraints(std::vector<quadratic_constraint_t> constraints) override;
   void add_quadratic_constraint(char constraint_row_type,
                                 f_t rhs_value,
-                                const f_t* quadratic_values,
-                                i_t size_quadratic_values,
-                                const i_t* quadratic_indices,
-                                i_t size_quadratic_indices,
-                                const i_t* quadratic_offsets,
-                                i_t size_quadratic_offsets,
-                                const f_t* linear_values,
-                                i_t size_linear_values,
-                                const i_t* linear_indices,
-                                i_t size_linear_indices) override;
+                                std::span<const i_t> row_index,
+                                std::span<const i_t> col_index,
+                                std::span<const f_t> coeff,
+                                std::span<const f_t> linear_values,
+                                std::span<const i_t> linear_indices) override;
 
   /** @copydoc optimization_problem_interface_t::set_variable_lower_bounds */
   void set_variable_lower_bounds(const f_t* variable_lower_bounds, i_t size) override;

cpp/include/cuopt/linear_programming/optimization_problem_interface.hpp

@@ -15,6 +15,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -64,9 +65,10 @@ class optimization_problem_interface_t {
     std::vector<f_t> linear_values{};
     std::vector<i_t> linear_indices{};
     f_t rhs_value{f_t(0)};
-    std::vector<f_t> quadratic_values{};
-    std::vector<i_t> quadratic_indices{};
-    std::vector<i_t> quadratic_offsets{};
+    /** Q in COO: parallel arrays, same length. */
+    std::vector<i_t> rows{};
+    std::vector<i_t> cols{};
+    std::vector<f_t> vals{};
   };
 
   virtual ~optimization_problem_interface_t() = default;
@@ -79,22 +81,17 @@ class optimization_problem_interface_t {
   /**
    * @brief Append one quadratic constraint x^T Q x + d^T x {<=, >=} rhs.
    *
-   * Quadratic matrix Q is CSR (values, indices, offsets). Linear term d uses parallel
+   * Quadratic matrix Q is COO (row_index, col_index, coeff spans). Linear term d uses parallel
    * linear_values and linear_indices (empty allowed). constraint_row_index is assigned
    * automatically as n_linear_constraints + n_existing_quadratic_constraints.
    */
   virtual void add_quadratic_constraint(char constraint_row_type,
                                         f_t rhs_value,
-                                        const f_t* quadratic_values,
-                                        i_t size_quadratic_values,
-                                        const i_t* quadratic_indices,
-                                        i_t size_quadratic_indices,
-                                        const i_t* quadratic_offsets,
-                                        i_t size_quadratic_offsets,
-                                        const f_t* linear_values,
-                                        i_t size_linear_values,
-                                        const i_t* linear_indices,
-                                        i_t size_linear_indices) = 0;
+                                        std::span<const i_t> row_index,
+                                        std::span<const i_t> col_index,
+                                        std::span<const f_t> coeff,
+                                        std::span<const f_t> linear_values,
+                                        std::span<const i_t> linear_indices) = 0;
   template <typename qc_t,
             typename = std::enable_if_t<!std::is_same_v<qc_t, quadratic_constraint_t>>>
   void set_quadratic_constraints(const std::vector<qc_t>& constraints)
@@ -109,9 +106,9 @@ class optimization_problem_interface_t {
          std::vector<f_t>(qc.linear_values.begin(), qc.linear_values.end()),
          std::vector<i_t>(qc.linear_indices.begin(), qc.linear_indices.end()),
          static_cast<f_t>(qc.rhs_value),
-         std::vector<f_t>(qc.quadratic_values.begin(), qc.quadratic_values.end()),
-         std::vector<i_t>(qc.quadratic_indices.begin(), qc.quadratic_indices.end()),
-         std::vector<i_t>(qc.quadratic_offsets.begin(), qc.quadratic_offsets.end())});
+         std::vector<i_t>(qc.rows.begin(), qc.rows.end()),
+         std::vector<i_t>(qc.cols.begin(), qc.cols.end()),
+         std::vector<f_t>(qc.vals.begin(), qc.vals.end())});
     }
     set_quadratic_constraints(std::move(converted_constraints));
   }

cpp/include/cuopt/linear_programming/optimization_problem_utils.hpp

@@ -85,6 +85,10 @@ void populate_from_mps_data_model(optimization_problem_interface_t<i_t, f_t>* pr
                                          n_nonzeros,
                                          A_offsets.data(),
                                          n_constraints + 1);
+    } else {
+      // Set empty constraint matrix
+      std::vector<i_t> offsets(1, 0);
+      problem->set_csr_constraint_matrix(nullptr, 0, nullptr, 0, offsets.data(), 1);
     }
   }