Fix typos in utils and GPU directories (#4671)

Subhadeep Karan · meta-codesync[bot] · commit 29f8e7263bff · 2025-11-12T00:15:58.000-08:00
Summary: Pull Request resolved: #4671 Fixed typos in comments, documentation, and code across utils/ and gpu/ directories: utils/: - Fixed 33 typos including variable names (bissect_cycles) - Fixed array index typos in approx_topk.h pseudocode - Fixed comment typos in SIMD libraries, partitioning, heap, etc. gpu/: - Fixed 23 typos across CUDA and C++ GPU implementation files - Fixed variable name typo: queryNormNiew → queryNormView - Fixed parameter name typo: chuk_size → chunk_size - Fixed common typo 'neigbors' → 'neighbors' (5 occurrences) All changes are in comments/documentation except for critical variable name fixes. Reviewed By: alibeklfc Differential Revision: D86571371 fbshipit-source-id: 71c88150ca38ac7dbf11b8aab4f623c6c0043531
diff --git a/faiss/gpu/GpuIndexCagra.cu b/faiss/gpu/GpuIndexCagra.cu
@@ -362,7 +362,7 @@ void GpuIndexCagra::copyFrom_ex(
         FAISS_ASSERT(base_index);
         auto dataset = (uint8_t*)base_index->codes.data();
 
-        // decode what was encded by Quantizer8bitDirectSigned in
+        // decode what was encoded by Quantizer8bitDirectSigned in
         // ScalarQuantizer
         int8_t* decoded_train_dataset = new int8_t[index->ntotal * index->d];
         for (int i = 0; i < index->ntotal * this->d; i++) {
diff --git a/faiss/gpu/impl/CuvsIVFFlat.cuh b/faiss/gpu/impl/CuvsIVFFlat.cuh
@@ -135,7 +135,7 @@ struct CuvsIVFFlatCodePackerInterleaved : CodePacker {
     CuvsIVFFlatCodePackerInterleaved(
             size_t list_size,
             uint32_t dim,
-            uint32_t chuk_size);
+            uint32_t chunk_size);
     void pack_1(const uint8_t* flat_code, size_t offset, uint8_t* block)
             const final;
     void unpack_1(const uint8_t* block, size_t offset, uint8_t* flat_code)
diff --git a/faiss/gpu/impl/Distance.cu b/faiss/gpu/impl/Distance.cu
@@ -254,7 +254,7 @@ void runDistance(
 
         auto queryView =
                 queries.narrow(queriesRowMajor ? 0 : 1, i, curQuerySize);
-        auto queryNormNiew = queryNorms.narrow(0, i, curQuerySize);
+        auto queryNormView = queryNorms.narrow(0, i, curQuerySize);
 
         auto outDistanceBufRowView =
                 outDistanceBufs[curStream]->narrow(0, 0, curQuerySize);
@@ -321,7 +321,7 @@ void runDistance(
                         // along rows top-k ||c||^2 - 2qc + ||q||^2 in the form
                         // (query id, k)
                         runSumAlongRows(
-                                queryNormNiew,
+                                queryNormView,
                                 outDistanceView,
                                 true, // L2 distances should not go below zero
                                       // due to roundoff error
@@ -345,7 +345,7 @@ void runDistance(
                         // along rows top-k ||c||^2 - 2qc + ||q||^2 in the form
                         // (query id, k)
                         runSumAlongRows(
-                                queryNormNiew,
+                                queryNormView,
                                 outDistanceBufColView,
                                 true, // L2 distances should not go below zero
                                       // due to roundoff error
diff --git a/faiss/gpu/impl/IVFAppend.cu b/faiss/gpu/impl/IVFAppend.cu
@@ -22,7 +22,7 @@ namespace faiss {
 namespace gpu {
 
 //
-// IVF list metadata aupdate
+// IVF list metadata update
 //
 
 // Updates the device-size array of list start pointers for codes and indices
diff --git a/faiss/gpu/impl/IVFBase.cuh b/faiss/gpu/impl/IVFBase.cuh
@@ -87,7 +87,7 @@ class IVFBase {
             Tensor<float, 2, true>& vecs,
             Tensor<idx_t, 1, true>& indices);
 
-    /// Find the approximate k nearest neigbors for `queries` against
+    /// Find the approximate k nearest neighbors for `queries` against
     /// our database
     virtual void search(
             Index* coarseQuantizer,
diff --git a/faiss/gpu/impl/IVFFlat.cuh b/faiss/gpu/impl/IVFFlat.cuh
@@ -29,7 +29,7 @@ class IVFFlat : public IVFBase {
 
     ~IVFFlat() override;
 
-    /// Find the approximate k nearest neigbors for `queries` against
+    /// Find the approximate k nearest neighbors for `queries` against
     /// our database
     void search(
             Index* coarseQuantizer,
diff --git a/faiss/gpu/impl/IVFPQ.cu b/faiss/gpu/impl/IVFPQ.cu
@@ -300,7 +300,7 @@ std::vector<uint8_t> IVFPQ::translateCodesToGpu_(
             std::move(up), numVecs, numSubQuantizers_, bitsPerSubQuantizer_);
 }
 
-// Conver the GPU layout to the CPU layout
+// Convert the GPU layout to the CPU layout
 std::vector<uint8_t> IVFPQ::translateCodesFromGpu_(
         std::vector<uint8_t> codes,
         idx_t numVecs) const {
diff --git a/faiss/gpu/impl/IVFPQ.cuh b/faiss/gpu/impl/IVFPQ.cuh
@@ -45,7 +45,7 @@ class IVFPQ : public IVFBase {
     /// (sub q)(code id)(sub dim)
     Tensor<float, 3, true> getPQCentroids();
 
-    /// Find the approximate k nearest neigbors for `queries` against
+    /// Find the approximate k nearest neighbors for `queries` against
     /// our database
     void search(
             Index* coarseQuantizer,
diff --git a/faiss/gpu/impl/IVFUtils.cu b/faiss/gpu/impl/IVFUtils.cu
@@ -39,7 +39,7 @@ size_t getIVFPerQueryTempMemory(size_t k, size_t nprobe, size_t maxListLength) {
     // Storage for all distances from all the IVF lists we are processing
     size_t allDistances = nprobe * maxListLength * sizeof(float);
 
-    // There are 2 streams on which computations is performed (hence the 2 *)
+    // There are 2 streams on which computation is performed (hence the 2 *)
     return 2 * (prefixSumOffsets + allDistances + sizeForFirstSelectPass);
 }
 
@@ -57,7 +57,7 @@ size_t getIVFPQPerQueryTempMemory(
             : (nprobe * numSubQuantizers * numSubQuantizerCodes *
                sizeof(float));
 
-    // There are 2 streams on which computations is performed (hence the 2 *)
+    // There are 2 streams on which computation is performed (hence the 2 *)
     // The IVF-generic temp memory allocation already takes this multi-streaming
     // into account, but we need to do so for the PQ residual distances too
     return (2 * residualDistances) +
diff --git a/faiss/gpu/impl/IcmEncoder.cuh b/faiss/gpu/impl/IcmEncoder.cuh
@@ -24,7 +24,7 @@ struct IcmEncoderImpl {
     std::shared_ptr<GpuResources> res;
     int device;
 
-    DeviceTensor<float, 4, true> bterm;     ///< bianry terms, size [M, M, K, K]
+    DeviceTensor<float, 4, true> bterm;     ///< binary terms, size [M, M, K, K]
     DeviceTensor<float, 3, true> codebooks; ///< codebooks, size [M, K, dims]
 
     IcmEncoderImpl(
diff --git a/faiss/gpu/test/TestGpuIndexIVFFlat.cpp b/faiss/gpu/test/TestGpuIndexIVFFlat.cpp
@@ -493,7 +493,7 @@ TEST(TestGpuIndexIVFFlat, Float32_negative) {
     // Construct a positive test set
     auto queryVecs = faiss::gpu::randVecs(opt.numQuery, opt.dim);
 
-    // Put all vecs on positive size
+    // Put all vecs on positive side
     for (auto& f : queryVecs) {
         f = std::abs(f);
     }
diff --git a/faiss/gpu/utils/MergeNetworkWarp.cuh b/faiss/gpu/utils/MergeNetworkWarp.cuh
@@ -38,7 +38,7 @@ namespace gpu {
 // template specialization / expansion and constexpr, and it uses warp
 // shuffles to exchange values between warp lanes.
 //
-// A note about comparsions:
+// A note about comparisons:
 //
 // For a sorting network of keys only, we only need one
 // comparison (a < b). However, what we really need to know is
@@ -74,7 +74,7 @@ namespace gpu {
 // I have tried both re-arranging the order in the higher lane to get
 // away with one comparison or adding the value to the check; both
 // result in greater register consumption or lower speed than just
-// perfoming both < and > comparisons with the variables, so I just
+// performing both < and > comparisons with the variables, so I just
 // stick with this.
 
 // This function merges kWarpSize / 2L lists in parallel using warp
diff --git a/faiss/gpu/utils/Tensor-inl.cuh b/faiss/gpu/utils/Tensor-inl.cuh
@@ -176,7 +176,7 @@ __host__ void Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::copyFrom(
     GPU_FAISS_ASSERT(this->isContiguous());
 
     // Size must be the same (since dimensions are checked and
-    // continuity is assumed, we need only check total number of
+    // contiguity is assumed, we need only check total number of
     // elements
     GPU_FAISS_ASSERT(this->numElements() == t.numElements());
 
@@ -220,7 +220,7 @@ __host__ void Tensor<T, Dim, InnerContig, IndexT, PtrTraits>::copyTo(
     GPU_FAISS_ASSERT(this->isContiguous());
 
     // Size must be the same (since dimensions are checked and
-    // continuity is assumed, we need only check total number of
+    // contiguity is assumed, we need only check total number of
     // elements
     GPU_FAISS_ASSERT(this->numElements() == t.numElements());
 
diff --git a/faiss/gpu/utils/WarpPackedBits.cuh b/faiss/gpu/utils/WarpPackedBits.cuh
@@ -134,11 +134,11 @@ struct WarpPackedBits<uint8_t, 5> {
             uint8_t v,
             bool valid,
             uint8_t* out) {
-        // Lower 24 lanes wwrite out packed data
+        // Lower 24 lanes write out packed data
         int laneFrom = (laneId * 8) / 5;
 
         v = valid ? v : 0;
-        v &= 0x1f; // ensure we have only 6 bits
+        v &= 0x1f; // ensure we have only 5 bits
 
         uint8_t lo = (uint8_t)SHFL_SYNC((unsigned int)v, laneFrom, kWarpSize);
         uint8_t hi =
diff --git a/faiss/utils/AlignedTable.h b/faiss/utils/AlignedTable.h
@@ -25,7 +25,7 @@ inline bool is_aligned_pointer(const void* x) {
 }
 
 // class that manages suitably aligned arrays for SIMD
-// T should be a POV type. The default alignment is 32 for AVX
+// T should be a POD type. The default alignment is 32 for AVX
 template <class T, int A = 32>
 struct AlignedTableTightAlloc {
     T* ptr;
diff --git a/faiss/utils/Heap.cpp b/faiss/utils/Heap.cpp
@@ -139,7 +139,7 @@ void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
     }
 }
 
-// explicit instanciations
+// explicit instantiations
 
 template struct HeapArray<CMin<float, int64_t>>;
 template struct HeapArray<CMax<float, int64_t>>;
@@ -238,7 +238,7 @@ void merge_knn_results(
     }
 }
 
-// explicit instanciations
+// explicit instantiations
 #define INSTANTIATE(C, distance_t)                                \
     template void merge_knn_results<int64_t, C<distance_t, int>>( \
             size_t,                                               \
diff --git a/faiss/utils/Heap.h b/faiss/utils/Heap.h
@@ -150,7 +150,7 @@ inline void heap_replace_top(
     bh_ids[i] = id;
 }
 
-/* Partial instanciation for heaps with TI = int64_t */
+/* Partial instantiation for heaps with TI = int64_t */
 
 template <typename T>
 inline void minheap_pop(size_t k, T* bh_val, int64_t* bh_ids) {
@@ -393,7 +393,7 @@ inline void heap_addn(
     }
 }
 
-/* Partial instanciation for heaps with TI = int64_t */
+/* Partial instantiation for heaps with TI = int64_t */
 
 template <typename T>
 inline void minheap_addn(
@@ -489,7 +489,7 @@ struct HeapArray {
         return val + key * k;
     }
 
-    /// Correspponding identifiers
+    /// Corresponding identifiers
     TI* get_ids(size_t key) {
         return ids + key * k;
     }
diff --git a/faiss/utils/NeuralNet.cpp b/faiss/utils/NeuralNet.cpp
@@ -71,7 +71,7 @@ Tensor2DTemplate<T> Tensor2DTemplate<T>::column(size_t j) const {
     return out;
 }
 
-// explicit template instanciation
+// explicit template instantiation
 template struct Tensor2DTemplate<float>;
 template struct Tensor2DTemplate<int32_t>;
 
diff --git a/faiss/utils/NeuralNet.h b/faiss/utils/NeuralNet.h
@@ -75,7 +75,7 @@ struct Embedding {
 };
 
 /// Feed forward layer that expands to a hidden dimension, applies a ReLU non
-/// linearity and maps back to the orignal dimension
+/// linearity and maps back to the original dimension
 struct FFN {
     Linear linear1, linear2;
 
@@ -103,7 +103,7 @@ struct QINCoStep {
         return residual_blocks[i];
     }
 
-    /** encode a set of vectors x with intial estimate xhat. Optionally return
+    /** encode a set of vectors x with initial estimate xhat. Optionally return
      * the delta to be added to xhat to form the new xhat */
     nn::Int32Tensor2D encode(
             const nn::Tensor2D& xhat,
diff --git a/faiss/utils/approx_topk/approx_topk.h b/faiss/utils/approx_topk/approx_topk.h
@@ -50,8 +50,8 @@
 //        for j in range(0, NBUCKETS):
 //          idx = beam * n + i * NBUCKETS + j
 //          if distances[idx] < local_min_distances[j]:
-//            local_min_distances[i] = distances[idx]
-//            local_min_indices[i] = indices[idx]
+//            local_min_distances[j] = distances[idx]
+//            local_min_indices[j] = indices[idx]
 //
 //    for j in range(0, NBUCKETS):
 //      heap.push(local_min_distances[j], local_min_indices[j])
diff --git a/faiss/utils/approx_topk/avx2-inl.h b/faiss/utils/approx_topk/avx2-inl.h
@@ -106,7 +106,7 @@ struct HeapWithBuckets<CMax<float, int>, NBUCKETS, N> {
                                 distance_candidate,
                                 _CMP_LE_OS);
 
-                        // // blend seems to be slower that min
+                        // // blend seems to be slower than min
                         // const __m256 min_distances_new = _mm256_blendv_ps(
                         //         distance_candidate,
                         //         min_distances_i[j][p],
@@ -120,7 +120,7 @@ struct HeapWithBuckets<CMax<float, int>, NBUCKETS, N> {
                                                 min_indices_i[j][p]),
                                         comparison));
 
-                        // // blend seems to be slower that min
+                        // // blend seems to be slower than min
                         // const __m256 max_distances_new = _mm256_blendv_ps(
                         //         min_distances_i[j][p],
                         //         distance_candidate,
diff --git a/faiss/utils/approx_topk/mode.h b/faiss/utils/approx_topk/mode.h
@@ -21,7 +21,7 @@
 /// It seems that only the limited number of combinations are
 /// meaningful, because of the limited supply of SIMD registers.
 /// Also, certain combinations, such as B32_D1 and B16_D1, were concluded
-/// to be not very precise in benchmarks, so ones were not introduced.
+/// to be not very precise in benchmarks, so they were not introduced.
 ///
 /// TODO: Consider d-ary SIMD heap.
 
diff --git a/faiss/utils/distances.h b/faiss/utils/distances.h
@@ -324,7 +324,7 @@ void knn_inner_product(
  *  vector y, for the L2 distance
  * @param x    query vectors, size nx * d
  * @param y    database vectors, size ny * d
- * @param res  result heap strcture, which also provides k. Sorted on output
+ * @param res  result heap structure, which also provides k. Sorted on output
  * @param y_norm2    (optional) norms for the y vectors (nullptr or size ny)
  * @param sel  search in this subset of vectors
  */
diff --git a/faiss/utils/extra_distances-inl.h b/faiss/utils/extra_distances-inl.h
@@ -190,7 +190,7 @@ inline float VectorDistance<METRIC_GOWER>::operator()(
 
 /***************************************************************************
  * Dispatching function that takes a metric type and a consumer object
- * the consumer object should contain a retun type T and a operation template
+ * the consumer object should contain a return type T and a operation template
  * function f() that is called to perform the operation. The first argument
  * of the function is the VectorDistance object. The rest are passed in as is.
  **************************************************************************/
diff --git a/faiss/utils/hamming.h b/faiss/utils/hamming.h
@@ -14,7 +14,7 @@
  * fvecs2bitvecs).
  *
  * User-defined type hamdis_t is used for distances because at this time
- * it is still uncler clear how we will need to balance
+ * it is still unclear clear how we will need to balance
  * - flexibility in vector size (may need 16- or even 8-bit vectors)
  * - memory usage
  * - cache-misses when dealing with large volumes of data (fewer bits is better)
diff --git a/faiss/utils/partitioning.cpp b/faiss/utils/partitioning.cpp
@@ -140,7 +140,7 @@ typename C::T partition_fuzzy_median3(
     using T = typename C::T;
 
     // here we use bissection with a median of 3 to find the threshold and
-    // compress the arrays afterwards. So it's a n*log(n) algoirithm rather than
+    // compress the arrays afterwards. So it's a n*log(n) algorithm rather than
     // qselect's O(n) but it avoids shuffling around the array.
 
     FAISS_THROW_IF_NOT(n >= 3);
@@ -350,7 +350,7 @@ int simd_compress_array(
         }
     }
 
-    // handle remaining, only striclty lt ones.
+    // handle remaining, only strictly lt ones.
     for (; i0 + 15 < n; i0 += 16) {
         simd16uint16 v(vals + i0);
         simd16uint16 max2 = max_func<C>(v, thr16);
@@ -506,7 +506,7 @@ uint16_t simd_partition_fuzzy_with_bounds(
 
     uint64_t t2 = get_cy();
 
-    partition_stats.bissect_cycles += t1 - t0;
+    partition_stats.bisect_cycles += t1 - t0;
     partition_stats.compress_cycles += t2 - t1;
 
     return thresh;
@@ -662,7 +662,7 @@ uint16_t simd_partition_fuzzy_with_bounds_histogram(
         }
     }
 
-    IFV printf("end bissection: thresh=%d q=%ld n_eq=%ld\n", thresh, q, n_eq);
+    IFV printf("end bisection: thresh=%d q=%ld n_eq=%ld\n", thresh, q, n_eq);
 
     if (!C::is_max) {
         if (n_eq == 0) {
@@ -762,7 +762,7 @@ typename C::T partition_fuzzy(
             vals, ids, n, q_min, q_max, q_out);
 }
 
-// explicit template instanciations
+// explicit template instantiations
 
 template float partition_fuzzy<CMin<float, int64_t>>(
         float* vals,
diff --git a/faiss/utils/partitioning.h b/faiss/utils/partitioning.h
@@ -28,7 +28,7 @@ typename C::T partition_fuzzy(
         size_t q_max,
         size_t* q_out);
 
-/** simplified interface for when the parition is not fuzzy */
+/** simplified interface for when the partition is not fuzzy */
 template <class C>
 inline typename C::T partition(
         typename C::T* vals,
@@ -59,7 +59,7 @@ void simd_histogram_16(
         int* hist);
 
 struct PartitionStats {
-    uint64_t bissect_cycles;
+    uint64_t bisect_cycles;
     uint64_t compress_cycles;
 
     PartitionStats() {
diff --git a/faiss/utils/random.cpp b/faiss/utils/random.cpp
@@ -91,7 +91,7 @@ uint64_t SplitMix64RandomGenerator::next() {
  *  more than 1-100 billion values. */
 
 /* Generate a set of random floating point values such that x[i] in [0,1]
-   multi-threading. For this reason, we rely on re-entreant functions.  */
+   multi-threading. For this reason, we rely on re-entrant functions.  */
 void float_rand(float* x, size_t n, int64_t seed) {
     // only try to parallelize on large enough arrays
     const size_t nblock = n < 1024 ? 1 : 1024;
diff --git a/faiss/utils/simdlib_avx2.h b/faiss/utils/simdlib_avx2.h
diff --git a/faiss/utils/simdlib_avx512.h b/faiss/utils/simdlib_avx512.h
diff --git a/faiss/utils/transpose/transpose-avx512-inl.h b/faiss/utils/transpose/transpose-avx512-inl.h
diff --git a/faiss/utils/utils.h b/faiss/utils/utils.h

Original file line number	Diff line number	Diff line change
`@@ -300,7 +300,7 @@ std::vector<uint8_t> IVFPQ::translateCodesToGpu_(`
`300`	`300`	`std::move(up), numVecs, numSubQuantizers_, bitsPerSubQuantizer_);`
`301`	`301`	`}`
`302`	`302`
`303`		`-// Conver the GPU layout to the CPU layout`
	`303`	`+// Convert the GPU layout to the CPU layout`
`304`	`304`	`std::vector<uint8_t> IVFPQ::translateCodesFromGpu_(`
`305`	`305`	`std::vector<uint8_t> codes,`
`306`	`306`	`idx_t numVecs) const {`