Merge pull request #3191 from bkmgit:patch-1

PiperOrigin-RevId: 943704604

Author: copybara-github

CMakeLists.txt

@@ -811,6 +811,15 @@ target_link_libraries(dot_product_unroll PRIVATE ${ATOMICS_LIBRARIES})
 set_target_properties(dot_product_unroll
     PROPERTIES RUNTIME_OUTPUT_DIRECTORY "examples/")
 
+# Mixed precision dot product
+add_executable(dot_product_mixed_precision hwy/examples/dot_product_mixed_precision.cc)
+target_compile_options(dot_product_mixed_precision PRIVATE ${HWY_FLAGS})
+target_compile_features(dot_product_mixed_precision PRIVATE ${HWY_CXX_STD_TGT_COMPILE_FEATURE})
+target_link_libraries(dot_product_mixed_precision PRIVATE hwy)
+target_link_libraries(dot_product_mixed_precision PRIVATE ${ATOMICS_LIBRARIES})
+set_target_properties(dot_product_mixed_precision
+    PROPERTIES RUNTIME_OUTPUT_DIRECTORY "examples/")
+
 # AES capture the flag example
 add_executable(ctf_aes hwy/examples/ctf_aes.cc)
 target_compile_options(ctf_aes PRIVATE ${HWY_FLAGS})

hwy/examples/README.md

@@ -27,6 +27,12 @@ Similar to sum_array_advanced, but for dot products. Adds:
 -   Duff's device for vector remainders
 -   Horizontal sum (reduction/fold) using `ReduceSum`.
 
+### `dot_product_mixed_precision.cc
+
+Similar to array simple but uses type promtion to allow for
+a greater range in resulting integer sum values before an
+overflow occurs.
+
 ### `matrix_transpose_scatter_gather.cc`
 
 Matrix transposition via Gather and Scatter, showing:

hwy/examples/dot_product_mixed_precision.cc

@@ -0,0 +1,120 @@
+// Copyright 2026 Google LLC
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <stddef.h>
+#include <stdint.h>
+
+#include <iostream>
+#include <numeric>
+#include <vector>
+
+#undef HWY_TARGET_INCLUDE
+#define HWY_TARGET_INCLUDE "hwy/examples/dot_product_mixed_precision.cc"
+#include "hwy/foreach_target.h"  // IWYU pragma: keep
+#include "hwy/highway.h"
+#include "hwy/nanobenchmark.h"
+#include "hwy/timer.h"
+
+/*
+Highway SIMD Tutorial: Mixed precision dot product
+
+This example demonstrates how to perform a dot product where the inputs are
+uint8_t and are promoted uint32_t to prevent overflow.
+
+*/
+
+HWY_BEFORE_NAMESPACE();
+namespace hwy {
+namespace HWY_NAMESPACE {
+namespace hn = hwy::HWY_NAMESPACE;
+
+uint32_t DotProductSIMD(const uint8_t* HWY_RESTRICT a,
+                        const uint8_t* HWY_RESTRICT b, size_t count) {
+  using DU8 = hn::ScalableTag<uint8_t>;
+  const DU8 du8;
+  using DU32 = hn::ScalableTag<uint32_t>;
+  const DU32 du32;
+  using V = hn::Vec<DU32>;
+  V sum = hn::Zero(du32);
+  const size_t N8 = hn::Lanes(du8);
+  size_t i = 0;
+  if (count >= N8) {
+    for (; i <= count - N8; i += N8) {
+      sum = hn::SumOfMulQuadAccumulate(du32, hn::LoadU(du8, a + i),
+                                       hn::LoadU(du8, b + i), sum);
+    }
+  }
+
+  // Use LoadN for remainder, sets 0 for values beyond remainder
+  size_t remainder = count - i;
+  HWY_DASSERT(remainder < N8);
+  if (remainder > 0) {
+    sum = hn::SumOfMulQuadAccumulate(du32, hn::LoadN(du8, a + i, remainder),
+                                     hn::LoadN(du8, b + i, remainder), sum);
+  }
+
+  uint32_t total = hn::ReduceSum(du32, sum);
+
+  return total;
+}
+
+}  // namespace HWY_NAMESPACE
+}  // namespace hwy
+HWY_AFTER_NAMESPACE();
+
+#if HWY_ONCE
+namespace hwy {
+HWY_EXPORT(DotProductSIMD);
+
+uint32_t DotProductScalar(const uint8_t* HWY_RESTRICT a,
+                          const uint8_t* HWY_RESTRICT b, size_t count) {
+  size_t i = 0;
+  uint32_t total = 0;
+  // Scalar dot product with type casting
+  for (; i < count; ++i) {
+    total += static_cast<uint32_t>(a[i]) * static_cast<uint32_t>(b[i]);
+  }
+  return total;
+}
+
+int Run() {
+  const size_t count = 10000025;
+  std::vector<uint8_t> a(count);
+  std::vector<uint8_t> b(count);
+  std::iota(a.begin(), a.end(), 1);
+  std::iota(b.begin(), b.end(), 1);
+  // Record start time
+  const double t_scalar_0 = hwy::platform::Now();
+  uint32_t dpScalar = hwy::DotProductScalar(a.data(), b.data(), count);
+  // Record end time and print execution time and dot product
+  const double t_scalar_1 = hwy::platform::Now();
+  const double dt_scalar = 1000.0 * (t_scalar_1 - t_scalar_0);
+  std::cout << "Scalar Execution time: " << dt_scalar << " ms" << std::endl;
+  std::cout << "Scalar Dot product: " << dpScalar << std::endl;
+  // Record start time
+  const double t_simd_0 = hwy::platform::Now();
+  uint32_t dpSIMD =
+      HWY_DYNAMIC_DISPATCH(DotProductSIMD)(a.data(), b.data(), count);
+  // Record stop timer and print time and dot product
+  const double t_simd_1 = hwy::platform::Now();
+  const double dt_simd = 1000.0 * (t_simd_1 - t_simd_0);
+  std::cout << "SIMD Execution time: " << dt_simd << " ms" << std::endl;
+  std::cout << "SIMD Dot product: " << dpSIMD << std::endl;
+  return 0;
+}
+}  // namespace hwy
+
+int main() { return hwy::Run(); }
+#endif  // HWY_ONCE