grpc 1.49.1-x86_64-linux → 1.50.0-x86_64-linux

data/src/core/{ext/filters/client_channel → lib/handshaker}/proxy_mapper_registry.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 
 #include <algorithm>
 #include <memory>
@@ -29,46 +29,25 @@
 
 namespace grpc_core {
 
-namespace {
-
-using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
-ProxyMapperList* g_proxy_mapper_list;
-
-}  // namespace
-
-void ProxyMapperRegistry::Init() {
-  if (g_proxy_mapper_list == nullptr) {
-    g_proxy_mapper_list = new ProxyMapperList();
-  }
-}
-
-void ProxyMapperRegistry::Shutdown() {
-  delete g_proxy_mapper_list;
-  // Clean up in case we re-initialze later.
-  // TODO(roth): This should ideally live in Init().  However, if we did this
-  // there, then we would do it AFTER we start registering proxy mappers from
-  // third-party plugins, so they'd never show up (and would leak memory).
-  // We probably need some sort of dependency system for plugins to fix
-  // this.
-  g_proxy_mapper_list = nullptr;
-}
-
-void ProxyMapperRegistry::Register(
+void ProxyMapperRegistry::Builder::Register(
     bool at_start, std::unique_ptr<ProxyMapperInterface> mapper) {
-  Init();
   if (at_start) {
-    g_proxy_mapper_list->insert(g_proxy_mapper_list->begin(),
-                                std::move(mapper));
+    mappers_.insert(mappers_.begin(), std::move(mapper));
   } else {
-    g_proxy_mapper_list->emplace_back(std::move(mapper));
+    mappers_.emplace_back(std::move(mapper));
   }
 }
 
+ProxyMapperRegistry ProxyMapperRegistry::Builder::Build() {
+  ProxyMapperRegistry registry;
+  registry.mappers_ = std::move(mappers_);
+  return registry;
+}
+
 absl::optional<std::string> ProxyMapperRegistry::MapName(
-    absl::string_view server_uri, ChannelArgs* args) {
-  Init();
+    absl::string_view server_uri, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
-  for (const auto& mapper : *g_proxy_mapper_list) {
+  for (const auto& mapper : mappers_) {
     *args = args_backup;
     auto r = mapper->MapName(server_uri, args);
     if (r.has_value()) return r;
@@ -78,10 +57,9 @@ absl::optional<std::string> ProxyMapperRegistry::MapName(
 }
 
 absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
-    const grpc_resolved_address& address, ChannelArgs* args) {
-  Init();
+    const grpc_resolved_address& address, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
-  for (const auto& mapper : *g_proxy_mapper_list) {
+  for (const auto& mapper : mappers_) {
     *args = args_backup;
     auto r = mapper->MapAddress(address, args);
     if (r.has_value()) return r;

data/src/core/lib/handshaker/proxy_mapper_registry.h

@@ -0,0 +1,75 @@
+/*
+ *
+ * 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_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_core {
+
+class ProxyMapperRegistry {
+  using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
+
+ public:
+  class Builder {
+   public:
+    /// Registers a new proxy mapper.
+    /// If \a at_start is true, the new mapper will be at the beginning of
+    /// the list.  Otherwise, it will be added to the end.
+    void Register(bool at_start, std::unique_ptr<ProxyMapperInterface> mapper);
+
+    ProxyMapperRegistry Build();
+
+   private:
+    ProxyMapperList mappers_;
+  };
+
+  ~ProxyMapperRegistry() = default;
+  ProxyMapperRegistry(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry& operator=(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry(ProxyMapperRegistry&&) = default;
+  ProxyMapperRegistry& operator=(ProxyMapperRegistry&&) = default;
+
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) const;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& address, ChannelArgs* args) const;
+
+ private:
+  ProxyMapperRegistry() = default;
+
+  ProxyMapperList mappers_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H */

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

@@ -25,7 +25,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/profiling/timers.h"
 
 namespace grpc_core {
 
@@ -113,7 +112,6 @@ void CallCombiner::ScheduleClosure(grpc_closure* closure,
 
 void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
                          DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Start", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO,
             "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
@@ -127,10 +125,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
-  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS();
   if (prev_size == 0) {
-    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("call_combiner_initiate", 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
       gpr_log(GPR_INFO, "  EXECUTING IMMEDIATELY");
     }
@@ -148,7 +143,6 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Stop", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO, "==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
             this DEBUG_FMT_ARGS, reason);
@@ -192,7 +186,6 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
 }
 
 void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
-  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL();
   while (true) {
     // Decode original state.
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
@@ -235,7 +228,6 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 }
 
 void CallCombiner::Cancel(grpc_error_handle error) {
-  GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
   intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
   gpr_atm new_state = kErrorBit | status_ptr;
   while (true) {

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

@@ -31,7 +31,6 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
 struct grpc_closure;
 typedef struct grpc_closure grpc_closure;

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

@@ -35,6 +35,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
@@ -60,17 +61,20 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   std::string final_name = absl::StrCat(name, ":client");
-  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
-                                          .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args)
-                                          .ToC()
-                                          .release();
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
-                             new_args, "socketpair-server");
+  auto new_args = grpc_core::CoreConfiguration::Get()
+                      .channel_args_preconditioning()
+                      .PreconditionChannelArgs(args);
+  p.client = grpc_tcp_create(
+      grpc_fd_create(sv[1], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-server");
   final_name = absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
-                             new_args, "socketpair-client");
-  grpc_channel_args_destroy(new_args);
+  p.server = grpc_tcp_create(
+      grpc_fd_create(sv[0], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-client");
   return p;
 }
 

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

@@ -77,9 +77,9 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                             channel_args, "endpoint:server");
+                             "endpoint:server");
   p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                             channel_args, "endpoint:client");
+                             "endpoint:client");
   return p;
 }
 

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

@@ -57,7 +57,6 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/lockfree_event.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/profiling/timers.h"
 
 static grpc_wakeup_fd global_wakeup_fd;
 
@@ -586,25 +585,20 @@ static void pollset_destroy(grpc_pollset* pollset) {
 }
 
 static grpc_error_handle pollset_kick_all(grpc_pollset* pollset) {
-  GPR_TIMER_SCOPE("pollset_kick_all", 0);
   grpc_error_handle error = GRPC_ERROR_NONE;
   if (pollset->root_worker != nullptr) {
     grpc_pollset_worker* worker = pollset->root_worker;
     do {
-      GRPC_STATS_INC_POLLSET_KICK();
       switch (worker->state) {
         case KICKED:
-          GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
           break;
         case UNKICKED:
           SET_KICK_STATE(worker, KICKED);
           if (worker->initialized_cv) {
-            GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
             gpr_cv_signal(&worker->cv);
           }
           break;
         case DESIGNATED_POLLER:
-          GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
           SET_KICK_STATE(worker, KICKED);
           append_error(&error, grpc_wakeup_fd_wakeup(&global_wakeup_fd),
                        "pollset_kick_all");
@@ -622,7 +616,6 @@ static grpc_error_handle pollset_kick_all(grpc_pollset* pollset) {
 static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
   if (pollset->shutdown_closure != nullptr && pollset->root_worker == nullptr &&
       pollset->begin_refs == 0) {
-    GPR_TIMER_MARK("pollset_finish_shutdown", 0);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, pollset->shutdown_closure,
                             GRPC_ERROR_NONE);
     pollset->shutdown_closure = nullptr;
@@ -630,7 +623,6 @@ static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
 }
 
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  GPR_TIMER_SCOPE("pollset_shutdown", 0);
   GPR_ASSERT(pollset->shutdown_closure == nullptr);
   GPR_ASSERT(!pollset->shutting_down);
   pollset->shutdown_closure = closure;
@@ -641,7 +633,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 
 static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
   if (millis == grpc_core::Timestamp::InfFuture()) return -1;
-  int64_t delta = (millis - grpc_core::ExecCtx::Get()->Now()).millis();
+  int64_t delta = (millis - grpc_core::Timestamp::Now()).millis();
   if (delta > INT_MAX) {
     return INT_MAX;
   } else if (delta < 0) {
@@ -660,8 +652,6 @@ static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
    called by g_active_poller thread. So there is no need for synchronization
    when accessing fields in g_epoll_set */
 static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {
-  GPR_TIMER_SCOPE("process_epoll_events", 0);
-
   static const char* err_desc = "process_events";
   grpc_error_handle error = GRPC_ERROR_NONE;
   long num_events = gpr_atm_acq_load(&g_epoll_set.num_events);
@@ -713,15 +703,12 @@ static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {
    no need for any synchronization when accesing fields in g_epoll_set */
 static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
                                        grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("do_epoll_wait", 0);
-
   int r;
   int timeout = poll_deadline_to_millis_timeout(deadline);
   if (timeout != 0) {
     GRPC_SCHEDULING_START_BLOCKING_REGION;
   }
   do {
-    GRPC_STATS_INC_SYSCALL_POLL();
     r = epoll_wait(g_epoll_set.epfd, g_epoll_set.events, MAX_EPOLL_EVENTS,
                    timeout);
   } while (r < 0 && errno == EINTR);
@@ -731,8 +718,6 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
 
   if (r < 0) return GRPC_OS_ERROR(errno, "epoll_wait");
 
-  GRPC_STATS_INC_POLL_EVENTS_RETURNED(r);
-
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_INFO, "ps: %p poll got %d events", ps, r);
   }
@@ -746,7 +731,6 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
 static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                          grpc_pollset_worker** worker_hdl,
                          grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("begin_worker", 0);
   if (worker_hdl != nullptr) *worker_hdl = worker;
   worker->initialized_cv = false;
   SET_KICK_STATE(worker, UNKICKED);
@@ -869,7 +853,6 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
 
 static bool check_neighborhood_for_available_poller(
     pollset_neighborhood* neighborhood) {
-  GPR_TIMER_SCOPE("check_neighborhood_for_available_poller", 0);
   bool found_worker = false;
   do {
     grpc_pollset* inspect = neighborhood->active_root;
@@ -892,8 +875,6 @@ static bool check_neighborhood_for_available_poller(
               }
               SET_KICK_STATE(inspect_worker, DESIGNATED_POLLER);
               if (inspect_worker->initialized_cv) {
-                GPR_TIMER_MARK("signal worker", 0);
-                GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
                 gpr_cv_signal(&inspect_worker->cv);
               }
             } else {
@@ -934,7 +915,6 @@ static bool check_neighborhood_for_available_poller(
 
 static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                        grpc_pollset_worker** worker_hdl) {
-  GPR_TIMER_SCOPE("end_worker", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_INFO, "PS:%p END_WORKER:%p", pollset, worker);
   }
@@ -952,7 +932,6 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
       GPR_ASSERT(worker->next->initialized_cv);
       gpr_atm_no_barrier_store(&g_active_poller, (gpr_atm)worker->next);
       SET_KICK_STATE(worker->next, DESIGNATED_POLLER);
-      GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
       gpr_cv_signal(&worker->next->cv);
       if (grpc_core::ExecCtx::Get()->HasWork()) {
         gpr_mu_unlock(&pollset->mu);
@@ -1014,7 +993,6 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
 static grpc_error_handle pollset_work(grpc_pollset* ps,
                                       grpc_pollset_worker** worker_hdl,
                                       grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   grpc_error_handle error = GRPC_ERROR_NONE;
   static const char* err_desc = "pollset_work";
@@ -1064,8 +1042,6 @@ static grpc_error_handle pollset_work(grpc_pollset* ps,
 
 static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                                       grpc_pollset_worker* specific_worker) {
-  GPR_TIMER_SCOPE("pollset_kick", 0);
-  GRPC_STATS_INC_POLLSET_KICK();
   grpc_error_handle ret_err = GRPC_ERROR_NONE;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     std::vector<std::string> log;
@@ -1091,7 +1067,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     if (g_current_thread_pollset != pollset) {
       grpc_pollset_worker* root_worker = pollset->root_worker;
       if (root_worker == nullptr) {
-        GRPC_STATS_INC_POLLSET_KICKED_WITHOUT_POLLER();
         pollset->kicked_without_poller = true;
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked_without_poller");
@@ -1100,14 +1075,12 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       }
       grpc_pollset_worker* next_worker = root_worker->next;
       if (root_worker->state == KICKED) {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. already kicked %p", root_worker);
         }
         SET_KICK_STATE(root_worker, KICKED);
         goto done;
       } else if (next_worker->state == KICKED) {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. already kicked %p", next_worker);
         }
@@ -1118,7 +1091,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                  root_worker ==
                      reinterpret_cast<grpc_pollset_worker*>(
                          gpr_atm_no_barrier_load(&g_active_poller))) {
-        GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked %p", root_worker);
         }
@@ -1126,7 +1098,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
         goto done;
       } else if (next_worker->state == UNKICKED) {
-        GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked %p", next_worker);
         }
@@ -1144,12 +1115,10 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           }
           SET_KICK_STATE(root_worker, KICKED);
           if (root_worker->initialized_cv) {
-            GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
             gpr_cv_signal(&root_worker->cv);
           }
           goto done;
         } else {
-          GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
           if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
             gpr_log(GPR_INFO, " .. non-root poller %p (root=%p)", next_worker,
                     root_worker);
@@ -1159,13 +1128,11 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           goto done;
         }
       } else {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         GPR_ASSERT(next_worker->state == KICKED);
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
       }
     } else {
-      GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD();
       if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
         gpr_log(GPR_INFO, " .. kicked while waking up");
       }
@@ -1181,7 +1148,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     }
     goto done;
   } else if (g_current_thread_worker == specific_worker) {
-    GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. mark %p kicked", specific_worker);
     }
@@ -1190,7 +1156,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   } else if (specific_worker ==
              reinterpret_cast<grpc_pollset_worker*>(
                  gpr_atm_no_barrier_load(&g_active_poller))) {
-    GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick active poller");
     }
@@ -1198,7 +1163,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
     goto done;
   } else if (specific_worker->initialized_cv) {
-    GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick waiting worker");
     }
@@ -1206,7 +1170,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     gpr_cv_signal(&specific_worker->cv);
     goto done;
   } else {
-    GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick non-waiting worker");
     }

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

@@ -48,7 +48,6 @@
 #include "src/core/lib/iomgr/ev_poll_posix.h"
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/profiling/timers.h"
 
 #define GRPC_POLLSET_KICK_BROADCAST ((grpc_pollset_worker*)1)
 
@@ -769,14 +768,11 @@ static void kick_append_error(grpc_error_handle* composite,
 static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
                                           grpc_pollset_worker* specific_worker,
                                           uint32_t flags) {
-  GPR_TIMER_SCOPE("pollset_kick_ext", 0);
   grpc_error_handle error = GRPC_ERROR_NONE;
-  GRPC_STATS_INC_POLLSET_KICK();
 
   /* pollset->mu already held */
   if (specific_worker != nullptr) {
     if (specific_worker == GRPC_POLLSET_KICK_BROADCAST) {
-      GPR_TIMER_SCOPE("pollset_kick_ext.broadcast", 0);
       GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
       for (specific_worker = p->root_worker.next;
            specific_worker != &p->root_worker;
@@ -786,7 +782,6 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
       }
       p->kicked_without_pollers = true;
     } else if (g_current_thread_worker != specific_worker) {
-      GPR_TIMER_MARK("different_thread_worker", 0);
       if ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) != 0) {
         specific_worker->reevaluate_polling_on_wakeup = true;
       }
@@ -794,7 +789,6 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
       kick_append_error(&error,
                         grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
     } else if ((flags & GRPC_POLLSET_CAN_KICK_SELF) != 0) {
-      GPR_TIMER_MARK("kick_yoself", 0);
       if ((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) != 0) {
         specific_worker->reevaluate_polling_on_wakeup = true;
       }
@@ -804,11 +798,9 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
     }
   } else if (g_current_thread_poller != p) {
     GPR_ASSERT((flags & GRPC_POLLSET_REEVALUATE_POLLING_ON_WAKEUP) == 0);
-    GPR_TIMER_MARK("kick_anonymous", 0);
     specific_worker = pop_front_worker(p);
     if (specific_worker != nullptr) {
       if (g_current_thread_worker == specific_worker) {
-        GPR_TIMER_MARK("kick_anonymous_not_self", 0);
         push_back_worker(p, specific_worker);
         specific_worker = pop_front_worker(p);
         if ((flags & GRPC_POLLSET_CAN_KICK_SELF) == 0 &&
@@ -818,13 +810,11 @@ static grpc_error_handle pollset_kick_ext(grpc_pollset* p,
         }
       }
       if (specific_worker != nullptr) {
-        GPR_TIMER_MARK("finally_kick", 0);
         push_back_worker(p, specific_worker);
         kick_append_error(
             &error, grpc_wakeup_fd_wakeup(&specific_worker->wakeup_fd->fd));
       }
     } else {
-      GPR_TIMER_MARK("kicked_no_pollers", 0);
       p->kicked_without_pollers = true;
     }
   }
@@ -914,7 +904,6 @@ static void work_combine_error(grpc_error_handle* composite,
 static grpc_error_handle pollset_work(grpc_pollset* pollset,
                                       grpc_pollset_worker** worker_hdl,
                                       grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   if (worker_hdl) *worker_hdl = &worker;
   grpc_error_handle error = GRPC_ERROR_NONE;
@@ -948,7 +937,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   worker.kicked_specifically = 0;
   /* If we're shutting down then we don't execute any extended work */
   if (pollset->shutting_down) {
-    GPR_TIMER_MARK("pollset_work.shutting_down", 0);
     goto done;
   }
   /* Start polling, and keep doing so while we're being asked to
@@ -959,13 +947,12 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
   while (keep_polling) {
     keep_polling = 0;
     if (!pollset->kicked_without_pollers ||
-        deadline <= grpc_core::ExecCtx::Get()->Now()) {
+        deadline <= grpc_core::Timestamp::Now()) {
       if (!added_worker) {
         push_front_worker(pollset, &worker);
         added_worker = 1;
         g_current_thread_worker = &worker;
       }
-      GPR_TIMER_SCOPE("maybe_work_and_unlock", 0);
 #define POLLOUT_CHECK (POLLOUT | POLLHUP | POLLERR)
 #define POLLIN_CHECK (POLLIN | POLLHUP | POLLERR)
 
@@ -1024,7 +1011,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
       /* TODO(vpai): Consider first doing a 0 timeout poll here to avoid
          even going into the blocking annotation if possible */
       GRPC_SCHEDULING_START_BLOCKING_REGION;
-      GRPC_STATS_INC_SYSCALL_POLL();
       r = grpc_poll_function(pfds, pfd_count, timeout);
       GRPC_SCHEDULING_END_BLOCKING_REGION;
 
@@ -1090,7 +1076,6 @@ static grpc_error_handle pollset_work(grpc_pollset* pollset,
 
       locked = 0;
     } else {
-      GPR_TIMER_MARK("pollset_work.kicked_without_pollers", 0);
       pollset->kicked_without_pollers = 0;
     }
   /* Finished execution - start cleaning up.
@@ -1160,7 +1145,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 static int poll_deadline_to_millis_timeout(grpc_core::Timestamp deadline) {
   if (deadline == grpc_core::Timestamp::InfFuture()) return -1;
   if (deadline.is_process_epoch()) return 0;
-  int64_t n = (deadline - grpc_core::ExecCtx::Get()->Now()).millis();
+  int64_t n = (deadline - grpc_core::Timestamp::Now()).millis();
   if (n < 0) return 0;
   if (n > INT_MAX) return -1;
   return static_cast<int>(n);

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

@@ -25,7 +25,6 @@
 
 #include "src/core/lib/iomgr/combiner.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
 static void exec_ctx_run(grpc_closure* closure) {
 #ifndef NDEBUG
@@ -60,7 +59,6 @@ ApplicationCallbackExecCtx::callback_exec_ctx_;
 
 bool ExecCtx::Flush() {
   bool did_something = false;
-  GPR_TIMER_SCOPE("grpc_exec_ctx_flush", 0);
   for (;;) {
     if (!grpc_closure_list_empty(closure_list_)) {
       grpc_closure* c = closure_list_.head;
@@ -79,14 +77,6 @@ bool ExecCtx::Flush() {
   return did_something;
 }
 
-Timestamp ExecCtx::Now() {
-  if (!now_is_valid_) {
-    now_ = Timestamp::FromTimespecRoundDown(gpr_now(GPR_CLOCK_MONOTONIC));
-    now_is_valid_ = true;
-  }
-  return now_;
-}
-
 void ExecCtx::Run(const DebugLocation& location, grpc_closure* closure,
                   grpc_error_handle error) {
   (void)location;