grpc 1.40.0 → 1.43.1

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

@@ -21,12 +21,13 @@
 #ifdef GPR_ANDROID
 
 #include <android/log.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 static android_LogPriority severity_to_log_priority(gpr_log_severity severity) {
   switch (severity) {
     case GPR_LOG_SEVERITY_DEBUG:

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

@@ -28,9 +28,6 @@
 
 #ifdef GPR_LINUX_LOG
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include <inttypes.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -42,6 +39,12 @@
 #include <string>
 
 #include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/gpr/tls.h"
 #include "src/core/lib/gprpp/examine_stack.h"
 
 int gpr_should_log_stacktrace(gpr_log_severity severity);
@@ -74,7 +77,7 @@ void gpr_default_log(gpr_log_func_args* args) {
   time_t timer;
   gpr_timespec now = gpr_now(GPR_CLOCK_REALTIME);
   struct tm tm;
-  static __thread long tid = 0;
+  static GPR_THREAD_LOCAL(long) tid(0);
   if (tid == 0) tid = sys_gettid();
 
   timer = static_cast<time_t>(now.tv_sec);

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

@@ -20,18 +20,21 @@
 
 #ifdef GPR_POSIX_LOG
 
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include <inttypes.h>
 #include <pthread.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
+
 #include <string>
 
 #include "absl/strings/str_format.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 #include "src/core/lib/gprpp/examine_stack.h"
 
 int gpr_should_log_stacktrace(gpr_log_severity severity);

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

@@ -89,7 +89,7 @@ static dump_out dump_out_create(void) {
 
 static void dump_out_append(dump_out* out, char c) {
   if (out->length == out->capacity) {
-    out->capacity = GPR_MAX(8, 2 * out->capacity);
+    out->capacity = std::max(size_t(8), 2 * out->capacity);
     out->data = static_cast<char*>(gpr_realloc(out->data, out->capacity));
   }
   out->data[out->length++] = c;
@@ -290,7 +290,7 @@ static void add_string_to_split(const char* beg, const char* end, char*** strs,
   memcpy(out, beg, static_cast<size_t>(end - beg));
   out[end - beg] = 0;
   if (*nstrs == *capstrs) {
-    *capstrs = GPR_MAX(8, 2 * *capstrs);
+    *capstrs = std::max(size_t(8), 2 * *capstrs);
     *strs = static_cast<char**>(gpr_realloc(*strs, sizeof(*strs) * *capstrs));
   }
   (*strs)[*nstrs] = out;

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

@@ -21,13 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/impl/codegen/gpr_types.h>
-
 #include <stdbool.h>
 #include <stddef.h>
 
 #include <string>
 
+#include <grpc/impl/codegen/gpr_types.h>
+
 /* String utility functions */
 
 /* Flags for gpr_dump function. */

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

@@ -20,12 +20,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <assert.h>
+
 #include <grpc/support/atm.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 
-#include <assert.h>
-
 /* Number of mutexes to allocate for events, to avoid lock contention.
    Should be a prime. */
 enum { event_sync_partitions = 31 };

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

@@ -20,20 +20,21 @@
 
 #if defined(GPR_ABSEIL_SYNC) && !defined(GPR_CUSTOM_SYNC)
 
-#include <grpc/support/alloc.h>
-
 #include <errno.h>
-#include <grpc/support/log.h>
-#include <grpc/support/sync.h>
-#include <grpc/support/time.h>
 #include <time.h>
-#include "src/core/lib/profiling/timers.h"
 
 #include "absl/base/call_once.h"
 #include "absl/synchronization/mutex.h"
 #include "absl/time/clock.h"
 #include "absl/time/time.h"
 
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#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;

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

@@ -21,14 +21,14 @@
 #if defined(GPR_POSIX_SYNC) && !defined(GPR_ABSEIL_SYNC) && \
     !defined(GPR_CUSTOM_SYNC)
 
+#include <errno.h>
+#include <time.h>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
-#include <errno.h>
-#include <time.h>
-
 #include "src/core/lib/profiling/timers.h"
 
 #ifdef GPR_LOW_LEVEL_COUNTERS

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

@@ -20,12 +20,13 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include <limits.h>
 #include <stdio.h>
 #include <string.h>
 
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 int gpr_time_cmp(gpr_timespec a, gpr_timespec b) {
   int cmp = (a.tv_sec > b.tv_sec) - (a.tv_sec < b.tv_sec);
   GPR_ASSERT(a.clock_type == b.clock_type);

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

@@ -22,12 +22,13 @@
 
 #ifdef GPR_WINDOWS_TIME
 
-#include <grpc/support/log.h>
-#include <grpc/support/time.h>
 #include <limits.h>
 #include <process.h>
 #include <sys/timeb.h>
 
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
 #include "src/core/lib/gpr/time_precise.h"
 
 static LARGE_INTEGER g_start_time;

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

@@ -21,52 +21,137 @@
 
 #include <grpc/support/port_platform.h>
 
-/** Thread local storage.
-
-   A minimal wrapper that should be implementable across many compilers,
-   and implementable efficiently across most modern compilers.
-
-   Thread locals have type intptr_t.
-
-   Declaring a thread local variable 'foo':
-     GPR_TLS_DECL(foo);
-   Thread locals always have static scope.
-
-   Declaring a thread local class variable 'foo':
-     GPR_TLS_CLASS_DECL(foo);
-
-   Defining the thread local class variable:
-     GPR_TLS_CLASS_DEF(foo);
-
-   Initializing a thread local (must be done at library initialization
-   time):
-     gpr_tls_init(&foo);
+#include <type_traits>
 
-   Destroying a thread local:
-     gpr_tls_destroy(&foo);
-
-   Setting a thread local (returns new_value):
-     gpr_tls_set(&foo, new_value);
+/** Thread local storage.
 
-   Accessing a thread local:
-     current_value = gpr_tls_get(&foo);
+   Usage is the same as C++ thread_local. Declaring a thread local:
+     static GPR_THREAD_LOCAL(uint32_t) foo;
 
    ALL functions here may be implemented as macros. */
 
-#ifdef GPR_STDCPP_TLS
-#include "src/core/lib/gpr/tls_stdcpp.h"
-#endif
-
-#ifdef GPR_GCC_TLS
-#include "src/core/lib/gpr/tls_gcc.h"
-#endif
-
-#ifdef GPR_MSVC_TLS
-#include "src/core/lib/gpr/tls_msvc.h"
-#endif
+namespace grpc_core {
+
+// This class is never instantiated. It exists to statically ensure that all
+// TLS usage is compatible with the most restrictive implementation, allowing
+// developers to write correct code regardless of the platform they develop on.
+template <typename T>
+class TlsTypeConstrainer {
+  static_assert(std::is_trivial<T>::value,
+                "TLS support is limited to trivial types");
+
+ public:
+  using Type = T;
+};
+
+}  // namespace grpc_core
+
+#if defined(GPR_PTHREAD_TLS)
+
+#include <pthread.h>
+
+#include <array>
+#include <cstring>
+
+#include <grpc/support/log.h> /* for GPR_ASSERT */
+
+namespace grpc_core {
+
+template <typename T>
+class PthreadTlsImpl : TlsTypeConstrainer<T> {
+ public:
+  PthreadTlsImpl(const PthreadTlsImpl&) = delete;
+  PthreadTlsImpl& operator=(const PthreadTlsImpl&) = delete;
+
+  // Achtung! This class emulates C++ `thread_local` using pthread keys. Each
+  // instance of this class is a stand in for a C++ `thread_local`. Think of
+  // each `thread_local` as a *global* pthread_key_t and a type tag. An
+  // important consequence of this is that the lifetime of a `pthread_key_t`
+  // is precisely the lifetime of an instance of this class. To understand why
+  // this is, consider the following scenario given a fictional implementation
+  // of this class which creates and destroys its `pthread_key_t` each time
+  // a given block of code runs (all actions take place on a single thread):
+  //
+  // - instance 1 (type tag = T*) is initialized, is assigned `pthread_key_t` 1
+  // - instance 2 (type tag = int) is initialized, is assigned `pthread_key_t` 2
+  // - instances 1 and 2 store and retrieve values; all is well
+  // - instances 1 and 2 are de-initialized; their keys are released to the pool
+  //
+  // - another run commences
+  // - instance 1 receives key 2
+  // - a value is read from instance 1, it observes a value of type int, but
+  //   interprets it as T*; undefined behavior, kaboom
+  //
+  // To properly ensure these invariants are upheld the `pthread_key_t` must be
+  // `const`, which means it can only be released in the destructor. This is a
+  // a violation of the style guide, since these objects are always static (see
+  // footnote) but this code is used in sufficiently narrow circumstances to
+  // justify the deviation.
+  //
+  // https://google.github.io/styleguide/cppguide.html#Static_and_Global_Variables
+  PthreadTlsImpl()
+      : keys_([]() {
+          typename std::remove_const<decltype(PthreadTlsImpl::keys_)>::type
+              keys;
+          for (pthread_key_t& key : keys) {
+            GPR_ASSERT(0 == pthread_key_create(&key, nullptr));
+          }
+          return keys;
+        }()) {}
+  PthreadTlsImpl(T t) : PthreadTlsImpl() { *this = t; }
+  ~PthreadTlsImpl() {
+    for (pthread_key_t key : keys_) {
+      GPR_ASSERT(0 == pthread_key_delete(key));
+    }
+  }
+
+  operator T() const {
+    T t;
+    char* dst = reinterpret_cast<char*>(&t);
+    for (pthread_key_t key : keys_) {
+      uintptr_t src = uintptr_t(pthread_getspecific(key));
+      size_t remaining = reinterpret_cast<char*>(&t + 1) - dst;
+      size_t step = std::min(sizeof(src), remaining);
+      memcpy(dst, &src, step);
+      dst += step;
+    }
+    return t;
+  }
+
+  T operator->() const {
+    static_assert(std::is_pointer<T>::value,
+                  "operator-> only usable on pointers");
+    return this->operator T();
+  }
+
+  T operator=(T t) {
+    char* src = reinterpret_cast<char*>(&t);
+    for (pthread_key_t key : keys_) {
+      uintptr_t dst;
+      size_t remaining = reinterpret_cast<char*>(&t + 1) - src;
+      size_t step = std::min(sizeof(dst), remaining);
+      memcpy(&dst, src, step);
+      GPR_ASSERT(0 == pthread_setspecific(key, reinterpret_cast<void*>(dst)));
+      src += step;
+    }
+    return t;
+  }
+
+ private:
+  const std::array<pthread_key_t,
+                   (sizeof(T) + sizeof(void*) - 1) / sizeof(void*)>
+      keys_;
+};
+
+}  // namespace grpc_core
+
+#define GPR_THREAD_LOCAL(type) grpc_core::PthreadTlsImpl<type>
+
+#else
+
+#define GPR_THREAD_LOCAL(type) \
+  thread_local typename grpc_core::TlsTypeConstrainer<type>::Type
 
-#ifdef GPR_PTHREAD_TLS
-#include "src/core/lib/gpr/tls_pthread.h"
 #endif
 
 #endif /* GRPC_CORE_LIB_GPR_TLS_H */

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

@@ -20,8 +20,6 @@
 
 #ifdef GPR_POSIX_TMPFILE
 
-#include "src/core/lib/gpr/tmpfile.h"
-
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
@@ -32,6 +30,7 @@
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gpr/tmpfile.h"
 
 FILE* gpr_tmpfile(const char* prefix, char** tmp_filename) {
   FILE* result = nullptr;

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

@@ -19,48 +19,95 @@
 #ifndef GRPC_CORE_LIB_GPR_USEFUL_H
 #define GRPC_CORE_LIB_GPR_USEFUL_H
 
-/** useful macros that don't belong anywhere else */
+#include <grpc/support/port_platform.h>
+
+#include <cstddef>
+
+/** useful utilities that don't belong anywhere else */
+
+namespace grpc_core {
+
+template <typename T>
+T Clamp(T val, T min, T max) {
+  if (val < min) return min;
+  if (max < val) return max;
+  return val;
+}
 
-#define GPR_MIN(a, b) ((a) < (b) ? (a) : (b))
-#define GPR_MAX(a, b) ((a) > (b) ? (a) : (b))
-#define GPR_CLAMP(a, min, max) ((a) < (min) ? (min) : (a) > (max) ? (max) : (a))
 /** rotl, rotr assume x is unsigned */
-#define GPR_ROTL(x, n) (((x) << (n)) | ((x) >> (sizeof(x) * 8 - (n))))
-#define GPR_ROTR(x, n) (((x) >> (n)) | ((x) << (sizeof(x) * 8 - (n))))
+template <typename T>
+constexpr T RotateLeft(T x, T n) {
+  return ((x << n) | (x >> (sizeof(x) * 8 - n)));
+}
+template <typename T>
+constexpr T RotateRight(T x, T n) {
+  return ((x >> n) | (x << (sizeof(x) * 8 - n)));
+}
 
-#define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))
+// Set the n-th bit of i
+template <typename T>
+T SetBit(T* i, size_t n) {
+  return *i |= (T(1) << n);
+}
+
+// Clear the n-th bit of i
+template <typename T>
+T ClearBit(T* i, size_t n) {
+  return *i &= ~(T(1) << n);
+}
 
-#define GPR_SWAP(type, a, b) \
-  do {                       \
-    type x = a;              \
-    (a) = b;                 \
-    (b) = x;                 \
-  } while (0)
+// Get the n-th bit of i
+template <typename T>
+bool GetBit(T i, size_t n) {
+  return (i & (T(1) << n)) != 0;
+}
 
-/** Set the \a n-th bit of \a i (a mutable pointer). */
-#define GPR_BITSET(i, n) ((*(i)) |= (1u << (n)))
+namespace useful_detail {
+inline constexpr uint32_t HexdigitBitcount(uint32_t x) {
+  return (x - ((x >> 1) & 0x77777777) - ((x >> 2) & 0x33333333) -
+          ((x >> 3) & 0x11111111));
+}
+}  // namespace useful_detail
 
-/** Clear the \a n-th bit of \a i (a mutable pointer). */
-#define GPR_BITCLEAR(i, n) ((*(i)) &= ~(1u << (n)))
+inline constexpr uint32_t BitCount(uint32_t i) {
+  return (((useful_detail::HexdigitBitcount(i) +
+            (useful_detail::HexdigitBitcount(i) >> 4)) &
+           0x0f0f0f0f) %
+          255);
+}
 
-/** Get the \a n-th bit of \a i */
-#define GPR_BITGET(i, n) (((i) & (1u << (n))) != 0)
+inline constexpr uint32_t BitCount(uint64_t i) {
+  return BitCount(uint32_t(i)) + BitCount(uint32_t(i >> 32));
+}
 
-#define GPR_INTERNAL_HEXDIGIT_BITCOUNT(x)                        \
-  ((x) - (((x) >> 1) & 0x77777777) - (((x) >> 2) & 0x33333333) - \
-   (((x) >> 3) & 0x11111111))
+inline constexpr uint32_t BitCount(uint16_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(uint8_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(int64_t i) { return BitCount(uint64_t(i)); }
+inline constexpr uint32_t BitCount(int32_t i) { return BitCount(uint32_t(i)); }
+inline constexpr uint32_t BitCount(int16_t i) { return BitCount(uint16_t(i)); }
+inline constexpr uint32_t BitCount(int8_t i) { return BitCount(uint8_t(i)); }
 
-/** Returns number of bits set in bitset \a i */
-#define GPR_BITCOUNT(i)                          \
-  (((GPR_INTERNAL_HEXDIGIT_BITCOUNT(i) +         \
-     (GPR_INTERNAL_HEXDIGIT_BITCOUNT(i) >> 4)) & \
-    0x0f0f0f0f) %                                \
-   255)
+// This function uses operator< to implement a qsort-style comparison, whereby:
+// if a is smaller than b, a number smaller than 0 is returned.
+// if a is bigger than b, a number greater than 0 is returned.
+// if a is neither smaller nor bigger than b, 0 is returned.
+template <typename T>
+int QsortCompare(const T& a, const T& b) {
+  if (a < b) return -1;
+  if (b < a) return 1;
+  return 0;
+}
 
-#define GPR_ICMP(a, b) ((a) < (b) ? -1 : ((a) > (b) ? 1 : 0))
+template <typename T>
+constexpr size_t HashPointer(T* p, size_t range) {
+  return (((reinterpret_cast<size_t>(p)) >> 4) ^
+          ((reinterpret_cast<size_t>(p)) >> 9) ^
+          ((reinterpret_cast<size_t>(p)) >> 14)) %
+         range;
+}
 
-#define GPR_HASH_POINTER(x, range)                                         \
-  (((((size_t)(x)) >> 4) ^ (((size_t)(x)) >> 9) ^ (((size_t)(x)) >> 14)) % \
-   (range))
+}  // namespace grpc_core
+
+#define GPR_ARRAY_SIZE(array) (sizeof(array) / sizeof(*(array)))
 
 #endif /* GRPC_CORE_LIB_GPR_USEFUL_H */

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

@@ -21,6 +21,7 @@
 #include "src/core/lib/gprpp/arena.h"
 
 #include <string.h>
+
 #include <new>
 
 #include <grpc/support/alloc.h>
@@ -75,7 +76,7 @@ std::pair<Arena*, void*> Arena::CreateWithAlloc(size_t initial_size,
 }
 
 size_t Arena::Destroy() {
-  size_t size = total_used_.Load(MemoryOrder::RELAXED);
+  size_t size = total_used_.load(std::memory_order_relaxed);
   this->~Arena();
   gpr_free_aligned(this);
   return size;

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

@@ -27,6 +27,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stddef.h>
+
+#include <atomic>
+#include <memory>
 #include <new>
 #include <utility>
 
@@ -35,9 +39,6 @@
 
 #include "src/core/lib/gpr/alloc.h"
 #include "src/core/lib/gpr/spinlock.h"
-#include "src/core/lib/gprpp/atomic.h"
-
-#include <stddef.h>
 
 namespace grpc_core {
 
@@ -59,7 +60,7 @@ class Arena {
     static constexpr size_t base_size =
         GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(Arena));
     size = GPR_ROUND_UP_TO_ALIGNMENT_SIZE(size);
-    size_t begin = total_used_.FetchAdd(size, MemoryOrder::RELAXED);
+    size_t begin = total_used_.fetch_add(size, std::memory_order_relaxed);
     if (begin + size <= initial_zone_size_) {
       return reinterpret_cast<char*>(this) + base_size + begin;
     } else {
@@ -105,7 +106,7 @@ class Arena {
 
   // Keep track of the total used size. We use this in our call sizing
   // hysteresis.
-  Atomic<size_t> total_used_;
+  std::atomic<size_t> total_used_{0};
   const size_t initial_zone_size_;
   gpr_spinlock arena_growth_spinlock_ = GPR_SPINLOCK_STATIC_INITIALIZER;
   // If the initial arena allocation wasn't enough, we allocate additional zones
@@ -116,6 +117,15 @@ class Arena {
   Zone* last_zone_ = nullptr;
 };
 
+// Smart pointer for arenas when the final size is not required.
+struct ScopedArenaDeleter {
+  void operator()(Arena* arena) { arena->Destroy(); }
+};
+using ScopedArenaPtr = std::unique_ptr<Arena, ScopedArenaDeleter>;
+inline ScopedArenaPtr MakeScopedArena(size_t initial_size) {
+  return ScopedArenaPtr(Arena::Create(initial_size));
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_ARENA_H */

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

@@ -0,0 +1,47 @@
+/*
+ *
+ * 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_GPRPP_ATOMIC_UTILS_H
+#define GRPC_CORE_LIB_GPRPP_ATOMIC_UTILS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+
+namespace grpc_core {
+
+// Atomically increment a counter only if the counter value is not zero.
+// Returns true if increment took place; false if counter is zero.
+template <typename T>
+inline bool IncrementIfNonzero(std::atomic<T>* p) {
+  T count = p->load(std::memory_order_acquire);
+  do {
+    // If zero, we are done (without an increment). If not, we must do a CAS
+    // to maintain the contract: do not increment the counter if it is already
+    // zero
+    if (count == 0) {
+      return false;
+    }
+  } while (!p->compare_exchange_weak(
+      count, count + 1, std::memory_order_acq_rel, std::memory_order_acquire));
+  return true;
+}
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_UTILS_H */