grpc 1.71.0 → 1.74.0

data/src/core/util/status_helper.cc

@@ -18,7 +18,7 @@
 
 #include "src/core/util/status_helper.h"
 
-#include <grpc/support/port_platform.h>
+#include <grpc/status.h>
 #include <string.h>
 
 #include <utility>
@@ -33,8 +33,11 @@
 #include "absl/time/clock.h"
 #include "google/protobuf/any.upb.h"
 #include "google/rpc/status.upb.h"
+#include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/status_conversion.h"
+#include "src/core/util/time.h"
 #include "upb/base/string_view.h"
 #include "upb/mem/arena.hpp"
 
@@ -57,18 +60,12 @@ const absl::string_view kChildrenPropertyUrl = TYPE_URL(TYPE_CHILDREN_TAG);
 
 const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
   switch (key) {
-    case StatusIntProperty::kFileLine:
-      return TYPE_URL(TYPE_INT_TAG "file_line");
     case StatusIntProperty::kStreamId:
       return TYPE_URL(TYPE_INT_TAG "stream_id");
     case StatusIntProperty::kRpcStatus:
       return TYPE_URL(TYPE_INT_TAG "grpc_status");
     case StatusIntProperty::kHttp2Error:
       return TYPE_URL(TYPE_INT_TAG "http2_error");
-    case StatusIntProperty::kFd:
-      return TYPE_URL(TYPE_INT_TAG "fd");
-    case StatusIntProperty::kOccurredDuringWrite:
-      return TYPE_URL(TYPE_INT_TAG "occurred_during_write");
     case StatusIntProperty::ChannelConnectivityState:
       return TYPE_URL(TYPE_INT_TAG "channel_connectivity_state");
     case StatusIntProperty::kLbPolicyDrop:
@@ -79,24 +76,12 @@ const char* GetStatusIntPropertyUrl(StatusIntProperty key) {
 
 const char* GetStatusStrPropertyUrl(StatusStrProperty key) {
   switch (key) {
-    case StatusStrProperty::kDescription:
-      return TYPE_URL(TYPE_STR_TAG "description");
-    case StatusStrProperty::kFile:
-      return TYPE_URL(TYPE_STR_TAG "file");
     case StatusStrProperty::kGrpcMessage:
       return TYPE_URL(TYPE_STR_TAG "grpc_message");
   }
   GPR_UNREACHABLE_CODE(return "unknown");
 }
 
-const char* GetStatusTimePropertyUrl(StatusTimeProperty key) {
-  switch (key) {
-    case StatusTimeProperty::kCreated:
-      return TYPE_URL(TYPE_TIME_TAG "created_time");
-  }
-  GPR_UNREACHABLE_CODE(return "unknown");
-}
-
 void EncodeUInt32ToBytes(uint32_t v, char* buf) {
   buf[0] = v & 0xFF;
   buf[1] = (v >> 8) & 0xFF;
@@ -133,16 +118,9 @@ std::vector<absl::Status> ParseChildren(absl::Cord children) {
 }  // namespace
 
 absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
-                          const DebugLocation& location,
+                          const DebugLocation& /*location*/,
                           std::vector<absl::Status> children) {
   absl::Status s(code, msg);
-  if (location.file() != nullptr) {
-    StatusSetStr(&s, StatusStrProperty::kFile, location.file());
-  }
-  if (location.line() != -1) {
-    StatusSetInt(&s, StatusIntProperty::kFileLine, location.line());
-  }
-  StatusSetTime(&s, StatusTimeProperty::kCreated, absl::Now());
   for (const absl::Status& child : children) {
     if (!child.ok()) {
       StatusAddChild(&s, child);
@@ -151,13 +129,35 @@ absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
   return s;
 }
 
+namespace {
+
+absl::Status ReplaceStatusCode(const absl::Status& status,
+                               absl::StatusCode code) {
+  absl::Status new_status(code, status.message());
+  status.ForEachPayload(
+      [&](absl::string_view type_url, const absl::Cord& payload) {
+        new_status.SetPayload(type_url, payload);
+      });
+  return new_status;
+}
+
+}  // namespace
+
 void StatusSetInt(absl::Status* status, StatusIntProperty key, intptr_t value) {
+  if (IsErrorFlattenEnabled() && key == StatusIntProperty::kRpcStatus) {
+    // When setting the RPC status, just replace the top-level status code.
+    *status = ReplaceStatusCode(*status, static_cast<absl::StatusCode>(value));
+    return;
+  }
   status->SetPayload(GetStatusIntPropertyUrl(key),
                      absl::Cord(std::to_string(value)));
 }
 
 std::optional<intptr_t> StatusGetInt(const absl::Status& status,
                                      StatusIntProperty key) {
+  if (IsErrorFlattenEnabled() && key == StatusIntProperty::kRpcStatus) {
+    return static_cast<intptr_t>(status.code());
+  }
   auto p = status.GetPayload(GetStatusIntPropertyUrl(key));
   if (p.has_value()) {
     auto sv = p->TryFlat();
@@ -175,13 +175,39 @@ std::optional<intptr_t> StatusGetInt(const absl::Status& status,
   return {};
 }
 
+namespace {
+
+absl::Status ReplaceStatusMessage(const absl::Status& status,
+                                  absl::string_view message) {
+  absl::Status new_status(status.code(), message);
+  status.ForEachPayload(
+      [&](absl::string_view type_url, const absl::Cord& payload) {
+        new_status.SetPayload(type_url, payload);
+      });
+  return new_status;
+}
+
+}  // namespace
+
 void StatusSetStr(absl::Status* status, StatusStrProperty key,
                   absl::string_view value) {
+  if (IsErrorFlattenEnabled() && key == StatusStrProperty::kGrpcMessage) {
+    if (!status->ok()) {
+      *status = ReplaceStatusMessage(
+          *status, status->message().empty()
+                       ? value
+                       : absl::StrCat(value, " (", status->message(), ")"));
+    }
+    return;
+  }
   status->SetPayload(GetStatusStrPropertyUrl(key), absl::Cord(value));
 }
 
 std::optional<std::string> StatusGetStr(const absl::Status& status,
                                         StatusStrProperty key) {
+  if (IsErrorFlattenEnabled() && key == StatusStrProperty::kGrpcMessage) {
+    return std::string(status.message());
+  }
   auto p = status.GetPayload(GetStatusStrPropertyUrl(key));
   if (p.has_value()) {
     return std::string(*p);
@@ -189,35 +215,37 @@ std::optional<std::string> StatusGetStr(const absl::Status& status,
   return {};
 }
 
-void StatusSetTime(absl::Status* status, StatusTimeProperty key,
-                   absl::Time time) {
-  std::string time_str =
-      absl::FormatTime(absl::RFC3339_full, time, absl::UTCTimeZone());
-  status->SetPayload(GetStatusTimePropertyUrl(key),
-                     absl::Cord(std::move(time_str)));
-}
-
-std::optional<absl::Time> StatusGetTime(const absl::Status& status,
-                                        StatusTimeProperty key) {
-  auto p = status.GetPayload(GetStatusTimePropertyUrl(key));
-  if (p.has_value()) {
-    auto sv = p->TryFlat();
-    absl::Time time;
-    if (sv.has_value()) {
-      if (absl::ParseTime(absl::RFC3339_full, sv.value(), &time, nullptr)) {
-        return time;
-      }
-    } else {
-      std::string s = std::string(*p);
-      if (absl::ParseTime(absl::RFC3339_full, s, &time, nullptr)) {
-        return time;
-      }
+void StatusAddChild(absl::Status* status, absl::Status child) {
+  if (IsErrorFlattenEnabled()) {
+    // If the child is OK, there's nothing to do.
+    if (child.ok()) return;
+    // If the parent is OK, replace it with the child.
+    if (status->ok()) {
+      *status = std::move(child);
+      return;
     }
+    // Parent and child are both non-OK, so we need to merge.
+    absl::Status new_status(
+        // Prefer any other code over UNKNOWN.
+        status->code() == absl::StatusCode::kUnknown ? child.code()
+                                                     : status->code(),
+        absl::StrCat(status->message(), " (", child.message(), ")"));
+    // TODO(roth): Remove this once we eliminate all status attributes.
+    status->ForEachPayload(
+        [&](absl::string_view type_url, const absl::Cord& payload) {
+          new_status.SetPayload(type_url, payload);
+        });
+    child.ForEachPayload(
+        [&](absl::string_view type_url, const absl::Cord& payload) {
+          // If the original error already has the attribute, don't overwrite
+          // it.
+          if (!new_status.GetPayload(type_url).has_value()) {
+            new_status.SetPayload(type_url, payload);
+          }
+        });
+    *status = std::move(new_status);
+    return;
   }
-  return {};
-}
-
-void StatusAddChild(absl::Status* status, absl::Status child) {
   upb::Arena arena;
   // Serialize msg to buf
   google_rpc_Status* msg = internal::StatusToProto(child, arena.ptr());
@@ -311,15 +339,10 @@ std::string StatusToString(const absl::Status& status) {
                      : absl::StrCat(head, " {", absl::StrJoin(kvs, ", "), "}");
 }
 
-absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status) {
-  absl::Status new_status(status.code(),
-                          absl::StrCat(prefix, ": ", status.message()));
-  // TODO(roth): Remove this once we eliminate all status attributes.
-  status.ForEachPayload(
-      [&](absl::string_view type_url, const absl::Cord& payload) {
-        new_status.SetPayload(type_url, payload);
-      });
-  return new_status;
+absl::Status AddMessagePrefix(absl::string_view prefix,
+                              const absl::Status& status) {
+  return ReplaceStatusMessage(status,
+                              absl::StrCat(prefix, ": ", status.message()));
 }
 
 namespace internal {

data/src/core/util/status_helper.h

@@ -46,42 +46,32 @@ namespace grpc_core {
 
 /// This enum should have the same value of grpc_error_ints
 enum class StatusIntProperty {
-  /// __LINE__ from the call site creating the error
-  kFileLine,
   /// stream identifier: for errors that are associated with an individual
   /// wire stream
+  // TODO(tjagtap): Remove this when the PH2 migration is done.
   kStreamId,
   /// grpc status code representing this error
-  // TODO(veblush): Remove this after grpc_error is replaced with absl::Status
+  // TODO(roth): Remove this after error_flatten experiment is removed.
   kRpcStatus,
   /// http2 error code associated with the error (see the HTTP2 RFC)
+  // TODO(tjagtap): Remove this as part of creating a new HTTP/2 error type.
   kHttp2Error,
-  /// File descriptor associated with this error
-  kFd,
-  /// chttp2: did the error occur while a write was in progress
-  kOccurredDuringWrite,
   /// channel connectivity state associated with the error
+  // TODO(roth): Remove this when the promise migration is done.
   ChannelConnectivityState,
   /// LB policy drop
+  // TODO(roth): Replace this with something else, possibly a call
+  // context element.
   kLbPolicyDrop,
 };
 
 /// This enum should have the same value of grpc_error_strs
+// TODO(roth): Remove this after error_flatten experiment is removed.
 enum class StatusStrProperty {
-  /// top-level textual description of this error
-  kDescription,
-  /// source file in which this error occurred
-  kFile,
   /// peer that we were trying to communicate when this error occurred
   kGrpcMessage,
 };
 
-/// This enum should have the same value of grpc_error_times
-enum class StatusTimeProperty {
-  /// timestamp of error creation
-  kCreated,
-};
-
 /// Creates a status with given additional information
 absl::Status StatusCreate(absl::StatusCode code, absl::string_view msg,
                           const DebugLocation& location,
@@ -103,14 +93,6 @@ void StatusSetStr(absl::Status* status, StatusStrProperty key,
 GRPC_MUST_USE_RESULT std::optional<std::string> StatusGetStr(
     const absl::Status& status, StatusStrProperty key);
 
-/// Sets the time property to the status
-void StatusSetTime(absl::Status* status, StatusTimeProperty key,
-                   absl::Time time);
-
-/// Gets the time property from the status
-GRPC_MUST_USE_RESULT std::optional<absl::Time> StatusGetTime(
-    const absl::Status& status, StatusTimeProperty key);
-
 /// Adds a child status to status
 void StatusAddChild(absl::Status* status, absl::Status child);
 
@@ -126,7 +108,8 @@ GRPC_MUST_USE_RESULT std::vector<absl::Status> StatusGetChildren(
 GRPC_MUST_USE_RESULT std::string StatusToString(const absl::Status& status);
 
 /// Adds prefix to the message of status.
-absl::Status AddMessagePrefix(absl::string_view prefix, absl::Status status);
+absl::Status AddMessagePrefix(absl::string_view prefix,
+                              const absl::Status& status);
 
 namespace internal {
 

data/src/core/util/upb_utils.h

@@ -17,10 +17,15 @@
 #ifndef GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 #define GRPC_SRC_CORE_UTIL_UPB_UTILS_H
 
+#include <grpc/support/time.h>
+
 #include <string>
 
 #include "absl/strings/string_view.h"
+#include "google/protobuf/duration.upb.h"
+#include "google/protobuf/timestamp.upb.h"
 #include "upb/base/string_view.h"
+#include "upb/mem/arena.h"
 
 namespace grpc_core {
 
@@ -30,6 +35,17 @@ inline upb_StringView StdStringToUpbString(const T& str) {
   return upb_StringView_FromDataAndSize(str.data(), str.size());
 }
 
+inline upb_StringView StdStringToUpbString(const char* str) {
+  return upb_StringView_FromDataAndSize(str, strlen(str));
+}
+
+template <typename T>
+inline upb_StringView CopyStdStringToUpbString(const T& str, upb_Arena* arena) {
+  char* copy = static_cast<char*>(upb_Arena_Malloc(arena, str.size()));
+  memcpy(copy, str.data(), str.size());
+  return upb_StringView_FromDataAndSize(copy, str.size());
+}
+
 inline absl::string_view UpbStringToAbsl(const upb_StringView& str) {
   return absl::string_view(str.data, str.size);
 }
@@ -38,6 +54,32 @@ inline std::string UpbStringToStdString(const upb_StringView& str) {
   return std::string(str.data, str.size);
 }
 
+inline void TimestampToUpb(gpr_timespec ts, google_protobuf_Timestamp* proto) {
+  auto t = gpr_convert_clock_type(ts, GPR_CLOCK_REALTIME);
+  google_protobuf_Timestamp_set_seconds(proto, t.tv_sec);
+  google_protobuf_Timestamp_set_nanos(proto, t.tv_nsec);
+}
+
+inline void UpbToTimestamp(const google_protobuf_Timestamp* proto,
+                           gpr_timespec* ts) {
+  ts->clock_type = GPR_CLOCK_REALTIME;
+  ts->tv_sec = google_protobuf_Timestamp_seconds(proto);
+  ts->tv_nsec = google_protobuf_Timestamp_nanos(proto);
+}
+
+inline void DurationToUpb(gpr_timespec ts, google_protobuf_Duration* proto) {
+  auto t = gpr_convert_clock_type(ts, GPR_TIMESPAN);
+  google_protobuf_Duration_set_seconds(proto, t.tv_sec);
+  google_protobuf_Duration_set_nanos(proto, t.tv_nsec);
+}
+
+inline void UpbToTimestamp(const google_protobuf_Duration* proto,
+                           gpr_timespec* ts) {
+  ts->clock_type = GPR_TIMESPAN;
+  ts->tv_sec = google_protobuf_Duration_seconds(proto);
+  ts->tv_nsec = google_protobuf_Duration_nanos(proto);
+}
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_UTIL_UPB_UTILS_H

data/src/core/util/uri.cc

@@ -103,6 +103,29 @@ bool IsAuthorityChar(char c) {
   return false;
 }
 
+// Returns true for any character in user_info, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.1
+bool IsUserInfoChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  if (c == ':') return true;
+  return false;
+}
+
+// Returns true for any character in host_port, as defined in:
+// https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.2
+bool IsHostPortChar(char c) {
+  if (IsUnreservedChar(c)) return true;
+  if (IsSubDelimChar(c)) return true;
+  switch (c) {
+    case ':':
+    case '[':
+    case ']':
+      return true;
+  }
+  return false;
+}
+
 // Returns true for any character in pchar, as defined in:
 // https://datatracker.ietf.org/doc/html/rfc3986#section-3.3
 bool IsPChar(char c) {
@@ -204,6 +227,13 @@ std::string URI::PercentDecode(absl::string_view str) {
   return out;
 }
 
+std::string URI::authority() const {
+  if (!user_info_.empty()) {
+    return absl::StrCat(user_info_, "@", host_port_);
+  }
+  return host_port_;
+}
+
 absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   absl::string_view remaining = uri_text;
   // parse scheme
@@ -225,10 +255,23 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
   }
   remaining.remove_prefix(offset + 1);
   // parse authority
-  std::string authority;
+  std::string user_info;
+  std::string host_port;
   if (absl::ConsumePrefix(&remaining, "//")) {
     offset = remaining.find_first_of("/?#");
-    authority = PercentDecode(remaining.substr(0, offset));
+    absl::string_view encoded_authority = remaining.substr(0, offset);
+    // parse user_info and host_port
+    absl::string_view encoded_user_info;
+    absl::string_view encoded_host_port;
+    size_t at_pos = encoded_authority.rfind('@');
+    if (at_pos == absl::string_view::npos) {
+      encoded_host_port = encoded_authority;
+    } else {
+      encoded_user_info = encoded_authority.substr(0, at_pos);
+      encoded_host_port = encoded_authority.substr(at_pos + 1);
+    }
+    user_info = PercentDecode(encoded_user_info);
+    host_port = PercentDecode(encoded_host_port);
     if (offset == remaining.npos) {
       remaining = "";
     } else {
@@ -279,29 +322,38 @@ absl::StatusOr<URI> URI::Parse(absl::string_view uri_text) {
     }
     fragment = PercentDecode(remaining);
   }
-  return URI(std::move(scheme), std::move(authority), std::move(path),
-             std::move(query_param_pairs), std::move(fragment));
+  return URI(std::move(scheme), std::move(user_info), std::move(host_port),
+             std::move(path), std::move(query_param_pairs),
+             std::move(fragment));
 }
 
-absl::StatusOr<URI> URI::Create(std::string scheme, std::string authority,
-                                std::string path,
+absl::StatusOr<URI> URI::Create(std::string scheme, std::string user_info,
+                                std::string host_port, std::string path,
                                 std::vector<QueryParam> query_parameter_pairs,
                                 std::string fragment) {
-  if (!authority.empty() && !path.empty() && path[0] != '/') {
+  if (!host_port.empty() && !path.empty() && path[0] != '/') {
     return absl::InvalidArgumentError(
-        "if authority is present, path must start with a '/'");
+        "if host_port is present, path must start with a '/'");
   }
-  return URI(std::move(scheme), std::move(authority), std::move(path),
-             std::move(query_parameter_pairs), std::move(fragment));
+  if (!user_info.empty() && host_port.empty()) {
+    return absl::InvalidArgumentError(
+        "if user_info is present, host_port must be present");
+  }
+  return URI(std::move(scheme), std::move(user_info), std::move(host_port),
+             std::move(path), std::move(query_parameter_pairs),
+             std::move(fragment));
 }
 
-URI::URI(std::string scheme, std::string authority, std::string path,
-         std::vector<QueryParam> query_parameter_pairs, std::string fragment)
+URI::URI(std::string scheme, std::string user_info, std::string host_port,
+         std::string path, std::vector<QueryParam> query_parameter_pairs,
+         std::string fragment)
     : scheme_(std::move(scheme)),
-      authority_(std::move(authority)),
+      user_info_(std::move(user_info)),
+      host_port_(std::move(host_port)),
       path_(std::move(path)),
       query_parameter_pairs_(std::move(query_parameter_pairs)),
       fragment_(std::move(fragment)) {
+  absl::AsciiStrToLower(&scheme_);
   for (const auto& kv : query_parameter_pairs_) {
     query_parameter_map_[kv.key] = kv.value;
   }
@@ -309,7 +361,8 @@ URI::URI(std::string scheme, std::string authority, std::string path,
 
 URI::URI(const URI& other)
     : scheme_(other.scheme_),
-      authority_(other.authority_),
+      user_info_(other.user_info_),
+      host_port_(other.host_port_),
       path_(other.path_),
       query_parameter_pairs_(other.query_parameter_pairs_),
       fragment_(other.fragment_) {
@@ -323,7 +376,8 @@ URI& URI::operator=(const URI& other) {
     return *this;
   }
   scheme_ = other.scheme_;
-  authority_ = other.authority_;
+  user_info_ = other.user_info_;
+  host_port_ = other.host_port_;
   path_ = other.path_;
   query_parameter_pairs_ = other.query_parameter_pairs_;
   fragment_ = other.fragment_;
@@ -350,9 +404,14 @@ std::string URI::ToString() const {
   std::vector<std::string> parts = {PercentEncode(scheme_, IsSchemeChar), ":"};
   // If path starts with '//' we need to encode the authority to ensure that
   // we can round-trip the URI through a parse/encode/parse loop.
-  if (!authority_.empty() || absl::StartsWith(path_, "//")) {
+  if (!user_info_.empty() || !host_port_.empty() ||
+      absl::StartsWith(path_, "//")) {
     parts.emplace_back("//");
-    parts.emplace_back(PercentEncode(authority_, IsAuthorityChar));
+    if (!user_info_.empty()) {
+      parts.emplace_back(PercentEncode(user_info_, IsUserInfoChar));
+      parts.emplace_back("@");
+    }
+    parts.emplace_back(PercentEncode(host_port_, IsHostPortChar));
   }
   parts.emplace_back(EncodedPathAndQueryParams());
   if (!fragment_.empty()) {

data/src/core/util/uri.h

@@ -48,8 +48,9 @@ class URI {
   static absl::StatusOr<URI> Parse(absl::string_view uri_text);
   // Creates a URI from components. Returns an InvalidArgumentError on failure.
   static absl::StatusOr<URI> Create(
-      std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+      std::string scheme, std::string user_info, std::string host_port,
+      std::string path, std::vector<QueryParam> query_parameter_pairs,
+      std::string fragment);
 
   URI() = default;
 
@@ -66,7 +67,9 @@ class URI {
   static std::string PercentDecode(absl::string_view str);
 
   const std::string& scheme() const { return scheme_; }
-  const std::string& authority() const { return authority_; }
+  std::string authority() const;
+  const std::string& user_info() const { return user_info_; }
+  const std::string& host_port() const { return host_port_; }
   const std::string& path() const { return path_; }
   // Stores the *last* value appearing for each repeated key in the query
   // string. If you need to capture repeated query parameters, use
@@ -90,18 +93,20 @@ class URI {
   std::string EncodedPathAndQueryParams() const;
 
   bool operator==(const URI& other) const {
-    return scheme_ == other.scheme_ && authority_ == other.authority_ &&
-           path_ == other.path_ &&
+    return scheme_ == other.scheme_ && user_info_ == other.user_info_ &&
+           host_port_ == other.host_port_ && path_ == other.path_ &&
            query_parameter_pairs_ == other.query_parameter_pairs_ &&
            fragment_ == other.fragment_;
   }
 
  private:
-  URI(std::string scheme, std::string authority, std::string path,
-      std::vector<QueryParam> query_parameter_pairs, std::string fragment);
+  URI(std::string scheme, std::string user_info, std::string host_port,
+      std::string path, std::vector<QueryParam> query_parameter_pairs,
+      std::string fragment);
 
   std::string scheme_;
-  std::string authority_;
+  std::string user_info_;
+  std::string host_port_;
   std::string path_;
   std::map<absl::string_view, absl::string_view> query_parameter_map_;
   std::vector<QueryParam> query_parameter_pairs_;

data/src/core/util/useful.h

@@ -19,6 +19,7 @@
 
 #include <cstddef>
 #include <limits>
+#include <type_traits>
 #include <variant>
 
 #include "absl/log/check.h"
@@ -114,8 +115,58 @@ inline T SaturatingAdd(T a, T b) {
   return a + b;
 }
 
-inline uint32_t MixHash32(uint32_t a, uint32_t b) {
-  return absl::rotl(a, 2u) ^ b;
+template <
+    typename T,
+    std::enable_if_t<std::is_integral_v<T> && std::is_unsigned_v<T>, int> = 0>
+inline T SaturatingMul(T a, T b) {
+  if (a == 0 || b == 0) return 0;
+  if (b > std::numeric_limits<T>::max() / a) {
+    return std::numeric_limits<T>::max();
+  }
+  return a * b;
+}
+
+template <
+    typename T,
+    std::enable_if_t<std::is_integral_v<T> && std::is_signed_v<T>, int> = 0>
+inline T SaturatingMul(T a, T b) {
+  if (a == 0 || b == 0) return 0;
+  if (a == std::numeric_limits<T>::min()) {
+    // negation is ub
+    if (b == -1) return std::numeric_limits<T>::max();
+    if (b == 1) return std::numeric_limits<T>::min();
+    if (b > 1) return std::numeric_limits<T>::min();
+    return std::numeric_limits<T>::max();
+  }
+  if (b == std::numeric_limits<T>::min()) {
+    if (a == -1) return std::numeric_limits<T>::max();
+    if (a == 1) return std::numeric_limits<T>::min();
+    if (a > 1) return std::numeric_limits<T>::min();
+    return std::numeric_limits<T>::max();
+  }
+  if (a > 0 && b > 0) {
+    // both positive
+    if (a > std::numeric_limits<T>::max() / b) {
+      return std::numeric_limits<T>::max();
+    }
+  } else if (a < 0 && b < 0) {
+    // both negative
+    if (a < std::numeric_limits<T>::max() / b) {
+      return std::numeric_limits<T>::max();
+    }
+  } else {
+    // one positive, one negative
+    if (a > 0) {
+      if (b < std::numeric_limits<T>::min() / a) {
+        return std::numeric_limits<T>::min();
+      }
+    } else {
+      if (a < std::numeric_limits<T>::min() / b) {
+        return std::numeric_limits<T>::min();
+      }
+    }
+  }
+  return a * b;
 }
 
 inline uint32_t RoundUpToPowerOf2(uint32_t v) {