Implement batch solve api

Author: hlinsen

cpp/include/cuopt/routing/cython/cython.hpp

@@ -16,6 +16,8 @@
 #include <raft/core/handle.hpp>
 
 #include <memory>
+#include <utility>
+#include <vector>
 
 namespace cuopt {
 namespace cython {
@@ -82,6 +84,10 @@ struct dataset_ret_t {
 std::unique_ptr<vehicle_routing_ret_t> call_solve(routing::data_model_view_t<int, float>*,
                                                   routing::solver_settings_t<int, float>*);
 
+// Wrapper for batch solve to expose the API to cython.
+std::pair<std::vector<std::unique_ptr<vehicle_routing_ret_t>>, double> call_batch_solve(
+  std::vector<routing::data_model_view_t<int, float>*>, routing::solver_settings_t<int, float>*);
+
 // Wrapper for dataset to expose the API to cython.
 std::unique_ptr<dataset_ret_t> call_generate_dataset(
   raft::handle_t const& handle, routing::generator::dataset_params_t<int, float> const& params);

cpp/src/routing/utilities/cython.cu

@@ -7,10 +7,14 @@
 
 #include <cuopt/routing/cython/cython.hpp>
 #include <cuopt/routing/solve.hpp>
+#include <raft/common/nvtx.hpp>
 #include <raft/core/handle.hpp>
 #include <rmm/device_buffer.hpp>
 #include <routing/generator/generator.hpp>
 
+#include <omp.h>
+#include <chrono>
+
 namespace cuopt {
 namespace cython {
 
@@ -86,6 +90,54 @@ std::unique_ptr<vehicle_routing_ret_t> call_solve(
   return std::make_unique<vehicle_routing_ret_t>(std::move(vr_ret));
 }
 
+/**
+ * @brief Wrapper for batch vehicle_routing to expose the API to cython
+ *
+ * @param data_models Vector of data model pointers
+ * @param settings  Composable solver settings object
+ * @return std::pair<std::vector<std::unique_ptr<vehicle_routing_ret_t>>, double>
+ */
+std::pair<std::vector<std::unique_ptr<vehicle_routing_ret_t>>, double> call_batch_solve(
+  std::vector<routing::data_model_view_t<int, float>*> data_models,
+  routing::solver_settings_t<int, float>* settings)
+{
+  raft::common::nvtx::range fun_scope("Call batch solve routing");
+
+  const std::size_t size = data_models.size();
+  std::vector<std::unique_ptr<vehicle_routing_ret_t>> list(size);
+
+  auto start_solver = std::chrono::high_resolution_clock::now();
+
+  // Use OpenMP for parallel execution
+  const int max_thread = std::min(static_cast<int>(size), omp_get_max_threads());
+
+#pragma omp parallel for num_threads(max_thread)
+  for (std::size_t i = 0; i < size; ++i) {
+    auto routing_solution = cuopt::routing::solve(*data_models[i], *settings);
+    vehicle_routing_ret_t vr_ret{
+      routing_solution.get_vehicle_count(),
+      routing_solution.get_total_objective(),
+      routing_solution.get_objectives(),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_route().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_order_locations().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_arrival_stamp().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_truck_id().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_node_types().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_unserviced_nodes().release()),
+      std::make_unique<rmm::device_buffer>(routing_solution.get_accepted().release()),
+      routing_solution.get_status(),
+      routing_solution.get_status_string(),
+      routing_solution.get_error_status().get_error_type(),
+      routing_solution.get_error_status().what()};
+    list[i] = std::make_unique<vehicle_routing_ret_t>(std::move(vr_ret));
+  }
+
+  auto end      = std::chrono::high_resolution_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start_solver);
+
+  return {std::move(list), duration.count() / 1000.0};
+}
+
 /**
  * @brief Wrapper for dataset_t to expose the API to cython.
  * @param solver Composable solver object

python/cuopt/cuopt/routing/vehicle_routing.pxd

@@ -8,7 +8,9 @@
 # cython: language_level = 3
 
 from libcpp cimport bool
+from libcpp.pair cimport pair
 from libcpp.string cimport string
+from libcpp.vector cimport vector
 
 from pylibraft.common.handle cimport *
 
@@ -133,3 +135,8 @@ cdef extern from "cuopt/routing/cython/cython.hpp" namespace "cuopt::cython": #
         data_model_view_t[int, float]* data_model,
         solver_settings_t[int, float]* solver_settings
     ) except +
+
+    cdef pair[vector[unique_ptr[vehicle_routing_ret_t]], double] call_batch_solve(
+        vector[data_model_view_t[int, float] *] data_models,
+        solver_settings_t[int, float]* solver_settings,
+    ) except +

python/cuopt/cuopt/routing/vehicle_routing_wrapper.pyx

@@ -11,6 +11,7 @@ from pylibraft.common.handle cimport *
 
 from cuopt.routing.structure.routing_utilities cimport *
 from cuopt.routing.vehicle_routing cimport (
+    call_batch_solve,
     call_solve,
     data_model_view_t,
     node_type_t,
@@ -32,8 +33,10 @@ from libc.stdlib cimport free, malloc
 from libc.string cimport memcpy, strcpy, strlen
 from libcpp cimport bool
 from libcpp.memory cimport unique_ptr
+from libcpp.pair cimport pair
 from libcpp.string cimport string
 from libcpp.utility cimport move
+from libcpp.vector cimport vector
 
 from rmm.pylibrmm.device_buffer cimport DeviceBuffer
 
@@ -834,3 +837,129 @@ def Solve(DataModel data_model, SolverSettings solver_settings):
         error_message,
         unserviced_nodes
     )
+
+
+cdef create_assignment_from_vr_ret(vehicle_routing_ret_t& vr_ret):
+    """Helper function to create an Assignment from a vehicle_routing_ret_t"""
+    vehicle_count = vr_ret.vehicle_count_
+    total_objective_value = vr_ret.total_objective_value_
+
+    objective_values = {}
+    for k in vr_ret.objective_values_:
+        obj = Objective(int(k.first))
+        objective_values[obj] = k.second
+
+    status = vr_ret.status_
+    cdef char* c_sol_string = c_get_string(vr_ret.solution_string_)
+    try:
+        solver_status_string = \
+            c_sol_string[:vr_ret.solution_string_.length()].decode('UTF-8')
+    finally:
+        free(c_sol_string)
+
+    route = DeviceBuffer.c_from_unique_ptr(move(vr_ret.d_route_))
+    route_locations = DeviceBuffer.c_from_unique_ptr(
+        move(vr_ret.d_route_locations_)
+    )
+    arrival_stamp = DeviceBuffer.c_from_unique_ptr(
+        move(vr_ret.d_arrival_stamp_)
+    )
+    truck_id = DeviceBuffer.c_from_unique_ptr(move(vr_ret.d_truck_id_))
+    node_types = DeviceBuffer.c_from_unique_ptr(move(vr_ret.d_node_types_))
+    unserviced_nodes_buf = \
+        DeviceBuffer.c_from_unique_ptr(move(vr_ret.d_unserviced_nodes_))
+    accepted_buf = \
+        DeviceBuffer.c_from_unique_ptr(move(vr_ret.d_accepted_))
+
+    route_df = cudf.DataFrame()
+    route_df['route'] = series_from_buf(route, pa.int32())
+    route_df['arrival_stamp'] = series_from_buf(arrival_stamp, pa.float64())
+    route_df['truck_id'] = series_from_buf(truck_id, pa.int32())
+    route_df['location'] = series_from_buf(route_locations, pa.int32())
+    route_df['type'] = series_from_buf(node_types, pa.int32())
+
+    unserviced_nodes = cudf.Series._from_column(
+        series_from_buf(unserviced_nodes_buf, pa.int32())
+    )
+    accepted = cudf.Series._from_column(
+        series_from_buf(accepted_buf, pa.int32())
+    )
+
+    def get_type_from_int(type_in_int):
+        if type_in_int == int(NodeType.DEPOT):
+            return "Depot"
+        elif type_in_int == int(NodeType.PICKUP):
+            return "Pickup"
+        elif type_in_int == int(NodeType.DELIVERY):
+            return "Delivery"
+        elif type_in_int == int(NodeType.BREAK):
+            return "Break"
+
+    node_types_string = [
+        get_type_from_int(type_in_int)
+        for type_in_int in route_df['type'].to_pandas()]
+    route_df['type'] = node_types_string
+    error_status = vr_ret.error_status_
+    error_message = vr_ret.error_message_
+
+    return Assignment(
+        vehicle_count,
+        total_objective_value,
+        objective_values,
+        route_df,
+        accepted,
+        <solution_status_t> status,
+        solver_status_string,
+        <error_type_t> error_status,
+        error_message,
+        unserviced_nodes
+    )
+
+
+def BatchSolve(py_data_model_list, SolverSettings solver_settings):
+    """
+    Solve multiple routing problems in batch mode using parallel execution.
+
+    Parameters
+    ----------
+    py_data_model_list : list of DataModel
+        List of data model objects representing routing problems to solve.
+    solver_settings : SolverSettings
+        Solver settings to use for all problems.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - list of Assignment: Solutions for each routing problem
+        - float: Total solve time in seconds
+    """
+    cdef solver_settings_t[int, float]* c_solver_settings = (
+        solver_settings.c_solver_settings.get()
+    )
+
+    cdef vector[data_model_view_t[int, float] *] data_model_views
+
+    for data_model_obj in py_data_model_list:
+        data_model_views.push_back(
+            (<DataModel>data_model_obj).c_data_model_view.get()
+        )
+
+    cdef pair[
+        vector[unique_ptr[vehicle_routing_ret_t]],
+        double] batch_solve_result = (
+        move(call_batch_solve(data_model_views, c_solver_settings))
+    )
+
+    cdef vector[unique_ptr[vehicle_routing_ret_t]] c_solutions = (
+        move(batch_solve_result.first)
+    )
+    cdef double solve_time = batch_solve_result.second
+
+    solutions = []
+    for i in range(c_solutions.size()):
+        solutions.append(
+            create_assignment_from_vr_ret(c_solutions[i].get()[0])
+        )
+
+    return solutions, solve_time