Simple diving for Branch-and-Bound

benchmarks/linear_programming/cuopt/run_mip.cpp

@@ -17,6 +17,7 @@
 #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>
@@ -151,7 +152,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,11 +170,13 @@ 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;
   {
-    CUOPT_LOG_INFO("running file %s on gpu : %d", base_filename.c_str(), device);
+    CUOPT_LOG_INFO("Running file %s", base_filename.c_str());
     try {
       mps_data_model = cuopt::mps_parser::parse_mps<int, double>(file_path, input_mps_strict);
     } catch (const std::logic_error& e) {
@@ -252,7 +256,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 +271,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 +346,15 @@ 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"));
+
+  program.add_argument("--gpu")
+    .help("id of the GPU to use when running a single test (default: 0)")
+    .scan<'i', int>()
+    .default_value(0);
+
   // Parse arguments
   try {
     program.parse_args(argc, argv);
@@ -362,10 +377,25 @@ 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");
+  int gpu_id                      = program.get<int>("--gpu");
+
+  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 +480,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);
@@ -468,6 +499,9 @@ int main(int argc, char* argv[])
     }
     merge_result_files(out_dir, result_file, n_gpus, batch_num);
   } else {
+    RAFT_CUDA_TRY(cudaSetDevice(gpu_id));
+    CUOPT_LOG_INFO("Using GPU %d", gpu_id);
+
     auto memory_resource = make_async();
     rmm::mr::set_current_device_resource(memory_resource.get());
     run_single_file(path,
@@ -479,7 +513,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/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.
    */