grpc 1.19.0 → 1.20.0.pre1

data/src/core/lib/compression/compression_internal.cc

@@ -32,7 +32,7 @@
 /* Interfaces related to MD */
 
 grpc_message_compression_algorithm
-grpc_message_compression_algorithm_from_slice(grpc_slice str) {
+grpc_message_compression_algorithm_from_slice(const grpc_slice& str) {
   if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY))
     return GRPC_MESSAGE_COMPRESS_NONE;
   if (grpc_slice_eq(str, GRPC_MDSTR_DEFLATE))
@@ -42,7 +42,7 @@ grpc_message_compression_algorithm_from_slice(grpc_slice str) {
 }
 
 grpc_stream_compression_algorithm grpc_stream_compression_algorithm_from_slice(
-    grpc_slice str) {
+    const grpc_slice& str) {
   if (grpc_slice_eq(str, GRPC_MDSTR_IDENTITY)) return GRPC_STREAM_COMPRESS_NONE;
   if (grpc_slice_eq(str, GRPC_MDSTR_GZIP)) return GRPC_STREAM_COMPRESS_GZIP;
   return GRPC_STREAM_COMPRESS_ALGORITHMS_COUNT;

data/src/core/lib/compression/stream_compression_gzip.cc

@@ -60,7 +60,7 @@ static bool gzip_flate(grpc_stream_compression_context_gzip* ctx,
       if (r < 0 && r != Z_BUF_ERROR) {
         gpr_log(GPR_ERROR, "zlib error (%d)", r);
         grpc_slice_unref_internal(slice_out);
-
+        grpc_slice_unref_internal(slice);
         return false;
       } else if (r == Z_STREAM_END && ctx->flate == inflate) {
         eoc = true;

data/src/core/lib/debug/trace.h

@@ -53,7 +53,8 @@ void grpc_tracer_enable_flag(grpc_core::TraceFlag* flag);
 class TraceFlag {
  public:
   TraceFlag(bool default_enabled, const char* name);
-  // This needs to be trivially destructible as it is used as global variable.
+  // TraceFlag needs to be trivially destructible since it is used as global
+  // variable.
   ~TraceFlag() = default;
 
   const char* name() const { return name_; }

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

@@ -25,7 +25,6 @@
 #include <string.h>
 #include <unistd.h>
 
-#include <grpc/support/alloc.h>
 #include <grpc/support/cpu.h>
 #include <grpc/support/log.h>
 #include <grpc/support/sync.h>
@@ -52,7 +51,7 @@ unsigned gpr_cpu_num_cores(void) {
 
 static void delete_thread_id(void* value) {
   if (value) {
-    gpr_free(value);
+    free(value);
   }
 }
 
@@ -71,7 +70,10 @@ unsigned gpr_cpu_current_cpu(void) {
   unsigned int* thread_id =
       static_cast<unsigned int*>(pthread_getspecific(thread_id_key));
   if (thread_id == nullptr) {
-    thread_id = static_cast<unsigned int*>(gpr_malloc(sizeof(unsigned int)));
+    // Note we cannot use gpr_malloc here because this allocation can happen in
+    // a main thread and will only be free'd when the main thread exits, which
+    // will cause our internal memory counters to believe it is a leak.
+    thread_id = static_cast<unsigned int*>(malloc(sizeof(unsigned int)));
     pthread_setspecific(thread_id_key, thread_id);
   }
 

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

@@ -18,6 +18,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <grpc/support/alloc.h>
+
 #ifdef GPR_POSIX_SYNC
 
 #include <errno.h>
@@ -72,27 +74,53 @@ 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);
+  mu->leak_checker = static_cast<int*>(malloc(sizeof(*mu->leak_checker)));
+  GPR_ASSERT(mu->leak_checker != nullptr);
+#else
   GPR_ASSERT(pthread_mutex_init(mu, nullptr) == 0);
+#endif
 }
 
-void gpr_mu_destroy(gpr_mu* mu) { GPR_ASSERT(pthread_mutex_destroy(mu) == 0); }
+void gpr_mu_destroy(gpr_mu* mu) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_mutex_destroy(&mu->mutex) == 0);
+  free(mu->leak_checker);
+#else
+  GPR_ASSERT(pthread_mutex_destroy(mu) == 0);
+#endif
+}
 
 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
   GPR_ASSERT(pthread_mutex_lock(mu) == 0);
+#endif
 }
 
 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
   GPR_ASSERT(pthread_mutex_unlock(mu) == 0);
+#endif
 }
 
 int gpr_mu_trylock(gpr_mu* mu) {
   GPR_TIMER_SCOPE("gpr_mu_trylock", 0);
-  int err = pthread_mutex_trylock(mu);
+  int err = 0;
+#ifdef GRPC_ASAN_ENABLED
+  err = pthread_mutex_trylock(&mu->mutex);
+#else
+  err = pthread_mutex_trylock(mu);
+#endif
   GPR_ASSERT(err == 0 || err == EBUSY);
   return err == 0;
 }
@@ -105,10 +133,24 @@ void gpr_cv_init(gpr_cv* cv) {
 #if GPR_LINUX
   GPR_ASSERT(pthread_condattr_setclock(&attr, CLOCK_MONOTONIC) == 0);
 #endif  // GPR_LINUX
+
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_init(&cv->cond_var, &attr) == 0);
+  cv->leak_checker = static_cast<int*>(malloc(sizeof(*cv->leak_checker)));
+  GPR_ASSERT(cv->leak_checker != nullptr);
+#else
   GPR_ASSERT(pthread_cond_init(cv, &attr) == 0);
+#endif
 }
 
-void gpr_cv_destroy(gpr_cv* cv) { GPR_ASSERT(pthread_cond_destroy(cv) == 0); }
+void gpr_cv_destroy(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_destroy(&cv->cond_var) == 0);
+  free(cv->leak_checker);
+#else
+  GPR_ASSERT(pthread_cond_destroy(cv) == 0);
+#endif
+}
 
 // For debug of the timer manager crash only.
 // TODO (mxyan): remove after bug is fixed.
@@ -169,7 +211,11 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
 #endif
   if (gpr_time_cmp(abs_deadline, gpr_inf_future(abs_deadline.clock_type)) ==
       0) {
+#ifdef GRPC_ASAN_ENABLED
+    err = pthread_cond_wait(&cv->cond_var, &mu->mutex);
+#else
     err = pthread_cond_wait(cv, mu);
+#endif
   } else {
     struct timespec abs_deadline_ts;
 #if GPR_LINUX
@@ -181,7 +227,12 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
 #endif  // GPR_LINUX
     abs_deadline_ts.tv_sec = static_cast<time_t>(abs_deadline.tv_sec);
     abs_deadline_ts.tv_nsec = abs_deadline.tv_nsec;
+#ifdef GRPC_ASAN_ENABLED
+    err = pthread_cond_timedwait(&cv->cond_var, &mu->mutex, &abs_deadline_ts);
+#else
     err = pthread_cond_timedwait(cv, mu, &abs_deadline_ts);
+#endif
+
 #ifdef GRPC_DEBUG_TIMER_MANAGER
     // For debug of the timer manager crash only.
     // TODO (mxyan): remove after bug is fixed.
@@ -226,10 +277,20 @@ int gpr_cv_wait(gpr_cv* cv, gpr_mu* mu, gpr_timespec abs_deadline) {
   return err == ETIMEDOUT;
 }
 
-void gpr_cv_signal(gpr_cv* cv) { GPR_ASSERT(pthread_cond_signal(cv) == 0); }
+void gpr_cv_signal(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_signal(&cv->cond_var) == 0);
+#else
+  GPR_ASSERT(pthread_cond_signal(cv) == 0);
+#endif
+}
 
 void gpr_cv_broadcast(gpr_cv* cv) {
+#ifdef GRPC_ASAN_ENABLED
+  GPR_ASSERT(pthread_cond_broadcast(&cv->cond_var) == 0);
+#else
   GPR_ASSERT(pthread_cond_broadcast(cv) == 0);
+#endif
 }
 
 /*----------------------------------------*/

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

@@ -21,10 +21,80 @@
 
 #include <grpc/support/port_platform.h>
 
-#ifdef GPR_HAS_CXX11_ATOMIC
-#include "src/core/lib/gprpp/atomic_with_std.h"
-#else
-#include "src/core/lib/gprpp/atomic_with_atm.h"
-#endif
+#include <atomic>
+
+#include <grpc/support/atm.h>
+
+namespace grpc_core {
+
+enum class MemoryOrder {
+  RELAXED = std::memory_order_relaxed,
+  CONSUME = std::memory_order_consume,
+  ACQUIRE = std::memory_order_acquire,
+  RELEASE = std::memory_order_release,
+  ACQ_REL = std::memory_order_acq_rel,
+  SEQ_CST = std::memory_order_seq_cst
+};
+
+template <typename T>
+class Atomic {
+ public:
+  explicit Atomic(T val = T()) : storage_(val) {}
+
+  T Load(MemoryOrder order) const {
+    return storage_.load(static_cast<std::memory_order>(order));
+  }
+
+  void Store(T val, MemoryOrder order) {
+    storage_.store(val, static_cast<std::memory_order>(order));
+  }
+
+  bool CompareExchangeWeak(T* expected, T desired, MemoryOrder success,
+                           MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(storage_.compare_exchange_weak(
+        *expected, desired, static_cast<std::memory_order>(success),
+        static_cast<std::memory_order>(failure)));
+  }
+
+  bool CompareExchangeStrong(T* expected, T desired, MemoryOrder success,
+                             MemoryOrder failure) {
+    return GPR_ATM_INC_CAS_THEN(storage_.compare_exchange_strong(
+        *expected, desired, static_cast<std::memory_order>(success),
+        static_cast<std::memory_order>(failure)));
+  }
+
+  template <typename Arg>
+  T FetchAdd(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_add(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  template <typename Arg>
+  T FetchSub(Arg arg, MemoryOrder order = MemoryOrder::SEQ_CST) {
+    return GPR_ATM_INC_ADD_THEN(storage_.fetch_sub(
+        static_cast<Arg>(arg), static_cast<std::memory_order>(order)));
+  }
+
+  // Atomically increment a counter only if the counter value is not zero.
+  // Returns true if increment took place; false if counter is zero.
+  bool IncrementIfNonzero(MemoryOrder load_order = MemoryOrder::ACQUIRE) {
+    T count = storage_.load(static_cast<std::memory_order>(load_order));
+    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 (!CompareExchangeWeak(&count, count + 1, MemoryOrder::ACQ_REL,
+                                  load_order));
+    return true;
+  }
+
+ private:
+  std::atomic<T> storage_;
+};
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_ATOMIC_H */

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

@@ -160,8 +160,6 @@ void Fork::GlobalInit() {
   if (!override_enabled_) {
 #ifdef GRPC_ENABLE_FORK_SUPPORT
     support_enabled_ = true;
-#else
-    support_enabled_ = false;
 #endif
     bool env_var_set = false;
     char* env = gpr_getenv("GRPC_ENABLE_FORK_SUPPORT");

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

@@ -94,8 +94,9 @@ class InternallyRefCounted : public Orphanable {
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
   template <typename TraceFlagT = TraceFlag>
-  explicit InternallyRefCounted(TraceFlagT* trace_flag = nullptr)
-      : refs_(1, trace_flag) {}
+  explicit InternallyRefCounted(TraceFlagT* trace_flag = nullptr,
+                                intptr_t initial_refcount = 1)
+      : refs_(initial_refcount, trace_flag) {}
   virtual ~InternallyRefCounted() = default;
 
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {

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

@@ -31,6 +31,7 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/abstract.h"
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -88,9 +89,7 @@ class RefCount {
   }
 
   // Increases the ref-count by `n`.
-  void Ref(Value n = 1) {
-    GPR_ATM_INC_ADD_THEN(value_.fetch_add(n, std::memory_order_relaxed));
-  }
+  void Ref(Value n = 1) { value_.FetchAdd(n, MemoryOrder::RELAXED); }
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
     if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
@@ -106,8 +105,7 @@ class RefCount {
   // Similar to Ref() with an assert on the ref-count being non-zero.
   void RefNonZero() {
 #ifndef NDEBUG
-    const Value prior =
-        GPR_ATM_INC_ADD_THEN(value_.fetch_add(1, std::memory_order_relaxed));
+    const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
     assert(prior > 0);
 #else
     Ref();
@@ -127,8 +125,7 @@ class RefCount {
 
   // Decrements the ref-count and returns true if the ref-count reaches 0.
   bool Unref() {
-    const Value prior =
-        GPR_ATM_INC_ADD_THEN(value_.fetch_sub(1, std::memory_order_acq_rel));
+    const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
     GPR_DEBUG_ASSERT(prior > 0);
     return prior == 1;
   }
@@ -145,12 +142,12 @@ class RefCount {
   }
 
  private:
-  Value get() const { return value_.load(std::memory_order_relaxed); }
+  Value get() const { return value_.Load(MemoryOrder::RELAXED); }
 
 #ifndef NDEBUG
   TraceFlag* trace_flag_;
 #endif
-  std::atomic<Value> value_;
+  Atomic<Value> value_;
 };
 
 // A base class for reference-counted objects.
@@ -221,8 +218,9 @@ class RefCounted : public Impl {
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
   template <typename TraceFlagT = TraceFlag>
-  explicit RefCounted(TraceFlagT* trace_flag = nullptr)
-      : refs_(1, trace_flag) {}
+  explicit RefCounted(TraceFlagT* trace_flag = nullptr,
+                      intptr_t initial_refcount = 1)
+      : refs_(initial_refcount, trace_flag) {}
 
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
   ~RefCounted() = default;

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

@@ -47,6 +47,27 @@ class ThreadInternalsInterface {
 
 class Thread {
  public:
+  class Options {
+   public:
+    Options() : joinable_(true), tracked_(true) {}
+    /// Set whether the thread is joinable or detached.
+    Options& set_joinable(bool joinable) {
+      joinable_ = joinable;
+      return *this;
+    }
+    bool joinable() const { return joinable_; }
+
+    /// Set whether the thread is tracked for fork support.
+    Options& set_tracked(bool tracked) {
+      tracked_ = tracked;
+      return *this;
+    }
+    bool tracked() const { return tracked_; }
+
+   private:
+    bool joinable_;
+    bool tracked_;
+  };
   /// Default constructor only to allow use in structs that lack constructors
   /// Does not produce a validly-constructed thread; must later
   /// use placement new to construct a real thread. Does not init mu_ and cv_
@@ -57,14 +78,17 @@ class Thread {
   /// with argument \a arg once it is started.
   /// The optional \a success argument indicates whether the thread
   /// is successfully created.
+  /// The optional \a options can be used to set the thread detachable.
   Thread(const char* thd_name, void (*thd_body)(void* arg), void* arg,
-         bool* success = nullptr);
+         bool* success = nullptr, const Options& options = Options());
 
   /// Move constructor for thread. After this is called, the other thread
   /// no longer represents a living thread object
-  Thread(Thread&& other) : state_(other.state_), impl_(other.impl_) {
+  Thread(Thread&& other)
+      : state_(other.state_), impl_(other.impl_), options_(other.options_) {
     other.state_ = MOVED;
     other.impl_ = nullptr;
+    other.options_ = Options();
   }
 
   /// Move assignment operator for thread. After this is called, the other
@@ -79,27 +103,37 @@ class Thread {
       // assert it for the time being.
       state_ = other.state_;
       impl_ = other.impl_;
+      options_ = other.options_;
       other.state_ = MOVED;
       other.impl_ = nullptr;
+      other.options_ = Options();
     }
     return *this;
   }
 
   /// The destructor is strictly optional; either the thread never came to life
-  /// and the constructor itself killed it or it has already been joined and
-  /// the Join function kills it. The destructor shouldn't have to do anything.
-  ~Thread() { GPR_ASSERT(impl_ == nullptr); }
+  /// and the constructor itself killed it, or it has already been joined and
+  /// the Join function kills it, or it was detached (non-joinable) and it has
+  /// run to completion and is now killing itself. The destructor shouldn't have
+  /// to do anything.
+  ~Thread() { GPR_ASSERT(!options_.joinable() || impl_ == nullptr); }
 
   void Start() {
     if (impl_ != nullptr) {
       GPR_ASSERT(state_ == ALIVE);
       state_ = STARTED;
       impl_->Start();
+      // If the Thread is not joinable, then the impl_ will cause the deletion
+      // of this Thread object when the thread function completes. Since no
+      // other operation is allowed to a detached thread after Start, there is
+      // no need to change the value of the impl_ or state_ . The next operation
+      // on this object will be the deletion, which will trigger the destructor.
     } else {
       GPR_ASSERT(state_ == FAILED);
     }
-  };
+  }
 
+  // It is only legal to call Join if the Thread is created as joinable.
   void Join() {
     if (impl_ != nullptr) {
       impl_->Join();
@@ -109,7 +143,7 @@ class Thread {
     } else {
       GPR_ASSERT(state_ == FAILED);
     }
-  };
+  }
 
  private:
   Thread(const Thread&) = delete;
@@ -125,6 +159,7 @@ class Thread {
   enum ThreadState { FAKE, ALIVE, STARTED, DONE, FAILED, MOVED };
   ThreadState state_;
   internal::ThreadInternalsInterface* impl_;
+  Options options_;
 };
 
 }  // namespace grpc_core