grpc 1.42.0 → 1.51.0

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

@@ -1,94 +1,482 @@
-/*
- *
- * 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>  // IWYU pragma: keep
+#include <memory>
+#include <utility>
+
+#include "src/core/lib/gpr/useful.h"
+
+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)));
+  }
+  template <typename SomethingLikeK>
+  AVL Remove(const SomethingLikeK& key) const {
+    return AVL(RemoveKey(root_, key));
+  }
+  template <typename SomethingLikeK>
+  const V* Lookup(const SomethingLikeK& 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(const AVL& avl) const { return root_ == avl.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 != 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 {
+    return QsortCompare(*this, other) < 0;
+  }
+
+ 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_;
+
+  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(n);
+        n = n->left.get();
+      }
+    }
+    Node* current() const { return stack_.Empty() ? nullptr : stack_.Back(); }
+    void MoveNext() {
+      auto* n = stack_.Pop();
+      if (n->right != nullptr) {
+        n = n->right.get();
+        while (n != nullptr) {
+          stack_.Push(n);
+          n = n->left.get();
+        }
+      }
+    }
+
+   private:
+    IteratorStack stack_;
+  };
+
+  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)));
+  }
+
+  template <typename SomethingLikeK>
+  static NodePtr Get(const NodePtr& node, const SomethingLikeK& 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;
+  }
+
+  template <typename SomethingLikeK>
+  static NodePtr RemoveKey(const NodePtr& node, const SomethingLikeK& 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

@@ -22,50 +22,21 @@
 
 #include <algorithm>
 
-#include "src/core/lib/gpr/useful.h"
-
 namespace grpc_core {
 
-namespace {
-
-/* Generate a random number between 0 and 1. We roll our own RNG because seeding
- * rand() modifies a global variable we have no control over. */
-double generate_uniform_random_number(uint32_t* rng_state) {
-  constexpr uint32_t two_raise_31 = uint32_t(1) << 31;
-  *rng_state = (1103515245 * *rng_state + 12345) % two_raise_31;
-  return *rng_state / static_cast<double>(two_raise_31);
-}
-
-double generate_uniform_random_number_between(uint32_t* rng_state, double a,
-                                              double b) {
-  if (a == b) return a;
-  if (a > b) std::swap(a, b);  // make sure a < b
-  const double range = b - a;
-  return a + generate_uniform_random_number(rng_state) * range;
-}
+BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
-}  // namespace
-
-BackOff::BackOff(const Options& options)
-    : options_(options),
-      rng_state_(static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec)) {
-  Reset();
-}
-
-grpc_millis BackOff::NextAttemptTime() {
+Timestamp BackOff::NextAttemptTime() {
   if (initial_) {
     initial_ = false;
-    return current_backoff_ + grpc_core::ExecCtx::Get()->Now();
+    return current_backoff_ + Timestamp::Now();
   }
-  current_backoff_ = static_cast<grpc_millis>(
-      std::min(current_backoff_ * options_.multiplier(),
-               static_cast<double>(options_.max_backoff())));
-  const double jitter = generate_uniform_random_number_between(
-      &rng_state_, -options_.jitter() * current_backoff_,
-      options_.jitter() * current_backoff_);
-  const grpc_millis next_timeout =
-      static_cast<grpc_millis>(current_backoff_ + jitter);
-  return next_timeout + grpc_core::ExecCtx::Get()->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 Timestamp::Now() + current_backoff_ + jitter;
 }
 
 void BackOff::Reset() {
@@ -73,6 +44,4 @@ void BackOff::Reset() {
   initial_ = true;
 }
 
-void BackOff::SetRandomSeed(uint32_t seed) { rng_state_ = seed; }
-
 }  // namespace grpc_core