grpc 1.46.2 → 1.48.0.pre1

data/src/core/lib/event_engine/iomgr_engine/timer_manager.h

@@ -0,0 +1,111 @@
+/*
+ *
+ * Copyright 2017 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_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_MANAGER_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_MANAGER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/event_engine/iomgr_engine/timer.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace iomgr_engine {
+
+// Timer Manager tries to keep only one thread waiting for the next timeout at
+// all times, and thus effectively preventing the thundering herd problem.
+// TODO(ctiller): consider unifying this thread pool and the one in
+// thread_pool.{h,cc}.
+class TimerManager final {
+ public:
+  TimerManager();
+  ~TimerManager();
+
+  grpc_core::Timestamp Now() { return host_.Now(); }
+
+  void TimerInit(Timer* timer, grpc_core::Timestamp deadline,
+                 experimental::EventEngine::Closure* closure);
+  bool TimerCancel(Timer* timer);
+
+ private:
+  struct RunThreadArgs {
+    TimerManager* self;
+    grpc_core::Thread thread;
+  };
+
+  class Host final : public TimerListHost {
+   public:
+    explicit Host(TimerManager* timer_manager)
+        : timer_manager_(timer_manager) {}
+
+    void Kick() override;
+    grpc_core::Timestamp Now() override;
+
+   private:
+    TimerManager* const timer_manager_;
+  };
+
+  void StartThread() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
+  static void RunThread(void* arg);
+  void MainLoop();
+  void RunSomeTimers(std::vector<experimental::EventEngine::Closure*> timers);
+  bool WaitUntil(grpc_core::Timestamp next);
+  void Kick();
+
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
+  Host host_;
+  // number of threads in the system
+  size_t thread_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of threads sitting around waiting
+  size_t waiter_count_ ABSL_GUARDED_BY(mu_) = 0;
+  // Threads waiting to be joined
+  std::vector<grpc_core::Thread> completed_threads_ ABSL_GUARDED_BY(mu_);
+  // is there a thread waiting until the next timer should fire?
+  bool has_timed_waiter_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool shutdown_ ABSL_GUARDED_BY(mu_) = false;
+  // are we shutting down?
+  bool kicked_ ABSL_GUARDED_BY(mu_) = false;
+  // the deadline of the current timed waiter thread (only relevant if
+  // has_timed_waiter_ is true)
+  grpc_core::Timestamp timed_waiter_deadline_ ABSL_GUARDED_BY(mu_);
+  // generation counter to track which thread is waiting for the next timer
+  uint64_t timed_waiter_generation_ ABSL_GUARDED_BY(mu_) = 0;
+  // number of timer wakeups
+  uint64_t wakeups_ ABSL_GUARDED_BY(mu_) = 0;
+  // actual timer implementation
+  std::unique_ptr<TimerList> timer_list_;
+};
+
+}  // namespace iomgr_engine
+}  // namespace grpc_event_engine
+
+#endif /* GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_TIMER_MANAGER_H */

data/src/core/lib/event_engine/memory_allocator.cc

@@ -14,10 +14,18 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <memory>
+#include <new>
+#include <utility>
+
 #include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/memory_request.h>
+#include <grpc/slice.h>
 
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
 
 namespace grpc_event_engine {
 namespace experimental {
@@ -41,7 +49,7 @@ class SliceRefCount : public grpc_slice_refcount {
   static void Destroy(grpc_slice_refcount* p) {
     auto* rc = static_cast<SliceRefCount*>(p);
     rc->~SliceRefCount();
-    gpr_free(rc);
+    free(rc);
   }
 
   std::shared_ptr<internal::MemoryAllocatorImpl> allocator_;
@@ -52,7 +60,7 @@ class SliceRefCount : public grpc_slice_refcount {
 
 grpc_slice MemoryAllocator::MakeSlice(MemoryRequest request) {
   auto size = Reserve(request.Increase(sizeof(SliceRefCount)));
-  void* p = gpr_malloc(size);
+  void* p = malloc(size);
   new (p) SliceRefCount(allocator_, size);
   grpc_slice slice;
   slice.refcount = static_cast<SliceRefCount*>(p);

data/src/core/lib/{iomgr/event_engine → event_engine}/promise.h

@@ -11,10 +11,12 @@
 // 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_CORE_LIB_IOMGR_EVENT_ENGINE_PROMISE_H
-#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_PROMISE_H
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/log.h>
+
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_event_engine {
@@ -28,24 +30,40 @@ namespace experimental {
 template <typename T>
 class Promise {
  public:
+  // The getter will wait until the setter has been called, and will return the
+  // value passed during Set.
   T& Get() {
-    absl::MutexLock lock(&mu_);
-    cv_.Wait(&mu_);
+    grpc_core::MutexLock lock(&mu_);
+    if (!set_) {
+      cv_.Wait(&mu_);
+    }
     return val_;
   }
+  // This setter can only be called exactly once without a Reset.
+  // Will automatically unblock getters.
   void Set(T&& val) {
-    absl::MutexLock lock(&mu_);
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(!set_);
     val_ = std::move(val);
-    cv_.Signal();
+    set_ = true;
+    cv_.SignalAll();
+  }
+
+  // Can only be called after a set operation.
+  void Reset() {
+    grpc_core::MutexLock lock(&mu_);
+    GPR_ASSERT(set_);
+    set_ = false;
   }
 
  private:
-  absl::Mutex mu_;
-  absl::CondVar cv_;
+  grpc_core::Mutex mu_;
+  grpc_core::CondVar cv_;
   T val_;
+  bool set_ = false;
 };
 
 }  // namespace experimental
 }  // namespace grpc_event_engine
 
-#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_PROMISE_H
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_PROMISE_H

data/src/core/lib/event_engine/resolved_address.cc

@@ -11,13 +11,15 @@
 // 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 <grpc/support/port_platform.h>
 
+#include <string.h>
+
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/event_engine/port.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/gprpp/sync.h"
+// IWYU pragma: no_include <sys/socket.h>
 
 namespace grpc_event_engine {
 namespace experimental {

data/src/core/lib/event_engine/slice.cc

@@ -0,0 +1,102 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <string>
+#include <utility>
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/slice.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice_refcount.h"
+#include "src/core/lib/slice/slice_refcount_base.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace slice_detail {
+
+uint32_t BaseSlice::Hash() const { return grpc_slice_hash_internal(slice_); }
+
+template <>
+MutableSlice CopyConstructors<MutableSlice>::FromCopiedString(std::string s) {
+  return MutableSlice(grpc_slice_from_cpp_string(std::move(s)));
+}
+
+template <>
+Slice CopyConstructors<Slice>::FromCopiedString(std::string s) {
+  return Slice(grpc_slice_from_cpp_string(std::move(s)));
+}
+
+}  // namespace slice_detail
+
+MutableSlice::MutableSlice(const grpc_slice& slice)
+    : slice_detail::BaseSlice(slice) {
+  GPR_DEBUG_ASSERT(slice.refcount == nullptr || slice.refcount->IsUnique());
+}
+
+MutableSlice::~MutableSlice() { grpc_slice_unref_internal(c_slice()); }
+
+Slice Slice::TakeOwned() {
+  if (c_slice().refcount == nullptr) {
+    return Slice(c_slice());
+  }
+  if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+    return Slice(grpc_slice_copy(c_slice()));
+  }
+  return Slice(TakeCSlice());
+}
+
+Slice Slice::AsOwned() const {
+  if (c_slice().refcount == nullptr) {
+    return Slice(c_slice());
+  }
+  if (c_slice().refcount == grpc_slice_refcount::NoopRefcount()) {
+    return Slice(grpc_slice_copy(c_slice()));
+  }
+  return Slice(grpc_slice_ref_internal(c_slice()));
+}
+
+MutableSlice Slice::TakeMutable() {
+  if (c_slice().refcount == nullptr) {
+    return MutableSlice(c_slice());
+  }
+  if (c_slice().refcount != grpc_slice_refcount::NoopRefcount() &&
+      c_slice().refcount->IsUnique()) {
+    return MutableSlice(TakeCSlice());
+  }
+  return MutableSlice(grpc_slice_copy(c_slice()));
+}
+
+Slice::~Slice() { grpc_slice_unref_internal(c_slice()); }
+
+Slice Slice::Ref() const { return Slice(grpc_slice_ref_internal(c_slice())); }
+
+Slice Slice::FromRefcountAndBytes(grpc_slice_refcount* r, const uint8_t* begin,
+                                  const uint8_t* end) {
+  grpc_slice out;
+  out.refcount = r;
+  if (r != grpc_slice_refcount::NoopRefcount()) r->Ref();
+  out.data.refcounted.bytes = const_cast<uint8_t*>(begin);
+  out.data.refcounted.length = end - begin;
+  return Slice(out);
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/event_engine/slice_buffer.cc

@@ -0,0 +1,50 @@
+// Copyright 2022 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.
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/event_engine/slice.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice.h>
+#include <grpc/slice_buffer.h>
+
+#include "src/core/lib/slice/slice_refcount.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+void SliceBuffer::Append(Slice slice) {
+  grpc_slice_buffer_add(&slice_buffer_, slice.TakeCSlice());
+}
+
+size_t SliceBuffer::AppendIndexed(Slice slice) {
+  return grpc_slice_buffer_add_indexed(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::TakeFirst() {
+  return Slice(grpc_slice_buffer_take_first(&slice_buffer_));
+}
+
+void SliceBuffer::Prepend(Slice slice) {
+  grpc_slice_buffer_undo_take_first(&slice_buffer_, slice.TakeCSlice());
+}
+
+Slice SliceBuffer::RefSlice(size_t index) {
+  return Slice(grpc_slice_ref_internal(slice_buffer_.slices[index]));
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

data/src/core/lib/{iomgr/event_engine/pollset.h → event_engine/trace.cc}

@@ -1,4 +1,4 @@
-// Copyright 2021 The gRPC Authors
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,15 +11,8 @@
 // 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_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
-#define GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
-
 #include <grpc/support/port_platform.h>
 
-#ifdef GRPC_USE_EVENT_ENGINE
-
-/// Signals pollset_work that some work has been done.
-void grpc_pollset_ee_broadcast_event();
+#include "src/core/lib/debug/trace.h"
 
-#endif
-#endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_POLLSET_H
+grpc_core::TraceFlag grpc_event_engine_trace(false, "event_engine");

data/src/core/lib/{iomgr/endpoint_pair_event_engine.cc → event_engine/trace.h}

@@ -1,4 +1,4 @@
-// Copyright 2021 The gRPC Authors
+// Copyright 2022 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,22 +11,20 @@
 // 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 <grpc/support/port_platform.h>
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H
 
-#ifdef GRPC_USE_EVENT_ENGINE
-#include <stdlib.h>
+#include <grpc/support/port_platform.h>
 
 #include <grpc/support/log.h>
 
-#include "src/core/lib/iomgr/endpoint_pair.h"
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/debug/trace.h"
+
+extern grpc_core::TraceFlag grpc_event_engine_trace;
 
-grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
-    const char* /* name */, grpc_channel_args* /* args */) {
-  // TODO(hork): determine what's needed here in the long run
-  GPR_ASSERT(
-      false &&
-      "grpc_iomgr_create_endpoint_pair is not suppoted with event_engine");
-}
+#define GRPC_EVENT_ENGINE_TRACE(format, ...)                   \
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {      \
+    gpr_log(GPR_DEBUG, "(event_engine) " format, __VA_ARGS__); \
+  }
 
-#endif  // GRPC_USE_EVENT_ENGINE
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TRACE_H

data/src/core/lib/gpr/log.cc

@@ -47,6 +47,11 @@ static gpr_atm g_log_func = reinterpret_cast<gpr_atm>(gpr_default_log);
 static gpr_atm g_min_severity_to_print = GPR_LOG_SEVERITY_UNSET;
 static gpr_atm g_min_severity_to_print_stacktrace = GPR_LOG_SEVERITY_UNSET;
 
+void gpr_unreachable_code(const char* reason, const char* file, int line) {
+  gpr_log(file, line, GPR_LOG_SEVERITY_ERROR, "UNREACHABLE CODE: %s", reason);
+  abort();
+}
+
 const char* gpr_log_severity_string(gpr_log_severity severity) {
   switch (severity) {
     case GPR_LOG_SEVERITY_DEBUG:

data/src/core/lib/gpr/time_posix.cc

@@ -88,17 +88,14 @@ static gpr_timespec now_impl(gpr_clock_type clock_type) {
 #include <mach/mach_time.h>
 #include <sys/time.h>
 
-static double g_time_scale;
-static uint64_t g_time_start;
-
-void gpr_time_init(void) {
+static double g_time_scale = []() {
   mach_timebase_info_data_t tb = {0, 1};
-  gpr_precise_clock_init();
   mach_timebase_info(&tb);
-  g_time_scale = tb.numer;
-  g_time_scale /= tb.denom;
-  g_time_start = mach_absolute_time();
-}
+  return static_cast<double>(tb.numer) / static_cast<double>(tb.denom);
+}();
+static uint64_t g_time_start = mach_absolute_time();
+
+void gpr_time_init(void) { gpr_precise_clock_init(); }
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now;

data/src/core/lib/gpr/time_windows.cc

@@ -31,15 +31,18 @@
 
 #include "src/core/lib/gpr/time_precise.h"
 
-static LARGE_INTEGER g_start_time;
-static double g_time_scale;
-
-void gpr_time_init(void) {
+static LARGE_INTEGER g_start_time = []() {
+  LARGE_INTEGER x;
+  QueryPerformanceCounter(&x);
+  return x;
+}();
+static double g_time_scale = []() {
   LARGE_INTEGER frequency;
   QueryPerformanceFrequency(&frequency);
-  QueryPerformanceCounter(&g_start_time);
-  g_time_scale = 1.0 / (double)frequency.QuadPart;
-}
+  return 1.0 / (double)frequency.QuadPart;
+}();
+
+void gpr_time_init(void) {}
 
 static gpr_timespec now_impl(gpr_clock_type clock) {
   gpr_timespec now_tv;

data/src/core/lib/gpr/tls.h

@@ -54,8 +54,6 @@ class TlsTypeConstrainer {
 #include <array>
 #include <cstring>
 
-#include <grpc/support/log.h> /* for GPR_ASSERT */
-
 namespace grpc_core {
 
 template <typename T>
@@ -95,14 +93,14 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
           typename std::remove_const<decltype(PthreadTlsImpl::keys_)>::type
               keys;
           for (pthread_key_t& key : keys) {
-            GPR_ASSERT(0 == pthread_key_create(&key, nullptr));
+            if (0 != pthread_key_create(&key, nullptr)) abort();
           }
           return keys;
         }()) {}
   PthreadTlsImpl(T t) : PthreadTlsImpl() { *this = t; }
   ~PthreadTlsImpl() {
     for (pthread_key_t key : keys_) {
-      GPR_ASSERT(0 == pthread_key_delete(key));
+      if (0 != pthread_key_delete(key)) abort();
     }
   }
 
@@ -132,7 +130,7 @@ class PthreadTlsImpl : TlsTypeConstrainer<T> {
       size_t remaining = reinterpret_cast<char*>(&t + 1) - src;
       size_t step = std::min(sizeof(dst), remaining);
       memcpy(&dst, src, step);
-      GPR_ASSERT(0 == pthread_setspecific(key, reinterpret_cast<void*>(dst)));
+      if (0 != pthread_setspecific(key, reinterpret_cast<void*>(dst))) abort();
       src += step;
     }
     return t;

data/src/core/lib/gprpp/bitset.h

@@ -17,7 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <utility>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <type_traits>
 
 #include "src/core/lib/gpr/useful.h"
 
@@ -33,6 +36,7 @@ namespace grpc_core {
 // exactly that number of bits. Undefined if that bit count is not available.
 template <size_t kBits>
 struct UintSelector;
+
 template <>
 struct UintSelector<8> {
   typedef uint8_t Type;

data/src/core/lib/gprpp/chunked_vector.h

@@ -18,6 +18,10 @@
 #include <grpc/support/port_platform.h>
 
 #include <cstddef>
+#include <iterator>
+#include <utility>
+
+#include <grpc/support/log.h>
 
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/resource_quota/arena.h"

data/src/core/lib/gprpp/construct_destruct.h

@@ -17,6 +17,7 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <new>
 #include <utility>
 
 namespace grpc_core {

data/src/core/lib/gprpp/dual_ref_counted.h

@@ -20,12 +20,9 @@
 #include <grpc/support/port_platform.h>
 
 #include <atomic>
-#include <cassert>
-#include <cinttypes>
+#include <cstdint>
 
-#include <grpc/support/atm.h>
 #include <grpc/support/log.h>
-#include <grpc/support/sync.h>
 
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/orphanable.h"

data/src/core/lib/gprpp/examine_stack.h

@@ -21,7 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <functional>
 #include <string>
 
 #include "absl/types/optional.h"

data/src/core/lib/gprpp/fork.cc

@@ -20,15 +20,12 @@
 
 #include "src/core/lib/gprpp/fork.h"
 
-#include <string.h>
-
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/atm.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/gpr/useful.h"
-#include "src/core/lib/gprpp/global_config.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/global_config_env.h"
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK

data/src/core/lib/gprpp/global_config.h

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
 // --------------------------------------------------------------------
 // How to use global configuration variables:
 //
@@ -89,7 +87,7 @@
 //   bool gpr_global_config_get_test();
 //   void gpr_global_config_set_test(bool value);
 
-#include "src/core/lib/gprpp/global_config_custom.h"
-#include "src/core/lib/gprpp/global_config_env.h"
+#include "src/core/lib/gprpp/global_config_custom.h"  // IWYU pragma: export
+#include "src/core/lib/gprpp/global_config_env.h"     // IWYU pragma: export
 
 #endif /* GRPC_CORE_LIB_GPRPP_GLOBAL_CONFIG_H */

data/src/core/lib/gprpp/global_config_env.cc

@@ -21,13 +21,14 @@
 #include "src/core/lib/gprpp/global_config_env.h"
 
 #include <ctype.h>
-#include <string.h>
+#include <stdlib.h>
 
+#include <memory>
 #include <string>
+#include <type_traits>
 
 #include "absl/strings/str_format.h"
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>