grpc 1.65.2 → 1.66.0

data/src/core/lib/promise/try_seq.h

@@ -43,22 +43,28 @@ struct TrySeqTraitsWithSfinae {
   using UnwrappedType = T;
   using WrappedType = absl::StatusOr<T>;
   template <typename Next>
-  static auto CallFactory(Next* next, T&& value) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(Next* next,
+                                                               T&& value) {
     return next->Make(std::forward<T>(value));
   }
-  static bool IsOk(const T&) { return true; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(const T&) {
+    return true;
+  }
   static const char* ErrorString(const T&) { abort(); }
   template <typename R>
   static R ReturnValue(T&&) {
     abort();
   }
   template <typename F, typename Elem>
-  static auto CallSeqFactory(F& f, Elem&& elem, T&& value)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(F& f,
+                                                                  Elem&& elem,
+                                                                  T&& value)
       -> decltype(f(std::forward<Elem>(elem), std::forward<T>(value))) {
     return f(std::forward<Elem>(elem), std::forward<T>(value));
   }
   template <typename Result, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(T prior, RunNext run_next) {
     return run_next(std::move(prior));
   }
 };
@@ -68,25 +74,31 @@ struct TrySeqTraitsWithSfinae<absl::StatusOr<T>> {
   using UnwrappedType = T;
   using WrappedType = absl::StatusOr<T>;
   template <typename Next>
-  static auto CallFactory(Next* next, absl::StatusOr<T>&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(
+      Next* next, absl::StatusOr<T>&& status) {
     return next->Make(std::move(*status));
   }
-  static bool IsOk(const absl::StatusOr<T>& status) { return status.ok(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(
+      const absl::StatusOr<T>& status) {
+    return status.ok();
+  }
   static std::string ErrorString(const absl::StatusOr<T>& status) {
     return status.status().ToString();
   }
   template <typename R>
-  static R ReturnValue(absl::StatusOr<T>&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(
+      absl::StatusOr<T>&& status) {
     return FailureStatusCast<R>(status.status());
   }
   template <typename F, typename Elem>
-  static auto CallSeqFactory(F& f, Elem&& elem, absl::StatusOr<T> value)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallSeqFactory(
+      F& f, Elem&& elem, absl::StatusOr<T> value)
       -> decltype(f(std::forward<Elem>(elem), std::move(*value))) {
     return f(std::forward<Elem>(elem), std::move(*value));
   }
   template <typename Result, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(absl::StatusOr<T> prior,
-                                            RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(absl::StatusOr<T> prior, RunNext run_next) {
     if (!prior.ok()) return FailureStatusCast<Result>(prior.status());
     return run_next(std::move(prior));
   }
@@ -128,19 +140,24 @@ struct TrySeqTraitsWithSfinae<
   using UnwrappedType = void;
   using WrappedType = T;
   template <typename Next>
-  static auto CallFactory(Next* next, T&&) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(Next* next,
+                                                               T&&) {
     return next->Make();
   }
-  static bool IsOk(const T& status) { return IsStatusOk(status); }
-  static std::string ErrorString(const T& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(const T& status) {
+    return IsStatusOk(status);
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static std::string ErrorString(
+      const T& status) {
     return IsStatusOk(status) ? "OK" : "FAILED";
   }
   template <typename R>
-  static R ReturnValue(T&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(T&& status) {
     return FailureStatusCast<R>(std::move(status));
   }
   template <typename Result, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(T prior, RunNext run_next) {
     if (!IsStatusOk(prior)) return Result(std::move(prior));
     return run_next(std::move(prior));
   }
@@ -154,20 +171,25 @@ struct TrySeqTraitsWithSfinae<
   using UnwrappedType = decltype(TakeValue(std::declval<T>()));
   using WrappedType = T;
   template <typename Next>
-  static auto CallFactory(Next* next, T&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(Next* next,
+                                                               T&& status) {
     return next->Make(TakeValue(std::forward<T>(status)));
   }
-  static bool IsOk(const T& status) { return IsStatusOk(status); }
-  static std::string ErrorString(const T& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(const T& status) {
+    return IsStatusOk(status);
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static std::string ErrorString(
+      const T& status) {
     return IsStatusOk(status) ? "OK" : "FAILED";
   }
   template <typename R>
-  static R ReturnValue(T&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(T&& status) {
     DCHECK(!IsStatusOk(status));
     return FailureStatusCast<R>(status.status());
   }
   template <typename Result, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(T prior, RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(T prior, RunNext run_next) {
     if (!IsStatusOk(prior)) return Result(std::move(prior));
     return run_next(std::move(prior));
   }
@@ -177,20 +199,25 @@ struct TrySeqTraitsWithSfinae<absl::Status> {
   using UnwrappedType = void;
   using WrappedType = absl::Status;
   template <typename Next>
-  static auto CallFactory(Next* next, absl::Status&&) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static auto CallFactory(Next* next,
+                                                               absl::Status&&) {
     return next->Make();
   }
-  static bool IsOk(const absl::Status& status) { return status.ok(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static bool IsOk(
+      const absl::Status& status) {
+    return status.ok();
+  }
   static std::string ErrorString(const absl::Status& status) {
     return status.ToString();
   }
   template <typename R>
-  static R ReturnValue(absl::Status&& status) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static R ReturnValue(
+      absl::Status&& status) {
     return FailureStatusCast<R>(std::move(status));
   }
   template <typename Result, typename RunNext>
-  static Poll<Result> CheckResultAndRunNext(absl::Status prior,
-                                            RunNext run_next) {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static Poll<Result>
+  CheckResultAndRunNext(absl::Status prior, RunNext run_next) {
     if (!prior.ok()) return StatusCast<Result>(std::move(prior));
     return run_next(std::move(prior));
   }
@@ -202,11 +229,15 @@ using TrySeqTraits = TrySeqTraitsWithSfinae<T>;
 template <typename P, typename... Fs>
 class TrySeq {
  public:
-  explicit TrySeq(P&& promise, Fs&&... factories, DebugLocation whence)
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION explicit TrySeq(P&& promise,
+                                                       Fs&&... factories,
+                                                       DebugLocation whence)
       : state_(std::forward<P>(promise), std::forward<Fs>(factories)...,
                whence) {}
 
-  auto operator()() { return state_.PollOnce(); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION auto operator()() {
+    return state_.PollOnce();
+  }
 
  private:
   SeqState<TrySeqTraits, P, Fs...> state_;
@@ -247,33 +278,33 @@ struct TrySeqIterResultTraits {
 // Status to indicate only success/failure. In the case of returning Status,
 // the construction functors take no arguments.
 template <typename F>
-F TrySeq(F functor) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION F TrySeq(F functor) {
   return functor;
 }
 
 template <typename F0, typename F1>
-promise_detail::TrySeq<F0, F1> TrySeq(F0 f0, F1 f1, DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::TrySeq<F0, F1> TrySeq(
+    F0 f0, F1 f1, DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1>(std::move(f0), std::move(f1), whence);
 }
 
 template <typename F0, typename F1, typename F2>
-promise_detail::TrySeq<F0, F1, F2> TrySeq(F0 f0, F1 f1, F2 f2,
-                                          DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::TrySeq<F0, F1, F2> TrySeq(
+    F0 f0, F1 f1, F2 f2, DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2>(std::move(f0), std::move(f1),
                                             std::move(f2), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3>
-promise_detail::TrySeq<F0, F1, F2, F3> TrySeq(F0 f0, F1 f1, F2 f2, F3 f3,
-                                              DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::TrySeq<F0, F1, F2, F3>
+TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2, F3>(
       std::move(f0), std::move(f1), std::move(f2), std::move(f3), whence);
 }
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4>
-promise_detail::TrySeq<F0, F1, F2, F3, F4> TrySeq(F0 f0, F1 f1, F2 f2, F3 f3,
-                                                  F4 f4,
-                                                  DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION promise_detail::TrySeq<F0, F1, F2, F3, F4>
+TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2, F3, F4>(
       std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
       whence);
@@ -281,8 +312,10 @@ promise_detail::TrySeq<F0, F1, F2, F3, F4> TrySeq(F0 f0, F1 f1, F2 f2, F3 f3,
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5>
-promise_detail::TrySeq<F0, F1, F2, F3, F4, F5> TrySeq(
-    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5>
+    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5,
+           DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5>(
       std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
       std::move(f5), whence);
@@ -290,9 +323,10 @@ promise_detail::TrySeq<F0, F1, F2, F3, F4, F5> TrySeq(
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6>
-promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6> TrySeq(
-    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6,
-    DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6>
+    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6,
+           DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6>(
       std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
       std::move(f5), std::move(f6), whence);
@@ -300,9 +334,10 @@ promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6> TrySeq(
 
 template <typename F0, typename F1, typename F2, typename F3, typename F4,
           typename F5, typename F6, typename F7>
-promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7> TrySeq(
-    F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
-    DebugLocation whence = {}) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+    promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7>
+    TrySeq(F0 f0, F1 f1, F2 f2, F3 f3, F4 f4, F5 f5, F6 f6, F7 f7,
+           DebugLocation whence = {}) {
   return promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7>(
       std::move(f0), std::move(f1), std::move(f2), std::move(f3), std::move(f4),
       std::move(f5), std::move(f6), std::move(f7), whence);
@@ -317,8 +352,10 @@ promise_detail::TrySeq<F0, F1, F2, F3, F4, F5, F6, F7> TrySeq(
 //   }
 //   return argument;
 template <typename Iter, typename Factory, typename Argument>
-typename promise_detail::TrySeqIterResultTraits<Iter, Factory, Argument>::Result
-TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION
+    typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
+                                                    Argument>::Result
+    TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
   using Result =
       typename promise_detail::TrySeqIterResultTraits<Iter, Factory,
                                                       Argument>::Result;

data/src/core/lib/resource_quota/arena.cc

@@ -33,19 +33,17 @@ namespace grpc_core {
 namespace {
 
 void* ArenaStorage(size_t& initial_size) {
-  static constexpr size_t base_size =
-      GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
-  initial_size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size);
-  initial_size = std::max(
-      initial_size, GPR_ROUND_UP_TO_ALIGNMENT_SIZE(
-                        arena_detail::BaseArenaContextTraits::ContextSize()));
-  size_t alloc_size = base_size + initial_size;
+  size_t base_size = Arena::ArenaOverhead() +
+                     GPR_ROUND_UP_TO_ALIGNMENT_SIZE(
+                         arena_detail::BaseArenaContextTraits::ContextSize());
+  initial_size =
+      std::max(GPR_ROUND_UP_TO_ALIGNMENT_SIZE(initial_size), base_size);
   static constexpr size_t alignment =
       (GPR_CACHELINE_SIZE > GPR_MAX_ALIGNMENT &&
        GPR_CACHELINE_SIZE % GPR_MAX_ALIGNMENT == 0)
           ? GPR_CACHELINE_SIZE
           : GPR_MAX_ALIGNMENT;
-  return gpr_malloc_aligned(alloc_size, alignment);
+  return gpr_malloc_aligned(initial_size, alignment);
 }
 
 }  // namespace
@@ -77,8 +75,9 @@ RefCountedPtr<Arena> Arena::Create(size_t initial_size,
 
 Arena::Arena(size_t initial_size, RefCountedPtr<ArenaFactory> arena_factory)
     : initial_zone_size_(initial_size),
-      total_used_(GPR_ROUND_UP_TO_ALIGNMENT_SIZE(
-          arena_detail::BaseArenaContextTraits::ContextSize())),
+      total_used_(ArenaOverhead() +
+                  GPR_ROUND_UP_TO_ALIGNMENT_SIZE(
+                      arena_detail::BaseArenaContextTraits::ContextSize())),
       arena_factory_(std::move(arena_factory)) {
   for (size_t i = 0; i < arena_detail::BaseArenaContextTraits::NumContexts();
        ++i) {
@@ -133,14 +132,17 @@ void Arena::ManagedNewObject::Link(std::atomic<ManagedNewObject*>* head) {
   }
 }
 
-RefCountedPtr<ArenaFactory> SimpleArenaAllocator(size_t initial_size) {
+MemoryAllocator DefaultMemoryAllocatorForSimpleArenaAllocator() {
+  return ResourceQuota::Default()->memory_quota()->CreateMemoryAllocator(
+      "simple-arena-allocator");
+}
+
+RefCountedPtr<ArenaFactory> SimpleArenaAllocator(size_t initial_size,
+                                                 MemoryAllocator allocator) {
   class Allocator : public ArenaFactory {
    public:
-    explicit Allocator(size_t initial_size)
-        : ArenaFactory(
-              ResourceQuota::Default()->memory_quota()->CreateMemoryAllocator(
-                  "simple-arena-allocator")),
-          initial_size_(initial_size) {}
+    Allocator(size_t initial_size, MemoryAllocator allocator)
+        : ArenaFactory(std::move(allocator)), initial_size_(initial_size) {}
 
     RefCountedPtr<Arena> MakeArena() override {
       return Arena::Create(initial_size_, Ref());
@@ -153,7 +155,7 @@ RefCountedPtr<ArenaFactory> SimpleArenaAllocator(size_t initial_size) {
    private:
     size_t initial_size_;
   };
-  return MakeRefCounted<Allocator>(initial_size);
+  return MakeRefCounted<Allocator>(initial_size, std::move(allocator));
 }
 
 }  // namespace grpc_core

data/src/core/lib/resource_quota/arena.h

@@ -87,14 +87,14 @@ class BaseArenaContextTraits {
 template <typename T>
 class ArenaContextTraits : public BaseArenaContextTraits {
  public:
-  static uint16_t id() { return id_; }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static uint16_t id() { return id_; }
 
  private:
   static const uint16_t id_;
 };
 
 template <typename T>
-void DestroyArenaContext(void* p) {
+GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void DestroyArenaContext(void* p) {
   ArenaContextType<T>::Destroy(static_cast<T*>(p));
 }
 
@@ -133,7 +133,11 @@ class ArenaFactory : public RefCounted<ArenaFactory> {
   MemoryAllocator allocator_;
 };
 
-RefCountedPtr<ArenaFactory> SimpleArenaAllocator(size_t initial_size = 1024);
+MemoryAllocator DefaultMemoryAllocatorForSimpleArenaAllocator();
+RefCountedPtr<ArenaFactory> SimpleArenaAllocator(
+    size_t initial_size = 1024,
+    MemoryAllocator allocator =
+        DefaultMemoryAllocatorForSimpleArenaAllocator());
 
 class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
                                       arena_detail::UnrefDestroy> {
@@ -156,12 +160,10 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
 
   // Allocate \a size bytes from the arena.
   void* Alloc(size_t size) {
-    static constexpr size_t base_size =
-        GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
     size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
     size_t begin = total_used_.fetch_add(size, std::memory_order_relaxed);
     if (begin + size <= initial_zone_size_) {
-      return reinterpret_cast<char*>(this) + base_size + begin;
+      return reinterpret_cast<char*>(this) + begin;
     } else {
       return AllocZone(size);
     }
@@ -245,6 +247,11 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
     return PoolPtr<T>(new T(std::forward<Args>(args)...), PooledDeleter());
   }
 
+  template <typename T>
+  static PoolPtr<T> MakePooledForOverwrite() {
+    return PoolPtr<T>(new T, PooledDeleter());
+  }
+
   // Make a unique_ptr to an array of T that is allocated from the arena.
   // When the pointer is released, the memory may be reused for other
   // MakePooled(.*) calls.
@@ -276,7 +283,7 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
   // for modern promise-based code -- however legacy filter stack based code
   // often needs to access these directly.
   template <typename T>
-  T* GetContext() {
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION T* GetContext() {
     return static_cast<T*>(
         contexts()[arena_detail::ArenaContextTraits<T>::id()]);
   }
@@ -291,6 +298,13 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
     DCHECK_EQ(GetContext<T>(), context);
   }
 
+  static size_t ArenaOverhead() {
+    return GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
+  }
+  static size_t ArenaZoneOverhead() {
+    return GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Zone));
+  }
+
  private:
   friend struct arena_detail::UnrefDestroy;
 
@@ -330,7 +344,9 @@ class Arena final : public RefCounted<Arena, NonPolymorphicRefCount,
 
   void* AllocZone(size_t size);
   void Destroy() const;
-  void** contexts() { return reinterpret_cast<void**>(this + 1); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION void** contexts() {
+    return reinterpret_cast<void**>(this + 1);
+  }
 
   // Keep track of the total used size. We use this in our call sizing
   // hysteresis.
@@ -362,8 +378,12 @@ namespace promise_detail {
 template <typename T>
 class Context<T, absl::void_t<decltype(ArenaContextType<T>::Destroy)>> {
  public:
-  static T* get() { return GetContext<Arena>()->GetContext<T>(); }
-  static void set(T* value) { GetContext<Arena>()->SetContext(value); }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static T* get() {
+    return GetContext<Arena>()->GetContext<T>();
+  }
+  GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION static void set(T* value) {
+    GetContext<Arena>()->SetContext(value);
+  }
 };
 
 }  // namespace promise_detail

data/src/core/lib/resource_quota/memory_quota.cc

@@ -26,6 +26,7 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 
@@ -355,7 +356,7 @@ void GrpcMemoryAllocatorImpl::MaybeDonateBack() {
                                           std::memory_order_acq_rel,
                                           std::memory_order_acquire)) {
       if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-        gpr_log(GPR_INFO, "[%p] Early return %" PRIdPTR " bytes", this, ret);
+        LOG(INFO) << "[" << this << "] Early return " << ret << " bytes";
       }
       CHECK(taken_bytes_.fetch_sub(ret, std::memory_order_relaxed) >= ret);
       memory_quota_->Return(ret);
@@ -452,10 +453,9 @@ void BasicMemoryQuota::Start() {
         if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
           double free = std::max(intptr_t{0}, self->free_bytes_.load());
           size_t quota_size = self->quota_size_.load();
-          gpr_log(GPR_INFO,
-                  "RQ: %s perform %s reclamation. Available free bytes: %f, "
-                  "total quota_size: %zu",
-                  self->name_.c_str(), std::get<0>(arg), free, quota_size);
+          LOG(INFO) << "RQ: " << self->name_ << " perform " << std::get<0>(arg)
+                    << " reclamation. Available free bytes: " << free
+                    << ", total quota_size: " << quota_size;
         }
         // One of the reclaimer queues gave us a way to get back memory.
         // Call the reclaimer with a token that contains enough to wake us
@@ -535,10 +535,9 @@ void BasicMemoryQuota::FinishReclamation(uint64_t token, Waker waker) {
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
       double free = std::max(intptr_t{0}, free_bytes_.load());
       size_t quota_size = quota_size_.load();
-      gpr_log(GPR_INFO,
-              "RQ: %s reclamation complete. Available free bytes: %f, "
-              "total quota_size: %zu",
-              name_.c_str(), free, quota_size);
+      LOG(INFO) << "RQ: " << name_
+                << " reclamation complete. Available free bytes: " << free
+                << ", total quota_size: " << quota_size;
     }
     waker.Wakeup();
   }
@@ -550,7 +549,7 @@ void BasicMemoryQuota::Return(size_t amount) {
 
 void BasicMemoryQuota::AddNewAllocator(GrpcMemoryAllocatorImpl* allocator) {
   if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    gpr_log(GPR_INFO, "Adding allocator %p", allocator);
+    LOG(INFO) << "Adding allocator " << allocator;
   }
 
   AllocatorBucket::Shard& shard = small_allocators_.SelectShard(allocator);
@@ -563,7 +562,7 @@ void BasicMemoryQuota::AddNewAllocator(GrpcMemoryAllocatorImpl* allocator) {
 
 void BasicMemoryQuota::RemoveAllocator(GrpcMemoryAllocatorImpl* allocator) {
   if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    gpr_log(GPR_INFO, "Removing allocator %p", allocator);
+    LOG(INFO) << "Removing allocator " << allocator;
   }
 
   AllocatorBucket::Shard& small_shard =
@@ -610,7 +609,7 @@ void BasicMemoryQuota::MaybeMoveAllocator(GrpcMemoryAllocatorImpl* allocator,
 void BasicMemoryQuota::MaybeMoveAllocatorBigToSmall(
     GrpcMemoryAllocatorImpl* allocator) {
   if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    gpr_log(GPR_INFO, "Moving allocator %p to small", allocator);
+    LOG(INFO) << "Moving allocator " << allocator << " to small";
   }
 
   AllocatorBucket::Shard& old_shard = big_allocators_.SelectShard(allocator);
@@ -631,7 +630,7 @@ void BasicMemoryQuota::MaybeMoveAllocatorBigToSmall(
 void BasicMemoryQuota::MaybeMoveAllocatorSmallToBig(
     GrpcMemoryAllocatorImpl* allocator) {
   if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-    gpr_log(GPR_INFO, "Moving allocator %p to big", allocator);
+    LOG(INFO) << "Moving allocator " << allocator << " to big";
   }
 
   AllocatorBucket::Shard& old_shard = small_allocators_.SelectShard(allocator);
@@ -768,8 +767,8 @@ double PressureTracker::AddSampleAndGetControlValue(double sample) {
       report = controller_.Update(current_estimate - kSetPoint);
     }
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-      gpr_log(GPR_INFO, "RQ: pressure:%lf report:%lf controller:%s",
-              current_estimate, report, controller_.DebugString().c_str());
+      LOG(INFO) << "RQ: pressure:" << current_estimate << " report:" << report
+                << " controller:" << controller_.DebugString();
     }
     report_.store(report, std::memory_order_relaxed);
   });

data/src/core/lib/resource_quota/memory_quota.h

@@ -29,12 +29,12 @@
 #include "absl/base/thread_annotations.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/memory_allocator.h>
 #include <grpc/event_engine/memory_request.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/debug/trace.h"
@@ -426,7 +426,8 @@ class GrpcMemoryAllocatorImpl final : public EventEngineMemoryAllocatorImpl {
     size_t ret = free_bytes_.exchange(0, std::memory_order_acq_rel);
     if (ret == 0) return;
     if (GRPC_TRACE_FLAG_ENABLED(resource_quota)) {
-      gpr_log(GPR_INFO, "Allocator %p returning %zu bytes to quota", this, ret);
+      LOG(INFO) << "Allocator " << this << " returning " << ret
+                << " bytes to quota";
     }
     taken_bytes_.fetch_sub(ret, std::memory_order_relaxed);
     memory_quota_->Return(ret);

data/src/core/lib/resource_quota/periodic_update.cc

@@ -56,8 +56,9 @@ bool PeriodicUpdate::MaybeEndPeriod(absl::FunctionRef<void(Duration)> f) {
     // Store the remainder left. Note that updates_remaining_ may have been
     // decremented by another thread whilst we performed the above calculations:
     // we simply discard those decrements.
-    updates_remaining_.store(better_guess - expected_updates_per_period_,
-                             std::memory_order_release);
+    auto remaining = better_guess - expected_updates_per_period_;
+    expected_updates_per_period_ = better_guess;
+    updates_remaining_.store(remaining, std::memory_order_release);
     // Not quite done, return, try for longer.
     return false;
   }

data/src/core/lib/security/authorization/grpc_server_authz_filter.cc

@@ -19,10 +19,10 @@
 #include <string>
 #include <utility>
 
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_stack.h"
@@ -65,14 +65,11 @@ GrpcServerAuthzFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
 bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
   EvaluateArgs args(&initial_metadata, &per_channel_evaluate_args_);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
-    gpr_log(GPR_DEBUG,
-            "checking request: url_path=%s, transport_security_type=%s, "
-            "uri_sans=[%s], dns_sans=[%s], subject=%s",
-            std::string(args.GetPath()).c_str(),
-            std::string(args.GetTransportSecurityType()).c_str(),
-            absl::StrJoin(args.GetUriSans(), ",").c_str(),
-            absl::StrJoin(args.GetDnsSans(), ",").c_str(),
-            std::string(args.GetSubject()).c_str());
+    VLOG(2) << "checking request: url_path=" << args.GetPath()
+            << ", transport_security_type=" << args.GetTransportSecurityType()
+            << ", uri_sans=[" << absl::StrJoin(args.GetUriSans(), ",")
+            << "], dns_sans=[" << absl::StrJoin(args.GetDnsSans(), ",")
+            << "], subject=" << args.GetSubject();
   }
   grpc_authorization_policy_provider::AuthorizationEngines engines =
       provider_->engines();
@@ -81,8 +78,8 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
         engines.deny_engine->Evaluate(args);
     if (decision.type == AuthorizationEngine::Decision::Type::kDeny) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
-        gpr_log(GPR_INFO, "chand=%p: request denied by policy %s.", this,
-                decision.matching_policy_name.c_str());
+        LOG(INFO) << "chand=" << this << ": request denied by policy "
+                  << decision.matching_policy_name;
       }
       return false;
     }
@@ -92,15 +89,15 @@ bool GrpcServerAuthzFilter::IsAuthorized(ClientMetadata& initial_metadata) {
         engines.allow_engine->Evaluate(args);
     if (decision.type == AuthorizationEngine::Decision::Type::kAllow) {
       if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
-        gpr_log(GPR_DEBUG, "chand=%p: request allowed by policy %s.", this,
-                decision.matching_policy_name.c_str());
+        VLOG(2) << "chand=" << this << ": request allowed by policy "
+                << decision.matching_policy_name;
       }
       return true;
     }
   }
   if (GRPC_TRACE_FLAG_ENABLED(grpc_authz_api)) {
-    gpr_log(GPR_INFO, "chand=%p: request denied, no matching policy found.",
-            this);
+    LOG(INFO) << "chand=" << this
+              << ": request denied, no matching policy found.";
   }
   return false;
 }
@@ -114,7 +111,6 @@ absl::Status GrpcServerAuthzFilter::Call::OnClientInitialMetadata(
 }
 
 const grpc_channel_filter GrpcServerAuthzFilter::kFilter =
-    MakePromiseBasedFilter<GrpcServerAuthzFilter, FilterEndpoint::kServer>(
-        "grpc-server-authz");
+    MakePromiseBasedFilter<GrpcServerAuthzFilter, FilterEndpoint::kServer>();
 
 }  // namespace grpc_core

data/src/core/lib/security/authorization/grpc_server_authz_filter.h

@@ -37,6 +37,8 @@ class GrpcServerAuthzFilter final
  public:
   static const grpc_channel_filter kFilter;
 
+  static absl::string_view TypeName() { return "grpc-server-authz"; }
+
   static absl::StatusOr<std::unique_ptr<GrpcServerAuthzFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args);