Clarify Kahan condition (microsoft#28790)

This pull request refactors the logic for determining when to use Kahan
compensated summation in reduction aggregators for integer types in
`onnxruntime/core/providers/cpu/reduction/reduction_ops.h`. Instead of
relying on the size of the type, a new type trait, `kReduceUseKahan<T>`,
is introduced to explicitly indicate when Kahan summation should be used
(currently for `int64_t` and `uint64_t`). This improves code clarity and
maintainability by making the condition more explicit and less
error-prone.

**Refactoring of Kahan Summation Condition:**

* Introduced the `kReduceUseKahan<T>` constexpr variable to indicate
when Kahan compensated summation should be used, replacing the previous
`sizeof(T) >= sizeof(int64_t)` checks. This trait currently evaluates to
true for `int64_t` and `uint64_t` types.
* Updated all reduction aggregator classes (`ReduceAggregatorSum`,
`ReduceAggregatorSumSquare`, `ReduceAggregatorMean`,
`ReduceAggregatorL1`, `ReduceAggregatorL2`, `ReduceAggregatorLogSum`) to
use `kReduceUseKahan<T>` instead of the previous size-based condition
when deciding to apply Kahan summation in both `aggall` and `update`
methods.
[[1]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L232-R239)
[[2]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L247-R254)
[[3]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L457-R464)
[[4]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L484-R491)
[[5]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L518-R525)
[[6]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1164-R1171)
[[7]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1188-R1195)
[[8]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1248-R1255)
[[9]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1276-R1283)
[[10]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1316-R1323)
[[11]](diffhunk://#diff-ca0c9224442a3c46251b0fb7326aacc1469bdee20ab409b930556f439d560015L1347-R1354)

Author: yuslepukhin

onnxruntime/core/providers/cpu/reduction/reduction_ops.h

@@ -154,6 +154,13 @@ inline bool reduce_isnan<int32_t>(int32_t) { return false; }
 template <>
 inline bool reduce_isnan<int64_t>(int64_t) { return false; }
 
+// Integer types whose precision exceeds double's 53-bit mantissa, where summing in double
+// loses precision for large values. For these, reduction aggregators use Kahan compensated
+// summation. int32_t/uint32_t (and narrower) fit exactly in double, so plain double
+// accumulation is sufficient.
+template <typename T>
+inline constexpr bool kReduceUseKahan = std::is_same_v<T, int64_t> || std::is_same_v<T, uint64_t>;
+
 class ReduceAggregatorBase {
  public:
   // Fast reduction: see OptimizeShapeForFastReduce's comment.
@@ -229,7 +236,7 @@ class ReduceAggregatorSum : public ReduceAggregator<T, T> {
   inline ReduceAggregatorSum(int64_t N, const T&) : ReduceAggregator<T, T>(N, 0) {}
   inline void update(const T& v) {
     if constexpr (std::is_integral_v<T>) {
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double y = static_cast<double>(v) - kahan_compensation_;
         double t = double_accumulator_ + y;
         kahan_compensation_ = (t - double_accumulator_) - y;
@@ -244,7 +251,7 @@ class ReduceAggregatorSum : public ReduceAggregator<T, T> {
   static T aggall(const T* from_data, int64_t size) {
     if constexpr (std::is_integral_v<T>) {
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(size); i < n; ++i) {
           double y = static_cast<double>(from_data[i]) - comp;
@@ -454,7 +461,7 @@ class ReduceAggregatorSumSquare : public ReduceAggregator<T, TVAL> {
   inline TVAL aggall(const T* from_data) {
     if constexpr (std::is_integral_v<T>) {
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(this->N_); i < n; ++i) {
           double dv = static_cast<double>(from_data[i]);
@@ -481,7 +488,7 @@ class ReduceAggregatorSumSquare : public ReduceAggregator<T, TVAL> {
   inline void update(const T& v) {
     if constexpr (std::is_integral_v<T>) {
       double dv = static_cast<double>(v);
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double y = dv * dv - kahan_compensation_;
         double t = double_accumulator_ + y;
         kahan_compensation_ = (t - double_accumulator_) - y;
@@ -515,7 +522,7 @@ class ReduceAggregatorMean : public ReduceAggregatorSum<T> {
     if constexpr (std::is_integral_v<T>) {
       // Accumulate in double, divide, then saturate back to T.
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(size); i < n; ++i) {
           double y = static_cast<double>(from_data[i]) - comp;
@@ -1161,7 +1168,7 @@ class ReduceAggregatorL1 : public ReduceAggregator<T, T> {
   inline T aggall(const T* from_data) {
     if constexpr (std::is_integral_v<T>) {
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         // Kahan compensated summation for int64+ to minimize precision loss.
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(this->N_); i < n; ++i) {
@@ -1185,7 +1192,7 @@ class ReduceAggregatorL1 : public ReduceAggregator<T, T> {
   }
   inline void update(const T& v) {
     if constexpr (std::is_integral_v<T>) {
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         // Kahan compensated summation for int64+.
         double y = std::abs(static_cast<double>(v)) - kahan_compensation_;
         double t = double_accumulator_ + y;
@@ -1245,7 +1252,7 @@ class ReduceAggregatorL2 : public ReduceAggregator<T, T> {
   inline T aggall(const T* from_data) {
     if constexpr (std::is_integral_v<T>) {
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         // Kahan compensated summation for int64+ to minimize precision loss.
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(this->N_); i < n; ++i) {
@@ -1273,7 +1280,7 @@ class ReduceAggregatorL2 : public ReduceAggregator<T, T> {
   inline void update(const T& v) {
     if constexpr (std::is_integral_v<T>) {
       double dv = static_cast<double>(v);
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         // Kahan compensated summation for int64+.
         double y = dv * dv - kahan_compensation_;
         double t = double_accumulator_ + y;
@@ -1313,7 +1320,7 @@ class ReduceAggregatorLogSum : public ReduceAggregator<T, T> {
   inline T aggall(const T* from_data) {
     if constexpr (std::is_integral_v<T>) {
       double sum = 0.0;
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double comp = 0.0;
         for (size_t i = 0, n = onnxruntime::narrow<size_t>(this->N_); i < n; ++i) {
           double y = static_cast<double>(from_data[i]) - comp;
@@ -1344,7 +1351,7 @@ class ReduceAggregatorLogSum : public ReduceAggregator<T, T> {
   }
   inline void update(const T& v) {
     if constexpr (std::is_integral_v<T>) {
-      if constexpr (sizeof(T) >= sizeof(int64_t)) {
+      if constexpr (kReduceUseKahan<T>) {
         double y = static_cast<double>(v) - kahan_compensation_;
         double t = double_accumulator_ + y;
         kahan_compensation_ = (t - double_accumulator_) - y;