grpc 1.48.0 → 1.50.0

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

@@ -23,6 +23,9 @@
 
 #include <cstddef>
 
+#include "absl/strings/string_view.h"
+#include "absl/types/variant.h"
+
 /** useful utilities that don't belong anywhere else */
 
 namespace grpc_core {
@@ -98,6 +101,32 @@ int QsortCompare(const T& a, const T& b) {
   return 0;
 }
 
+template <typename... X>
+int QsortCompare(const absl::variant<X...>& a, const absl::variant<X...>& b) {
+  const int index = QsortCompare(a.index(), b.index());
+  if (index != 0) return index;
+  return absl::visit(
+      [&](const auto& x) {
+        return QsortCompare(x, absl::get<absl::remove_cvref_t<decltype(x)>>(b));
+      },
+      a);
+}
+
+inline int QsortCompare(absl::string_view a, absl::string_view b) {
+  return a.compare(b);
+}
+
+inline int QsortCompare(const std::string& a, const std::string& b) {
+  return a.compare(b);
+}
+
+template <typename A, typename B>
+int QsortCompare(const std::pair<A, B>& a, const std::pair<A, B>& b) {
+  const int first = QsortCompare(a.first, b.first);
+  if (first != 0) return first;
+  return QsortCompare(a.second, b.second);
+}
+
 template <typename T>
 constexpr size_t HashPointer(T* p, size_t range) {
   return (((reinterpret_cast<size_t>(p)) >> 4) ^
@@ -124,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/gprpp/bitset.h

@@ -24,12 +24,6 @@
 
 #include "src/core/lib/gpr/useful.h"
 
-#if __cplusplus > 201103l
-#define GRPC_BITSET_CONSTEXPR_MUTATOR constexpr
-#else
-#define GRPC_BITSET_CONSTEXPR_MUTATOR
-#endif
-
 namespace grpc_core {
 
 // Given a bit count as an integer, vend as member type `Type` a type with
@@ -90,12 +84,10 @@ class BitSet {
   constexpr BitSet() : units_{} {}
 
   // Set bit i to true
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i) {
-    units_[unit_for(i)] |= mask_for(i);
-  }
+  constexpr void set(int i) { units_[unit_for(i)] |= mask_for(i); }
 
   // Set bit i to is_set
-  GRPC_BITSET_CONSTEXPR_MUTATOR void set(int i, bool is_set) {
+  constexpr void set(int i, bool is_set) {
     if (is_set) {
       set(i);
     } else {
@@ -104,9 +96,7 @@ class BitSet {
   }
 
   // Set bit i to false
-  GRPC_BITSET_CONSTEXPR_MUTATOR void clear(int i) {
-    units_[unit_for(i)] &= ~mask_for(i);
-  }
+  constexpr void clear(int i) { units_[unit_for(i)] &= ~mask_for(i); }
 
   // Return true if bit i is set
   constexpr bool is_set(int i) const {

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

@@ -19,8 +19,39 @@
 #ifndef GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 #define GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H
 
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_FILE)
+#define GRPC_DEFAULT_FILE __builtin_FILE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_FILE
+#define GRPC_DEFAULT_FILE "<unknown>"
+#endif
+#if defined(__has_builtin)
+#if __has_builtin(__builtin_LINE)
+#define GRPC_DEFAULT_LINE __builtin_LINE()
+#endif
+#endif
+#ifndef GRPC_DEFAULT_LINE
+#define GRPC_DEFAULT_LINE -1
+#endif
+
 namespace grpc_core {
 
+class SourceLocation {
+ public:
+  // NOLINTNEXTLINE
+  SourceLocation(const char* file = GRPC_DEFAULT_FILE,
+                 int line = GRPC_DEFAULT_LINE)
+      : file_(file), line_(line) {}
+  const char* file() const { return file_; }
+  int line() const { return line_; }
+
+ private:
+  const char* file_;
+  int line_;
+};
+
 // Used for tracking file and line where a call is made for debug builds.
 // No-op for non-debug builds.
 // Callers can use the DEBUG_LOCATION macro in either case.
@@ -30,15 +61,15 @@ namespace grpc_core {
 // callers don't need to explicitly pass DEBUG_LOCATION anywhere.
 class DebugLocation {
  public:
-  DebugLocation(const char* file, int line) : file_(file), line_(line) {}
-  const char* file() const { return file_; }
-  int line() const { return line_; }
+  DebugLocation(const char* file = GRPC_DEFAULT_FILE,
+                int line = GRPC_DEFAULT_LINE)
+      : location_(file, line) {}
+  const char* file() const { return location_.file(); }
+  int line() const { return location_.line(); }
 
  private:
-  const char* file_;
-  const int line_;
+  SourceLocation location_;
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
 #else
 class DebugLocation {
  public:
@@ -47,9 +78,10 @@ class DebugLocation {
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };
-#define DEBUG_LOCATION ::grpc_core::DebugLocation()
 #endif
 
+#define DEBUG_LOCATION ::grpc_core::DebugLocation(__FILE__, __LINE__)
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_DEBUG_LOCATION_H */

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/manual_constructor.h

@@ -25,7 +25,6 @@
 
 #include <stddef.h>
 
-#include <type_traits>
 #include <utility>
 
 #include "src/core/lib/gprpp/construct_destruct.h"