[SVS] SVS API and functionality update

cmake/svs.cmake

@@ -12,12 +12,7 @@ if(uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG")
     set(SVS_NO_AVX512 ON)
 endif()
 
-if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "(x86_64)|(AMD64|amd64)")
-    set(SVS_SUPPORTED 1)
-else()
-    set(SVS_SUPPORTED 0)
-    message(STATUS "SVS is not supported on this architecture")
-endif()
+set(SVS_SUPPORTED 1)
 
 # GCC < v11 does not support C++20 features required for SVS
 # https://gcc.gnu.org/projects/cxx-status.html
@@ -39,6 +34,13 @@ if(USE_SVS)
     # Configure SVS build
     add_compile_definitions("HAVE_SVS=1")
 
+    if(${CMAKE_SYSTEM_PROCESSOR} MATCHES "(x86_64)|(AMD64|amd64)")
+        set(SVS_LVQ_SUPPORTED 1)
+    else()
+        set(SVS_LVQ_SUPPORTED 0)
+        message(STATUS "SVS LVQ is not supported on this architecture")
+    endif()
+
     # detect if build environment is using glibc
     include(CheckSymbolExists)
     unset(GLIBC_FOUND CACHE)
@@ -47,8 +49,8 @@ if(USE_SVS)
         message(STATUS "GLIBC is not detected - SVS shared library is not supported")
     endif()
 
-    cmake_dependent_option(SVS_SHARED_LIB "Use SVS pre-compiled shared library" ON "USE_SVS AND GLIBC_FOUND" OFF)
-    set(SVS_URL "https://github.com/intel/ScalableVectorSearch/releases/download/v0.0.8-dev/svs-shared-library-0.0.8-NIGHTLY-20250505.tar.gz" CACHE STRING "SVS URL")
+    cmake_dependent_option(SVS_SHARED_LIB "Use SVS pre-compiled shared library" ON "USE_SVS AND GLIBC_FOUND AND SVS_LVQ_SUPPORTED" OFF)
+    set(SVS_URL "https://github.com/intel/ScalableVectorSearch/releases/download/v0.0.8-dev/svs-shared-library-0.0.8-NIGHTLY-254.tar.gz" CACHE STRING "SVS URL")
 
     if(SVS_SHARED_LIB)
         include(FetchContent)
@@ -71,7 +73,7 @@ if(USE_SVS)
         set(SVS_LVQ_HEADER "svs/quantization/lvq/impl/lvq_impl.h")
     endif()
 
-    if(EXISTS "${svs_SOURCE_DIR}/include/${SVS_LVQ_HEADER}")
+    if(SVS_LVQ_SUPPORTED AND EXISTS "${svs_SOURCE_DIR}/include/${SVS_LVQ_HEADER}")
         message("SVS LVQ implementation found")
         add_compile_definitions(VectorSimilarity PUBLIC "HAVE_SVS_LVQ=1" PUBLIC "SVS_LVQ_HEADER=\"${SVS_LVQ_HEADER}\"")
     else()

src/VecSim/algorithms/svs/svs.h

@@ -19,6 +19,7 @@
 #include <vector>
 
 #include "svs/index/vamana/dynamic_index.h"
+#include "spdlog/sinks/callback_sink.h"
 
 #include "VecSim/algorithms/svs/svs_utils.h"
 #include "VecSim/algorithms/svs/svs_batch_iterator.h"
@@ -28,6 +29,9 @@
     virtual ~SVSIndexBase() = default;
     virtual int addVectors(const void *vectors_data, const labelType *labels, size_t n) = 0;
     virtual int deleteVectors(const labelType *labels, size_t n) = 0;
+#ifdef BUILD_TESTS
+    virtual svs::logging::logger_ptr getLogger() const = 0;
+#endif
 };
 
 template <typename MetricType, typename DataType, size_t QuantBits, size_t ResidualBits,
@@ -65,7 +69,7 @@
     // SVS Index implementation instance
     std::unique_ptr<impl_type> impl_;
 
-    static float toVecSimDistance(float v) { return svs_details::toVecSimDistance<distance_f>(v); }
+    static double toVecSimDistance(float v) { return svs_details::toVecSimDistance<distance_f>(v); }
 
     template <typename T, typename U>
     static T getOrDefault(T v, U def) {
@@ -109,12 +113,51 @@
         // clang-format on
     }
 
+    svs::logging::logger_ptr makeLogger() {
+        spdlog::custom_log_callback callback = [this](const spdlog::details::log_msg &msg) {
+            if (!VecSimIndexInterface::logCallback) {
+                return; // No callback function provided
+            }
+            // Custom callback implementation
+            const char *vecsim_level = [msg]() {
+                switch (msg.level) {
+                case spdlog::level::trace:
+                    return VecSimCommonStrings::LOG_DEBUG_STRING;
+                case spdlog::level::debug:
+                    return VecSimCommonStrings::LOG_VERBOSE_STRING;
+                case spdlog::level::info:
+                    return VecSimCommonStrings::LOG_NOTICE_STRING;
+                case spdlog::level::warn:
+                case spdlog::level::err:
+                case spdlog::level::critical:
+                    return VecSimCommonStrings::LOG_WARNING_STRING;
+                default:
+                    return "UNKNOWN";
+                }
+            }();
+
+            std::string msg_str{msg.payload.data(), msg.payload.size()};
+            // Log the message using the custom callback
+            VecSimIndexInterface::logCallback(this->logCallbackCtx, vecsim_level, msg_str.c_str());
+        };
+
+        // Create a logger with the custom callback
+        auto sink = std::make_shared<spdlog::sinks::callback_sink_mt>(callback);
+        auto logger = std::make_shared<spdlog::logger>("SVSIndex", sink);
+        // Sink all messages to VecSim
+        logger->set_level(spdlog::level::trace);
+        return logger;
+    }
+
     // Create SVS index instance with initial data
     // Data should not be empty
     template <svs::data::ImmutableMemoryDataset Dataset>
     void initImpl(const Dataset &points, std::span<const labelType> ids) {
         VecSimSVSThreadPool threadpool;
         svs::threads::ThreadPoolHandle threadpool_handle{VecSimSVSThreadPool{threadpool}};
+
+        auto logger = makeLogger();
+
         // Construct SVS index initial storage with compression if needed
         auto data = storage_traits_t::create_storage(points, this->blockSize, threadpool_handle,
                                                      this->getAllocator());
@@ -129,11 +172,12 @@
         // Construct initial Vamana Graph
         auto graph =
             graph_builder_t::build_graph(parameters, data, distance, threadpool, entry_point,
-                                         this->blockSize, this->getAllocator());
+                                         this->blockSize, this->getAllocator(), logger);
 
         // Create SVS MutableIndex instance
-        impl_ = std::make_unique<impl_type>(std::move(graph), std::move(data), entry_point,
-                                            std::move(distance), ids, std::move(threadpool));
+        impl_ =
+            std::make_unique<impl_type>(std::move(graph), std::move(data), entry_point,
+                                        std::move(distance), ids, std::move(threadpool), logger);
 
         // Set SVS MutableIndex build parameters to be used in future updates
         impl_->set_construction_window_size(parameters.window_size);
@@ -361,7 +405,8 @@
         rep->results.reserve(n_neighbors);
 
         for (size_t i = 0; i < n_neighbors; i++) {
-            rep->results.emplace_back(result.index(0, i), toVecSimDistance(result.distance(0, i)));
+            rep->results.push_back(
+                VecSimQueryResult{result.index(0, i), toVecSimDistance(result.distance(0, i))});
         }
         return rep;
     }
@@ -388,13 +433,11 @@
         // SVS BatchIterator handles the search in batches
         // The batch size is set to the index search window size by default
         const size_t batch_size = sp.buffer_config_.get_search_window_size();
-        auto schedule = svs::index::vamana::DefaultSchedule{sp, batch_size};
 
         // Create SVS BatchIterator for range search
-        // SVS BatchIterator executes first batch of search at construction
         // Search result is cached in the iterator and can be accessed by the user
-        svs::index::vamana::BatchIterator<impl_type, data_type> svs_it{*impl_, query, schedule,
-                                                                       cancel};
+        svs::index::vamana::BatchIterator<impl_type, data_type> svs_it{*impl_, query};
+        svs_it.next(batch_size, cancel);
         if (cancel()) {
             rep->code = VecSim_QueryReply_TimedOut;
             return rep;
@@ -414,15 +457,15 @@
             for (auto &neighbor : svs_it) {
                 const auto dist = toVecSimDistance(neighbor.distance());
                 if (dist <= radius) {
-                    rep->results.emplace_back(neighbor.id(), dist);
+                    rep->results.push_back(VecSimQueryResult{neighbor.id(), dist});
                 } else if (dist > range_search_boundaries) {
                     keep_searching = false;
                 }
             }
             // If search radius + epsilon is not exceeded, request SVS BatchIterator for the next
             // batch
             if (keep_searching) {
-                svs_it.next(cancel);
+                svs_it.next(batch_size, cancel);
                 if (cancel()) {
                     rep->code = VecSim_QueryReply_TimedOut;
                     return rep;
@@ -481,13 +524,17 @@
 #ifdef BUILD_TESTS
     void fitMemory() override {}
     std::vector<std::vector<char>> getStoredVectorDataByLabel(labelType label) const override {
-        assert(nullptr && "Not implemented");
+        assert(false && "Not implemented");
         return {};
     }
     void getDataByLabel(
         labelType label,
         std::vector<std::vector<svs_details::vecsim_dt<DataType>>> &vectors_output) const override {
-        assert(nullptr && "Not implemented");
+        assert(false && "Not implemented");
+    }
+
+    svs::logging::logger_ptr getLogger() const override {
+        return impl_ ? impl_->get_logger() : nullptr;
     }
 #endif
 };

src/VecSim/algorithms/svs/svs_batch_iterator.h

@@ -24,26 +24,12 @@
 private:
     using impl_type = svs::index::vamana::BatchIterator<Index, DataType>;
     using dist_type = typename Index::distance_type;
+    bool done;
     size_t dim;
+    const Index *index_; // Pointer to the index, used for reset and other operations.
     std::unique_ptr<impl_type> impl_;
-    decltype(impl_->begin()) curr_it;
-
-    static std::unique_ptr<impl_type> makeImpl(const Index *index, void *query_vector,
-                                               VecSimQueryParams *queryParams) {
-        auto sp = svs_details::joinSearchParams(index->get_search_parameters(), queryParams);
-        const size_t batch_size = queryParams && queryParams->batchSize
-                                      ? queryParams->batchSize
-                                      : sp.buffer_config_.get_search_window_size();
-        // Base search parameters for the iterator schedule.
-        auto schedule = svs::index::vamana::DefaultSchedule{sp, batch_size};
-        std::span<const DataType> query{reinterpret_cast<DataType *>(query_vector),
-                                        index->dimensions()};
-
-        auto timeoutCtx = queryParams ? queryParams->timeoutCtx : nullptr;
-        auto cancel = [timeoutCtx]() { return VECSIM_TIMEOUT(timeoutCtx); };
-        return std::make_unique<svs::index::vamana::BatchIterator<Index, DataType>>(
-            *index, query, schedule, cancel);
-    }
+    typename impl_type::const_iterator curr_it;
+    size_t batch_size;
 
     VecSimQueryReply *getNextResultsImpl(size_t n_res) {
         auto rep = new VecSimQueryReply(this->allocator);
@@ -56,16 +42,19 @@
             return rep;
         }
 
+        const auto bs = std::max(n_res, batch_size);
+
         for (size_t i = 0; i < n_res; i++) {
             if (curr_it == impl_->end()) {
-                impl_->next(cancel);
+                impl_->next(bs, cancel);
                 if (cancel()) {
                     rep->code = VecSim_QueryReply_TimedOut;
                     rep->results.clear();
                     return rep;
                 }
                 curr_it = impl_->begin();
                 if (impl_->size() == 0) {
+                    this->done = true;
                     return rep;
                 }
             }
@@ -77,12 +66,18 @@
     }
 
 public:
-    SVS_BatchIterator(void *query_vector, const Index *index, VecSimQueryParams *queryParams,
+    SVS_BatchIterator(void *query_vector, const Index *index, const VecSimQueryParams *queryParams,
                       std::shared_ptr<VecSimAllocator> allocator)
         : VecSimBatchIterator{query_vector, queryParams ? queryParams->timeoutCtx : nullptr,
                               std::move(allocator)},
-          dim{index->dimensions()}, impl_{makeImpl(index, query_vector, queryParams)} {
-        curr_it = impl_->begin();
+          done{false}, dim{index->dimensions()}, index_{index},
+          impl_{std::make_unique<impl_type>(*index_,
+                                            std::span{static_cast<DataType *>(query_vector), dim})},
+          curr_it{impl_->begin()} {
+        auto sp = svs_details::joinSearchParams(index->get_search_parameters(), queryParams);
+        batch_size = queryParams && queryParams->batchSize
+                         ? queryParams->batchSize
+                         : sp.buffer_config_.get_search_window_size();
     }
 
     VecSimQueryReply *getNextResults(size_t n_res, VecSimQueryReply_Order order) override {
@@ -92,23 +87,21 @@
         return rep;
     }
 
-    bool isDepleted() override { return curr_it == impl_->end() && impl_->done(); }
+    bool isDepleted() override { return curr_it == impl_->end() && (this->done || impl_->done()); }
 
     void reset() override {
-        std::span<const DataType> query{reinterpret_cast<const DataType *>(this->getQueryBlob()),
-                                        dim};
-        auto timeoutCtx = this->getTimeoutCtx();
-        auto cancel = [timeoutCtx]() { return VECSIM_TIMEOUT(timeoutCtx); };
-        impl_->update(query, cancel);
+        impl_.reset(new impl_type{
+            *index_, std::span{static_cast<const DataType *>(this->getQueryBlob()), dim}});
         curr_it = impl_->begin();
+        this->done = false;
     }
 };
 
 // Empty index iterator
 class NullSVS_BatchIterator : public VecSimBatchIterator {
 private:
 public:
-    NullSVS_BatchIterator(void *query_vector, VecSimQueryParams *queryParams,
+    NullSVS_BatchIterator(void *query_vector, const VecSimQueryParams *queryParams,
                           std::shared_ptr<VecSimAllocator> allocator)
         : VecSimBatchIterator{query_vector, queryParams ? queryParams->timeoutCtx : nullptr,
                               allocator} {}

src/VecSim/algorithms/svs/svs_extensions.h

@@ -9,11 +9,58 @@
 
 #pragma once
 #include "VecSim/algorithms/svs/svs_utils.h"
+#include "svs/extensions/vamana/scalar.h"
 
 #if HAVE_SVS_LVQ
 #include SVS_LVQ_HEADER
 #include "svs/extensions/vamana/leanvec.h"
+#endif // HAVE_SVS_LVQ
+
+// Scalar Quantization traits for SVS
+template <typename DataType>
+struct SVSStorageTraits<DataType, 1, 0, false> {
+    using element_type = std::int8_t;
+    using allocator_type = svs_details::SVSAllocator<element_type>;
+    using blocked_type = svs::data::Blocked<svs::AllocatorHandle<element_type>>;
+    using index_storage_type =
+        svs::quantization::scalar::SQDataset<element_type, svs::Dynamic, blocked_type>;
+
+    template <svs::data::ImmutableMemoryDataset Dataset, svs::threads::ThreadPool Pool>
+    static index_storage_type create_storage(const Dataset &data, size_t block_size, Pool &pool,
+                                             std::shared_ptr<VecSimAllocator> allocator) {
+        const auto dim = data.dimensions();
+        auto svs_bs = svs_details::SVSBlockSize(block_size, element_size(dim));
+
+        allocator_type data_allocator{std::move(allocator)};
+        auto blocked_alloc = svs::make_blocked_allocator_handle({svs_bs}, data_allocator);
+
+        return index_storage_type::compress(data, pool, blocked_alloc);
+    }
+
+    static constexpr size_t element_size(size_t dims, size_t alignment = 0) {
+        return dims * sizeof(element_type);
+    }
+
+    static size_t storage_capacity(const index_storage_type &storage) {
+        // SQDataset does not provide a capacity method
+        return storage.size();
+    }
+
+    template <typename Distance, typename E, size_t N>
+    static float compute_distance_by_id(const index_storage_type &storage, const Distance &distance,
+                                        size_t id, std::span<E, N> query) {
+        auto dist_f = svs::index::vamana::extensions::single_search_setup(storage, distance);
+
+        // SVS distance function may require to fix/pre-process one of arguments
+        svs::distance::maybe_fix_argument(dist_f, query);
 
+        // Get the datum from the storage using the storage ID
+        auto datum = storage.get_datum(id);
+        return svs::distance::compute(dist_f, query, datum);
+    }
+};
+
+#if HAVE_SVS_LVQ
 namespace svs_details {
 template <size_t Primary>
 struct LVQSelector {
@@ -29,7 +76,7 @@ struct LVQSelector<4> {
 // LVQDataset traits for SVS
 template <typename DataType, size_t QuantBits, size_t ResidualBits>
 struct SVSStorageTraits<DataType, QuantBits, ResidualBits, false,
-                        std::enable_if_t<(QuantBits > 0)>> {
+                        std::enable_if_t<(QuantBits > 1)>> {
     using allocator_type = svs_details::SVSAllocator<std::byte>;
     using blocked_type = svs::data::Blocked<svs::AllocatorHandle<std::byte>>;
     using strategy_type = typename svs_details::LVQSelector<QuantBits>::strategy;