grpc 1.49.1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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_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

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

@@ -29,12 +29,11 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/string_windows.h"
 #include "src/core/lib/gpr/tmpfile.h"
+#include "src/core/lib/gprpp/tchar.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
   FILE* result = NULL;
-  LPTSTR template_string = NULL;
   TCHAR tmp_path[MAX_PATH];
   TCHAR tmp_filename[MAX_PATH];
   DWORD status;
@@ -43,15 +42,14 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
   if (tmp_filename_out != NULL) *tmp_filename_out = NULL;
 
   /* Convert our prefix to TCHAR. */
-  template_string = gpr_char_to_tchar(prefix);
-  GPR_ASSERT(template_string);
+  grpc_core::TcharString template_string = grpc_core::CharToTchar(prefix);
 
   /* Get the path to the best temporary folder available. */
   status = GetTempPath(MAX_PATH, tmp_path);
   if (status == 0 || status > MAX_PATH) goto end;
 
   /* Generate a unique filename with our template + temporary path. */
-  success = GetTempFileName(tmp_path, template_string, 0, tmp_filename);
+  success = GetTempFileName(tmp_path, template_string.c_str(), 0, tmp_filename);
   if (!success) goto end;
 
   /* Open a file there. */
@@ -59,10 +57,10 @@ FILE* gpr_tmpfile(const char* prefix, char** tmp_filename_out) {
 
 end:
   if (result && tmp_filename_out) {
-    *tmp_filename_out = gpr_tchar_to_char(tmp_filename);
+    *tmp_filename_out =
+        gpr_strdup(grpc_core::TcharToChar(tmp_filename).c_str());
   }
 
-  gpr_free(template_string);
   return result;
 }
 

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

@@ -153,6 +153,17 @@ inline uint32_t MixHash32(uint32_t a, uint32_t b) {
   return RotateLeft(a, 2u) ^ b;
 }
 
+inline uint32_t RoundUpToPowerOf2(uint32_t v) {
+  v--;
+  v |= v >> 1;
+  v |= v >> 2;
+  v |= v >> 4;
+  v |= v >> 8;
+  v |= v >> 16;
+  v++;
+  return v;
+}
+
 }  // namespace grpc_core
 
 #define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))

data/src/core/lib/{gpr → gprpp}/env.h

@@ -16,25 +16,38 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_GPR_ENV_H
-#define GRPC_CORE_LIB_GPR_ENV_H
+#ifndef GRPC_CORE_LIB_GPRPP_ENV_H
+#define GRPC_CORE_LIB_GPRPP_ENV_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stdio.h>
+#include <string>
 
-/* Env utility functions */
+#include "absl/types/optional.h"
 
-/* Gets the environment variable value with the specified name.
-   Returns a newly allocated string. It is the responsibility of the caller to
-   gpr_free the return value if not NULL (which means that the environment
-   variable exists). */
-char* gpr_getenv(const char* name);
+namespace grpc_core {
+
+// Gets the environment variable value with the specified name. */
+absl::optional<std::string> GetEnv(const char* name);
 
 /* Sets the environment with the specified name to the specified value. */
-void gpr_setenv(const char* name, const char* value);
+void SetEnv(const char* name, const char* value);
+inline void SetEnv(const char* name, const std::string& value) {
+  SetEnv(name, value.c_str());
+}
 
 /* Deletes the variable name from the environment. */
-void gpr_unsetenv(const char* name);
+void UnsetEnv(const char* name);
+
+template <typename T>
+void SetOrUnsetEnv(const char* name, const absl::optional<T>& value) {
+  if (value.has_value()) {
+    SetEnv(name, value.value());
+  } else {
+    UnsetEnv(name);
+  }
+}
+
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_GPR_ENV_H */
+#endif /* GRPC_CORE_LIB_GPRPP_ENV_H */

data/src/core/lib/{gpr → gprpp}/env_linux.cc

@@ -23,21 +23,24 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <string>
+
+#include "absl/types/optional.h"
+
 #ifdef GPR_LINUX_ENV
 
+#if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
 #include <dlfcn.h>
+#endif
+
 #include <features.h>
 #include <stdlib.h>
-#include <string.h>
 
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include "src/core/lib/gprpp/env.h"
 
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gpr/useful.h"
+namespace grpc_core {
 
-char* gpr_getenv(const char* name) {
+absl::optional<std::string> GetEnv(const char* name) {
   char* result = nullptr;
 #if defined(GPR_BACKWARDS_COMPATIBILITY_MODE)
   typedef char* (*getenv_type)(const char*);
@@ -45,9 +48,8 @@ char* gpr_getenv(const char* name) {
   /* Check to see which getenv variant is supported (go from most
    * to least secure) */
   if (getenv_func == nullptr) {
-    const char* names[] = {"secure_getenv", "__secure_getenv", "getenv"};
-    for (size_t i = 0; i < GPR_ARRAY_SIZE(names); i++) {
-      getenv_func = (getenv_type)dlsym(RTLD_DEFAULT, names[i]);
+    for (auto name : {"secure_getenv", "__secure_getenv", "getenv"}) {
+      getenv_func = reinterpret_cast<getenv_type>(dlsym(RTLD_DEFAULT, name));
       if (getenv_func != nullptr) {
         break;
       }
@@ -59,17 +61,20 @@ char* gpr_getenv(const char* name) {
 #else
   result = getenv(name);
 #endif
-  return result == nullptr ? result : gpr_strdup(result);
+  if (result == nullptr) return absl::nullopt;
+  return result;
 }
 
-void gpr_setenv(const char* name, const char* value) {
+void SetEnv(const char* name, const char* value) {
   int res = setenv(name, value, 1);
-  GPR_ASSERT(res == 0);
+  if (res != 0) abort();
 }
 
-void gpr_unsetenv(const char* name) {
+void UnsetEnv(const char* name) {
   int res = unsetenv(name);
-  GPR_ASSERT(res == 0);
+  if (res != 0) abort();
 }
 
+}  // namespace grpc_core
+
 #endif /* GPR_LINUX_ENV */

data/src/core/lib/{gpr → gprpp}/env_posix.cc

@@ -22,25 +22,26 @@
 
 #include <stdlib.h>
 
-#include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
+#include "src/core/lib/gprpp/env.h"
 
-#include "src/core/lib/gpr/env.h"
-#include "src/core/lib/gpr/string.h"
+namespace grpc_core {
 
-char* gpr_getenv(const char* name) {
+absl::optional<std::string> GetEnv(const char* name) {
   char* result = getenv(name);
-  return result == nullptr ? result : gpr_strdup(result);
+  if (result == nullptr) return absl::nullopt;
+  return result;
 }
 
-void gpr_setenv(const char* name, const char* value) {
+void SetEnv(const char* name, const char* value) {
   int res = setenv(name, value, 1);
-  GPR_ASSERT(res == 0);
+  if (res != 0) abort();
 }
 
-void gpr_unsetenv(const char* name) {
+void UnsetEnv(const char* name) {
   int res = unsetenv(name);
-  GPR_ASSERT(res == 0);
+  if (res != 0) abort();
 }
 
+}  // namespace grpc_core
+
 #endif /* GPR_POSIX_ENV */

data/src/core/lib/gprpp/env_windows.cc

@@ -0,0 +1,56 @@
+/*
+ *
+ * Copyright 2015 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>
+
+#ifdef GPR_WINDOWS_ENV
+
+#include <windows.h>
+
+#include <memory>
+
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/tchar.h"
+
+namespace grpc_core {
+
+absl::optional<std::string> GetEnv(const char* name) {
+  auto tname = CharToTchar(name);
+  DWORD ret = GetEnvironmentVariable(tname.c_str(), NULL, 0);
+  if (ret == 0) return absl::nullopt;
+  std::unique_ptr<TCHAR[]> tresult(new TCHAR[ret]);
+  ret =
+      GetEnvironmentVariable(tname.c_str(), tresult.get(), ret * sizeof(TCHAR));
+  if (ret == 0) return absl::nullopt;
+  return TcharToChar(tresult.get());
+}
+
+void SetEnv(const char* name, const char* value) {
+  BOOL res = SetEnvironmentVariable(CharToTchar(name).c_str(),
+                                    CharToTchar(value).c_str());
+  if (!res) abort();
+}
+
+void UnsetEnv(const char* name) {
+  BOOL res = SetEnvironmentVariable(CharToTchar(name).c_str(), NULL);
+  if (!res) abort();
+}
+
+}  // namespace grpc_core
+
+#endif /* GPR_WINDOWS_ENV */

data/src/core/lib/gprpp/fork.cc

@@ -26,6 +26,7 @@
 #include <grpc/support/time.h>
 
 #include "src/core/lib/gprpp/global_config_env.h"
+#include "src/core/lib/gprpp/no_destruct.h"
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
@@ -43,7 +44,7 @@ GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_enable_fork_support,
                               "Enable fork support");
 
 namespace grpc_core {
-namespace internal {
+namespace {
 // The exec_ctx_count has 2 modes, blocked and unblocked.
 // When unblocked, the count is 2-indexed; exec_ctx_count=2 indicates
 // 0 active ExecCtxs, exex_ctx_count=3 indicates 1 active ExecCtxs...
@@ -161,24 +162,13 @@ class ThreadState {
   int count_;
 };
 
-}  // namespace internal
+}  // namespace
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
     support_enabled_.store(GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support),
                            std::memory_order_relaxed);
   }
-  if (support_enabled_.load(std::memory_order_relaxed)) {
-    exec_ctx_state_ = new internal::ExecCtxState();
-    thread_state_ = new internal::ThreadState();
-  }
-}
-
-void Fork::GlobalShutdown() {
-  if (support_enabled_.load(std::memory_order_relaxed)) {
-    delete exec_ctx_state_;
-    delete thread_state_;
-  }
 }
 
 bool Fork::Enabled() {
@@ -191,9 +181,13 @@ void Fork::Enable(bool enable) {
   support_enabled_.store(enable, std::memory_order_relaxed);
 }
 
-void Fork::DoIncExecCtxCount() { exec_ctx_state_->IncExecCtxCount(); }
+void Fork::DoIncExecCtxCount() {
+  NoDestructSingleton<ExecCtxState>::Get()->IncExecCtxCount();
+}
 
-void Fork::DoDecExecCtxCount() { exec_ctx_state_->DecExecCtxCount(); }
+void Fork::DoDecExecCtxCount() {
+  NoDestructSingleton<ExecCtxState>::Get()->DecExecCtxCount();
+}
 
 void Fork::SetResetChildPollingEngineFunc(
     Fork::child_postfork_func reset_child_polling_engine) {
@@ -205,36 +199,34 @@ Fork::child_postfork_func Fork::GetResetChildPollingEngineFunc() {
 
 bool Fork::BlockExecCtx() {
   if (support_enabled_.load(std::memory_order_relaxed)) {
-    return exec_ctx_state_->BlockExecCtx();
+    return NoDestructSingleton<ExecCtxState>::Get()->BlockExecCtx();
   }
   return false;
 }
 
 void Fork::AllowExecCtx() {
   if (support_enabled_.load(std::memory_order_relaxed)) {
-    exec_ctx_state_->AllowExecCtx();
+    NoDestructSingleton<ExecCtxState>::Get()->AllowExecCtx();
   }
 }
 
 void Fork::IncThreadCount() {
   if (support_enabled_.load(std::memory_order_relaxed)) {
-    thread_state_->IncThreadCount();
+    NoDestructSingleton<ThreadState>::Get()->IncThreadCount();
   }
 }
 
 void Fork::DecThreadCount() {
   if (support_enabled_.load(std::memory_order_relaxed)) {
-    thread_state_->DecThreadCount();
+    NoDestructSingleton<ThreadState>::Get()->DecThreadCount();
   }
 }
 void Fork::AwaitThreads() {
   if (support_enabled_.load(std::memory_order_relaxed)) {
-    thread_state_->AwaitThreads();
+    NoDestructSingleton<ThreadState>::Get()->AwaitThreads();
   }
 }
 
-internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
-internal::ThreadState* Fork::thread_state_ = nullptr;
 std::atomic<bool> Fork::support_enabled_(false);
 bool Fork::override_enabled_ = false;
 Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;

data/src/core/lib/gprpp/fork.h

@@ -30,17 +30,11 @@
 
 namespace grpc_core {
 
-namespace internal {
-class ExecCtxState;
-class ThreadState;
-}  // namespace internal
-
 class Fork {
  public:
   typedef void (*child_postfork_func)(void);
 
   static void GlobalInit();
-  static void GlobalShutdown();
 
   // Returns true if fork suppport is enabled, false otherwise
   static bool Enabled();
@@ -91,8 +85,6 @@ class Fork {
   static void DoIncExecCtxCount();
   static void DoDecExecCtxCount();
 
-  static internal::ExecCtxState* exec_ctx_state_;
-  static internal::ThreadState* thread_state_;
   static std::atomic<bool> support_enabled_;
   static bool override_enabled_;
   static child_postfork_func reset_child_polling_engine_;

data/src/core/lib/gprpp/global_config_env.cc

@@ -28,12 +28,13 @@
 #include <type_traits>
 
 #include "absl/strings/str_format.h"
+#include "absl/types/optional.h"
 
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/env.h"
 
 namespace grpc_core {
 
@@ -60,14 +61,14 @@ void SetGlobalConfigEnvErrorFunction(GlobalConfigEnvErrorFunctionType func) {
 }
 
 UniquePtr<char> GlobalConfigEnv::GetValue() {
-  return UniquePtr<char>(gpr_getenv(GetName()));
+  auto env = GetEnv(GetName());
+  return UniquePtr<char>(env.has_value() ? gpr_strdup(env.value().c_str())
+                                         : nullptr);
 }
 
-void GlobalConfigEnv::SetValue(const char* value) {
-  gpr_setenv(GetName(), value);
-}
+void GlobalConfigEnv::SetValue(const char* value) { SetEnv(GetName(), value); }
 
-void GlobalConfigEnv::Unset() { gpr_unsetenv(GetName()); }
+void GlobalConfigEnv::Unset() { UnsetEnv(GetName()); }
 
 char* GlobalConfigEnv::GetName() {
   // This makes sure that name_ is in a canonical form having uppercase

data/src/core/lib/gprpp/notification.h

@@ -0,0 +1,67 @@
+// 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_GPRPP_NOTIFICATION_H
+#define GRPC_CORE_LIB_GPRPP_NOTIFICATION_H
+
+#include <grpc/support/port_platform.h>
+
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+#include "src/core/lib/gprpp/sync.h"
+
+namespace grpc_core {
+
+// Polyfill for absl::Notification until we can use that type.
+class Notification {
+ public:
+  void Notify() {
+    MutexLock lock(&mu_);
+    notified_ = true;
+    cv_.SignalAll();
+  }
+
+  void WaitForNotification() {
+    MutexLock lock(&mu_);
+    while (!notified_) {
+      cv_.Wait(&mu_);
+    }
+  }
+
+  bool WaitForNotificationWithTimeout(absl::Duration timeout) {
+    auto now = absl::Now();
+    auto deadline = now + timeout;
+    MutexLock lock(&mu_);
+    while (!notified_ && now < deadline) {
+      cv_.WaitWithTimeout(&mu_, deadline - now);
+      now = absl::Now();
+    }
+    return notified_;
+  }
+
+  bool HasBeenNotified() {
+    MutexLock lock(&mu_);
+    return notified_;
+  }
+
+ private:
+  Mutex mu_;
+  CondVar cv_;
+  bool notified_ = false;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_NOTIFICATION_H

data/src/core/lib/gprpp/packed_table.h

@@ -0,0 +1,40 @@
+// 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_GPRPP_PACKED_TABLE_H
+#define GRPC_CORE_LIB_GPRPP_PACKED_TABLE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/sorted_pack.h"
+#include "src/core/lib/gprpp/table.h"
+
+namespace grpc_core {
+
+namespace packed_table_detail {
+template <typename A, typename B>
+struct Cmp {
+  static constexpr bool kValue = alignof(A) > alignof(B) ||
+                                 (alignof(A) == alignof(B) &&
+                                  sizeof(A) > sizeof(B));
+};
+};  // namespace packed_table_detail
+
+template <typename... T>
+using PackedTable =
+    typename WithSortedPack<Table, packed_table_detail::Cmp, T...>::Type;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_PACKED_TABLE_H