Fix cudf breaking change for build_column which is used to create cudf series from buffer (NVIDIA#535)

Fix cudf breaking change from rapidsai/cudf#20233 for build_column which is used to create cudf series from buffer

Authors:
  - Ramakrishnap (https://github.com/rgsl888prabhu)

Approvers:
  - Trevor McKay (https://github.com/tmckayus)

URL: NVIDIA#535

Author: rgsl888prabhu

python/cuopt/cuopt/distance_engine/waypoint_matrix_wrapper.pyx

@@ -35,6 +35,8 @@ import cudf
 from cudf.core.buffer import as_buffer
 from cudf.core.column_accessor import ColumnAccessor
 
+from cuopt.utilities import col_from_buf
+
 
 cdef class WaypointMatrix:
 
@@ -107,20 +109,15 @@ cdef class WaypointMatrix:
         full_sequence_offset = as_buffer(full_sequence_offset)
         full_path = as_buffer(full_path)
 
-        route_df['sequence_offset'] = (
-            cudf.core.column.build_column(
-                full_sequence_offset,
-                dtype=np.dtype(np.int32)
-            )
+        route_df['sequence_offset'] = col_from_buf(
+            full_sequence_offset, np.int32
         )
         locations = route_df["location"].replace(
             to_replace=list(range(len(target_locations))),
             value=target_locations.tolist()
         )
         route_df['location'] = locations
-        waypoint_seq = cudf.core.column.build_column(
-            full_path, dtype=np.dtype(np.int32)
-        )
+        waypoint_seq = col_from_buf(full_path, np.int32)
 
         def create_way_point_types(routes, waypoint_seq):
 

python/cuopt/cuopt/linear_programming/solver/solver_wrapper.pyx

@@ -69,7 +69,7 @@ from cuopt.linear_programming.solver_settings.solver_settings import (
     PDLPSolverMode,
     SolverSettings,
 )
-from cuopt.utilities import InputValidationError
+from cuopt.utilities import InputValidationError, col_from_buf
 
 
 cdef extern from "cuopt/linear_programming/utilities/internals.hpp" namespace "cuopt::internals": # noqa
@@ -328,11 +328,9 @@ cdef create_solution(unique_ptr[solver_ret_t] sol_ret_ptr,
         num_nodes = sol_ret.mip_ret.nodes_
         num_simplex_iterations = sol_ret.mip_ret.simplex_iterations_
 
+        solution_buf = as_buffer(solution)
         solution = cudf.Series._from_column(
-            cudf.core.column.build_column(
-                as_buffer(solution),
-                dtype=np.dtype(np.float64)
-            )
+            col_from_buf(solution_buf, np.float64)
         ).to_numpy()
 
         return Solution(
@@ -361,23 +359,18 @@ cdef create_solution(unique_ptr[solver_ret_t] sol_ret_ptr,
         dual_solution = DeviceBuffer.c_from_unique_ptr(move(sol_ret.lp_ret.dual_solution_)) # noqa
         reduced_cost = DeviceBuffer.c_from_unique_ptr(move(sol_ret.lp_ret.reduced_cost_)) # noqa
 
+        primal_solution_buf = as_buffer(primal_solution)
+        dual_solution_buf = as_buffer(dual_solution)
+        reduced_cost_buf = as_buffer(reduced_cost)
+
         primal_solution = cudf.Series._from_column(
-            cudf.core.column.build_column(
-                as_buffer(primal_solution),
-                dtype=np.dtype(np.float64)
-            )
+            col_from_buf(primal_solution_buf, np.float64)
         ).to_numpy()
         dual_solution = cudf.Series._from_column(
-            cudf.core.column.build_column(
-                as_buffer(dual_solution),
-                dtype=np.dtype(np.float64)
-            )
+            col_from_buf(dual_solution_buf, np.float64)
         ).to_numpy()
         reduced_cost = cudf.Series._from_column(
-            cudf.core.column.build_column(
-                as_buffer(reduced_cost),
-                dtype=np.dtype(np.float64)
-            )
+            col_from_buf(reduced_cost_buf, np.float64)
         ).to_numpy()
 
         termination_status = sol_ret.lp_ret.termination_status_
@@ -430,58 +423,51 @@ cdef create_solution(unique_ptr[solver_ret_t] sol_ret_ptr,
             sum_solution_weight = sol_ret.lp_ret.sum_solution_weight_
             iterations_since_last_restart = sol_ret.lp_ret.iterations_since_last_restart_ # noqa
 
+            current_primal_solution_buf = as_buffer(current_primal_solution)
+            current_dual_solution_buf = as_buffer(current_dual_solution)
+            initial_primal_average_buf = as_buffer(initial_primal_average)
+            initial_dual_average_buf = as_buffer(initial_dual_average)
+            current_ATY_buf = as_buffer(current_ATY)
+            sum_primal_solutions_buf = as_buffer(sum_primal_solutions)
+            sum_dual_solutions_buf = as_buffer(sum_dual_solutions)
+            last_restart_duality_gap_primal_solution_buf = as_buffer(
+                last_restart_duality_gap_primal_solution
+            )
+            last_restart_duality_gap_dual_solution_buf = as_buffer(
+                last_restart_duality_gap_dual_solution
+            )
+
             current_primal_solution = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(current_primal_solution),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(current_primal_solution_buf, np.float64)
             ).to_numpy()
             current_dual_solution = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(current_dual_solution),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(current_dual_solution_buf, np.float64)
             ).to_numpy()
             initial_primal_average = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(initial_primal_average),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(initial_primal_average_buf, np.float64)
             ).to_numpy()
             initial_dual_average = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(initial_dual_average),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(initial_dual_average_buf, np.float64)
             ).to_numpy()
             current_ATY = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(current_ATY),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(current_ATY_buf, np.float64)
             ).to_numpy()
             sum_primal_solutions = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(sum_primal_solutions),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(sum_primal_solutions_buf, np.float64)
             ).to_numpy()
             sum_dual_solutions = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(sum_dual_solutions),
-                    dtype=np.dtype(np.float64)
-                )
+                col_from_buf(sum_dual_solutions_buf, np.float64)
             ).to_numpy()
             last_restart_duality_gap_primal_solution = cudf.Series._from_column( # noqa
-                cudf.core.column.build_column(
-                    as_buffer(last_restart_duality_gap_primal_solution),
-                    dtype=np.dtype(np.float64)
+                col_from_buf(
+                    last_restart_duality_gap_primal_solution_buf,
+                    np.float64
                 )
             ).to_numpy()
             last_restart_duality_gap_dual_solution = cudf.Series._from_column(
-                cudf.core.column.build_column(
-                    as_buffer(last_restart_duality_gap_dual_solution),
-                    dtype=np.dtype(np.float64)
+                col_from_buf(
+                    last_restart_duality_gap_dual_solution_buf,
+                    np.float64
                 )
             ).to_numpy()
 

python/cuopt/cuopt/routing/utils_wrapper.pyx

@@ -37,6 +37,8 @@ from cudf.core.buffer import as_buffer
 
 from libcpp.utility cimport move
 
+from cuopt.utilities import col_from_buf
+
 
 class DatasetDistribution(IntEnum):
     CLUSTERED = dataset_distribution_t.CLUSTERED
@@ -113,8 +115,8 @@ def generate_dataset(locations=100, asymmetric=True, min_demand=cudf.Series(),
     y_pos = DeviceBuffer.c_from_unique_ptr(move(g_ret.d_y_pos_))
     x_pos = as_buffer(x_pos)
     y_pos = as_buffer(y_pos)
-    coordinates['x'] = cudf.core.column.build_column(x_pos, dtype=np.float32)
-    coordinates['y'] = cudf.core.column.build_column(y_pos, dtype=np.float32)
+    coordinates['x'] = col_from_buf(x_pos, np.float32)
+    coordinates['y'] = col_from_buf(y_pos, np.float32)
 
     matrices_buf = as_buffer(
         DeviceBuffer.c_from_unique_ptr(move(g_ret.d_matrices_))
@@ -144,17 +146,13 @@ def generate_dataset(locations=100, asymmetric=True, min_demand=cudf.Series(),
     vehicle_latest = as_buffer(vehicle_latest)
     vehicle_drop_return_trips = as_buffer(vehicle_drop_return_trips)
     vehicle_skip_first_trips = as_buffer(vehicle_skip_first_trips)
-    vehicles["earliest_time"] = cudf.core.column.build_column(
-        vehicle_earliest, dtype=np.int32
-    )
-    vehicles["latest_time"] = cudf.core.column.build_column(
-        vehicle_latest, dtype=np.int32
-    )
-    vehicles["drop_return_trips"] = cudf.core.column.build_column(
-        vehicle_drop_return_trips, dtype=np.bool_
+    vehicles["earliest_time"] = col_from_buf(vehicle_earliest, np.int32)
+    vehicles["latest_time"] = col_from_buf(vehicle_latest, np.int32)
+    vehicles["drop_return_trips"] = col_from_buf(
+        vehicle_drop_return_trips, np.bool_
     )
-    vehicles["skip_first_trips"] = cudf.core.column.build_column(
-        vehicle_skip_first_trips, dtype=np.bool_
+    vehicles["skip_first_trips"] = col_from_buf(
+        vehicle_skip_first_trips, np.bool_
     )
 
     fleet_size = vehicles["earliest_time"].shape[0]
@@ -192,12 +190,8 @@ def generate_dataset(locations=100, asymmetric=True, min_demand=cudf.Series(),
     )
     latest_time = as_buffer(latest_time)
 
-    orders["earliest_time"] = cudf.core.column.build_column(
-        earliest_time, dtype=np.int32
-    )
-    orders["latest_time"] = cudf.core.column.build_column(
-        latest_time, dtype=np.int32
-    )
+    orders["earliest_time"] = col_from_buf(earliest_time, np.int32)
+    orders["latest_time"] = col_from_buf(latest_time, np.int32)
 
     demands_buf = as_buffer(
         DeviceBuffer.c_from_unique_ptr(move(g_ret.d_demands_))

python/cuopt/cuopt/routing/vehicle_routing_wrapper.pyx

@@ -59,6 +59,8 @@ from numba import cuda
 import cudf
 from cudf.core.buffer import as_buffer
 
+from cuopt.utilities import col_from_buf
+
 
 class ErrorStatus(IntEnum):
     Success = error_type_t.Success
@@ -809,29 +811,17 @@ def Solve(DataModel data_model, SolverSettings solver_settings):
     accepted = as_buffer(accepted)
 
     route_df = cudf.DataFrame()
-    route_df['route'] = cudf.core.column.build_column(
-        route, dtype=np.dtype(np.int32)
-    )
-    route_df['arrival_stamp'] = cudf.core.column.build_column(
-        arrival_stamp, dtype=np.dtype(np.float64)
-    )
-    route_df['truck_id'] = cudf.core.column.build_column(
-        truck_id, dtype=np.dtype(np.int32)
-    )
-    route_df['location'] = cudf.core.column.build_column(
-        route_locations, dtype=np.dtype(np.int32)
-    )
-    route_df['type'] = cudf.core.column.build_column(
-        node_types, dtype=np.dtype(np.int32)
-    )
+    route_df['route'] = col_from_buf(route, np.int32)
+    route_df['arrival_stamp'] = col_from_buf(arrival_stamp, np.float64)
+    route_df['truck_id'] = col_from_buf(truck_id, np.int32)
+    route_df['location'] = col_from_buf(route_locations, np.int32)
+    route_df['type'] = col_from_buf(node_types, np.int32)
 
     unserviced_nodes = cudf.Series._from_column(
-        cudf.core.column.build_column(
-            unserviced_nodes, dtype=np.dtype(np.int32)
-        )
+        col_from_buf(unserviced_nodes, np.int32)
     )
     accepted = cudf.Series._from_column(
-        cudf.core.column.build_column(accepted, dtype=np.dtype(np.int32))
+        col_from_buf(accepted, np.int32)
     )
 
     def get_type_from_int(type_in_int):

python/cuopt/cuopt/utilities/__init__.py

@@ -20,4 +20,4 @@
     catch_cuopt_exception,
 )
 from cuopt.utilities.type_casting import type_cast
-from cuopt.utilities.utils import check_solution
+from cuopt.utilities.utils import check_solution, col_from_buf

python/cuopt/cuopt/utilities/utils.py

@@ -15,13 +15,42 @@
 
 import numpy as np
 
+import cudf
+
 from cuopt.linear_programming.solver.solver_parameters import (
     CUOPT_ABSOLUTE_PRIMAL_TOLERANCE,
     CUOPT_MIP_INTEGRALITY_TOLERANCE,
     CUOPT_RELATIVE_PRIMAL_TOLERANCE,
 )
 
 
+def col_from_buf(buf, dtype):
+    """Helper function to create a cudf column from a buffer.
+
+    Parameters
+    ----------
+    buf : cudf.core.buffer.Buffer
+        The buffer containing the data
+    dtype : numpy.dtype or type
+        The data type for the column
+
+    Returns
+    -------
+    cudf.core.column.Column
+        A cudf column built from the buffer
+    """
+    dt = np.dtype(dtype)
+    return cudf.core.column.build_column(
+        buf,
+        dtype=dt,
+        size=buf.size // dt.itemsize,
+        mask=None,
+        offset=0,
+        null_count=0,
+        children=(),
+    )
+
+
 def validate_variable_bounds(data, settings, solution):
     integrality_tolerance = settings.get_parameter(
         CUOPT_MIP_INTEGRALITY_TOLERANCE