grpc 1.23.1 → 1.24.0.pre1

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_channel.h

@@ -23,14 +23,20 @@
 
 #include <grpc/impl/codegen/grpc_types.h>
 
+namespace grpc_core {
+
 /// Makes any necessary modifications to \a args for use in the xds
 /// balancer channel.
 ///
 /// Takes ownership of \a args.
 ///
 /// Caller takes ownership of the returned args.
-grpc_channel_args* grpc_lb_policy_xds_modify_lb_channel_args(
-    grpc_channel_args* args);
+grpc_channel_args* ModifyXdsBalancerChannelArgs(grpc_channel_args* args);
+
+grpc_channel* CreateXdsBalancerChannel(const char* target_uri,
+                                       const grpc_channel_args& args);
+
+}  // namespace grpc_core
 
 #endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_XDS_XDS_CHANNEL_H \
         */

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_channel_secure.cc

@@ -20,9 +20,11 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/xds/xds_channel.h"
 
+#include <string.h>
+
+#include <grpc/grpc_security.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
-#include <string.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/server_address.h"
@@ -33,29 +35,48 @@
 #include "src/core/lib/security/transport/target_authority_table.h"
 #include "src/core/lib/slice/slice_internal.h"
 
-grpc_channel_args* grpc_lb_policy_xds_modify_lb_channel_args(
-    grpc_channel_args* args) {
-  const char* args_to_remove[1];
-  size_t num_args_to_remove = 0;
-  grpc_arg args_to_add[2];
-  size_t num_args_to_add = 0;
+namespace grpc_core {
+
+grpc_channel_args* ModifyXdsBalancerChannelArgs(grpc_channel_args* args) {
+  InlinedVector<const char*, 1> args_to_remove;
+  InlinedVector<grpc_arg, 2> args_to_add;
   // Substitute the channel credentials with a version without call
   // credentials: the load balancer is not necessarily trusted to handle
   // bearer token credentials.
   grpc_channel_credentials* channel_credentials =
       grpc_channel_credentials_find_in_args(args);
-  grpc_core::RefCountedPtr<grpc_channel_credentials> creds_sans_call_creds;
+  RefCountedPtr<grpc_channel_credentials> creds_sans_call_creds;
   if (channel_credentials != nullptr) {
     creds_sans_call_creds =
         channel_credentials->duplicate_without_call_credentials();
     GPR_ASSERT(creds_sans_call_creds != nullptr);
-    args_to_remove[num_args_to_remove++] = GRPC_ARG_CHANNEL_CREDENTIALS;
-    args_to_add[num_args_to_add++] =
-        grpc_channel_credentials_to_arg(creds_sans_call_creds.get());
+    args_to_remove.emplace_back(GRPC_ARG_CHANNEL_CREDENTIALS);
+    args_to_add.emplace_back(
+        grpc_channel_credentials_to_arg(creds_sans_call_creds.get()));
   }
   grpc_channel_args* result = grpc_channel_args_copy_and_add_and_remove(
-      args, args_to_remove, num_args_to_remove, args_to_add, num_args_to_add);
+      args, args_to_remove.data(), args_to_remove.size(), args_to_add.data(),
+      args_to_add.size());
   // Clean up.
   grpc_channel_args_destroy(args);
   return result;
 }
+
+grpc_channel* CreateXdsBalancerChannel(const char* target_uri,
+                                       const grpc_channel_args& args) {
+  grpc_channel_credentials* creds =
+      grpc_channel_credentials_find_in_args(&args);
+  if (creds == nullptr) {
+    // Build with security but parent channel is insecure.
+    return grpc_insecure_channel_create(target_uri, &args, nullptr);
+  }
+  const char* arg_to_remove = GRPC_ARG_CHANNEL_CREDENTIALS;
+  grpc_channel_args* new_args =
+      grpc_channel_args_copy_and_remove(&args, &arg_to_remove, 1);
+  grpc_channel* channel =
+      grpc_secure_channel_create(creds, target_uri, new_args, nullptr);
+  grpc_channel_args_destroy(new_args);
+  return channel;
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_client_stats.cc

@@ -26,60 +26,171 @@
 
 namespace grpc_core {
 
-void XdsLbClientStats::AddCallStarted() {
-  gpr_atm_full_fetch_add(&num_calls_started_, (gpr_atm)1);
+namespace {
+
+template <typename T>
+T GetAndResetCounter(Atomic<T>* from) {
+  return from->Exchange(0, MemoryOrder::RELAXED);
+}
+
+}  // namespace
+
+//
+// XdsClientStats::LocalityStats::LoadMetric::Snapshot
+//
+
+bool XdsClientStats::LocalityStats::LoadMetric::Snapshot::IsAllZero() const {
+  return total_metric_value == 0 && num_requests_finished_with_metric == 0;
+}
+
+//
+// XdsClientStats::LocalityStats::LoadMetric
+//
+
+XdsClientStats::LocalityStats::LoadMetric::Snapshot
+XdsClientStats::LocalityStats::LoadMetric::GetSnapshotAndReset() {
+  Snapshot metric = {num_requests_finished_with_metric_, total_metric_value_};
+  num_requests_finished_with_metric_ = 0;
+  total_metric_value_ = 0;
+  return metric;
 }
 
-void XdsLbClientStats::AddCallFinished(bool finished_with_client_failed_to_send,
-                                       bool finished_known_received) {
-  gpr_atm_full_fetch_add(&num_calls_finished_, (gpr_atm)1);
-  if (finished_with_client_failed_to_send) {
-    gpr_atm_full_fetch_add(&num_calls_finished_with_client_failed_to_send_,
-                           (gpr_atm)1);
+//
+// XdsClientStats::LocalityStats::Snapshot
+//
+
+bool XdsClientStats::LocalityStats::Snapshot::IsAllZero() {
+  if (total_successful_requests != 0 || total_requests_in_progress != 0 ||
+      total_error_requests != 0 || total_issued_requests != 0) {
+    return false;
   }
-  if (finished_known_received) {
-    gpr_atm_full_fetch_add(&num_calls_finished_known_received_, (gpr_atm)1);
+  for (auto& p : load_metric_stats) {
+    const LoadMetric::Snapshot& metric_value = p.second;
+    if (!metric_value.IsAllZero()) return false;
   }
+  return true;
 }
 
-void XdsLbClientStats::AddCallDroppedLocked(char* token) {
-  // Increment num_calls_started and num_calls_finished.
-  gpr_atm_full_fetch_add(&num_calls_started_, (gpr_atm)1);
-  gpr_atm_full_fetch_add(&num_calls_finished_, (gpr_atm)1);
-  // Record the drop.
-  if (drop_token_counts_ == nullptr) {
-    drop_token_counts_.reset(New<DroppedCallCounts>());
-  }
-  for (size_t i = 0; i < drop_token_counts_->size(); ++i) {
-    if (strcmp((*drop_token_counts_)[i].token.get(), token) == 0) {
-      ++(*drop_token_counts_)[i].count;
-      return;
+//
+// XdsClientStats::LocalityStats
+//
+
+XdsClientStats::LocalityStats::Snapshot
+XdsClientStats::LocalityStats::GetSnapshotAndReset() {
+  Snapshot snapshot = {
+      GetAndResetCounter(&total_successful_requests_),
+      // Don't reset total_requests_in_progress because it's not
+      // related to a single reporting interval.
+      total_requests_in_progress_.Load(MemoryOrder::RELAXED),
+      GetAndResetCounter(&total_error_requests_),
+      GetAndResetCounter(&total_issued_requests_)};
+  {
+    MutexLock lock(&load_metric_stats_mu_);
+    for (auto& p : load_metric_stats_) {
+      const char* metric_name = p.first.get();
+      LoadMetric& metric_value = p.second;
+      snapshot.load_metric_stats.emplace(
+          UniquePtr<char>(gpr_strdup(metric_name)),
+          metric_value.GetSnapshotAndReset());
     }
   }
-  // Not found, so add a new entry.
-  drop_token_counts_->emplace_back(UniquePtr<char>(gpr_strdup(token)), 1);
+  return snapshot;
 }
 
-namespace {
+void XdsClientStats::LocalityStats::AddCallStarted() {
+  total_issued_requests_.FetchAdd(1, MemoryOrder::RELAXED);
+  total_requests_in_progress_.FetchAdd(1, MemoryOrder::RELAXED);
+}
 
-void AtomicGetAndResetCounter(int64_t* value, gpr_atm* counter) {
-  *value = static_cast<int64_t>(gpr_atm_full_xchg(counter, (gpr_atm)0));
+void XdsClientStats::LocalityStats::AddCallFinished(bool fail) {
+  Atomic<uint64_t>& to_increment =
+      fail ? total_error_requests_ : total_successful_requests_;
+  to_increment.FetchAdd(1, MemoryOrder::RELAXED);
+  total_requests_in_progress_.FetchAdd(-1, MemoryOrder::ACQ_REL);
 }
 
-}  // namespace
+//
+// XdsClientStats::Snapshot
+//
 
-void XdsLbClientStats::GetLocked(
-    int64_t* num_calls_started, int64_t* num_calls_finished,
-    int64_t* num_calls_finished_with_client_failed_to_send,
-    int64_t* num_calls_finished_known_received,
-    UniquePtr<DroppedCallCounts>* drop_token_counts) {
-  AtomicGetAndResetCounter(num_calls_started, &num_calls_started_);
-  AtomicGetAndResetCounter(num_calls_finished, &num_calls_finished_);
-  AtomicGetAndResetCounter(num_calls_finished_with_client_failed_to_send,
-                           &num_calls_finished_with_client_failed_to_send_);
-  AtomicGetAndResetCounter(num_calls_finished_known_received,
-                           &num_calls_finished_known_received_);
-  *drop_token_counts = std::move(drop_token_counts_);
+bool XdsClientStats::Snapshot::IsAllZero() {
+  for (auto& p : upstream_locality_stats) {
+    if (!p.second.IsAllZero()) return false;
+  }
+  for (auto& p : dropped_requests) {
+    if (p.second != 0) return false;
+  }
+  return total_dropped_requests == 0;
+}
+
+//
+// XdsClientStats
+//
+
+XdsClientStats::Snapshot XdsClientStats::GetSnapshotAndReset() {
+  grpc_millis now = ExecCtx::Get()->Now();
+  // Record total_dropped_requests and reporting interval in the snapshot.
+  Snapshot snapshot;
+  snapshot.total_dropped_requests =
+      GetAndResetCounter(&total_dropped_requests_);
+  snapshot.load_report_interval = now - last_report_time_;
+  // Update last report time.
+  last_report_time_ = now;
+  // Snapshot all the other stats.
+  for (auto& p : upstream_locality_stats_) {
+    snapshot.upstream_locality_stats.emplace(p.first,
+                                             p.second->GetSnapshotAndReset());
+  }
+  {
+    MutexLock lock(&dropped_requests_mu_);
+#if GRPC_USE_CPP_STD_LIB
+    // This is a workaround for the case where some compilers cannot build
+    // move-assignment of map with non-copyable but movable key.
+    // https://stackoverflow.com/questions/36475497
+    std::swap(snapshot.dropped_requests, dropped_requests_);
+    dropped_requests_.clear();
+#else
+    snapshot.dropped_requests = std::move(dropped_requests_);
+#endif
+  }
+  return snapshot;
+}
+
+void XdsClientStats::MaybeInitLastReportTime() {
+  if (last_report_time_ == -1) last_report_time_ = ExecCtx::Get()->Now();
+}
+
+RefCountedPtr<XdsClientStats::LocalityStats> XdsClientStats::FindLocalityStats(
+    const RefCountedPtr<XdsLocalityName>& locality_name) {
+  auto iter = upstream_locality_stats_.find(locality_name);
+  if (iter == upstream_locality_stats_.end()) {
+    iter = upstream_locality_stats_
+               .emplace(locality_name, MakeRefCounted<LocalityStats>())
+               .first;
+  }
+  return iter->second;
+}
+
+void XdsClientStats::PruneLocalityStats() {
+  auto iter = upstream_locality_stats_.begin();
+  while (iter != upstream_locality_stats_.end()) {
+    if (iter->second->IsSafeToDelete()) {
+      iter = upstream_locality_stats_.erase(iter);
+    } else {
+      ++iter;
+    }
+  }
+}
+
+void XdsClientStats::AddCallDropped(const UniquePtr<char>& category) {
+  total_dropped_requests_.FetchAdd(1, MemoryOrder::RELAXED);
+  MutexLock lock(&dropped_requests_mu_);
+  auto iter = dropped_requests_.find(category);
+  if (iter == dropped_requests_.end()) {
+    dropped_requests_.emplace(UniquePtr<char>(gpr_strdup(category.get())), 1);
+  } else {
+    ++iter->second;
+  }
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/xds/xds_client_stats.h

@@ -21,49 +21,207 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/atm.h>
+#include <grpc/support/string_util.h>
 
+#include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/inlined_vector.h"
+#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
 
-class XdsLbClientStats : public RefCounted<XdsLbClientStats> {
+class XdsLocalityName : public RefCounted<XdsLocalityName> {
  public:
-  struct DropTokenCount {
-    UniquePtr<char> token;
-    int64_t count;
+  struct Less {
+    bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
+                    const RefCountedPtr<XdsLocalityName>& rhs) const {
+      int cmp_result = strcmp(lhs->region_.get(), rhs->region_.get());
+      if (cmp_result != 0) return cmp_result < 0;
+      cmp_result = strcmp(lhs->zone_.get(), rhs->zone_.get());
+      if (cmp_result != 0) return cmp_result < 0;
+      return strcmp(lhs->sub_zone_.get(), rhs->sub_zone_.get()) < 0;
+    }
+  };
+
+  XdsLocalityName(UniquePtr<char> region, UniquePtr<char> zone,
+                  UniquePtr<char> subzone)
+      : region_(std::move(region)),
+        zone_(std::move(zone)),
+        sub_zone_(std::move(subzone)) {}
+
+  bool operator==(const XdsLocalityName& other) const {
+    return strcmp(region_.get(), other.region_.get()) == 0 &&
+           strcmp(zone_.get(), other.zone_.get()) == 0 &&
+           strcmp(sub_zone_.get(), other.sub_zone_.get()) == 0;
+  }
+
+  const char* region() const { return region_.get(); }
+  const char* zone() const { return zone_.get(); }
+  const char* sub_zone() const { return sub_zone_.get(); }
+
+  const char* AsHumanReadableString() {
+    if (human_readable_string_ == nullptr) {
+      char* tmp;
+      gpr_asprintf(&tmp, "{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
+                   region_.get(), zone_.get(), sub_zone_.get());
+      human_readable_string_.reset(tmp);
+    }
+    return human_readable_string_.get();
+  }
+
+ private:
+  UniquePtr<char> region_;
+  UniquePtr<char> zone_;
+  UniquePtr<char> sub_zone_;
+  UniquePtr<char> human_readable_string_;
+};
+
+// The stats classes (i.e., XdsClientStats, LocalityStats, and LoadMetric) can
+// be taken a snapshot (and reset) to populate the load report. The snapshots
+// are contained in the respective Snapshot structs. The Snapshot structs have
+// no synchronization. The stats classes use several different synchronization
+// methods. 1. Most of the counters are Atomic<>s for performance. 2. Some of
+// the Map<>s are protected by Mutex if we are not guaranteed that the accesses
+// to them are synchronized by the callers. 3. The Map<>s to which the accesses
+// are already synchronized by the callers do not have additional
+// synchronization here. Note that the Map<>s we mentioned in 2 and 3 refer to
+// the map's tree structure rather than the content in each tree node.
+class XdsClientStats {
+ public:
+  class LocalityStats : public RefCounted<LocalityStats> {
+   public:
+    class LoadMetric {
+     public:
+      struct Snapshot {
+        bool IsAllZero() const;
 
-    DropTokenCount(UniquePtr<char> token, int64_t count)
-        : token(std::move(token)), count(count) {}
+        uint64_t num_requests_finished_with_metric;
+        double total_metric_value;
+      };
+
+      // Returns a snapshot of this instance and reset all the accumulative
+      // counters.
+      Snapshot GetSnapshotAndReset();
+
+     private:
+      uint64_t num_requests_finished_with_metric_{0};
+      double total_metric_value_{0};
+    };
+
+    using LoadMetricMap = Map<UniquePtr<char>, LoadMetric, StringLess>;
+    using LoadMetricSnapshotMap =
+        Map<UniquePtr<char>, LoadMetric::Snapshot, StringLess>;
+
+    struct Snapshot {
+      // TODO(juanlishen): Change this to const method when const_iterator is
+      // added to Map<>.
+      bool IsAllZero();
+
+      uint64_t total_successful_requests;
+      uint64_t total_requests_in_progress;
+      uint64_t total_error_requests;
+      uint64_t total_issued_requests;
+      LoadMetricSnapshotMap load_metric_stats;
+    };
+
+    // Returns a snapshot of this instance and reset all the accumulative
+    // counters.
+    Snapshot GetSnapshotAndReset();
+
+    // Each XdsLb::PickerWrapper holds a ref to the perspective LocalityStats.
+    // If the refcount is 0, there won't be new calls recorded to the
+    // LocalityStats, so the LocalityStats can be safely deleted when all the
+    // in-progress calls have finished.
+    // Only be called from the control plane combiner.
+    void RefByPicker() { picker_refcount_.FetchAdd(1, MemoryOrder::ACQ_REL); }
+    // Might be called from the control plane combiner or the data plane
+    // combiner.
+    // TODO(juanlishen): Once https://github.com/grpc/grpc/pull/19390 is merged,
+    //  this method will also only be invoked in the control plane combiner.
+    //  We may then be able to simplify the LocalityStats' lifetime by making it
+    //  RefCounted<> and populating the protobuf in its dtor.
+    void UnrefByPicker() { picker_refcount_.FetchSub(1, MemoryOrder::ACQ_REL); }
+    // Only be called from the control plane combiner.
+    // The only place where the picker_refcount_ can be increased is
+    // RefByPicker(), which also can only be called from the control plane
+    // combiner. Also, if the picker_refcount_ is 0, total_requests_in_progress_
+    // can't be increased from 0. So it's safe to delete the LocalityStats right
+    // after this method returns true.
+    bool IsSafeToDelete() {
+      return picker_refcount_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0 &&
+             total_requests_in_progress_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0;
+    }
+
+    void AddCallStarted();
+    void AddCallFinished(bool fail = false);
+
+   private:
+    Atomic<uint64_t> total_successful_requests_{0};
+    Atomic<uint64_t> total_requests_in_progress_{0};
+    // Requests that were issued (not dropped) but failed.
+    Atomic<uint64_t> total_error_requests_{0};
+    Atomic<uint64_t> total_issued_requests_{0};
+    // Protects load_metric_stats_. A mutex is necessary because the length of
+    // load_metric_stats_ can be accessed by both the callback intercepting the
+    // call's recv_trailing_metadata (not from any combiner) and the load
+    // reporting thread (from the control plane combiner).
+    Mutex load_metric_stats_mu_;
+    LoadMetricMap load_metric_stats_;
+    // Can be accessed from either the control plane combiner or the data plane
+    // combiner.
+    Atomic<uint8_t> picker_refcount_{0};
   };
 
-  typedef InlinedVector<DropTokenCount, 10> DroppedCallCounts;
+  // TODO(juanlishen): The value type of Map<> must be movable in current
+  // implementation. To avoid making LocalityStats movable, we wrap it by
+  // UniquePtr<>. We should remove this wrapper if the value type of Map<>
+  // doesn't have to be movable.
+  using LocalityStatsMap =
+      Map<RefCountedPtr<XdsLocalityName>, RefCountedPtr<LocalityStats>,
+          XdsLocalityName::Less>;
+  using LocalityStatsSnapshotMap =
+      Map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
+          XdsLocalityName::Less>;
+  using DroppedRequestsMap = Map<UniquePtr<char>, uint64_t, StringLess>;
+  using DroppedRequestsSnapshotMap = DroppedRequestsMap;
 
-  XdsLbClientStats() {}
+  struct Snapshot {
+    // TODO(juanlishen): Change this to const method when const_iterator is
+    // added to Map<>.
+    bool IsAllZero();
 
-  void AddCallStarted();
-  void AddCallFinished(bool finished_with_client_failed_to_send,
-                       bool finished_known_received);
+    LocalityStatsSnapshotMap upstream_locality_stats;
+    uint64_t total_dropped_requests;
+    DroppedRequestsSnapshotMap dropped_requests;
+    // The actual load report interval.
+    grpc_millis load_report_interval;
+  };
 
-  // This method is not thread-safe; caller must synchronize.
-  void AddCallDroppedLocked(char* token);
+  // Returns a snapshot of this instance and reset all the accumulative
+  // counters.
+  Snapshot GetSnapshotAndReset();
 
-  // This method is not thread-safe; caller must synchronize.
-  void GetLocked(int64_t* num_calls_started, int64_t* num_calls_finished,
-                 int64_t* num_calls_finished_with_client_failed_to_send,
-                 int64_t* num_calls_finished_known_received,
-                 UniquePtr<DroppedCallCounts>* drop_token_counts);
+  void MaybeInitLastReportTime();
+  RefCountedPtr<LocalityStats> FindLocalityStats(
+      const RefCountedPtr<XdsLocalityName>& locality_name);
+  void PruneLocalityStats();
+  void AddCallDropped(const UniquePtr<char>& category);
 
  private:
-  // This field must only be accessed via *_locked() methods.
-  UniquePtr<DroppedCallCounts> drop_token_counts_;
-  // These fields may be accessed from multiple threads at a time.
-  gpr_atm num_calls_started_ = 0;
-  gpr_atm num_calls_finished_ = 0;
-  gpr_atm num_calls_finished_with_client_failed_to_send_ = 0;
-  gpr_atm num_calls_finished_known_received_ = 0;
+  // The stats for each locality.
+  LocalityStatsMap upstream_locality_stats_;
+  Atomic<uint64_t> total_dropped_requests_{0};
+  // Protects dropped_requests_. A mutex is necessary because the length of
+  // dropped_requests_ can be accessed by both the picker (from data plane
+  // combiner) and the load reporting thread (from the control plane combiner).
+  Mutex dropped_requests_mu_;
+  DroppedRequestsMap dropped_requests_;
+  // The timestamp of last reporting. For the LB-policy-wide first report, the
+  // last_report_time is the time we scheduled the first reporting timer.
+  grpc_millis last_report_time_ = -1;
 };
 
 }  // namespace grpc_core