grpc 1.28.0 → 1.42.0

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

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <limits>
+
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/cpu.h>
@@ -56,8 +58,8 @@ typedef struct grpc_combiner grpc_combiner;
 #define GRPC_APP_CALLBACK_EXEC_CTX_FLAG_IS_INTERNAL_THREAD 1
 
 gpr_timespec grpc_millis_to_timespec(grpc_millis millis, gpr_clock_type clock);
-grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec timespec);
-grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec timespec);
+grpc_millis grpc_timespec_to_millis_round_down(gpr_timespec ts);
+grpc_millis grpc_timespec_to_millis_round_up(gpr_timespec ts);
 grpc_millis grpc_cycle_counter_to_millis_round_down(gpr_cycle_counter cycles);
 grpc_millis grpc_cycle_counter_to_millis_round_up(gpr_cycle_counter cycles);
 
@@ -111,7 +113,7 @@ class ExecCtx {
   }
 
   /** Parameterised Constructor */
-  ExecCtx(uintptr_t fl) : flags_(fl) {
+  explicit ExecCtx(uintptr_t fl) : flags_(fl) {
     if (!(GRPC_EXEC_CTX_FLAG_IS_INTERNAL_THREAD & flags_)) {
       grpc_core::Fork::IncExecCtxCount();
     }
@@ -132,7 +134,12 @@ class ExecCtx {
   ExecCtx(const ExecCtx&) = delete;
   ExecCtx& operator=(const ExecCtx&) = delete;
 
-  unsigned starting_cpu() const { return starting_cpu_; }
+  unsigned starting_cpu() {
+    if (starting_cpu_ == std::numeric_limits<unsigned>::max()) {
+      starting_cpu_ = gpr_cpu_current_cpu();
+    }
+    return starting_cpu_;
+  }
 
   struct CombinerData {
     /* currently active combiner: updated only via combiner.c */
@@ -209,19 +216,15 @@ 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* error);
+                  grpc_error_handle error);
 
   static void RunList(const DebugLocation& location, grpc_closure_list* list);
 
@@ -239,12 +242,12 @@ class ExecCtx {
   CombinerData combiner_data_ = {nullptr, nullptr};
   uintptr_t flags_;
 
-  unsigned starting_cpu_ = gpr_cpu_current_cpu();
+  unsigned starting_cpu_ = std::numeric_limits<unsigned>::max();
 
   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();
 };
 
@@ -301,11 +304,12 @@ class ApplicationCallbackExecCtx {
   ApplicationCallbackExecCtx() { Set(this, flags_); }
 
   /** Parameterised Constructor */
-  ApplicationCallbackExecCtx(uintptr_t fl) : flags_(fl) { Set(this, flags_); }
+  explicit ApplicationCallbackExecCtx(uintptr_t fl) : flags_(fl) {
+    Set(this, flags_);
+  }
 
   ~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;
@@ -314,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();
       }
@@ -324,23 +328,24 @@ class ApplicationCallbackExecCtx {
     }
   }
 
+  uintptr_t Flags() { return flags_; }
+
+  static ApplicationCallbackExecCtx* Get() { return callback_exec_ctx_; }
+
   static void Set(ApplicationCallbackExecCtx* exec_ctx, uintptr_t flags) {
-    if (reinterpret_cast<ApplicationCallbackExecCtx*>(
-            gpr_tls_get(&callback_exec_ctx_)) == nullptr) {
+    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;
     }
   }
 
-  static void Enqueue(grpc_experimental_completion_queue_functor* functor,
-                      int is_success) {
+  static void Enqueue(grpc_completion_queue_functor* functor, int is_success) {
     functor->internal_success = is_success;
     functor->internal_next = nullptr;
 
-    auto* ctx = reinterpret_cast<ApplicationCallbackExecCtx*>(
-        gpr_tls_get(&callback_exec_ctx_));
+    ApplicationCallbackExecCtx* ctx = Get();
 
     if (ctx->head_ == nullptr) {
       ctx->head_ = functor;
@@ -352,16 +357,18 @@ 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; }
 
  private:
   uintptr_t flags_{0u};
-  grpc_experimental_completion_queue_functor* head_{nullptr};
-  grpc_experimental_completion_queue_functor* tail_{nullptr};
-  GPR_TLS_CLASS_DECL(callback_exec_ctx_);
+  grpc_completion_queue_functor* head_{nullptr};
+  grpc_completion_queue_functor* tail_{nullptr};
+  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();
   }
 
@@ -66,7 +67,7 @@ inline void* InfLenFIFOQueue::PopFront() {
 
 InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
   num_nodes_ = num_nodes_ + num;
-  Node* new_chunk = static_cast<Node*>(gpr_zalloc(sizeof(Node) * num));
+  Node* new_chunk = new Node[num];
   new_chunk[0].next = &new_chunk[1];
   new_chunk[num - 1].prev = &new_chunk[num - 2];
   for (int i = 1; i < num - 1; ++i) {
@@ -78,8 +79,7 @@ InfLenFIFOQueue::Node* InfLenFIFOQueue::AllocateNodes(int num) {
 
 InfLenFIFOQueue::InfLenFIFOQueue() {
   delete_list_size_ = kDeleteListInitSize;
-  delete_list_ =
-      static_cast<Node**>(gpr_zalloc(sizeof(Node*) * delete_list_size_));
+  delete_list_ = new Node*[delete_list_size_];
 
   Node* new_chunk = AllocateNodes(kQueueInitNumNodes);
   delete_list_[delete_list_count_++] = new_chunk;
@@ -92,17 +92,17 @@ 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]);
+    delete[] delete_list_[i];
   }
-  gpr_free(delete_list_);
+  delete[] delete_list_;
 }
 
 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
@@ -111,8 +111,7 @@ void InfLenFIFOQueue::Put(void* elem) {
     // Expands delete list on full.
     if (delete_list_count_ == delete_list_size_) {
       delete_list_size_ = delete_list_size_ * 2;
-      delete_list_ = static_cast<Node**>(
-          gpr_realloc(delete_list_, sizeof(Node*) * delete_list_size_));
+      delete_list_ = new Node*[delete_list_size_];
     }
     new_chunk[0].prev = queue_tail_->prev;
     new_chunk[curr_count - 1].next = queue_head_;
@@ -134,7 +133,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 +142,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 +153,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 {
@@ -42,7 +43,7 @@ class MPMCQueueInterface {
   // Removes the oldest element from the queue and return it.
   // This might cause to block on empty queue depending on implementation.
   // Optional argument for collecting stats purpose.
-  virtual void* Get(gpr_timespec* wait_time = nullptr) = 0;
+  virtual void* Get(gpr_timespec* wait_time) = 0;
 
   // Returns number of elements in the queue currently
   virtual int count() const = 0;
@@ -55,33 +56,28 @@ class InfLenFIFOQueue : public MPMCQueueInterface {
 
   // Releases all resources held by the queue. The queue must be empty, and no
   // one waits on conditional variables.
-  ~InfLenFIFOQueue();
+  ~InfLenFIFOQueue() override;
 
   // Puts elem into queue immediately at the end of queue. Since the queue has
   // infinite length, this routine will never block and should never fail.
-  void Put(void* elem);
+  void Put(void* elem) override;
 
   // Removes the oldest element from the queue and returns it.
   // This routine will cause the thread to block if queue is currently empty.
   // Argument wait_time should be passed in when trace flag turning on (for
   // collecting stats info purpose.)
-  void* Get(gpr_timespec* wait_time = nullptr);
+  void* Get(gpr_timespec* wait_time) override;
 
   // Returns number of elements in queue currently.
   // There might be concurrently add/remove on queue, so count might change
   // quickly.
-  int count() const { return count_.Load(MemoryOrder::RELAXED); }
+  int count() const override { return count_.load(std::memory_order_relaxed); }
 
   struct Node {
-    Node* next;  // Linking
-    Node* prev;
-    void* content;             // Points to actual element
+    Node* next = nullptr;  // Linking
+    Node* prev = nullptr;
+    void* content = nullptr;   // Points to actual element
     gpr_timespec insert_time;  // Time for stats
-
-    Node() {
-      next = prev = nullptr;
-      content = nullptr;
-    }
   };
 
   // For test purpose only. Returns number of nodes allocated in queue.
@@ -157,7 +153,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

@@ -41,8 +41,7 @@ void ThreadPoolWorker::Run() {
       break;
     }
     // Runs closure
-    auto* closure =
-        static_cast<grpc_experimental_completion_queue_functor*>(elem);
+    auto* closure = static_cast<grpc_completion_queue_functor*>(elem);
     closure->functor_run(closure, closure->internal_success);
   }
 }
@@ -73,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) {
@@ -103,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);
@@ -120,7 +119,7 @@ ThreadPool::~ThreadPool() {
   delete queue_;
 }
 
-void ThreadPool::Add(grpc_experimental_completion_queue_functor* closure) {
+void ThreadPool::Add(grpc_completion_queue_functor* closure) {
   AssertHasNotBeenShutDown();
   queue_->Put(static_cast<void*>(closure));
 }

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

@@ -43,7 +43,7 @@ class ThreadPoolInterface {
   // current thread to be blocked (in case of unable to schedule).
   // Closure should contain a function pointer and arguments it will take, more
   // details for closure struct at /grpc/include/grpc/impl/codegen/grpc_types.h
-  virtual void Add(grpc_experimental_completion_queue_functor* closure) = 0;
+  virtual void Add(grpc_completion_queue_functor* closure) = 0;
 
   // Returns the current number of pending closures
   virtual int num_pending_closures() const = 0;
@@ -65,9 +65,9 @@ class ThreadPoolWorker {
   ThreadPoolWorker(const char* thd_name, MPMCQueueInterface* queue,
                    Thread::Options& options, int index)
       : queue_(queue), thd_name_(thd_name), index_(index) {
-    thd_ = Thread(thd_name,
-                  [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
-                  this, nullptr, options);
+    thd_ = Thread(
+        thd_name, [](void* th) { static_cast<ThreadPoolWorker*>(th)->Run(); },
+        this, nullptr, options);
   }
 
   ~ThreadPoolWorker() {}
@@ -99,7 +99,7 @@ class ThreadPool : public ThreadPoolInterface {
   // Creates a thread pool with size of "num_threads", with default thread name
   // "ThreadPoolWorker" and all thread options set to default. If the given size
   // is 0 or less, there will be 1 worker thread created inside pool.
-  ThreadPool(int num_threads);
+  explicit ThreadPool(int num_threads);
 
   // Same as ThreadPool(int num_threads) constructor, except
   // that it also sets "thd_name" as the name of all threads in the thread pool.
@@ -120,7 +120,7 @@ class ThreadPool : public ThreadPoolInterface {
 
   // Adds given closure into pending queue immediately. Since closure queue has
   // infinite length, this routine will not block.
-  void Add(grpc_experimental_completion_queue_functor* closure) override;
+  void Add(grpc_completion_queue_functor* closure) override;
 
   int num_pending_closures() const override;
   int pool_capacity() const override;
@@ -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

@@ -27,12 +27,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/debug/stats.h"
 #include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/core/lib/iomgr/iomgr.h"
+#include "src/core/lib/iomgr/iomgr_internal.h"
 
 #define MAX_DEPTH 2
 
@@ -53,31 +52,31 @@
 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)];
 
-void default_enqueue_short(grpc_closure* closure, grpc_error* error) {
+void default_enqueue_short(grpc_closure* closure, grpc_error_handle error) {
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Enqueue(
       closure, error, true /* is_short */);
 }
 
-void default_enqueue_long(grpc_closure* closure, grpc_error* error) {
+void default_enqueue_long(grpc_closure* closure, grpc_error_handle error) {
   executors[static_cast<size_t>(ExecutorType::DEFAULT)]->Enqueue(
       closure, error, false /* is_short */);
 }
 
-void resolver_enqueue_short(grpc_closure* closure, grpc_error* error) {
+void resolver_enqueue_short(grpc_closure* closure, grpc_error_handle error) {
   executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Enqueue(
       closure, error, true /* is_short */);
 }
 
-void resolver_enqueue_long(grpc_closure* closure, grpc_error* error) {
+void resolver_enqueue_long(grpc_closure* closure, grpc_error_handle error) {
   executors[static_cast<size_t>(ExecutorType::RESOLVER)]->Enqueue(
       closure, error, false /* is_short */);
 }
 
-using EnqueueFunc = void (*)(grpc_closure* closure, grpc_error* error);
+using EnqueueFunc = void (*)(grpc_closure* closure, grpc_error_handle error);
 
 const EnqueueFunc
     executor_enqueue_fns_[static_cast<size_t>(ExecutorType::NUM_EXECUTORS)]
@@ -92,7 +91,7 @@ TraceFlag executor_trace(false, "executor");
 Executor::Executor(const char* name) : name_(name) {
   adding_thread_lock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   gpr_atm_rel_store(&num_threads_, 0);
-  max_threads_ = GPR_MAX(1, 2 * gpr_cpu_num_cores());
+  max_threads_ = std::max(1u, 2 * gpr_cpu_num_cores());
 }
 
 void Executor::Init() { SetThreading(true); }
@@ -115,7 +114,7 @@ size_t Executor::RunClosures(const char* executor_name,
   grpc_closure* c = list.head;
   while (c != nullptr) {
     grpc_closure* next = c->next_data.next;
-    grpc_error* error = c->error_data.error;
+    grpc_error_handle error = c->error_data.error;
 #ifndef NDEBUG
     EXECUTOR_TRACE("(%s) run %p [created by %s:%d]", executor_name, c,
                    c->file_created, c->line_created);
@@ -204,7 +203,7 @@ void Executor::SetThreading(bool threading) {
     // an application.
     // TODO(guantaol): create another method to finish all the pending closures
     // registered in the background poller by grpc_core::Executor.
-    grpc_iomgr_shutdown_background_closure();
+    grpc_iomgr_platform_shutdown_background_closure();
   }
 
   EXECUTOR_TRACE("(%s) SetThreading(%d) done", name_, threading);
@@ -214,7 +213,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);
 
@@ -237,7 +236,6 @@ void Executor::ThreadMain(void* arg) {
       break;
     }
 
-    GRPC_STATS_INC_EXECUTOR_QUEUE_DRAINED();
     grpc_closure_list closures = ts->elems;
     ts->elems = GRPC_CLOSURE_LIST_INIT;
     gpr_mu_unlock(&ts->mu);
@@ -248,17 +246,12 @@ 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* error,
+void Executor::Enqueue(grpc_closure* closure, grpc_error_handle error,
                        bool is_short) {
   bool retry_push;
-  if (is_short) {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_SHORT_ITEMS();
-  } else {
-    GRPC_STATS_INC_EXECUTOR_SCHEDULED_LONG_ITEMS();
-  }
 
   do {
     retry_push = false;
@@ -279,16 +272,14 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error* error,
       return;
     }
 
-    if (grpc_iomgr_add_closure_to_background_poller(closure, error)) {
+    if (grpc_iomgr_platform_add_closure_to_background_poller(closure, error)) {
       return;
     }
 
-    ThreadState* ts = (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)];
-    } else {
-      GRPC_STATS_INC_EXECUTOR_SCHEDULED_TO_SELF();
+      ts = &thd_state_[grpc_core::HashPointer(grpc_core::ExecCtx::Get(),
+                                              cur_thread_count)];
     }
 
     ThreadState* orig_ts = ts;
@@ -341,7 +332,6 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error* error,
       // - Note that gpr_cv_signal() won't immediately wakeup the thread. That
       //   happens after we release the mutex &ts->mu a few lines below
       if (grpc_closure_list_empty(ts->elems) && !ts->shutdown) {
-        GRPC_STATS_INC_EXECUTOR_WAKEUP_INITIATED();
         gpr_cv_signal(&ts->cv);
       }
 
@@ -372,10 +362,6 @@ void Executor::Enqueue(grpc_closure* closure, grpc_error* error,
       }
       gpr_spinlock_unlock(&adding_thread_lock_);
     }
-
-    if (retry_push) {
-      GRPC_STATS_INC_EXECUTOR_PUSH_RETRIES();
-    }
   } while (retry_push);
 }
 
@@ -403,7 +389,7 @@ void Executor::InitAll() {
   EXECUTOR_TRACE0("Executor::InitAll() done");
 }
 
-void Executor::Run(grpc_closure* closure, grpc_error* error,
+void Executor::Run(grpc_closure* closure, grpc_error_handle error,
                    ExecutorType executor_type, ExecutorJobType job_type) {
   executor_enqueue_fns_[static_cast<size_t>(executor_type)]
                        [static_cast<size_t>(job_type)](closure, error);
@@ -464,6 +450,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/executor.h

@@ -54,7 +54,7 @@ enum class ExecutorJobType {
 
 class Executor {
  public:
-  Executor(const char* executor_name);
+  explicit Executor(const char* executor_name);
 
   void Init();
 
@@ -70,7 +70,7 @@ class Executor {
 
   /** Enqueue the closure onto the executor. is_short is true if the closure is
    * a short job (i.e expected to not block and complete quickly) */
-  void Enqueue(grpc_closure* closure, grpc_error* error, bool is_short);
+  void Enqueue(grpc_closure* closure, grpc_error_handle error, bool is_short);
 
   // TODO(sreek): Currently we have two executors (available globally): The
   // default executor and the resolver executor.
@@ -83,7 +83,7 @@ class Executor {
   // Initialize ALL the executors
   static void InitAll();
 
-  static void Run(grpc_closure* closure, grpc_error* error,
+  static void Run(grpc_closure* closure, grpc_error_handle error,
                   ExecutorType executor_type = ExecutorType::DEFAULT,
                   ExecutorJobType job_type = ExecutorJobType::SHORT);
 

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