Class faiss::IndexReplicasTemplate

template<typename IndexT> class IndexReplicasTemplate : public faiss::ThreadedIndex<IndexT>

Takes individual faiss::Index instances, and splits queries for sending to each Index instance, and joins the results together when done. Each index is managed by a separate CPU thread.

Public Types

using component_t = typename IndexT::component_t

using distance_t = typename IndexT::distance_t

Public Functions

explicit IndexReplicasTemplate(bool threaded = true)

The dimension that all sub-indices must share will be the dimension of the first sub-index added

Parameters:: threaded – do we use one thread per sub-index or do queries sequentially?

explicit IndexReplicasTemplate(idx_t d, bool threaded = true)

Parameters:

d – the dimension that all sub-indices must share
threaded – do we use one thread per sub index or do queries sequentially?

explicit IndexReplicasTemplate(int d, bool threaded = true): int version due to the implicit bool conversion ambiguity of int as dimension

inline void add_replica(IndexT *index): Alias for addIndex()

inline void remove_replica(IndexT *index): Alias for removeIndex()

void train(idx_t n, const component_t *x) override: faiss::Index API All indices receive the same call

void add(idx_t n, const component_t *x) override: faiss::Index API All indices receive the same call

void search(idx_t n, const component_t *x, idx_t k, distance_t *distances, idx_t *labels, const SearchParameters *params = nullptr) const override: faiss::Index API Query is partitioned into a slice for each sub-index split by ceil(n / #indices) for our sub-indices

void reconstruct(idx_t, component_t *v) const override: reconstructs from the first index

void syncWithSubIndexes(): Synchronize the top-level index (IndexShards) with data in the sub-indices

virtual void addIndex(IndexT *index): override an index that is managed by ourselves. WARNING: once an index is added, it becomes unsafe to touch it from any other thread than that on which is managing it, until we are shut down. Use runOnIndex to perform work on it instead.

void removeIndex(IndexT *index): Remove an index that is managed by ourselves. This will flush all pending work on that index, and then shut down its managing thread, and will remove the index.

void runOnIndex(std::function<void(int, IndexT*)> f): Run a function on all indices, in the thread that the index is managed in. Function arguments are (index in collection, index pointer)

void runOnIndex(std::function<void(int, const IndexT*)> f) const

void reset() override: faiss::Index API All indices receive the same call

inline int count() const: Returns the number of sub-indices.

inline IndexT *at(size_t i): Returns the i-th sub-index.

inline const IndexT *at(size_t i) const: Returns the i-th sub-index (const version)

Public Members

bool own_indices = false: Whether or not we are responsible for deleting our contained indices.

Protected Functions

virtual void onAfterAddIndex(IndexT *index) override: Called just after an index is added.

virtual void onAfterRemoveIndex(IndexT *index) override: Called just after an index is removed.

Protected Attributes

std::vector<std::pair<IndexT*, std::unique_ptr<WorkerThread>>> indices_: Collection of Index instances, with their managing worker thread if any.

bool isThreaded_: Is this index multi-threaded?

Protected Static Functions

static void waitAndHandleFutures(std::vector<std::future<bool>> &v)