grpc 1.48.0 → 1.50.0

data/src/core/lib/avl/avl.h

@@ -22,7 +22,8 @@
 #include <algorithm>  // IWYU pragma: keep
 #include <memory>
 #include <utility>
-#include <vector>
+
+#include "src/core/lib/gpr/useful.h"
 
 namespace grpc_core {
 
@@ -58,33 +59,32 @@ class AVL {
 
   bool SameIdentity(const AVL& avl) const { return root_ == avl.root_; }
 
-  bool operator==(const AVL& other) const {
-    Iterator a(root_);
-    Iterator b(other.root_);
+  friend int QsortCompare(const AVL& left, const AVL& right) {
+    if (left.root_.get() == right.root_.get()) return 0;
+    Iterator a(left.root_);
+    Iterator b(right.root_);
     for (;;) {
       Node* p = a.current();
       Node* q = b.current();
-      if (p == nullptr) return q == nullptr;
-      if (q == nullptr) return false;
-      if (p->kv != q->kv) return false;
+      if (p != q) {
+        if (p == nullptr) return -1;
+        if (q == nullptr) return 1;
+        const int kv = QsortCompare(p->kv, q->kv);
+        if (kv != 0) return kv;
+      } else if (p == nullptr) {
+        return 0;
+      }
       a.MoveNext();
       b.MoveNext();
     }
   }
 
+  bool operator==(const AVL& other) const {
+    return QsortCompare(*this, other) == 0;
+  }
+
   bool operator<(const AVL& other) const {
-    Iterator a(root_);
-    Iterator b(other.root_);
-    for (;;) {
-      Node* p = a.current();
-      Node* q = b.current();
-      if (p == nullptr) return q != nullptr;
-      if (q == nullptr) return false;
-      if (p->kv < q->kv) return true;
-      if (p->kv != q->kv) return false;
-      a.MoveNext();
-      b.MoveNext();
-    }
+    return QsortCompare(*this, other) < 0;
   }
 
  private:
@@ -104,30 +104,52 @@ class AVL {
   };
   NodePtr root_;
 
+  class IteratorStack {
+   public:
+    void Push(Node* n) {
+      nodes_[depth_] = n;
+      ++depth_;
+    }
+
+    Node* Pop() {
+      --depth_;
+      return nodes_[depth_];
+    }
+
+    Node* Back() const { return nodes_[depth_ - 1]; }
+
+    bool Empty() const { return depth_ == 0; }
+
+   private:
+    size_t depth_{0};
+    // 32 is the maximum depth we can accept, and corresponds to ~4billion nodes
+    // - which ought to suffice our use cases.
+    Node* nodes_[32];
+  };
+
   class Iterator {
    public:
     explicit Iterator(const NodePtr& root) {
       auto* n = root.get();
       while (n != nullptr) {
-        stack_.push_back(n);
+        stack_.Push(n);
         n = n->left.get();
       }
     }
-    Node* current() const { return stack_.empty() ? nullptr : stack_.back(); }
+    Node* current() const { return stack_.Empty() ? nullptr : stack_.Back(); }
     void MoveNext() {
-      auto* n = stack_.back();
-      stack_.pop_back();
+      auto* n = stack_.Pop();
       if (n->right != nullptr) {
         n = n->right.get();
         while (n != nullptr) {
-          stack_.push_back(n);
+          stack_.Push(n);
           n = n->left.get();
         }
       }
     }
 
    private:
-    std::vector<Node*> stack_;
+    IteratorStack stack_;
   };
 
   explicit AVL(NodePtr root) : root_(std::move(root)) {}

data/src/core/lib/backoff/backoff.cc

@@ -22,8 +22,6 @@
 
 #include <algorithm>
 
-#include "src/core/lib/iomgr/exec_ctx.h"
-
 namespace grpc_core {
 
 BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
@@ -31,14 +29,14 @@ BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
-    return current_backoff_ + ExecCtx::Get()->Now();
+    return current_backoff_ + Timestamp::Now();
   }
   current_backoff_ = std::min(current_backoff_ * options_.multiplier(),
                               options_.max_backoff());
   const Duration jitter = Duration::FromSecondsAsDouble(
       absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_.seconds(),
                     options_.jitter() * current_backoff_.seconds()));
-  return ExecCtx::Get()->Now() + current_backoff_ + jitter;
+  return Timestamp::Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {

data/src/core/lib/channel/call_finalization.h

@@ -19,8 +19,6 @@
 
 #include <utility>
 
-#include "absl/utility/utility.h"
-
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/resource_quota/arena.h"
@@ -47,7 +45,7 @@ class CallFinalization {
   }
 
   void Run(const grpc_call_final_info* final_info) {
-    if (Finalizer* f = absl::exchange(first_, nullptr)) f->Run(final_info);
+    if (Finalizer* f = std::exchange(first_, nullptr)) f->Run(final_info);
   }
 
  private:

data/src/core/lib/channel/call_tracer.h

@@ -50,7 +50,7 @@ class CallTracer {
     // Please refer to `grpc_transport_stream_op_batch_payload` for details on
     // arguments.
     virtual void RecordSendInitialMetadata(
-        grpc_metadata_batch* send_initial_metadata, uint32_t flags) = 0;
+        grpc_metadata_batch* send_initial_metadata) = 0;
     // TODO(yashkt): We are using gpr_atm here instead of absl::string_view
     // since that's what the transport API uses, and performing an atomic load
     // is unnecessary if the census tracer does not need it at present. Fix this

data/src/core/lib/channel/channel_args.cc

@@ -41,30 +41,65 @@
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/match.h"
 
-namespace {
+namespace grpc_core {
 
-int PointerCompare(void* a_ptr, const grpc_arg_pointer_vtable* a_vtable,
-                   void* b_ptr, const grpc_arg_pointer_vtable* b_vtable) {
-  int c = grpc_core::QsortCompare(a_ptr, b_ptr);
-  if (c == 0) return 0;
-  c = grpc_core::QsortCompare(a_vtable, b_vtable);
-  if (c != 0) return c;
-  return a_vtable->cmp(a_ptr, b_ptr);
+ChannelArgs::Pointer::Pointer(void* p, const grpc_arg_pointer_vtable* vtable)
+    : p_(p), vtable_(vtable == nullptr ? EmptyVTable() : vtable) {}
+
+ChannelArgs::Pointer::Pointer(const Pointer& other)
+    : p_(other.vtable_->copy(other.p_)), vtable_(other.vtable_) {}
+
+ChannelArgs::Pointer::Pointer(Pointer&& other) noexcept
+    : p_(other.p_), vtable_(other.vtable_) {
+  other.p_ = nullptr;
+  other.vtable_ = EmptyVTable();
 }
 
-}  // namespace
+const grpc_arg_pointer_vtable* ChannelArgs::Pointer::EmptyVTable() {
+  static const grpc_arg_pointer_vtable vtable = {
+      // copy
+      [](void* p) { return p; },
+      // destroy
+      [](void*) {},
+      // cmp
+      [](void* p1, void* p2) -> int { return QsortCompare(p1, p2); },
+  };
+  return &vtable;
+}
 
-namespace grpc_core {
+ChannelArgs::ChannelArgs() = default;
+ChannelArgs::~ChannelArgs() = default;
+ChannelArgs::ChannelArgs(const ChannelArgs& other) = default;
+ChannelArgs& ChannelArgs::operator=(const ChannelArgs& other) = default;
+ChannelArgs::ChannelArgs(ChannelArgs&& other) noexcept = default;
+ChannelArgs& ChannelArgs::operator=(ChannelArgs&& other) noexcept = default;
 
-bool ChannelArgs::Pointer::operator==(const Pointer& rhs) const {
-  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) == 0;
+const ChannelArgs::Value* ChannelArgs::Get(absl::string_view name) const {
+  return args_.Lookup(name);
 }
 
-bool ChannelArgs::Pointer::operator<(const Pointer& rhs) const {
-  return PointerCompare(p_, vtable_, rhs.p_, rhs.vtable_) < 0;
+bool ChannelArgs::Contains(absl::string_view name) const {
+  return Get(name) != nullptr;
 }
 
-ChannelArgs::ChannelArgs() = default;
+bool ChannelArgs::operator<(const ChannelArgs& other) const {
+  return args_ < other.args_;
+}
+
+bool ChannelArgs::operator==(const ChannelArgs& other) const {
+  return args_ == other.args_;
+}
+
+bool ChannelArgs::operator!=(const ChannelArgs& other) const {
+  return !(*this == other);
+}
+
+bool ChannelArgs::WantMinimalStack() const {
+  return GetBool(GRPC_ARG_MINIMAL_STACK).value_or(false);
+}
+
+ChannelArgs::ChannelArgs(AVL<std::string, Value> args)
+    : args_(std::move(args)) {}
 
 ChannelArgs ChannelArgs::Set(grpc_arg arg) const {
   switch (arg.type) {
@@ -91,7 +126,7 @@ ChannelArgs ChannelArgs::FromC(const grpc_channel_args* args) {
   return result;
 }
 
-const grpc_channel_args* ChannelArgs::ToC() const {
+ChannelArgs::CPtr ChannelArgs::ToC() const {
   std::vector<grpc_arg> c_args;
   args_.ForEach([&c_args](const std::string& key, const Value& value) {
     char* name = const_cast<char*>(key.c_str());
@@ -107,7 +142,16 @@ const grpc_channel_args* ChannelArgs::ToC() const {
                                                  p.c_vtable());
         }));
   });
-  return grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size());
+  return CPtr(static_cast<const grpc_channel_args*>(
+      grpc_channel_args_copy_and_add(nullptr, c_args.data(), c_args.size())));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view name, Pointer value) const {
+  return Set(name, Value(std::move(value)));
+}
+
+ChannelArgs ChannelArgs::Set(absl::string_view name, int value) const {
+  return Set(name, Value(value));
 }
 
 ChannelArgs ChannelArgs::Set(absl::string_view key, Value value) const {
@@ -155,6 +199,13 @@ absl::optional<absl::string_view> ChannelArgs::GetString(
   return absl::get<std::string>(*v);
 }
 
+absl::optional<std::string> ChannelArgs::GetOwnedString(
+    absl::string_view name) const {
+  absl::optional<absl::string_view> v = GetString(name);
+  if (!v.has_value()) return absl::nullopt;
+  return std::string(*v);
+}
+
 void* ChannelArgs::GetVoidPointer(absl::string_view name) const {
   auto* v = Get(name);
   if (v == nullptr) return nullptr;
@@ -199,6 +250,22 @@ std::string ChannelArgs::ToString() const {
   return absl::StrCat("{", absl::StrJoin(arg_strings, ", "), "}");
 }
 
+ChannelArgs ChannelArgs::UnionWith(ChannelArgs other) const {
+  args_.ForEach([&other](const std::string& key, const Value& value) {
+    other.args_ = other.args_.Add(key, value);
+  });
+  return other;
+}
+
+void ChannelArgs::ChannelArgsDeleter::operator()(
+    const grpc_channel_args* p) const {
+  grpc_channel_args_destroy(p);
+}
+
+std::ostream& operator<<(std::ostream& out, const ChannelArgs& args) {
+  return out << args.ToString();
+}
+
 }  // namespace grpc_core
 
 static grpc_arg copy_arg(const grpc_arg* src) {
@@ -319,8 +386,9 @@ static int cmp_arg(const grpc_arg* a, const grpc_arg* b) {
     case GRPC_ARG_INTEGER:
       return grpc_core::QsortCompare(a->value.integer, b->value.integer);
     case GRPC_ARG_POINTER:
-      return PointerCompare(a->value.pointer.p, a->value.pointer.vtable,
-                            b->value.pointer.p, b->value.pointer.vtable);
+      return grpc_core::channel_args_detail::PointerCompare(
+          a->value.pointer.p, a->value.pointer.vtable, b->value.pointer.p,
+          b->value.pointer.vtable);
   }
   GPR_UNREACHABLE_CODE(return 0);
 }
@@ -540,6 +608,7 @@ ChannelArgs ChannelArgsBuiltinPrecondition(const grpc_channel_args* src) {
   }
   return output;
 }
+
 }  // namespace grpc_core
 
 namespace {