diff --git a/ci/build_wheel.sh b/ci/build_wheel.sh index 3dc7740a1e..5d06e46303 100755 --- a/ci/build_wheel.sh +++ b/ci/build_wheel.sh @@ -39,6 +39,8 @@ fi if [[ ${package_name} == "raft-dask" ]]; then sed -r -i "s/pylibraft==(.*)\"/pylibraft${PACKAGE_CUDA_SUFFIX}==\1${alpha_spec}\"/g" ${pyproject_file} sed -r -i "s/ucx-py==(.*)\"/ucx-py${PACKAGE_CUDA_SUFFIX}==\1${alpha_spec}\"/g" ${pyproject_file} + sed -r -i "s/rapids-dask-dependency==(.*)\"/rapids-dask-dependency==\1${alpha_spec}\"/g" ${pyproject_file} + sed -r -i "s/dask-cuda==(.*)\"/dask-cuda==\1${alpha_spec}\"/g" ${pyproject_file} else sed -r -i "s/rmm(.*)\"/rmm${PACKAGE_CUDA_SUFFIX}\1${alpha_spec}\"/g" ${pyproject_file} fi diff --git a/ci/release/update-version.sh b/ci/release/update-version.sh index 471987eb40..d5bc17be56 100755 --- a/ci/release/update-version.sh +++ b/ci/release/update-version.sh @@ -56,7 +56,12 @@ sed_runner 's/release = .*/release = '"'${NEXT_FULL_TAG}'"'/g' docs/source/conf. DEPENDENCIES=( dask-cuda pylibraft + pylibraft-cu11 + pylibraft-cu12 rmm + rmm-cu11 + rmm-cu12 + rapids-dask-dependency # ucx-py is handled separately below ) for FILE in dependencies.yaml conda/environments/*.yaml; do @@ -75,11 +80,6 @@ done sed_runner "/^ucx_py_version:$/ {n;s/.*/ - \"${NEXT_UCX_PY_VERSION}\"/}" conda/recipes/raft-dask/conda_build_config.yaml -# Wheel builds install dask-cuda from source, update its branch -for FILE in .github/workflows/*.yaml; do - sed_runner "s/dask-cuda.git@branch-[^\"\s]\+/dask-cuda.git@branch-${NEXT_SHORT_TAG}/g" ${FILE}; -done - for FILE in .github/workflows/*.yaml; do sed_runner "/shared-workflows/ s/@.*/@branch-${NEXT_SHORT_TAG}/g" "${FILE}" done @@ -88,9 +88,13 @@ sed_runner "s/RAPIDS_VERSION_NUMBER=\".*/RAPIDS_VERSION_NUMBER=\"${NEXT_SHORT_TA sed_runner "/^PROJECT_NUMBER/ s|\".*\"|\"${NEXT_SHORT_TAG}\"|g" cpp/doxygen/Doxyfile sed_runner "/^set(RAFT_VERSION/ s|\".*\"|\"${NEXT_SHORT_TAG}\"|g" docs/source/build.md -sed_runner "/GIT_TAG.*branch-/ s|branch-.*|branch-${NEXT_SHORT_TAG}|g" docs/source/build.md +sed_runner "s|branch-[0-9][0-9].[0-9][0-9]|branch-${NEXT_SHORT_TAG}|g" docs/source/build.md sed_runner "/rapidsai\/raft/ s|branch-[0-9][0-9].[0-9][0-9]|branch-${NEXT_SHORT_TAG}|g" docs/source/developer_guide.md +sed_runner "s|:[0-9][0-9].[0-9][0-9]|:${NEXT_SHORT_TAG}|g" docs/source/raft_ann_benchmarks.md + +sed_runner "s|branch-[0-9][0-9].[0-9][0-9]|branch-${NEXT_SHORT_TAG}|g" README.md + # .devcontainer files find .devcontainer/ -type f -name devcontainer.json -print0 | while IFS= read -r -d '' filename; do sed_runner "s@rapidsai/devcontainers:[0-9.]*@rapidsai/devcontainers:${NEXT_SHORT_TAG}@g" "${filename}" diff --git a/ci/test_wheel_raft_dask.sh b/ci/test_wheel_raft_dask.sh index a20e950313..b70563b7a1 100755 --- a/ci/test_wheel_raft_dask.sh +++ b/ci/test_wheel_raft_dask.sh @@ -11,9 +11,6 @@ RAPIDS_PY_WHEEL_NAME="raft_dask_${RAPIDS_PY_CUDA_SUFFIX}" rapids-download-wheels RAPIDS_PY_WHEEL_NAME="pylibraft_${RAPIDS_PY_CUDA_SUFFIX}" rapids-download-wheels-from-s3 ./local-pylibraft-dep python -m pip install --no-deps ./local-pylibraft-dep/pylibraft*.whl -# Always install latest dask for testing -python -m pip install git+https://github.com/dask/dask.git@main git+https://github.com/dask/distributed.git@main git+https://github.com/rapidsai/dask-cuda.git@branch-23.12 - # echo to expand wildcard before adding `[extra]` requires for pip python -m pip install $(echo ./dist/raft_dask*.whl)[test] diff --git a/conda/environments/all_cuda-118_arch-aarch64.yaml b/conda/environments/all_cuda-118_arch-aarch64.yaml index 762d436028..c28f1961e6 100644 --- a/conda/environments/all_cuda-118_arch-aarch64.yaml +++ b/conda/environments/all_cuda-118_arch-aarch64.yaml @@ -20,10 +20,7 @@ dependencies: - cupy>=12.0.0 - cxx-compiler - cython>=3.0.0 -- dask-core>=2023.9.2 - dask-cuda==23.12.* -- dask>=2023.9.2 -- distributed>=2023.9.2 - doxygen>=1.8.20 - gcc_linux-aarch64=11.* - gmock>=1.13.0 @@ -49,6 +46,7 @@ dependencies: - pydata-sphinx-theme - pytest - pytest-cov +- rapids-dask-dependency==23.12.* - recommonmark - rmm==23.12.* - scikit-build>=0.13.1 diff --git a/conda/environments/all_cuda-118_arch-x86_64.yaml b/conda/environments/all_cuda-118_arch-x86_64.yaml index 48cd34c6ca..9b7c110bc3 100644 --- a/conda/environments/all_cuda-118_arch-x86_64.yaml +++ b/conda/environments/all_cuda-118_arch-x86_64.yaml @@ -20,10 +20,7 @@ dependencies: - cupy>=12.0.0 - cxx-compiler - cython>=3.0.0 -- dask-core>=2023.9.2 - dask-cuda==23.12.* -- dask>=2023.9.2 -- distributed>=2023.9.2 - doxygen>=1.8.20 - gcc_linux-64=11.* - gmock>=1.13.0 @@ -49,6 +46,7 @@ dependencies: - pydata-sphinx-theme - pytest - pytest-cov +- rapids-dask-dependency==23.12.* - recommonmark - rmm==23.12.* - scikit-build>=0.13.1 diff --git a/conda/environments/all_cuda-120_arch-aarch64.yaml b/conda/environments/all_cuda-120_arch-aarch64.yaml index 9108fb6215..8d614d3c2c 100644 --- a/conda/environments/all_cuda-120_arch-aarch64.yaml +++ b/conda/environments/all_cuda-120_arch-aarch64.yaml @@ -21,10 +21,7 @@ dependencies: - cupy>=12.0.0 - cxx-compiler - cython>=3.0.0 -- dask-core>=2023.9.2 - dask-cuda==23.12.* -- dask>=2023.9.2 -- distributed>=2023.9.2 - doxygen>=1.8.20 - gcc_linux-aarch64=11.* - gmock>=1.13.0 @@ -45,6 +42,7 @@ dependencies: - pydata-sphinx-theme - pytest - pytest-cov +- rapids-dask-dependency==23.12.* - recommonmark - rmm==23.12.* - scikit-build>=0.13.1 diff --git a/conda/environments/all_cuda-120_arch-x86_64.yaml b/conda/environments/all_cuda-120_arch-x86_64.yaml index 8f1fbf6744..f9d65cee39 100644 --- a/conda/environments/all_cuda-120_arch-x86_64.yaml +++ b/conda/environments/all_cuda-120_arch-x86_64.yaml @@ -21,10 +21,7 @@ dependencies: - cupy>=12.0.0 - cxx-compiler - cython>=3.0.0 -- dask-core>=2023.9.2 - dask-cuda==23.12.* -- dask>=2023.9.2 -- distributed>=2023.9.2 - doxygen>=1.8.20 - gcc_linux-64=11.* - gmock>=1.13.0 @@ -45,6 +42,7 @@ dependencies: - pydata-sphinx-theme - pytest - pytest-cov +- rapids-dask-dependency==23.12.* - recommonmark - rmm==23.12.* - scikit-build>=0.13.1 diff --git a/conda/recipes/raft-dask/meta.yaml b/conda/recipes/raft-dask/meta.yaml index db4fc860df..eae5a6affe 100644 --- a/conda/recipes/raft-dask/meta.yaml +++ b/conda/recipes/raft-dask/meta.yaml @@ -60,10 +60,8 @@ requirements: - cudatoolkit {% endif %} - {{ pin_compatible('cuda-version', max_pin='x', min_pin='x') }} - - dask >=2023.9.2 - - dask-core >=2023.9.2 - dask-cuda ={{ minor_version }} - - distributed >=2023.9.2 + - rapids-dask-dependency ={{ minor_version }} - joblib >=0.11 - nccl >=2.9.9 - pylibraft {{ version }} diff --git a/cpp/bench/ann/CMakeLists.txt b/cpp/bench/ann/CMakeLists.txt index d6a5fddb98..eb44e58cb5 100644 --- a/cpp/bench/ann/CMakeLists.txt +++ b/cpp/bench/ann/CMakeLists.txt @@ -30,6 +30,7 @@ option(RAFT_ANN_BENCH_USE_FAISS_CPU_IVF_PQ "Include faiss' cpu ivf pq algorithm option(RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT "Include raft's ivf flat algorithm in benchmark" ON) option(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ "Include raft's ivf pq algorithm in benchmark" ON) option(RAFT_ANN_BENCH_USE_RAFT_CAGRA "Include raft's CAGRA in benchmark" ON) +option(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB "Include raft's CAGRA in benchmark" ON) option(RAFT_ANN_BENCH_USE_HNSWLIB "Include hnsw algorithm in benchmark" ON) option(RAFT_ANN_BENCH_USE_GGNN "Include ggnn algorithm in benchmark" ON) option(RAFT_ANN_BENCH_SINGLE_EXE @@ -54,6 +55,7 @@ if(BUILD_CPU_ONLY) set(RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT OFF) set(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ OFF) set(RAFT_ANN_BENCH_USE_RAFT_CAGRA OFF) + set(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB OFF) set(RAFT_ANN_BENCH_USE_GGNN OFF) else() # Disable faiss benchmarks on CUDA 12 since faiss is not yet CUDA 12-enabled. @@ -88,6 +90,7 @@ if(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ OR RAFT_ANN_BENCH_USE_RAFT_BRUTE_FORCE OR RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT OR RAFT_ANN_BENCH_USE_RAFT_CAGRA + OR RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB ) set(RAFT_ANN_BENCH_USE_RAFT ON) endif() @@ -95,7 +98,7 @@ endif() # ################################################################################################## # * Fetch requirements ------------------------------------------------------------- -if(RAFT_ANN_BENCH_USE_HNSWLIB) +if(RAFT_ANN_BENCH_USE_HNSWLIB OR RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) include(cmake/thirdparty/get_hnswlib.cmake) endif() @@ -250,6 +253,20 @@ if(RAFT_ANN_BENCH_USE_RAFT_CAGRA) ) endif() +if(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) + ConfigureAnnBench( + NAME + RAFT_CAGRA_HNSWLIB + PATH + bench/ann/src/raft/raft_cagra_hnswlib.cu + INCLUDES + ${CMAKE_CURRENT_BINARY_DIR}/_deps/hnswlib-src/hnswlib + LINKS + raft::compiled + CXXFLAGS "${HNSW_CXX_FLAGS}" + ) +endif() + set(RAFT_FAISS_TARGETS faiss::faiss) if(TARGET faiss::faiss_avx2) set(RAFT_FAISS_TARGETS faiss::faiss_avx2) diff --git a/cpp/bench/ann/src/common/benchmark.hpp b/cpp/bench/ann/src/common/benchmark.hpp index 1cbd54cb7b..7db5eab194 100644 --- a/cpp/bench/ann/src/common/benchmark.hpp +++ b/cpp/bench/ann/src/common/benchmark.hpp @@ -287,8 +287,8 @@ void bench_search(::benchmark::State& state, std::shared_ptr> neighbors = std::make_shared>(algo_property.query_memory_type, k * query_set_size); - auto start = std::chrono::high_resolution_clock::now(); cuda_timer gpu_timer; + auto start = std::chrono::high_resolution_clock::now(); { nvtx_case nvtx{state.name()}; diff --git a/cpp/bench/ann/src/hnswlib/hnswlib_wrapper.h b/cpp/bench/ann/src/hnswlib/hnswlib_wrapper.h index 364da81f77..921d72decc 100644 --- a/cpp/bench/ann/src/hnswlib/hnswlib_wrapper.h +++ b/cpp/bench/ann/src/hnswlib/hnswlib_wrapper.h @@ -91,6 +91,8 @@ class HnswLib : public ANN { return property; } + void set_base_layer_only() { appr_alg_->base_layer_only = true; } + private: void get_search_knn_results_(const T* query, int k, size_t* indices, float* distances) const; diff --git a/cpp/bench/ann/src/raft/raft_ann_bench_param_parser.h b/cpp/bench/ann/src/raft/raft_ann_bench_param_parser.h new file mode 100644 index 0000000000..479a90e3b5 --- /dev/null +++ b/cpp/bench/ann/src/raft/raft_ann_bench_param_parser.h @@ -0,0 +1,231 @@ +/* + * Copyright (c) 2023, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#define JSON_DIAGNOSTICS 1 +#include + +#undef WARP_SIZE +#ifdef RAFT_ANN_BENCH_USE_RAFT_BFKNN +#include "raft_wrapper.h" +#endif +#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT +#include "raft_ivf_flat_wrapper.h" +extern template class raft::bench::ann::RaftIvfFlatGpu; +extern template class raft::bench::ann::RaftIvfFlatGpu; +extern template class raft::bench::ann::RaftIvfFlatGpu; +#endif +#if defined(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) || \ + defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) +#include "raft_ivf_pq_wrapper.h" +#endif +#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_PQ +extern template class raft::bench::ann::RaftIvfPQ; +extern template class raft::bench::ann::RaftIvfPQ; +extern template class raft::bench::ann::RaftIvfPQ; +#endif +#if defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) +#include "raft_cagra_wrapper.h" +#endif +#ifdef RAFT_ANN_BENCH_USE_RAFT_CAGRA +extern template class raft::bench::ann::RaftCagra; +extern template class raft::bench::ann::RaftCagra; +extern template class raft::bench::ann::RaftCagra; +#endif + +#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT +template +void parse_build_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftIvfFlatGpu::BuildParam& param) +{ + param.n_lists = conf.at("nlist"); + if (conf.contains("niter")) { param.kmeans_n_iters = conf.at("niter"); } + if (conf.contains("ratio")) { param.kmeans_trainset_fraction = 1.0 / (double)conf.at("ratio"); } +} + +template +void parse_search_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftIvfFlatGpu::SearchParam& param) +{ + param.ivf_flat_params.n_probes = conf.at("nprobe"); +} +#endif + +#if defined(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) || \ + defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) +template +void parse_build_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftIvfPQ::BuildParam& param) +{ + if (conf.contains("nlist")) { param.n_lists = conf.at("nlist"); } + if (conf.contains("niter")) { param.kmeans_n_iters = conf.at("niter"); } + if (conf.contains("ratio")) { param.kmeans_trainset_fraction = 1.0 / (double)conf.at("ratio"); } + if (conf.contains("pq_bits")) { param.pq_bits = conf.at("pq_bits"); } + if (conf.contains("pq_dim")) { param.pq_dim = conf.at("pq_dim"); } + if (conf.contains("codebook_kind")) { + std::string kind = conf.at("codebook_kind"); + if (kind == "cluster") { + param.codebook_kind = raft::neighbors::ivf_pq::codebook_gen::PER_CLUSTER; + } else if (kind == "subspace") { + param.codebook_kind = raft::neighbors::ivf_pq::codebook_gen::PER_SUBSPACE; + } else { + throw std::runtime_error("codebook_kind: '" + kind + + "', should be either 'cluster' or 'subspace'"); + } + } +} + +template +void parse_search_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftIvfPQ::SearchParam& param) +{ + if (conf.contains("nprobe")) { param.pq_param.n_probes = conf.at("nprobe"); } + if (conf.contains("internalDistanceDtype")) { + std::string type = conf.at("internalDistanceDtype"); + if (type == "float") { + param.pq_param.internal_distance_dtype = CUDA_R_32F; + } else if (type == "half") { + param.pq_param.internal_distance_dtype = CUDA_R_16F; + } else { + throw std::runtime_error("internalDistanceDtype: '" + type + + "', should be either 'float' or 'half'"); + } + } else { + // set half as default type + param.pq_param.internal_distance_dtype = CUDA_R_16F; + } + + if (conf.contains("smemLutDtype")) { + std::string type = conf.at("smemLutDtype"); + if (type == "float") { + param.pq_param.lut_dtype = CUDA_R_32F; + } else if (type == "half") { + param.pq_param.lut_dtype = CUDA_R_16F; + } else if (type == "fp8") { + param.pq_param.lut_dtype = CUDA_R_8U; + } else { + throw std::runtime_error("smemLutDtype: '" + type + + "', should be either 'float', 'half' or 'fp8'"); + } + } else { + // set half as default + param.pq_param.lut_dtype = CUDA_R_16F; + } + if (conf.contains("refine_ratio")) { + param.refine_ratio = conf.at("refine_ratio"); + if (param.refine_ratio < 1.0f) { throw std::runtime_error("refine_ratio should be >= 1.0"); } + } +} +#endif + +#if defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA_HNSWLIB) +template +void parse_build_param(const nlohmann::json& conf, + raft::neighbors::experimental::nn_descent::index_params& param) +{ + if (conf.contains("graph_degree")) { param.graph_degree = conf.at("graph_degree"); } + if (conf.contains("intermediate_graph_degree")) { + param.intermediate_graph_degree = conf.at("intermediate_graph_degree"); + } + // we allow niter shorthand for max_iterations + if (conf.contains("niter")) { param.max_iterations = conf.at("niter"); } + if (conf.contains("max_iterations")) { param.max_iterations = conf.at("max_iterations"); } + if (conf.contains("termination_threshold")) { + param.termination_threshold = conf.at("termination_threshold"); + } +} + +nlohmann::json collect_conf_with_prefix(const nlohmann::json& conf, + const std::string& prefix, + bool remove_prefix = true) +{ + nlohmann::json out; + for (auto& i : conf.items()) { + if (i.key().compare(0, prefix.size(), prefix) == 0) { + auto new_key = remove_prefix ? i.key().substr(prefix.size()) : i.key(); + out[new_key] = i.value(); + } + } + return out; +} + +template +void parse_build_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftCagra::BuildParam& param) +{ + if (conf.contains("graph_degree")) { + param.cagra_params.graph_degree = conf.at("graph_degree"); + param.cagra_params.intermediate_graph_degree = param.cagra_params.graph_degree * 2; + } + if (conf.contains("intermediate_graph_degree")) { + param.cagra_params.intermediate_graph_degree = conf.at("intermediate_graph_degree"); + } + if (conf.contains("graph_build_algo")) { + if (conf.at("graph_build_algo") == "IVF_PQ") { + param.cagra_params.build_algo = raft::neighbors::cagra::graph_build_algo::IVF_PQ; + } else if (conf.at("graph_build_algo") == "NN_DESCENT") { + param.cagra_params.build_algo = raft::neighbors::cagra::graph_build_algo::NN_DESCENT; + } + } + nlohmann::json ivf_pq_build_conf = collect_conf_with_prefix(conf, "ivf_pq_build_"); + if (!ivf_pq_build_conf.empty()) { + raft::neighbors::ivf_pq::index_params bparam; + parse_build_param(ivf_pq_build_conf, bparam); + param.ivf_pq_build_params = bparam; + } + nlohmann::json ivf_pq_search_conf = collect_conf_with_prefix(conf, "ivf_pq_search_"); + if (!ivf_pq_search_conf.empty()) { + typename raft::bench::ann::RaftIvfPQ::SearchParam sparam; + parse_search_param(ivf_pq_search_conf, sparam); + param.ivf_pq_search_params = sparam.pq_param; + param.ivf_pq_refine_rate = sparam.refine_ratio; + } + nlohmann::json nn_descent_conf = collect_conf_with_prefix(conf, "nn_descent_"); + if (!nn_descent_conf.empty()) { + raft::neighbors::experimental::nn_descent::index_params nn_param; + nn_param.intermediate_graph_degree = 1.5 * param.cagra_params.intermediate_graph_degree; + parse_build_param(nn_descent_conf, nn_param); + if (nn_param.graph_degree != param.cagra_params.intermediate_graph_degree) { + nn_param.graph_degree = param.cagra_params.intermediate_graph_degree; + } + param.nn_descent_params = nn_param; + } +} + +template +void parse_search_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftCagra::SearchParam& param) +{ + if (conf.contains("itopk")) { param.p.itopk_size = conf.at("itopk"); } + if (conf.contains("search_width")) { param.p.search_width = conf.at("search_width"); } + if (conf.contains("max_iterations")) { param.p.max_iterations = conf.at("max_iterations"); } + if (conf.contains("algo")) { + if (conf.at("algo") == "single_cta") { + param.p.algo = raft::neighbors::experimental::cagra::search_algo::SINGLE_CTA; + } else if (conf.at("algo") == "multi_cta") { + param.p.algo = raft::neighbors::experimental::cagra::search_algo::MULTI_CTA; + } else if (conf.at("algo") == "multi_kernel") { + param.p.algo = raft::neighbors::experimental::cagra::search_algo::MULTI_KERNEL; + } else if (conf.at("algo") == "auto") { + param.p.algo = raft::neighbors::experimental::cagra::search_algo::AUTO; + } else { + std::string tmp = conf.at("algo"); + THROW("Invalid value for algo: %s", tmp.c_str()); + } + } +} +#endif diff --git a/cpp/bench/ann/src/raft/raft_benchmark.cu b/cpp/bench/ann/src/raft/raft_benchmark.cu index fb7d83a829..f8c65a2d6e 100644 --- a/cpp/bench/ann/src/raft/raft_benchmark.cu +++ b/cpp/bench/ann/src/raft/raft_benchmark.cu @@ -16,6 +16,8 @@ #include "../common/ann_types.hpp" +#include "raft_ann_bench_param_parser.h" + #include #include #include @@ -26,219 +28,11 @@ #include #include -#undef WARP_SIZE -#ifdef RAFT_ANN_BENCH_USE_RAFT_BFKNN -#include "raft_wrapper.h" -#endif -#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT -#include "raft_ivf_flat_wrapper.h" -extern template class raft::bench::ann::RaftIvfFlatGpu; -extern template class raft::bench::ann::RaftIvfFlatGpu; -extern template class raft::bench::ann::RaftIvfFlatGpu; -#endif -#if defined(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) -#include "raft_ivf_pq_wrapper.h" -#endif -#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_PQ -extern template class raft::bench::ann::RaftIvfPQ; -extern template class raft::bench::ann::RaftIvfPQ; -extern template class raft::bench::ann::RaftIvfPQ; -#endif -#ifdef RAFT_ANN_BENCH_USE_RAFT_CAGRA -#include "raft_cagra_wrapper.h" -extern template class raft::bench::ann::RaftCagra; -extern template class raft::bench::ann::RaftCagra; -extern template class raft::bench::ann::RaftCagra; -#endif #define JSON_DIAGNOSTICS 1 #include namespace raft::bench::ann { -#ifdef RAFT_ANN_BENCH_USE_RAFT_IVF_FLAT -template -void parse_build_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftIvfFlatGpu::BuildParam& param) -{ - param.n_lists = conf.at("nlist"); - if (conf.contains("niter")) { param.kmeans_n_iters = conf.at("niter"); } - if (conf.contains("ratio")) { param.kmeans_trainset_fraction = 1.0 / (double)conf.at("ratio"); } -} - -template -void parse_search_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftIvfFlatGpu::SearchParam& param) -{ - param.ivf_flat_params.n_probes = conf.at("nprobe"); -} -#endif - -#if defined(RAFT_ANN_BENCH_USE_RAFT_IVF_PQ) || defined(RAFT_ANN_BENCH_USE_RAFT_CAGRA) -template -void parse_build_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftIvfPQ::BuildParam& param) -{ - if (conf.contains("nlist")) { param.n_lists = conf.at("nlist"); } - if (conf.contains("niter")) { param.kmeans_n_iters = conf.at("niter"); } - if (conf.contains("ratio")) { param.kmeans_trainset_fraction = 1.0 / (double)conf.at("ratio"); } - if (conf.contains("pq_bits")) { param.pq_bits = conf.at("pq_bits"); } - if (conf.contains("pq_dim")) { param.pq_dim = conf.at("pq_dim"); } - if (conf.contains("codebook_kind")) { - std::string kind = conf.at("codebook_kind"); - if (kind == "cluster") { - param.codebook_kind = raft::neighbors::ivf_pq::codebook_gen::PER_CLUSTER; - } else if (kind == "subspace") { - param.codebook_kind = raft::neighbors::ivf_pq::codebook_gen::PER_SUBSPACE; - } else { - throw std::runtime_error("codebook_kind: '" + kind + - "', should be either 'cluster' or 'subspace'"); - } - } -} - -template -void parse_search_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftIvfPQ::SearchParam& param) -{ - if (conf.contains("nprobe")) { param.pq_param.n_probes = conf.at("nprobe"); } - if (conf.contains("internalDistanceDtype")) { - std::string type = conf.at("internalDistanceDtype"); - if (type == "float") { - param.pq_param.internal_distance_dtype = CUDA_R_32F; - } else if (type == "half") { - param.pq_param.internal_distance_dtype = CUDA_R_16F; - } else { - throw std::runtime_error("internalDistanceDtype: '" + type + - "', should be either 'float' or 'half'"); - } - } else { - // set half as default type - param.pq_param.internal_distance_dtype = CUDA_R_16F; - } - - if (conf.contains("smemLutDtype")) { - std::string type = conf.at("smemLutDtype"); - if (type == "float") { - param.pq_param.lut_dtype = CUDA_R_32F; - } else if (type == "half") { - param.pq_param.lut_dtype = CUDA_R_16F; - } else if (type == "fp8") { - param.pq_param.lut_dtype = CUDA_R_8U; - } else { - throw std::runtime_error("smemLutDtype: '" + type + - "', should be either 'float', 'half' or 'fp8'"); - } - } else { - // set half as default - param.pq_param.lut_dtype = CUDA_R_16F; - } - if (conf.contains("refine_ratio")) { - param.refine_ratio = conf.at("refine_ratio"); - if (param.refine_ratio < 1.0f) { throw std::runtime_error("refine_ratio should be >= 1.0"); } - } -} -#endif - -#ifdef RAFT_ANN_BENCH_USE_RAFT_CAGRA -template -void parse_build_param(const nlohmann::json& conf, - raft::neighbors::experimental::nn_descent::index_params& param) -{ - if (conf.contains("graph_degree")) { param.graph_degree = conf.at("graph_degree"); } - if (conf.contains("intermediate_graph_degree")) { - param.intermediate_graph_degree = conf.at("intermediate_graph_degree"); - } - // we allow niter shorthand for max_iterations - if (conf.contains("niter")) { param.max_iterations = conf.at("niter"); } - if (conf.contains("max_iterations")) { param.max_iterations = conf.at("max_iterations"); } - if (conf.contains("termination_threshold")) { - param.termination_threshold = conf.at("termination_threshold"); - } -} - -nlohmann::json collect_conf_with_prefix(const nlohmann::json& conf, - const std::string& prefix, - bool remove_prefix = true) -{ - nlohmann::json out; - for (auto& i : conf.items()) { - if (i.key().compare(0, prefix.size(), prefix) == 0) { - auto new_key = remove_prefix ? i.key().substr(prefix.size()) : i.key(); - out[new_key] = i.value(); - } - } - return out; -} - -template -void parse_build_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftCagra::BuildParam& param) -{ - if (conf.contains("graph_degree")) { - param.cagra_params.graph_degree = conf.at("graph_degree"); - param.cagra_params.intermediate_graph_degree = param.cagra_params.graph_degree * 2; - } - if (conf.contains("intermediate_graph_degree")) { - param.cagra_params.intermediate_graph_degree = conf.at("intermediate_graph_degree"); - } - if (conf.contains("graph_build_algo")) { - if (conf.at("graph_build_algo") == "IVF_PQ") { - param.cagra_params.build_algo = raft::neighbors::cagra::graph_build_algo::IVF_PQ; - } else if (conf.at("graph_build_algo") == "NN_DESCENT") { - param.cagra_params.build_algo = raft::neighbors::cagra::graph_build_algo::NN_DESCENT; - } - } - nlohmann::json ivf_pq_build_conf = collect_conf_with_prefix(conf, "ivf_pq_build_"); - if (!ivf_pq_build_conf.empty()) { - raft::neighbors::ivf_pq::index_params bparam; - parse_build_param(ivf_pq_build_conf, bparam); - param.ivf_pq_build_params = bparam; - } - nlohmann::json ivf_pq_search_conf = collect_conf_with_prefix(conf, "ivf_pq_search_"); - if (!ivf_pq_search_conf.empty()) { - typename raft::bench::ann::RaftIvfPQ::SearchParam sparam; - parse_search_param(ivf_pq_search_conf, sparam); - param.ivf_pq_search_params = sparam.pq_param; - param.ivf_pq_refine_rate = sparam.refine_ratio; - } - nlohmann::json nn_descent_conf = collect_conf_with_prefix(conf, "nn_descent_"); - if (!nn_descent_conf.empty()) { - raft::neighbors::experimental::nn_descent::index_params nn_param; - nn_param.intermediate_graph_degree = 1.5 * param.cagra_params.intermediate_graph_degree; - parse_build_param(nn_descent_conf, nn_param); - if (nn_param.graph_degree != param.cagra_params.intermediate_graph_degree) { - RAFT_LOG_WARN( - "nn_descent_graph_degree has to be equal to CAGRA intermediate_grpah_degree, overriding"); - nn_param.graph_degree = param.cagra_params.intermediate_graph_degree; - } - param.nn_descent_params = nn_param; - } -} - -template -void parse_search_param(const nlohmann::json& conf, - typename raft::bench::ann::RaftCagra::SearchParam& param) -{ - if (conf.contains("itopk")) { param.p.itopk_size = conf.at("itopk"); } - if (conf.contains("search_width")) { param.p.search_width = conf.at("search_width"); } - if (conf.contains("max_iterations")) { param.p.max_iterations = conf.at("max_iterations"); } - if (conf.contains("algo")) { - if (conf.at("algo") == "single_cta") { - param.p.algo = raft::neighbors::experimental::cagra::search_algo::SINGLE_CTA; - } else if (conf.at("algo") == "multi_cta") { - param.p.algo = raft::neighbors::experimental::cagra::search_algo::MULTI_CTA; - } else if (conf.at("algo") == "multi_kernel") { - param.p.algo = raft::neighbors::experimental::cagra::search_algo::MULTI_KERNEL; - } else if (conf.at("algo") == "auto") { - param.p.algo = raft::neighbors::experimental::cagra::search_algo::AUTO; - } else { - std::string tmp = conf.at("algo"); - THROW("Invalid value for algo: %s", tmp.c_str()); - } - } -} -#endif - template std::unique_ptr> create_algo(const std::string& algo, const std::string& distance, @@ -281,6 +75,7 @@ std::unique_ptr> create_algo(const std::string& algo, ann = std::make_unique>(metric, dim, param); } #endif + if (!ann) { throw std::runtime_error("invalid algo: '" + algo + "'"); } return ann; @@ -318,6 +113,7 @@ std::unique_ptr::AnnSearchParam> create_search return param; } #endif + // else throw std::runtime_error("invalid algo: '" + algo + "'"); } diff --git a/cpp/bench/ann/src/raft/raft_cagra_hnswlib.cu b/cpp/bench/ann/src/raft/raft_cagra_hnswlib.cu new file mode 100644 index 0000000000..ce6fa255b2 --- /dev/null +++ b/cpp/bench/ann/src/raft/raft_cagra_hnswlib.cu @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2023, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "../common/ann_types.hpp" +#include "raft_ann_bench_param_parser.h" +#include "raft_cagra_hnswlib_wrapper.h" + +#include + +#define JSON_DIAGNOSTICS 1 +#include + +namespace raft::bench::ann { + +template +void parse_search_param(const nlohmann::json& conf, + typename raft::bench::ann::RaftCagraHnswlib::SearchParam& param) +{ + param.ef = conf.at("ef"); + if (conf.contains("numThreads")) { param.num_threads = conf.at("numThreads"); } +} + +template +std::unique_ptr> create_algo(const std::string& algo, + const std::string& distance, + int dim, + const nlohmann::json& conf, + const std::vector& dev_list) +{ + // stop compiler warning; not all algorithms support multi-GPU so it may not be used + (void)dev_list; + + raft::bench::ann::Metric metric = parse_metric(distance); + std::unique_ptr> ann; + + if constexpr (std::is_same_v or std::is_same_v) { + if (algo == "raft_cagra_hnswlib") { + typename raft::bench::ann::RaftCagraHnswlib::BuildParam param; + parse_build_param(conf, param); + ann = std::make_unique>(metric, dim, param); + } + } + + if (!ann) { throw std::runtime_error("invalid algo: '" + algo + "'"); } + + return ann; +} + +template +std::unique_ptr::AnnSearchParam> create_search_param( + const std::string& algo, const nlohmann::json& conf) +{ + if (algo == "raft_cagra_hnswlib") { + auto param = + std::make_unique::SearchParam>(); + parse_search_param(conf, *param); + return param; + } + + throw std::runtime_error("invalid algo: '" + algo + "'"); +} + +} // namespace raft::bench::ann + +REGISTER_ALGO_INSTANCE(float); +REGISTER_ALGO_INSTANCE(std::int8_t); +REGISTER_ALGO_INSTANCE(std::uint8_t); + +#ifdef ANN_BENCH_BUILD_MAIN +#include "../common/benchmark.hpp" +int main(int argc, char** argv) +{ + rmm::mr::cuda_memory_resource cuda_mr; + // Construct a resource that uses a coalescing best-fit pool allocator + rmm::mr::pool_memory_resource pool_mr{&cuda_mr}; + rmm::mr::set_current_device_resource( + &pool_mr); // Updates the current device resource pointer to `pool_mr` + rmm::mr::device_memory_resource* mr = + rmm::mr::get_current_device_resource(); // Points to `pool_mr` + return raft::bench::ann::run_main(argc, argv); +} +#endif diff --git a/cpp/bench/ann/src/raft/raft_cagra_hnswlib_wrapper.h b/cpp/bench/ann/src/raft/raft_cagra_hnswlib_wrapper.h new file mode 100644 index 0000000000..432caecfcc --- /dev/null +++ b/cpp/bench/ann/src/raft/raft_cagra_hnswlib_wrapper.h @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2023, NVIDIA CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#pragma once + +#include "../hnswlib/hnswlib_wrapper.h" +#include "raft_cagra_wrapper.h" +#include + +namespace raft::bench::ann { + +template +class RaftCagraHnswlib : public ANN { + public: + using typename ANN::AnnSearchParam; + using BuildParam = typename RaftCagra::BuildParam; + using SearchParam = typename HnswLib::SearchParam; + + RaftCagraHnswlib(Metric metric, int dim, const BuildParam& param, int concurrent_searches = 1) + : ANN(metric, dim), + metric_(metric), + index_params_(param), + dimension_(dim), + handle_(cudaStreamPerThread) + { + } + + ~RaftCagraHnswlib() noexcept {} + + void build(const T* dataset, size_t nrow, cudaStream_t stream) final; + + void set_search_param(const AnnSearchParam& param) override; + + // TODO: if the number of results is less than k, the remaining elements of 'neighbors' + // will be filled with (size_t)-1 + void search(const T* queries, + int batch_size, + int k, + size_t* neighbors, + float* distances, + cudaStream_t stream = 0) const override; + + // to enable dataset access from GPU memory + AlgoProperty get_preference() const override + { + AlgoProperty property; + property.dataset_memory_type = MemoryType::HostMmap; + property.query_memory_type = MemoryType::Host; + return property; + } + void save(const std::string& file) const override; + void load(const std::string&) override; + + private: + raft::device_resources handle_; + Metric metric_; + BuildParam index_params_; + int dimension_; + + std::unique_ptr> cagra_build_; + std::unique_ptr> hnswlib_search_; + + Objective metric_objective_; +}; + +template +void RaftCagraHnswlib::build(const T* dataset, size_t nrow, cudaStream_t stream) +{ + if (not cagra_build_) { + cagra_build_ = std::make_unique>(metric_, dimension_, index_params_); + } + cagra_build_->build(dataset, nrow, stream); +} + +template +void RaftCagraHnswlib::set_search_param(const AnnSearchParam& param_) +{ + hnswlib_search_->set_search_param(param_); +} + +template +void RaftCagraHnswlib::save(const std::string& file) const +{ + cagra_build_->save_to_hnswlib(file); +} + +template +void RaftCagraHnswlib::load(const std::string& file) +{ + typename HnswLib::BuildParam param; + // these values don't matter since we don't build with HnswLib + param.M = 50; + param.ef_construction = 100; + if (not hnswlib_search_) { + hnswlib_search_ = std::make_unique>(metric_, dimension_, param); + } + hnswlib_search_->load(file); + hnswlib_search_->set_base_layer_only(); +} + +template +void RaftCagraHnswlib::search( + const T* queries, int batch_size, int k, size_t* neighbors, float* distances, cudaStream_t) const +{ + hnswlib_search_->search(queries, batch_size, k, neighbors, distances); +} + +} // namespace raft::bench::ann diff --git a/cpp/bench/ann/src/raft/raft_cagra_wrapper.h b/cpp/bench/ann/src/raft/raft_cagra_wrapper.h index 73fae027bc..bf526101be 100644 --- a/cpp/bench/ann/src/raft/raft_cagra_wrapper.h +++ b/cpp/bench/ann/src/raft/raft_cagra_wrapper.h @@ -98,6 +98,7 @@ class RaftCagra : public ANN { } void save(const std::string& file) const override; void load(const std::string&) override; + void save_to_hnswlib(const std::string& file) const; private: raft::device_resources handle_; @@ -143,7 +144,13 @@ void RaftCagra::set_search_dataset(const T* dataset, size_t nrow) template void RaftCagra::save(const std::string& file) const { - raft::neighbors::cagra::serialize(handle_, file, *index_, false); + raft::neighbors::cagra::serialize(handle_, file, *index_); +} + +template +void RaftCagra::save_to_hnswlib(const std::string& file) const +{ + raft::neighbors::cagra::serialize_to_hnswlib(handle_, file, *index_); } template diff --git a/cpp/cmake/patches/hnswlib.patch b/cpp/cmake/patches/hnswlib.patch new file mode 100644 index 0000000000..32c1537c58 --- /dev/null +++ b/cpp/cmake/patches/hnswlib.patch @@ -0,0 +1,130 @@ +diff --git a/hnswlib/hnswalg.h b/hnswlib/hnswalg.h +index e95e0b5..f0fe50a 100644 +--- a/hnswlib/hnswalg.h ++++ b/hnswlib/hnswalg.h +@@ -3,6 +3,7 @@ + #include "visited_list_pool.h" + #include "hnswlib.h" + #include ++#include + #include + #include + #include +@@ -16,6 +17,8 @@ namespace hnswlib { + template + class HierarchicalNSW : public AlgorithmInterface { + public: ++ bool base_layer_only{false}; ++ int num_seeds=32; + static const tableint max_update_element_locks = 65536; + HierarchicalNSW(SpaceInterface *s) { + } +@@ -56,7 +59,7 @@ namespace hnswlib { + visited_list_pool_ = new VisitedListPool(1, max_elements); + + //initializations for special treatment of the first node +- enterpoint_node_ = -1; ++ enterpoint_node_ = std::numeric_limits::max(); + maxlevel_ = -1; + + linkLists_ = (char **) malloc(sizeof(void *) * max_elements_); +@@ -527,7 +530,7 @@ namespace hnswlib { + tableint *datal = (tableint *) (data + 1); + for (int i = 0; i < size; i++) { + tableint cand = datal[i]; +- if (cand < 0 || cand > max_elements_) ++ if (cand > max_elements_) + throw std::runtime_error("cand error"); + dist_t d = fstdistfunc_(query_data, getDataByInternalId(cand), dist_func_param_); + +@@ -1067,7 +1070,7 @@ namespace hnswlib { + tableint *datal = (tableint *) (data + 1); + for (int i = 0; i < size; i++) { + tableint cand = datal[i]; +- if (cand < 0 || cand > max_elements_) ++ if (cand > max_elements_) + throw std::runtime_error("cand error"); + dist_t d = fstdistfunc_(data_point, getDataByInternalId(cand), dist_func_param_); + if (d < curdist) { +@@ -1119,28 +1122,41 @@ namespace hnswlib { + tableint currObj = enterpoint_node_; + dist_t curdist = fstdistfunc_(query_data, getDataByInternalId(enterpoint_node_), dist_func_param_); + +- for (int level = maxlevel_; level > 0; level--) { +- bool changed = true; +- while (changed) { +- changed = false; +- unsigned int *data; ++ if (base_layer_only) { ++ // You can increase the number of seeds when testing large-scale dataset, num_seeds = 48 for 100M-scale ++ for (int i = 0; i < num_seeds; i++) { ++ tableint obj = i * (max_elements_ / num_seeds); ++ dist_t dist = fstdistfunc_(query_data, getDataByInternalId(obj), dist_func_param_); ++ if (dist < curdist) { ++ curdist = dist; ++ currObj = obj; ++ } ++ } ++ } ++ else{ ++ for (int level = maxlevel_; level > 0; level--) { ++ bool changed = true; ++ while (changed) { ++ changed = false; ++ unsigned int *data; + +- data = (unsigned int *) get_linklist(currObj, level); +- int size = getListCount(data); +- metric_hops++; +- metric_distance_computations+=size; ++ data = (unsigned int *) get_linklist(currObj, level); ++ int size = getListCount(data); ++ metric_hops++; ++ metric_distance_computations+=size; + +- tableint *datal = (tableint *) (data + 1); +- for (int i = 0; i < size; i++) { +- tableint cand = datal[i]; +- if (cand < 0 || cand > max_elements_) +- throw std::runtime_error("cand error"); +- dist_t d = fstdistfunc_(query_data, getDataByInternalId(cand), dist_func_param_); ++ tableint *datal = (tableint *) (data + 1); ++ for (int i = 0; i < size; i++) { ++ tableint cand = datal[i]; ++ if (cand > max_elements_) ++ throw std::runtime_error("cand error"); ++ dist_t d = fstdistfunc_(query_data, getDataByInternalId(cand), dist_func_param_); + +- if (d < curdist) { +- curdist = d; +- currObj = cand; +- changed = true; ++ if (d < curdist) { ++ curdist = d; ++ currObj = cand; ++ changed = true; ++ } + } + } + } +diff --git a/hnswlib/visited_list_pool.h b/hnswlib/visited_list_pool.h +index 5e1a4a5..4195ebd 100644 +--- a/hnswlib/visited_list_pool.h ++++ b/hnswlib/visited_list_pool.h +@@ -3,6 +3,7 @@ + #include + #include + #include ++#include + + namespace hnswlib { + typedef unsigned short int vl_type; +@@ -14,7 +15,7 @@ namespace hnswlib { + unsigned int numelements; + + VisitedList(int numelements1) { +- curV = -1; ++ curV = std::numeric_limits::max(); + numelements = numelements1; + mass = new vl_type[numelements]; + } diff --git a/cpp/cmake/thirdparty/get_hnswlib.cmake b/cpp/cmake/thirdparty/get_hnswlib.cmake index 94033e8333..a4ceacae38 100644 --- a/cpp/cmake/thirdparty/get_hnswlib.cmake +++ b/cpp/cmake/thirdparty/get_hnswlib.cmake @@ -26,6 +26,11 @@ function(find_and_configure_hnswlib) COMMAND git clone --branch=v0.6.2 https://github.com/nmslib/hnswlib.git hnswlib-src WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/_deps ) + message("SOURCE ${CMAKE_CURRENT_SOURCE_DIR}") + execute_process ( + COMMAND git apply ${CMAKE_CURRENT_SOURCE_DIR}/cmake/patches/hnswlib.patch + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/_deps/hnswlib-src + ) endif () include(cmake/modules/FindAVX.cmake) diff --git a/cpp/include/raft/matrix/detail/select_k-inl.cuh b/cpp/include/raft/matrix/detail/select_k-inl.cuh index af5a5770fb..20fe1963fc 100644 --- a/cpp/include/raft/matrix/detail/select_k-inl.cuh +++ b/cpp/include/raft/matrix/detail/select_k-inl.cuh @@ -34,7 +34,7 @@ namespace raft::matrix::detail { // this is a subset of algorithms, chosen by running the algorithm_selection // notebook in cpp/scripts/heuristics/select_k -enum class Algo { kRadix11bits, kWarpDistributedShm, kFaissBlockSelect }; +enum class Algo { kRadix11bits, kWarpDistributedShm, kWarpImmediate, kRadix11bitsExtraPass }; /** * Predict the fastest select_k algorithm based on the number of rows/cols/k @@ -50,73 +50,29 @@ enum class Algo { kRadix11bits, kWarpDistributedShm, kFaissBlockSelect }; */ inline Algo choose_select_k_algorithm(size_t rows, size_t cols, int k) { - if (k > 134) { - if (k > 256) { - if (k > 809) { - return Algo::kRadix11bits; - } else { - if (rows > 124) { - if (cols > 63488) { - return Algo::kFaissBlockSelect; - } else { - return Algo::kRadix11bits; - } - } else { - return Algo::kRadix11bits; - } - } - } else { - if (cols > 678736) { - return Algo::kWarpDistributedShm; + if (k > 256) { + if (cols > 16862) { + if (rows > 1020) { + return Algo::kRadix11bitsExtraPass; } else { return Algo::kRadix11bits; } + } else { + return Algo::kRadix11bitsExtraPass; } } else { - if (cols > 13776) { - if (rows > 335) { - if (k > 1) { - if (rows > 546) { - return Algo::kWarpDistributedShm; - } else { - if (k > 17) { - return Algo::kWarpDistributedShm; - } else { - return Algo::kFaissBlockSelect; - } - } - } else { - return Algo::kFaissBlockSelect; - } + if (k > 2) { + if (cols > 22061) { + return Algo::kWarpDistributedShm; } else { - if (k > 44) { - if (cols > 1031051) { - return Algo::kWarpDistributedShm; - } else { - if (rows > 22) { - return Algo::kWarpDistributedShm; - } else { - return Algo::kRadix11bits; - } - } - } else { - return Algo::kWarpDistributedShm; - } - } - } else { - if (k > 1) { - if (rows > 188) { + if (rows > 198) { return Algo::kWarpDistributedShm; } else { - if (k > 72) { - return Algo::kRadix11bits; - } else { - return Algo::kWarpDistributedShm; - } + return Algo::kWarpImmediate; } - } else { - return Algo::kFaissBlockSelect; } + } else { + return Algo::kWarpImmediate; } } } @@ -294,6 +250,8 @@ void select_k(raft::resources const& handle, switch (algo) { case Algo::kRadix11bits: + case Algo::kRadix11bitsExtraPass: { + bool fused_last_filter = algo == Algo::kRadix11bits; detail::select::radix::select_k(in_val, in_idx, batch_size, @@ -302,7 +260,7 @@ void select_k(raft::resources const& handle, out_val, out_idx, select_min, - true, // fused_last_filter + fused_last_filter, stream, mr); @@ -324,13 +282,15 @@ void select_k(raft::resources const& handle, handle, raft::make_const_mdspan(offsets.view()), keys, vals, select_min); } return; + } case Algo::kWarpDistributedShm: return detail::select::warpsort:: select_k_impl( in_val, in_idx, batch_size, len, k, out_val, out_idx, select_min, stream, mr); - case Algo::kFaissBlockSelect: - return neighbors::detail::select_k( - in_val, in_idx, batch_size, len, out_val, out_idx, select_min, k, stream); + case Algo::kWarpImmediate: + return detail::select::warpsort:: + select_k_impl( + in_val, in_idx, batch_size, len, k, out_val, out_idx, select_min, stream, mr); default: RAFT_FAIL("K-selection Algorithm not supported."); } } diff --git a/cpp/include/raft/matrix/detail/select_radix.cuh b/cpp/include/raft/matrix/detail/select_radix.cuh index b3c07b9d3a..fa12005df2 100644 --- a/cpp/include/raft/matrix/detail/select_radix.cuh +++ b/cpp/include/raft/matrix/detail/select_radix.cuh @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -103,15 +104,27 @@ _RAFT_DEVICE int calc_bucket(T x, int start_bit, unsigned mask, bool select_min) return (twiddle_in(x, select_min) >> start_bit) & mask; } -template +// Strangely, RATIO_T has a strong impact on register usage and occupancy for sm80, e.g. +// using RATIO_T=unsigned for radix_kernel decreases occupancy (with CUDA 12). +// In the meanwhile, RATIO_T has no impact for sm90. +template _RAFT_HOST_DEVICE IdxT calc_buf_len(IdxT len) { // When writing is skipped, only read `in`(type T). // When writing is not skipped, read `in_buf`(T) and `in_idx_buf`(IdxT), and write `out_buf`(T) // and `out_idx_buf`(IdxT). // The ratio between these cases determines whether to skip writing and hence the buffer size. - constexpr float ratio = 2 + sizeof(IdxT) * 2.0 / sizeof(T); - return len / ratio; + constexpr RATIO_T ratio = 2 + sizeof(IdxT) * 2 / sizeof(T); + // Even such estimation is too conservative, so further decrease buf_len by 1/8 + IdxT buf_len = len / (ratio * 8); + + // one-block kernel splits one large buffer into smaller ones, so round buf size to 256 bytes to + // avoid alignment issues + static_assert(is_a_power_of_two(sizeof(T))); + static_assert(is_a_power_of_two(sizeof(IdxT))); + constexpr IdxT aligned = 256 / std::min(sizeof(T), sizeof(IdxT)); + buf_len = Pow2::roundDown(buf_len); + return buf_len; } /** @@ -208,6 +221,11 @@ struct alignas(128) Counter { /** * Fused filtering of the current pass and building histogram for the next pass * (see steps 4 & 1 in `radix_kernel` description). + * + * This function is more complicated than the one-block counterpart because this function handles + * the case of early stopping. When early stopping is triggered, it's desirable to do the final + * filtering in this function rather than in last_filter(), because this function is run by multiple + * blocks while last_filter is run by a single block. */ template _RAFT_DEVICE void filter_and_histogram(const T* in_buf, @@ -397,7 +415,7 @@ _RAFT_DEVICE void last_filter(const T* in_buf, const int start_bit = calc_start_bit(pass); // changed in choose_bucket(); need to reload - const IdxT needed_num_of_kth = counter->k; + const IdxT num_of_kth_needed = counter->k; IdxT* p_out_cnt = &counter->out_cnt; IdxT* p_out_back_cnt = &counter->out_back_cnt; for (IdxT i = threadIdx.x; i < current_len; i += blockDim.x) { @@ -412,7 +430,7 @@ _RAFT_DEVICE void last_filter(const T* in_buf, out_idx[pos] = in_idx_buf ? in_idx_buf[i] : i; } else if (bits == kth_value_bits) { IdxT back_pos = atomicAdd(p_out_back_cnt, static_cast(1)); - if (back_pos < needed_num_of_kth) { + if (back_pos < num_of_kth_needed) { IdxT pos = k - 1 - back_pos; out[pos] = value; out_idx[pos] = in_idx_buf ? in_idx_buf[i] : i; @@ -428,8 +446,8 @@ RAFT_KERNEL last_filter_kernel(const T* in, const IdxT* in_idx_buf, T* out, IdxT* out_idx, - IdxT len, - IdxT k, + const IdxT len, + const IdxT k, Counter* counters, const bool select_min) { @@ -454,14 +472,14 @@ RAFT_KERNEL last_filter_kernel(const T* in, constexpr int start_bit = calc_start_bit(pass); const auto kth_value_bits = counter->kth_value_bits; - const IdxT needed_num_of_kth = counter->k; + const IdxT num_of_kth_needed = counter->k; IdxT* p_out_cnt = &counter->out_cnt; IdxT* p_out_back_cnt = &counter->out_back_cnt; auto f = [k, select_min, kth_value_bits, - needed_num_of_kth, + num_of_kth_needed, p_out_cnt, p_out_back_cnt, in_idx_buf, @@ -474,7 +492,7 @@ RAFT_KERNEL last_filter_kernel(const T* in, out_idx[pos] = in_idx_buf ? in_idx_buf[i] : i; } else if (bits == kth_value_bits) { IdxT back_pos = atomicAdd(p_out_back_cnt, static_cast(1)); - if (back_pos < needed_num_of_kth) { + if (back_pos < num_of_kth_needed) { IdxT pos = k - 1 - back_pos; out[pos] = value; out_idx[pos] = in_idx_buf ? in_idx_buf[i] : i; @@ -657,16 +675,35 @@ RAFT_KERNEL radix_kernel(const T* in, } template -int calc_chunk_size(int batch_size, IdxT len, int sm_cnt, Kernel kernel) +int calc_chunk_size(int batch_size, IdxT len, int sm_cnt, Kernel kernel, bool one_block) { int active_blocks; RAFT_CUDA_TRY( cudaOccupancyMaxActiveBlocksPerMultiprocessor(&active_blocks, kernel, BlockSize, 0)); - constexpr int items_per_thread = 32; - constexpr int num_waves = 10; - int chunk_size = - std::max(1, num_waves * sm_cnt * active_blocks * BlockSize * items_per_thread / len); + // The chunk size is chosen so that there is enough workload to fully utilize GPU. + // One full wave contains (sm_cnt * active_blocks) blocks, and 10 waves is an empirically safe + // estimation of enough workload. It also counteracts imbalance if some blocks run slower + // than others. + constexpr int num_waves = 10; + int chunk_size; + if (one_block) { + // For one-block version, one block processes one instance in the chunk. Just ensure that there + // are enough blocks. + chunk_size = num_waves * sm_cnt * active_blocks; + } else { + // One instance in the chunk contains len items and is processed by multiple blocks. + // The total number of items in a chunk (chunk_size * len) should be large enough that every + // thread has enough items to processes. So set it to num_waves * "max num of active threads" + // (sm_cnt * active_blocks * BlockSize) * items_per_thread. + // + // Also, the upper bound of the total number of items in a chunk is: + // 10 (num_waves) * ~100 (sm_cnt) * 2048 (active_blocks*BlockSize) * 32 (items_per_thread) =64M. + // So temporary buffer size required for one chunk won't be too large. + constexpr int items_per_thread = 32; + chunk_size = + std::max(1, num_waves * sm_cnt * active_blocks * BlockSize * items_per_thread / len); + } return std::min(chunk_size, batch_size); } @@ -709,17 +746,17 @@ unsigned calc_grid_dim(int batch_size, IdxT len, int sm_cnt) } template -_RAFT_HOST_DEVICE void set_buf_pointers(const T* in, - const IdxT* in_idx, - T* buf1, - IdxT* idx_buf1, - T* buf2, - IdxT* idx_buf2, - int pass, - const T*& in_buf, - const IdxT*& in_idx_buf, - T*& out_buf, - IdxT*& out_idx_buf) +_RAFT_HOST void set_buf_pointers(const T* in, + const IdxT* in_idx, + T* buf1, + IdxT* idx_buf1, + T* buf2, + IdxT* idx_buf2, + int pass, + const T*& in_buf, + const IdxT*& in_idx_buf, + T*& out_buf, + IdxT*& out_idx_buf) { if (pass == 0) { in_buf = in; @@ -744,6 +781,41 @@ _RAFT_HOST_DEVICE void set_buf_pointers(const T* in, } } +template +_RAFT_DEVICE void set_buf_pointers(const T* in, + const IdxT* in_idx, + char* bufs, + IdxT buf_len, + int pass, + const T*& in_buf, + const IdxT*& in_idx_buf, + T*& out_buf, + IdxT*& out_idx_buf) +{ + // bufs consists of 4 pieces in order: buf1, buf2, idx_buf1, idx_buf2 + if (pass == 0) { + in_buf = in; + in_idx_buf = nullptr; + out_buf = nullptr; + out_idx_buf = nullptr; + } else if (pass == 1) { + in_buf = in; + in_idx_buf = in_idx; + out_buf = reinterpret_cast(bufs); + out_idx_buf = reinterpret_cast(bufs + sizeof(T) * 2 * buf_len); + } else if (pass % 2 == 0) { + in_buf = reinterpret_cast(bufs); + in_idx_buf = reinterpret_cast(bufs + sizeof(T) * 2 * buf_len); + out_buf = const_cast(in_buf + buf_len); + out_idx_buf = const_cast(in_idx_buf + buf_len); + } else { + out_buf = reinterpret_cast(bufs); + out_idx_buf = reinterpret_cast(bufs + sizeof(T) * 2 * buf_len); + in_buf = out_buf + buf_len; + in_idx_buf = out_idx_buf + buf_len; + } +} + template void radix_topk(const T* in, const IdxT* in_idx, @@ -765,7 +837,7 @@ void radix_topk(const T* in, auto kernel = radix_kernel; const size_t max_chunk_size = - calc_chunk_size(batch_size, len, sm_cnt, kernel); + calc_chunk_size(batch_size, len, sm_cnt, kernel, false); if (max_chunk_size != static_cast(batch_size)) { grid_dim = calc_grid_dim(max_chunk_size, len, sm_cnt); } @@ -793,6 +865,7 @@ void radix_topk(const T* in, RAFT_CUDA_TRY( cudaMemsetAsync(counters.data(), 0, counters.size() * sizeof(Counter), stream)); RAFT_CUDA_TRY(cudaMemsetAsync(histograms.data(), 0, histograms.size() * sizeof(IdxT), stream)); + auto kernel = radix_kernel; const T* chunk_in = in + offset * len; const IdxT* chunk_in_idx = in_idx ? (in_idx + offset * len) : nullptr; @@ -866,6 +939,7 @@ _RAFT_DEVICE void filter_and_histogram_for_one_block(const T* in_buf, IdxT* out_idx_buf, T* out, IdxT* out_idx, + const IdxT previous_len, Counter* counter, IdxT* histogram, bool select_min, @@ -879,9 +953,8 @@ _RAFT_DEVICE void filter_and_histogram_for_one_block(const T* in_buf, if (threadIdx.x == 0) { *p_filter_cnt = 0; } __syncthreads(); - const int start_bit = calc_start_bit(pass); - const unsigned mask = calc_mask(pass); - const IdxT previous_len = counter->previous_len; + const int start_bit = calc_start_bit(pass); + const unsigned mask = calc_mask(pass); if (pass == 0) { auto f = [histogram, select_min, start_bit, mask](T value, IdxT) { @@ -889,6 +962,20 @@ _RAFT_DEVICE void filter_and_histogram_for_one_block(const T* in_buf, atomicAdd(histogram + bucket, static_cast(1)); }; vectorized_process(threadIdx.x, blockDim.x, in_buf, previous_len, f); + } else if (!out_buf) { + // not use vectorized_process here because it increases #registers a lot + const auto kth_value_bits = counter->kth_value_bits; + const int previous_start_bit = calc_start_bit(pass - 1); + + for (IdxT i = threadIdx.x; i < previous_len; i += blockDim.x) { + const T value = in_buf[i]; + const auto previous_bits = (twiddle_in(value, select_min) >> previous_start_bit) + << previous_start_bit; + if (previous_bits == kth_value_bits) { + int bucket = calc_bucket(value, start_bit, mask, select_min); + atomicAdd(histogram + bucket, static_cast(1)); + } + } } else { // not use vectorized_process here because it increases #registers a lot IdxT* p_out_cnt = &counter->out_cnt; @@ -927,10 +1014,7 @@ RAFT_KERNEL radix_topk_one_block_kernel(const T* in, T* out, IdxT* out_idx, const bool select_min, - T* buf1, - IdxT* idx_buf1, - T* buf2, - IdxT* idx_buf2) + char* bufs) { constexpr int num_buckets = calc_num_buckets(); __shared__ Counter counter; @@ -951,22 +1035,30 @@ RAFT_KERNEL radix_topk_one_block_kernel(const T* in, if (in_idx) { in_idx += batch_id * len; } out += batch_id * k; out_idx += batch_id * k; - buf1 += batch_id * len; - idx_buf1 += batch_id * len; - buf2 += batch_id * len; - idx_buf2 += batch_id * len; - const T* in_buf = nullptr; - const IdxT* in_idx_buf = nullptr; - T* out_buf = nullptr; - IdxT* out_idx_buf = nullptr; + const IdxT buf_len = calc_buf_len(len); + bufs += batch_id * buf_len * 2 * (sizeof(T) + sizeof(IdxT)); constexpr int num_passes = calc_num_passes(); for (int pass = 0; pass < num_passes; ++pass) { - set_buf_pointers( - in, in_idx, buf1, idx_buf1, buf2, idx_buf2, pass, in_buf, in_idx_buf, out_buf, out_idx_buf); - - IdxT current_len = counter.len; - IdxT current_k = counter.k; + const T* in_buf; + const IdxT* in_idx_buf; + T* out_buf; + IdxT* out_idx_buf; + set_buf_pointers(in, in_idx, bufs, buf_len, pass, in_buf, in_idx_buf, out_buf, out_idx_buf); + + const IdxT current_len = counter.len; + const IdxT current_k = counter.k; + IdxT previous_len = counter.previous_len; + if (previous_len > buf_len) { + in_buf = in; + in_idx_buf = in_idx; + previous_len = len; + } + if (current_len > buf_len) { + // so "out_buf==nullptr" denotes skipping writing buffer in current pass + out_buf = nullptr; + out_idx_buf = nullptr; + } filter_and_histogram_for_one_block(in_buf, in_idx_buf, @@ -974,6 +1066,7 @@ RAFT_KERNEL radix_topk_one_block_kernel(const T* in, out_idx_buf, out, out_idx, + previous_len, &counter, histogram, select_min, @@ -988,11 +1081,11 @@ RAFT_KERNEL radix_topk_one_block_kernel(const T* in, __syncthreads(); if (counter.len == counter.k || pass == num_passes - 1) { - last_filter(pass == 0 ? in : out_buf, - pass == 0 ? in_idx : out_idx_buf, + last_filter(out_buf ? out_buf : in, + out_buf ? out_idx_buf : in_idx, out, out_idx, - current_len, + out_buf ? current_len : len, k, &counter, select_min, @@ -1022,21 +1115,17 @@ void radix_topk_one_block(const T* in, { static_assert(calc_num_passes() > 1); - auto kernel = radix_topk_one_block_kernel; + auto kernel = radix_topk_one_block_kernel; + const IdxT buf_len = calc_buf_len(len); const size_t max_chunk_size = - calc_chunk_size(batch_size, len, sm_cnt, kernel); + calc_chunk_size(batch_size, len, sm_cnt, kernel, true); auto pool_guard = - raft::get_pool_memory_resource(mr, - max_chunk_size * len * 2 * (sizeof(T) + sizeof(IdxT)) + - 256 * 4 // might need extra memory for alignment - ); + raft::get_pool_memory_resource(mr, max_chunk_size * buf_len * 2 * (sizeof(T) + sizeof(IdxT))); if (pool_guard) { RAFT_LOG_DEBUG("radix::select_k: using pool memory resource"); } - rmm::device_uvector buf1(len * max_chunk_size, stream, mr); - rmm::device_uvector idx_buf1(len * max_chunk_size, stream, mr); - rmm::device_uvector buf2(len * max_chunk_size, stream, mr); - rmm::device_uvector idx_buf2(len * max_chunk_size, stream, mr); + rmm::device_uvector bufs( + max_chunk_size * buf_len * 2 * (sizeof(T) + sizeof(IdxT)), stream, mr); for (size_t offset = 0; offset < static_cast(batch_size); offset += max_chunk_size) { int chunk_size = std::min(max_chunk_size, batch_size - offset); @@ -1047,10 +1136,7 @@ void radix_topk_one_block(const T* in, out + offset * k, out_idx + offset * k, select_min, - buf1.data(), - idx_buf1.data(), - buf2.data(), - idx_buf2.data()); + bufs.data()); } } diff --git a/cpp/include/raft/neighbors/cagra_serialize.cuh b/cpp/include/raft/neighbors/cagra_serialize.cuh index 0a806402d2..c801bc9eda 100644 --- a/cpp/include/raft/neighbors/cagra_serialize.cuh +++ b/cpp/include/raft/neighbors/cagra_serialize.cuh @@ -93,6 +93,70 @@ void serialize(raft::resources const& handle, detail::serialize(handle, filename, index, include_dataset); } +/** + * Write the CAGRA built index as a base layer HNSW index to an output stream + * + * Experimental, both the API and the serialization format are subject to change. + * + * @code{.cpp} + * #include + * + * raft::resources handle; + * + * // create an output stream + * std::ostream os(std::cout.rdbuf()); + * // create an index with `auto index = cagra::build(...);` + * raft::serialize_to_hnswlib(handle, os, index); + * @endcode + * + * @tparam T data element type + * @tparam IdxT type of the indices + * + * @param[in] handle the raft handle + * @param[in] os output stream + * @param[in] index CAGRA index + * + */ +template +void serialize_to_hnswlib(raft::resources const& handle, + std::ostream& os, + const index& index) +{ + detail::serialize_to_hnswlib(handle, os, index); +} + +/** + * Write the CAGRA built index as a base layer HNSW index to file + * + * Experimental, both the API and the serialization format are subject to change. + * + * @code{.cpp} + * #include + * + * raft::resources handle; + * + * // create a string with a filepath + * std::string filename("/path/to/index"); + * // create an index with `auto index = cagra::build(...);` + * raft::serialize_to_hnswlib(handle, filename, index); + * @endcode + * + * @tparam T data element type + * @tparam IdxT type of the indices + * + * @param[in] handle the raft handle + * @param[in] filename the file name for saving the index + * @param[in] index CAGRA index + * + */ +template +void serialize_to_hnswlib(raft::resources const& handle, + const std::string& filename, + const index& index) +{ + detail::serialize_to_hnswlib(handle, filename, index); +} + /** * Load index from input stream * diff --git a/cpp/include/raft/neighbors/detail/cagra/cagra_serialize.cuh b/cpp/include/raft/neighbors/detail/cagra/cagra_serialize.cuh index 8261f637e1..51c9475434 100644 --- a/cpp/include/raft/neighbors/detail/cagra/cagra_serialize.cuh +++ b/cpp/include/raft/neighbors/detail/cagra/cagra_serialize.cuh @@ -16,29 +16,23 @@ #pragma once +#include +#include +#include #include +#include #include +#include #include #include #include +#include namespace raft::neighbors::cagra::detail { constexpr int serialization_version = 3; -// NB: we wrap this check in a struct, so that the updated RealSize is easy to see in the error -// message. -template -struct check_index_layout { - static_assert(RealSize == ExpectedSize, - "The size of the index struct has changed since the last update; " - "paste in the new size and consider updating the serialization logic"); -}; - -constexpr size_t expected_size = 200; -template struct check_index_layout), expected_size>; - /** * Save the index to file. * @@ -104,6 +98,129 @@ void serialize(raft::resources const& res, if (!of) { RAFT_FAIL("Error writing output %s", filename.c_str()); } } +template +void serialize_to_hnswlib(raft::resources const& res, + std::ostream& os, + const index& index_) +{ + common::nvtx::range fun_scope("cagra::serialize_to_hnswlib"); + RAFT_LOG_DEBUG("Saving CAGRA index to hnswlib format, size %zu, dim %u", + static_cast(index_.size()), + index_.dim()); + + // offset_level_0 + std::size_t offset_level_0 = 0; + os.write(reinterpret_cast(&offset_level_0), sizeof(std::size_t)); + // max_element + std::size_t max_element = index_.size(); + os.write(reinterpret_cast(&max_element), sizeof(std::size_t)); + // curr_element_count + std::size_t curr_element_count = index_.size(); + os.write(reinterpret_cast(&curr_element_count), sizeof(std::size_t)); + // Example:M: 16, dim = 128, data_t = float, index_t = uint32_t, list_size_type = uint32_t, + // labeltype: size_t size_data_per_element_ = M * 2 * sizeof(index_t) + sizeof(list_size_type) + + // dim * sizeof(data_t) + sizeof(labeltype) + auto size_data_per_element = + static_cast(index_.graph_degree() * 4 + 4 + index_.dim() * 4 + 8); + os.write(reinterpret_cast(&size_data_per_element), sizeof(std::size_t)); + // label_offset + std::size_t label_offset = size_data_per_element - 8; + os.write(reinterpret_cast(&label_offset), sizeof(std::size_t)); + // offset_data + auto offset_data = static_cast(index_.graph_degree() * 4 + 4); + os.write(reinterpret_cast(&offset_data), sizeof(std::size_t)); + // max_level + int max_level = 1; + os.write(reinterpret_cast(&max_level), sizeof(int)); + // entrypoint_node + auto entrypoint_node = static_cast(index_.size() / 2); + os.write(reinterpret_cast(&entrypoint_node), sizeof(int)); + // max_M + auto max_M = static_cast(index_.graph_degree() / 2); + os.write(reinterpret_cast(&max_M), sizeof(std::size_t)); + // max_M0 + std::size_t max_M0 = index_.graph_degree(); + os.write(reinterpret_cast(&max_M0), sizeof(std::size_t)); + // M + auto M = static_cast(index_.graph_degree() / 2); + os.write(reinterpret_cast(&M), sizeof(std::size_t)); + // mult, can be anything + double mult = 0.42424242; + os.write(reinterpret_cast(&mult), sizeof(double)); + // efConstruction, can be anything + std::size_t efConstruction = 500; + os.write(reinterpret_cast(&efConstruction), sizeof(std::size_t)); + + auto dataset = index_.dataset(); + // Remove padding before saving the dataset + auto host_dataset = make_host_matrix(dataset.extent(0), dataset.extent(1)); + RAFT_CUDA_TRY(cudaMemcpy2DAsync(host_dataset.data_handle(), + sizeof(T) * host_dataset.extent(1), + dataset.data_handle(), + sizeof(T) * dataset.stride(0), + sizeof(T) * host_dataset.extent(1), + dataset.extent(0), + cudaMemcpyDefault, + resource::get_cuda_stream(res))); + resource::sync_stream(res); + + auto graph = index_.graph(); + auto host_graph = + raft::make_host_matrix(graph.extent(0), graph.extent(1)); + raft::copy(host_graph.data_handle(), + graph.data_handle(), + graph.size(), + raft::resource::get_cuda_stream(res)); + resource::sync_stream(res); + + // Write one dataset and graph row at a time + for (std::size_t i = 0; i < index_.size(); i++) { + auto graph_degree = static_cast(index_.graph_degree()); + os.write(reinterpret_cast(&graph_degree), sizeof(int)); + + for (std::size_t j = 0; j < index_.graph_degree(); ++j) { + auto graph_elem = host_graph(i, j); + os.write(reinterpret_cast(&graph_elem), sizeof(IdxT)); + } + + auto data_row = host_dataset.data_handle() + (index_.dim() * i); + if constexpr (std::is_same_v) { + for (std::size_t j = 0; j < index_.dim(); ++j) { + auto data_elem = host_dataset(i, j); + os.write(reinterpret_cast(&data_elem), sizeof(T)); + } + } else if constexpr (std::is_same_v or std::is_same_v) { + for (std::size_t j = 0; j < index_.dim(); ++j) { + auto data_elem = static_cast(host_dataset(i, j)); + os.write(reinterpret_cast(&data_elem), sizeof(int)); + } + } + + os.write(reinterpret_cast(&i), sizeof(std::size_t)); + } + + for (std::size_t i = 0; i < index_.size(); i++) { + // zeroes + auto zero = 0; + os.write(reinterpret_cast(&zero), sizeof(int)); + } + // delete [] host_graph; +} + +template +void serialize_to_hnswlib(raft::resources const& res, + const std::string& filename, + const index& index_) +{ + std::ofstream of(filename, std::ios::out | std::ios::binary); + if (!of) { RAFT_FAIL("Cannot open file %s", filename.c_str()); } + + detail::serialize_to_hnswlib(res, of, index_); + + of.close(); + if (!of) { RAFT_FAIL("Error writing output %s", filename.c_str()); } +} + /** Load an index from file. * * Experimental, both the API and the serialization format are subject to change. diff --git a/cpp/include/raft/neighbors/detail/cagra/graph_core.cuh b/cpp/include/raft/neighbors/detail/cagra/graph_core.cuh index 8fcba38883..192850cf2d 100644 --- a/cpp/include/raft/neighbors/detail/cagra/graph_core.cuh +++ b/cpp/include/raft/neighbors/detail/cagra/graph_core.cuh @@ -528,8 +528,9 @@ void optimize(raft::resources const& res, constexpr int _omp_chunk = 1024; #pragma omp parallel for schedule(dynamic, _omp_chunk) for (uint64_t j = 0; j < graph_size; j++) { - for (uint64_t _k = 0; _k < rev_graph_count.data_handle()[j]; _k++) { - uint64_t k = rev_graph_count.data_handle()[j] - 1 - _k; + uint64_t k = std::min(rev_graph_count.data_handle()[j], output_graph_degree); + while (k) { + k--; uint64_t i = rev_graph.data_handle()[k + (output_graph_degree * j)]; uint64_t pos = diff --git a/cpp/include/raft/neighbors/detail/ivf_flat_serialize.cuh b/cpp/include/raft/neighbors/detail/ivf_flat_serialize.cuh index 61a6046273..aaf48ae830 100644 --- a/cpp/include/raft/neighbors/detail/ivf_flat_serialize.cuh +++ b/cpp/include/raft/neighbors/detail/ivf_flat_serialize.cuh @@ -29,24 +29,13 @@ namespace raft::neighbors::ivf_flat::detail { -// Serialization version 3 +// Serialization version // No backward compatibility yet; that is, can't add additional fields without breaking // backward compatibility. // TODO(hcho3) Implement next-gen serializer for IVF that allows for expansion in a backward // compatible fashion. constexpr int serialization_version = 4; -// NB: we wrap this check in a struct, so that the updated RealSize is easy to see in the error -// message. -template -struct check_index_layout { - static_assert(RealSize == ExpectedSize, - "The size of the index struct has changed since the last update; " - "paste in the new size and consider updating the serialization logic"); -}; - -template struct check_index_layout), 328>; - /** * Save the index to file. * diff --git a/cpp/include/raft/neighbors/detail/ivf_pq_serialize.cuh b/cpp/include/raft/neighbors/detail/ivf_pq_serialize.cuh index f01035cad3..038bf8d7cc 100644 --- a/cpp/include/raft/neighbors/detail/ivf_pq_serialize.cuh +++ b/cpp/include/raft/neighbors/detail/ivf_pq_serialize.cuh @@ -38,18 +38,6 @@ namespace raft::neighbors::ivf_pq::detail { // compatible fashion. constexpr int kSerializationVersion = 3; -// NB: we wrap this check in a struct, so that the updated RealSize is easy to see in the error -// message. -template -struct check_index_layout { - static_assert(RealSize == ExpectedSize, - "The size of the index struct has changed since the last update; " - "paste in the new size and consider updating the serialization logic"); -}; - -// TODO: Recompute this and come back to it. -template struct check_index_layout), 480>; - /** * Write the index to an output stream * diff --git a/cpp/scripts/heuristics/select_k/algorithm_selection.ipynb b/cpp/scripts/heuristics/select_k/algorithm_selection.ipynb index 674ce3c906..c56281ef58 100644 --- a/cpp/scripts/heuristics/select_k/algorithm_selection.ipynb +++ b/cpp/scripts/heuristics/select_k/algorithm_selection.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 11, "id": "fbf08b4e-7a91-4c4b-8320-ded040d3f827", "metadata": { "tags": [] @@ -59,63 +59,63 @@ " \n", " \n", " 0\n", - " double\n", + " float\n", " int64_t\n", " kRadix8bits\n", " 1\n", " 1024\n", " 1\n", " 0\n", - " 0\n", - " 0.000050\n", + " 1\n", + " 0.000017\n", " \n", " \n", " 1\n", - " double\n", + " float\n", " int64_t\n", " kRadix11bits\n", " 1\n", " 1024\n", " 1\n", " 0\n", - " 0\n", - " 0.000033\n", + " 1\n", + " 0.000012\n", " \n", " \n", " 2\n", - " double\n", + " float\n", " int64_t\n", " kRadix11bitsExtraPass\n", " 1\n", " 1024\n", " 1\n", " 0\n", - " 0\n", - " 0.000033\n", + " 1\n", + " 0.000012\n", " \n", " \n", " 3\n", - " double\n", + " float\n", " int64_t\n", " kWarpImmediate\n", " 1\n", " 1024\n", " 1\n", " 0\n", - " 0\n", - " 0.000022\n", + " 1\n", + " 0.000009\n", " \n", " \n", " 4\n", - " double\n", + " float\n", " int64_t\n", " kWarpFiltered\n", " 1\n", " 1024\n", " 1\n", " 0\n", - " 0\n", - " 0.000024\n", + " 1\n", + " 0.000010\n", " \n", " \n", " ...\n", @@ -130,101 +130,101 @@ " ...\n", " \n", " \n", - " 179963\n", + " 21405\n", " float\n", - " uint32_t\n", + " int64_t\n", " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", - " 0\n", - " 0.001018\n", + " 1\n", + " 0.000015\n", " \n", " \n", - " 179964\n", + " 21406\n", " float\n", - " uint32_t\n", + " int64_t\n", " kRadix11bitsExtraPass\n", - " 1075\n", - " 2042\n", - " 8175\n", - " 0\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", - " 0.001018\n", + " 1\n", + " 0.000015\n", " \n", " \n", - " 179965\n", + " 21407\n", " float\n", - " uint32_t\n", + " int64_t\n", " kRadix8bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000059\n", + " 0.000030\n", " \n", " \n", - " 179966\n", + " 21408\n", " float\n", - " uint32_t\n", + " int64_t\n", " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000072\n", + " 0.000019\n", " \n", " \n", - " 179967\n", + " 21409\n", " float\n", - " uint32_t\n", + " int64_t\n", " kRadix11bitsExtraPass\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000072\n", + " 0.000019\n", " \n", " \n", "\n", - "

179968 rows × 9 columns

\n", + "

21410 rows × 9 columns

\n", "" ], "text/plain": [ - " key_type index_type algo row col k \\\n", - "0 double int64_t kRadix8bits 1 1024 1 \n", - "1 double int64_t kRadix11bits 1 1024 1 \n", - "2 double int64_t kRadix11bitsExtraPass 1 1024 1 \n", - "3 double int64_t kWarpImmediate 1 1024 1 \n", - "4 double int64_t kWarpFiltered 1 1024 1 \n", - "... ... ... ... ... ... ... \n", - "179963 float uint32_t kRadix11bits 1075 2042 8175 \n", - "179964 float uint32_t kRadix11bitsExtraPass 1075 2042 8175 \n", - "179965 float uint32_t kRadix8bits 1075 2042 8175 \n", - "179966 float uint32_t kRadix11bits 1075 2042 8175 \n", - "179967 float uint32_t kRadix11bitsExtraPass 1075 2042 8175 \n", + " key_type index_type algo row col k \\\n", + "0 float int64_t kRadix8bits 1 1024 1 \n", + "1 float int64_t kRadix11bits 1 1024 1 \n", + "2 float int64_t kRadix11bitsExtraPass 1 1024 1 \n", + "3 float int64_t kWarpImmediate 1 1024 1 \n", + "4 float int64_t kWarpFiltered 1 1024 1 \n", + "... ... ... ... ... ... ... \n", + "21405 float int64_t kRadix11bits 7 1254 7696 \n", + "21406 float int64_t kRadix11bitsExtraPass 7 1254 7696 \n", + "21407 float int64_t kRadix8bits 7 2189 7960 \n", + "21408 float int64_t kRadix11bits 7 2189 7960 \n", + "21409 float int64_t kRadix11bitsExtraPass 7 2189 7960 \n", "\n", - " use_index_input use_memory_pool time \n", - "0 0 0 0.000050 \n", - "1 0 0 0.000033 \n", - "2 0 0 0.000033 \n", - "3 0 0 0.000022 \n", - "4 0 0 0.000024 \n", - "... ... ... ... \n", - "179963 0 0 0.001018 \n", - "179964 0 0 0.001018 \n", - "179965 0 1 0.000059 \n", - "179966 0 1 0.000072 \n", - "179967 0 1 0.000072 \n", + " use_index_input use_memory_pool time \n", + "0 0 1 0.000017 \n", + "1 0 1 0.000012 \n", + "2 0 1 0.000012 \n", + "3 0 1 0.000009 \n", + "4 0 1 0.000010 \n", + "... ... ... ... \n", + "21405 0 1 0.000015 \n", + "21406 0 1 0.000015 \n", + "21407 0 1 0.000030 \n", + "21408 0 1 0.000019 \n", + "21409 0 1 0.000019 \n", "\n", - "[179968 rows x 9 columns]" + "[21410 rows x 9 columns]" ] }, - "execution_count": 1, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 12, "id": "c0d9fed5-35c3-4b0b-987a-973e93e0c59c", "metadata": { "tags": [] @@ -257,7 +257,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 13, "id": "56c5dd8e-6f44-4ef3-b825-1d5a5d6698a2", "metadata": { "tags": [] @@ -266,17 +266,17 @@ { "data": { "text/plain": [ - "[('kRadix11bits', 7267),\n", - " ('kWarpDistributedShm', 6861),\n", - " ('kFaissBlockSelect', 3620),\n", - " ('kRadix8bits', 3229),\n", - " ('kWarpDistributed', 2619),\n", - " ('kWarpImmediate', 2584),\n", - " ('kRadix11bitsExtraPass', 2260),\n", - " ('kWarpFiltered', 490)]" + "[('kWarpDistributedShm', 1157),\n", + " ('kRadix11bits', 1064),\n", + " ('kWarpImmediate', 447),\n", + " ('kRadix11bitsExtraPass', 369),\n", + " ('kFaissBlockSelect', 302),\n", + " ('kWarpDistributed', 42),\n", + " ('kWarpFiltered', 23),\n", + " ('kRadix8bits', 4)]" ] }, - "execution_count": 3, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -288,7 +288,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, "id": "ec63f794-0bdf-4afe-92a8-3fa8ab7a1648", "metadata": { "tags": [] @@ -297,17 +297,17 @@ { "data": { "text/plain": [ - "[('kRadix11bits', 3591),\n", - " ('kWarpDistributedShm', 3589),\n", - " ('kFaissBlockSelect', 2006),\n", - " ('kWarpImmediate', 1552),\n", - " ('kWarpDistributed', 1448),\n", - " ('kRadix11bitsExtraPass', 1338),\n", - " ('kRadix8bits', 460),\n", - " ('kWarpFiltered', 290)]" + "[('kWarpDistributedShm', 1157),\n", + " ('kRadix11bits', 1064),\n", + " ('kWarpImmediate', 447),\n", + " ('kRadix11bitsExtraPass', 369),\n", + " ('kFaissBlockSelect', 302),\n", + " ('kWarpDistributed', 42),\n", + " ('kWarpFiltered', 23),\n", + " ('kRadix8bits', 4)]" ] }, - "execution_count": 7, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -320,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "id": "9b7de19f-ddb6-4fa6-b423-db384428d701", "metadata": { "tags": [] @@ -329,17 +329,10 @@ { "data": { "text/plain": [ - "[('kRadix11bits', 3676),\n", - " ('kWarpDistributedShm', 3272),\n", - " ('kRadix8bits', 2769),\n", - " ('kFaissBlockSelect', 1614),\n", - " ('kWarpDistributed', 1171),\n", - " ('kWarpImmediate', 1032),\n", - " ('kRadix11bitsExtraPass', 922),\n", - " ('kWarpFiltered', 200)]" + "[]" ] }, - "execution_count": 8, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -350,7 +343,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "id": "bc0a10ea-652b-4822-8587-514c8f0348c3", "metadata": { "tags": [] @@ -360,18 +353,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "selected {'kRadix11bits', 'kWarpDistributedShm', 'kFaissBlockSelect'}\n" + "selected {'kWarpImmediate', 'kRadix11bitsExtraPass', 'kRadix11bits', 'kWarpDistributedShm'}\n" ] }, { "data": { "text/plain": [ - "[('kRadix11bits', 12736),\n", - " ('kWarpDistributedShm', 12317),\n", - " ('kFaissBlockSelect', 3877)]" + "[('kWarpDistributedShm', 1266),\n", + " ('kRadix11bits', 1156),\n", + " ('kWarpImmediate', 577),\n", + " ('kRadix11bitsExtraPass', 409)]" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -396,7 +390,7 @@ "algos = set(df.algo)\n", "\n", "# we're arbitrarily getting this down to 3 selection algorithms\n", - "while len(algos) > 3:\n", + "while len(algos) > 4:\n", " times = rank_algos(current, use_relative_speedup=False)\n", " algo, speedup = times[-1]\n", " algos.remove(algo)\n", @@ -408,7 +402,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "028ebbb1-5289-4104-a13c-494c74742087", "metadata": {}, "outputs": [], @@ -417,6 +411,14 @@ "# to pretty consistently show that kRadix11bits / kWarpDistributedShm / kFaissBlockSelect\n", "# all get selected here" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18fb1217-388e-4530-a4f2-eb6bb0dc6e1f", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -435,7 +437,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/cpp/scripts/heuristics/select_k/generate_heuristic.ipynb b/cpp/scripts/heuristics/select_k/generate_heuristic.ipynb index 12b06bdd47..50bc12556a 100644 --- a/cpp/scripts/heuristics/select_k/generate_heuristic.ipynb +++ b/cpp/scripts/heuristics/select_k/generate_heuristic.ipynb @@ -70,8 +70,8 @@ " \n", " \n", " \n", - " 9\n", - " double\n", + " 1\n", + " float\n", " int64_t\n", " kRadix11bits\n", " 1\n", @@ -79,55 +79,55 @@ " 1\n", " 0\n", " 1\n", - " 0.000024\n", + " 0.000012\n", " \n", " \n", - " 14\n", - " double\n", + " 2\n", + " float\n", " int64_t\n", - " kWarpDistributedShm\n", + " kRadix11bitsExtraPass\n", " 1\n", " 1024\n", " 1\n", " 0\n", " 1\n", - " 0.000010\n", + " 0.000012\n", " \n", " \n", - " 15\n", - " double\n", + " 3\n", + " float\n", " int64_t\n", - " kFaissBlockSelect\n", + " kWarpImmediate\n", " 1\n", " 1024\n", " 1\n", " 0\n", " 1\n", - " 0.000005\n", + " 0.000009\n", " \n", " \n", - " 25\n", - " double\n", - " uint32_t\n", - " kRadix11bits\n", + " 6\n", + " float\n", + " int64_t\n", + " kWarpDistributedShm\n", " 1\n", " 1024\n", " 1\n", " 0\n", " 1\n", - " 0.000008\n", + " 0.000010\n", " \n", " \n", - " 30\n", - " double\n", - " uint32_t\n", - " kWarpDistributedShm\n", + " 9\n", + " float\n", + " int64_t\n", + " kRadix11bits\n", " 1\n", - " 1024\n", + " 1838\n", " 1\n", " 0\n", " 1\n", - " 0.000010\n", + " 0.000014\n", " \n", " \n", " ...\n", @@ -142,98 +142,98 @@ " ...\n", " \n", " \n", - " 179942\n", + " 21403\n", " float\n", - " uint32_t\n", - " kRadix11bits\n", - " 7586\n", - " 162460\n", - " 8149\n", + " int64_t\n", + " kRadix11bitsExtraPass\n", + " 10\n", + " 17340\n", + " 7543\n", " 0\n", " 1\n", - " 0.021265\n", + " 0.000053\n", " \n", " \n", - " 179948\n", - " double\n", + " 21405\n", + " float\n", " int64_t\n", " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", " 1\n", - " 0.000317\n", + " 0.000015\n", " \n", " \n", - " 179954\n", - " double\n", - " uint32_t\n", - " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 21406\n", + " float\n", + " int64_t\n", + " kRadix11bitsExtraPass\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", " 1\n", - " 0.000154\n", + " 0.000015\n", " \n", " \n", - " 179960\n", + " 21408\n", " float\n", " int64_t\n", " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000138\n", + " 0.000019\n", " \n", " \n", - " 179966\n", + " 21409\n", " float\n", - " uint32_t\n", - " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " int64_t\n", + " kRadix11bitsExtraPass\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000072\n", + " 0.000019\n", " \n", " \n", "\n", - "

34909 rows × 9 columns

\n", + "

10934 rows × 9 columns

\n", "" ], "text/plain": [ - " key_type index_type algo row col k \\\n", - "9 double int64_t kRadix11bits 1 1024 1 \n", - "14 double int64_t kWarpDistributedShm 1 1024 1 \n", - "15 double int64_t kFaissBlockSelect 1 1024 1 \n", - "25 double uint32_t kRadix11bits 1 1024 1 \n", - "30 double uint32_t kWarpDistributedShm 1 1024 1 \n", - "... ... ... ... ... ... ... \n", - "179942 float uint32_t kRadix11bits 7586 162460 8149 \n", - "179948 double int64_t kRadix11bits 1075 2042 8175 \n", - "179954 double uint32_t kRadix11bits 1075 2042 8175 \n", - "179960 float int64_t kRadix11bits 1075 2042 8175 \n", - "179966 float uint32_t kRadix11bits 1075 2042 8175 \n", + " key_type index_type algo row col k \\\n", + "1 float int64_t kRadix11bits 1 1024 1 \n", + "2 float int64_t kRadix11bitsExtraPass 1 1024 1 \n", + "3 float int64_t kWarpImmediate 1 1024 1 \n", + "6 float int64_t kWarpDistributedShm 1 1024 1 \n", + "9 float int64_t kRadix11bits 1 1838 1 \n", + "... ... ... ... ... ... ... \n", + "21403 float int64_t kRadix11bitsExtraPass 10 17340 7543 \n", + "21405 float int64_t kRadix11bits 7 1254 7696 \n", + "21406 float int64_t kRadix11bitsExtraPass 7 1254 7696 \n", + "21408 float int64_t kRadix11bits 7 2189 7960 \n", + "21409 float int64_t kRadix11bitsExtraPass 7 2189 7960 \n", "\n", - " use_index_input use_memory_pool time \n", - "9 0 1 0.000024 \n", - "14 0 1 0.000010 \n", - "15 0 1 0.000005 \n", - "25 0 1 0.000008 \n", - "30 0 1 0.000010 \n", - "... ... ... ... \n", - "179942 0 1 0.021265 \n", - "179948 0 1 0.000317 \n", - "179954 0 1 0.000154 \n", - "179960 0 1 0.000138 \n", - "179966 0 1 0.000072 \n", + " use_index_input use_memory_pool time \n", + "1 0 1 0.000012 \n", + "2 0 1 0.000012 \n", + "3 0 1 0.000009 \n", + "6 0 1 0.000010 \n", + "9 0 1 0.000014 \n", + "... ... ... ... \n", + "21403 0 1 0.000053 \n", + "21405 0 1 0.000015 \n", + "21406 0 1 0.000015 \n", + "21408 0 1 0.000019 \n", + "21409 0 1 0.000019 \n", "\n", - "[34909 rows x 9 columns]" + "[10934 rows x 9 columns]" ] }, "execution_count": 2, @@ -247,7 +247,7 @@ "\n", "# we're limiting down to 3 different select_k methods - chosen by \n", "# the 'algorithm_selection.ipynb' script here\n", - "df = df[df.algo.isin([\"kRadix11bits\", \"kWarpDistributedShm\", \"kFaissBlockSelect\"])]\n", + "df = df[df.algo.isin(['kWarpImmediate', 'kRadix11bitsExtraPass', 'kRadix11bits', 'kWarpDistributedShm'])]\n", "\n", "# we're also assuming we have a memory pool for now\n", "df = df[(df.use_memory_pool == True)]\n", @@ -267,7 +267,7 @@ { "data": { "text/plain": [ - "((12295, 4), (2170, 4))" + "((2896, 4), (512, 4))" ] }, "execution_count": 3, @@ -294,10 +294,10 @@ { "data": { "text/html": [ - "
DecisionTreeClassifier(max_depth=6, max_leaf_nodes=20)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
DecisionTreeClassifier(max_depth=4, max_leaf_nodes=8)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ - "DecisionTreeClassifier(max_depth=6, max_leaf_nodes=20)" + "DecisionTreeClassifier(max_depth=4, max_leaf_nodes=8)" ] }, "execution_count": 4, @@ -306,7 +306,7 @@ } ], "source": [ - "model = sklearn.tree.DecisionTreeClassifier(max_depth=6, max_leaf_nodes=20)\n", + "model = sklearn.tree.DecisionTreeClassifier(max_depth=4, max_leaf_nodes=8)\n", "model.fit(X_train, y_train) #, weights_train)" ] }, @@ -321,7 +321,7 @@ { "data": { "text/plain": [ - "0.9952052831917203" + "0.9974583860473801" ] }, "execution_count": 5, @@ -344,7 +344,7 @@ { "data": { "text/plain": [ - "0.9998545056217218" + "0.9954595589509098" ] }, "execution_count": 6, @@ -378,7 +378,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -390,7 +390,7 @@ "source": [ "import matplotlib.pyplot as plt\n", "plt.figure(figsize=(12,12))\n", - "viz = sklearn.tree.plot_tree(model, fontsize=8, label='all', class_names=model.classes_, feature_names=[\"k\", \"rows\", \"cols\", \"use_memory_pool\"], impurity=True)" + "viz = sklearn.tree.plot_tree(model, fontsize=8, class_names=list(model.classes_), feature_names=[\"k\", \"rows\", \"cols\", \"use_memory_pool\"], impurity=True)" ] }, { @@ -407,73 +407,29 @@ "text": [ "inline Algo choose_select_k_algorithm(size_t rows, size_t cols, int k)\n", "{\n", - " if (k > 134) {\n", - " if (k > 256) {\n", - " if (k > 809) {\n", - " return Algo::kRadix11bits;\n", - " } else {\n", - " if (rows > 124) {\n", - " if (cols > 63488) {\n", - " return Algo::kFaissBlockSelect;\n", - " } else {\n", - " return Algo::kRadix11bits;\n", - " }\n", - " } else {\n", - " return Algo::kRadix11bits;\n", - " }\n", - " }\n", - " } else {\n", - " if (cols > 678736) {\n", - " return Algo::kWarpDistributedShm;\n", + " if (k > 256) {\n", + " if (cols > 16862) {\n", + " if (rows > 1020) {\n", + " return Algo::kRadix11bitsExtraPass;\n", " } else {\n", " return Algo::kRadix11bits;\n", " }\n", + " } else {\n", + " return Algo::kRadix11bitsExtraPass;\n", " }\n", " } else {\n", - " if (cols > 13776) {\n", - " if (rows > 335) {\n", - " if (k > 1) {\n", - " if (rows > 546) {\n", - " return Algo::kWarpDistributedShm;\n", - " } else {\n", - " if (k > 17) {\n", - " return Algo::kWarpDistributedShm;\n", - " } else {\n", - " return Algo::kFaissBlockSelect;\n", - " }\n", - " }\n", - " } else {\n", - " return Algo::kFaissBlockSelect;\n", - " }\n", + " if (k > 2) {\n", + " if (cols > 22061) {\n", + " return Algo::kWarpDistributedShm;\n", " } else {\n", - " if (k > 44) {\n", - " if (cols > 1031051) {\n", - " return Algo::kWarpDistributedShm;\n", - " } else {\n", - " if (rows > 22) {\n", - " return Algo::kWarpDistributedShm;\n", - " } else {\n", - " return Algo::kRadix11bits;\n", - " }\n", - " }\n", - " } else {\n", - " return Algo::kWarpDistributedShm;\n", - " }\n", - " }\n", - " } else {\n", - " if (k > 1) {\n", - " if (rows > 188) {\n", + " if (rows > 198) {\n", " return Algo::kWarpDistributedShm;\n", " } else {\n", - " if (k > 72) {\n", - " return Algo::kRadix11bits;\n", - " } else {\n", - " return Algo::kWarpDistributedShm;\n", - " }\n", + " return Algo::kWarpImmediate;\n", " }\n", - " } else {\n", - " return Algo::kFaissBlockSelect;\n", " }\n", + " } else {\n", + " return Algo::kWarpImmediate;\n", " }\n", " }\n", "}\n" @@ -539,7 +495,7 @@ { "data": { "text/plain": [ - "6750" + "12388" ] }, "execution_count": 10, @@ -561,6 +517,22 @@ "\n", "open(select_k_path.resolve(), \"w\").write(\"\\n\".join(new_source))" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d1964b89-00f5-4aa1-ad7b-8e17d9f1dc4b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f53d30c8-3b6f-4d3b-acd6-a4f54726f0e0", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -579,7 +551,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/cpp/scripts/heuristics/select_k/generate_plots.ipynb b/cpp/scripts/heuristics/select_k/generate_plots.ipynb index 1ed1f432d3..ffdad58b1c 100644 --- a/cpp/scripts/heuristics/select_k/generate_plots.ipynb +++ b/cpp/scripts/heuristics/select_k/generate_plots.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "id": "0d0564e1-137c-4458-b0b4-d4aa01301942", "metadata": { "tags": [] @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "f91d6f1d-e198-46c8-9ac6-955995f058d1", "metadata": { "tags": [] @@ -60,7 +60,7 @@ " \n", " \n", " \n", - " 40\n", + " 0\n", " float\n", " int64_t\n", " kRadix8bits\n", @@ -69,10 +69,10 @@ " 1\n", " 0\n", " 1\n", - " 0.000024\n", + " 0.000017\n", " \n", " \n", - " 41\n", + " 1\n", " float\n", " int64_t\n", " kRadix11bits\n", @@ -81,10 +81,10 @@ " 1\n", " 0\n", " 1\n", - " 0.000013\n", + " 0.000012\n", " \n", " \n", - " 42\n", + " 2\n", " float\n", " int64_t\n", " kRadix11bitsExtraPass\n", @@ -93,10 +93,10 @@ " 1\n", " 0\n", " 1\n", - " 0.000013\n", + " 0.000012\n", " \n", " \n", - " 43\n", + " 3\n", " float\n", " int64_t\n", " kWarpImmediate\n", @@ -108,7 +108,7 @@ " 0.000009\n", " \n", " \n", - " 44\n", + " 4\n", " float\n", " int64_t\n", " kWarpFiltered\n", @@ -132,101 +132,101 @@ " ...\n", " \n", " \n", - " 179936\n", + " 21405\n", " float\n", " int64_t\n", " kRadix11bits\n", - " 7586\n", - " 162460\n", - " 8149\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", " 1\n", - " 0.104029\n", + " 0.000015\n", " \n", " \n", - " 179937\n", + " 21406\n", " float\n", " int64_t\n", " kRadix11bitsExtraPass\n", - " 7586\n", - " 162460\n", - " 8149\n", + " 7\n", + " 1254\n", + " 7696\n", " 0\n", " 1\n", - " 0.104047\n", + " 0.000015\n", " \n", " \n", - " 179959\n", + " 21407\n", " float\n", " int64_t\n", " kRadix8bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000201\n", + " 0.000030\n", " \n", " \n", - " 179960\n", + " 21408\n", " float\n", " int64_t\n", " kRadix11bits\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000138\n", + " 0.000019\n", " \n", " \n", - " 179961\n", + " 21409\n", " float\n", " int64_t\n", " kRadix11bitsExtraPass\n", - " 1075\n", - " 2042\n", - " 8175\n", + " 7\n", + " 2189\n", + " 7960\n", " 0\n", " 1\n", - " 0.000138\n", + " 0.000019\n", " \n", " \n", "\n", - "

22913 rows × 9 columns

\n", + "

21410 rows × 9 columns

\n", "" ], "text/plain": [ - " key_type index_type algo row col k \\\n", - "40 float int64_t kRadix8bits 1 1024 1 \n", - "41 float int64_t kRadix11bits 1 1024 1 \n", - "42 float int64_t kRadix11bitsExtraPass 1 1024 1 \n", - "43 float int64_t kWarpImmediate 1 1024 1 \n", - "44 float int64_t kWarpFiltered 1 1024 1 \n", - "... ... ... ... ... ... ... \n", - "179936 float int64_t kRadix11bits 7586 162460 8149 \n", - "179937 float int64_t kRadix11bitsExtraPass 7586 162460 8149 \n", - "179959 float int64_t kRadix8bits 1075 2042 8175 \n", - "179960 float int64_t kRadix11bits 1075 2042 8175 \n", - "179961 float int64_t kRadix11bitsExtraPass 1075 2042 8175 \n", + " key_type index_type algo row col k \\\n", + "0 float int64_t kRadix8bits 1 1024 1 \n", + "1 float int64_t kRadix11bits 1 1024 1 \n", + "2 float int64_t kRadix11bitsExtraPass 1 1024 1 \n", + "3 float int64_t kWarpImmediate 1 1024 1 \n", + "4 float int64_t kWarpFiltered 1 1024 1 \n", + "... ... ... ... ... ... ... \n", + "21405 float int64_t kRadix11bits 7 1254 7696 \n", + "21406 float int64_t kRadix11bitsExtraPass 7 1254 7696 \n", + "21407 float int64_t kRadix8bits 7 2189 7960 \n", + "21408 float int64_t kRadix11bits 7 2189 7960 \n", + "21409 float int64_t kRadix11bitsExtraPass 7 2189 7960 \n", "\n", - " use_index_input use_memory_pool time \n", - "40 0 1 0.000024 \n", - "41 0 1 0.000013 \n", - "42 0 1 0.000013 \n", - "43 0 1 0.000009 \n", - "44 0 1 0.000010 \n", - "... ... ... ... \n", - "179936 0 1 0.104029 \n", - "179937 0 1 0.104047 \n", - "179959 0 1 0.000201 \n", - "179960 0 1 0.000138 \n", - "179961 0 1 0.000138 \n", + " use_index_input use_memory_pool time \n", + "0 0 1 0.000017 \n", + "1 0 1 0.000012 \n", + "2 0 1 0.000012 \n", + "3 0 1 0.000009 \n", + "4 0 1 0.000010 \n", + "... ... ... ... \n", + "21405 0 1 0.000015 \n", + "21406 0 1 0.000015 \n", + "21407 0 1 0.000030 \n", + "21408 0 1 0.000019 \n", + "21409 0 1 0.000019 \n", "\n", - "[22913 rows x 9 columns]" + "[21410 rows x 9 columns]" ] }, - "execution_count": 5, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -241,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "id": "e1b124af-1630-4139-a1e7-ed9ea96c384d", "metadata": { "tags": [] @@ -275,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 4, "id": "13742a23-09a2-4ca1-aeb9-8e3914c7fc4d", "metadata": { "tags": [] @@ -283,7 +283,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -298,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "id": "8401ef27-8733-4ab3-a561-e915a783a196", "metadata": { "tags": [] @@ -306,7 +306,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -344,7 +344,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/dependencies.yaml b/dependencies.yaml index aba81d7ed9..419cd0c22e 100644 --- a/dependencies.yaml +++ b/dependencies.yaml @@ -436,16 +436,14 @@ dependencies: common: - output_types: [conda, pyproject] packages: - - dask>=2023.9.2 - dask-cuda==23.12.* - - distributed>=2023.9.2 - joblib>=0.11 - numba>=0.57 - *numpy + - rapids-dask-dependency==23.12.* - ucx-py==0.35.* - output_types: conda packages: - - dask-core>=2023.9.2 - ucx>=1.13.0 - ucx-proc=*=gpu - &ucx_py_conda ucx-py==0.35.* diff --git a/docs/source/ann_benchmarks_param_tuning.md b/docs/source/ann_benchmarks_param_tuning.md index cdc7958714..4c95b9e520 100644 --- a/docs/source/ann_benchmarks_param_tuning.md +++ b/docs/source/ann_benchmarks_param_tuning.md @@ -46,7 +46,7 @@ IVF-pq is an inverted-file index, which partitions the vectors into a series of ### `raft_cagra` -CAGRA uses a graph-based index, which creates an intermediate, approximate kNN graph using IVF-PQ and then further refining and optimizing to create a final kNN graph. This kNN graph is used by CAGRA as an index for search. +CAGRA uses a graph-based index, which creates an intermediate, approximate kNN graph using IVF-PQ and then further refining and optimizing to create a final kNN graph. This kNN graph is used by CAGRA as an index for search. | Parameter | Type | Required | Data Type | Default | Description | |-----------------------------|----------------|----------|----------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| @@ -83,6 +83,13 @@ Alternatively, if `graph_build_algo == "NN_DESCENT"`, then we can customize the | `nn_descent_max_iterations` | `build_param` | N | Positive Integer>0 | 20 | Alias for `nn_descent_niter` | | `nn_descent_termination_threshold` | `build_param` | N | Positive float>0 | 0.0001 | Termination threshold for NN descent. | +### `raft_cagra_hnswlib` +This is a benchmark that enables interoperability between `CAGRA` built `HNSW` search. It uses the `CAGRA` built graph as the base layer of an `hnswlib` index to search queries only within the base layer (this is enabled with a simple patch to `hnswlib`). + +`build_param` : Same as `build_param` of [CAGRA](#raft-cagra) + +`search_param` : Same as `search_param` of [hnswlib](#hnswlib) + ## FAISS Indexes ### `faiss_gpu_flat` @@ -152,7 +159,7 @@ Use FAISS IVF-PQ index on CPU ## HNSW - + ### `hnswlib` | Parameter | Type | Required | Data Type | Default | Description | diff --git a/python/raft-ann-bench/src/raft-ann-bench/data_export/__main__.py b/python/raft-ann-bench/src/raft-ann-bench/data_export/__main__.py index fd6c2077e7..4978c99d60 100644 --- a/python/raft-ann-bench/src/raft-ann-bench/data_export/__main__.py +++ b/python/raft-ann-bench/src/raft-ann-bench/data_export/__main__.py @@ -52,9 +52,15 @@ def read_file(dataset, dataset_path, method): for file in os.listdir(dir): if file.endswith(".json"): with open(os.path.join(dir, file), "r") as f: - data = json.load(f) - df = pd.DataFrame(data["benchmarks"]) - yield (os.path.join(dir, file), file.split("-")[0], df) + try: + data = json.load(f) + df = pd.DataFrame(data["benchmarks"]) + yield os.path.join(dir, file), file.split("-")[0], df + except Exception as e: + print( + "An error occurred processing file %s (%s). " + "Skipping..." % (file, e) + ) def convert_json_to_csv_build(dataset, dataset_path): @@ -114,7 +120,7 @@ def convert_json_to_csv_search(dataset, dataset_path): write["build cpu_time"] = None write["build GPU"] = None - for col_idx in range(5, len(build_df.columns)): + for col_idx in range(6, len(build_df.columns)): col_name = build_df.columns[col_idx] write[col_name] = None diff --git a/python/raft-ann-bench/src/raft-ann-bench/run/algos.yaml b/python/raft-ann-bench/src/raft-ann-bench/run/algos.yaml index 7ea360e0c9..e382bdcba6 100644 --- a/python/raft-ann-bench/src/raft-ann-bench/run/algos.yaml +++ b/python/raft-ann-bench/src/raft-ann-bench/run/algos.yaml @@ -37,3 +37,6 @@ ggnn: hnswlib: executable: HNSWLIB_ANN_BENCH requires_gpu: false +raft_cagra_hnswlib: + executable: RAFT_CAGRA_HNSWLIB_ANN_BENCH + requires_gpu: true diff --git a/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra.yaml b/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra.yaml index 0f80608eef..d8015da5c6 100644 --- a/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra.yaml +++ b/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra.yaml @@ -10,8 +10,3 @@ groups: search: itopk: [32, 64, 128, 256, 512] search_width: [1, 2, 4, 8, 16, 32, 64] - - - - - diff --git a/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra_hnswlib.yaml b/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra_hnswlib.yaml new file mode 100644 index 0000000000..787675d65d --- /dev/null +++ b/python/raft-ann-bench/src/raft-ann-bench/run/conf/algos/raft_cagra_hnswlib.yaml @@ -0,0 +1,11 @@ +name: raft_cagra_hnswlib +constraints: + search: raft-ann-bench.constraints.hnswlib_search_constraints +groups: + base: + build: + graph_degree: [32, 64, 128, 256] + intermediate_graph_degree: [32, 64, 96, 128] + graph_build_algo: ["NN_DESCENT"] + search: + ef: [10, 20, 40, 60, 80, 120, 200, 400, 600, 800] diff --git a/python/raft-ann-bench/src/raft-ann-bench/run/conf/datasets.yaml b/python/raft-ann-bench/src/raft-ann-bench/run/conf/datasets.yaml index a2b948a464..be63e1d535 100644 --- a/python/raft-ann-bench/src/raft-ann-bench/run/conf/datasets.yaml +++ b/python/raft-ann-bench/src/raft-ann-bench/run/conf/datasets.yaml @@ -107,7 +107,7 @@ - name: wiki_all_1M dims: 768 - base_file: wiki_all_1M/base.1MM.fbin + base_file: wiki_all_1M/base.1M.fbin query_file: wiki_all_1M/queries.fbin groundtruth_neighbors_file: wiki_all_1M/groundtruth.1M.neighbors.ibin distance: euclidean diff --git a/python/raft-dask/pyproject.toml b/python/raft-dask/pyproject.toml index 7abb6231a1..be030f839d 100644 --- a/python/raft-dask/pyproject.toml +++ b/python/raft-dask/pyproject.toml @@ -35,12 +35,11 @@ license = { text = "Apache 2.0" } requires-python = ">=3.9" dependencies = [ "dask-cuda==23.12.*", - "dask>=2023.9.2", - "distributed>=2023.9.2", "joblib>=0.11", "numba>=0.57", "numpy>=1.21", "pylibraft==23.12.*", + "rapids-dask-dependency==23.12.*", "ucx-py==0.35.*", ] # This list was generated by `rapids-dependency-file-generator`. To make changes, edit ../../dependencies.yaml and run `rapids-dependency-file-generator`. classifiers = [