grpc 1.24.0 → 1.25.0.pre1

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

@@ -28,63 +28,52 @@
 #include <memory>
 #include <utility>
 
-// Add this to a class that want to use Delete(), but has a private or
-// protected destructor.
-// Should not be used in new code.
-// TODO(juanlishen): Remove this macro, and instead comment that the public dtor
-// should not be used directly.
-#define GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE         \
-  template <typename _Delete_T, bool _Delete_can_be_null> \
-  friend void ::grpc_core::Delete(_Delete_T*);            \
-  template <typename _Delete_T>                           \
-  friend void ::grpc_core::Delete(_Delete_T*);
-
-// Add this to a class that want to use New(), but has a private or
-// protected constructor.
-// Should not be used in new code.
-// TODO(juanlishen): Remove this macro, and instead comment that the public dtor
-// should not be used directly.
-#define GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW      \
-  template <typename _New_T, typename... _New_Args> \
-  friend _New_T* grpc_core::New(_New_Args&&...);
-
 namespace grpc_core {
 
-// Alternative to new, since we cannot use it (for fear of libstdc++)
+// Alternative to new, to ensure memory allocation being wrapped to gpr_malloc
 template <typename T, typename... Args>
 inline T* New(Args&&... args) {
   void* p = gpr_malloc(sizeof(T));
   return new (p) T(std::forward<Args>(args)...);
 }
 
-// Alternative to delete, since we cannot use it (for fear of libstdc++)
-// We cannot add a default value for can_be_null, because they are used as
-// as friend template methods where we cannot define a default value.
-// Instead we simply define two variants, one with and one without the boolean
-// argument.
-template <typename T, bool can_be_null>
-inline void Delete(T* p) {
-  GPR_DEBUG_ASSERT(can_be_null || p != nullptr);
-  if (can_be_null && p == nullptr) return;
-  p->~T();
-  gpr_free(p);
-}
+// Gets the base pointer of any class, in case of multiple inheritance.
+// Used by Delete and friends.
+template <typename T, bool isPolymorphic>
+struct BasePointerGetter {
+  static void* get(T* p) { return p; }
+};
+
+template <typename T>
+struct BasePointerGetter<T, true> {
+  static void* get(T* p) { return dynamic_cast<void*>(p); }
+};
+
+// Alternative to delete, to ensure memory allocation being wrapped to gpr_free
 template <typename T>
 inline void Delete(T* p) {
-  Delete<T, /*can_be_null=*/true>(p);
+  if (p == nullptr) return;
+  void* basePtr = BasePointerGetter<T, std::is_polymorphic<T>::value>::get(p);
+  p->~T();
+  gpr_free(basePtr);
 }
 
-template <typename T>
 class DefaultDelete {
  public:
+  template <typename T>
   void operator()(T* p) {
-    // std::unique_ptr is gauranteed not to call the deleter
-    // if the pointer is nullptr.
-    Delete<T, /*can_be_null=*/false>(p);
+    // Delete() checks whether the value is null, but std::unique_ptr<> is
+    // guaranteed not to call the deleter if the pointer is nullptr
+    // (i.e., it already does this check for us), and we don't want to
+    // do the check twice.  So, instead of calling Delete() here, we
+    // manually call the object's dtor and free it.
+    void* basePtr = BasePointerGetter<T, std::is_polymorphic<T>::value>::get(p);
+    p->~T();
+    gpr_free(basePtr);
   }
 };
 
-template <typename T, typename Deleter = DefaultDelete<T>>
+template <typename T, typename Deleter = DefaultDelete>
 using UniquePtr = std::unique_ptr<T, Deleter>;
 
 template <typename T, typename... Args>
@@ -110,13 +99,18 @@ class Allocator {
   };
   typedef std::true_type is_always_equal;
 
+  Allocator() = default;
+
+  template <class U>
+  Allocator(const Allocator<U>&) {}
+
   pointer address(reference x) const { return &x; }
   const_pointer address(const_reference x) const { return &x; }
   pointer allocate(std::size_t n,
-                   std::allocator<void>::const_pointer hint = nullptr) {
+                   std::allocator<void>::const_pointer /*hint*/ = nullptr) {
     return static_cast<pointer>(gpr_malloc(n * sizeof(T)));
   }
-  void deallocate(T* p, std::size_t n) { gpr_free(p); }
+  void deallocate(T* p, std::size_t /* n */) { gpr_free(p); }
   size_t max_size() const {
     return std::numeric_limits<size_type>::max() / sizeof(value_type);
   }
@@ -132,6 +126,16 @@ class Allocator {
   }
 };
 
+template <class T, class U>
+bool operator==(Allocator<T> const&, Allocator<U> const&) noexcept {
+  return true;
+}
+
+template <class T, class U>
+bool operator!=(Allocator<T> const& /*x*/, Allocator<U> const& /*y*/) noexcept {
+  return false;
+}
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_GPRPP_MEMORY_H */

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

@@ -0,0 +1,108 @@
+/*
+ *
+ * Copyright 2016 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/mpscq.h"
+
+namespace grpc_core {
+
+//
+// MultiProducerSingleConsumerQueue
+//
+
+bool MultiProducerSingleConsumerQueue::Push(Node* node) {
+  node->next.Store(nullptr, MemoryOrder::RELAXED);
+  Node* prev = head_.Exchange(node, MemoryOrder::ACQ_REL);
+  prev->next.Store(node, MemoryOrder::RELEASE);
+  return prev == &stub_;
+}
+
+MultiProducerSingleConsumerQueue::Node*
+MultiProducerSingleConsumerQueue::Pop() {
+  bool empty;
+  return PopAndCheckEnd(&empty);
+}
+
+MultiProducerSingleConsumerQueue::Node*
+MultiProducerSingleConsumerQueue::PopAndCheckEnd(bool* empty) {
+  Node* tail = tail_;
+  Node* next = tail_->next.Load(MemoryOrder::ACQUIRE);
+  if (tail == &stub_) {
+    // indicates the list is actually (ephemerally) empty
+    if (next == nullptr) {
+      *empty = true;
+      return nullptr;
+    }
+    tail_ = next;
+    tail = next;
+    next = tail->next.Load(MemoryOrder::ACQUIRE);
+  }
+  if (next != nullptr) {
+    *empty = false;
+    tail_ = next;
+    return tail;
+  }
+  Node* head = head_.Load(MemoryOrder::ACQUIRE);
+  if (tail != head) {
+    *empty = false;
+    // indicates a retry is in order: we're still adding
+    return nullptr;
+  }
+  Push(&stub_);
+  next = tail->next.Load(MemoryOrder::ACQUIRE);
+  if (next != nullptr) {
+    *empty = false;
+    tail_ = next;
+    return tail;
+  }
+  // indicates a retry is in order: we're still adding
+  *empty = false;
+  return nullptr;
+}
+
+//
+// LockedMultiProducerSingleConsumerQueue
+//
+
+bool LockedMultiProducerSingleConsumerQueue::Push(Node* node) {
+  return queue_.Push(node);
+}
+
+LockedMultiProducerSingleConsumerQueue::Node*
+LockedMultiProducerSingleConsumerQueue::TryPop() {
+  if (gpr_mu_trylock(mu_.get())) {
+    Node* node = queue_.Pop();
+    gpr_mu_unlock(mu_.get());
+    return node;
+  }
+  return nullptr;
+}
+
+LockedMultiProducerSingleConsumerQueue::Node*
+LockedMultiProducerSingleConsumerQueue::Pop() {
+  MutexLock lock(&mu_);
+  bool empty = false;
+  Node* node;
+  do {
+    node = queue_.PopAndCheckEnd(&empty);
+  } while (node == nullptr && !empty);
+  return node;
+}
+
+}  // namespace grpc_core

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

@@ -0,0 +1,98 @@
+/*
+ *
+ * Copyright 2016 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_MPSCQ_H
+#define GRPC_CORE_LIB_GPRPP_MPSCQ_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/gprpp/atomic.h"
+#include "src/core/lib/gprpp/sync.h"
+
+#include <grpc/support/log.h>
+
+namespace grpc_core {
+
+// Multiple-producer single-consumer lock free queue, based upon the
+// implementation from Dmitry Vyukov here:
+// http://www.1024cores.net/home/lock-free-algorithms/queues/intrusive-mpsc-node-based-queue
+class MultiProducerSingleConsumerQueue {
+ public:
+  // List node.  Application node types can inherit from this.
+  struct Node {
+    Atomic<Node*> next;
+  };
+
+  MultiProducerSingleConsumerQueue() : head_{&stub_}, tail_(&stub_) {}
+  ~MultiProducerSingleConsumerQueue() {
+    GPR_ASSERT(head_.Load(MemoryOrder::RELAXED) == &stub_);
+    GPR_ASSERT(tail_ == &stub_);
+  }
+
+  // Push a node
+  // Thread safe - can be called from multiple threads concurrently
+  // Returns true if this was possibly the first node (may return true
+  // sporadically, will not return false sporadically)
+  bool Push(Node* node);
+  // Pop a node (returns NULL if no node is ready - which doesn't indicate that
+  // the queue is empty!!)
+  // Thread compatible - can only be called from one thread at a time
+  Node* Pop();
+  // Pop a node; sets *empty to true if the queue is empty, or false if it is
+  // not.
+  Node* PopAndCheckEnd(bool* empty);
+
+ private:
+  // make sure head & tail don't share a cacheline
+  union {
+    char padding_[GPR_CACHELINE_SIZE];
+    Atomic<Node*> head_;
+  };
+  Node* tail_;
+  Node stub_;
+};
+
+// An mpscq with a lock: it's safe to pop from multiple threads, but doing
+// only one thread will succeed concurrently.
+class LockedMultiProducerSingleConsumerQueue {
+ public:
+  typedef MultiProducerSingleConsumerQueue::Node Node;
+
+  // Push a node
+  // Thread safe - can be called from multiple threads concurrently
+  // Returns true if this was possibly the first node (may return true
+  // sporadically, will not return false sporadically)
+  bool Push(Node* node);
+
+  // Pop a node (returns NULL if no node is ready - which doesn't indicate that
+  // the queue is empty!!)
+  // Thread safe - can be called from multiple threads concurrently
+  Node* TryPop();
+
+  // Pop a node.  Returns NULL only if the queue was empty at some point after
+  // calling this function
+  Node* Pop();
+
+ private:
+  MultiProducerSingleConsumerQueue queue_;
+  Mutex mu_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_GPRPP_MPSCQ_H */

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

@@ -28,7 +28,6 @@
 #include <memory>
 
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gprpp/abstract.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -46,26 +45,26 @@ class Orphanable {
   // Gives up ownership of the object.  The implementation must arrange
   // to eventually destroy the object without further interaction from the
   // caller.
-  virtual void Orphan() GRPC_ABSTRACT;
+  virtual void Orphan() = 0;
 
   // Not copyable or movable.
   Orphanable(const Orphanable&) = delete;
   Orphanable& operator=(const Orphanable&) = delete;
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
   Orphanable() {}
   virtual ~Orphanable() {}
 };
 
-template <typename T>
 class OrphanableDelete {
  public:
-  void operator()(T* p) { p->Orphan(); }
+  template <typename T>
+  void operator()(T* p) {
+    p->Orphan();
+  }
 };
 
-template <typename T, typename Deleter = OrphanableDelete<T>>
+template <typename T, typename Deleter = OrphanableDelete>
 using OrphanablePtr = std::unique_ptr<T, Deleter>;
 
 template <typename T, typename... Args>
@@ -81,11 +80,7 @@ class InternallyRefCounted : public Orphanable {
   InternallyRefCounted(const InternallyRefCounted&) = delete;
   InternallyRefCounted& operator=(const InternallyRefCounted&) = delete;
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-
   // Allow RefCountedPtr<> to access Unref() and IncrementRefCount().
   template <typename T>
   friend class RefCountedPtr;

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

@@ -30,7 +30,6 @@
 #include <cinttypes>
 
 #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"
@@ -41,11 +40,6 @@ namespace grpc_core {
 // PolymorphicRefCount enforces polymorphic destruction of RefCounted.
 class PolymorphicRefCount {
  public:
-  GRPC_ABSTRACT_BASE_CLASS
-
- protected:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-
   virtual ~PolymorphicRefCount() = default;
 };
 
@@ -54,11 +48,6 @@ class PolymorphicRefCount {
 // when in doubt use PolymorphicRefCount.
 class NonPolymorphicRefCount {
  public:
-  GRPC_ABSTRACT_BASE_CLASS
-
- protected:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-
   ~NonPolymorphicRefCount() = default;
 };
 
@@ -80,7 +69,14 @@ class RefCount {
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
   template <typename TraceFlagT = TraceFlag>
-  constexpr explicit RefCount(Value init = 1, TraceFlagT* trace_flag = nullptr)
+  constexpr explicit RefCount(
+      Value init = 1,
+      TraceFlagT*
+#ifndef NDEBUG
+          // Leave unnamed if NDEBUG to avoid unused parameter warning
+          trace_flag
+#endif
+      = nullptr)
       :
 #ifndef NDEBUG
         trace_flag_(trace_flag),
@@ -109,6 +105,10 @@ class RefCount {
               prior, prior + n, reason);
     }
 #else
+    // Use conditionally-important parameters
+    (void)location;
+    (void)reason;
+
     value_.FetchAdd(n, MemoryOrder::RELAXED);
 #endif
   }
@@ -136,6 +136,9 @@ class RefCount {
     }
     assert(prior > 0);
 #else
+    // Avoid unused-parameter warnings for debug-only parameters
+    (void)location;
+    (void)reason;
     RefNonZero();
 #endif
   }
@@ -161,6 +164,9 @@ class RefCount {
               prior, prior + 1, reason);
     }
 #endif
+    // Avoid unused-parameter warnings for debug-only parameters
+    (void)location;
+    (void)reason;
     return value_.IncrementIfNonzero();
   }
 
@@ -195,6 +201,10 @@ class RefCount {
               prior - 1, reason);
     }
     GPR_DEBUG_ASSERT(prior > 0);
+#else
+    // Avoid unused-parameter warnings for debug-only parameters
+    (void)location;
+    (void)reason;
 #endif
     return prior == 1;
   }
@@ -237,6 +247,9 @@ class RefCount {
 template <typename Child, typename Impl = PolymorphicRefCount>
 class RefCounted : public Impl {
  public:
+  // Note: Depending on the Impl used, this dtor can be implicitly virtual.
+  ~RefCounted() = default;
+
   RefCountedPtr<Child> Ref() GRPC_MUST_USE_RESULT {
     IncrementRefCount();
     return RefCountedPtr<Child>(static_cast<Child*>(this));
@@ -272,11 +285,7 @@ class RefCounted : public Impl {
   RefCounted(const RefCounted&) = delete;
   RefCounted& operator=(const RefCounted&) = delete;
 
-  GRPC_ABSTRACT_BASE_CLASS
-
  protected:
-  GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE
-
   // TraceFlagT is defined to accept both DebugOnlyTraceFlag and TraceFlag.
   // Note: RefCount tracing is only enabled on debug builds, even when a
   //       TraceFlag is used.
@@ -285,9 +294,6 @@ class RefCounted : public Impl {
                       intptr_t initial_refcount = 1)
       : refs_(initial_refcount, trace_flag) {}
 
-  // Note: Depending on the Impl used, this dtor can be implicitly virtual.
-  ~RefCounted() = default;
-
  private:
   // Allow RefCountedPtr<> to access IncrementRefCount().
   template <typename T>