grpc 1.42.0 → 1.43.1

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

@@ -1,94 +1,395 @@
-/*
- *
- * 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.
- *
- */
+// Copyright 2021 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_AVL_AVL_H
 #define GRPC_CORE_LIB_AVL_AVL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <grpc/support/sync.h>
-
-/** internal node of an AVL tree */
-typedef struct grpc_avl_node {
-  gpr_refcount refs;
-  void* key;
-  void* value;
-  struct grpc_avl_node* left;
-  struct grpc_avl_node* right;
-  long height;
-} grpc_avl_node;
-
-/** vtable for the AVL tree
- * The optional user_data is propagated from the top level grpc_avl_XXX API.
- * From the same API call, multiple vtable functions may be called multiple
- * times.
- */
-typedef struct grpc_avl_vtable {
-  /** destroy a key */
-  void (*destroy_key)(void* key, void* user_data);
-  /** copy a key, returning new value */
-  void* (*copy_key)(void* key, void* user_data);
-  /** compare key1, key2; return <0 if key1 < key2,
-      >0 if key1 > key2, 0 if key1 == key2 */
-  long (*compare_keys)(void* key1, void* key2, void* user_data);
-  /** destroy a value */
-  void (*destroy_value)(void* value, void* user_data);
-  /** copy a value */
-  void* (*copy_value)(void* value, void* user_data);
-} grpc_avl_vtable;
-
-/** "pointer" to an AVL tree - this is a reference
-    counted object - use grpc_avl_ref to add a reference,
-    grpc_avl_unref when done with a reference */
-typedef struct grpc_avl {
-  const grpc_avl_vtable* vtable;
-  grpc_avl_node* root;
-} grpc_avl;
-
-/** Create an immutable AVL tree. */
-grpc_avl grpc_avl_create(const grpc_avl_vtable* vtable);
-/** Add a reference to an existing tree - returns
-    the tree as a convenience. The optional user_data will be passed to vtable
-    functions. */
-grpc_avl grpc_avl_ref(grpc_avl avl, void* user_data);
-/** Remove a reference to a tree - destroying it if there
-    are no references left. The optional user_data will be passed to vtable
-    functions. */
-void grpc_avl_unref(grpc_avl avl, void* user_data);
-/** Return a new tree with (key, value) added to avl.
-    implicitly unrefs avl to allow easy chaining.
-    if key exists in avl, the new tree's key entry updated
-    (i.e. a duplicate is not created). The optional user_data will be passed to
-    vtable functions. */
-grpc_avl grpc_avl_add(grpc_avl avl, void* key, void* value, void* user_data);
-/** Return a new tree with key deleted
-    implicitly unrefs avl to allow easy chaining. The optional user_data will be
-    passed to vtable functions. */
-grpc_avl grpc_avl_remove(grpc_avl avl, void* key, void* user_data);
-/** Lookup key, and return the associated value.
-    Does not mutate avl.
-    Returns NULL if key is not found. The optional user_data will be passed to
-    vtable functions.*/
-void* grpc_avl_get(grpc_avl avl, void* key, void* user_data);
-/** Return 1 if avl contains key, 0 otherwise; if it has the key, sets *value to
-    its value. The optional user_data will be passed to vtable functions. */
-int grpc_avl_maybe_get(grpc_avl avl, void* key, void** value, void* user_data);
-/** Return 1 if avl is empty, 0 otherwise */
-int grpc_avl_is_empty(grpc_avl avl);
-
-#endif /* GRPC_CORE_LIB_AVL_AVL_H */
+#include <stdlib.h>
+
+#include <algorithm>
+#include <memory>
+
+namespace grpc_core {
+
+template <class K, class V = void>
+class AVL {
+ public:
+  AVL() {}
+
+  AVL Add(K key, V value) const {
+    return AVL(AddKey(root_, std::move(key), std::move(value)));
+  }
+  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
+  const V* Lookup(const K& key) const {
+    NodePtr n = Get(root_, key);
+    return n ? &n->kv.second : nullptr;
+  }
+
+  const std::pair<K, V>* LookupBelow(const K& key) const {
+    NodePtr n = GetBelow(root_, *key);
+    return n ? &n->kv : nullptr;
+  }
+
+  bool Empty() const { return root_ == nullptr; }
+
+  template <class F>
+  void ForEach(F&& f) const {
+    ForEachImpl(root_.get(), std::forward<F>(f));
+  }
+
+  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+
+ private:
+  struct Node;
+  typedef std::shared_ptr<Node> NodePtr;
+  struct Node : public std::enable_shared_from_this<Node> {
+    Node(K k, V v, NodePtr l, NodePtr r, long h)
+        : kv(std::move(k), std::move(v)),
+          left(std::move(l)),
+          right(std::move(r)),
+          height(h) {}
+    const std::pair<K, V> kv;
+    const NodePtr left;
+    const NodePtr right;
+    const long height;
+  };
+  NodePtr root_;
+
+  explicit AVL(NodePtr root) : root_(std::move(root)) {}
+
+  template <class F>
+  static void ForEachImpl(const Node* n, F&& f) {
+    if (n == nullptr) return;
+    ForEachImpl(n->left.get(), std::forward<F>(f));
+    f(const_cast<const K&>(n->kv.first), const_cast<const V&>(n->kv.second));
+    ForEachImpl(n->right.get(), std::forward<F>(f));
+  }
+
+  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+
+  static NodePtr MakeNode(K key, V value, const NodePtr& left,
+                          const NodePtr& right) {
+    return std::make_shared<Node>(std::move(key), std::move(value), left, right,
+                                  1 + std::max(Height(left), Height(right)));
+  }
+
+  static NodePtr Get(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+
+    if (node->kv.first > key) {
+      return Get(node->left, key);
+    } else if (node->kv.first < key) {
+      return Get(node->right, key);
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr GetBelow(const NodePtr& node, const K& key) {
+    if (!node) return nullptr;
+    if (node->kv.first > key) {
+      return GetBelow(node->left, key);
+    } else if (node->kv.first < key) {
+      NodePtr n = GetBelow(node->right, key);
+      if (n == nullptr) n = node;
+      return n;
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr RotateLeft(K key, V value, const NodePtr& left,
+                            const NodePtr& right) {
+    return MakeNode(
+        right->kv.first, right->kv.second,
+        MakeNode(std::move(key), std::move(value), left, right->left),
+        right->right);
+  }
+
+  static NodePtr RotateRight(K key, V value, const NodePtr& left,
+                             const NodePtr& right) {
+    return MakeNode(
+        left->kv.first, left->kv.second, left->left,
+        MakeNode(std::move(key), std::move(value), left->right, right));
+  }
+
+  static NodePtr RotateLeftRight(K key, V value, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_right(..., rotate_left(left), right) */
+    return MakeNode(
+        left->right->kv.first, left->right->kv.second,
+        MakeNode(left->kv.first, left->kv.second, left->left,
+                 left->right->left),
+        MakeNode(std::move(key), std::move(value), left->right->right, right));
+  }
+
+  static NodePtr RotateRightLeft(K key, V value, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_left(..., left, rotate_right(right)) */
+    return MakeNode(
+        right->left->kv.first, right->left->kv.second,
+        MakeNode(std::move(key), std::move(value), left, right->left->left),
+        MakeNode(right->kv.first, right->kv.second, right->left->right,
+                 right->right));
+  }
+
+  static NodePtr Rebalance(K key, V value, const NodePtr& left,
+                           const NodePtr& right) {
+    switch (Height(left) - Height(right)) {
+      case 2:
+        if (Height(left->left) - Height(left->right) == -1) {
+          return RotateLeftRight(std::move(key), std::move(value), left, right);
+        } else {
+          return RotateRight(std::move(key), std::move(value), left, right);
+        }
+      case -2:
+        if (Height(right->left) - Height(right->right) == 1) {
+          return RotateRightLeft(std::move(key), std::move(value), left, right);
+        } else {
+          return RotateLeft(std::move(key), std::move(value), left, right);
+        }
+      default:
+        return MakeNode(key, value, left, right);
+    }
+  }
+
+  static NodePtr AddKey(const NodePtr& node, K key, V value) {
+    if (!node) {
+      return MakeNode(std::move(key), std::move(value), nullptr, nullptr);
+    }
+    if (node->kv.first < key) {
+      return Rebalance(node->kv.first, node->kv.second, node->left,
+                       AddKey(node->right, std::move(key), std::move(value)));
+    }
+    if (key < node->kv.first) {
+      return Rebalance(node->kv.first, node->kv.second,
+                       AddKey(node->left, std::move(key), std::move(value)),
+                       node->right);
+    }
+    return MakeNode(std::move(key), std::move(value), node->left, node->right);
+  }
+
+  static NodePtr InOrderHead(NodePtr node) {
+    while (node->left != nullptr) {
+      node = node->left;
+    }
+    return node;
+  }
+
+  static NodePtr InOrderTail(NodePtr node) {
+    while (node->right != nullptr) {
+      node = node->right;
+    }
+    return node;
+  }
+
+  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (key < node->kv.first) {
+      return Rebalance(node->kv.first, node->kv.second,
+                       RemoveKey(node->left, key), node->right);
+    } else if (node->kv.first < key) {
+      return Rebalance(node->kv.first, node->kv.second, node->left,
+                       RemoveKey(node->right, key));
+    } else {
+      if (node->left == nullptr) {
+        return node->right;
+      } else if (node->right == nullptr) {
+        return node->left;
+      } else if (node->left->height < node->right->height) {
+        NodePtr h = InOrderHead(node->right);
+        return Rebalance(h->kv.first, h->kv.second, node->left,
+                         RemoveKey(node->right, h->kv.first));
+      } else {
+        NodePtr h = InOrderTail(node->left);
+        return Rebalance(h->kv.first, h->kv.second,
+                         RemoveKey(node->left, h->kv.first), node->right);
+      }
+    }
+    abort();
+  }
+};
+
+template <class K>
+class AVL<K, void> {
+ public:
+  AVL() {}
+
+  AVL Add(K key) const { return AVL(AddKey(root_, std::move(key))); }
+  AVL Remove(const K& key) const { return AVL(RemoveKey(root_, key)); }
+  bool Lookup(const K& key) const { return Get(root_, key) != nullptr; }
+  bool Empty() const { return root_ == nullptr; }
+
+  template <class F>
+  void ForEach(F&& f) const {
+    ForEachImpl(root_.get(), std::forward<F>(f));
+  }
+
+  bool SameIdentity(AVL avl) const { return root_ == avl.root_; }
+
+ private:
+  struct Node;
+  typedef std::shared_ptr<Node> NodePtr;
+  struct Node : public std::enable_shared_from_this<Node> {
+    Node(K k, NodePtr l, NodePtr r, long h)
+        : key(std::move(k)),
+          left(std::move(l)),
+          right(std::move(r)),
+          height(h) {}
+    const K key;
+    const NodePtr left;
+    const NodePtr right;
+    const long height;
+  };
+  NodePtr root_;
+
+  explicit AVL(NodePtr root) : root_(std::move(root)) {}
+
+  template <class F>
+  static void ForEachImpl(const Node* n, F&& f) {
+    if (n == nullptr) return;
+    ForEachImpl(n->left.get(), std::forward<F>(f));
+    f(const_cast<const K&>(n->key));
+    ForEachImpl(n->right.get(), std::forward<F>(f));
+  }
+
+  static long Height(const NodePtr& n) { return n ? n->height : 0; }
+
+  static NodePtr MakeNode(K key, const NodePtr& left, const NodePtr& right) {
+    return std::make_shared<Node>(std::move(key), left, right,
+                                  1 + std::max(Height(left), Height(right)));
+  }
+
+  static NodePtr Get(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+
+    if (node->key > key) {
+      return Get(node->left, key);
+    } else if (node->key < key) {
+      return Get(node->right, key);
+    } else {
+      return node;
+    }
+  }
+
+  static NodePtr RotateLeft(K key, const NodePtr& left, const NodePtr& right) {
+    return MakeNode(right->key, MakeNode(std::move(key), left, right->left),
+                    right->right);
+  }
+
+  static NodePtr RotateRight(K key, const NodePtr& left, const NodePtr& right) {
+    return MakeNode(left->key, left->left,
+                    MakeNode(std::move(key), left->right, right));
+  }
+
+  static NodePtr RotateLeftRight(K key, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_right(..., rotate_left(left), right) */
+    return MakeNode(left->right->key,
+                    MakeNode(left->key, left->left, left->right->left),
+                    MakeNode(std::move(key), left->right->right, right));
+  }
+
+  static NodePtr RotateRightLeft(K key, const NodePtr& left,
+                                 const NodePtr& right) {
+    /* rotate_left(..., left, rotate_right(right)) */
+    return MakeNode(right->left->key,
+                    MakeNode(std::move(key), left, right->left->left),
+                    MakeNode(right->key, right->left->right, right->right));
+  }
+
+  static NodePtr Rebalance(K key, const NodePtr& left, const NodePtr& right) {
+    switch (Height(left) - Height(right)) {
+      case 2:
+        if (Height(left->left) - Height(left->right) == -1) {
+          return RotateLeftRight(std::move(key), left, right);
+        } else {
+          return RotateRight(std::move(key), left, right);
+        }
+      case -2:
+        if (Height(right->left) - Height(right->right) == 1) {
+          return RotateRightLeft(std::move(key), left, right);
+        } else {
+          return RotateLeft(std::move(key), left, right);
+        }
+      default:
+        return MakeNode(key, left, right);
+    }
+  }
+
+  static NodePtr AddKey(const NodePtr& node, K key) {
+    if (!node) {
+      return MakeNode(std::move(key), nullptr, nullptr);
+    }
+    if (node->key < key) {
+      return Rebalance(node->key, node->left,
+                       AddKey(node->right, std::move(key)));
+    }
+    if (key < node->key) {
+      return Rebalance(node->key, AddKey(node->left, std::move(key)),
+                       node->right);
+    }
+    return MakeNode(std::move(key), node->left, node->right);
+  }
+
+  static NodePtr InOrderHead(NodePtr node) {
+    while (node->left != nullptr) {
+      node = node->left;
+    }
+    return node;
+  }
+
+  static NodePtr InOrderTail(NodePtr node) {
+    while (node->right != nullptr) {
+      node = node->right;
+    }
+    return node;
+  }
+
+  static NodePtr RemoveKey(const NodePtr& node, const K& key) {
+    if (node == nullptr) {
+      return nullptr;
+    }
+    if (key < node->key) {
+      return Rebalance(node->key, RemoveKey(node->left, key), node->right);
+    } else if (node->key < key) {
+      return Rebalance(node->key, node->left, RemoveKey(node->right, key));
+    } else {
+      if (node->left == nullptr) {
+        return node->right;
+      } else if (node->right == nullptr) {
+        return node->left;
+      } else if (node->left->height < node->right->height) {
+        NodePtr h = InOrderHead(node->right);
+        return Rebalance(h->key, node->left, RemoveKey(node->right, h->key));
+      } else {
+        NodePtr h = InOrderTail(node->left);
+        return Rebalance(h->key, RemoveKey(node->left, h->key), node->right);
+      }
+    }
+    abort();
+  }
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_AVL_AVL_H

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

@@ -55,7 +55,7 @@ BackOff::BackOff(const Options& options)
 grpc_millis BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
-    return current_backoff_ + grpc_core::ExecCtx::Get()->Now();
+    return current_backoff_ + ExecCtx::Get()->Now();
   }
   current_backoff_ = static_cast<grpc_millis>(
       std::min(current_backoff_ * options_.multiplier(),
@@ -65,7 +65,7 @@ grpc_millis BackOff::NextAttemptTime() {
       options_.jitter() * current_backoff_);
   const grpc_millis next_timeout =
       static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + grpc_core::ExecCtx::Get()->Now();
+  return next_timeout + ExecCtx::Get()->Now();
 }
 
 void BackOff::Reset() {

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

@@ -29,7 +29,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
-#include <grpc/grpc.h>
 #include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
@@ -73,22 +72,6 @@ grpc_channel_args* grpc_channel_args_copy_and_remove(
                                                    num_to_remove, nullptr, 0);
 }
 
-grpc_channel_args* grpc_channel_args_remove_grpc_internal(
-    const grpc_channel_args* src) {
-  if (src == nullptr) return nullptr;
-  // Create result.
-  grpc_channel_args* dst =
-      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
-  dst->args =
-      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
-  dst->num_args = 0;
-  for (size_t i = 0; i < src->num_args; ++i) {
-    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
-    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
-  }
-  return dst;
-}
-
 static bool should_remove_arg(const grpc_arg* arg, const char** to_remove,
                               size_t num_to_remove) {
   for (size_t i = 0; i < num_to_remove; ++i) {
@@ -385,6 +368,23 @@ std::string grpc_channel_args_string(const grpc_channel_args* args) {
   return absl::StrJoin(arg_strings, ", ");
 }
 
+namespace grpc_core {
+const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src) {
+  if (src == nullptr) return nullptr;
+  // Create result.
+  grpc_channel_args* dst =
+      static_cast<grpc_channel_args*>(gpr_malloc(sizeof(grpc_channel_args)));
+  dst->args =
+      static_cast<grpc_arg*>(gpr_malloc(sizeof(grpc_arg) * src->num_args));
+  dst->num_args = 0;
+  for (size_t i = 0; i < src->num_args; ++i) {
+    if (absl::StartsWith(src->args[i].key, "grpc.internal.")) continue;
+    dst->args[dst->num_args++] = copy_arg(&src->args[i]);
+  }
+  return dst;
+}
+}  // namespace grpc_core
+
 namespace {
 grpc_channel_args_client_channel_creation_mutator g_mutator = nullptr;
 }  // namespace

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

@@ -23,7 +23,7 @@
 
 #include <string>
 
-#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 
 #include "src/core/lib/surface/channel_stack_type.h"
 
@@ -41,15 +41,6 @@ grpc_channel_args* grpc_channel_args_copy_and_add(const grpc_channel_args* src,
                                                   const grpc_arg* to_add,
                                                   size_t num_to_add);
 
-/** Remove any channel args prefixed with 'grpc.internal.'
- *  These are used for internal implementation details and are not intended to
- *  be exposed to users.
- *  Returns a new channel args instance.
- *  Does not take ownership of \a src.
- *  Should be called by any public API that receives channel args. */
-grpc_channel_args* grpc_channel_args_remove_grpc_internal(
-    const grpc_channel_args* src);
-
 /** Copies the arguments in \a src except for those whose keys are in
     \a to_remove. */
 grpc_channel_args* grpc_channel_args_copy_and_remove(
@@ -128,6 +119,16 @@ grpc_arg grpc_channel_arg_pointer_create(char* name, void* value,
 // Returns a string representing channel args in human-readable form.
 std::string grpc_channel_args_string(const grpc_channel_args* args);
 
+namespace grpc_core {
+/** Remove any channel args prefixed with 'grpc.internal.'
+ *  These are used for internal implementation details and are not intended to
+ *  be exposed to users.
+ *  Returns a new channel args instance.
+ *  Does not take ownership of \a src.
+ *  Should be called by any public API that receives channel args. */
+const grpc_channel_args* RemoveGrpcInternalArgs(const grpc_channel_args* src);
+}  // namespace grpc_core
+
 // Takes ownership of the old_args
 typedef grpc_channel_args* (*grpc_channel_args_client_channel_creation_mutator)(
     const char* target, grpc_channel_args* old_args,

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

@@ -0,0 +1,47 @@
+// Copyright 2021 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/channel/channel_args_preconditioning.h"
+
+#include <grpc/support/alloc.h>
+
+namespace grpc_core {
+
+void ChannelArgsPreconditioning::Builder::RegisterStage(Stage stage) {
+  stages_.emplace_back(std::move(stage));
+}
+
+ChannelArgsPreconditioning ChannelArgsPreconditioning::Builder::Build() {
+  // TODO(ctiller): should probably make this registered too.
+  stages_.emplace_back(RemoveGrpcInternalArgs);
+
+  ChannelArgsPreconditioning preconditioning;
+  preconditioning.stages_ = std::move(stages_);
+  return preconditioning;
+}
+
+const grpc_channel_args* ChannelArgsPreconditioning::PreconditionChannelArgs(
+    const grpc_channel_args* args) const {
+  const grpc_channel_args* owned_args = nullptr;
+  for (auto& stage : stages_) {
+    args = stage(args);
+    grpc_channel_args_destroy(owned_args);
+    owned_args = args;
+  }
+  return args;
+}
+
+}  // namespace grpc_core