Add C api callbacks for getting and setting solutions

ci/run_cuopt_pytests.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 set -euo pipefail
@@ -9,4 +9,4 @@ set -euo pipefail
 # Support invoking run_cuopt_pytests.sh outside the script directory
 cd "$(dirname "$(realpath "${BASH_SOURCE[0]}")")"/../python/cuopt/cuopt/
 
-pytest --cache-clear "$@" tests
+pytest -s --cache-clear "$@" tests

ci/run_cuopt_server_pytests.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 set -euo pipefail
@@ -9,4 +9,4 @@ set -euo pipefail
 # Support invoking run_cuopt_server_pytests.sh outside the script directory
 cd "$(dirname "$(realpath "${BASH_SOURCE[0]}")")"/../python/cuopt_server/cuopt_server/
 
-pytest --cache-clear "$@" tests
+pytest -s --cache-clear "$@" tests

conda/recipes/libcuopt/recipe.yaml

@@ -36,7 +36,7 @@ cache:
         - AWS_SESSION_TOKEN
       env:
         # Enable assertions (-a flag) for PR builds, but not for nightly or release builds
-        BUILD_EXTRA_FLAGS: '${{ "-a" if build_type == "pull-request" else "" }}'
+        BUILD_EXTRA_FLAGS: '${{ "-a --host-lineinfo" if build_type == "pull-request" else "" }}'
         CMAKE_C_COMPILER_LAUNCHER: ${{ env.get("CMAKE_C_COMPILER_LAUNCHER") }}
         CMAKE_CUDA_COMPILER_LAUNCHER: ${{ env.get("CMAKE_CUDA_COMPILER_LAUNCHER") }}
         CMAKE_CXX_COMPILER_LAUNCHER: ${{ env.get("CMAKE_CXX_COMPILER_LAUNCHER") }}

cpp/include/cuopt/linear_programming/cuopt_c.h

@@ -695,6 +695,76 @@ cuopt_int_t cuOptGetFloatParameter(cuOptSolverSettings settings,
                                    const char* parameter_name,
                                    cuopt_float_t* parameter_value);
 
+/**
+ * @brief Type of callback for receiving incumbent MIP solutions with user context.
+ *
+ * @param[in] solution - Pointer to incumbent solution values.
+ * The allocated array for solution pointer must be at least the number of variables in the original
+ * problem.
+ * @param[in] objective_value - Pointer to incumbent objective value.
+ * @param[in] solution_bound - Pointer to current solution (dual/user) bound.
+ * @param[in] user_data - Pointer to user data.
+ * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host
+ * memory and are only valid during the callback invocation. Do not pass device/GPU pointers.
+ * Copy any data you need to keep after the callback returns.
+ */
+typedef void (*cuOptMIPGetSolutionCallback)(const cuopt_float_t* solution,
+                                            const cuopt_float_t* objective_value,
+                                            const cuopt_float_t* solution_bound,
+                                            void* user_data);
+
+/**
+ * @brief Type of callback for injecting MIP solutions with user context.
+ *
+ * @param[out] solution - Pointer to solution values to set.
+ * The allocated array for solution pointer must be at least the number of variables in the original
+ * problem.
+ * @param[out] objective_value - Pointer to objective value to set.
+ * @param[in] solution_bound - Pointer to current solution (dual/user) bound.
+ * @param[in] user_data - Pointer to user data.
+ * @note All pointer arguments (solution, objective_value, solution_bound, user_data) refer to host
+ * memory and are only valid during the callback invocation. Do not pass device/GPU pointers.
+ * Copy any data you need to keep after the callback returns.
+ */
+typedef void (*cuOptMIPSetSolutionCallback)(cuopt_float_t* solution,
+                                            cuopt_float_t* objective_value,
+                                            const cuopt_float_t* solution_bound,
+                                            void* user_data);
+
+/**
+ * @brief Register a callback to receive incumbent MIP solutions.
+ *
+ * @param[in] settings - The solver settings object.
+ * @param[in] callback - Callback function to receive incumbent solutions.
+ * @param[in] user_data - User-defined pointer passed through to the callback.
+ *  It will be forwarded to ``cuOptMIPGetSolutionCallback`` when invoked.
+ * @note The callback arguments refer to host memory and are only valid during the callback
+ * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback
+ * returns.
+ *
+ * @return A status code indicating success or failure.
+ */
+cuopt_int_t cuOptSetMIPGetSolutionCallback(cuOptSolverSettings settings,
+                                           cuOptMIPGetSolutionCallback callback,
+                                           void* user_data);
+
+/**
+ * @brief Register a callback to inject MIP solutions.
+ *
+ * @param[in] settings - The solver settings object.
+ * @param[in] callback - Callback function to inject solutions.
+ * @param[in] user_data - User-defined pointer passed through to the callback.
+ *  It will be forwarded to ``cuOptMIPSetSolutionCallback`` when invoked.
+ * @note Registering a set-solution callback disables presolve.
+ * @note The callback arguments refer to host memory and are only valid during the callback
+ * invocation. Do not pass device/GPU pointers. Copy any data you need to keep after the callback
+ * returns.
+ *
+ * @return A status code indicating success or failure.
+ */
+cuopt_int_t cuOptSetMIPSetSolutionCallback(cuOptSolverSettings settings,
+                                           cuOptMIPSetSolutionCallback callback,
+                                           void* user_data);
 /**
  * @brief Set the initial primal solution for an LP solve.
  *

cpp/include/cuopt/linear_programming/mip/solver_settings.hpp

@@ -37,8 +37,12 @@ class mip_solver_settings_t {
 
   /**
    * @brief Set the callback for the user solution
+   *
+   * @param[in] callback - Callback handler for user solutions.
+   * @param[in] user_data - Pointer to user-defined data forwarded to the callback.
    */
-  void set_mip_callback(internals::base_solution_callback_t* callback = nullptr);
+  void set_mip_callback(internals::base_solution_callback_t* callback = nullptr,
+                        void* user_data                               = nullptr);
 
   /**
    * @brief Add an primal solution.
@@ -91,7 +95,7 @@ class mip_solver_settings_t {
 
   /** Initial primal solutions */
   std::vector<std::shared_ptr<rmm::device_uvector<f_t>>> initial_solutions;
-  bool mip_scaling = true;
+  bool mip_scaling = false;
   bool presolve    = true;
   // this is for extracting info from different places of the solver during
   // benchmarks

cpp/include/cuopt/linear_programming/mip/solver_stats.hpp

@@ -1,17 +1,41 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
 #pragma once
+
+#include <atomic>
+#include <limits>
 namespace cuopt::linear_programming {
 
 template <typename i_t, typename f_t>
 struct solver_stats_t {
-  f_t total_solve_time       = 0.;
-  f_t presolve_time          = 0.;
-  f_t solution_bound         = std::numeric_limits<f_t>::min();
+  // Direction-neutral placeholder; solver_context initializes based on maximize/minimize.
+  solver_stats_t() : solution_bound(std::numeric_limits<f_t>::infinity()) {}
+
+  solver_stats_t(const solver_stats_t& other) { *this = other; }
+
+  solver_stats_t& operator=(const solver_stats_t& other)
+  {
+    if (this == &other) { return *this; }
+    total_solve_time = other.total_solve_time;
+    presolve_time    = other.presolve_time;
+    solution_bound.store(other.solution_bound.load(std::memory_order_relaxed),
+                         std::memory_order_relaxed);
+    num_nodes              = other.num_nodes;
+    num_simplex_iterations = other.num_simplex_iterations;
+    return *this;
+  }
+
+  f_t get_solution_bound() const { return solution_bound.load(std::memory_order_relaxed); }
+
+  void set_solution_bound(f_t value) { solution_bound.store(value, std::memory_order_relaxed); }
+
+  f_t total_solve_time = 0.;
+  f_t presolve_time    = 0.;
+  std::atomic<f_t> solution_bound;
   i_t num_nodes              = 0;
   i_t num_simplex_iterations = 0;
 };

cpp/include/cuopt/linear_programming/solver_settings.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -81,7 +81,8 @@ class solver_settings_t {
   void add_initial_mip_solution(const f_t* initial_solution,
                                 i_t size,
                                 rmm::cuda_stream_view stream = rmm::cuda_stream_default);
-  void set_mip_callback(internals::base_solution_callback_t* callback = nullptr);
+  void set_mip_callback(internals::base_solution_callback_t* callback = nullptr,
+                        void* user_data                               = nullptr);
 
   const pdlp_warm_start_data_view_t<i_t, f_t>& get_pdlp_warm_start_data_view() const noexcept;
   const std::vector<internals::base_solution_callback_t*> get_mip_callbacks() const;

cpp/include/cuopt/linear_programming/utilities/callbacks_implems.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -17,17 +17,6 @@ namespace internals {
 
 class default_get_solution_callback_t : public get_solution_callback_t {
  public:
-  PyObject* get_numba_matrix(void* data, std::size_t size)
-  {
-    PyObject* pycl = (PyObject*)this->pyCallbackClass;
-
-    if (isFloat) {
-      return PyObject_CallMethod(pycl, "get_numba_matrix", "(lls)", data, size, "float32");
-    } else {
-      return PyObject_CallMethod(pycl, "get_numba_matrix", "(lls)", data, size, "float64");
-    }
-  }
-
   PyObject* get_numpy_array(void* data, std::size_t size)
   {
     PyObject* pycl = (PyObject*)this->pyCallbackClass;
@@ -38,33 +27,33 @@ class default_get_solution_callback_t : public get_solution_callback_t {
     }
   }
 
-  void get_solution(void* data, void* objective_value) override
+  void get_solution(void* data,
+                    void* objective_value,
+                    void* solution_bound,
+                    void* user_data) override
   {
-    PyObject* numba_matrix = get_numba_matrix(data, n_variables);
-    PyObject* numpy_array  = get_numba_matrix(objective_value, 1);
-    PyObject* res =
-      PyObject_CallMethod(this->pyCallbackClass, "get_solution", "(OO)", numba_matrix, numpy_array);
-    Py_DECREF(numba_matrix);
+    PyObject* numpy_matrix = get_numpy_array(data, n_variables);
+    PyObject* numpy_array  = get_numpy_array(objective_value, 1);
+    PyObject* numpy_bound  = get_numpy_array(solution_bound, 1);
+    PyObject* py_user_data = user_data == nullptr ? Py_None : static_cast<PyObject*>(user_data);
+    PyObject* res          = PyObject_CallMethod(this->pyCallbackClass,
+                                        "get_solution",
+                                        "(OOOO)",
+                                        numpy_matrix,
+                                        numpy_array,
+                                        numpy_bound,
+                                        py_user_data);
+    Py_DECREF(numpy_matrix);
     Py_DECREF(numpy_array);
-    Py_DECREF(res);
+    Py_DECREF(numpy_bound);
+    if (res != nullptr) { Py_DECREF(res); }
   }
 
   PyObject* pyCallbackClass;
 };
 
 class default_set_solution_callback_t : public set_solution_callback_t {
  public:
-  PyObject* get_numba_matrix(void* data, std::size_t size)
-  {
-    PyObject* pycl = (PyObject*)this->pyCallbackClass;
-
-    if (isFloat) {
-      return PyObject_CallMethod(pycl, "get_numba_matrix", "(lls)", data, size, "float32");
-    } else {
-      return PyObject_CallMethod(pycl, "get_numba_matrix", "(lls)", data, size, "float64");
-    }
-  }
-
   PyObject* get_numpy_array(void* data, std::size_t size)
   {
     PyObject* pycl = (PyObject*)this->pyCallbackClass;
@@ -75,15 +64,26 @@ class default_set_solution_callback_t : public set_solution_callback_t {
     }
   }
 
-  void set_solution(void* data, void* objective_value) override
+  void set_solution(void* data,
+                    void* objective_value,
+                    void* solution_bound,
+                    void* user_data) override
   {
-    PyObject* numba_matrix = get_numba_matrix(data, n_variables);
-    PyObject* numpy_array  = get_numba_matrix(objective_value, 1);
-    PyObject* res =
-      PyObject_CallMethod(this->pyCallbackClass, "set_solution", "(OO)", numba_matrix, numpy_array);
-    Py_DECREF(numba_matrix);
+    PyObject* numpy_matrix = get_numpy_array(data, n_variables);
+    PyObject* numpy_array  = get_numpy_array(objective_value, 1);
+    PyObject* numpy_bound  = get_numpy_array(solution_bound, 1);
+    PyObject* py_user_data = user_data == nullptr ? Py_None : static_cast<PyObject*>(user_data);
+    PyObject* res          = PyObject_CallMethod(this->pyCallbackClass,
+                                        "set_solution",
+                                        "(OOOO)",
+                                        numpy_matrix,
+                                        numpy_array,
+                                        numpy_bound,
+                                        py_user_data);
+    Py_DECREF(numpy_matrix);
     Py_DECREF(numpy_array);
-    Py_DECREF(res);
+    Py_DECREF(numpy_bound);
+    if (res != nullptr) { Py_DECREF(res); }
   }
 
   PyObject* pyCallbackClass;

cpp/include/cuopt/linear_programming/utilities/internals.hpp

@@ -31,16 +31,23 @@ class base_solution_callback_t : public Callback {
     this->n_variables = n_variables_;
   }
 
+  void set_user_data(void* input_user_data) { user_data = input_user_data; }
+  void* get_user_data() const { return user_data; }
+
   virtual base_solution_callback_type get_type() const = 0;
 
  protected:
   bool isFloat       = true;
   size_t n_variables = 0;
+  void* user_data    = nullptr;
 };
 
 class get_solution_callback_t : public base_solution_callback_t {
  public:
-  virtual void get_solution(void* data, void* objective_value) = 0;
+  virtual void get_solution(void* data,
+                            void* objective_value,
+                            void* solution_bound,
+                            void* user_data) = 0;
   base_solution_callback_type get_type() const override
   {
     return base_solution_callback_type::GET_SOLUTION;
@@ -49,7 +56,10 @@ class get_solution_callback_t : public base_solution_callback_t {
 
 class set_solution_callback_t : public base_solution_callback_t {
  public:
-  virtual void set_solution(void* data, void* objective_value) = 0;
+  virtual void set_solution(void* data,
+                            void* objective_value,
+                            void* solution_bound,
+                            void* user_data) = 0;
   base_solution_callback_type get_type() const override
   {
     return base_solution_callback_type::SET_SOLUTION;

cpp/src/dual_simplex/branch_and_bound.cpp

@@ -282,6 +282,7 @@ void branch_and_bound_t<i_t, f_t>::report_heuristic(f_t obj)
 template <typename i_t, typename f_t>
 void branch_and_bound_t<i_t, f_t>::report(char symbol, f_t obj, f_t lower_bound, i_t node_depth)
 {
+  update_user_bound(lower_bound);
   i_t nodes_explored   = exploration_stats_.nodes_explored;
   i_t nodes_unexplored = exploration_stats_.nodes_unexplored;
   f_t user_obj         = compute_user_objective(original_lp_, obj);
@@ -300,6 +301,14 @@ void branch_and_bound_t<i_t, f_t>::report(char symbol, f_t obj, f_t lower_bound,
                        toc(exploration_stats_.start_time));
 }
 
+template <typename i_t, typename f_t>
+void branch_and_bound_t<i_t, f_t>::update_user_bound(f_t lower_bound)
+{
+  if (user_bound_callback_ == nullptr) { return; }
+  f_t user_lower = compute_user_objective(original_lp_, lower_bound);
+  user_bound_callback_(user_lower);
+}
+
 template <typename i_t, typename f_t>
 void branch_and_bound_t<i_t, f_t>::set_new_solution(const std::vector<f_t>& solution)
 {
@@ -335,9 +344,10 @@ void branch_and_bound_t<i_t, f_t>::set_new_solution(const std::vector<f_t>& solu
           num_fractional);
       }
     }
+  } else {
+    settings_.log.debug("Solution objective not better than current upper_bound_. Not accepted.\n");
   }
   mutex_upper_.unlock();
-
   if (is_feasible) { report_heuristic(obj); }
   if (attempt_repair) {
     mutex_repair_.lock();