grpc 1.32.0 → 1.36.0

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

@@ -0,0 +1,43 @@
+/*
+ *
+ * Copyright 2020 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/gprpp/examine_stack.h"
+
+namespace grpc_core {
+
+gpr_current_stack_trace_func g_current_stack_trace_provider = nullptr;
+
+gpr_current_stack_trace_func GetCurrentStackTraceProvider() {
+  return g_current_stack_trace_provider;
+}
+
+void SetCurrentStackTraceProvider(
+    gpr_current_stack_trace_func current_stack_trace_provider) {
+  g_current_stack_trace_provider = current_stack_trace_provider;
+}
+
+absl::optional<std::string> GetCurrentStackTrace() {
+  if (g_current_stack_trace_provider != nullptr) {
+    return g_current_stack_trace_provider();
+  }
+  return absl::nullopt;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,46 @@
+/*
+ *
+ * Copyright 2020 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_EXAMINE_STACK_H
+#define GRPC_CORE_LIB_GPRPP_EXAMINE_STACK_H
+
+#include <grpc/support/port_platform.h>
+
+#include <functional>
+#include <string>
+
+#include "absl/types/optional.h"
+
+namespace grpc_core {
+
+typedef std::string (*gpr_current_stack_trace_func)();
+
+// Returns a current_stack_trace_provider.
+gpr_current_stack_trace_func GetCurrentStackTraceProvider();
+
+// Sets current_stack_trace_provider which provides a current-stack trace.
+void SetCurrentStackTraceProvider(
+    gpr_current_stack_trace_func current_stack_trace_provider);
+
+// Returns the current stack trace as a string via current_stack_trace_provider
+// If current_stack_trace_provider is not set, it returns absl::nullopt.
+absl::optional<std::string> GetCurrentStackTrace();
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_EXAMINE_STACK_H */

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

@@ -43,7 +43,7 @@
 
 GPR_GLOBAL_CONFIG_DEFINE_BOOL(grpc_enable_fork_support,
                               GRPC_ENABLE_FORK_SUPPORT_DEFAULT,
-                              "Enable folk support");
+                              "Enable fork support");
 
 namespace grpc_core {
 namespace internal {
@@ -54,7 +54,7 @@ namespace internal {
 // When blocked, the exec_ctx_count is 0-indexed.  Note that ExecCtx
 // creation can only be blocked if there is exactly 1 outstanding ExecCtx,
 // meaning that BLOCKED and UNBLOCKED counts partition the integers
-#define UNBLOCKED(n) (n + 2)
+#define UNBLOCKED(n) ((n) + 2)
 #define BLOCKED(n) (n)
 
 class ExecCtxState {

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

@@ -145,7 +145,7 @@ class PolymorphicManualConstructor {
   }
   template <class DerivedType>
   void Init(DerivedType&& x) {
-    FinishInit(new (&space_) DerivedType(std::move(x)));
+    FinishInit(new (&space_) DerivedType(std::forward<DerivedType>(x)));
   }
 
   void Destroy() { get()->~BaseType(); }

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

@@ -86,9 +86,9 @@ bool LockedMultiProducerSingleConsumerQueue::Push(Node* node) {
 
 LockedMultiProducerSingleConsumerQueue::Node*
 LockedMultiProducerSingleConsumerQueue::TryPop() {
-  if (gpr_mu_trylock(mu_.get())) {
+  if (mu_.TryLock()) {
     Node* node = queue_.Pop();
-    gpr_mu_unlock(mu_.get());
+    mu_.Unlock();
     return node;
   }
   return nullptr;

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

@@ -27,7 +27,6 @@
 #include <cinttypes>
 #include <memory>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -85,14 +84,11 @@ class InternallyRefCounted : public Orphanable {
   template <typename T>
   friend class RefCountedPtr;
 
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // 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,
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit InternallyRefCounted(const char* trace = nullptr,
                                 intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace_flag) {}
-  virtual ~InternallyRefCounted() = default;
+      : refs_(initial_refcount, trace) {}
+  ~InternallyRefCounted() override = default;
 
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
     IncrementRefCount();

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

@@ -29,7 +29,6 @@
 #include <cassert>
 #include <cinttypes>
 
-#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
@@ -37,20 +36,6 @@
 
 namespace grpc_core {
 
-// PolymorphicRefCount enforces polymorphic destruction of RefCounted.
-class PolymorphicRefCount {
- public:
-  virtual ~PolymorphicRefCount() = default;
-};
-
-// NonPolymorphicRefCount does not enforce polymorphic destruction of
-// RefCounted. Please refer to grpc_core::RefCounted for more details, and
-// when in doubt use PolymorphicRefCount.
-class NonPolymorphicRefCount {
- public:
-  ~NonPolymorphicRefCount() = default;
-};
-
 // RefCount is a simple atomic ref-count.
 //
 // This is a C++ implementation of gpr_refcount, with inline functions. Due to
@@ -65,21 +50,19 @@ class RefCount {
 
   // `init` is the initial refcount stored in this object.
   //
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // Note: RefCount tracing is only enabled on debug builds, even when a
-  //       TraceFlag is used.
-  template <typename TraceFlagT = TraceFlag>
-  constexpr explicit RefCount(
+  // `trace` is a string to be logged with trace events; if null, no
+  // trace logging will be done.  Tracing is a no-op in non-debug builds.
+  explicit RefCount(
       Value init = 1,
-      TraceFlagT*
+      const char*
 #ifndef NDEBUG
           // Leave unnamed if NDEBUG to avoid unused parameter warning
-          trace_flag
+          trace
 #endif
       = nullptr)
       :
 #ifndef NDEBUG
-        trace_flag_(trace_flag),
+        trace_(trace),
 #endif
         value_(init) {
   }
@@ -88,9 +71,9 @@ class RefCount {
   void Ref(Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + n);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + n);
     }
 #else
     value_.FetchAdd(n, MemoryOrder::RELAXED);
@@ -99,16 +82,15 @@ class RefCount {
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + n, reason);
+              trace_, this, location.file(), location.line(), prior, prior + n,
+              reason);
     }
 #else
     // Use conditionally-important parameters
     (void)location;
     (void)reason;
-
     value_.FetchAdd(n, MemoryOrder::RELAXED);
 #endif
   }
@@ -117,9 +99,9 @@ class RefCount {
   void RefNonZero() {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+    if (trace_ != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p ref %" PRIdPTR " -> %" PRIdPTR, trace_, this,
+              prior, prior + 1);
     }
     assert(prior > 0);
 #else
@@ -129,10 +111,10 @@ class RefCount {
   void RefNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
     assert(prior > 0);
 #else
@@ -145,23 +127,22 @@ class RefCount {
 
   bool RefIfNonZero() {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag_->name(), this, prior, prior + 1);
+              trace_, this, prior, prior + 1);
     }
 #endif
     return value_.IncrementIfNonzero();
   }
   bool RefIfNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+    if (trace_ != nullptr) {
       const Value prior = get();
       gpr_log(GPR_INFO,
-              "%s:%p %s:%d ref_if_non_zero "
-              "%" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              prior, prior + 1, reason);
+              "%s:%p %s:%d ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR " %s",
+              trace_, this, location.file(), location.line(), prior, prior + 1,
+              reason);
     }
 #endif
     // Avoid unused-parameter warnings for debug-only parameters
@@ -174,14 +155,15 @@ class RefCount {
   bool Unref() {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
-      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR,
-              trace_flag->name(), this, prior, prior - 1);
+    if (trace != nullptr) {
+      gpr_log(GPR_INFO, "%s:%p unref %" PRIdPTR " -> %" PRIdPTR, trace, this,
+              prior, prior - 1);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #endif
@@ -190,15 +172,16 @@ class RefCount {
   bool Unref(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
     // Grab a copy of the trace flag before the atomic change, since we
-    // can't safely access it afterwards if we're going to be freed.
-    auto* trace_flag = trace_flag_;
+    // will no longer be holding a ref afterwards and therefore can't
+    // safely access it, since another thread might free us in the interim.
+    auto* trace = trace_;
 #endif
     const Value prior = value_.FetchSub(1, MemoryOrder::ACQ_REL);
 #ifndef NDEBUG
-    if (trace_flag != nullptr && trace_flag->enabled()) {
+    if (trace != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d unref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag->name(), this, location.file(), location.line(), prior,
-              prior - 1, reason);
+              trace, this, location.file(), location.line(), prior, prior - 1,
+              reason);
     }
     GPR_DEBUG_ASSERT(prior > 0);
 #else
@@ -213,14 +196,50 @@ class RefCount {
   Value get() const { return value_.Load(MemoryOrder::RELAXED); }
 
 #ifndef NDEBUG
-  TraceFlag* trace_flag_;
+  const char* trace_;
 #endif
   Atomic<Value> value_;
 };
 
+// PolymorphicRefCount enforces polymorphic destruction of RefCounted.
+class PolymorphicRefCount {
+ public:
+  virtual ~PolymorphicRefCount() = default;
+};
+
+// NonPolymorphicRefCount does not enforce polymorphic destruction of
+// RefCounted. Please refer to grpc_core::RefCounted for more details, and
+// when in doubt use PolymorphicRefCount.
+class NonPolymorphicRefCount {
+ public:
+  ~NonPolymorphicRefCount() = default;
+};
+
+namespace internal {
+template <typename T, bool DoDelete>
+class Delete;
+template <typename T>
+class Delete<T, true> {
+ public:
+  explicit Delete(T* t) { delete t; }
+};
+template <typename T>
+class Delete<T, false> {
+ public:
+  explicit Delete(T* /*t*/) {}
+};
+}  // namespace internal
+
 // A base class for reference-counted objects.
-// New objects should be created via New() and start with a refcount of 1.
-// When the refcount reaches 0, the object will be deleted via delete .
+// New objects should be created via new and start with a refcount of 1.
+// When the refcount reaches 0, the object will be deleted via delete.
+//
+// If DeleteUponUnref is false, deletion will not occur when the ref
+// count reaches 0.  This is useful in cases where all existing objects
+// must be tracked in a registry but the object's entry in the registry
+// cannot be removed from the object's dtor due to synchronization issues.
+// In this case, the registry can be cleaned up later by identifying
+// entries for which RefIfNonZero() returns null.
 //
 // This will commonly be used by CRTP (curiously-recurring template pattern)
 // e.g., class MyClass : public RefCounted<MyClass>
@@ -244,7 +263,8 @@ class RefCount {
 //    Child* ch;
 //    ch->Unref();
 //
-template <typename Child, typename Impl = PolymorphicRefCount>
+template <typename Child, typename Impl = PolymorphicRefCount,
+          bool DeleteUponUnref = true>
 class RefCounted : public Impl {
  public:
   // Note: Depending on the Impl used, this dtor can be implicitly virtual.
@@ -267,18 +287,24 @@ class RefCounted : public Impl {
   // friend of this class.
   void Unref() {
     if (GPR_UNLIKELY(refs_.Unref())) {
-      delete static_cast<Child*>(this);
+      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
     }
   }
   void Unref(const DebugLocation& location, const char* reason) {
     if (GPR_UNLIKELY(refs_.Unref(location, reason))) {
-      delete static_cast<Child*>(this);
+      internal::Delete<Child, DeleteUponUnref>(static_cast<Child*>(this));
     }
   }
 
-  bool RefIfNonZero() { return refs_.RefIfNonZero(); }
-  bool RefIfNonZero(const DebugLocation& location, const char* reason) {
-    return refs_.RefIfNonZero(location, reason);
+  RefCountedPtr<Child> RefIfNonZero() GRPC_MUST_USE_RESULT {
+    return RefCountedPtr<Child>(refs_.RefIfNonZero() ? static_cast<Child*>(this)
+                                                     : nullptr);
+  }
+  RefCountedPtr<Child> RefIfNonZero(const DebugLocation& location,
+                                    const char* reason) GRPC_MUST_USE_RESULT {
+    return RefCountedPtr<Child>(refs_.RefIfNonZero(location, reason)
+                                    ? static_cast<Child*>(this)
+                                    : nullptr);
   }
 
   // Not copyable nor movable.
@@ -286,13 +312,10 @@ class RefCounted : public Impl {
   RefCounted& operator=(const RefCounted&) = delete;
 
  protected:
-  // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
-  // 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,
+  // Note: Tracing is a no-op on non-debug builds.
+  explicit RefCounted(const char* trace = nullptr,
                       intptr_t initial_refcount = 1)
-      : refs_(initial_refcount, trace_flag) {}
+      : refs_(initial_refcount, trace) {}
 
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().