grpc 1.22.0 → 1.23.0

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

@@ -25,10 +25,12 @@ namespace grpc_core {
 // No-op for non-debug builds.
 // Callers can use the DEBUG_LOCATION macro in either case.
 #ifndef NDEBUG
+// TODO(roth): See if there's a way to automatically populate this,
+// similarly to how absl::SourceLocation::current() works, so that
+// callers don't need to explicitly pass DEBUG_LOCATION anywhere.
 class DebugLocation {
  public:
   DebugLocation(const char* file, int line) : file_(file), line_(line) {}
-  bool Log() const { return true; }
   const char* file() const { return file_; }
   int line() const { return line_; }
 
@@ -40,7 +42,6 @@ class DebugLocation {
 #else
 class DebugLocation {
  public:
-  bool Log() const { return false; }
   const char* file() const { return nullptr; }
   int line() const { return -1; }
 };

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

@@ -168,40 +168,33 @@ class ThreadState {
 
 void Fork::GlobalInit() {
   if (!override_enabled_) {
-    support_enabled_ = GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support);
+    support_enabled_.Store(GPR_GLOBAL_CONFIG_GET(grpc_enable_fork_support),
+                           MemoryOrder::RELAXED);
   }
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     exec_ctx_state_ = grpc_core::New<internal::ExecCtxState>();
     thread_state_ = grpc_core::New<internal::ThreadState>();
   }
 }
 
 void Fork::GlobalShutdown() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     grpc_core::Delete(exec_ctx_state_);
     grpc_core::Delete(thread_state_);
   }
 }
 
-bool Fork::Enabled() { return support_enabled_; }
+bool Fork::Enabled() { return support_enabled_.Load(MemoryOrder::RELAXED); }
 
 // Testing Only
 void Fork::Enable(bool enable) {
   override_enabled_ = true;
-  support_enabled_ = enable;
+  support_enabled_.Store(enable, MemoryOrder::RELAXED);
 }
 
-void Fork::IncExecCtxCount() {
-  if (support_enabled_) {
-    exec_ctx_state_->IncExecCtxCount();
-  }
-}
+void Fork::DoIncExecCtxCount() { exec_ctx_state_->IncExecCtxCount(); }
 
-void Fork::DecExecCtxCount() {
-  if (support_enabled_) {
-    exec_ctx_state_->DecExecCtxCount();
-  }
-}
+void Fork::DoDecExecCtxCount() { exec_ctx_state_->DecExecCtxCount(); }
 
 void Fork::SetResetChildPollingEngineFunc(
     Fork::child_postfork_func reset_child_polling_engine) {
@@ -212,38 +205,38 @@ Fork::child_postfork_func Fork::GetResetChildPollingEngineFunc() {
 }
 
 bool Fork::BlockExecCtx() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     return exec_ctx_state_->BlockExecCtx();
   }
   return false;
 }
 
 void Fork::AllowExecCtx() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     exec_ctx_state_->AllowExecCtx();
   }
 }
 
 void Fork::IncThreadCount() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     thread_state_->IncThreadCount();
   }
 }
 
 void Fork::DecThreadCount() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     thread_state_->DecThreadCount();
   }
 }
 void Fork::AwaitThreads() {
-  if (support_enabled_) {
+  if (support_enabled_.Load(MemoryOrder::RELAXED)) {
     thread_state_->AwaitThreads();
   }
 }
 
 internal::ExecCtxState* Fork::exec_ctx_state_ = nullptr;
 internal::ThreadState* Fork::thread_state_ = nullptr;
-std::atomic<bool> Fork::support_enabled_;
+Atomic<bool> Fork::support_enabled_(false);
 bool Fork::override_enabled_ = false;
 Fork::child_postfork_func Fork::reset_child_polling_engine_ = nullptr;
 }  // namespace grpc_core

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

@@ -21,7 +21,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <atomic>
+#include "src/core/lib/gprpp/atomic.h"
 
 /*
  * NOTE: FORKING IS NOT GENERALLY SUPPORTED, THIS IS ONLY INTENDED TO WORK
@@ -47,10 +47,18 @@ class Fork {
 
   // Increment the count of active ExecCtxs.
   // Will block until a pending fork is complete if one is in progress.
-  static void IncExecCtxCount();
+  static void IncExecCtxCount() {
+    if (GPR_UNLIKELY(support_enabled_.Load(MemoryOrder::RELAXED))) {
+      DoIncExecCtxCount();
+    }
+  }
 
   // Decrement the count of active ExecCtxs
-  static void DecExecCtxCount();
+  static void DecExecCtxCount() {
+    if (GPR_UNLIKELY(support_enabled_.Load(MemoryOrder::RELAXED))) {
+      DoDecExecCtxCount();
+    }
+  }
 
   // Provide a function that will be invoked in the child's postfork handler to
   // reset the polling engine's internal state.
@@ -80,9 +88,12 @@ class Fork {
   static void Enable(bool enable);
 
  private:
+  static void DoIncExecCtxCount();
+  static void DoDecExecCtxCount();
+
   static internal::ExecCtxState* exec_ctx_state_;
   static internal::ThreadState* thread_state_;
-  static std::atomic<bool> support_enabled_;
+  static grpc_core::Atomic<bool> support_enabled_;
   static bool override_enabled_;
   static child_postfork_func reset_child_polling_engine_;
 };

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

@@ -0,0 +1,118 @@
+/*
+ *
+ * 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>
+
+#include "src/core/lib/gprpp/host_port.h"
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/string_view.h"
+
+namespace grpc_core {
+int JoinHostPort(UniquePtr<char>* out, const char* host, int port) {
+  char* tmp;
+  int ret;
+  if (host[0] != '[' && strchr(host, ':') != nullptr) {
+    /* IPv6 literals must be enclosed in brackets. */
+    ret = gpr_asprintf(&tmp, "[%s]:%d", host, port);
+  } else {
+    /* Ordinary non-bracketed host:port. */
+    ret = gpr_asprintf(&tmp, "%s:%d", host, port);
+  }
+  out->reset(tmp);
+  return ret;
+}
+
+namespace {
+bool DoSplitHostPort(StringView name, StringView* host, StringView* port,
+                     bool* has_port) {
+  *has_port = false;
+  if (name[0] == '[') {
+    /* Parse a bracketed host, typically an IPv6 literal. */
+    const size_t rbracket = name.find(']', 1);
+    if (rbracket == grpc_core::StringView::npos) {
+      /* Unmatched [ */
+      return false;
+    }
+    if (rbracket == name.size() - 1) {
+      /* ]<end> */
+      port->clear();
+    } else if (name[rbracket + 1] == ':') {
+      /* ]:<port?> */
+      *port = name.substr(rbracket + 2, name.size() - rbracket - 2);
+      *has_port = true;
+    } else {
+      /* ]<invalid> */
+      return false;
+    }
+    *host = name.substr(1, rbracket - 1);
+    if (host->find(':') == grpc_core::StringView::npos) {
+      /* Require all bracketed hosts to contain a colon, because a hostname or
+         IPv4 address should never use brackets. */
+      host->clear();
+      return false;
+    }
+  } else {
+    size_t colon = name.find(':');
+    if (colon != grpc_core::StringView::npos &&
+        name.find(':', colon + 1) == grpc_core::StringView::npos) {
+      /* Exactly 1 colon.  Split into host:port. */
+      *host = name.substr(0, colon);
+      *port = name.substr(colon + 1, name.size() - colon - 1);
+      *has_port = true;
+    } else {
+      /* 0 or 2+ colons.  Bare hostname or IPv6 litearal. */
+      *host = name;
+      port->clear();
+    }
+  }
+  return true;
+}
+}  // namespace
+
+bool SplitHostPort(StringView name, StringView* host, StringView* port) {
+  bool unused;
+  return DoSplitHostPort(name, host, port, &unused);
+}
+
+bool SplitHostPort(StringView name, UniquePtr<char>* host,
+                   UniquePtr<char>* port) {
+  GPR_DEBUG_ASSERT(host != nullptr && *host == nullptr);
+  GPR_DEBUG_ASSERT(port != nullptr && *port == nullptr);
+  StringView host_view;
+  StringView port_view;
+  bool has_port;
+  const bool ret = DoSplitHostPort(name, &host_view, &port_view, &has_port);
+  if (ret) {
+    // We always set the host, but port is set only when DoSplitHostPort find a
+    // port in the string, to remain backward compatible with the old
+    // gpr_split_host_port API.
+    *host = host_view.dup();
+    if (has_port) {
+      *port = port_view.dup();
+    }
+  }
+  return ret;
+}
+}  // namespace grpc_core

data/src/core/lib/{gpr → gprpp}/host_port.h

@@ -16,28 +16,44 @@
  *
  */
 
-#ifndef GRPC_CORE_LIB_GPR_HOST_PORT_H
-#define GRPC_CORE_LIB_GPR_HOST_PORT_H
+#ifndef GRPC_CORE_LIB_GPRPP_HOST_PORT_H
+#define GRPC_CORE_LIB_GPRPP_HOST_PORT_H
 
 #include <grpc/support/port_platform.h>
 
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/string_view.h"
+
+namespace grpc_core {
+
 /** Given a host and port, creates a newly-allocated string of the form
    "host:port" or "[ho:st]:port", depending on whether the host contains colons
    like an IPv6 literal.  If the host is already bracketed, then additional
    brackets will not be added.
 
    Usage is similar to gpr_asprintf: returns the number of bytes written
-   (excluding the final '\0'), and *out points to a string which must later be
-   destroyed using gpr_free().
+   (excluding the final '\0'), and *out points to a string.
 
    In the unlikely event of an error, returns -1 and sets *out to NULL. */
-int gpr_join_host_port(char** out, const char* host, int port);
+int JoinHostPort(UniquePtr<char>* out, const char* host, int port);
 
 /** Given a name in the form "host:port" or "[ho:st]:port", split into hostname
-   and port number, into newly allocated strings, which must later be
-   destroyed using gpr_free().
-   Return 1 on success, 0 on failure. Guarantees *host and *port == NULL on
-   failure. */
-int gpr_split_host_port(const char* name, char** host, char** port);
+   and port number.
+
+   There are two variants of this method:
+   1) StringView output: port and host are returned as views on name.
+   2) char* output: port and host are copied into newly allocated strings.
+
+   Prefer variant (1) over (2), because no allocation or copy is performed in
+   variant (1).  Use (2) only when interacting with C API that mandate
+   null-terminated strings.
+
+   Return true on success, false on failure. Guarantees *host and *port are
+   cleared on failure. */
+bool SplitHostPort(StringView name, StringView* host, StringView* port);
+bool SplitHostPort(StringView name, UniquePtr<char>* host,
+                   UniquePtr<char>* port);
+
+}  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_GPR_HOST_PORT_H */
+#endif /* GRPC_CORE_LIB_GPRPP_HOST_PORT_H */

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

@@ -30,6 +30,7 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/pair.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
 
 namespace grpc_core {
 struct StringLess {
@@ -41,6 +42,13 @@ struct StringLess {
   }
 };
 
+template <typename T>
+struct RefCountedPtrLess {
+  bool operator()(const RefCountedPtr<T>& p1, const RefCountedPtr<T>& p2) {
+    return p1.get() < p2.get();
+  }
+};
+
 namespace testing {
 class MapTest;
 }
@@ -55,8 +63,25 @@ class Map {
   typedef Compare key_compare;
   class iterator;
 
+  Map() = default;
   ~Map() { clear(); }
 
+  // Movable.
+  Map(Map&& other) : root_(other.root_), size_(other.size_) {
+    other.root_ = nullptr;
+    other.size_ = 0;
+  }
+  Map& operator=(Map&& other) {
+    if (this != &other) {
+      clear();
+      root_ = other.root_;
+      size_ = other.size_;
+      other.root_ = nullptr;
+      other.size_ = 0;
+    }
+    return *this;
+  }
+
   T& operator[](key_type&& key);
   T& operator[](const key_type& key);
   iterator find(const key_type& k);

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

@@ -22,6 +22,7 @@
 #include <grpc/support/port_platform.h>
 
 #include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
 
 #include <limits>
 #include <memory>
@@ -29,14 +30,17 @@
 
 // Add this to a class that want to use Delete(), but has a private or
 // protected destructor.
-#define GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_DELETE \
-  template <typename T>                           \
-  friend void grpc_core::Delete(T*);
+#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.
-#define GRPC_ALLOW_CLASS_TO_USE_NON_PUBLIC_NEW \
-  template <typename T, typename... Args>      \
-  friend T* grpc_core::New(Args&&...);
+#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 {
 
@@ -48,17 +52,30 @@ inline T* New(Args&&... args) {
 }
 
 // Alternative to delete, since we cannot use it (for fear of libstdc++)
-template <typename T>
+// 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) {
-  if (p == nullptr) return;
+  GPR_DEBUG_ASSERT(can_be_null || p != nullptr);
+  if (can_be_null && p == nullptr) return;
   p->~T();
   gpr_free(p);
 }
+template <typename T>
+inline void Delete(T* p) {
+  Delete<T, /*can_be_null=*/true>(p);
+}
 
 template <typename T>
 class DefaultDelete {
  public:
-  void operator()(T* p) { Delete(p); }
+  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);
+  }
 };
 
 template <typename T, typename Deleter = DefaultDelete<T>>

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

@@ -89,72 +89,114 @@ class RefCount {
   }
 
   // Increases the ref-count by `n`.
-  void Ref(Value n = 1) { value_.FetchAdd(n, MemoryOrder::RELAXED); }
+  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);
+    }
+#else
+    value_.FetchAdd(n, MemoryOrder::RELAXED);
+#endif
+  }
   void Ref(const DebugLocation& location, const char* reason, Value n = 1) {
 #ifndef NDEBUG
-    if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
-      const RefCount::Value old_refs = get();
+    const Value prior = value_.FetchAdd(n, MemoryOrder::RELAXED);
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
               trace_flag_->name(), this, location.file(), location.line(),
-              old_refs, old_refs + n, reason);
+              prior, prior + n, reason);
     }
+#else
+    value_.FetchAdd(n, MemoryOrder::RELAXED);
 #endif
-    Ref(n);
   }
 
   // Similar to Ref() with an assert on the ref-count being non-zero.
   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);
+    }
     assert(prior > 0);
 #else
-    Ref();
+    value_.FetchAdd(1, MemoryOrder::RELAXED);
 #endif
   }
   void RefNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
-      const RefCount::Value old_refs = get();
+    const Value prior = value_.FetchAdd(1, MemoryOrder::RELAXED);
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
       gpr_log(GPR_INFO, "%s:%p %s:%d ref %" PRIdPTR " -> %" PRIdPTR " %s",
               trace_flag_->name(), this, location.file(), location.line(),
-              old_refs, old_refs + 1, reason);
+              prior, prior + 1, reason);
     }
-#endif
+    assert(prior > 0);
+#else
     RefNonZero();
+#endif
   }
 
-  bool RefIfNonZero() { return value_.IncrementIfNonzero(); }
-
+  bool RefIfNonZero() {
+#ifndef NDEBUG
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+      const Value prior = get();
+      gpr_log(GPR_INFO, "%s:%p ref_if_non_zero %" PRIdPTR " -> %" PRIdPTR,
+              trace_flag_->name(), this, prior, prior + 1);
+    }
+#endif
+    return value_.IncrementIfNonzero();
+  }
   bool RefIfNonZero(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
-      const RefCount::Value old_refs = get();
+    if (trace_flag_ != nullptr && trace_flag_->enabled()) {
+      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(),
-              old_refs, old_refs + 1, reason);
+              prior, prior + 1, reason);
     }
 #endif
-    return RefIfNonZero();
+    return value_.IncrementIfNonzero();
   }
 
   // Decrements the ref-count and returns true if the ref-count reaches 0.
   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_;
+#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);
+    }
     GPR_DEBUG_ASSERT(prior > 0);
+#endif
     return prior == 1;
   }
   bool Unref(const DebugLocation& location, const char* reason) {
 #ifndef NDEBUG
-    if (location.Log() && trace_flag_ != nullptr && trace_flag_->enabled()) {
-      const RefCount::Value old_refs = get();
+    // 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_;
+#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 %s:%d unref %" PRIdPTR " -> %" PRIdPTR " %s",
-              trace_flag_->name(), this, location.file(), location.line(),
-              old_refs, old_refs - 1, reason);
+              trace_flag->name(), this, location.file(), location.line(), prior,
+              prior - 1, reason);
     }
+    GPR_DEBUG_ASSERT(prior > 0);
 #endif
-    return Unref();
+    return prior == 1;
   }
 
  private: