Tune CAGRA hashmap minimum size

Expose the hashmap bit-length floor to benchmarks and select the automatic default from the GPU's shared-memory capacity for SINGLE_CTA searches while preserving the MULTI_CTA default.

Author: sherylll

cpp/bench/ann/src/cuvs/cuvs_ann_bench_param_parser.h

@@ -489,6 +489,9 @@ void parse_search_param(const nlohmann::json& conf,
   if (conf.contains("thread_block_size")) {
     param.p.thread_block_size = conf.at("thread_block_size");
   }
+  if (conf.contains("hashmap_min_bitlen")) {
+    param.p.hashmap_min_bitlen = conf.at("hashmap_min_bitlen");
+  }
   if (conf.contains("algo")) {
     if (conf.at("algo") == "single_cta") {
       param.p.algo = cuvs::neighbors::cagra::search_algo::SINGLE_CTA;

cpp/include/cuvs/neighbors/cagra.hpp

@@ -367,7 +367,7 @@ struct search_params : cuvs::neighbors::search_params {
   size_t thread_block_size = 0;
   /** Hashmap type. Auto selection when AUTO. */
   hash_mode hashmap_mode = hash_mode::AUTO;
-  /** Lower limit of hashmap bit length. More than 8. */
+  /** Lower limit of hashmap bit length. 0 selects the default; otherwise, 8 to 20. */
   size_t hashmap_min_bitlen = 0;
   /** Upper limit of hashmap fill rate. More than 0.1, less than 0.9.*/
   float hashmap_max_fill_rate = 0.5;

cpp/src/neighbors/detail/cagra/search_plan.cuh

@@ -10,6 +10,7 @@
 #include <cuvs/neighbors/common.hpp>
 #include <neighbors/detail/cagra/compute_distance-ext.cuh>
 #include <raft/core/resource/cuda_stream.hpp>
+#include <raft/core/resource/device_properties.hpp>
 // #include "topk_for_cagra/topk.h"
 
 #include <raft/core/device_mdspan.hpp>
@@ -297,6 +298,17 @@ struct search_plan_impl : public search_plan_impl_base {
       }
       RAFT_EXPECTS(hash_bitlen <= 25, "hash_bitlen cannot be largen than 25 (32M)");
     } else {
+      constexpr size_t kib = 1024;
+      const auto shared_mem_per_sm =
+        raft::resource::get_device_properties(res).sharedMemPerMultiprocessor;
+      unsigned default_min_bitlen = 8;
+      if (shared_mem_per_sm >= 196 * kib) {
+        default_min_bitlen = 11;
+      } else if (shared_mem_per_sm >= 128 * kib) {
+        default_min_bitlen = 10;
+      } else if (shared_mem_per_sm >= 64 * kib) {
+        default_min_bitlen = 9;
+      }
       while (hashmap_mode == hash_mode::AUTO || hashmap_mode == hash_mode::SMALL) {
         //
         // The small-hash reduces hash table size by initializing the hash table
@@ -306,10 +318,9 @@ struct search_plan_impl : public search_plan_impl_base {
         // visited per iteration.
         //
         const auto max_visited_nodes = itopk_size + (search_width * graph_degree * 1);
-        unsigned min_bitlen          = 8;   // 256
+        unsigned min_bitlen = hashmap_min_bitlen == 0 ? default_min_bitlen : hashmap_min_bitlen;
         unsigned max_bitlen          = 13;  // 8K
-        if (min_bitlen < hashmap_min_bitlen) { min_bitlen = hashmap_min_bitlen; }
-        hash_bitlen = min_bitlen;
+        hash_bitlen                  = min_bitlen;
         while (max_visited_nodes > hashmap::get_size(hash_bitlen) * max_fill_rate) {
           hash_bitlen += 1;
         }