faiss 0.1.2 → 0.1.3

data/vendor/faiss/{VectorTransform.cpp → faiss/VectorTransform.cpp}

@@ -9,6 +9,7 @@
 
 #include <faiss/VectorTransform.h>
 
+#include <cinttypes>
 #include <cstdio>
 #include <cmath>
 #include <cstring>
@@ -270,7 +271,7 @@ void RandomRotationMatrix::init (int seed)
     is_trained = true;
 }
 
-void RandomRotationMatrix::train (Index::idx_t /*n*/, const float */*x*/)
+void RandomRotationMatrix::train (Index::idx_t /*n*/, const float * /*x*/)
 {
     // initialize with some arbitrary seed
     init (12345);
@@ -867,7 +868,7 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
 
     if (verbose) {
         printf ("OPQMatrix::train: training an OPQ rotation matrix "
-                "for M=%d from %ld vectors in %dD -> %dD\n",
+                "for M=%d from %" PRId64 " vectors in %dD -> %dD\n",
                 M, n, d_in, d_out);
     }
 
@@ -895,7 +896,7 @@ void OPQMatrix::train (Index::idx_t n, const float *x)
         A.resize (d * d);
         rotation = A.data();
         if (verbose)
-            printf("  OPQMatrix::train: making random %ld*%ld rotation\n",
+            printf("  OPQMatrix::train: making random %zd*%zd rotation\n",
                    d, d);
         float_randn (rotation, d * d, 1234);
         matrix_qr (d, d, rotation);

data/vendor/faiss/{gpu → faiss/gpu}/GpuCloner.cpp

@@ -114,9 +114,9 @@ faiss::Index * index_gpu_to_cpu(const faiss::Index *gpu_index)
  * Cloning to 1 GPU
  **********************************************************/
 
-ToGpuCloner::ToGpuCloner(GpuResources *resources, int device,
+ToGpuCloner::ToGpuCloner(GpuResourcesProvider *prov, int device,
                          const GpuClonerOptions &options):
-    GpuClonerOptions(options), resources(resources), device(device)
+    GpuClonerOptions(options), provider(prov), device(device)
 {}
 
 Index *ToGpuCloner::clone_Index(const Index *index)
@@ -127,7 +127,7 @@ Index *ToGpuCloner::clone_Index(const Index *index)
         config.useFloat16 = useFloat16;
         config.storeTransposed = storeTransposed;
 
-        return new GpuIndexFlat(resources, ifl, config);
+        return new GpuIndexFlat(provider, ifl, config);
     } else if(auto ifl = dynamic_cast<const faiss::IndexIVFFlat *>(index)) {
         GpuIndexIVFFlatConfig config;
         config.device = device;
@@ -136,7 +136,7 @@ Index *ToGpuCloner::clone_Index(const Index *index)
         config.flatConfig.storeTransposed = storeTransposed;
 
         GpuIndexIVFFlat *res =
-            new GpuIndexIVFFlat(resources,
+            new GpuIndexIVFFlat(provider,
                                 ifl->d,
                                 ifl->nlist,
                                 ifl->metric_type,
@@ -156,7 +156,7 @@ Index *ToGpuCloner::clone_Index(const Index *index)
         config.flatConfig.storeTransposed = storeTransposed;
 
         GpuIndexIVFScalarQuantizer *res =
-            new GpuIndexIVFScalarQuantizer(resources,
+            new GpuIndexIVFScalarQuantizer(provider,
                                            ifl->d,
                                            ifl->nlist,
                                            ifl->sq.qtype,
@@ -184,7 +184,7 @@ Index *ToGpuCloner::clone_Index(const Index *index)
         config.useFloat16LookupTables = useFloat16;
         config.usePrecomputedTables = usePrecomputed;
 
-        GpuIndexIVFPQ *res = new GpuIndexIVFPQ(resources, ipq, config);
+        GpuIndexIVFPQ *res = new GpuIndexIVFPQ(provider, ipq, config);
 
         if(reserveVecs > 0 && ipq->ntotal == 0) {
             res->reserveMemory(reserveVecs);
@@ -198,12 +198,12 @@ Index *ToGpuCloner::clone_Index(const Index *index)
 
 
 faiss::Index * index_cpu_to_gpu(
-       GpuResources* resources, int device,
+       GpuResourcesProvider* provider, int device,
        const faiss::Index *index,
        const GpuClonerOptions *options)
 {
     GpuClonerOptions defaults;
-    ToGpuCloner cl(resources, device, options ? *options : defaults);
+    ToGpuCloner cl(provider, device, options ? *options : defaults);
     return cl.clone_Index(index);
 }
 
@@ -213,14 +213,14 @@ faiss::Index * index_cpu_to_gpu(
  **********************************************************/
 
 ToGpuClonerMultiple::ToGpuClonerMultiple(
-                        std::vector<GpuResources *> & resources,
+                        std::vector<GpuResourcesProvider *> & provider,
                         std::vector<int>& devices,
                         const GpuMultipleClonerOptions &options):
     GpuMultipleClonerOptions(options)
 {
-    FAISS_ASSERT(resources.size() == devices.size());
-    for(int i = 0; i < resources.size(); i++) {
-        sub_cloners.push_back(ToGpuCloner(resources[i], devices[i], options));
+    FAISS_ASSERT(provider.size() == devices.size());
+    for(int i = 0; i < provider.size(); i++) {
+        sub_cloners.push_back(ToGpuCloner(provider[i], devices[i], options));
     }
 }
 
@@ -394,13 +394,13 @@ Index *ToGpuClonerMultiple::clone_Index(const Index *index)
 
 
 faiss::Index * index_cpu_to_gpu_multiple(
-       std::vector<GpuResources*> & resources,
+       std::vector<GpuResourcesProvider*> & provider,
        std::vector<int> &devices,
        const faiss::Index *index,
        const GpuMultipleClonerOptions *options)
 {
     GpuMultipleClonerOptions defaults;
-    ToGpuClonerMultiple cl(resources, devices, options ? *options : defaults);
+    ToGpuClonerMultiple cl(provider, devices, options ? *options : defaults);
     return cl.clone_Index(index);
 }
 

data/vendor/faiss/{gpu → faiss/gpu}/GpuCloner.h

@@ -17,8 +17,7 @@
 
 namespace faiss { namespace gpu {
 
-class GpuResources;
-
+class GpuResourcesProvider;
 
 /// Cloner specialized for GPU -> CPU
 struct ToCPUCloner: faiss::Cloner {
@@ -29,10 +28,10 @@ struct ToCPUCloner: faiss::Cloner {
 
 /// Cloner specialized for CPU -> 1 GPU
 struct ToGpuCloner: faiss::Cloner, GpuClonerOptions {
-    GpuResources *resources;
+    GpuResourcesProvider *provider;
     int device;
 
-    ToGpuCloner(GpuResources *resources, int device,
+    ToGpuCloner(GpuResourcesProvider *prov, int device,
                 const GpuClonerOptions &options);
 
     Index *clone_Index(const Index *index) override;
@@ -43,7 +42,7 @@ struct ToGpuCloner: faiss::Cloner, GpuClonerOptions {
 struct ToGpuClonerMultiple: faiss::Cloner, GpuMultipleClonerOptions {
     std::vector<ToGpuCloner> sub_cloners;
 
-    ToGpuClonerMultiple(std::vector<GpuResources *> & resources,
+    ToGpuClonerMultiple(std::vector<GpuResourcesProvider *> & provider,
                         std::vector<int>& devices,
                         const GpuMultipleClonerOptions &options);
 
@@ -67,12 +66,12 @@ faiss::Index * index_gpu_to_cpu(const faiss::Index *gpu_index);
 
 /// converts any CPU index that can be converted to GPU
 faiss::Index * index_cpu_to_gpu(
-       GpuResources* resources, int device,
+       GpuResourcesProvider* provider, int device,
        const faiss::Index *index,
        const GpuClonerOptions *options = nullptr);
 
 faiss::Index * index_cpu_to_gpu_multiple(
-       std::vector<GpuResources*> & resources,
+       std::vector<GpuResourcesProvider*> & provider,
        std::vector<int> &devices,
        const faiss::Index *index,
        const GpuMultipleClonerOptions *options = nullptr);

data/vendor/faiss/{gpu → faiss/gpu}/GpuDistance.h

@@ -12,7 +12,7 @@
 
 namespace faiss { namespace gpu {
 
-class GpuResources;
+class GpuResourcesProvider;
 
 // Scalar type of the vector data
 enum class DistanceDataType {
@@ -20,6 +20,12 @@ enum class DistanceDataType {
   F16,
 };
 
+// Scalar type of the indices data
+enum class IndicesDataType {
+  I64 = 1,
+  I32,
+};
+
 /// Arguments to brute-force GPU k-nearest neighbor searching
 struct GpuDistanceParams {
   GpuDistanceParams()
@@ -38,6 +44,7 @@ struct GpuDistanceParams {
         numQueries(0),
         outDistances(nullptr),
         ignoreOutDistances(false),
+        outIndicesType(IndicesDataType::I64),
         outIndices(nullptr) {
   }
 
@@ -101,7 +108,8 @@ struct GpuDistanceParams {
 
   // A region of memory size numQueries x k, with k
   // innermost (row major)
-  faiss::Index::idx_t* outIndices;
+  IndicesDataType outIndicesType;
+  void* outIndices;
 };
 
 /// A wrapper for gpu/impl/Distance.cuh to expose direct brute-force k-nearest
@@ -116,10 +124,10 @@ struct GpuDistanceParams {
 ///
 /// For each vector in `queries`, searches all of `vectors` to find its k
 /// nearest neighbors with respect to the given metric
-void bfKnn(GpuResources* resources, const GpuDistanceParams& args);
+void bfKnn(GpuResourcesProvider* resources, const GpuDistanceParams& args);
 
 /// Deprecated legacy implementation
-void bruteForceKnn(GpuResources* resources,
+void bruteForceKnn(GpuResourcesProvider* resources,
                    faiss::MetricType metric,
                    // If vectorsRowMajor is true, this is
                    // numVectors x dims, with dims innermost; otherwise,

data/vendor/faiss/{gpu → faiss/gpu}/GpuIndex.h

@@ -9,12 +9,10 @@
 #pragma once
 
 #include <faiss/Index.h>
-#include <faiss/gpu/utils/MemorySpace.h>
+#include <faiss/gpu/GpuResources.h>
 
 namespace faiss { namespace gpu {
 
-class GpuResources;
-
 struct GpuIndexConfig {
   inline GpuIndexConfig()
       : device(0),
@@ -32,7 +30,7 @@ struct GpuIndexConfig {
 
 class GpuIndex : public faiss::Index {
  public:
-  GpuIndex(GpuResources* resources,
+  GpuIndex(std::shared_ptr<GpuResources> resources,
            int dims,
            faiss::MetricType metric,
            float metricArg,
@@ -42,10 +40,6 @@ class GpuIndex : public faiss::Index {
     return device_;
   }
 
-  inline GpuResources* getResources() {
-    return resources_;
-  }
-
   /// Set the minimum data size for searches (in MiB) for which we use
   /// CPU -> GPU paging
   void setMinPagingSize(size_t size);
@@ -140,7 +134,7 @@ private:
 
  protected:
   /// Manages streams, cuBLAS handles and scratch memory for devices
-  GpuResources* resources_;
+  std::shared_ptr<GpuResources> resources_;
 
   /// The GPU device we are resident on
   const int device_;

data/vendor/faiss/{gpu → faiss/gpu}/GpuIndexBinaryFlat.h

@@ -9,11 +9,12 @@
 
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/gpu/GpuIndex.h>
+#include <faiss/gpu/GpuResources.h>
+#include <memory>
 
 namespace faiss { namespace gpu {
 
 class BinaryFlatIndex;
-class GpuResources;
 
 struct GpuIndexBinaryFlatConfig : public GpuIndexConfig {
 };
@@ -24,13 +25,13 @@ class GpuIndexBinaryFlat : public IndexBinary {
  public:
   /// Construct from a pre-existing faiss::IndexBinaryFlat instance, copying
   /// data over to the given GPU
-  GpuIndexBinaryFlat(GpuResources* resources,
+  GpuIndexBinaryFlat(GpuResourcesProvider* resources,
                      const faiss::IndexBinaryFlat* index,
                      GpuIndexBinaryFlatConfig config =
                      GpuIndexBinaryFlatConfig());
 
   /// Construct an empty instance that can be added to
-  GpuIndexBinaryFlat(GpuResources* resources,
+  GpuIndexBinaryFlat(GpuResourcesProvider* resources,
                      int dims,
                      GpuIndexBinaryFlatConfig config =
                      GpuIndexBinaryFlatConfig());
@@ -76,14 +77,13 @@ class GpuIndexBinaryFlat : public IndexBinary {
 
  protected:
   /// Manages streans, cuBLAS handles and scratch memory for devices
-  GpuResources* resources_;
+  std::shared_ptr<GpuResources> resources_;
 
   /// Configuration options
   GpuIndexBinaryFlatConfig config_;
 
-  /// Holds our GPU data containing the list of vectors; is managed via raw
-  /// pointer so as to allow non-CUDA compilers to see this header
-  BinaryFlatIndex* data_;
+  /// Holds our GPU data containing the list of vectors
+  std::unique_ptr<BinaryFlatIndex> data_;
 };
 
 } } // namespace gpu

data/vendor/faiss/{gpu → faiss/gpu}/GpuIndexFlat.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <faiss/gpu/GpuIndex.h>
+#include <memory>
 
 namespace faiss {
 
@@ -47,12 +48,21 @@ class GpuIndexFlat : public GpuIndex {
  public:
   /// Construct from a pre-existing faiss::IndexFlat instance, copying
   /// data over to the given GPU
-  GpuIndexFlat(GpuResources* resources,
+  GpuIndexFlat(GpuResourcesProvider* provider,
+               const faiss::IndexFlat* index,
+               GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlat(std::shared_ptr<GpuResources> resources,
                const faiss::IndexFlat* index,
                GpuIndexFlatConfig config = GpuIndexFlatConfig());
 
   /// Construct an empty instance that can be added to
-  GpuIndexFlat(GpuResources* resources,
+  GpuIndexFlat(GpuResourcesProvider* provider,
+               int dims,
+               faiss::MetricType metric,
+               GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlat(std::shared_ptr<GpuResources> resources,
                int dims,
                faiss::MetricType metric,
                GpuIndexFlatConfig config = GpuIndexFlatConfig());
@@ -100,7 +110,7 @@ class GpuIndexFlat : public GpuIndex {
                           const faiss::Index::idx_t* keys) const override;
 
   /// For internal access
-  inline FlatIndex* getGpuData() { return data_; }
+  inline FlatIndex* getGpuData() { return data_.get(); }
 
  protected:
   /// Flat index does not require IDs as there is no storage available for them
@@ -122,9 +132,8 @@ class GpuIndexFlat : public GpuIndex {
   /// Our config object
   const GpuIndexFlatConfig config_;
 
-  /// Holds our GPU data containing the list of vectors; is managed via raw
-  /// pointer so as to allow non-CUDA compilers to see this header
-  FlatIndex* data_;
+  /// Holds our GPU data containing the list of vectors
+  std::unique_ptr<FlatIndex> data_;
 };
 
 /// Wrapper around the GPU implementation that looks like
@@ -134,12 +143,20 @@ class GpuIndexFlatL2 : public GpuIndexFlat {
  public:
   /// Construct from a pre-existing faiss::IndexFlatL2 instance, copying
   /// data over to the given GPU
-  GpuIndexFlatL2(GpuResources* resources,
+  GpuIndexFlatL2(GpuResourcesProvider* provider,
+                 faiss::IndexFlatL2* index,
+                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlatL2(std::shared_ptr<GpuResources> resources,
                  faiss::IndexFlatL2* index,
                  GpuIndexFlatConfig config = GpuIndexFlatConfig());
 
   /// Construct an empty instance that can be added to
-  GpuIndexFlatL2(GpuResources* resources,
+  GpuIndexFlatL2(GpuResourcesProvider* provider,
+                 int dims,
+                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlatL2(std::shared_ptr<GpuResources> resources,
                  int dims,
                  GpuIndexFlatConfig config = GpuIndexFlatConfig());
 
@@ -159,12 +176,20 @@ class GpuIndexFlatIP : public GpuIndexFlat {
  public:
   /// Construct from a pre-existing faiss::IndexFlatIP instance, copying
   /// data over to the given GPU
-  GpuIndexFlatIP(GpuResources* resources,
+  GpuIndexFlatIP(GpuResourcesProvider* provider,
+                 faiss::IndexFlatIP* index,
+                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlatIP(std::shared_ptr<GpuResources> resources,
                  faiss::IndexFlatIP* index,
                  GpuIndexFlatConfig config = GpuIndexFlatConfig());
 
   /// Construct an empty instance that can be added to
-  GpuIndexFlatIP(GpuResources* resources,
+  GpuIndexFlatIP(GpuResourcesProvider* provider,
+                 int dims,
+                 GpuIndexFlatConfig config = GpuIndexFlatConfig());
+
+  GpuIndexFlatIP(std::shared_ptr<GpuResources> resources,
                  int dims,
                  GpuIndexFlatConfig config = GpuIndexFlatConfig());
 

data/vendor/faiss/{gpu → faiss/gpu}/GpuIndexIVF.h

@@ -18,7 +18,6 @@ namespace faiss { struct IndexIVF; }
 namespace faiss { namespace gpu {
 
 class GpuIndexFlat;
-class GpuResources;
 
 struct GpuIndexIVFConfig : public GpuIndexConfig {
   inline GpuIndexIVFConfig()
@@ -34,7 +33,7 @@ struct GpuIndexIVFConfig : public GpuIndexConfig {
 
 class GpuIndexIVF : public GpuIndex {
  public:
-  GpuIndexIVF(GpuResources* resources,
+  GpuIndexIVF(GpuResourcesProvider* provider,
               int dims,
               faiss::MetricType metric,
               float metricArg,

data/vendor/faiss/{gpu → faiss/gpu}/GpuIndexIVFFlat.h

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <faiss/gpu/GpuIndexIVF.h>
+#include <memory>
 
 namespace faiss { struct IndexIVFFlat; }
 
@@ -26,13 +27,13 @@ class GpuIndexIVFFlat : public GpuIndexIVF {
  public:
   /// Construct from a pre-existing faiss::IndexIVFFlat instance, copying
   /// data over to the given GPU, if the input index is trained.
-  GpuIndexIVFFlat(GpuResources* resources,
+  GpuIndexIVFFlat(GpuResourcesProvider* provider,
                   const faiss::IndexIVFFlat* index,
                   GpuIndexIVFFlatConfig config = GpuIndexIVFFlatConfig());
 
   /// Constructs a new instance with an empty flat quantizer; the user
   /// provides the number of lists desired.
-  GpuIndexIVFFlat(GpuResources* resources,
+  GpuIndexIVFFlat(GpuResourcesProvider* provider,
                   int dims,
                   int nlist,
                   faiss::MetricType metric,
@@ -79,7 +80,7 @@ class GpuIndexIVFFlat : public GpuIndexIVF {
   size_t reserveMemoryVecs_;
 
   /// Instance that we own; contains the inverted list
-  IVFFlat* index_;
+  std::unique_ptr<IVFFlat> index_;
 };
 
 } } // namespace