refactor: make to_optimization_problem a free function

cpp/include/cuopt/mathematical_optimization/cpu_optimization_problem.hpp

@@ -30,6 +30,7 @@ class mps_data_model_t;
 // Forward declarations
 template <typename i_t, typename f_t>
 class optimization_problem_t;
+
 template <typename i_t, typename f_t>
 class pdlp_solver_settings_t;
 template <typename i_t, typename f_t>
@@ -166,17 +167,6 @@ class cpu_optimization_problem_t : public optimization_problem_interface_t<i_t,
   std::vector<char> get_row_types_host() const override;
   std::vector<var_t> get_variable_types_host() const override;
 
-  /**
-   * @brief Convert this CPU optimization problem to an optimization_problem_t
-   *        by copying CPU data to GPU (requires GPU memory transfer).
-   *
-   * @param handle_ptr RAFT handle with CUDA resources for GPU memory allocation.
-   * @return unique_ptr to new optimization_problem_t with all data copied to GPU
-   * @throws std::runtime_error if handle_ptr is null
-   */
-  std::unique_ptr<optimization_problem_t<i_t, f_t>> to_optimization_problem(
-    raft::handle_t const* handle_ptr = nullptr) override;
-
   /**
    * @brief Write the optimization problem to an MPS file.
    * @param[in] mps_file_path Path to the output MPS file
@@ -207,6 +197,12 @@ class cpu_optimization_problem_t : public optimization_problem_interface_t<i_t,
   void copy_variable_types_to_host(var_t* output, i_t size) const override;
 
  private:
+  // Reads this class's host-side storage directly. Callers include optimization_problem.hpp,
+  // where it is declared; this friend declaration alone is not visible to ordinary lookup.
+  template <typename I, typename F>
+  friend std::unique_ptr<optimization_problem_t<I, F>> to_optimization_problem(
+    optimization_problem_interface_t<I, F>&, raft::handle_t const*);
+
   problem_category_t problem_category_ = problem_category_t::LP;
   bool maximize_{false};
   i_t n_vars_{0};

cpp/include/cuopt/mathematical_optimization/optimization_problem.hpp

@@ -352,13 +352,6 @@ class optimization_problem_t : public optimization_problem_interface_t<i_t, f_t>
   template <typename other_f_t>
   optimization_problem_t<i_t, other_f_t> convert_to_other_prec(rmm::cuda_stream_view stream) const;
 
-  /**
-   * @brief Returns nullptr since this is already a GPU problem.
-   * @return nullptr
-   */
-  std::unique_ptr<optimization_problem_t<i_t, f_t>> to_optimization_problem(
-    raft::handle_t const* handle_ptr = nullptr) override;
-
   // ============================================================================
   // C API support: Copy to host (polymorphic)
   // ============================================================================
@@ -427,5 +420,26 @@ class optimization_problem_t : public optimization_problem_interface_t<i_t, f_t>
   std::vector<std::string> row_names_{};
 };
 
+/**
+ * @brief Convert a problem to a GPU-backed optimization_problem_t.
+ *
+ * For optimization_problem_t (GPU): returns nullptr (already is one).
+ * For cpu_optimization_problem_t: creates a new GPU problem, copies data, returns it.
+ *
+ * Usage pattern:
+ *   auto temp = to_optimization_problem(problem, &handle);
+ *   optimization_problem_t& op = temp ? *temp : static_cast<optimization_problem_t&>(problem);
+ *
+ * A free function rather than a virtual member so that cpu_optimization_problem_t's vtable
+ * carries no GPU-defined entry; see optimization_problem_interface.hpp.
+ *
+ * @param problem     The problem to convert.
+ * @param handle_ptr  RAFT handle with CUDA resources. Required for CPU->GPU conversion.
+ * @return unique_ptr to a new GPU problem, or nullptr if it already is one.
+ */
+template <typename i_t, typename f_t>
+std::unique_ptr<optimization_problem_t<i_t, f_t>> to_optimization_problem(
+  optimization_problem_interface_t<i_t, f_t>& problem, raft::handle_t const* handle_ptr = nullptr);
+
 }  // namespace CUOPT_EXPORT mathematical_optimization
 }  // namespace cuopt

cpp/include/cuopt/mathematical_optimization/optimization_problem_interface.hpp

@@ -478,22 +478,13 @@ class optimization_problem_interface_t {
   // Conversion
   // ============================================================================
 
-  /**
-   * @brief Convert to a GPU-backed optimization_problem_t.
-   *
-   * For optimization_problem_t (GPU): returns nullptr (already is one).
-   * For cpu_optimization_problem_t: creates new GPU problem, copies data, returns owned pointer.
-   *
-   * Usage pattern:
-   *   auto temp = problem_interface->to_optimization_problem(&handle);
-   *   optimization_problem_t& op = temp ? *temp : static_cast<optimization_problem_t&>(*this);
-   *
-   * @param handle_ptr RAFT handle with CUDA resources for GPU memory allocation.
-   *                   Required for CPU->GPU conversion. Ignored for GPU problems.
-   * @return unique_ptr to new GPU problem, or nullptr if already a GPU problem
-   */
-  virtual std::unique_ptr<optimization_problem_t<i_t, f_t>> to_optimization_problem(
-    raft::handle_t const* handle_ptr = nullptr) = 0;
+  // NOTE: CPU -> GPU conversion is deliberately NOT a virtual member here.
+  //
+  // As a virtual, it occupied a slot in cpu_optimization_problem_t's vtable, and vtable
+  // relocations are resolved eagerly at load time. That made every library containing
+  // the vtable -- including the CUDA-free cuopt_client -- unable to load without
+  // libcuopt.so present. It is now the free function to_optimization_problem() declared
+  // in optimization_problem.hpp, which lives in libcuopt where the GPU types do.
 };
 
 }  // namespace cuopt::mathematical_optimization

cpp/src/grpc/server/grpc_worker.cpp

@@ -425,7 +425,7 @@ static SolveResult run_mip_solve(DeserializedJob& dj,
     }
 
     SERVER_LOG_INFO("[Worker] Converting CPU problem to GPU problem...");
-    auto gpu_problem = dj.problem.to_optimization_problem(&handle);
+    auto gpu_problem = to_optimization_problem(dj.problem, &handle);
 
     SERVER_LOG_INFO("[Worker] Calling solve_mip...");
     auto gpu_solution = cuopt::mathematical_optimization::solve_mip(*gpu_problem, dj.mip_settings);
@@ -486,7 +486,7 @@ static SolveResult run_lp_solve(DeserializedJob& dj,
     dj.lp_settings.log_to_console = config.log_to_console;
 
     SERVER_LOG_INFO("[Worker] Converting CPU problem to GPU problem...");
-    auto gpu_problem = dj.problem.to_optimization_problem(&handle);
+    auto gpu_problem = to_optimization_problem(dj.problem, &handle);
 
     SERVER_LOG_INFO("[Worker] Calling solve_lp...");
     auto gpu_solution = cuopt::mathematical_optimization::solve_lp(*gpu_problem, dj.lp_settings);

cpp/src/mip_heuristics/solve.cu

@@ -936,7 +936,7 @@ std::unique_ptr<mip_solution_interface_t<i_t, f_t>> solve_mip(
   raft::handle_t handle(stream);
 
   // Convert CPU problem to GPU problem
-  auto gpu_problem = cpu_problem.to_optimization_problem(&handle);
+  auto gpu_problem = to_optimization_problem(cpu_problem, &handle);
 
   // Synchronize before solving to ensure conversion is complete
   stream.synchronize();

cpp/src/pdlp/CMakeLists.txt

@@ -8,6 +8,7 @@ set(LP_CORE_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/solver_settings.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/optimization_problem.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/cpu_optimization_problem.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cpu_optimization_problem_to_gpu.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/backend_selection.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/utilities/problem_checking.cu
   ${CMAKE_CURRENT_SOURCE_DIR}/solve.cu

cpp/src/pdlp/cpu_optimization_problem.cpp

@@ -10,7 +10,6 @@
 #include <cuopt/mathematical_optimization/cpu_optimization_problem.hpp>
 #include <cuopt/mathematical_optimization/csr_matrix_utils.hpp>
 #include <cuopt/mathematical_optimization/io/mps_data_model.hpp>
-#include <cuopt/mathematical_optimization/optimization_problem.hpp>
 #include <cuopt/mathematical_optimization/optimization_problem_utils.hpp>
 #include <cuopt/mathematical_optimization/solve_remote.hpp>
 
@@ -634,100 +633,6 @@ std::vector<var_t> cpu_optimization_problem_t<i_t, f_t>::get_variable_types_host
   return variable_types_;
 }
 
-// ==============================================================================
-// Conversion to optimization_problem_t
-// ==============================================================================
-
-template <typename i_t, typename f_t>
-std::unique_ptr<optimization_problem_t<i_t, f_t>>
-cpu_optimization_problem_t<i_t, f_t>::to_optimization_problem(raft::handle_t const* handle_ptr)
-{
-  if (handle_ptr == nullptr) {
-    throw std::runtime_error(
-      "cpu_optimization_problem_t::to_optimization_problem(): "
-      "handle_ptr is null. A RAFT handle with CUDA resources is required to convert "
-      "a CPU-backed problem to a GPU-backed optimization_problem_t.");
-  }
-
-  auto gpu_problem = std::make_unique<optimization_problem_t<i_t, f_t>>(handle_ptr);
-
-  // Set scalar values
-  gpu_problem->set_maximize(maximize_);
-  gpu_problem->set_objective_scaling_factor(objective_scaling_factor_);
-  gpu_problem->set_objective_offset(objective_offset_);
-  gpu_problem->set_problem_category(problem_category_);
-
-  // Set string values
-  if (!objective_name_.empty()) gpu_problem->set_objective_name(objective_name_);
-  if (!problem_name_.empty()) gpu_problem->set_problem_name(problem_name_);
-  if (!var_names_.empty()) gpu_problem->set_variable_names(var_names_);
-  if (!row_names_.empty()) gpu_problem->set_row_names(row_names_);
-
-  // Set CSR constraint matrix (data will be copied to GPU by optimization_problem_t setters)
-  // Use A_offsets_ presence as the guard: a valid CSR can have zero non-zeros but still
-  // needs row offsets to define the number of constraints.
-  if (!A_offsets_.empty()) {
-    gpu_problem->set_csr_constraint_matrix(A_.data(),
-                                           A_.size(),
-                                           A_indices_.data(),
-                                           A_indices_.size(),
-                                           A_offsets_.data(),
-                                           A_offsets_.size());
-  }
-
-  // Set constraint bounds
-  if (!b_.empty()) { gpu_problem->set_constraint_bounds(b_.data(), b_.size()); }
-
-  // Set objective coefficients
-  if (!c_.empty()) { gpu_problem->set_objective_coefficients(c_.data(), c_.size()); }
-
-  // Set quadratic objective if present (GPU setter symmetrizes once: H = Q + Q^T)
-  if (!Q_values_.empty()) {
-    gpu_problem->set_quadratic_objective_matrix(Q_values_.data(),
-                                                Q_values_.size(),
-                                                Q_indices_.data(),
-                                                Q_indices_.size(),
-                                                Q_offsets_.data(),
-                                                Q_offsets_.size());
-  }
-
-  if (!quadratic_constraints_.empty()) {
-    gpu_problem->set_quadratic_constraints(
-      std::vector<typename optimization_problem_interface_t<i_t, f_t>::quadratic_constraint_t>(
-        quadratic_constraints_));
-  }
-
-  // Set variable bounds
-  if (!variable_lower_bounds_.empty()) {
-    gpu_problem->set_variable_lower_bounds(variable_lower_bounds_.data(),
-                                           variable_lower_bounds_.size());
-  }
-  if (!variable_upper_bounds_.empty()) {
-    gpu_problem->set_variable_upper_bounds(variable_upper_bounds_.data(),
-                                           variable_upper_bounds_.size());
-  }
-
-  // Set variable types
-  if (!variable_types_.empty()) {
-    gpu_problem->set_variable_types(variable_types_.data(), variable_types_.size());
-  }
-
-  // Set constraint bounds
-  if (!constraint_lower_bounds_.empty()) {
-    gpu_problem->set_constraint_lower_bounds(constraint_lower_bounds_.data(),
-                                             constraint_lower_bounds_.size());
-  }
-  if (!constraint_upper_bounds_.empty()) {
-    gpu_problem->set_constraint_upper_bounds(constraint_upper_bounds_.data(),
-                                             constraint_upper_bounds_.size());
-  }
-
-  // Set row types
-  if (!row_types_.empty()) { gpu_problem->set_row_types(row_types_.data(), row_types_.size()); }
-
-  return gpu_problem;
-}
-
 // ==============================================================================
 // File I/O
 // ==============================================================================