grpc 1.48.0 → 1.50.0

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

@@ -0,0 +1,120 @@
+// Copyright 2022 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+#ifndef GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#define GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H
+#include <grpc/support/port_platform.h>
+
+#ifdef GPR_WINDOWS
+
+#include <memory>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/event_engine/endpoint_config.h>
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/event_engine/slice_buffer.h>
+
+#include "src/core/lib/event_engine/executor/threaded_executor.h"
+#include "src/core/lib/event_engine/handle_containers.h"
+#include "src/core/lib/event_engine/posix_engine/timer_manager.h"
+#include "src/core/lib/event_engine/windows/iocp.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class WindowsEventEngine : public EventEngine {
+ public:
+  class WindowsEndpoint : public EventEngine::Endpoint {
+   public:
+    ~WindowsEndpoint() override;
+    void Read(absl::AnyInvocable<void(absl::Status)> on_read,
+              SliceBuffer* buffer, const ReadArgs* args) override;
+    void Write(absl::AnyInvocable<void(absl::Status)> on_writable,
+               SliceBuffer* data, const WriteArgs* args) override;
+    const ResolvedAddress& GetPeerAddress() const override;
+    const ResolvedAddress& GetLocalAddress() const override;
+  };
+  class WindowsListener : public EventEngine::Listener {
+   public:
+    ~WindowsListener() override;
+    absl::StatusOr<int> Bind(const ResolvedAddress& addr) override;
+    absl::Status Start() override;
+  };
+  class WindowsDNSResolver : public EventEngine::DNSResolver {
+   public:
+    ~WindowsDNSResolver() override;
+    LookupTaskHandle LookupHostname(LookupHostnameCallback on_resolve,
+                                    absl::string_view name,
+                                    absl::string_view default_port,
+                                    Duration timeout) override;
+    LookupTaskHandle LookupSRV(LookupSRVCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    LookupTaskHandle LookupTXT(LookupTXTCallback on_resolve,
+                               absl::string_view name,
+                               Duration timeout) override;
+    bool CancelLookup(LookupTaskHandle handle) override;
+  };
+
+  WindowsEventEngine();
+  ~WindowsEventEngine() override;
+
+  absl::StatusOr<std::unique_ptr<Listener>> CreateListener(
+      Listener::AcceptCallback on_accept,
+      absl::AnyInvocable<void(absl::Status)> on_shutdown,
+      const EndpointConfig& config,
+      std::unique_ptr<MemoryAllocatorFactory> memory_allocator_factory)
+      override;
+
+  ConnectionHandle Connect(OnConnectCallback on_connect,
+                           const ResolvedAddress& addr,
+                           const EndpointConfig& args,
+                           MemoryAllocator memory_allocator,
+                           Duration timeout) override;
+
+  bool CancelConnect(ConnectionHandle handle) override;
+  bool IsWorkerThread() override;
+  std::unique_ptr<DNSResolver> GetDNSResolver(
+      const DNSResolver::ResolverOptions& options) override;
+  void Run(Closure* closure) override;
+  void Run(absl::AnyInvocable<void()> closure) override;
+  TaskHandle RunAfter(Duration when, Closure* closure) override;
+  TaskHandle RunAfter(Duration when,
+                      absl::AnyInvocable<void()> closure) override;
+  bool Cancel(TaskHandle handle) override;
+
+ private:
+  struct Closure;
+  EventEngine::TaskHandle RunAfterInternal(Duration when,
+                                           absl::AnyInvocable<void()> cb);
+  grpc_core::Mutex mu_;
+  TaskHandleSet known_handles_ ABSL_GUARDED_BY(mu_);
+  std::atomic<intptr_t> aba_token_{0};
+
+  posix_engine::TimerManager timer_manager_;
+  ThreadedExecutor executor_{2};
+  IOCP iocp_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif
+
+#endif  // GRPC_CORE_LIB_EVENT_ENGINE_WINDOWS_WINDOWS_ENGINE_H

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();
 }
 

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

@@ -29,14 +29,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) {
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_mutex_init(&mu->mutex, nullptr) == 0);
@@ -57,10 +49,6 @@ void gpr_mu_destroy(gpr_mu* mu) {
 }
 
 void gpr_mu_lock(gpr_mu* mu) {
-#ifdef GPR_LOW_LEVEL_COUNTERS
-  GPR_ATM_INC_COUNTER(gpr_mu_locks);
-#endif
-  GPR_TIMER_SCOPE("gpr_mu_lock", 0);
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_mutex_lock(&mu->mutex) == 0);
 #else
@@ -69,7 +57,6 @@ void gpr_mu_lock(gpr_mu* mu) {
 }
 
 void gpr_mu_unlock(gpr_mu* mu) {
-  GPR_TIMER_SCOPE("gpr_mu_unlock", 0);
 #ifdef GRPC_ASAN_ENABLED
   GPR_ASSERT(pthread_mutex_unlock(&mu->mutex) == 0);
 #else
@@ -78,7 +65,6 @@ void gpr_mu_unlock(gpr_mu* mu) {
 }
 
 int gpr_mu_trylock(gpr_mu* mu) {
-  GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
   int err = 0;
 #ifdef GRPC_ASAN_ENABLED
   err = pthread_mutex_trylock(&mu->mutex);

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

@@ -77,16 +77,18 @@ static gpr_timespec to_seconds_from_sub_second_time(int64_t time_in_units,
   } else if (time_in_units == INT64_MIN) {
     out = gpr_inf_past(type);
   } else {
-    if (time_in_units >= 0) {
-      out.tv_sec = time_in_units / units_per_sec;
-    } else {
-      out.tv_sec = (-((units_per_sec - 1) - (time_in_units + units_per_sec)) /
-                    units_per_sec) -
-                   1;
-    }
+    GPR_DEBUG_ASSERT(GPR_NS_PER_SEC % units_per_sec == 0);
+
+    out.tv_sec = time_in_units / units_per_sec;
     out.tv_nsec =
-        static_cast<int32_t>((time_in_units - out.tv_sec * units_per_sec) *
-                             GPR_NS_PER_SEC / units_per_sec);
+        static_cast<int32_t>((time_in_units - (out.tv_sec * units_per_sec)) *
+                             (GPR_NS_PER_SEC / units_per_sec));
+    /// `out.tv_nsec` should always be positive.
+    if (out.tv_nsec < 0) {
+      out.tv_nsec += GPR_NS_PER_SEC;
+      out.tv_sec--;
+    }
+
     out.clock_type = type;
   }
   return out;

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

@@ -140,13 +140,7 @@ static gpr_timespec now_impl(gpr_clock_type clock) {
 
 gpr_timespec (*gpr_now_impl)(gpr_clock_type clock_type) = now_impl;
 
-#ifdef GPR_LOW_LEVEL_COUNTERS
-gpr_atm gpr_now_call_count;
-#endif
 gpr_timespec gpr_now(gpr_clock_type clock_type) {
-#ifdef GPR_LOW_LEVEL_COUNTERS
-  __atomic_fetch_add(&gpr_now_call_count, 1, __ATOMIC_RELAXED);
-#endif
   // validate clock type
   GPR_ASSERT(clock_type == GPR_CLOCK_MONOTONIC ||
              clock_type == GPR_CLOCK_REALTIME ||

data/src/core/lib/gpr/time_precise.h

@@ -28,7 +28,7 @@
 // low as a usec. Use other clock sources or gpr_precise_clock_now(),
 // where you need high resolution clocks.
 //
-// Using gpr_get_cycle_counter() is preferred to using ExecCtx::Get()->Now()
+// Using gpr_get_cycle_counter() is preferred to using Timestamp::Now()
 // whenever possible.
 
 #if GPR_CYCLE_COUNTER_CUSTOM