faiss 0.2.6 → 0.2.7

data/vendor/faiss/faiss/gpu/GpuIndexBinaryFlat.h

@@ -53,37 +53,37 @@ class GpuIndexBinaryFlat : public IndexBinary {
     /// in the index instance
     void copyTo(faiss::IndexBinaryFlat* index) const;
 
-    void add(faiss::IndexBinary::idx_t n, const uint8_t* x) override;
+    void add(faiss::idx_t n, const uint8_t* x) override;
 
     void reset() override;
 
     void search(
-            faiss::IndexBinary::idx_t n,
+            idx_t n,
             const uint8_t* x,
-            faiss::IndexBinary::idx_t k,
+            // faiss::IndexBinary has idx_t for k
+            idx_t k,
             int32_t* distances,
-            faiss::IndexBinary::idx_t* labels,
+            faiss::idx_t* labels,
             const faiss::SearchParameters* params = nullptr) const override;
 
-    void reconstruct(faiss::IndexBinary::idx_t key, uint8_t* recons)
-            const override;
+    void reconstruct(faiss::idx_t key, uint8_t* recons) const override;
 
    protected:
     /// Called from search when the input data is on the CPU;
     /// potentially allows for pinned memory usage
     void searchFromCpuPaged_(
-            int n,
+            idx_t n,
             const uint8_t* x,
             int k,
             int32_t* outDistancesData,
-            int* outIndicesData) const;
+            idx_t* outIndicesData) const;
 
     void searchNonPaged_(
-            int n,
+            idx_t n,
             const uint8_t* x,
             int k,
             int32_t* outDistancesData,
-            int* outIndicesData) const;
+            idx_t* outIndicesData) const;
 
    protected:
     /// Manages streans, cuBLAS handles and scratch memory for devices

data/vendor/faiss/faiss/gpu/GpuIndexFlat.h

@@ -82,33 +82,32 @@ class GpuIndexFlat : public GpuIndex {
     void reset() override;
 
     /// This index is not trained, so this does nothing
-    void train(Index::idx_t n, const float* x) override;
+    void train(idx_t n, const float* x) override;
 
     /// Overrides to avoid excessive copies
-    void add(Index::idx_t, const float* x) override;
+    void add(idx_t, const float* x) override;
 
     /// Reconstruction methods; prefer the batch reconstruct as it will
     /// be more efficient
-    void reconstruct(Index::idx_t key, float* out) const override;
+    void reconstruct(idx_t key, float* out) const override;
 
     /// Batch reconstruction method
-    void reconstruct_n(Index::idx_t i0, Index::idx_t num, float* out)
-            const override;
+    void reconstruct_n(idx_t i0, idx_t num, float* out) const override;
 
     /// Batch reconstruction method
-    void reconstruct_batch(Index::idx_t n, const Index::idx_t* keys, float* out)
+    void reconstruct_batch(idx_t n, const idx_t* keys, float* out)
             const override;
 
     /// Compute residual
-    void compute_residual(const float* x, float* residual, Index::idx_t key)
+    void compute_residual(const float* x, float* residual, idx_t key)
             const override;
 
     /// Compute residual (batch mode)
     void compute_residual_n(
-            Index::idx_t n,
+            idx_t n,
             const float* xs,
             float* residuals,
-            const Index::idx_t* keys) const override;
+            const idx_t* keys) const override;
 
     /// For internal access
     inline FlatIndex* getGpuData() {
@@ -121,15 +120,15 @@ class GpuIndexFlat : public GpuIndex {
     bool addImplRequiresIDs_() const override;
 
     /// Called from GpuIndex for add
-    void addImpl_(int n, const float* x, const Index::idx_t* ids) override;
+    void addImpl_(idx_t n, const float* x, const idx_t* ids) override;
 
     /// Called from GpuIndex for search
     void searchImpl_(
-            int n,
+            idx_t n,
             const float* x,
             int k,
             float* distances,
-            Index::idx_t* labels,
+            idx_t* labels,
             const SearchParameters* params) const override;
 
    protected:

data/vendor/faiss/faiss/gpu/GpuIndexIVF.h

@@ -33,7 +33,7 @@ struct GpuIndexIVFConfig : public GpuIndexConfig {
 /// Base class of all GPU IVF index types. This (for now) deliberately does not
 /// inherit from IndexIVF, as many of the public data members and functionality
 /// in IndexIVF is not supported in the same manner on the GPU.
-class GpuIndexIVF : public GpuIndex {
+class GpuIndexIVF : public GpuIndex, public IndexIVFInterface {
    public:
     /// Version that auto-constructs a flat coarse quantizer based on the
     /// desired metric
@@ -42,7 +42,7 @@ class GpuIndexIVF : public GpuIndex {
             int dims,
             faiss::MetricType metric,
             float metricArg,
-            int nlist,
+            idx_t nlist,
             GpuIndexIVFConfig config = GpuIndexIVFConfig());
 
     /// Version that takes a coarse quantizer instance. The GpuIndexIVF does not
@@ -53,7 +53,7 @@ class GpuIndexIVF : public GpuIndex {
             int dims,
             faiss::MetricType metric,
             float metricArg,
-            int nlist,
+            idx_t nlist,
             GpuIndexIVFConfig config = GpuIndexIVFConfig());
 
     ~GpuIndexIVF() override;
@@ -75,10 +75,10 @@ class GpuIndexIVF : public GpuIndex {
     virtual void updateQuantizer() = 0;
 
     /// Returns the number of inverted lists we're managing
-    int getNumLists() const;
+    idx_t getNumLists() const;
 
     /// Returns the number of vectors present in a particular inverted list
-    int getListLength(int listId) const;
+    idx_t getListLength(idx_t listId) const;
 
     /// Return the encoded vector data contained in a particular inverted list,
     /// for debugging purposes.
@@ -86,34 +86,13 @@ class GpuIndexIVF : public GpuIndex {
     /// GPU-side representation.
     /// Otherwise, it is converted to the CPU format.
     /// compliant format, while the native GPU format may differ.
-    std::vector<uint8_t> getListVectorData(int listId, bool gpuFormat = false)
+    std::vector<uint8_t> getListVectorData(idx_t listId, bool gpuFormat = false)
             const;
 
     /// Return the vector indices contained in a particular inverted list, for
     /// debugging purposes.
-    std::vector<Index::idx_t> getListIndices(int listId) const;
-
-    /// Sets the number of list probes per query
-    void setNumProbes(int nprobe);
-
-    /// Returns our current number of list probes per query
-    int getNumProbes() const;
-
-    /// Same interface as faiss::IndexIVF, in order to search a set of vectors
-    /// pre-quantized by the IVF quantizer. Does not include IndexIVFStats as
-    /// that can only be obtained on the host via a GPU d2h copy.
-    /// @param n      nb of vectors to query
-    /// @param x      query vectors, size nx * d
-    /// @param assign coarse quantization indices, size nx * nprobe
-    /// @param centroid_dis
-    ///             distances to coarse centroids, size nx * nprobe
-    /// @param distance
-    ///             output distances, size n * k
-    /// @param labels output labels, size n * k
-    /// @param store_pairs store inv list index + inv list offset
-    ///                   instead in upper/lower 32 bit of result,
-    ///                   instead of ids (used for reranking).
-    /// @param params used to override the object's search parameters
+    std::vector<idx_t> getListIndices(idx_t listId) const;
+
     void search_preassigned(
             idx_t n,
             const float* x,
@@ -123,41 +102,41 @@ class GpuIndexIVF : public GpuIndex {
             float* distances,
             idx_t* labels,
             bool store_pairs,
-            const SearchParametersIVF* params = nullptr) const;
+            const SearchParametersIVF* params = nullptr,
+            IndexIVFStats* stats = nullptr) const override;
+
+    // not implemented for GPU
+    void range_search_preassigned(
+            idx_t nx,
+            const float* x,
+            float radius,
+            const idx_t* keys,
+            const float* coarse_dis,
+            RangeSearchResult* result,
+            bool store_pairs = false,
+            const IVFSearchParameters* params = nullptr,
+            IndexIVFStats* stats = nullptr) const override;
 
    protected:
+    /// From either the current set nprobe or the SearchParameters if available,
+    /// return the nprobe that we should use for the current search
+    int getCurrentNProbe_(const SearchParameters* params) const;
     void verifyIVFSettings_() const;
     bool addImplRequiresIDs_() const override;
-    void trainQuantizer_(Index::idx_t n, const float* x);
+    void trainQuantizer_(idx_t n, const float* x);
 
     /// Called from GpuIndex for add/add_with_ids
-    void addImpl_(int n, const float* x, const Index::idx_t* ids) override;
+    void addImpl_(idx_t n, const float* x, const idx_t* ids) override;
 
     /// Called from GpuIndex for search
     void searchImpl_(
-            int n,
+            idx_t n,
             const float* x,
             int k,
             float* distances,
-            Index::idx_t* labels,
+            idx_t* labels,
             const SearchParameters* params) const override;
 
-   public:
-    /// Exposing this like the CPU version for manipulation
-    ClusteringParameters cp;
-
-    /// Exposing this like the CPU version for query
-    int nlist;
-
-    /// Exposing this like the CPU version for manipulation
-    int nprobe;
-
-    /// A user-pluggable coarse quantizer
-    Index* quantizer;
-
-    /// Whether or not we own the coarse quantizer
-    bool own_fields;
-
    protected:
     /// Our configuration options
     const GpuIndexIVFConfig ivfConfig_;

data/vendor/faiss/faiss/gpu/GpuIndexIVFFlat.h

@@ -44,7 +44,7 @@ class GpuIndexIVFFlat : public GpuIndexIVF {
     GpuIndexIVFFlat(
             GpuResourcesProvider* provider,
             int dims,
-            int nlist,
+            idx_t nlist,
             faiss::MetricType metric = faiss::METRIC_L2,
             GpuIndexIVFFlatConfig config = GpuIndexIVFFlatConfig());
 
@@ -54,7 +54,7 @@ class GpuIndexIVFFlat : public GpuIndexIVF {
             GpuResourcesProvider* provider,
             Index* coarseQuantizer,
             int dims,
-            int nlist,
+            idx_t nlist,
             faiss::MetricType metric = faiss::METRIC_L2,
             GpuIndexIVFFlatConfig config = GpuIndexIVFFlatConfig());
 
@@ -85,7 +85,7 @@ class GpuIndexIVFFlat : public GpuIndexIVF {
     void updateQuantizer() override;
 
     /// Trains the coarse quantizer based on the given vector data
-    void train(Index::idx_t n, const float* x) override;
+    void train(idx_t n, const float* x) override;
 
    protected:
     /// Our configuration options

data/vendor/faiss/faiss/gpu/GpuIndexIVFPQ.h

@@ -68,9 +68,9 @@ class GpuIndexIVFPQ : public GpuIndexIVF {
     GpuIndexIVFPQ(
             GpuResourcesProvider* provider,
             int dims,
-            int nlist,
-            int subQuantizers,
-            int bitsPerCode,
+            idx_t nlist,
+            idx_t subQuantizers,
+            idx_t bitsPerCode,
             faiss::MetricType metric = faiss::METRIC_L2,
             GpuIndexIVFPQConfig config = GpuIndexIVFPQConfig());
 
@@ -80,9 +80,9 @@ class GpuIndexIVFPQ : public GpuIndexIVF {
             GpuResourcesProvider* provider,
             Index* coarseQuantizer,
             int dims,
-            int nlist,
-            int subQuantizers,
-            int bitsPerCode,
+            idx_t nlist,
+            idx_t subQuantizers,
+            idx_t bitsPerCode,
             faiss::MetricType metric = faiss::METRIC_L2,
             GpuIndexIVFPQConfig config = GpuIndexIVFPQConfig());
 
@@ -131,7 +131,7 @@ class GpuIndexIVFPQ : public GpuIndexIVF {
     void updateQuantizer() override;
 
     /// Trains the coarse and product quantizer based on the given vector data
-    void train(Index::idx_t n, const float* x) override;
+    void train(idx_t n, const float* x) override;
 
    public:
     /// Like the CPU version, we expose a publically-visible ProductQuantizer
@@ -143,7 +143,7 @@ class GpuIndexIVFPQ : public GpuIndexIVF {
     void verifyPQSettings_() const;
 
     /// Trains the PQ quantizer based on the given vector data
-    void trainResidualQuantizer_(Index::idx_t n, const float* x);
+    void trainResidualQuantizer_(idx_t n, const float* x);
 
    protected:
     /// Our configuration options that we were initialized with

data/vendor/faiss/faiss/gpu/GpuIndexIVFScalarQuantizer.h

@@ -42,7 +42,7 @@ class GpuIndexIVFScalarQuantizer : public GpuIndexIVF {
     GpuIndexIVFScalarQuantizer(
             GpuResourcesProvider* provider,
             int dims,
-            int nlist,
+            idx_t nlist,
             faiss::ScalarQuantizer::QuantizerType qtype,
             faiss::MetricType metric = MetricType::METRIC_L2,
             bool encodeResidual = true,
@@ -55,7 +55,7 @@ class GpuIndexIVFScalarQuantizer : public GpuIndexIVF {
             GpuResourcesProvider* provider,
             Index* coarseQuantizer,
             int dims,
-            int nlist,
+            idx_t nlist,
             faiss::ScalarQuantizer::QuantizerType qtype,
             faiss::MetricType metric = MetricType::METRIC_L2,
             bool encodeResidual = true,
@@ -89,14 +89,14 @@ class GpuIndexIVFScalarQuantizer : public GpuIndexIVF {
     void updateQuantizer() override;
 
     /// Trains the coarse and scalar quantizer based on the given vector data
-    void train(Index::idx_t n, const float* x) override;
+    void train(idx_t n, const float* x) override;
 
    protected:
     /// Validates index SQ parameters
     void verifySQSettings_() const;
 
     /// Called from train to handle SQ residual training
-    void trainResiduals_(Index::idx_t n, const float* x);
+    void trainResiduals_(idx_t n, const float* x);
 
    public:
     /// Exposed like the CPU version

data/vendor/faiss/faiss/gpu/impl/IndexUtils.h

@@ -20,13 +20,10 @@ namespace gpu {
 int getMaxKSelection();
 
 // Validate the k parameter for search
-void validateKSelect(Index::idx_t k);
+void validateKSelect(int k);
 
 // Validate the nprobe parameter for search
-void validateNProbe(Index::idx_t nprobe);
-
-/// Validate the n (number of vectors) parameter for add, search, reconstruct
-void validateNumVectors(Index::idx_t n);
+void validateNProbe(size_t nprobe);
 
 } // namespace gpu
 } // namespace faiss

data/vendor/faiss/faiss/gpu/impl/RemapIndices.cpp

@@ -14,21 +14,23 @@ namespace gpu {
 // Utility function to translate (list id, offset) to a user index on
 // the CPU. In a cpp in order to use OpenMP
 void ivfOffsetToUserIndex(
-        Index::idx_t* indices,
-        int numLists,
-        int queries,
+        idx_t* indices,
+        idx_t numLists,
+        idx_t queries,
         int k,
-        const std::vector<std::vector<Index::idx_t>>& listOffsetToUserIndex) {
+        const std::vector<std::vector<idx_t>>& listOffsetToUserIndex) {
     FAISS_ASSERT(numLists == listOffsetToUserIndex.size());
 
 #pragma omp parallel for
-    for (int q = 0; q < queries; ++q) {
-        for (int r = 0; r < k; ++r) {
+    for (idx_t q = 0; q < queries; ++q) {
+        for (idx_t r = 0; r < k; ++r) {
             auto offsetIndex = indices[q * k + r];
 
-            if (offsetIndex < 0)
+            if (offsetIndex < 0) {
                 continue;
+            }
 
+            // FIXME: implicit limit on list and list offset length
             int listId = (int)(offsetIndex >> 32);
             int listOffset = (int)(offsetIndex & 0xffffffff);
 

data/vendor/faiss/faiss/gpu/impl/RemapIndices.h

@@ -16,11 +16,11 @@ namespace gpu {
 /// Utility function to translate (list id, offset) to a user index on
 /// the CPU. In a cpp in order to use OpenMP.
 void ivfOffsetToUserIndex(
-        Index::idx_t* indices,
-        int numLists,
-        int queries,
+        idx_t* indices,
+        idx_t numLists,
+        idx_t queries,
         int k,
-        const std::vector<std::vector<Index::idx_t>>& listOffsetToUserIndex);
+        const std::vector<std::vector<idx_t>>& listOffsetToUserIndex);
 
 } // namespace gpu
 } // namespace faiss

data/vendor/faiss/faiss/gpu/perf/IndexWrapper-inl.h

@@ -58,8 +58,8 @@ void IndexWrapper<GpuIndex>::runOnIndices(std::function<void(GpuIndex*)> f) {
 }
 
 template <typename GpuIndex>
-void IndexWrapper<GpuIndex>::setNumProbes(int nprobe) {
-    runOnIndices([nprobe](GpuIndex* index) { index->setNumProbes(nprobe); });
+void IndexWrapper<GpuIndex>::setNumProbes(size_t nprobe) {
+    runOnIndices([nprobe](GpuIndex* index) { index->nprobe = nprobe; });
 }
 
 } // namespace gpu

data/vendor/faiss/faiss/gpu/perf/IndexWrapper.h

@@ -32,7 +32,7 @@ struct IndexWrapper {
     faiss::Index* getIndex();
 
     void runOnIndices(std::function<void(GpuIndex*)> f);
-    void setNumProbes(int nprobe);
+    void setNumProbes(size_t nprobe);
 };
 
 } // namespace gpu

data/vendor/faiss/faiss/gpu/test/TestGpuIndexBinaryFlat.cpp

@@ -18,9 +18,9 @@
 
 void compareBinaryDist(
         const std::vector<int>& cpuDist,
-        const std::vector<faiss::IndexBinary::idx_t>& cpuLabels,
+        const std::vector<faiss::idx_t>& cpuLabels,
         const std::vector<int>& gpuDist,
-        const std::vector<faiss::IndexBinary::idx_t>& gpuLabels,
+        const std::vector<faiss::idx_t>& gpuLabels,
         int numQuery,
         int k) {
     for (int i = 0; i < numQuery; ++i) {
@@ -29,8 +29,8 @@ void compareBinaryDist(
         // encounters the values. The last set of equivalent distances seen in
         // the min-k might be truncated, so we can't check that set, but all
         // others we can check.
-        std::set<faiss::IndexBinary::idx_t> cpuLabelSet;
-        std::set<faiss::IndexBinary::idx_t> gpuLabelSet;
+        std::set<faiss::idx_t> cpuLabelSet;
+        std::set<faiss::idx_t> gpuLabelSet;
 
         int curDist = -1;
 
@@ -89,13 +89,13 @@ void testGpuIndexBinaryFlat(int kOverride = -1) {
     auto query = faiss::gpu::randBinaryVecs(numQuery, dims);
 
     std::vector<int> cpuDist(numQuery * k);
-    std::vector<faiss::IndexBinary::idx_t> cpuLabels(numQuery * k);
+    std::vector<faiss::idx_t> cpuLabels(numQuery * k);
 
     cpuIndex.search(
             numQuery, query.data(), k, cpuDist.data(), cpuLabels.data());
 
     std::vector<int> gpuDist(numQuery * k);
-    std::vector<faiss::IndexBinary::idx_t> gpuLabels(numQuery * k);
+    std::vector<faiss::idx_t> gpuLabels(numQuery * k);
 
     gpuIndex.search(
             numQuery, query.data(), k, gpuDist.data(), gpuLabels.data());
@@ -115,6 +115,55 @@ TEST(TestGpuIndexBinaryFlat, Test32) {
     }
 }
 
+TEST(TestGpuIndexBinaryFlat, LargeIndex) {
+    // Construct on a random device to test multi-device, if we have
+    // multiple devices
+    int device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+
+    faiss::gpu::StandardGpuResources res;
+    res.noTempMemory();
+
+    // Skip this device if we do not have sufficient memory
+    constexpr size_t kMem = size_t(8) * 1024 * 1024 * 1024;
+
+    if (faiss::gpu::getFreeMemory(device) < kMem) {
+        std::cerr << "TestGpuIndexFlat.LargeIndex: skipping due "
+                     "to insufficient device memory\n";
+        return;
+    }
+
+    std::cerr << "Running LargeIndex test\n";
+
+    faiss::gpu::GpuIndexBinaryFlatConfig config;
+    config.device = device;
+
+    int dims = 1250 * 8;
+    faiss::gpu::GpuIndexBinaryFlat gpuIndex(&res, dims, config);
+
+    faiss::IndexBinaryFlat cpuIndex(dims);
+
+    int k = 10;
+    int nb = 4000000;
+    int nq = 10;
+
+    auto xb = faiss::gpu::randBinaryVecs(nb, dims);
+    auto xq = faiss::gpu::randBinaryVecs(nq, dims);
+    gpuIndex.add(nb, xb.data());
+    cpuIndex.add(nb, xb.data());
+
+    std::vector<int> cpuDist(nq * k);
+    std::vector<faiss::idx_t> cpuLabels(nq * k);
+
+    cpuIndex.search(nq, xq.data(), k, cpuDist.data(), cpuLabels.data());
+
+    std::vector<int> gpuDist(nq * k);
+    std::vector<faiss::idx_t> gpuLabels(nq * k);
+
+    gpuIndex.search(nq, xq.data(), k, gpuDist.data(), gpuLabels.data());
+
+    compareBinaryDist(cpuDist, cpuLabels, gpuDist, gpuLabels, nq, k);
+}
+
 int main(int argc, char** argv) {
     testing::InitGoogleTest(&argc, argv);
 

data/vendor/faiss/faiss/gpu/test/TestGpuIndexFlat.cpp

@@ -141,6 +141,20 @@ TEST(TestGpuIndexFlat, L2_Float32) {
     }
 }
 
+// At least one test for the k > 1024 select
+TEST(TestGpuIndexFlat, L2_k_2048) {
+    if (faiss::gpu::getMaxKSelection() >= 2048) {
+        TestFlatOptions opt;
+        opt.metric = faiss::MetricType::METRIC_L2;
+        opt.useFloat16 = false;
+        opt.kOverride = 2048;
+        opt.dimOverride = 128;
+        opt.numVecsOverride = 10000;
+
+        testFlat(opt);
+    }
+}
+
 // test specialized k == 1 codepath
 TEST(TestGpuIndexFlat, L2_Float32_K1) {
     for (int tries = 0; tries < 3; ++tries) {
@@ -220,7 +234,7 @@ TEST(TestGpuIndexFlat, QueryEmpty) {
     std::vector<float> queries(numQuery * dim, 1.0f);
 
     std::vector<float> dist(numQuery * k, 0);
-    std::vector<faiss::Index::idx_t> ind(numQuery * k);
+    std::vector<faiss::idx_t> ind(numQuery * k);
 
     gpuIndex.search(numQuery, queries.data(), k, dist.data(), ind.data());
 
@@ -437,7 +451,7 @@ TEST(TestGpuIndexFlat, Residual) {
     cpuIndex.add(numVecs, vecs.data());
     gpuIndex.add(numVecs, vecs.data());
 
-    auto indexVecs = std::vector<faiss::Index::idx_t>{0, 2, 4, 6, 8};
+    auto indexVecs = std::vector<faiss::idx_t>{0, 2, 4, 6, 8};
     auto queryVecs = faiss::gpu::randVecs(indexVecs.size(), dim);
 
     auto residualsCpu = std::vector<float>(indexVecs.size() * dim);
@@ -517,7 +531,7 @@ TEST(TestGpuIndexFlat, Reconstruct) {
 
         // Test reconstruct_batch
         if (false) {
-            auto reconstructKeys = std::vector<faiss::Index::idx_t>{1, 3, 5};
+            auto reconstructKeys = std::vector<faiss::idx_t>{1, 3, 5};
             auto reconstructVecs =
                     std::vector<float>(reconstructKeys.size() * dim);
 
@@ -565,7 +579,7 @@ TEST(TestGpuIndexFlat, SearchAndReconstruct) {
     gpuIndex.add(nb, xb.data());
 
     std::vector<float> refDistance(nq * k, 0);
-    std::vector<faiss::Index::idx_t> refIndices(nq * k, -1);
+    std::vector<faiss::idx_t> refIndices(nq * k, -1);
     std::vector<float> refReconstruct(nq * k * dim, 0);
     cpuIndex.search_and_reconstruct(
             nq,
@@ -576,7 +590,7 @@ TEST(TestGpuIndexFlat, SearchAndReconstruct) {
             refReconstruct.data());
 
     std::vector<float> testDistance(nq * k, 0);
-    std::vector<faiss::Index::idx_t> testIndices(nq * k, -1);
+    std::vector<faiss::idx_t> testIndices(nq * k, -1);
     std::vector<float> testReconstruct(nq * k * dim, 0);
     gpuIndex.search_and_reconstruct(
             nq,
@@ -606,7 +620,7 @@ TEST(TestGpuIndexFlat, SearchAndReconstruct) {
     // above will ensure a decent number of matches), reconstruction should be
     // the same for the vectors that do match
     for (int i = 0; i < nq; ++i) {
-        std::unordered_map<faiss::Index::idx_t, int> refLocation;
+        std::unordered_map<faiss::idx_t, int> refLocation;
 
         for (int j = 0; j < k; ++j) {
             refLocation.insert(std::make_pair(refIndices[i * k + j], j));