grpc 1.46.3 → 1.47.0

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

@@ -0,0 +1,206 @@
+// 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.
+// 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 "src/core/lib/event_engine/iomgr_engine.h"
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/cleanup/cleanup.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/clock.h"
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/event_engine/trace.h"
+#include "src/core/lib/gprpp/match.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/executor.h"
+#include "src/core/lib/iomgr/timer.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+namespace {
+
+struct ClosureData {
+  grpc_timer timer;
+  grpc_closure closure;
+  absl::variant<std::function<void()>, EventEngine::Closure*> cb;
+  IomgrEventEngine* engine;
+  EventEngine::TaskHandle handle;
+};
+
+// Timer limits due to quirks in the iomgr implementation.
+// If deadline <= Now, the callback will be run inline, which can result in lock
+// issues. And absl::InfiniteFuture yields UB.
+absl::Time Clamp(absl::Time when) {
+  absl::Time max = absl::Now() + absl::Hours(8766);
+  absl::Time min = absl::Now() + absl::Milliseconds(2);
+  if (when > max) return max;
+  if (when < min) return min;
+  return when;
+}
+
+std::string HandleToString(EventEngine::TaskHandle handle) {
+  return absl::StrCat("{", handle.keys[0], ",", handle.keys[1], "}");
+}
+
+}  // namespace
+
+IomgrEventEngine::IomgrEventEngine() {}
+
+IomgrEventEngine::~IomgrEventEngine() {
+  grpc_core::MutexLock lock(&mu_);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
+    for (auto handle : known_handles_) {
+      gpr_log(GPR_ERROR,
+              "(event_engine) IomgrEventEngine:%p uncleared TaskHandle at "
+              "shutdown:%s",
+              this, HandleToString(handle).c_str());
+    }
+  }
+  GPR_ASSERT(GPR_LIKELY(known_handles_.empty()));
+}
+
+bool IomgrEventEngine::Cancel(EventEngine::TaskHandle handle) {
+  grpc_core::ExecCtx ctx;
+  grpc_core::MutexLock lock(&mu_);
+  if (!known_handles_.contains(handle)) return false;
+  auto* cd = reinterpret_cast<ClosureData*>(handle.keys[0]);
+  grpc_timer_cancel(&cd->timer);
+  known_handles_.erase(handle);
+  return true;
+}
+
+EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
+                                                std::function<void()> closure) {
+  return RunAtInternal(when, std::move(closure));
+}
+
+EventEngine::TaskHandle IomgrEventEngine::RunAt(absl::Time when,
+                                                EventEngine::Closure* closure) {
+  return RunAtInternal(when, closure);
+}
+
+void IomgrEventEngine::Run(std::function<void()> closure) {
+  RunInternal(closure);
+}
+
+void IomgrEventEngine::Run(EventEngine::Closure* closure) {
+  RunInternal(closure);
+}
+
+EventEngine::TaskHandle IomgrEventEngine::RunAtInternal(
+    absl::Time when,
+    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
+  when = Clamp(when);
+  grpc_core::ExecCtx ctx;
+  auto* cd = new ClosureData;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  GRPC_CLOSURE_INIT(
+      &cd->closure,
+      [](void* arg, grpc_error_handle error) {
+        auto* cd = static_cast<ClosureData*>(arg);
+        GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p executing callback:%s",
+                                cd->engine, HandleToString(cd->handle).c_str());
+        {
+          grpc_core::MutexLock lock(&cd->engine->mu_);
+          cd->engine->known_handles_.erase(cd->handle);
+        }
+        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
+        if (error == GRPC_ERROR_CANCELLED) return;
+        grpc_core::Match(
+            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
+            [](std::function<void()> fn) { fn(); });
+      },
+      cd, nullptr);
+  // kludge to deal with realtime/monotonic clock conversion
+  absl::Time absl_now = absl::Now();
+  grpc_core::Duration duration = grpc_core::Duration::Milliseconds(
+      absl::ToInt64Milliseconds(when - absl_now) + 1);
+  grpc_core::ExecCtx::Get()->InvalidateNow();
+  grpc_core::Timestamp when_internal = grpc_core::ExecCtx::Get()->Now() +
+                                       duration +
+                                       grpc_core::Duration::Milliseconds(1);
+  EventEngine::TaskHandle handle{reinterpret_cast<intptr_t>(cd),
+                                 aba_token_.fetch_add(1)};
+  grpc_core::MutexLock lock(&mu_);
+  known_handles_.insert(handle);
+  cd->handle = handle;
+  GRPC_EVENT_ENGINE_TRACE("IomgrEventEngine:%p scheduling callback:%s", this,
+                          HandleToString(handle).c_str());
+  grpc_timer_init(&cd->timer, when_internal, &cd->closure);
+  return handle;
+}
+
+void IomgrEventEngine::RunInternal(
+    absl::variant<std::function<void()>, EventEngine::Closure*> cb) {
+  auto* cd = new ClosureData;
+  cd->cb = std::move(cb);
+  cd->engine = this;
+  GRPC_CLOSURE_INIT(
+      &cd->closure,
+      [](void* arg, grpc_error_handle /*error*/) {
+        auto* cd = static_cast<ClosureData*>(arg);
+        auto cleaner = absl::MakeCleanup([cd] { delete cd; });
+        grpc_core::Match(
+            cd->cb, [](EventEngine::Closure* cb) { cb->Run(); },
+            [](std::function<void()> fn) { fn(); });
+      },
+      cd, nullptr);
+  // TODO(hork): have the EE spawn dedicated closure thread(s)
+  grpc_core::Executor::Run(&cd->closure, GRPC_ERROR_NONE);
+}
+
+std::unique_ptr<EventEngine::DNSResolver> IomgrEventEngine::GetDNSResolver(
+    EventEngine::DNSResolver::ResolverOptions const& /*options*/) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+bool IomgrEventEngine::IsWorkerThread() {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+bool IomgrEventEngine::CancelConnect(EventEngine::ConnectionHandle /*handle*/) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+EventEngine::ConnectionHandle IomgrEventEngine::Connect(
+    OnConnectCallback /*on_connect*/, const ResolvedAddress& /*addr*/,
+    const EndpointConfig& /*args*/, MemoryAllocator /*memory_allocator*/,
+    absl::Time /*deadline*/) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+absl::StatusOr<std::unique_ptr<EventEngine::Listener>>
+IomgrEventEngine::CreateListener(
+    Listener::AcceptCallback /*on_accept*/,
+    std::function<void(absl::Status)> /*on_shutdown*/,
+    const EndpointConfig& /*config*/,
+    std::unique_ptr<MemoryAllocatorFactory> /*memory_allocator_factory*/) {
+  GPR_ASSERT(false && "unimplemented");
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,118 @@
+// 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.
+// 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_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#include <stdint.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+#include "absl/time/time.h"
+#include "absl/types/variant.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/slice_buffer.h>
+
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class IomgrEventEngine final : public EventEngine {
+ public:
+  class IomgrEndpoint : public EventEngine::Endpoint {
+   public:
+    ~IomgrEndpoint() override;
+    void Read(std::function<void(absl::Status)> on_read, SliceBuffer* buffer,
+              const ReadArgs* args) override;
+    void Write(std::function<void(absl::Status)> on_writable, SliceBuffer* data,
+               const WriteArgs* args) override;
+    const ResolvedAddress& GetPeerAddress() const override;
+    const ResolvedAddress& GetLocalAddress() const override;
+  };
+  class IomgrListener : public EventEngine::Listener {
+   public:
+    ~IomgrListener() override;
+    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
+    absl::Status Start() override;
+  };
+  class IomgrDNSResolver : public EventEngine::DNSResolver {
+   public:
+    ~IomgrDNSResolver() override;
+    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
+                                    absl::string_view name,
+                                    absl::string_view default_port,
+                                    absl::Time deadline) override;
+    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
+                               absl::string_view name,
+                               absl::Time deadline) override;
+    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
+                               absl::string_view name,
+                               absl::Time deadline) override;
+    bool CancelLookup(LookupTaskHandle handle) override;
+  };
+
+  IomgrEventEngine();
+  ~IomgrEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      std::function<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           absl::Time deadline) override;
+
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(std::function<void()> closure) override;
+  TaskHandle RunAt(absl::Time when, Closure* closure) override;
+  TaskHandle RunAt(absl::Time when, std::function<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  EventEngine::TaskHandle RunAtInternal(
+      absl::Time when,
+      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
+
+  void RunInternal(
+      absl::variant<std::function<void()>, EventEngine::Closure*> cb);
+
+  grpc_core::Mutex mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  std::atomic<intptr_t> aba_token_{0};
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_IOMGR_ENGINE_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/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/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"