MOD-15578 Track shared SVS thread pool memory & expose it through public API

src/VecSim/algorithms/svs/svs.h

@@ -361,8 +361,8 @@ class SVSIndex : public VecSimIndexAbstract<svs_details::vecsim_dt<DataType>, fl
           leanvec_dim{
               svs_details::getOrDefault(params.leanvec_dim, SVS_VAMANA_DEFAULT_LEANVEC_DIM)},
           epsilon{svs_details::getOrDefault(params.epsilon, SVS_VAMANA_DEFAULT_EPSILON)},
-          is_two_level_lvq{isTwoLevelLVQ(params.quantBits)}, threadpool_{this->logCallbackCtx},
-          impl_{nullptr} {
+          is_two_level_lvq{isTwoLevelLVQ(params.quantBits)},
+          threadpool_{this->allocator, this->logCallbackCtx}, impl_{nullptr} {
         logger_ = makeLogger();
         if (params.num_threads != 0) {
             this->log(VecSimCommonStrings::LOG_WARNING_STRING,
@@ -429,8 +429,14 @@ class SVSIndex : public VecSimIndexAbstract<svs_details::vecsim_dt<DataType>, fl
 
     VecSimDebugInfoIterator *debugInfoIterator() const override {
         VecSimIndexDebugInfo info = this->debugInfo();
-        // For readability. Update this number when needed.
-        size_t numberOfInfoFields = 23;
+        // Capacity hint: 26 = 25 fields added below (1 ALGORITHM + 9 from
+        // addCommonInfoToIterator + 15 SVS-specific) + 1 for the SHARED_MEMORY field
+        // that the C API wrapper VecSimIndex_DebugInfoIterator appends after this
+        // method returns. Reserving the extra slot avoids a reallocation on the
+        // top-level path; when nested in a tiered BACKEND_INDEX the C API does not
+        // append it, so the hint over-reserves by one (harmless).
+        // Update this number when fields are added or removed.
+        size_t numberOfInfoFields = 26;
         VecSimDebugInfoIterator *infoIterator =
             new VecSimDebugInfoIterator(numberOfInfoFields, this->allocator);
 

src/VecSim/algorithms/svs/svs_utils.h

@@ -10,6 +10,7 @@
 #pragma once
 #include "VecSim/query_results.h"
 #include "VecSim/vec_sim_interface.h"
+#include "VecSim/utils/vecsim_stl.h"
 #include "VecSim/types/float16.h"
 
 #include "svs/core/distance.h"
@@ -407,35 +408,71 @@ class VecSimSVSThreadPoolImpl {
         std::vector<ThreadSlot *> slots_;
     };
 
+    using SlotPtr = std::shared_ptr<ThreadSlot>;
+
     // Create a pool with `num_threads` total parallelism (including the calling thread).
     // Spawns `num_threads - 1` worker OS threads. num_threads must be >= 1.
     // In write-in-place mode, the pool is created with num_threads == 1 (0 worker threads,
     // only the calling thread participates).
     // Private — use instance() to access the shared singleton.
-    explicit VecSimSVSThreadPoolImpl(size_t num_threads = 1) {
+    explicit VecSimSVSThreadPoolImpl(size_t num_threads = 1)
+        : allocator_(VecSimAllocator::newVecsimAllocator()), slots_(allocator_) {
         assert(num_threads && "VecSimSVSThreadPoolImpl should not be created with 0 threads");
         slots_.reserve(num_threads - 1);
         for (size_t i = 0; i < num_threads - 1; ++i) {
-            slots_.push_back(std::make_shared<ThreadSlot>());
+            slots_.push_back(
+                std::allocate_shared<ThreadSlot>(VecsimSTLAllocator<ThreadSlot>(allocator_)));
         }
     }
 
+    // Set to true the first time instance() constructs the singleton. Allows other
+    // code paths (e.g., global stats reporting) to query whether the pool has been
+    // touched without forcing its lazy construction.
+    static std::atomic<bool> &initialized_flag() {
+        static std::atomic<bool> flag{false};
+        return flag;
+    }
+
 public:
     // Singleton accessor for the shared SVS thread pool.
     // Always valid — initialized with size 1 (write-in-place mode: 0 worker threads,
     // only the calling thread participates). Resized on VecSim_UpdateThreadPoolSize() calls.
     static std::shared_ptr<VecSimSVSThreadPoolImpl> instance() {
-        static auto shared_pool = std::shared_ptr<VecSimSVSThreadPoolImpl>(
-            new VecSimSVSThreadPoolImpl(1), [](VecSimSVSThreadPoolImpl *) { /* leak at exit */ });
+        static auto shared_pool = [] {
+            auto p = std::shared_ptr<VecSimSVSThreadPoolImpl>(
+                new VecSimSVSThreadPoolImpl(1),
+                [](VecSimSVSThreadPoolImpl *) { /* leak at exit */ });
+            initialized_flag().store(true, std::memory_order_release);
+            return p;
+        }();
         return shared_pool;
     }
 
+    // Returns true iff instance() has ever been called (singleton constructed).
+    static bool isInitialized() { return initialized_flag().load(std::memory_order_acquire); }
+
     // Total parallelism: worker slots + 1 (the calling thread always participates).
     size_t size() const {
         std::lock_guard lock{pool_mutex_};
         return slots_.size() + 1;
     }
 
+    // Bytes currently allocated through the pool's internal allocator (the slots vector
+    // and the ThreadSlot objects). Does not include allocations performed by SVS itself
+    // outside of the pool, nor per-index wrapper state.
+    size_t getAllocationSize() const { return allocator_->getAllocationSize(); }
+
+    // Bytes allocated by the shared pool singleton. Returns 0 if the singleton has
+    // never been constructed (e.g., no SVS index was ever created and
+    // VecSim_UpdateThreadPoolSize was never called). Safe to call from any context;
+    // does not force singleton construction.
+    static size_t getSharedAllocationSize() {
+        if (!isInitialized()) {
+            return 0;
+        }
+        return instance()->getAllocationSize();
+    }
+
     // Physically resize the pool. Creates new OS threads on grow, shuts down idle threads
     // on shrink. new_size is total parallelism including the calling thread (minimum 1).
     // Occupied threads (held by renters) survive shrink via the deferred-resize protocol —
@@ -599,7 +636,8 @@ class VecSimSVSThreadPoolImpl {
             // Grow (or same size): apply immediately, cancel any pending deferred shrink.
             deferred_size_.reset();
             for (size_t i = slots_.size(); i < target_workers; ++i) {
-                slots_.push_back(std::make_shared<ThreadSlot>());
+                slots_.push_back(
+                    std::allocate_shared<ThreadSlot>(VecsimSTLAllocator<ThreadSlot>(allocator_)));
             }
         } else {
             // Shrink.
@@ -615,8 +653,9 @@ class VecSimSVSThreadPoolImpl {
         }
     }
 
+    std::shared_ptr<VecSimAllocator> allocator_; // pool's own allocator for memory tracking
     mutable std::mutex pool_mutex_;
-    std::vector<std::shared_ptr<ThreadSlot>> slots_;
+    vecsim_stl::vector<SlotPtr> slots_;
     size_t pending_jobs_ = 0;             // jobs currently scheduled / in-flight
     std::optional<size_t> deferred_size_; // resize target deferred until pending_jobs_ == 0
 };
@@ -646,9 +685,14 @@ class VecSimSVSThreadPool {
     // parallelism_ starts at 1 (the calling thread always participates), matching the
     // pool's minimum size. Safe for immediate use in write-in-place mode without an
     // explicit setParallelism() call.
-    explicit VecSimSVSThreadPool(void *log_ctx = nullptr)
+    // parallelism_ is allocated through the provided VecsimAllocator so that the
+    // allocation is tracked by the index's memory accounting.
+    explicit VecSimSVSThreadPool(const std::shared_ptr<VecSimAllocator> &allocator,
+                                 void *log_ctx = nullptr)
         : pool_(VecSimSVSThreadPoolImpl::instance()),
-          parallelism_(std::make_shared<std::atomic<size_t>>(1)), log_ctx_(log_ctx) {}
+          parallelism_(std::allocate_shared<std::atomic<size_t>>(
+              VecsimSTLAllocator<std::atomic<size_t>>(allocator), size_t{1})),
+          log_ctx_(log_ctx) {}
 
     // Resize the shared pool singleton. Delegates to VecSimSVSThreadPoolImpl::instance().
     static void resize(size_t new_size) { VecSimSVSThreadPoolImpl::instance()->resize(new_size); }
@@ -677,6 +721,11 @@ class VecSimSVSThreadPool {
     // Shared pool size — used by scheduling to decide how many reserve jobs to submit.
     static size_t poolSize() { return VecSimSVSThreadPoolImpl::instance()->size(); }
 
+    // See VecSimSVSThreadPoolImpl::getSharedAllocationSize().
+    static size_t getSharedAllocationSize() {
+        return VecSimSVSThreadPoolImpl::getSharedAllocationSize();
+    }
+
     // Delegates to the shared pool's parallel_for, passing the per-index log context.
     // n may be less than parallelism_ when the problem size is smaller than the
     // thread count (SVS computes n = min(arg.size(), pool.size())).

src/VecSim/index_factories/svs_factory.cpp

@@ -13,13 +13,30 @@
 #include "VecSim/memory/vecsim_malloc.h"
 #include "VecSim/vec_sim_index.h"
 #include "VecSim/algorithms/svs/svs.h"
+#include "VecSim/algorithms/svs/svs_utils.h"
 #include "VecSim/index_factories/components/components_factory.h"
 #include "VecSim/index_factories/factory_utils.h"
+#include <atomic>
 
 namespace SVSFactory {
 
 namespace {
 
+// Bytes consumed by the per-index VecSimSVSThreadPool::parallelism_ allocation
+// (a std::allocate_shared<std::atomic<size_t>> through the index's allocator).
+// The exact size of the inplace shared_ptr control block is implementation-defined,
+// so measure the allocation delta once at startup against a throwaway VecSimAllocator.
+size_t getThreadPoolParallelismAllocationSize() {
+    static const size_t size = []() {
+        auto allocator = VecSimAllocator::newVecsimAllocator();
+        size_t before = allocator->getAllocationSize();
+        [[maybe_unused]] auto p = std::allocate_shared<std::atomic<size_t>>(
+            VecsimSTLAllocator<std::atomic<size_t>>(allocator), size_t{1});
+        return allocator->getAllocationSize() - before;
+    }();
+    return size;
+}
+
 // NewVectorsImpl() is the chain of a template helper functions to create a new SVS index.
 template <typename MetricType, typename DataType, size_t QuantBits, size_t ResidualBits,
           bool IsLeanVec>
@@ -230,6 +247,9 @@ size_t EstimateInitialSize(const SVSParams *params, bool is_normalized) {
     est += EstimateSVSIndexSize(params);
     est += EstimateComponentsMemorySVS(params->type, params->metric, is_normalized);
     est += sizeof(DataBlocksContainer) + allocations_overhead;
+    // Per-index VecSimSVSThreadPool::parallelism_ allocation tracked through
+    // the index's VecSimAllocator (see VecSimSVSThreadPool ctor).
+    est += getThreadPoolParallelismAllocationSize();
     return est;
 }
 

src/VecSim/utils/vec_utils.cpp

@@ -89,6 +89,8 @@ const char *VecSimCommonStrings::TIERED_SVS_UPDATE_THRESHOLD_STRING = "TIERED_SV
 const char *VecSimCommonStrings::TIERED_SVS_THREADS_RESERVE_TIMEOUT_STRING =
     "TIERED_SVS_THREADS_RESERVE_TIMEOUT";
 
+const char *VecSimCommonStrings::SHARED_MEMORY_STRING = "SHARED_MEMORY";
+
 // Log levels
 const char *VecSimCommonStrings::LOG_DEBUG_STRING = "debug";
 const char *VecSimCommonStrings::LOG_VERBOSE_STRING = "verbose";

src/VecSim/utils/vec_utils.h

@@ -87,6 +87,11 @@ struct VecSimCommonStrings {
     static const char *TIERED_SVS_UPDATE_THRESHOLD_STRING;
     static const char *TIERED_SVS_THREADS_RESERVE_TIMEOUT_STRING;
 
+    // Process-wide VecSim allocations not tied to any single index (e.g. the
+    // shared SVS thread-pool allocation). Appended by VecSimIndex_DebugInfoIterator
+    // (C API) to every algorithm's response. Does NOT include per-index memory.
+    static const char *SHARED_MEMORY_STRING;
+
     // Log levels
     static const char *LOG_DEBUG_STRING;
     static const char *LOG_VERBOSE_STRING;

src/VecSim/vec_sim.cpp

@@ -379,7 +379,20 @@ extern "C" VecSimIndexDebugInfo VecSimIndex_DebugInfo(VecSimIndex *index) {
 }
 
 extern "C" VecSimDebugInfoIterator *VecSimIndex_DebugInfoIterator(VecSimIndex *index) {
-    return index->debugInfoIterator();
+    VecSimDebugInfoIterator *infoIterator = index->debugInfoIterator();
+    // Append the process-wide shared memory total. This field is not emitted by
+    // any algorithm's own debugInfoIterator(); it is injected here at the C API
+    // boundary so that every caller (regardless of algorithm) can account for
+    // memory not tied to any single index without special-casing SVS internals.
+    infoIterator->addInfoField(
+        VecSim_InfoField{.fieldName = VecSimCommonStrings::SHARED_MEMORY_STRING,
+                         .fieldType = INFOFIELD_UINT64,
+                         .fieldValue = {FieldValue{.uintegerValue = VecSim_GetSharedMemory()}}});
+    return infoIterator;
+}
+
+extern "C" size_t VecSim_GetSharedMemory(void) {
+    return VecSimSVSThreadPool::getSharedAllocationSize();
 }
 
 extern "C" VecSimIndexBasicInfo VecSimIndex_BasicInfo(VecSimIndex *index) {

src/VecSim/vec_sim.h

@@ -322,6 +322,14 @@ void VecSim_SetWriteMode(VecSimWriteMode mode);
  */
 void VecSim_UpdateThreadPoolSize(size_t new_size);
 
+/**
+ * @brief Return the total bytes of process-wide VecSim allocations that are NOT tied to any
+ *        single index (e.g. the shared SVS thread-pool allocation).
+ *        This does NOT include per-index memory; use VecSimIndex_Info() for per-index accounting.
+ * @return Process-wide shared VecSim allocation size in bytes.
+ */
+size_t VecSim_GetSharedMemory(void);
+
 #ifdef __cplusplus
 }
 #endif

src/VecSim/vec_sim_common.h

@@ -355,7 +355,10 @@ typedef struct {
  * production without worrying about performance
  */
 typedef struct {
-    size_t memory;
+    size_t memory;                // Memory tracked by the index's own allocator. Does NOT include
+                                  // process-wide allocations such as the shared SVS thread pool;
+                                  // those are reported via VecSim_GetSharedMemory() so callers
+                                  // that aggregate across indexes don't double-count them.
     size_t numberOfMarkedDeleted; // The number of vectors that are marked as deleted (HNSW/tiered
                                   // only).
     size_t directHNSWInsertions;  // Count of vectors inserted directly into HNSW by main thread

tests/unit/test_hnsw_tiered.cpp

@@ -2936,7 +2936,9 @@ TYPED_TEST(HNSWTieredIndexTest, testInfoIterator) {
     VecSimIndexDebugInfo frontendIndexInfo = tiered_index->frontendIndex->debugInfo();
     VecSimIndexDebugInfo backendIndexInfo = tiered_index->backendIndex->debugInfo();
 
-    VecSimDebugInfoIterator *infoIterator = tiered_index->debugInfoIterator();
+    // Use the C API wrapper (as RediSearch does) so the process-wide SHARED_MEMORY
+    // field is appended at the top level — compareTieredIndexInfoToIterator expects it.
+    VecSimDebugInfoIterator *infoIterator = VecSimIndex_DebugInfoIterator(tiered_index);
     compareTieredIndexInfoToIterator(info, frontendIndexInfo, backendIndexInfo, infoIterator);
 
     VecSimDebugInfoIterator_Free(infoIterator);

tests/unit/test_svs.cpp

@@ -3362,6 +3362,72 @@ TEST(SVSTest, NumThreadsParamIgnored) {
     VecSimIndexInterface::logCallback = nullptr;
 }
 
+// The SHARED_MEMORY field is a top-level field appended by
+// VecSimIndex_DebugInfoIterator (mirrors VecSim_GetSharedMemory()); it is
+// present on every algorithm. Verify it appears exactly once in an SVS
+// response and reports the same bytes as the public API.
+TYPED_TEST(SVSTest, debugInfoSharedMemoryMatchesApi) {
+    // Ensure the shared SVS thread pool singleton has allocated memory so the
+    // field reports a non-zero value. resize() always lazy-initializes the singleton.
+    VecSim_UpdateThreadPoolSize(2);
+    ASSERT_GT(VecSim_GetSharedMemory(), 0u);
+
+    size_t dim = 4;
+    SVSParams params = {.type = TypeParam::get_index_type(), .dim = dim, .metric = VecSimMetric_L2};
+    VecSimIndex *index = this->CreateNewIndex(params);
+    ASSERT_INDEX(index);
+
+    VecSimDebugInfoIterator *infoIterator = VecSimIndex_DebugInfoIterator(index);
+
+    bool seen_shared_memory = false;
+    uint64_t shared_memory_value = 0;
+    while (VecSimDebugInfoIterator_HasNextField(infoIterator)) {
+        VecSim_InfoField *f = VecSimDebugInfoIterator_NextField(infoIterator);
+        if (!strcmp(f->fieldName, VecSimCommonStrings::SHARED_MEMORY_STRING)) {
+            ASSERT_FALSE(seen_shared_memory) << "SHARED_MEMORY appears more than once";
+            ASSERT_EQ(f->fieldType, INFOFIELD_UINT64);
+            shared_memory_value = f->fieldValue.uintegerValue;
+            seen_shared_memory = true;
+        }
+    }
+    EXPECT_TRUE(seen_shared_memory) << "SHARED_MEMORY field missing from SVS debug info";
+    EXPECT_EQ(shared_memory_value, VecSim_GetSharedMemory());
+
+    VecSimDebugInfoIterator_Free(infoIterator);
+    VecSimIndex_Free(index);
+
+    // Reset the shared singleton pool to size 1 so the next test is not affected.
+    // Use VecSimSVSThreadPool::resize(1) directly (matching other thread-pool tests)
+    // to avoid the write-mode side effect that VecSim_UpdateThreadPoolSize(0) carries.
+    VecSimSVSThreadPool::resize(1);
+}
+
+// VecSim shared memory must actually track the SVS thread-pool allocation:
+// it grows when the pool grows and shrinks when the pool shrinks. Without this,
+// SHARED_MEMORY could be a constant and debugInfoSharedMemoryMatchesApi would
+// still pass (both readouts share the same getSharedAllocationSize() source).
+TYPED_TEST(SVSTest, sharedMemoryTracksThreadPoolResize) {
+    // Use the C API to ensure it is covered. VecSim_UpdateThreadPoolSize(0)
+    // sets WriteInPlace and pool size 1.
+    VecSim_UpdateThreadPoolSize(0);
+    size_t mem_baseline = VecSim_GetSharedMemory();
+
+    // Grow the pool (sets WriteAsync).
+    VecSim_UpdateThreadPoolSize(8);
+    ASSERT_EQ(VecSimSVSThreadPool::poolSize(), 8u);
+    size_t mem_8 = VecSim_GetSharedMemory();
+    EXPECT_GT(mem_8, mem_baseline) << "shared memory must grow when the pool grows";
+
+    // Shrink back to size 1 (still WriteAsync).
+    VecSim_UpdateThreadPoolSize(1);
+    ASSERT_EQ(VecSimSVSThreadPool::poolSize(), 1u);
+    size_t mem_after = VecSim_GetSharedMemory();
+    EXPECT_LT(mem_after, mem_8) << "shared memory must shrink when the pool shrinks";
+
+    // Restore to default baseline.
+    VecSim_UpdateThreadPoolSize(0);
+}
+
 #else // HAVE_SVS
 
 TEST(SVSTest, svs_not_supported) {