AmirulAndalib · pull · Sep 24, 2025 · Sep 24, 2025
diff --git a/hwy/contrib/algo/transform_test.cc b/hwy/contrib/algo/transform_test.cc
@@ -173,8 +173,8 @@ struct TestGenerate {
     // TODO(janwas): can we update the apply_to in HWY_PUSH_ATTRIBUTES so that
     // the attribute also applies to lambdas? If so, remove HWY_ATTR.
 #if HWY_GENERIC_LAMBDA
-    const auto gen2 = [](const auto d, const auto vidx)
-                          HWY_ATTR { return BitCast(d, Add(vidx, vidx)); };
+    const auto gen2 = [](const auto d2, const auto vidx)
+                          HWY_ATTR { return BitCast(d2, Add(vidx, vidx)); };
 #else
     const Gen2 gen2;
 #endif
@@ -245,8 +245,8 @@ struct TestTransform {
     // TODO(janwas): can we update the apply_to in HWY_PUSH_ATTRIBUTES so that
     // the attribute also applies to lambdas? If so, remove HWY_ATTR.
 #if HWY_GENERIC_LAMBDA
-    const auto scal = [](const auto d, const auto v) HWY_ATTR {
-      return Mul(Set(d, ConvertScalarTo<T>(kAlpha)), v);
+    const auto scal = [](const auto d2, const auto v) HWY_ATTR {
+      return Mul(Set(d2, ConvertScalarTo<T>(kAlpha)), v);
     };
 #else
     const SCAL scal;
@@ -290,8 +290,8 @@ struct TestTransform1 {
     SimpleAXPY(a, b, expected.get(), count);
 
 #if HWY_GENERIC_LAMBDA
-    const auto axpy = [](const auto d, const auto v, const auto v1) HWY_ATTR {
-      return MulAdd(Set(d, ConvertScalarTo<T>(kAlpha)), v, v1);
+    const auto axpy = [](const auto d2, const auto v, const auto v1) HWY_ATTR {
+      return MulAdd(Set(d2, ConvertScalarTo<T>(kAlpha)), v, v1);
     };
 #else
     const AXPY axpy;

diff --git a/hwy/contrib/matvec/matvec-inl.h b/hwy/contrib/matvec/matvec-inl.h
@@ -49,13 +49,13 @@ HWY_NOINLINE void MatVecAddImpl(const T* HWY_RESTRICT mat,
   // Process multiple rows at a time so that we write multiples of a cache line
   // to avoid false sharing (>= 64). 128 is better than 256. 512 has too little
   // parallelization potential.
-  constexpr size_t kChunkSize = 64 / sizeof(T);
-  const uint64_t num_chunks = static_cast<uint64_t>(kOuter / kChunkSize);
+  constexpr size_t kChunkSize2 = 64 / sizeof(T);
+  const uint64_t num_chunks = static_cast<uint64_t>(kOuter / kChunkSize2);
 
   const ScalableTag<T> d;
   const size_t N = Lanes(d);
   // Required for Stream loop, otherwise we might have partial vectors.
-  HWY_DASSERT(kChunkSize >= N);
+  HWY_DASSERT(kChunkSize2 >= N);
   pool.Run(0, num_chunks,
            [&](const uint64_t chunk, size_t /*thread*/) HWY_ATTR {
              // MSVC workaround: duplicate to ensure constexpr.
@@ -126,7 +126,7 @@ HWY_NOINLINE void MatVecAddImpl(const T* HWY_RESTRICT mat,
   hwy::FlushStream();
 
   // Handle remainder rows which are not a multiple of the chunk size.
-  for (size_t r = num_chunks * kChunkSize; r < kOuter; ++r) {
+  for (size_t r = num_chunks * kChunkSize2; r < kOuter; ++r) {
     auto sum0 = Zero(d);
 
     const T* HWY_RESTRICT row = &mat[r * kInner];

diff --git a/hwy/contrib/sort/BUILD b/hwy/contrib/sort/BUILD
@@ -175,6 +175,7 @@ cc_library(
         ":vxsort",  # required if HAVE_VXSORT
         "//:algo",
         "//:hwy",
+        "//:nanobenchmark",
     ],
 )
 
@@ -201,6 +202,7 @@ cc_library(
     deps = [
         "//:algo",
         "//:hwy",
+        "//:nanobenchmark",
     ],
 )
 

diff --git a/hwy/contrib/sort/algo-inl.h b/hwy/contrib/sort/algo-inl.h
@@ -24,6 +24,7 @@
 #include <functional>  // std::less, std::greater
 #include <vector>
 
+#include "hwy/base.h"
 #include "hwy/contrib/sort/vqsort.h"
 #include "hwy/highway.h"
 #include "hwy/print.h"
@@ -606,9 +607,6 @@ void Run(Algo algo, KeyType* inout, size_t num_keys, SharedState& shared,
       return CallHeapPartialSort(inout, num_keys, k_keys, Order());
     case Algo::kHeapSelect:
       return CallHeapSelect(inout, num_keys, k_keys, Order());
-
-    default:
-      HWY_ABORT("Not implemented");
   }
 }
 

diff --git a/hwy/contrib/sort/bench_sort.cc b/hwy/contrib/sort/bench_sort.cc
@@ -360,7 +360,6 @@ enum class BenchmarkModes {
 std::vector<size_t> SizesToBenchmark(BenchmarkModes mode) {
   std::vector<size_t> sizes;
   switch (mode) {
-    default:
     case BenchmarkModes::kDefault:
 #if HAVE_PARALLEL_IPS4O || SORT_100M
       sizes.push_back(100 * 1000 * size_t{1000});

diff --git a/hwy/contrib/sort/result-inl.h b/hwy/contrib/sort/result-inl.h
@@ -29,7 +29,6 @@
 
 #include "hwy/aligned_allocator.h"
 #include "hwy/base.h"
-#include "hwy/contrib/sort/order.h"
 #include "hwy/per_target.h"  // DispatchedTarget
 #include "hwy/targets.h"     // TargetName
 
@@ -51,16 +50,17 @@ static inline double SummarizeMeasurements(std::vector<double>& seconds) {
 
 struct SortResult {
   SortResult() {}
-  SortResult(const Algo algo, Dist dist, size_t num_keys, size_t num_threads,
-             double sec, size_t sizeof_key, const char* key_name)
+  SortResult(Algo algo_in, Dist dist_in, size_t num_keys_in,
+             size_t num_threads_in, double sec_in, size_t sizeof_key_in,
+             const char* key_name_in)
       : target(DispatchedTarget()),
-        algo(algo),
-        dist(dist),
-        num_keys(num_keys),
-        num_threads(num_threads),
-        sec(sec),
-        sizeof_key(sizeof_key),
-        key_name(key_name) {}
+        algo(algo_in),
+        dist(dist_in),
+        num_keys(num_keys_in),
+        num_threads(num_threads_in),
+        sec(sec_in),
+        sizeof_key(sizeof_key_in),
+        key_name(key_name_in) {}
 
   void Print() const {
     const double bytes = static_cast<double>(num_keys) *

diff --git a/hwy/contrib/sort/sort_test.cc b/hwy/contrib/sort/sort_test.cc
@@ -20,6 +20,10 @@
 #include <random>
 #include <vector>
 
+#if !defined(HWY_DISABLED_TARGETS) && HWY_IS_DEBUG_BUILD
+#define HWY_DISABLED_TARGETS (HWY_SSE2 | HWY_SSSE3)
+#endif
+
 #include "hwy/aligned_allocator.h"  // IsAligned
 #include "hwy/base.h"
 #include "hwy/contrib/sort/vqsort.h"

diff --git a/hwy/contrib/sort/vqsort_f16a.cc b/hwy/contrib/sort/vqsort_f16a.cc
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 #include "hwy/contrib/sort/vqsort.h"  // VQSort
+#include "hwy/nanobenchmark.h"        // Unpredictable1
 
 #undef HWY_TARGET_INCLUDE
 #define HWY_TARGET_INCLUDE "hwy/contrib/sort/vqsort_f16a.cc"
@@ -33,7 +34,7 @@ void SortF16Asc(float16_t* HWY_RESTRICT keys, const size_t num) {
 #else
   (void)keys;
   (void)num;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 
@@ -45,7 +46,7 @@ void PartialSortF16Asc(float16_t* HWY_RESTRICT keys, const size_t num,
   (void)keys;
   (void)num;
   (void)k;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 
@@ -57,7 +58,7 @@ void SelectF16Asc(float16_t* HWY_RESTRICT keys, const size_t num,
   (void)keys;
   (void)num;
   (void)k;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 

diff --git a/hwy/contrib/sort/vqsort_f16d.cc b/hwy/contrib/sort/vqsort_f16d.cc
@@ -14,6 +14,7 @@
 // limitations under the License.
 
 #include "hwy/contrib/sort/vqsort.h"  // VQSort
+#include "hwy/nanobenchmark.h"        //
 
 #undef HWY_TARGET_INCLUDE
 #define HWY_TARGET_INCLUDE "hwy/contrib/sort/vqsort_f16d.cc"
@@ -33,7 +34,7 @@ void SortF16Desc(float16_t* HWY_RESTRICT keys, const size_t num) {
 #else
   (void)keys;
   (void)num;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 
@@ -45,7 +46,7 @@ void PartialSortF16Desc(float16_t* HWY_RESTRICT keys, const size_t num,
   (void)keys;
   (void)num;
   (void)k;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 
@@ -57,7 +58,7 @@ void SelectF16Desc(float16_t* HWY_RESTRICT keys, const size_t num,
   (void)keys;
   (void)num;
   (void)k;
-  HWY_ASSERT(0);
+  if (Unpredictable1()) HWY_ASSERT(0);
 #endif
 }
 

diff --git a/hwy/contrib/thread_pool/spin.h b/hwy/contrib/thread_pool/spin.h
@@ -99,8 +99,6 @@ static inline const char* ToString(SpinType type) {
       return "Pause";
     case SpinType::kSentinel:
       return nullptr;
-    default:
-      HWY_UNREACHABLE;
   }
 }
 

diff --git a/hwy/contrib/thread_pool/thread_pool.h b/hwy/contrib/thread_pool/thread_pool.h
@@ -175,8 +175,6 @@ static inline const char* ToString(WaitType type) {
       return "Separate";
     case WaitType::kSentinel:
       return nullptr;
-    default:
-      HWY_UNREACHABLE;
   }
 }
 
@@ -226,8 +224,8 @@ struct Config {  // 4 bytes
     return buf;
   }
 
-  Config(SpinType spin_type, WaitType wait_type)
-      : spin_type(spin_type), wait_type(wait_type) {}
+  Config(SpinType spin_type_in, WaitType wait_type_in)
+      : spin_type(spin_type_in), wait_type(wait_type_in) {}
   // Workers initially spin until ThreadPool sends them their actual config.
   Config() : Config(SpinType::kPause, WaitType::kSpinSeparate) {}
 

diff --git a/hwy/contrib/thread_pool/thread_pool_test.cc b/hwy/contrib/thread_pool/thread_pool_test.cc
@@ -337,10 +337,11 @@ TEST(ThreadPoolTest, TestPool) {
     mementos[task - begin].store(1000 + task);
 
     // Re-entering Run is fine on a 0-worker pool.
-    inner.Run(begin, end, [begin, end](uint64_t task, size_t worker) {
-      HWY_ASSERT(worker == 0);
-      HWY_ASSERT(begin <= task && task < end);
-    });
+    inner.Run(begin, end,
+              [begin, end](uint64_t inner_task, size_t inner_worker) {
+                HWY_ASSERT(inner_worker == 0);
+                HWY_ASSERT(begin <= inner_task && inner_task < end);
+              });
   };
 
   for (size_t num_threads = 0; num_threads <= 6; num_threads += 3) {

diff --git a/hwy/perf_counters.h b/hwy/perf_counters.h
@@ -82,7 +82,7 @@ class PerfCounters {
       case kMigrations:
         return "migration";
       default:
-        HWY_ABORT("Bug: unknown counter %d", c);
+        HWY_UNREACHABLE;
     }
   }
 

diff --git a/hwy/print.cc b/hwy/print.cc
@@ -37,6 +37,8 @@ HWY_DLLEXPORT void TypeName(const TypeInfo& info, size_t N, char* string100) {
   }
 }
 
+// The NOLINT are to suppress the warning about passing 100 instead of
+// `sizeof(string100)`, which is a pointer.
 HWY_DLLEXPORT void ToString(const TypeInfo& info, const void* ptr,
                             char* string100) {
   if (info.sizeof_t == 1) {
@@ -52,12 +54,14 @@ HWY_DLLEXPORT void ToString(const TypeInfo& info, const void* ptr,
   } else if (info.sizeof_t == 2) {
     if (info.is_bf16) {
       const double value = static_cast<double>(F32FromBF16Mem(ptr));
-      const char* fmt = hwy::ScalarAbs(value) < 1E-3 ? "%.3E" : "%.3f";
-      snprintf(string100, 100, fmt, value);  // NOLINT
+      // NOLINTNEXTLINE
+      snprintf(string100, 100, hwy::ScalarAbs(value) < 1E-3 ? "%.3E" : "%.3f",
+               value);
     } else if (info.is_float) {
       const double value = static_cast<double>(F32FromF16Mem(ptr));
-      const char* fmt = hwy::ScalarAbs(value) < 1E-4 ? "%.4E" : "%.4f";
-      snprintf(string100, 100, fmt, value);  // NOLINT
+      // NOLINTNEXTLINE
+      snprintf(string100, 100, hwy::ScalarAbs(value) < 1E-4 ? "%.4E" : "%.4f",
+               value);
     } else {
       uint16_t bits;
       CopyBytes<2>(ptr, &bits);
@@ -67,8 +71,9 @@ HWY_DLLEXPORT void ToString(const TypeInfo& info, const void* ptr,
     if (info.is_float) {
       float value;
       CopyBytes<4>(ptr, &value);
-      const char* fmt = hwy::ScalarAbs(value) < 1E-6 ? "%.9E" : "%.9f";
-      snprintf(string100, 100, fmt, static_cast<double>(value));  // NOLINT
+      // NOLINTNEXTLINE
+      snprintf(string100, 100, hwy::ScalarAbs(value) < 1E-6 ? "%.9E" : "%.9f",
+               static_cast<double>(value));
     } else if (info.is_signed) {
       int32_t value;
       CopyBytes<4>(ptr, &value);
@@ -82,8 +87,9 @@ HWY_DLLEXPORT void ToString(const TypeInfo& info, const void* ptr,
     if (info.is_float) {
       double value;
       CopyBytes<8>(ptr, &value);
-      const char* fmt = hwy::ScalarAbs(value) < 1E-9 ? "%.18E" : "%.18f";
-      snprintf(string100, 100, fmt, value);  // NOLINT
+      // NOLINTNEXTLINE
+      snprintf(string100, 100, hwy::ScalarAbs(value) < 1E-9 ? "%.18E" : "%.18f",
+               value);
     } else {
       const uint8_t* ptr8 = reinterpret_cast<const uint8_t*>(ptr);
       uint32_t lo, hi;