grpc 1.49.1 → 1.50.0.pre1

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

@@ -0,0 +1,30 @@
+// 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 "src/core/lib/event_engine/time_util.h"
+
+#include <chrono>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+size_t Milliseconds(EventEngine::Duration d) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
+}
+
+}  // namespace experimental
+}  // namespace grpc_event_engine

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

@@ -0,0 +1,32 @@
+// 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.
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <grpc/event_engine/event_engine.h>
+
+namespace grpc_event_engine {
+namespace experimental {
+
+// Convert a duration to milliseconds
+size_t Milliseconds(EventEngine::Duration d);
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_TIME_UTIL_H

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

@@ -18,7 +18,6 @@
 #include <stdint.h>
 
 #include <algorithm>
-#include <chrono>
 
 #include "absl/strings/str_cat.h"
 
@@ -41,9 +40,5 @@ grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
          grpc_core::Duration::Milliseconds(1);
 }
 
-size_t Milliseconds(EventEngine::Duration d) {
-  return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
-}
-
 }  // namespace experimental
 }  // namespace grpc_event_engine

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

@@ -16,8 +16,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
-
 #include <string>
 
 #include <grpc/event_engine/event_engine.h>
@@ -32,8 +30,6 @@ std::string HandleToString(EventEngine::TaskHandle handle);
 grpc_core::Timestamp ToTimestamp(grpc_core::Timestamp now,
                                  EventEngine::Duration delta);
 
-size_t Milliseconds(EventEngine::Duration d);
-
 }  // namespace experimental
 }  // namespace grpc_event_engine
 

data/src/core/lib/event_engine/windows/iocp.cc

@@ -22,8 +22,8 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log_windows.h>
 
+#include "src/core/lib/event_engine/time_util.h"
 #include "src/core/lib/event_engine/trace.h"
-#include "src/core/lib/event_engine/utils.h"
 #include "src/core/lib/event_engine/windows/iocp.h"
 #include "src/core/lib/event_engine/windows/win_socket.h"
 
@@ -59,12 +59,13 @@ WinSocket* IOCP::Watch(SOCKET socket) {
 
 void IOCP::Shutdown() {
   while (outstanding_kicks_.load() > 0) {
-    Work(std::chrono::hours(42));
+    Work(std::chrono::hours(42), []() {});
   }
   GPR_ASSERT(CloseHandle(iocp_handle_));
 }
 
-Poller::WorkResult IOCP::Work(EventEngine::Duration timeout) {
+Poller::WorkResult IOCP::Work(EventEngine::Duration timeout,
+                              absl::FunctionRef<void()> schedule_poll_again) {
   static const absl::Status kDeadlineExceeded = absl::DeadlineExceededError(
       absl::StrFormat("IOCP::%p: Received no completions", this));
   static const absl::Status kKicked =
@@ -82,7 +83,7 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout) {
     if (GRPC_TRACE_FLAG_ENABLED(grpc_event_engine_trace)) {
       gpr_log(GPR_DEBUG, "IOCP::%p deadline exceeded", this);
     }
-    return Poller::DeadlineExceeded{};
+    return Poller::WorkResult::kDeadlineExceeded;
   }
   GPR_ASSERT(completion_key && overlapped);
   if (overlapped == &kick_overlap_) {
@@ -91,7 +92,7 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout) {
     }
     outstanding_kicks_.fetch_sub(1);
     if (completion_key == (ULONG_PTR)&kick_token_) {
-      return Poller::Kicked{};
+      return Poller::WorkResult::kKicked;
     }
     gpr_log(GPR_ERROR, "Unknown custom completion key: %p", completion_key);
     abort();
@@ -109,10 +110,15 @@ Poller::WorkResult IOCP::Work(EventEngine::Duration timeout) {
   } else {
     info->GetOverlappedResult();
   }
-  if (info->closure() != nullptr) return Events{info->closure()};
+  if (info->closure() != nullptr) {
+    schedule_poll_again();
+    executor_->Run(info->closure());
+    return Poller::WorkResult::kOk;
+  }
   // No callback registered. Set ready and return an empty set
   info->SetReady();
-  return Events{};
+  schedule_poll_again();
+  return Poller::WorkResult::kOk;
 }
 
 void IOCP::Kick() {

data/src/core/lib/event_engine/windows/iocp.h

@@ -42,7 +42,8 @@ class IOCP final : public Poller {
 
   // interface methods
   void Shutdown();
-  WorkResult Work(EventEngine::Duration timeout) override;
+  WorkResult Work(EventEngine::Duration timeout,
+                  absl::FunctionRef<void()> schedule_poll_again) override;
   void Kick() override;
 
   WinSocket* Watch(SOCKET socket);

data/src/core/lib/event_engine/windows/win_socket.cc

@@ -82,7 +82,7 @@ void WinSocket::NotifyOnReady(OpState& info, EventEngine::Closure* closure) {
     executor_->Run(closure);
     return;
   };
-  if (absl::exchange(info.has_pending_iocp_, false)) {
+  if (std::exchange(info.has_pending_iocp_, false)) {
     executor_->Run(closure);
   } else {
     info.closure_ = closure;

data/src/core/lib/experiments/config.cc

@@ -0,0 +1,146 @@
+// 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 "src/core/lib/experiments/config.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <atomic>
+#include <memory>
+#include <string>
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/no_destruct.h"
+
+GPR_GLOBAL_CONFIG_DEFINE_STRING(
+    grpc_experiments, "",
+    "List of grpc experiments to enable (or with a '-' prefix to disable).");
+
+namespace grpc_core {
+
+namespace {
+struct Experiments {
+  bool enabled[kNumExperiments];
+};
+
+struct ForcedExperiment {
+  bool forced = false;
+  bool value;
+};
+ForcedExperiment g_forced_experiments[kNumExperiments];
+
+std::atomic<bool> g_loaded;
+
+GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
+  GPR_ASSERT(g_loaded.exchange(true, std::memory_order_relaxed) == false);
+  // Set defaults from metadata.
+  Experiments experiments;
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    experiments.enabled[i] = g_experiment_metadata[i].default_value;
+  }
+  // Get the global config.
+  auto experiments_str = GPR_GLOBAL_CONFIG_GET(grpc_experiments);
+  // For each comma-separated experiment in the global config:
+  for (auto experiment :
+       absl::StrSplit(absl::string_view(experiments_str.get()), ',')) {
+    // Strip whitespace.
+    experiment = absl::StripAsciiWhitespace(experiment);
+    // Handle ",," without crashing.
+    if (experiment.empty()) continue;
+    // Enable unless prefixed with '-' (=> disable).
+    bool enable = true;
+    if (experiment[0] == '-') {
+      enable = false;
+      experiment.remove_prefix(1);
+    }
+    // See if we can find the experiment in the list in this binary.
+    bool found = false;
+    for (size_t i = 0; i < kNumExperiments; i++) {
+      if (experiment == g_experiment_metadata[i].name) {
+        experiments.enabled[i] = enable;
+        found = true;
+        break;
+      }
+    }
+    // If not found log an error, but don't take any other action.
+    // Allows us an easy path to disabling experiments.
+    if (!found) {
+      gpr_log(GPR_ERROR, "Unknown experiment: %s",
+              std::string(experiment).c_str());
+    }
+  }
+  return experiments;
+}
+}  // namespace
+
+bool IsExperimentEnabled(size_t experiment_id) {
+  // One time initialization:
+  static const NoDestruct<Experiments> experiments{
+      LoadExperimentsFromConfigVariable()};
+  // Normal path: just return the value;
+  return experiments->enabled[experiment_id];
+}
+
+void PrintExperimentsList() {
+  size_t max_experiment_length = 0;
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    max_experiment_length =
+        std::max(max_experiment_length, strlen(g_experiment_metadata[i].name));
+  }
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    gpr_log(GPR_DEBUG, "%s",
+            absl::StrCat(
+                "gRPC EXPERIMENT ", g_experiment_metadata[i].name,
+                std::string(max_experiment_length -
+                                strlen(g_experiment_metadata[i].name) + 1,
+                            ' '),
+                IsExperimentEnabled(i) ? "ON " : "OFF", " (default:",
+                g_experiment_metadata[i].default_value ? "ON" : "OFF",
+                g_forced_experiments[i].forced
+                    ? absl::StrCat(" force:",
+                                   g_forced_experiments[i].value ? "ON" : "OFF")
+                    : std::string(),
+                ")")
+                .c_str());
+  }
+}
+
+void ForceEnableExperiment(absl::string_view experiment, bool enable) {
+  GPR_ASSERT(g_loaded.load(std::memory_order_relaxed) == false);
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    if (g_experiment_metadata[i].name != experiment) continue;
+    if (g_forced_experiments[i].forced) {
+      GPR_ASSERT(g_forced_experiments[i].value == enable);
+    } else {
+      g_forced_experiments[i].forced = true;
+      g_forced_experiments[i].value = enable;
+    }
+    return;
+  }
+  gpr_log(GPR_INFO, "gRPC EXPERIMENT %s not found to force %s",
+          std::string(experiment).c_str(), enable ? "enable" : "disable");
+}
+
+}  // namespace grpc_core

data/src/core/lib/experiments/config.h

@@ -0,0 +1,43 @@
+// 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.
+
+#ifndef GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H
+#define GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Return true if experiment \a experiment_id is enabled.
+// Experiments are numbered by their order in the g_experiment_metadata array
+// declared in experiments.h.
+bool IsExperimentEnabled(size_t experiment_id);
+
+// Print out a list of all experiments that are built into this binary.
+void PrintExperimentsList();
+
+// Force an experiment to be on or off.
+// Must be called before experiments are configured (the first
+// IsExperimentEnabled call).
+// If the experiment does not exist, emits a warning but continues execution.
+// If this is called twice for the same experiment, both calls must agree.
+void ForceEnableExperiment(absl::string_view experiment_name, bool enable);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_EXPERIMENTS_CONFIG_H

data/src/core/lib/experiments/experiments.cc

@@ -0,0 +1,75 @@
+// 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.
+
+// Automatically generated by tools/codegen/core/gen_experiments.py
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/experiments/experiments.h"
+
+namespace {
+const char* const description_tcp_frame_size_tuning =
+    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
+    "would not indicate completion of a read operation until a specified "
+    "number of bytes have been read over the socket. Buffers are also "
+    "allocated according to estimated RPC sizes.";
+const char* const description_tcp_read_chunks =
+    "Allocate only 8kb or 64kb chunks for TCP reads to reduce pressure on "
+    "malloc to recycle arbitrary large blocks.";
+const char* const description_tcp_rcv_lowat =
+    "Use SO_RCVLOWAT to avoid wakeups on the read path.";
+const char* const description_peer_state_based_framing =
+    "If set, the max sizes of frames sent to lower layers is controlled based "
+    "on the peer's memory pressure which is reflected in its max http2 frame "
+    "size.";
+const char* const description_flow_control_fixes =
+    "Various fixes for flow control, max frame size setting.";
+const char* const description_memory_pressure_controller =
+    "New memory pressure controller";
+const char* const description_periodic_resource_quota_reclamation =
+    "Periodically return memory to the resource quota";
+const char* const description_unconstrained_max_quota_buffer_size =
+    "Discard the cap on the max free pool size for one memory allocator";
+const char* const description_new_hpack_huffman_decoder =
+    "New HPACK huffman decoder - should be much faster than the existing "
+    "implementation.";
+const char* const description_event_engine_client =
+    "Use EventEngine clients instead of iomgr's grpc_tcp_client";
+#ifdef NDEBUG
+const bool kDefaultForDebugOnly = false;
+#else
+const bool kDefaultForDebugOnly = true;
+#endif
+}  // namespace
+
+namespace grpc_core {
+
+const ExperimentMetadata g_experiment_metadata[] = {
+    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
+    {"tcp_read_chunks", description_tcp_read_chunks, false},
+    {"tcp_rcv_lowat", description_tcp_rcv_lowat, false},
+    {"peer_state_based_framing", description_peer_state_based_framing, false},
+    {"flow_control_fixes", description_flow_control_fixes, false},
+    {"memory_pressure_controller", description_memory_pressure_controller,
+     false},
+    {"periodic_resource_quota_reclamation",
+     description_periodic_resource_quota_reclamation, false},
+    {"unconstrained_max_quota_buffer_size",
+     description_unconstrained_max_quota_buffer_size, false},
+    {"new_hpack_huffman_decoder", description_new_hpack_huffman_decoder,
+     kDefaultForDebugOnly},
+    {"event_engine_client", description_event_engine_client, false},
+};
+
+}  // namespace grpc_core

data/src/core/lib/experiments/experiments.h

@@ -0,0 +1,56 @@
+// 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.
+
+// Automatically generated by tools/codegen/core/gen_experiments.py
+
+#ifndef GRPC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H
+#define GRPC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/experiments/config.h"
+
+namespace grpc_core {
+
+inline bool IsTcpFrameSizeTuningEnabled() { return IsExperimentEnabled(0); }
+inline bool IsTcpReadChunksEnabled() { return IsExperimentEnabled(1); }
+inline bool IsTcpRcvLowatEnabled() { return IsExperimentEnabled(2); }
+inline bool IsPeerStateBasedFramingEnabled() { return IsExperimentEnabled(3); }
+inline bool IsFlowControlFixesEnabled() { return IsExperimentEnabled(4); }
+inline bool IsMemoryPressureControllerEnabled() {
+  return IsExperimentEnabled(5);
+}
+inline bool IsPeriodicResourceQuotaReclamationEnabled() {
+  return IsExperimentEnabled(6);
+}
+inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() {
+  return IsExperimentEnabled(7);
+}
+inline bool IsNewHpackHuffmanDecoderEnabled() { return IsExperimentEnabled(8); }
+inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(9); }
+
+struct ExperimentMetadata {
+  const char* name;
+  const char* description;
+  bool default_value;
+};
+
+constexpr const size_t kNumExperiments = 10;
+extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H

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

@@ -24,10 +24,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/profiling/timers.h"
-
 void* gpr_malloc(size_t size) {
-  GPR_TIMER_SCOPE("gpr_malloc", 0);
   void* p;
   if (size == 0) return nullptr;
   p = malloc(size);
@@ -38,7 +35,6 @@ void* gpr_malloc(size_t size) {
 }
 
 void* gpr_zalloc(size_t size) {
-  GPR_TIMER_SCOPE("gpr_zalloc", 0);
   void* p;
   if (size == 0) return nullptr;
   p = calloc(size, 1);
@@ -48,13 +44,9 @@ void* gpr_zalloc(size_t size) {
   return p;
 }
 
-void gpr_free(void* p) {
-  GPR_TIMER_SCOPE("gpr_free", 0);
-  free(p);
-}
+void gpr_free(void* p) { free(p); }
 
 void* gpr_realloc(void* p, size_t size) {
-  GPR_TIMER_SCOPE("gpr_realloc", 0);
   if ((size == 0) && (p == nullptr)) return nullptr;
   p = realloc(p, size);
   if (!p) {

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

@@ -30,7 +30,6 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/string_windows.h"
 #include "src/core/lib/gprpp/examine_stack.h"
 
 int gpr_should_log_stacktrace(gpr_log_severity severity);

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

@@ -37,46 +37,19 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/string_windows.h"
-
-#if defined UNICODE || defined _UNICODE
-LPTSTR
-gpr_char_to_tchar(LPCSTR input) {
-  LPTSTR ret;
-  int needed = MultiByteToWideChar(CP_UTF8, 0, input, -1, NULL, 0);
-  if (needed <= 0) return NULL;
-  ret = (LPTSTR)gpr_malloc((unsigned)needed * sizeof(TCHAR));
-  MultiByteToWideChar(CP_UTF8, 0, input, -1, ret, needed);
-  return ret;
-}
-
-LPSTR
-gpr_tchar_to_char(LPCTSTR input) {
-  LPSTR ret;
-  int needed = WideCharToMultiByte(CP_UTF8, 0, input, -1, NULL, 0, NULL, NULL);
-  if (needed <= 0) return NULL;
-  ret = (LPSTR)gpr_malloc((unsigned)needed);
-  WideCharToMultiByte(CP_UTF8, 0, input, -1, ret, needed, NULL, NULL);
-  return ret;
-}
-#else
-LPSTR gpr_tchar_to_char(LPCTSTR input) { return (LPSTR)gpr_strdup(input); }
-
-LPTSTR gpr_char_to_tchar(LPCTSTR input) { return (LPTSTR)gpr_strdup(input); }
-#endif
+#include "src/core/lib/gprpp/tchar.h"
 
 char* gpr_format_message(int messageid) {
   LPTSTR tmessage;
-  char* message;
   DWORD status = FormatMessage(
       FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
           FORMAT_MESSAGE_IGNORE_INSERTS,
       NULL, (DWORD)messageid, MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),
       (LPTSTR)(&tmessage), 0, NULL);
   if (status == 0) return gpr_strdup("Unable to retrieve error string");
-  message = gpr_tchar_to_char(tmessage);
+  auto message = grpc_core::TcharToChar(tmessage);
   LocalFree(tmessage);
-  return message;
+  return gpr_strdup(message.c_str());
 }
 
 #endif /* GPR_WINDOWS */

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

@@ -33,14 +33,6 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include "src/core/lib/profiling/timers.h"
-
-#ifdef GPR_LOW_LEVEL_COUNTERS
-gpr_atm gpr_mu_locks = 0;
-gpr_atm gpr_counter_atm_cas = 0;
-gpr_atm gpr_counter_atm_add = 0;
-#endif
-
 void gpr_mu_init(gpr_mu* mu) {
   static_assert(sizeof(gpr_mu) == sizeof(absl::Mutex),
                 "gpr_mu and Mutex must be the same size");
@@ -52,17 +44,14 @@ void gpr_mu_destroy(gpr_mu* mu) {
 }
 
 void gpr_mu_lock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  GPR_TIMER_SCOPE("gpr_mu_lock", 0);
   reinterpret_cast<absl::Mutex*>(mu)->Lock();
 }
 
 void gpr_mu_unlock(gpr_mu* mu) ABSL_NO_THREAD_SAFETY_ANALYSIS {
-  GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
   reinterpret_cast<absl::Mutex*>(mu)->Unlock();
 }
 
 int gpr_mu_trylock(gpr_mu* mu) {
-  GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
   return reinterpret_cast<absl::Mutex*>(mu)->TryLock();
 }
 
@@ -79,7 +68,6 @@ void gpr_cv_destroy(gpr_cv* cv) {
 }
 
 int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
-  GPR_TIMER_SCOPE("gpr_cv_wait", 0);
   if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
       0) {
     reinterpret_cast<absl::CondVar*>(cv)->Wait(
@@ -94,12 +82,10 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
 }
 
 void gpr_cv_signal(gpr_cv* cv) {
-  GPR_TIMER_MARK("gpr_cv_signal", 0);
   reinterpret_cast<absl::CondVar*>(cv)->Signal();
 }
 
 void gpr_cv_broadcast(gpr_cv* cv) {
-  GPR_TIMER_MARK("gpr_cv_broadcast", 0);
   reinterpret_cast<absl::CondVar*>(cv)->SignalAll();
 }