clang-format | Format fbsource with clang-format 21.

Reviewed By: ChristianK275

Differential Revision: D85317706

fbshipit-source-id: b399c5c4b75252999442b7d7d2778e7a241b0025

demos/rocksdb_ivf/RocksDBInvertedLists.cpp

@@ -22,14 +22,17 @@ RocksDBInvertedListsIterator::RocksDBInvertedListsIterator(
           list_no(list_no),
           code_size(code_size),
           codes(code_size) {
-    it->Seek(rocksdb::Slice(
-            reinterpret_cast<const char*>(&list_no), sizeof(size_t)));
+    it->Seek(
+            rocksdb::Slice(
+                    reinterpret_cast<const char*>(&list_no), sizeof(size_t)));
 }
 
 bool RocksDBInvertedListsIterator::is_available() const {
     return it->Valid() &&
-            it->key().starts_with(rocksdb::Slice(
-                    reinterpret_cast<const char*>(&list_no), sizeof(size_t)));
+            it->key().starts_with(
+                    rocksdb::Slice(
+                            reinterpret_cast<const char*>(&list_no),
+                            sizeof(size_t)));
 }
 
 void RocksDBInvertedListsIterator::next() {

faiss/IndexBinaryHNSW.cpp

@@ -290,7 +290,9 @@ struct FlatHammingDis : DistanceComputer {
 
     ~FlatHammingDis() override {
 #pragma omp critical
-        { hnsw_stats.ndis += ndis; }
+        {
+            hnsw_stats.ndis += ndis;
+        }
     }
 };
 

faiss/IndexBinaryIVF.cpp

@@ -492,12 +492,13 @@ void search_knn_hamming_count(
 
     std::vector<HCounterState<HammingComputer>> cs;
     for (size_t i = 0; i < nx; ++i) {
-        cs.push_back(HCounterState<HammingComputer>(
-                all_counters.data() + i * nBuckets,
-                all_ids_per_dis.get() + i * nBuckets * k,
-                x + i * ivf->code_size,
-                ivf->d,
-                k));
+        cs.push_back(
+                HCounterState<HammingComputer>(
+                        all_counters.data() + i * nBuckets,
+                        all_ids_per_dis.get() + i * nBuckets * k,
+                        x + i * ivf->code_size,
+                        ivf->d,
+                        k));
     }
 
     size_t nlistv = 0, ndis = 0;

faiss/IndexFastScan.cpp

@@ -506,16 +506,17 @@ void IndexFastScan::search_implem_12(
             pq4_pack_LUT_qbs(qbs, M2, quantized_dis_tables.get(), LUT.get());
     FAISS_THROW_IF_NOT(LUT_nq == n);
 
-    std::unique_ptr<RH> handler(static_cast<RH*>(make_knn_handler(
-            C::is_max,
-            impl,
-            n,
-            k,
-            ntotal,
-            distances,
-            labels,
-            nullptr,
-            context)));
+    std::unique_ptr<RH> handler(
+            static_cast<RH*>(make_knn_handler(
+                    C::is_max,
+                    impl,
+                    n,
+                    k,
+                    ntotal,
+                    distances,
+                    labels,
+                    nullptr,
+                    context)));
 
     handler->disable = bool(skip & 2);
     handler->normalizers = normalizers.get();
@@ -588,16 +589,17 @@ void IndexFastScan::search_implem_14(
     AlignedTable<uint8_t> LUT(n * dim12);
     pq4_pack_LUT(n, M2, quantized_dis_tables.get(), LUT.get());
 
-    std::unique_ptr<RH> handler(static_cast<RH*>(make_knn_handler(
-            C::is_max,
-            impl,
-            n,
-            k,
-            ntotal,
-            distances,
-            labels,
-            nullptr,
-            context)));
+    std::unique_ptr<RH> handler(
+            static_cast<RH*>(make_knn_handler(
+                    C::is_max,
+                    impl,
+                    n,
+                    k,
+                    ntotal,
+                    distances,
+                    labels,
+                    nullptr,
+                    context)));
     handler->disable = bool(skip & 2);
     handler->normalizers = normalizers.get();
 

faiss/IndexHNSW.cpp

@@ -450,7 +450,9 @@ void IndexHNSW::search_level_0(
             vt.advance();
         }
 #pragma omp critical
-        { hnsw_stats.combine(search_stats); }
+        {
+            hnsw_stats.combine(search_stats);
+        }
     }
     if (is_similarity_metric(this->metric_type)) {
 // we need to revert the negated distances

faiss/IndexIVFPQ.cpp

@@ -1163,7 +1163,9 @@ struct IVFPQScannerT : QueryTables {
         }
 
 #pragma omp critical
-        { indexIVFPQ_stats.n_hamming_pass += n_hamming_pass; }
+        {
+            indexIVFPQ_stats.n_hamming_pass += n_hamming_pass;
+        }
     }
 
     template <class SearchResultType>

faiss/gpu/GpuIcmEncoder.cu

@@ -24,9 +24,10 @@ struct IcmEncoderShards {
             workers;
 
     void add(IcmEncoderImpl* encoder) {
-        workers.emplace_back(std::make_pair(
-                std::unique_ptr<IcmEncoderImpl>(encoder),
-                std::unique_ptr<WorkerThread>(new WorkerThread)));
+        workers.emplace_back(
+                std::make_pair(
+                        std::unique_ptr<IcmEncoderImpl>(encoder),
+                        std::unique_ptr<WorkerThread>(new WorkerThread)));
     }
 
     IcmEncoderImpl* at(int idx) {

faiss/gpu/impl/GeneralDistance.cuh

@@ -137,8 +137,9 @@ __launch_bounds__(TILE_SIZE* TILE_SIZE) __global__ void generalDistance(
             __syncthreads();
 
             // thread (y, x) does (query y, vec x)
-            acc.combine(reduce<T, 8, kDimMultiple, DistanceOp>(
-                    op, queryTile, vecTile));
+            acc.combine(
+                    reduce<T, 8, kDimMultiple, DistanceOp>(
+                            op, queryTile, vecTile));
 
             __syncthreads();
         }

faiss/gpu/impl/GpuScalarQuantizer.cuh

@@ -37,10 +37,11 @@ inline bool isSQSupported(ScalarQuantizer::QuantizerType qtype) {
 struct GpuScalarQuantizer : public ScalarQuantizer {
     GpuScalarQuantizer(GpuResources* res, const ScalarQuantizer& sq)
             : ScalarQuantizer(sq),
-              gpuTrained(DeviceTensor<float, 1, true>(
-                      res,
-                      makeDevAlloc(AllocType::Quantizer, 0),
-                      {(idx_t)sq.trained.size()})) {
+              gpuTrained(
+                      DeviceTensor<float, 1, true>(
+                              res,
+                              makeDevAlloc(AllocType::Quantizer, 0),
+                              {(idx_t)sq.trained.size()})) {
         HostTensor<float, 1, true> cpuTrained(
                 (float*)sq.trained.data(), {(idx_t)sq.trained.size()});
 

faiss/gpu/impl/IVFBase.cu

@@ -119,11 +119,13 @@ void IVFBase::reset() {
             AllocInfo(AllocType::IVFLists, getCurrentDevice(), space_, stream);
 
     for (idx_t i = 0; i < numLists_; ++i) {
-        deviceListData_.emplace_back(std::unique_ptr<DeviceIVFList>(
-                new DeviceIVFList(resources_, info)));
+        deviceListData_.emplace_back(
+                std::unique_ptr<DeviceIVFList>(
+                        new DeviceIVFList(resources_, info)));
 
-        deviceListIndices_.emplace_back(std::unique_ptr<DeviceIVFList>(
-                new DeviceIVFList(resources_, info)));
+        deviceListIndices_.emplace_back(
+                std::unique_ptr<DeviceIVFList>(
+                        new DeviceIVFList(resources_, info)));
 
         listOffsetToUserIndex_.emplace_back(std::vector<idx_t>());
     }

faiss/gpu/utils/DeviceTensor-inl.cuh

@@ -15,8 +15,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor()
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>() {}
 
@@ -25,8 +24,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>&& t)
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>() {
@@ -38,8 +36,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>& DeviceTensor<
         T,
         Dim,
@@ -59,8 +56,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::~DeviceTensor() {
 }
 
@@ -69,8 +65,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         GpuResources* res,
         const AllocInfo& info,
@@ -88,8 +83,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         GpuResources* res,
         const AllocInfo& info,
@@ -107,8 +101,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         DataPtrType data,
         const IndexT sizes[Dim])
@@ -119,8 +112,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         DataPtrType data,
         std::initializer_list<IndexT> sizes)
@@ -131,8 +123,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         DataPtrType data,
         const IndexT sizes[Dim],
@@ -145,8 +136,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>::DeviceTensor(
         GpuResources* res,
         const AllocInfo& info,
@@ -169,8 +159,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ DeviceTensor<T, Dim, InnerContig, IndexT, PtrTraits>& DeviceTensor<
         T,
         Dim,

faiss/gpu/utils/HostTensor-inl.cuh

@@ -13,8 +13,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor()
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>(),
           state_(AllocState::NotOwner) {}
@@ -24,8 +23,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::~HostTensor() {
     if (state_ == AllocState::Owner) {
         FAISS_ASSERT(this->data_ != nullptr);
@@ -39,8 +37,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>&& t)
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>(),
@@ -53,8 +50,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>& HostTensor<
         T,
         Dim,
@@ -82,8 +78,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         const IndexT sizes[Dim])
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>(nullptr, sizes),
@@ -97,8 +92,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         std::initializer_list<IndexT> sizes)
         : Tensor<T, Dim, InnerContig, IndexT, PtrTraits>(nullptr, sizes),
@@ -112,8 +106,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         DataPtrType data,
         const IndexT sizes[Dim])
@@ -125,8 +118,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         DataPtrType data,
         std::initializer_list<IndexT> sizes)
@@ -138,8 +130,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         DataPtrType data,
         const IndexT sizes[Dim],
@@ -152,8 +143,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::HostTensor(
         const Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& t,
         cudaStream_t stream)
@@ -175,8 +165,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>& HostTensor<
         T,
         Dim,
@@ -198,8 +187,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ T HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>::maxDiff(
         const HostTensor<T, Dim, InnerContig, IndexT, PtrTraits>& t) const {
     auto size = this->numElements();

faiss/gpu/utils/Tensor-inl.cuh

@@ -18,8 +18,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor()
         : data_(nullptr) {
     static_assert(Dim > 0, "must have > 0 dimensions");
@@ -35,8 +34,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor(
         Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& t) {
     this->operator=(t);
@@ -47,8 +45,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor(
         Tensor<T, Dim, InnerContig, IndexT, PtrTraits>&& t) {
     this->operator=(std::move(t));
@@ -59,8 +56,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& Tensor<
         T,
         Dim,
@@ -82,8 +78,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& Tensor<
         T,
         Dim,
@@ -108,8 +103,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor(
         DataPtrType data,
         const IndexT sizes[Dim])
@@ -131,8 +125,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor(
         DataPtrType data,
         std::initializer_list<IndexT> sizes)
@@ -156,8 +149,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::Tensor(
         DataPtrType data,
         const IndexT sizes[Dim],
@@ -176,8 +168,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ void Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::copyFrom(
         const Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& t,
         cudaStream_t stream) {
@@ -221,8 +212,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ void Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::copyTo(
         Tensor<T, Dim, InnerContig, IndexT, PtrTraits>& t,
         cudaStream_t stream) {
@@ -266,8 +256,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ void Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::copyFrom(
         const std::vector<T>& v,
         cudaStream_t stream) {
@@ -295,8 +284,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ std::vector<T> Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         copyToVector(cudaStream_t stream) {
     // The tensor must be fully contiguous
@@ -328,8 +316,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename OtherT, int OtherDim>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::isSame(
         const Tensor<OtherT, OtherDim, InnerContig, IndexT, PtrTraits>& rhs)
@@ -356,8 +343,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename OtherT, int OtherDim>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         isSameSize(
@@ -381,8 +367,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename U>
 __host__ __device__ Tensor<U, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -401,8 +386,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename U>
 __host__ __device__ const Tensor<U, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -421,8 +405,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename U>
 __host__ __device__ Tensor<U, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -455,8 +438,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename U>
 __host__ __device__ const Tensor<U, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -473,8 +455,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename U>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         canCastResize() const {
@@ -510,8 +491,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename NewIndexT>
 __host__ Tensor<T, Dim, InnerContig, NewIndexT, PtrTraits> Tensor<
         T,
@@ -539,8 +519,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <typename NewIndexT>
 __host__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::canUseIndexType()
         const {
@@ -571,8 +550,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ IndexT
 Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::numElements() const {
     auto size = getSize(0);
@@ -589,8 +567,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         isContiguous() const {
     IndexT prevSize = 1;
@@ -613,8 +590,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         isConsistentlySized(int i) const {
     if (i == 0 && getStride(i) > 0 && getSize(i) > 0) {
@@ -633,8 +609,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         isConsistentlySized() const {
     for (int i = 0; i < Dim; ++i) {
@@ -651,8 +626,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ bool Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::
         isContiguousDim(int i) const {
     return (i == Dim - 1) || // just in case
@@ -665,8 +639,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
         Dim,
@@ -706,8 +679,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, false, IndexT, PtrTraits> Tensor<
         T,
         Dim,
@@ -743,8 +715,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int NewDim>
 __host__ __device__ Tensor<T, NewDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -781,8 +752,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int NewDim>
 __host__ __device__ Tensor<T, NewDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -817,8 +787,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int NewDim>
 __host__ __device__ Tensor<T, NewDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -871,8 +840,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int NewDim>
 __host__ __device__ Tensor<T, NewDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -923,8 +891,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int SubDim>
 __host__ __device__ Tensor<T, SubDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -952,8 +919,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int SubDim>
 __host__ __device__ Tensor<T, SubDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
@@ -969,8 +935,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
         Dim,
@@ -985,8 +950,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ Tensor<T, Dim, InnerContig, IndexT, PtrTraits> Tensor<
         T,
         Dim,
@@ -1022,8 +986,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 template <int NewDim>
 __host__ __device__ Tensor<T, NewDim, InnerContig, IndexT, PtrTraits> Tensor<
         T,

faiss/gpu/utils/Tensor.cuh

@@ -28,8 +28,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 class Tensor;
 
 /// Type of a subspace of a tensor
@@ -37,8 +36,7 @@ namespace detail {
 template <
         typename TensorType,
         int SubDim,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 class SubTensor;
 }
 
@@ -412,12 +410,12 @@ class SubTensor<TensorType, 0, PtrTraits> {
     }
 
     // operator T&
-    __host__ __device__ operator typename TensorType::DataType &() {
+    __host__ __device__ operator typename TensorType::DataType&() {
         return *data_;
     }
 
     // const operator T& returning const T&
-    __host__ __device__ operator const typename TensorType::DataType &() const {
+    __host__ __device__ operator const typename TensorType::DataType&() const {
         return *data_;
     }
 
@@ -514,8 +512,7 @@ class SubTensor<TensorType, 0, PtrTraits> {
 template <
         typename TensorType,
         int SubDim,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 class SubTensor {
    public:
     /// Returns a view of the data located at our offset (the dimension
@@ -664,8 +661,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ inline detail::SubTensor<
         Tensor<T, Dim, InnerContig, IndexT, PtrTraits>,
         Dim - 1,
@@ -680,8 +676,7 @@ template <
         int Dim,
         bool InnerContig,
         typename IndexT,
-        template <typename U>
-        class PtrTraits>
+        template <typename U> class PtrTraits>
 __host__ __device__ inline const detail::SubTensor<
         Tensor<T, Dim, InnerContig, IndexT, PtrTraits>,
         Dim - 1,

faiss/gpu/utils/warpselect/WarpSelectImpl.cuh

@@ -27,8 +27,9 @@
             cudaStream_t stream) {                                             \
         int warpSize = getWarpSizeCurrentDevice();                             \
         constexpr int kWarpSelectNumThreads = 128;                             \
-        auto grid = dim3(utils::divUp(                                         \
-                in.getSize(0), (kWarpSelectNumThreads / warpSize)));           \
+        auto grid =                                                            \
+                dim3(utils::divUp(                                             \
+                        in.getSize(0), (kWarpSelectNumThreads / warpSize)));   \
         auto block = dim3(kWarpSelectNumThreads);                              \
                                                                                \
         FAISS_ASSERT(k <= WARP_Q);                                             \

faiss/impl/ThreadedIndex-inl.h

@@ -77,10 +77,11 @@ void ThreadedIndex<IndexT>::addIndex(IndexT* index) {
         }
     }
 
-    indices_.emplace_back(std::make_pair(
-            index,
-            std::unique_ptr<WorkerThread>(
-                    isThreaded_ ? new WorkerThread : nullptr)));
+    indices_.emplace_back(
+            std::make_pair(
+                    index,
+                    std::unique_ptr<WorkerThread>(
+                            isThreaded_ ? new WorkerThread : nullptr)));
 
     onAfterAddIndex(index);
 }

faiss/utils/hamming.cpp

@@ -257,12 +257,13 @@ void hammings_knn_mc(
 
     std::vector<HCounterState<HammingComputer>> cs;
     for (size_t i = 0; i < na; ++i) {
-        cs.push_back(HCounterState<HammingComputer>(
-                all_counters.data() + i * nBuckets,
-                all_ids_per_dis.get() + i * nBuckets * k,
-                a + i * bytes_per_code,
-                8 * bytes_per_code,
-                k));
+        cs.push_back(
+                HCounterState<HammingComputer>(
+                        all_counters.data() + i * nBuckets,
+                        all_ids_per_dis.get() + i * nBuckets * k,
+                        a + i * bytes_per_code,
+                        8 * bytes_per_code,
+                        k));
     }
 
     const size_t block_size = hamming_batch_size;

faiss/utils/simdlib_neon.h

@@ -805,8 +805,8 @@ struct simd32uint8 {
         uint8_t bytes[32];
         store(bytes);
         detail::simdlib::bin(
-                const_cast<const char(&)[32]>(
-                        reinterpret_cast<char(&)[32]>(bytes)),
+                const_cast<const char (&)[32]>(
+                        reinterpret_cast<char (&)[32]>(bytes)),
                 bits);
     }
 

tests/test_common_ivf_empty_index.cpp

@@ -76,8 +76,9 @@ TEST(COMMON, test_common_trained_index) {
 
     // construct and build an "empty index": a trained index that does not
     // itself hold any data
-    std::unique_ptr<faiss::IndexIVF> empty_index(dynamic_cast<faiss::IndexIVF*>(
-            faiss::index_factory(d, "IVF32,PQ8np")));
+    std::unique_ptr<faiss::IndexIVF> empty_index(
+            dynamic_cast<faiss::IndexIVF*>(
+                    faiss::index_factory(d, "IVF32,PQ8np")));
     auto xt = get_random_vectors(nt, 123);
     empty_index->train(nt, xt.data());
     empty_index->nprobe = 4;

tests/test_transfer_invlists.cpp

@@ -125,7 +125,9 @@ void test_index_type(const char* factory_string) {
                             read_InvertedLists(&reader)));
 
             // swap inverted lists. Block searches here!
-            { ivflib::set_invlist_range(dst_index.get(), i0, i1, il.get()); }
+            {
+                ivflib::set_invlist_range(dst_index.get(), i0, i1, il.get());
+            }
         }
     }
     EXPECT_EQ(dst_index->ntotal, src_index->ntotal);