faiss 0.2.0 → 0.2.1

data/vendor/faiss/faiss/gpu/perf/PerfIVFPQAdd.cpp

@@ -5,8 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
-
 #include <cuda_profiler_api.h>
 #include <faiss/IndexFlat.h>
 #include <faiss/IndexIVFPQ.h>
@@ -32,108 +30,131 @@ DEFINE_bool(per_batch_time, false, "print per-batch times");
 DEFINE_bool(reserve_memory, false, "whether or not to pre-reserve memory");
 
 int main(int argc, char** argv) {
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-
-  cudaProfilerStop();
-
-  int dim = FLAGS_dim;
-  int numCentroids = FLAGS_centroids;
-  int bytesPerVec = FLAGS_bytes_per_vec;
-  int bitsPerCode = FLAGS_bits_per_code;
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
 
-  faiss::gpu::StandardGpuResources res;
+    cudaProfilerStop();
 
-  // IndexIVFPQ will complain, but just give us enough to get through this
-  int numTrain = 4 * numCentroids;
-  std::vector<float> trainVecs = faiss::gpu::randVecs(numTrain, dim);
+    int dim = FLAGS_dim;
+    int numCentroids = FLAGS_centroids;
+    int bytesPerVec = FLAGS_bytes_per_vec;
+    int bitsPerCode = FLAGS_bits_per_code;
 
-  faiss::IndexFlatL2 coarseQuantizer(dim);
-  faiss::IndexIVFPQ cpuIndex(&coarseQuantizer, dim, numCentroids,
-                             bytesPerVec, bitsPerCode);
-  if (FLAGS_time_cpu) {
-    cpuIndex.train(numTrain, trainVecs.data());
-  }
+    faiss::gpu::StandardGpuResources res;
 
-  faiss::gpu::GpuIndexIVFPQConfig config;
-  config.device = 0;
-  config.indicesOptions = (faiss::gpu::IndicesOptions) FLAGS_index;
+    // IndexIVFPQ will complain, but just give us enough to get through this
+    int numTrain = 4 * numCentroids;
+    std::vector<float> trainVecs = faiss::gpu::randVecs(numTrain, dim);
 
-  faiss::gpu::GpuIndexIVFPQ gpuIndex(
-    &res, dim, numCentroids, bytesPerVec, bitsPerCode,
-    faiss::METRIC_L2, config);
-
-  if (FLAGS_time_gpu) {
-    gpuIndex.train(numTrain, trainVecs.data());
-    if (FLAGS_reserve_memory) {
-      size_t numVecs = (size_t) FLAGS_batches * (size_t) FLAGS_batch_size;
-      gpuIndex.reserveMemory(numVecs);
+    faiss::IndexFlatL2 coarseQuantizer(dim);
+    faiss::IndexIVFPQ cpuIndex(
+            &coarseQuantizer, dim, numCentroids, bytesPerVec, bitsPerCode);
+    if (FLAGS_time_cpu) {
+        cpuIndex.train(numTrain, trainVecs.data());
     }
-  }
 
-  cudaDeviceSynchronize();
-  CUDA_VERIFY(cudaProfilerStart());
+    faiss::gpu::GpuIndexIVFPQConfig config;
+    config.device = 0;
+    config.indicesOptions = (faiss::gpu::IndicesOptions)FLAGS_index;
 
-  float totalGpuTime = 0.0f;
-  float totalCpuTime = 0.0f;
+    faiss::gpu::GpuIndexIVFPQ gpuIndex(
+            &res,
+            dim,
+            numCentroids,
+            bytesPerVec,
+            bitsPerCode,
+            faiss::METRIC_L2,
+            config);
 
-  for (int i = 0; i < FLAGS_batches; ++i) {
-    if (!FLAGS_per_batch_time) {
-      if (i % 10 == 0) {
-        printf("Adding batch %d\n", i + 1);
-      }
+    if (FLAGS_time_gpu) {
+        gpuIndex.train(numTrain, trainVecs.data());
+        if (FLAGS_reserve_memory) {
+            size_t numVecs = (size_t)FLAGS_batches * (size_t)FLAGS_batch_size;
+            gpuIndex.reserveMemory(numVecs);
+        }
     }
 
-    auto addVecs = faiss::gpu::randVecs(FLAGS_batch_size, dim);
+    cudaDeviceSynchronize();
+    CUDA_VERIFY(cudaProfilerStart());
+
+    float totalGpuTime = 0.0f;
+    float totalCpuTime = 0.0f;
+
+    for (int i = 0; i < FLAGS_batches; ++i) {
+        if (!FLAGS_per_batch_time) {
+            if (i % 10 == 0) {
+                printf("Adding batch %d\n", i + 1);
+            }
+        }
+
+        auto addVecs = faiss::gpu::randVecs(FLAGS_batch_size, dim);
+
+        if (FLAGS_time_gpu) {
+            faiss::gpu::CpuTimer timer;
+            gpuIndex.add(FLAGS_batch_size, addVecs.data());
+            CUDA_VERIFY(cudaDeviceSynchronize());
+            auto time = timer.elapsedMilliseconds();
+
+            totalGpuTime += time;
+
+            if (FLAGS_per_batch_time) {
+                printf("Batch %d | GPU time to add %d vecs: %.3f ms (%.5f ms per)\n",
+                       i + 1,
+                       FLAGS_batch_size,
+                       time,
+                       time / (float)FLAGS_batch_size);
+            }
+        }
+
+        if (FLAGS_time_cpu) {
+            faiss::gpu::CpuTimer timer;
+            cpuIndex.add(FLAGS_batch_size, addVecs.data());
+            auto time = timer.elapsedMilliseconds();
+
+            totalCpuTime += time;
+
+            if (FLAGS_per_batch_time) {
+                printf("Batch %d | CPU time to add %d vecs: %.3f ms (%.5f ms per)\n",
+                       i + 1,
+                       FLAGS_batch_size,
+                       time,
+                       time / (float)FLAGS_batch_size);
+            }
+        }
+    }
 
-    if (FLAGS_time_gpu) {
-      faiss::gpu::CpuTimer timer;
-      gpuIndex.add(FLAGS_batch_size, addVecs.data());
-      CUDA_VERIFY(cudaDeviceSynchronize());
-      auto time = timer.elapsedMilliseconds();
+    CUDA_VERIFY(cudaProfilerStop());
 
-      totalGpuTime += time;
+    int total = FLAGS_batch_size * FLAGS_batches;
 
-      if (FLAGS_per_batch_time) {
-      printf("Batch %d | GPU time to add %d vecs: %.3f ms (%.5f ms per)\n",
-             i + 1, FLAGS_batch_size, time, time / (float) FLAGS_batch_size);
-      }
+    if (FLAGS_time_gpu) {
+        printf("%d dim, %d centroids, %d x %d encoding\n"
+               "GPU time to add %d vectors (%d batches, %d per batch): "
+               "%.3f ms (%.3f us per)\n",
+               dim,
+               numCentroids,
+               bytesPerVec,
+               bitsPerCode,
+               total,
+               FLAGS_batches,
+               FLAGS_batch_size,
+               totalGpuTime,
+               totalGpuTime * 1000.0f / (float)total);
     }
 
     if (FLAGS_time_cpu) {
-      faiss::gpu::CpuTimer timer;
-      cpuIndex.add(FLAGS_batch_size, addVecs.data());
-      auto time = timer.elapsedMilliseconds();
-
-      totalCpuTime += time;
-
-      if (FLAGS_per_batch_time) {
-        printf("Batch %d | CPU time to add %d vecs: %.3f ms (%.5f ms per)\n",
-               i + 1, FLAGS_batch_size, time, time / (float) FLAGS_batch_size);
-      }
+        printf("%d dim, %d centroids, %d x %d encoding\n"
+               "CPU time to add %d vectors (%d batches, %d per batch): "
+               "%.3f ms (%.3f us per)\n",
+               dim,
+               numCentroids,
+               bytesPerVec,
+               bitsPerCode,
+               total,
+               FLAGS_batches,
+               FLAGS_batch_size,
+               totalCpuTime,
+               totalCpuTime * 1000.0f / (float)total);
     }
-  }
-
-  CUDA_VERIFY(cudaProfilerStop());
-
-  int total = FLAGS_batch_size * FLAGS_batches;
-
-  if (FLAGS_time_gpu) {
-    printf("%d dim, %d centroids, %d x %d encoding\n"
-           "GPU time to add %d vectors (%d batches, %d per batch): "
-           "%.3f ms (%.3f us per)\n",
-           dim, numCentroids, bytesPerVec, bitsPerCode,
-           total, FLAGS_batches, FLAGS_batch_size,
-           totalGpuTime, totalGpuTime * 1000.0f / (float) total);
-  }
-
-  if (FLAGS_time_cpu) {
-    printf("%d dim, %d centroids, %d x %d encoding\n"
-           "CPU time to add %d vectors (%d batches, %d per batch): "
-           "%.3f ms (%.3f us per)\n",
-           dim, numCentroids, bytesPerVec, bitsPerCode,
-           total, FLAGS_batches, FLAGS_batch_size,
-           totalCpuTime, totalCpuTime * 1000.0f / (float) total);
-  }
-
-  return 0;
+
+    return 0;
 }

data/vendor/faiss/faiss/gpu/perf/WriteIndex.cpp

@@ -5,14 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
+#include <faiss/IndexFlat.h>
 #include <faiss/IndexIVFFlat.h>
 #include <faiss/IndexIVFPQ.h>
-#include <faiss/IndexFlat.h>
-#include <faiss/index_io.h>
 #include <faiss/gpu/test/TestUtils.h>
-#include <vector>
+#include <faiss/index_io.h>
 #include <gflags/gflags.h>
+#include <vector>
 
 // For IVFPQ:
 DEFINE_bool(ivfpq, false, "use IVFPQ encoding");
@@ -32,71 +31,83 @@ DEFINE_int32(num_train, -1, "number of database vecs to train on");
 
 template <typename T>
 void fillAndSave(T& index, int numTrain, int num, int dim) {
-  auto trainVecs = faiss::gpu::randVecs(numTrain, dim);
-  index.train(numTrain, trainVecs.data());
+    auto trainVecs = faiss::gpu::randVecs(numTrain, dim);
+    index.train(numTrain, trainVecs.data());
 
-  constexpr int kAddChunk = 1000000;
+    constexpr int kAddChunk = 1000000;
 
-  for (int i = 0; i < num; i += kAddChunk) {
-    int numRemaining = (num - i) < kAddChunk ? (num - i) : kAddChunk;
-    auto vecs = faiss::gpu::randVecs(numRemaining, dim);
+    for (int i = 0; i < num; i += kAddChunk) {
+        int numRemaining = (num - i) < kAddChunk ? (num - i) : kAddChunk;
+        auto vecs = faiss::gpu::randVecs(numRemaining, dim);
 
-    printf("adding at %d: %d\n", i, numRemaining);
-    index.add(numRemaining, vecs.data());
-  }
+        printf("adding at %d: %d\n", i, numRemaining);
+        index.add(numRemaining, vecs.data());
+    }
 
-  faiss::write_index(&index, FLAGS_out.c_str());
+    faiss::write_index(&index, FLAGS_out.c_str());
 }
 
 int main(int argc, char** argv) {
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-
-  // Either ivfpq or ivfflat must be set
-  if ((FLAGS_ivfpq && FLAGS_ivfflat) ||
-      (!FLAGS_ivfpq && !FLAGS_ivfflat)) {
-    printf("must specify either ivfpq or ivfflat\n");
-    return 1;
-  }
-
-  auto dim = FLAGS_dim;
-  auto numCentroids = FLAGS_num_coarse;
-  auto num = FLAGS_num;
-  auto numTrain = FLAGS_num_train;
-  numTrain = numTrain == -1 ? std::max((num / 4), 1) : numTrain;
-  numTrain = std::min(num, numTrain);
-
-  if (FLAGS_ivfpq) {
-    faiss::IndexFlatL2 quantizer(dim);
-    faiss::IndexIVFPQ index(&quantizer, dim, numCentroids,
-                            FLAGS_codes, FLAGS_bits_per_code);
-    index.verbose = true;
-
-    printf("IVFPQ: codes %d bits per code %d\n",
-           FLAGS_codes, FLAGS_bits_per_code);
-    printf("Lists: %d\n", numCentroids);
-    printf("Database: dim %d num vecs %d trained on %d\n", dim, num, numTrain);
-    printf("output file: %s\n", FLAGS_out.c_str());
-
-    fillAndSave(index, numTrain, num, dim);
-  } else if (FLAGS_ivfflat) {
-    faiss::IndexFlatL2 quantizerL2(dim);
-    faiss::IndexFlatIP quantizerIP(dim);
-
-    faiss::IndexFlat* quantizer = FLAGS_l2 ?
-      (faiss::IndexFlat*) &quantizerL2 :
-      (faiss::IndexFlat*) &quantizerIP;
-
-    faiss::IndexIVFFlat index(quantizer, dim, numCentroids,
-                              FLAGS_l2 ? faiss::METRIC_L2 :
-                              faiss::METRIC_INNER_PRODUCT);
-
-    printf("IVFFlat: metric %s\n", FLAGS_l2 ? "L2" : "IP");
-    printf("Lists: %d\n", numCentroids);
-    printf("Database: dim %d num vecs %d trained on %d\n", dim, num, numTrain);
-    printf("output file: %s\n", FLAGS_out.c_str());
-
-    fillAndSave(index, numTrain, num, dim);
-  }
-
-  return 0;
+    gflags::ParseCommandLineFlags(&argc, &argv, true);
+
+    // Either ivfpq or ivfflat must be set
+    if ((FLAGS_ivfpq && FLAGS_ivfflat) || (!FLAGS_ivfpq && !FLAGS_ivfflat)) {
+        printf("must specify either ivfpq or ivfflat\n");
+        return 1;
+    }
+
+    auto dim = FLAGS_dim;
+    auto numCentroids = FLAGS_num_coarse;
+    auto num = FLAGS_num;
+    auto numTrain = FLAGS_num_train;
+    numTrain = numTrain == -1 ? std::max((num / 4), 1) : numTrain;
+    numTrain = std::min(num, numTrain);
+
+    if (FLAGS_ivfpq) {
+        faiss::IndexFlatL2 quantizer(dim);
+        faiss::IndexIVFPQ index(
+                &quantizer,
+                dim,
+                numCentroids,
+                FLAGS_codes,
+                FLAGS_bits_per_code);
+        index.verbose = true;
+
+        printf("IVFPQ: codes %d bits per code %d\n",
+               FLAGS_codes,
+               FLAGS_bits_per_code);
+        printf("Lists: %d\n", numCentroids);
+        printf("Database: dim %d num vecs %d trained on %d\n",
+               dim,
+               num,
+               numTrain);
+        printf("output file: %s\n", FLAGS_out.c_str());
+
+        fillAndSave(index, numTrain, num, dim);
+    } else if (FLAGS_ivfflat) {
+        faiss::IndexFlatL2 quantizerL2(dim);
+        faiss::IndexFlatIP quantizerIP(dim);
+
+        faiss::IndexFlat* quantizer = FLAGS_l2
+                ? (faiss::IndexFlat*)&quantizerL2
+                : (faiss::IndexFlat*)&quantizerIP;
+
+        faiss::IndexIVFFlat index(
+                quantizer,
+                dim,
+                numCentroids,
+                FLAGS_l2 ? faiss::METRIC_L2 : faiss::METRIC_INNER_PRODUCT);
+
+        printf("IVFFlat: metric %s\n", FLAGS_l2 ? "L2" : "IP");
+        printf("Lists: %d\n", numCentroids);
+        printf("Database: dim %d num vecs %d trained on %d\n",
+               dim,
+               num,
+               numTrain);
+        printf("output file: %s\n", FLAGS_out.c_str());
+
+        fillAndSave(index, numTrain, num, dim);
+    }
+
+    return 0;
 }

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

@@ -5,270 +5,285 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 #include <faiss/gpu/impl/InterleavedCodes.h>
-#include <faiss/gpu/utils/StaticUtils.h>
 #include <faiss/gpu/test/TestUtils.h>
-#include <cmath>
+#include <faiss/gpu/utils/StaticUtils.h>
 #include <gtest/gtest.h>
+#include <cmath>
 #include <random>
 #include <sstream>
 #include <vector>
 
 TEST(TestCodePacking, NonInterleavedCodes_UnpackPack) {
-  using namespace faiss::gpu;
+    using namespace faiss::gpu;
 
-  // We are fine using non-fixed seeds here, the results should be fully
-  // deterministic
-  auto seed = std::random_device()();
-  std::mt19937 gen(seed);
-  std::uniform_int_distribution<uint8_t> dist;
+    // We are fine using non-fixed seeds here, the results should be fully
+    // deterministic
+    auto seed = std::random_device()();
+    std::mt19937 gen(seed);
+    std::uniform_int_distribution<uint8_t> dist;
 
-  std::cout << "seed " << seed << "\n";
+    std::cout << "seed " << seed << "\n";
 
-  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
-    for (auto dims : {1, 7, 8, 31, 32}) {
-      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
-        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+    for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+        for (auto dims : {1, 7, 8, 31, 32}) {
+            for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+                std::cout << bitsPerCode << " " << dims << " " << numVecs
+                          << "\n";
 
-        int srcVecSize = utils::divUp(dims * bitsPerCode, 8);
-        std::vector<uint8_t> data(numVecs * srcVecSize);
+                int srcVecSize = utils::divUp(dims * bitsPerCode, 8);
+                std::vector<uint8_t> data(numVecs * srcVecSize);
 
-        for (auto& v : data) {
-          v = dist(gen);
-        }
+                for (auto& v : data) {
+                    v = dist(gen);
+                }
 
-        // currently unimplemented
-        EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
+                // currently unimplemented
+                EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
 
-        // Due to bit packing, mask out bits that should be zero based on
-        // dimensions we shouldn't have present
-        int vectorSizeBits = dims * bitsPerCode;
-        int vectorSizeBytes = utils::divUp(vectorSizeBits, 8);
-        int remainder = vectorSizeBits % 8;
+                // Due to bit packing, mask out bits that should be zero based
+                // on dimensions we shouldn't have present
+                int vectorSizeBits = dims * bitsPerCode;
+                int vectorSizeBytes = utils::divUp(vectorSizeBits, 8);
+                int remainder = vectorSizeBits % 8;
 
-        if (remainder > 0) {
-          uint8_t mask = 0xff >> (8 - remainder);
+                if (remainder > 0) {
+                    uint8_t mask = 0xff >> (8 - remainder);
 
-          for (int i = 0; i < numVecs; ++i) {
-            int lastVecByte = (i + 1) * vectorSizeBytes - 1;
-            data[lastVecByte] &= mask;
-          }
-        }
+                    for (int i = 0; i < numVecs; ++i) {
+                        int lastVecByte = (i + 1) * vectorSizeBytes - 1;
+                        data[lastVecByte] &= mask;
+                    }
+                }
 
-        auto up = unpackNonInterleaved(data, numVecs, dims, bitsPerCode);
-        auto p = packNonInterleaved(up, numVecs, dims, bitsPerCode);
+                auto up =
+                        unpackNonInterleaved(data, numVecs, dims, bitsPerCode);
+                auto p = packNonInterleaved(up, numVecs, dims, bitsPerCode);
 
-        EXPECT_EQ(data, p);
-      }
+                EXPECT_EQ(data, p);
+            }
+        }
     }
-  }
 }
 
 TEST(TestCodePacking, NonInterleavedCodes_PackUnpack) {
-  using namespace faiss::gpu;
+    using namespace faiss::gpu;
 
-  // We are fine using non-fixed seeds here, the results should be fully
-  // deterministic
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  std::uniform_int_distribution<uint8_t> dist;
+    // We are fine using non-fixed seeds here, the results should be fully
+    // deterministic
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<uint8_t> dist;
 
-  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
-    for (auto dims : {1, 7, 8, 31, 32}) {
-      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
-        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+    for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+        for (auto dims : {1, 7, 8, 31, 32}) {
+            for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+                std::cout << bitsPerCode << " " << dims << " " << numVecs
+                          << "\n";
 
-        std::vector<uint8_t> data(numVecs * dims * utils::divUp(bitsPerCode, 8));
+                std::vector<uint8_t> data(
+                        numVecs * dims * utils::divUp(bitsPerCode, 8));
 
-        // currently unimplemented
-        EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
+                // currently unimplemented
+                EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
 
-        // Mask out high bits we shouldn't have based on code size
-        uint8_t mask = bitsPerCode < 8 ? (0xff >> (8 - bitsPerCode)) : 0xff;
+                // Mask out high bits we shouldn't have based on code size
+                uint8_t mask =
+                        bitsPerCode < 8 ? (0xff >> (8 - bitsPerCode)) : 0xff;
 
-        for (auto& v : data) {
-          v = dist(gen) & mask;
-        }
+                for (auto& v : data) {
+                    v = dist(gen) & mask;
+                }
 
-        auto p = packNonInterleaved(data, numVecs, dims, bitsPerCode);
-        auto up = unpackNonInterleaved(p, numVecs, dims, bitsPerCode);
+                auto p = packNonInterleaved(data, numVecs, dims, bitsPerCode);
+                auto up = unpackNonInterleaved(p, numVecs, dims, bitsPerCode);
 
-        EXPECT_EQ(data, up);
-      }
+                EXPECT_EQ(data, up);
+            }
+        }
     }
-  }
 }
 
 TEST(TestCodePacking, InterleavedCodes_UnpackPack) {
-  using namespace faiss::gpu;
-
-  // We are fine using non-fixed seeds here, the results should be fully
-  // deterministic
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  std::uniform_int_distribution<uint8_t> dist;
-
-  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
-    for (auto dims : {1, 7, 8, 31, 32}) {
-      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
-        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
-
-        int blocks = utils::divUp(numVecs, 32);
-        int bytesPerDimBlock = 32 * bitsPerCode / 8;
-        int bytesPerBlock = bytesPerDimBlock * dims;
-        int size = blocks * bytesPerBlock;
-
-        std::vector<uint8_t> data(size);
-
-        if (bitsPerCode == 8 || bitsPerCode == 16 || bitsPerCode == 32) {
-          int bytesPerCode = bitsPerCode / 8;
-
-          for (int i = 0; i < blocks; ++i) {
-            for (int j = 0; j < dims; ++j) {
-              for (int k = 0; k < 32; ++k) {
-                for (int l = 0; l < bytesPerCode; ++l) {
-                  int vec = i * 32 + k;
-                  if (vec < numVecs) {
-                    data[i * bytesPerBlock +
-                         j * bytesPerDimBlock +
-                         k * bytesPerCode + l] = dist(gen);
-                  }
-                }
-              }
-            }
-          }
-        } else if (bitsPerCode < 8) {
-          for (int i = 0; i < blocks; ++i) {
-            for (int j = 0; j < dims; ++j) {
-              for (int k = 0; k < bytesPerDimBlock; ++k) {
-                int loVec = i * 32 + (k * 8) / bitsPerCode;
-                int hiVec = loVec + 1;
-                int hiVec2 = hiVec + 1;
-
-                uint8_t lo = loVec < numVecs ?
-                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
-                uint8_t hi = hiVec < numVecs ?
-                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
-                uint8_t hi2 = hiVec2 < numVecs ?
-                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
-
-                uint8_t v = 0;
-                if (bitsPerCode == 4) {
-                  v = lo | (hi << 4);
-                } else if (bitsPerCode == 5) {
-                  switch (k % 5) {
-                    case 0:
-                      // 5 msbs of lower as vOut lsbs
-                      // 3 lsbs of upper as vOut msbs
-                      v = (lo & 0x1f) | (hi << 5);
-                      break;
-                    case 1:
-                      // 2 msbs of lower as vOut lsbs
-                      // 5 lsbs of upper as vOut msbs
-                      // 1 lsbs of upper2 as vOut msb
-                      v = (lo >> 3) | (hi << 2) | (hi2 << 7);
-                      break;
-                    case 2:
-                      // 4 msbs of lower as vOut lsbs
-                      // 4 lsbs of upper as vOut msbs
-                      v = (lo >> 1) | (hi << 4);
-                      break;
-                    case 3:
-                      // 1 msbs of lower as vOut lsbs
-                      // 5 lsbs of upper as vOut msbs
-                      // 2 lsbs of upper2 as vOut msb
-                      v = (lo >> 4) | (hi << 1) | (hi2 << 6);
-                      break;
-                    case 4:
-                      // 3 msbs of lower as vOut lsbs
-                      // 5 lsbs of upper as vOut msbs
-                      v = (lo >> 2) | (hi << 3);
-                      break;
-                  }
-                } else if (bitsPerCode == 6) {
-                  switch (k % 3) {
-                    case 0:
-                      // 6 msbs of lower as vOut lsbs
-                      // 2 lsbs of upper as vOut msbs
-                      v = (lo & 0x3f) | (hi << 6);
-                      break;
-                    case 1:
-                      // 4 msbs of lower as vOut lsbs
-                      // 4 lsbs of upper as vOut msbs
-                      v = (lo >> 2) | (hi << 4);
-                      break;
-                    case 2:
-                      // 2 msbs of lower as vOut lsbs
-                      // 6 lsbs of upper as vOut msbs
-                      v = (lo >> 4) | (hi << 2);
-                      break;
-                  }
+    using namespace faiss::gpu;
+
+    // We are fine using non-fixed seeds here, the results should be fully
+    // deterministic
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<uint8_t> dist;
+
+    for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+        for (auto dims : {1, 7, 8, 31, 32}) {
+            for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+                std::cout << bitsPerCode << " " << dims << " " << numVecs
+                          << "\n";
+
+                int blocks = utils::divUp(numVecs, 32);
+                int bytesPerDimBlock = 32 * bitsPerCode / 8;
+                int bytesPerBlock = bytesPerDimBlock * dims;
+                int size = blocks * bytesPerBlock;
+
+                std::vector<uint8_t> data(size);
+
+                if (bitsPerCode == 8 || bitsPerCode == 16 ||
+                    bitsPerCode == 32) {
+                    int bytesPerCode = bitsPerCode / 8;
+
+                    for (int i = 0; i < blocks; ++i) {
+                        for (int j = 0; j < dims; ++j) {
+                            for (int k = 0; k < 32; ++k) {
+                                for (int l = 0; l < bytesPerCode; ++l) {
+                                    int vec = i * 32 + k;
+                                    if (vec < numVecs) {
+                                        data[i * bytesPerBlock +
+                                             j * bytesPerDimBlock +
+                                             k * bytesPerCode + l] = dist(gen);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else if (bitsPerCode < 8) {
+                    for (int i = 0; i < blocks; ++i) {
+                        for (int j = 0; j < dims; ++j) {
+                            for (int k = 0; k < bytesPerDimBlock; ++k) {
+                                int loVec = i * 32 + (k * 8) / bitsPerCode;
+                                int hiVec = loVec + 1;
+                                int hiVec2 = hiVec + 1;
+
+                                uint8_t lo = loVec < numVecs ? dist(gen) &
+                                                (0xff >> (8 - bitsPerCode))
+                                                             : 0;
+                                uint8_t hi = hiVec < numVecs ? dist(gen) &
+                                                (0xff >> (8 - bitsPerCode))
+                                                             : 0;
+                                uint8_t hi2 = hiVec2 < numVecs ? dist(gen) &
+                                                (0xff >> (8 - bitsPerCode))
+                                                               : 0;
+
+                                uint8_t v = 0;
+                                if (bitsPerCode == 4) {
+                                    v = lo | (hi << 4);
+                                } else if (bitsPerCode == 5) {
+                                    switch (k % 5) {
+                                        case 0:
+                                            // 5 msbs of lower as vOut lsbs
+                                            // 3 lsbs of upper as vOut msbs
+                                            v = (lo & 0x1f) | (hi << 5);
+                                            break;
+                                        case 1:
+                                            // 2 msbs of lower as vOut lsbs
+                                            // 5 lsbs of upper as vOut msbs
+                                            // 1 lsbs of upper2 as vOut msb
+                                            v = (lo >> 3) | (hi << 2) |
+                                                    (hi2 << 7);
+                                            break;
+                                        case 2:
+                                            // 4 msbs of lower as vOut lsbs
+                                            // 4 lsbs of upper as vOut msbs
+                                            v = (lo >> 1) | (hi << 4);
+                                            break;
+                                        case 3:
+                                            // 1 msbs of lower as vOut lsbs
+                                            // 5 lsbs of upper as vOut msbs
+                                            // 2 lsbs of upper2 as vOut msb
+                                            v = (lo >> 4) | (hi << 1) |
+                                                    (hi2 << 6);
+                                            break;
+                                        case 4:
+                                            // 3 msbs of lower as vOut lsbs
+                                            // 5 lsbs of upper as vOut msbs
+                                            v = (lo >> 2) | (hi << 3);
+                                            break;
+                                    }
+                                } else if (bitsPerCode == 6) {
+                                    switch (k % 3) {
+                                        case 0:
+                                            // 6 msbs of lower as vOut lsbs
+                                            // 2 lsbs of upper as vOut msbs
+                                            v = (lo & 0x3f) | (hi << 6);
+                                            break;
+                                        case 1:
+                                            // 4 msbs of lower as vOut lsbs
+                                            // 4 lsbs of upper as vOut msbs
+                                            v = (lo >> 2) | (hi << 4);
+                                            break;
+                                        case 2:
+                                            // 2 msbs of lower as vOut lsbs
+                                            // 6 lsbs of upper as vOut msbs
+                                            v = (lo >> 4) | (hi << 2);
+                                            break;
+                                    }
+                                } else {
+                                    // unimplemented
+                                    EXPECT_TRUE(false);
+                                }
+
+                                data[i * bytesPerBlock + j * bytesPerDimBlock +
+                                     k] = v;
+                            }
+                        }
+                    }
                 } else {
-                  // unimplemented
-                  EXPECT_TRUE(false);
+                    // unimplemented
+                    EXPECT_TRUE(false);
                 }
 
-                data[i * bytesPerBlock + j * bytesPerDimBlock + k] = v;
-              }
+                auto up = unpackInterleaved(data, numVecs, dims, bitsPerCode);
+                auto p = packInterleaved(up, numVecs, dims, bitsPerCode);
+
+                EXPECT_EQ(data, p);
             }
-          }
-        } else {
-          // unimplemented
-          EXPECT_TRUE(false);
         }
-
-        auto up = unpackInterleaved(data, numVecs, dims, bitsPerCode);
-        auto p = packInterleaved(up, numVecs, dims, bitsPerCode);
-
-        EXPECT_EQ(data, p);
-      }
     }
-  }
 }
 
 TEST(TestCodePacking, InterleavedCodes_PackUnpack) {
-  using namespace faiss::gpu;
-
-  // We are fine using non-fixed seeds here, the results should be fully
-  // deterministic
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  std::uniform_int_distribution<uint8_t> dist;
-
-  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
-    for (auto dims : {1, 7, 8, 31, 32}) {
-      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
-        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
-
-        std::vector<uint8_t> data(numVecs * dims * utils::divUp(bitsPerCode, 8));
-
-        if (bitsPerCode == 8 || bitsPerCode == 16 || bitsPerCode == 32) {
-          for (auto& v : data) {
-            v = dist(gen);
-          }
-        } else if (bitsPerCode < 8) {
-          uint8_t mask = 0xff >> (8 - bitsPerCode);
-
-          for (auto& v : data) {
-            v = dist(gen) & mask;
-          }
-        } else {
-          // unimplemented
-          EXPECT_TRUE(false);
-        }
+    using namespace faiss::gpu;
+
+    // We are fine using non-fixed seeds here, the results should be fully
+    // deterministic
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<uint8_t> dist;
+
+    for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+        for (auto dims : {1, 7, 8, 31, 32}) {
+            for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+                std::cout << bitsPerCode << " " << dims << " " << numVecs
+                          << "\n";
+
+                std::vector<uint8_t> data(
+                        numVecs * dims * utils::divUp(bitsPerCode, 8));
+
+                if (bitsPerCode == 8 || bitsPerCode == 16 ||
+                    bitsPerCode == 32) {
+                    for (auto& v : data) {
+                        v = dist(gen);
+                    }
+                } else if (bitsPerCode < 8) {
+                    uint8_t mask = 0xff >> (8 - bitsPerCode);
+
+                    for (auto& v : data) {
+                        v = dist(gen) & mask;
+                    }
+                } else {
+                    // unimplemented
+                    EXPECT_TRUE(false);
+                }
 
-        auto p = packInterleaved(data, numVecs, dims, bitsPerCode);
-        auto up = unpackInterleaved(p, numVecs, dims, bitsPerCode);
+                auto p = packInterleaved(data, numVecs, dims, bitsPerCode);
+                auto up = unpackInterleaved(p, numVecs, dims, bitsPerCode);
 
-        EXPECT_EQ(data, up);
-      }
+                EXPECT_EQ(data, up);
+            }
+        }
     }
-  }
 }
 
 int main(int argc, char** argv) {
-  testing::InitGoogleTest(&argc, argv);
+    testing::InitGoogleTest(&argc, argv);
 
-  return RUN_ALL_TESTS();
+    return RUN_ALL_TESTS();
 }