Simple diving for Branch-and-Bound

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -17,14 +17,14 @@
 #include "initial_solution_reader.hpp"
 #include "mip_test_instances.hpp"
 
+#include <cstdio>
 #include <cuopt/linear_programming/mip/solver_settings.hpp>
 #include <cuopt/linear_programming/mip/solver_solution.hpp>
 #include <cuopt/linear_programming/optimization_problem.hpp>
 #include <cuopt/linear_programming/solve.hpp>
 #include <cuopt/logger.hpp>
 #include <mps_parser/parser.hpp>
 
-#include <omp.h>
 #include <raft/core/handle.hpp>
 
 #include <rmm/mr/device/cuda_async_memory_resource.hpp>
@@ -151,7 +151,8 @@ int run_single_file(std::string file_path,
                     int num_cpu_threads,
                     bool write_log_file,
                     bool log_to_console,
-                    double time_limit)
+                    double time_limit,
+                    cuopt::linear_programming::bnb_search_strategy_t search_strategy)
 {
   const raft::handle_t handle_{};
   cuopt::linear_programming::mip_solver_settings_t<int, double> settings;
@@ -168,6 +169,8 @@ int run_single_file(std::string file_path,
     }
   }
 
+  settings.bnb_search_strategy = search_strategy;
+
   constexpr bool input_mps_strict = false;
   cuopt::mps_parser::mps_data_model_t<int, double> mps_data_model;
   bool parsing_failed = false;
@@ -252,7 +255,8 @@ void run_single_file_mp(std::string file_path,
                         int num_cpu_threads,
                         bool write_log_file,
                         bool log_to_console,
-                        double time_limit)
+                        double time_limit,
+                        cuopt::linear_programming::bnb_search_strategy_t search_strategy)
 {
   std::cout << "running file " << file_path << " on gpu : " << device << std::endl;
   auto memory_resource = make_async();
@@ -266,7 +270,8 @@ void run_single_file_mp(std::string file_path,
                                   num_cpu_threads,
                                   write_log_file,
                                   log_to_console,
-                                  time_limit);
+                                  time_limit,
+                                  search_strategy);
   // this is a bad design to communicate the result but better than adding complexity of IPC or
   // pipes
   exit(sol_found);
@@ -340,6 +345,10 @@ int main(int argc, char* argv[])
     .scan<'g', double>()
     .default_value(std::numeric_limits<double>::max());
 
+  program.add_argument("--search-strategy")
+    .help("Search strategy used in B&B (bfs/bfs-diving/dfs)")
+    .default_value(std::string("bfs"));
+
   // Parse arguments
   try {
     program.parse_args(argc, argv);
@@ -362,10 +371,24 @@ int main(int argc, char* argv[])
   std::string result_file;
   int batch_num = -1;
 
-  bool heuristics_only = program.get<std::string>("--heuristics-only")[0] == 't';
-  int num_cpu_threads  = program.get<int>("--num-cpu-threads");
-  bool write_log_file  = program.get<std::string>("--write-log-file")[0] == 't';
-  bool log_to_console  = program.get<std::string>("--log-to-console")[0] == 't';
+  bool heuristics_only            = program.get<std::string>("--heuristics-only")[0] == 't';
+  int num_cpu_threads             = program.get<int>("--num-cpu-threads");
+  bool write_log_file             = program.get<std::string>("--write-log-file")[0] == 't';
+  bool log_to_console             = program.get<std::string>("--log-to-console")[0] == 't';
+  std::string search_strategy_cli = program.get<std::string>("--search-strategy");
+
+  cuopt::linear_programming::bnb_search_strategy_t search_strategy;
+  if (search_strategy_cli == "bfs") {
+    search_strategy = cuopt::linear_programming::bnb_search_strategy_t::BEST_FIRST;
+  } else if (search_strategy_cli == "bfs-diving") {
+    search_strategy =
+      cuopt::linear_programming::bnb_search_strategy_t::MULTITHREADED_BEST_FIRST_WITH_DIVING;
+  } else if (search_strategy_cli == "dfs") {
+    search_strategy = cuopt::linear_programming::bnb_search_strategy_t::DEPTH_FIRST;
+  } else {
+    std::cerr << "Invalid search strategy: " << search_strategy_cli << std::endl;
+    exit(1);
+  }
 
   if (program.is_used("--out-dir")) {
     out_dir     = program.get<std::string>("--out-dir");
@@ -450,7 +473,8 @@ int main(int argc, char* argv[])
                                num_cpu_threads,
                                write_log_file,
                                log_to_console,
-                               time_limit);
+                               time_limit,
+                               search_strategy);
           } else if (sys_pid < 0) {
             std::cerr << "Fork failed!" << std::endl;
             exit(1);
@@ -479,7 +503,8 @@ int main(int argc, char* argv[])
                     num_cpu_threads,
                     write_log_file,
                     log_to_console,
-                    time_limit);
+                    time_limit,
+                    search_strategy);
   }
 
   return 0;

cpp/include/cuopt/linear_programming/constants.h

@@ -62,6 +62,7 @@
 #define CUOPT_SOLUTION_FILE               "solution_file"
 #define CUOPT_NUM_CPU_THREADS             "num_cpu_threads"
 #define CUOPT_USER_PROBLEM_FILE           "user_problem_file"
+#define CUOPT_BNB_SEARCH_STRATEGY         "bnb_search_strategy"
 
 /* @brief LP/MIP termination status constants */
 #define CUOPT_TERIMINATION_STATUS_NO_TERMINATION   0
@@ -115,4 +116,9 @@
 #define CUOPT_OUT_OF_MEMORY    5
 #define CUOPT_RUNTIME_ERROR    6
 
+/* @brief BNB search strategy constants */
+#define CUOPT_BNB_SEARCH_STRATEGY_BEST_FIRST                           0
+#define CUOPT_BNB_SEARCH_STRATEGY_DEPTH_FIRST                          1
+#define CUOPT_BNB_SEARCH_STRATEGY_MULTITHREADED_BEST_FIRST_WITH_DIVING 2
+
 #endif  // CUOPT_CONSTANTS_H

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

@@ -35,6 +35,12 @@ struct benchmark_info_t {
   double objective_of_initial_population      = std::numeric_limits<double>::max();
 };
 
+enum class bnb_search_strategy_t {
+  BEST_FIRST                           = 0,
+  DEPTH_FIRST                          = 1,
+  MULTITHREADED_BEST_FIRST_WITH_DIVING = 2,
+};
+
 // Forward declare solver_settings_t for friend class
 template <typename i_t, typename f_t>
 class solver_settings_t;
@@ -79,6 +85,8 @@ class mip_solver_settings_t {
     f_t relative_mip_gap            = 1.0e-4;
   };
 
+  bnb_search_strategy_t bnb_search_strategy = bnb_search_strategy_t::BEST_FIRST;
+
   /**
    * @brief Get the tolerance settings as a single structure.
    */