grpc 1.66.0 → 1.67.0.pre1

data/src/core/util/ring_buffer.h

@@ -0,0 +1,123 @@
+// Copyright 2024 gRPC authors.
+//
+// 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.
+
+#ifndef GRPC_SRC_CORE_UTIL_RING_BUFFER_H
+#define GRPC_SRC_CORE_UTIL_RING_BUFFER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <array>
+#include <cstddef>
+#include <iterator>
+
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+template <typename T, int kCapacity>
+class RingBuffer {
+ public:
+  class RingBufferIterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = const T;
+    using pointer = void;
+    using reference = void;
+    using difference_type = std::ptrdiff_t;
+
+    RingBufferIterator& operator++() {
+      if (--size_ <= 0) {
+        head_ = 0;
+        size_ = 0;
+        buffer_ = nullptr;
+      } else {
+        head_ = (head_ + 1) % kCapacity;
+      }
+      return *this;
+    }
+
+    RingBufferIterator operator++(int) {
+      RingBufferIterator tmp(*this);
+      operator++();
+      return tmp;
+    }
+
+    bool operator==(const RingBufferIterator& rhs) const {
+      return (buffer_ == rhs.buffer_ && head_ == rhs.head_ &&
+              size_ == rhs.size_);
+    }
+
+    bool operator!=(const RingBufferIterator& rhs) const {
+      return !operator==(rhs);
+    }
+
+    T operator*() { return buffer_->data_[head_]; }
+
+    RingBufferIterator() : buffer_(nullptr), head_(0), size_(0) {};
+    RingBufferIterator(const RingBufferIterator& other) = default;
+    explicit RingBufferIterator(const RingBuffer<T, kCapacity>* buffer)
+        : buffer_(buffer), head_(buffer->head_), size_(buffer->size_) {
+      if (!size_) {
+        buffer_ = nullptr;
+      }
+    }
+
+   private:
+    friend class RingBuffer<T, kCapacity>;
+    const RingBuffer<T, kCapacity>* buffer_;
+    int head_ = 0;
+    int size_ = 0;
+  };
+
+  RingBuffer() = default;
+
+  void Append(T data) {
+    if (size_ < kCapacity) {
+      data_[size_] = std::move(data);
+      size_++;
+    } else {
+      data_[head_] = std::move(data);
+      head_ = (head_ + 1) % kCapacity;
+    }
+  }
+
+  // Returns the data of the first element in the buffer and removes it from
+  // the buffer. If the buffer is empty, returns absl::nullopt.
+  absl::optional<T> PopIfNotEmpty() {
+    if (!size_) return absl::nullopt;
+    T data = std::move(data_[head_]);
+    --size_;
+    head_ = (head_ + 1) % kCapacity;
+    return data;
+  }
+
+  void Clear() {
+    head_ = 0;
+    size_ = 0;
+  }
+
+  RingBufferIterator begin() const { return RingBufferIterator(this); }
+
+  RingBufferIterator end() const { return RingBufferIterator(); }
+
+ private:
+  friend class RingBufferIterator;
+  std::array<T, kCapacity> data_;
+  int head_ = 0;
+  int size_ = 0;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_RING_BUFFER_H

data/src/core/util/spinlock.h

@@ -34,8 +34,7 @@ struct gpr_spinlock {
 #else
 #define GPR_SPINLOCK_INITIALIZER ((gpr_spinlock){0})
 #endif
-#define GPR_SPINLOCK_STATIC_INITIALIZER \
-  { 0 }
+#define GPR_SPINLOCK_STATIC_INITIALIZER {0}
 
 #define gpr_spinlock_trylock(lock) (gpr_atm_acq_cas(&(lock)->atm, 0, 1))
 #define gpr_spinlock_unlock(lock) (gpr_atm_rel_store(&(lock)->atm, 0))

data/src/core/util/string.cc

@@ -29,9 +29,9 @@
 #include <time.h>
 
 #include "absl/strings/str_cat.h"
+#include "absl/time/time.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/crash.h"
@@ -54,14 +54,14 @@ char* gpr_strdup(const char* src) {
 }
 
 std::string gpr_format_timespec(gpr_timespec tm) {
-  char time_buffer[35];
-  char ns_buffer[11];  // '.' + 9 digits of precision
-  struct tm* tm_info = localtime(reinterpret_cast<time_t*>(&tm.tv_sec));
-  strftime(time_buffer, sizeof(time_buffer), "%Y-%m-%dT%H:%M:%S", tm_info);
-  snprintf(ns_buffer, 11, ".%09d", tm.tv_nsec);
+  const std::string time_str =
+      absl::FormatTime("%Y-%m-%d%ET%H:%M:%S", absl::FromUnixSeconds(tm.tv_sec),
+                       absl::LocalTimeZone());
   // This loop trims off trailing zeros by inserting a null character that the
   // right point. We iterate in chunks of three because we want 0, 3, 6, or 9
   // fractional digits.
+  char ns_buffer[11];  // '.' + 9 digits of precision
+  snprintf(ns_buffer, 11, ".%09d", tm.tv_nsec);
   for (int i = 7; i >= 1; i -= 3) {
     if (ns_buffer[i] == '0' && ns_buffer[i + 1] == '0' &&
         ns_buffer[i + 2] == '0') {
@@ -74,7 +74,7 @@ std::string gpr_format_timespec(gpr_timespec tm) {
       break;
     }
   }
-  return absl::StrCat(time_buffer, ns_buffer, "Z");
+  return absl::StrCat(time_str, ns_buffer, "Z");
 }
 
 struct dump_out {

data/src/core/util/sync.cc

@@ -25,7 +25,6 @@
 #include "absl/log/check.h"
 
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
 // Number of mutexes to allocate for events, to avoid lock contention.

data/src/core/util/sync_abseil.cc

@@ -29,7 +29,6 @@
 #include "absl/time/time.h"
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 

data/src/core/util/time.cc

@@ -26,7 +26,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/crash.h"

data/src/core/util/unique_ptr_with_bitset.h

@@ -0,0 +1,86 @@
+// Copyright 2024 gRPC authors.
+//
+// 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.
+
+#ifndef GRPC_SRC_CORE_UTIL_UNIQUE_PTR_WITH_BITSET_H
+#define GRPC_SRC_CORE_UTIL_UNIQUE_PTR_WITH_BITSET_H
+
+#include <memory>
+#include <utility>
+
+#include "absl/log/check.h"
+#include "absl/numeric/bits.h"
+
+namespace grpc_core {
+
+// Like std::unique_ptr, but also includes a small bitset stored in the lower
+// bits of the underlying T*.
+template <typename T, size_t kBits>
+class UniquePtrWithBitset {
+ public:
+  UniquePtrWithBitset() : p_(0) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  UniquePtrWithBitset(std::nullptr_t) : p_(0) {}
+  explicit UniquePtrWithBitset(T* p) : p_(reinterpret_cast<uintptr_t>(p)) {}
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  UniquePtrWithBitset(std::unique_ptr<T>&& p)
+      : UniquePtrWithBitset(p.release()) {}
+  ~UniquePtrWithBitset() {
+    DCHECK_LE(kBits, static_cast<size_t>(absl::countr_zero(alignof(T))));
+    delete get();
+  }
+  UniquePtrWithBitset(const UniquePtrWithBitset&) = delete;
+  UniquePtrWithBitset& operator=(const UniquePtrWithBitset&) = delete;
+  UniquePtrWithBitset(UniquePtrWithBitset&& other) noexcept
+      : p_(std::exchange(other.p_, 0)) {}
+  UniquePtrWithBitset& operator=(UniquePtrWithBitset&& other) noexcept {
+    p_ = std::exchange(other.p_, 0);
+    return *this;
+  }
+
+  T* get() const { return reinterpret_cast<T*>(p_ & ~kBitMask); }
+  T* operator->() const { return get(); }
+  T& operator*() const { return *get(); }
+  explicit operator bool() const { return get() != nullptr; }
+  void reset(T* p = nullptr) {
+    uintptr_t bits = p_ & kBitMask;
+    delete get();
+    p_ = reinterpret_cast<uintptr_t>(p) | bits;
+  }
+
+  void SetBit(size_t bit) {
+    DCHECK_LT(bit, kBits);
+    p_ |= 1 << bit;
+  }
+  void ClearBit(size_t bit) {
+    DCHECK_LT(bit, kBits);
+    p_ &= ~(1 << bit);
+  }
+  bool TestBit(size_t bit) const {
+    DCHECK_LT(bit, kBits);
+    return p_ & (1 << bit);
+  }
+
+  friend bool operator==(const UniquePtrWithBitset& a,
+                         const UniquePtrWithBitset& b) {
+    return a.p_ == b.p_;
+  }
+
+ private:
+  static constexpr uintptr_t kBitMask = (1 << kBits) - 1;
+  uintptr_t p_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_UTIL_UNIQUE_PTR_WITH_BITSET_H

data/src/core/util/useful.h

@@ -57,30 +57,6 @@ bool GetBit(T i, size_t n) {
   return (i & (T(1) << n)) != 0;
 }
 
-#if GRPC_HAS_BUILTIN(__builtin_ctz)
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
-    uint32_t i) {
-  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
-  return __builtin_ctz(i);
-}
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
-    uint64_t i) {
-  DCHECK_NE(i, 0u);  // __builtin_ctz returns undefined behavior for 0
-  return __builtin_ctzll(i);
-}
-#else
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
-    uint32_t i) {
-  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
-  return absl::popcount((i & -i) - 1);
-}
-GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION inline uint32_t CountTrailingZeros(
-    uint64_t i) {
-  DCHECK_NE(i, 0);  // __builtin_ctz returns undefined behavior for 0
-  return absl::popcount((i & -i) - 1);
-}
-#endif
-
 // This function uses operator< to implement a qsort-style comparison, whereby:
 // if a is smaller than b, a number smaller than 0 is returned.
 // if a is bigger than b, a number greater than 0 is returned.

data/src/core/util/windows/cpu.cc

@@ -20,7 +20,6 @@
 
 #ifdef GPR_WINDOWS
 #include <grpc/support/cpu.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/crash.h"
 

data/src/core/util/windows/sync.cc

@@ -25,7 +25,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 

data/src/core/util/windows/time.cc

@@ -28,7 +28,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/crash.h"

data/src/core/util/windows/tmpfile.cc

@@ -26,7 +26,6 @@
 #include <tchar.h>
 
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/crash.h"

data/src/core/xds/grpc/xds_bootstrap_grpc.cc

@@ -18,8 +18,6 @@
 
 #include <stdlib.h>
 
-#include <algorithm>
-#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -36,29 +34,14 @@
 #include <grpc/support/json.h>
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/json/json_reader.h"
 #include "src/core/util/json/json_writer.h"
-#include "src/core/util/string.h"
 
 namespace grpc_core {
 
-namespace {
-bool IsFallbackExperimentEnabled() {
-  auto fallback_enabled = GetEnv("GRPC_EXPERIMENTAL_XDS_FALLBACK");
-  bool enabled = false;
-  return gpr_parse_bool_value(fallback_enabled.value_or("0").c_str(),
-                              &enabled) &&
-         enabled;
-}
-
-}  // namespace
-
 //
 // GrpcXdsBootstrap::GrpcNode::Locality
 //
@@ -106,16 +89,6 @@ const JsonLoaderInterface* GrpcXdsBootstrap::GrpcAuthority::JsonLoader(
   return loader;
 }
 
-void GrpcXdsBootstrap::GrpcAuthority::JsonPostLoad(
-    const Json& /*json*/, const JsonArgs& /*args*/,
-    ValidationErrors* /*errors*/) {
-  if (!IsFallbackExperimentEnabled()) {
-    if (servers_.size() > 1) {
-      servers_.resize(1);
-    }
-  }
-}
-
 //
 // GrpcXdsBootstrap
 //
@@ -190,11 +163,6 @@ void GrpcXdsBootstrap::JsonPostLoad(const Json& /*json*/,
       }
     }
   }
-  if (!IsFallbackExperimentEnabled()) {
-    if (servers_.size() > 1) {
-      servers_.resize(1);
-    }
-  }
 }
 
 std::string GrpcXdsBootstrap::ToString() const {

data/src/core/xds/grpc/xds_bootstrap_grpc.h

@@ -19,7 +19,6 @@
 
 #include <map>
 #include <memory>
-#include <set>
 #include <string>
 #include <vector>
 
@@ -29,9 +28,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/json/json_args.h"
 #include "src/core/util/json/json_object_loader.h"
@@ -93,8 +90,6 @@ class GrpcXdsBootstrap final : public XdsBootstrap {
     }
 
     static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
-    void JsonPostLoad(const Json& json, const JsonArgs& args,
-                      ValidationErrors* errors);
 
    private:
     std::vector<GrpcXdsServer> servers_;

data/src/core/xds/grpc/xds_certificate_provider.cc

@@ -24,7 +24,6 @@
 #include "absl/log/check.h"
 #include "absl/types/optional.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/xds/grpc/xds_client_grpc.cc

@@ -198,11 +198,10 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
   // First, try GRPC_XDS_BOOTSTRAP env var.
   auto path = GetEnv("GRPC_XDS_BOOTSTRAP");
   if (path.has_value()) {
-    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-      LOG(INFO) << "Got bootstrap file location from GRPC_XDS_BOOTSTRAP "
-                   "environment variable: "
-                << *path;
-    }
+    GRPC_TRACE_LOG(xds_client, INFO)
+        << "Got bootstrap file location from GRPC_XDS_BOOTSTRAP "
+           "environment variable: "
+        << *path;
     auto contents = LoadFile(*path, /*add_null_terminator=*/true);
     if (!contents.ok()) return contents.status();
     return std::string(contents->as_string_view());
@@ -210,10 +209,9 @@ absl::StatusOr<std::string> GetBootstrapContents(const char* fallback_config) {
   // Next, try GRPC_XDS_BOOTSTRAP_CONFIG env var.
   auto env_config = GetEnv("GRPC_XDS_BOOTSTRAP_CONFIG");
   if (env_config.has_value()) {
-    if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-      LOG(INFO) << "Got bootstrap contents from GRPC_XDS_BOOTSTRAP_CONFIG "
-                   "environment variable";
-    }
+    GRPC_TRACE_LOG(xds_client, INFO)
+        << "Got bootstrap contents from GRPC_XDS_BOOTSTRAP_CONFIG "
+        << "environment variable";
     return std::move(*env_config);
   }
   // Finally, try fallback config.
@@ -258,9 +256,8 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
   // Find bootstrap contents.
   auto bootstrap_contents = GetBootstrapContents(g_fallback_bootstrap_config);
   if (!bootstrap_contents.ok()) return bootstrap_contents.status();
-  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    LOG(INFO) << "xDS bootstrap contents: " << *bootstrap_contents;
-  }
+  GRPC_TRACE_LOG(xds_client, INFO)
+      << "xDS bootstrap contents: " << *bootstrap_contents;
   // Parse bootstrap.
   auto bootstrap = GrpcXdsBootstrap::Create(*bootstrap_contents);
   if (!bootstrap.ok()) return bootstrap.status();
@@ -270,10 +267,8 @@ absl::StatusOr<RefCountedPtr<GrpcXdsClient>> GrpcXdsClient::GetOrCreate(
       key, std::move(*bootstrap), channel_args,
       MakeOrphanable<GrpcXdsTransportFactory>(channel_args));
   g_xds_client_map->emplace(xds_client->key(), xds_client.get());
-  if (GRPC_TRACE_FLAG_ENABLED(xds_client)) {
-    LOG(INFO) << "[xds_client " << xds_client.get()
-              << "] Created xDS client for key " << key;
-  }
+  GRPC_TRACE_LOG(xds_client, INFO) << "[xds_client " << xds_client.get()
+                                   << "] Created xDS client for key " << key;
   return xds_client;
 }
 

data/src/core/xds/grpc/xds_cluster.cc

@@ -65,14 +65,8 @@ std::string XdsClusterResource::ToString() const {
       absl::StrCat("max_concurrent_requests=", max_concurrent_requests));
   contents.push_back(absl::StrCat("override_host_statuses=",
                                   override_host_statuses.ToString()));
-  if (!service_telemetry_label.as_string_view().empty()) {
-    contents.push_back(absl::StrCat("service_name_telemetry_label=",
-                                    service_telemetry_label.as_string_view()));
-  }
-  if (!namespace_telemetry_label.as_string_view().empty()) {
-    contents.push_back(
-        absl::StrCat("service_namespace_telemetry_label=",
-                     namespace_telemetry_label.as_string_view()));
+  if (!metadata.empty()) {
+    contents.push_back(absl::StrCat("metadata={", metadata.ToString(), "}"));
   }
   return absl::StrCat("{", absl::StrJoin(contents, ", "), "}");
 }

data/src/core/xds/grpc/xds_cluster.h

@@ -20,6 +20,7 @@
 #include <string>
 #include <vector>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/types/optional.h"
 #include "absl/types/variant.h"
 
@@ -27,6 +28,7 @@
 #include "src/core/util/json/json.h"
 #include "src/core/xds/grpc/xds_common_types.h"
 #include "src/core/xds/grpc/xds_health_status.h"
+#include "src/core/xds/grpc/xds_metadata.h"
 #include "src/core/xds/grpc/xds_server_grpc.h"
 #include "src/core/xds/xds_client/xds_resource_type.h"
 #include "src/core/xds/xds_client/xds_resource_type_impl.h"
@@ -86,8 +88,7 @@ struct XdsClusterResource : public XdsResourceType::ResourceData {
 
   XdsHealthStatusSet override_host_statuses;
 
-  RefCountedStringValue service_telemetry_label;
-  RefCountedStringValue namespace_telemetry_label;
+  XdsMetadataMap metadata;
 
   bool operator==(const XdsClusterResource& other) const {
     return type == other.type && lb_policy_config == other.lb_policy_config &&
@@ -97,8 +98,7 @@ struct XdsClusterResource : public XdsResourceType::ResourceData {
            max_concurrent_requests == other.max_concurrent_requests &&
            outlier_detection == other.outlier_detection &&
            override_host_statuses == other.override_host_statuses &&
-           service_telemetry_label == other.service_telemetry_label &&
-           namespace_telemetry_label == other.namespace_telemetry_label;
+           metadata == other.metadata;
   }
 
   std::string ToString() const;