grpc 1.39.0 → 1.41.0

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

@@ -14,13 +14,11 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include "src/core/lib/iomgr/event_engine/iomgr.h"
-
 #include <grpc/event_engine/event_engine.h>
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/closure.h"
-#include "src/core/lib/iomgr/event_engine/promise.h"
+#include "src/core/lib/iomgr/event_engine/iomgr.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/tcp_client.h"
 #include "src/core/lib/iomgr/tcp_server.h"
@@ -42,25 +40,15 @@ namespace {
 
 using ::grpc_event_engine::experimental::DefaultEventEngineFactory;
 using ::grpc_event_engine::experimental::EventEngine;
-using ::grpc_event_engine::experimental::Promise;
 
-// Note: This is a pointer to a shared_ptr, so it's trivially destructible.
-std::shared_ptr<EventEngine>* g_event_engine;
+EventEngine* g_event_engine = nullptr;
 
-void iomgr_platform_init(void) {
-  g_event_engine =
-      new std::shared_ptr<EventEngine>(DefaultEventEngineFactory());
-}
+// TODO(nnoble): Instantiate the default EventEngine if none have been provided.
+void iomgr_platform_init(void) { GPR_ASSERT(g_event_engine != nullptr); }
 
 void iomgr_platform_flush(void) {}
 
 void iomgr_platform_shutdown(void) {
-  Promise<absl::Status> shutdown_status_promise;
-  (*g_event_engine)->Shutdown([&shutdown_status_promise](absl::Status status) {
-    shutdown_status_promise.Set(std::move(status));
-  });
-  auto shutdown_status = shutdown_status_promise.Get();
-  GPR_ASSERT(shutdown_status.ok());
   delete g_event_engine;
   g_event_engine = nullptr;
 }
@@ -68,7 +56,7 @@ void iomgr_platform_shutdown(void) {
 void iomgr_platform_shutdown_background_closure(void) {}
 
 bool iomgr_platform_is_any_background_poller_thread(void) {
-  return (*g_event_engine)->IsWorkerThread();
+  return g_event_engine->IsWorkerThread();
 }
 
 bool iomgr_platform_add_closure_to_background_poller(
@@ -99,7 +87,18 @@ void grpc_set_default_iomgr_platform() {
 bool grpc_iomgr_run_in_background() { return false; }
 
 grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine() {
-  return g_event_engine->get();
+  return g_event_engine;
 }
 
+namespace grpc_core {
+
+void SetDefaultEventEngine(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine>
+        event_engine) {
+  GPR_ASSERT(g_event_engine == nullptr);
+  g_event_engine = event_engine.release();
+}
+
+}  // namespace grpc_core
+
 #endif  // GRPC_USE_EVENT_ENGINE

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

@@ -17,8 +17,26 @@
 
 #include <grpc/event_engine/event_engine.h>
 
-// This can be called anywhere in the EE-based iomgr impl where we need to
-// access the global EE instance.
+/// This can be called anywhere in the EventEngine-based iomgr impl where we
+/// need to access the global EventEngine instance.
 grpc_event_engine::experimental::EventEngine* grpc_iomgr_event_engine();
 
+namespace grpc_core {
+
+/// Set the default \a EventEngine.
+///
+/// The iomgr interfaces conceptually expose a global singleton iomgr instance
+/// that is shared throughout gRPC. To accomodate an EventEngine-based iomgr
+/// implementation, this method sets the default EventEngine that will be used.
+/// The default EventEngine can only be set once during the lifetime of gRPC.
+/// This method must be called before \a grpc_init() (truly, before
+/// \a grpc_iomgr_init()). This engine is shut down along with iomgr.
+///
+/// This is an internal method, not intended for public use. Public APIs are
+/// being planned.
+void SetDefaultEventEngine(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine> event_engine);
+
+}  // namespace grpc_core
+
 #endif  // GRPC_CORE_LIB_IOMGR_EVENT_ENGINE_IOMGR_H

data/src/core/lib/iomgr/event_engine/resolver.cc

@@ -14,9 +14,10 @@
 #include <grpc/support/port_platform.h>
 
 #ifdef GRPC_USE_EVENT_ENGINE
-#include <grpc/event_engine/event_engine.h>
 #include "absl/functional/bind_front.h"
 
+#include <grpc/event_engine/event_engine.h>
+
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/iomgr/error.h"

data/src/core/lib/iomgr/event_engine/tcp.cc

@@ -38,20 +38,66 @@ using ::grpc_event_engine::experimental::EventEngine;
 using ::grpc_event_engine::experimental::GrpcClosureToCallback;
 using ::grpc_event_engine::experimental::SliceAllocator;
 using ::grpc_event_engine::experimental::SliceAllocatorFactory;
+using ::grpc_event_engine::experimental::SliceBuffer;
 }  // namespace
 
+class WrappedInternalSliceAllocator : public SliceAllocator {
+ public:
+  explicit WrappedInternalSliceAllocator(grpc_slice_allocator* slice_allocator)
+      : slice_allocator_(slice_allocator) {}
+
+  ~WrappedInternalSliceAllocator() {
+    grpc_slice_allocator_destroy(slice_allocator_);
+  }
+
+  absl::Status Allocate(size_t size, SliceBuffer* dest,
+                        SliceAllocator::AllocateCallback cb) override {
+    // TODO(nnoble): requires the SliceBuffer definition.
+    grpc_slice_allocator_allocate(
+        slice_allocator_, size, 1, grpc_slice_allocator_intent::kReadBuffer,
+        dest->RawSliceBuffer(),
+        [](void* arg, grpc_error_handle error) {
+          auto cb = static_cast<SliceAllocator::AllocateCallback*>(arg);
+          (*cb)(grpc_error_to_absl_status(error));
+          delete cb;
+        },
+        new SliceAllocator::AllocateCallback(cb));
+    return absl::OkStatus();
+  }
+
+ private:
+  grpc_slice_allocator* slice_allocator_;
+};
+
+class WrappedInternalSliceAllocatorFactory : public SliceAllocatorFactory {
+ public:
+  explicit WrappedInternalSliceAllocatorFactory(
+      grpc_slice_allocator_factory* slice_allocator_factory)
+      : slice_allocator_factory_(slice_allocator_factory) {}
+
+  ~WrappedInternalSliceAllocatorFactory() {
+    grpc_slice_allocator_factory_destroy(slice_allocator_factory_);
+  }
+
+  std::unique_ptr<SliceAllocator> CreateSliceAllocator(
+      absl::string_view peer_name) override {
+    return absl::make_unique<WrappedInternalSliceAllocator>(
+        grpc_slice_allocator_factory_create_slice_allocator(
+            slice_allocator_factory_, peer_name));
+  };
+
+ private:
+  grpc_slice_allocator_factory* slice_allocator_factory_;
+};
+
 struct grpc_tcp_server {
-  grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener,
-                  grpc_resource_quota* rq)
+  explicit grpc_tcp_server(std::unique_ptr<EventEngine::Listener> listener)
       : refcount(1, GRPC_TRACE_FLAG_ENABLED(grpc_tcp_trace) ? "tcp" : nullptr),
-        listener(std::move(listener)),
-        resource_quota(rq) {
+        listener(std::move(listener)) {
     shutdown_starting.head = nullptr;
     shutdown_starting.tail = nullptr;
   };
   ~grpc_tcp_server() {
-    // TODO(nnoble): see if we can handle this in ~SliceAllocatorFactory
-    grpc_resource_quota_unref_internal(resource_quota);
     grpc_core::ExecCtx::RunList(DEBUG_LOCATION, &shutdown_starting);
     grpc_core::ExecCtx::Get()->Flush();
   }
@@ -59,7 +105,6 @@ struct grpc_tcp_server {
   grpc_core::Mutex mu;
   std::unique_ptr<EventEngine::Listener> listener;
   grpc_closure_list shutdown_starting ABSL_GUARDED_BY(mu);
-  grpc_resource_quota* resource_quota;
   grpc_tcp_server_cb on_accept_internal;
   void* on_accept_internal_arg;
 };
@@ -90,6 +135,7 @@ EventEngine::OnConnectCallback GrpcClosureToOnConnectCallback(
 
 /// Usage note: this method does not take ownership of any pointer arguments.
 void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
+                 grpc_slice_allocator* slice_allocator,
                  grpc_pollset_set* /* interested_parties */,
                  const grpc_channel_args* channel_args,
                  const grpc_resolved_address* addr, grpc_millis deadline) {
@@ -99,14 +145,16 @@ void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
   *endpoint = &ee_endpoint->base;
   EventEngine::OnConnectCallback ee_on_connect =
       GrpcClosureToOnConnectCallback(on_connect, endpoint);
-  SliceAllocator sa(ee_endpoint->ru);
+  auto ee_slice_allocator =
+      absl::make_unique<WrappedInternalSliceAllocator>(slice_allocator);
   EventEngine::ResolvedAddress ra(reinterpret_cast<const sockaddr*>(addr->addr),
                                   addr->len);
   absl::Time ee_deadline = grpc_core::ToAbslTime(
       grpc_millis_to_timespec(deadline, GPR_CLOCK_MONOTONIC));
   ChannelArgsEndpointConfig endpoint_config(channel_args);
   absl::Status connected = grpc_iomgr_event_engine()->Connect(
-      ee_on_connect, ra, endpoint_config, std::move(sa), ee_deadline);
+      ee_on_connect, ra, endpoint_config, std::move(ee_slice_allocator),
+      ee_deadline);
   if (!connected.ok()) {
     // EventEngine failed to start an asynchronous connect.
     grpc_endpoint_destroy(*endpoint);
@@ -116,14 +164,14 @@ void tcp_connect(grpc_closure* on_connect, grpc_endpoint** endpoint,
   }
 }
 
-grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
-                              const grpc_channel_args* args,
-                              grpc_tcp_server** server) {
+grpc_error* tcp_server_create(
+    grpc_closure* shutdown_complete, const grpc_channel_args* args,
+    grpc_slice_allocator_factory* slice_allocator_factory,
+    grpc_tcp_server** server) {
   ChannelArgsEndpointConfig endpoint_config(args);
-  grpc_resource_quota* rq = grpc_resource_quota_from_channel_args(args);
-  if (rq == nullptr) {
-    rq = grpc_resource_quota_create(nullptr);
-  }
+  auto ee_slice_allocator_factory =
+      absl::make_unique<WrappedInternalSliceAllocatorFactory>(
+          slice_allocator_factory);
   EventEngine* event_engine = grpc_iomgr_event_engine();
   absl::StatusOr<std::unique_ptr<EventEngine::Listener>> listener =
       event_engine->CreateListener(
@@ -144,11 +192,11 @@ grpc_error* tcp_server_create(grpc_closure* shutdown_complete,
             grpc_pollset_ee_broadcast_event();
           },
           GrpcClosureToCallback(shutdown_complete, GRPC_ERROR_NONE),
-          endpoint_config, SliceAllocatorFactory(rq));
+          endpoint_config, std::move(ee_slice_allocator_factory));
   if (!listener.ok()) {
     return absl_status_to_grpc_error(listener.status());
   }
-  *server = new grpc_tcp_server(std::move(*listener), rq);
+  *server = new grpc_tcp_server(std::move(*listener));
   return GRPC_ERROR_NONE;
 }
 
@@ -236,7 +284,8 @@ grpc_fd* grpc_fd_create(int /* fd */, const char* /* name */,
 
 grpc_endpoint* grpc_tcp_client_create_from_fd(
     grpc_fd* /* fd */, const grpc_channel_args* /* channel_args */,
-    const char* /* addr_str */) {
+    const char* /* addr_str */, grpc_slice_allocator* slice_allocator) {
+  grpc_slice_allocator_destroy(slice_allocator);
   return nullptr;
 }
 

data/src/core/lib/iomgr/exec_ctx.cc

@@ -131,13 +131,13 @@ grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles) {
 }
 
 namespace grpc_core {
-GPR_TLS_CLASS_DEF(ExecCtx::exec_ctx_);
-GPR_TLS_CLASS_DEF(ApplicationCallbackExecCtx::callback_exec_ctx_);
+GPR_THREAD_LOCAL(ExecCtx*) ExecCtx::exec_ctx_;
+GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*)
+ApplicationCallbackExecCtx::callback_exec_ctx_;
 
 // WARNING: for testing purposes only!
 void ExecCtx::TestOnlyGlobalInit(gpr_timespec new_val) {
   g_start_time = new_val;
-  gpr_tls_init(&exec_ctx_);
 }
 
 void ExecCtx::GlobalInit(void) {
@@ -148,7 +148,6 @@ void ExecCtx::GlobalInit(void) {
   g_start_time = gpr_now(GPR_CLOCK_MONOTONIC);
   const gpr_cycle_counter cycle_after = gpr_get_cycle_counter();
   g_start_cycle = (cycle_before + cycle_after) / 2;
-  gpr_tls_init(&exec_ctx_);
 }
 
 bool ExecCtx::Flush() {

data/src/core/lib/iomgr/exec_ctx.h

@@ -216,16 +216,12 @@ class ExecCtx {
   static void GlobalInit(void);
 
   /** Global shutdown for ExecCtx. Called by iomgr. */
-  static void GlobalShutdown(void) { gpr_tls_destroy(&exec_ctx_); }
+  static void GlobalShutdown(void) {}
 
   /** Gets pointer to current exec_ctx. */
-  static ExecCtx* Get() {
-    return reinterpret_cast<ExecCtx*>(gpr_tls_get(&exec_ctx_));
-  }
+  static ExecCtx* Get() { return exec_ctx_; }
 
-  static void Set(ExecCtx* exec_ctx) {
-    gpr_tls_set(&exec_ctx_, reinterpret_cast<intptr_t>(exec_ctx));
-  }
+  static void Set(ExecCtx* exec_ctx) { exec_ctx_ = exec_ctx; }
 
   static void Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error);
@@ -251,7 +247,7 @@ class ExecCtx {
   bool now_is_valid_ = false;
   grpc_millis now_ = 0;
 
-  GPR_TLS_CLASS_DECL(exec_ctx_);
+  static GPR_THREAD_LOCAL(ExecCtx*) exec_ctx_;
   ExecCtx* last_exec_ctx_ = Get();
 };
 
@@ -313,8 +309,7 @@ class ApplicationCallbackExecCtx {
   }
 
   ~ApplicationCallbackExecCtx() {
-    if (reinterpret_cast<ApplicationCallbackExecCtx*>(
-            gpr_tls_get(&callback_exec_ctx_)) == this) {
+    if (Get() == this) {
       while (head_ != nullptr) {
         auto* f = head_;
         head_ = f->internal_next;
@@ -323,7 +318,7 @@ class ApplicationCallbackExecCtx {
         }
         (*f->functor_run)(f, f->internal_success);
       }
-      gpr_tls_set(&callback_exec_ctx_, reinterpret_cast<intptr_t>(nullptr));
+      callback_exec_ctx_ = nullptr;
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
         grpc_core::Fork::DecExecCtxCount();
       }
@@ -335,17 +330,14 @@ class ApplicationCallbackExecCtx {
 
   uintptr_t Flags() { return flags_; }
 
-  static ApplicationCallbackExecCtx* Get() {
-    return reinterpret_cast<ApplicationCallbackExecCtx*>(
-        gpr_tls_get(&callback_exec_ctx_));
-  }
+  static ApplicationCallbackExecCtx* Get() { return callback_exec_ctx_; }
 
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
     if (Get() == nullptr) {
       if (!(GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags)) {
         grpc_core::Fork::IncExecCtxCount();
       }
-      gpr_tls_set(&callback_exec_ctx_, reinterpret_cast<intptr_t>(exec_ctx));
+      callback_exec_ctx_ = exec_ctx;
     }
   }
 
@@ -365,10 +357,10 @@ class ApplicationCallbackExecCtx {
   }
 
   /** Global initialization for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalInit(void) { gpr_tls_init(&callback_exec_ctx_); }
+  static void GlobalInit(void) {}
 
   /** Global shutdown for ApplicationCallbackExecCtx. Called by init. */
-  static void GlobalShutdown(void) { gpr_tls_destroy(&callback_exec_ctx_); }
+  static void GlobalShutdown(void) {}
 
   static bool Available() { return Get() != nullptr; }
 
@@ -376,7 +368,7 @@ class ApplicationCallbackExecCtx {
   uintptr_t flags_{0u};
   grpc_completion_queue_functor* head_{nullptr};
   grpc_completion_queue_functor* tail_{nullptr};
-  GPR_TLS_CLASS_DECL(callback_exec_ctx_);
+  static GPR_THREAD_LOCAL(ApplicationCallbackExecCtx*) callback_exec_ctx_;
 };
 }  // namespace grpc_core
 

data/src/core/lib/iomgr/executor/mpmcqueue.cc

@@ -29,7 +29,8 @@ inline void* InfLenFIFOQueue::PopFront() {
   // mutex. This function will assume that there is at least one element in the
   // queue (i.e. queue_head_->content is valid).
   void* result = queue_head_->content;
-  count_.Store(count_.Load(MemoryOrder::RELAXED) - 1, MemoryOrder::RELAXED);
+  count_.store(count_.load(std::memory_order_relaxed) - 1,
+               std::memory_order_relaxed);
 
   // Updates Stats when trace flag turned on.
   if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace)) {
@@ -40,7 +41,7 @@ inline void* InfLenFIFOQueue::PopFront() {
     stats_.max_queue_time = gpr_time_max(
         gpr_convert_clock_type(stats_.max_queue_time, GPR_TIMESPAN), wait_time);
 
-    if (count_.Load(MemoryOrder::RELAXED) == 0) {
+    if (count_.load(std::memory_order_relaxed) == 0) {
       stats_.busy_queue_time =
           gpr_time_add(stats_.busy_queue_time,
                        gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), busy_time));
@@ -57,7 +58,7 @@ inline void* InfLenFIFOQueue::PopFront() {
 
   queue_head_ = queue_head_->next;
   // Signal waiting thread
-  if (count_.Load(MemoryOrder::RELAXED) > 0) {
+  if (count_.load(std::memory_order_relaxed) > 0) {
     TopWaiter()->cv.Signal();
   }
 
@@ -92,7 +93,7 @@ InfLenFIFOQueue::InfLenFIFOQueue() {
 }
 
 InfLenFIFOQueue::~InfLenFIFOQueue() {
-  GPR_ASSERT(count_.Load(MemoryOrder::RELAXED) == 0);
+  GPR_ASSERT(count_.load(std::memory_order_relaxed) == 0);
   for (size_t i = 0; i < delete_list_count_; ++i) {
     gpr_free(delete_list_[i]);
   }
@@ -102,7 +103,7 @@ InfLenFIFOQueue::~InfLenFIFOQueue() {
 void InfLenFIFOQueue::Put(void* elem) {
   MutexLock l(&mu_);
 
-  int curr_count = count_.Load(MemoryOrder::RELAXED);
+  int curr_count = count_.load(std::memory_order_relaxed);
 
   if (queue_tail_ == queue_head_ && curr_count != 0) {
     // List is full. Expands list to double size by inserting new chunk of nodes
@@ -134,7 +135,7 @@ void InfLenFIFOQueue::Put(void* elem) {
     queue_tail_->insert_time = current_time;
   }
 
-  count_.Store(curr_count + 1, MemoryOrder::RELAXED);
+  count_.store(curr_count + 1, std::memory_order_relaxed);
   queue_tail_ = queue_tail_->next;
 
   TopWaiter()->cv.Signal();
@@ -143,7 +144,7 @@ void InfLenFIFOQueue::Put(void* elem) {
 void* InfLenFIFOQueue::Get(gpr_timespec* wait_time) {
   MutexLock l(&mu_);
 
-  if (count_.Load(MemoryOrder::RELAXED) == 0) {
+  if (count_.load(std::memory_order_relaxed) == 0) {
     gpr_timespec start_time;
     if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
         wait_time != nullptr) {
@@ -154,14 +155,14 @@ void* InfLenFIFOQueue::Get(gpr_timespec* wait_time) {
     PushWaiter(&self);
     do {
       self.cv.Wait(&mu_);
-    } while (count_.Load(MemoryOrder::RELAXED) == 0);
+    } while (count_.load(std::memory_order_relaxed) == 0);
     RemoveWaiter(&self);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_thread_pool_trace) &&
         wait_time != nullptr) {
       *wait_time = gpr_time_sub(gpr_now(GPR_CLOCK_MONOTONIC), start_time);
     }
   }
-  GPR_DEBUG_ASSERT(count_.Load(MemoryOrder::RELAXED) > 0);
+  GPR_DEBUG_ASSERT(count_.load(std::memory_order_relaxed) > 0);
   return PopFront();
 }
 

data/src/core/lib/iomgr/executor/mpmcqueue.h

@@ -21,8 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <atomic>
+
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
@@ -70,7 +71,7 @@ class InfLenFIFOQueue : public MPMCQueueInterface {
   // Returns number of elements in queue currently.
   // There might be concurrently add/remove on queue, so count might change
   // quickly.
-  int count() const override { return count_.Load(MemoryOrder::RELAXED); }
+  int count() const override { return count_.load(std::memory_order_relaxed); }
 
   struct Node {
     Node* next;  // Linking
@@ -157,7 +158,7 @@ class InfLenFIFOQueue : public MPMCQueueInterface {
 
   Node* queue_head_ = nullptr;  // Head of the queue, remove position
   Node* queue_tail_ = nullptr;  // End of queue, insert position
-  Atomic<int> count_{0};        // Number of elements in queue
+  std::atomic<int> count_{0};   // Number of elements in queue
   int num_nodes_ = 0;           // Number of nodes allocated
 
   Stats stats_;            // Stats info

data/src/core/lib/iomgr/executor/threadpool.cc

@@ -72,7 +72,7 @@ size_t ThreadPool::DefaultStackSize() {
 
 void ThreadPool::AssertHasNotBeenShutDown() {
   // For debug checking purpose, using RELAXED order is sufficient.
-  GPR_DEBUG_ASSERT(!shut_down_.Load(MemoryOrder::RELAXED));
+  GPR_DEBUG_ASSERT(!shut_down_.load(std::memory_order_relaxed));
 }
 
 ThreadPool::ThreadPool(int num_threads) : num_threads_(num_threads) {
@@ -102,7 +102,7 @@ ThreadPool::ThreadPool(int num_threads, const char* thd_name,
 
 ThreadPool::~ThreadPool() {
   // For debug checking purpose, using RELAXED order is sufficient.
-  shut_down_.Store(true, MemoryOrder::RELAXED);
+  shut_down_.store(true, std::memory_order_relaxed);
 
   for (int i = 0; i < num_threads_; ++i) {
     queue_->Put(nullptr);

data/src/core/lib/iomgr/executor/threadpool.h

@@ -134,7 +134,8 @@ class ThreadPool : public ThreadPoolInterface {
   ThreadPoolWorker** threads_ = nullptr;  // Array of worker threads
   MPMCQueueInterface* queue_ = nullptr;   // Closure queue
 
-  Atomic<bool> shut_down_{false};  // Destructor has been called if set to true
+  std::atomic<bool> shut_down_{
+      false};  // Destructor has been called if set to true
 
   void SharedThreadPoolConstructor();
   // For ThreadPool, default stack size for mobile platform is 1952K. for other

data/src/core/lib/iomgr/executor.cc

@@ -53,7 +53,7 @@
 namespace grpc_core {
 namespace {
 
-GPR_TLS_DECL(g_this_thread_state);
+static GPR_THREAD_LOCAL(ThreadState*) g_this_thread_state;
 
 Executor* executors[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)];
 
@@ -214,7 +214,7 @@ void Executor::Shutdown() { SetThreading(false); }
 
 void Executor::ThreadMain(void* arg) {
   ThreadState* ts = static_cast<ThreadState*>(arg);
-  gpr_tls_set(&g_this_thread_state, reinterpret_cast<intptr_t>(ts));
+  g_this_thread_state = ts;
 
   grpc_core::ExecCtx exec_ctx(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD);
 
@@ -248,7 +248,7 @@ void Executor::ThreadMain(void* arg) {
     subtract_depth = RunClosures(ts->name, closures);
   }
 
-  gpr_tls_set(&g_this_thread_state, reinterpret_cast<intptr_t>(nullptr));
+  g_this_thread_state = nullptr;
 }
 
 void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
@@ -283,8 +283,7 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
       return;
     }
 
-    ThreadState* ts =
-        reinterpret_cast<ThreadState*>(gpr_tls_get(&g_this_thread_state));
+    ThreadState* ts = g_this_thread_state;
     if (ts == nullptr) {
       ts = &thd_state_[GPR_HASH_POINTER(grpc_core::ExecCtx::Get(),
                                         cur_thread_count)];
@@ -465,6 +464,6 @@ void Executor::SetThreadingDefault(bool enable) {
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->SetThreading(enable);
 }
 
-void grpc_executor_global_init() { gpr_tls_init(&g_this_thread_state); }
+void grpc_executor_global_init() {}
 
 }  // namespace grpc_core

data/src/core/lib/iomgr/grpc_if_nametoindex_posix.cc

@@ -22,13 +22,13 @@
 
 #if GRPC_IF_NAMETOINDEX == 1 && defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
 
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
-
 #include <errno.h>
 #include <net/if.h>
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+
 uint32_t grpc_if_nametoindex(char* name) {
   uint32_t out = if_nametoindex(name);
   if (out == 0) {

data/src/core/lib/iomgr/grpc_if_nametoindex_unsupported.cc

@@ -22,10 +22,10 @@
 
 #if GRPC_IF_NAMETOINDEX == 0 || !defined(GRPC_POSIX_SOCKET_IF_NAMETOINDEX)
 
-#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
-
 #include <grpc/support/log.h>
 
+#include "src/core/lib/iomgr/grpc_if_nametoindex.h"
+
 uint32_t grpc_if_nametoindex(char* name) {
   gpr_log(GPR_DEBUG,
           "Not attempting to convert interface name %s to index for current "

data/src/core/lib/iomgr/internal_errqueue.cc

@@ -18,10 +18,11 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/internal_errqueue.h"
 
 #include <grpc/impl/codegen/log.h>
-#include "src/core/lib/iomgr/internal_errqueue.h"
+
+#include "src/core/lib/iomgr/port.h"
 
 #ifdef GRPC_POSIX_SOCKET_TCP
 

data/src/core/lib/iomgr/iocp_windows.cc

@@ -23,6 +23,7 @@
 #ifdef GRPC_WINSOCK_SOCKET
 
 #include <winsock2.h>
+
 #include <limits>
 
 #include <grpc/support/alloc.h>

data/src/core/lib/iomgr/iomgr.h

@@ -21,11 +21,11 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdlib.h>
+
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/port.h"
 
-#include <stdlib.h>
-
 /** Initializes the iomgr. */
 void grpc_iomgr_init();
 

data/src/core/lib/iomgr/iomgr_custom.cc

@@ -18,16 +18,16 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/iomgr/port.h"
+#include "src/core/lib/iomgr/iomgr_custom.h"
 
 #include <grpc/support/thd_id.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/executor.h"
-#include "src/core/lib/iomgr/iomgr_custom.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/pollset_custom.h"
 #include "src/core/lib/iomgr/pollset_set_custom.h"
+#include "src/core/lib/iomgr/port.h"
 #include "src/core/lib/iomgr/resolve_address_custom.h"
 
 gpr_thd_id g_init_thread;

data/src/core/lib/iomgr/iomgr_custom.h

@@ -21,13 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/thd_id.h>
+
 #include "src/core/lib/iomgr/pollset_custom.h"
 #include "src/core/lib/iomgr/resolve_address_custom.h"
 #include "src/core/lib/iomgr/tcp_custom.h"
 #include "src/core/lib/iomgr/timer_custom.h"
 
-#include <grpc/support/thd_id.h>
-
 /* The thread ID of the thread on which grpc was initialized. Used to verify
  * that all calls into the custom iomgr are made on that same thread */
 extern gpr_thd_id g_init_thread;