grpc 1.52.0 → 1.53.0.pre2

data/src/core/lib/promise/poll.h

@@ -12,16 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_POLL_H
-#define GRPC_CORE_LIB_PROMISE_POLL_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_POLL_H
+#define GRPC_SRC_CORE_LIB_PROMISE_POLL_H
 
 #include <grpc/support/port_platform.h>
 
-#include <stddef.h>
-
 #include <string>
+#include <utility>
+
+#include <grpc/support/log.h>
 
-#include "absl/types/variant.h"
+#include "src/core/lib/gprpp/construct_destruct.h"
 
 namespace grpc_core {
 
@@ -43,17 +44,115 @@ struct Empty {
 // Can be either pending - the Promise has not yet completed, or ready -
 // indicating that the Promise has completed AND should not be polled again.
 template <typename T>
-using Poll = absl::variant<Pending, T>;
+class Poll {
+ public:
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Poll(Pending) : ready_(false) {}
+  Poll() : ready_(false) {}
+  Poll(const Poll& other) : ready_(other.ready_) {
+    if (ready_) Construct(&value_, other.value_);
+  }
+  Poll(Poll&& other) noexcept : ready_(other.ready_) {
+    if (ready_) Construct(&value_, std::move(other.value_));
+  }
+  Poll& operator=(const Poll& other) {
+    if (ready_) {
+      if (other.ready_) {
+        value_ = other.value_;
+      } else {
+        Destruct(&value_);
+        ready_ = false;
+      }
+    } else if (other.ready_) {
+      Construct(&value_, other.value_);
+      ready_ = true;
+    }
+    return *this;
+  }
+  Poll& operator=(Poll&& other) noexcept {
+    if (ready_) {
+      if (other.ready_) {
+        value_ = std::move(other.value_);
+      } else {
+        Destruct(&value_);
+        ready_ = false;
+      }
+    } else if (other.ready_) {
+      Construct(&value_, std::move(other.value_));
+      ready_ = true;
+    }
+    return *this;
+  }
+  template <typename U>
+  // NOLINTNEXTLINE(google-explicit-constructor)
+  Poll(U value) : ready_(true) {
+    Construct(&value_, std::move(value));
+  }
+  ~Poll() {
+    if (ready_) Destruct(&value_);
+  }
+
+  bool pending() const { return !ready_; }
+  bool ready() const { return ready_; }
+
+  T& value() {
+    GPR_DEBUG_ASSERT(ready());
+    return value_;
+  }
+
+  const T& value() const {
+    GPR_DEBUG_ASSERT(ready());
+    return value_;
+  }
+
+  T* value_if_ready() {
+    if (ready()) return &value_;
+    return nullptr;
+  }
+
+  const T* value_if_ready() const {
+    if (ready()) return &value_;
+    return nullptr;
+  }
+
+ private:
+  // Flag indicating readiness, followed by an optional value.
+  //
+  // Why not optional<T>?
+  //
+  // We have cases where we want to return absl::nullopt{} from a promise, and
+  // have that upgraded to a Poll<absl::nullopt_t> prior to a cast to some
+  // Poll<optional<T>>.
+  //
+  // Since optional<nullopt_t> is not allowed, we'd not be allowed to make
+  // Poll<nullopt_t> and so we'd need to pollute all poll handling code with
+  // some edge case handling template magic - the complexity would explode and
+  // grow over time - versus hand coding the pieces we need here and containing
+  // that quirk to one place.
+  bool ready_;
+  // We do a single element union so we can choose when to construct/destruct
+  // this value.
+  union {
+    T value_;
+  };
+};
+
+template <>
+class Poll<Pending>;
+
+template <typename T>
+bool operator==(const Poll<T>& a, const Poll<T>& b) {
+  if (a.pending() && b.pending()) return true;
+  if (a.ready() && b.ready()) return a.value() == b.value();
+  return false;
+}
 
 template <typename T, typename U>
 Poll<T> poll_cast(Poll<U> poll) {
-  if (absl::holds_alternative<Pending>(poll)) return Pending{};
-  return std::move(absl::get<U>(poll));
+  if (poll.pending()) return Pending{};
+  return static_cast<T>(std::move(poll.value()));
 }
 
-// Variant of Poll that serves as a ready value
-static constexpr size_t kPollReadyIdx = 1;
-
 // PollTraits tells us whether a type is Poll<> or some other type, and is
 // leveraged in the PromiseLike/PromiseFactory machinery to select the
 // appropriate implementation of those concepts based upon the return type of a
@@ -74,12 +173,12 @@ template <typename T, typename F>
 std::string PollToString(
     const Poll<T>& poll,
     F t_to_string = [](const T& t) { return t.ToString(); }) {
-  if (absl::holds_alternative<Pending>(poll)) {
+  if (poll.pending()) {
     return "<<pending>>";
   }
-  return t_to_string(absl::get<T>(poll));
+  return t_to_string(poll.value());
 }
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_POLL_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_POLL_H

data/src/core/lib/promise/promise.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_PROMISE_H
-#define GRPC_CORE_LIB_PROMISE_PROMISE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_PROMISE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_PROMISE_H
 
 #include <grpc/support/port_platform.h>
 
@@ -23,7 +23,6 @@
 
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
-#include "absl/types/variant.h"
 
 #include "src/core/lib/promise/detail/promise_like.h"
 #include "src/core/lib/promise/poll.h"
@@ -42,7 +41,7 @@ template <typename Promise>
 auto NowOrNever(Promise promise)
     -> absl::optional<typename promise_detail::PromiseLike<Promise>::Result> {
   auto r = promise_detail::PromiseLike<Promise>(std::move(promise))();
-  if (auto* p = absl::get_if<kPollReadyIdx>(&r)) {
+  if (auto* p = r.value_if_ready()) {
     return std::move(*p);
   }
   return {};
@@ -93,4 +92,4 @@ auto WithResult(F f) ->
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_PROMISE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_PROMISE_H

data/src/core/lib/promise/race.h

@@ -12,16 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_RACE_H
-#define GRPC_CORE_LIB_PROMISE_RACE_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_RACE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_RACE_H
 
 #include <grpc/support/port_platform.h>
 
 #include <type_traits>
-
-#include "absl/types/variant.h"
-
-#include "src/core/lib/promise/poll.h"
+#include <utility>
 
 namespace grpc_core {
 
@@ -42,12 +39,12 @@ class Race<Promise, Promises...> {
   Result operator()() {
     // Check our own promise.
     auto r = promise_();
-    if (absl::holds_alternative<Pending>(r)) {
+    if (r.pending()) {
       // Check the rest of them.
       return next_();
     }
     // Return the first ready result.
-    return std::move(absl::get<kPollReadyIdx>(std::move(r)));
+    return std::move(r.value());
   }
 
  private:
@@ -80,4 +77,4 @@ promise_detail::Race<Promises...> Race(Promises... promises) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_RACE_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_RACE_H

data/src/core/lib/promise/seq.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_SEQ_H
-#define GRPC_CORE_LIB_PROMISE_SEQ_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_SEQ_H
+#define GRPC_SRC_CORE_LIB_PROMISE_SEQ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -104,4 +104,4 @@ SeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_SEQ_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_SEQ_H

data/src/core/lib/promise/sleep.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_SLEEP_H
-#define GRPC_CORE_LIB_PROMISE_SLEEP_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_SLEEP_H
+#define GRPC_SRC_CORE_LIB_PROMISE_SLEEP_H
 
 #include <grpc/support/port_platform.h>
 
@@ -81,4 +81,4 @@ class Sleep final {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_SLEEP_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_SLEEP_H

data/src/core/lib/promise/{pipe.cc → trace.cc}

@@ -14,6 +14,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/promise/pipe.h"
+#include "src/core/lib/promise/trace.h"
 
-grpc_core::DebugOnlyTraceFlag grpc_trace_promise_pipe(false, "promise_pipe");
+grpc_core::DebugOnlyTraceFlag grpc_trace_promise_primitives(
+    false, "promise_primitives");

data/src/core/lib/promise/trace.h

@@ -0,0 +1,24 @@
+// Copyright 2022 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_SRC_CORE_LIB_PROMISE_TRACE_H
+#define GRPC_SRC_CORE_LIB_PROMISE_TRACE_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/debug/trace.h"
+
+extern grpc_core::DebugOnlyTraceFlag grpc_trace_promise_primitives;
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_TRACE_H

data/src/core/lib/promise/try_join.h

@@ -0,0 +1,82 @@
+// 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_SRC_CORE_LIB_PROMISE_TRY_JOIN_H
+#define GRPC_SRC_CORE_LIB_PROMISE_TRY_JOIN_H
+
+#include <grpc/support/port_platform.h>
+
+#include <type_traits>
+
+#include "absl/meta/type_traits.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/promise/detail/basic_join.h"
+#include "src/core/lib/promise/detail/status.h"
+#include "src/core/lib/promise/poll.h"
+
+namespace grpc_core {
+
+namespace promise_detail {
+
+// Extract the T from a StatusOr<T>
+template <typename T>
+T IntoResult(absl::StatusOr<T>* status) {
+  return std::move(**status);
+}
+
+// TryJoin returns a StatusOr<tuple<A,B,C>> for f()->Poll<StatusOr<A>>,
+// g()->Poll<StatusOr<B>>, h()->Poll<StatusOr<C>>. If one of those should be a
+// Status instead, we need a placeholder type to return, and this is it.
+inline Empty IntoResult(absl::Status*) { return Empty{}; }
+
+// Traits object to pass to BasicJoin
+struct TryJoinTraits {
+  template <typename T>
+  using ResultType =
+      decltype(IntoResult(std::declval<absl::remove_reference_t<T>*>()));
+  template <typename T, typename F>
+  static auto OnResult(T result, F kontinue)
+      -> decltype(kontinue(IntoResult(&result))) {
+    using Result =
+        typename PollTraits<decltype(kontinue(IntoResult(&result)))>::Type;
+    if (!result.ok()) {
+      return Result(IntoStatus(&result));
+    }
+    return kontinue(IntoResult(&result));
+  }
+  template <typename T>
+  static absl::StatusOr<T> Wrap(T x) {
+    return absl::StatusOr<T>(std::move(x));
+  }
+};
+
+// Implementation of TryJoin combinator.
+template <typename... Promises>
+using TryJoin = BasicJoin<TryJoinTraits, Promises...>;
+
+}  // namespace promise_detail
+
+// Run all promises.
+// If any fail, cancel the rest and return the failure.
+// If all succeed, return Ok(tuple-of-results).
+template <typename... Promises>
+promise_detail::TryJoin<Promises...> TryJoin(Promises... promises) {
+  return promise_detail::TryJoin<Promises...>(std::move(promises)...);
+}
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_TRY_JOIN_H

data/src/core/lib/promise/try_seq.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_PROMISE_TRY_SEQ_H
-#define GRPC_CORE_LIB_PROMISE_TRY_SEQ_H
+#ifndef GRPC_SRC_CORE_LIB_PROMISE_TRY_SEQ_H
+#define GRPC_SRC_CORE_LIB_PROMISE_TRY_SEQ_H
 
 #include <grpc/support/port_platform.h>
 
@@ -172,4 +172,4 @@ TrySeqIter(Iter begin, Iter end, Argument argument, Factory factory) {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_PROMISE_TRY_SEQ_H
+#endif  // GRPC_SRC_CORE_LIB_PROMISE_TRY_SEQ_H

data/src/core/lib/resolver/resolver.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_H
-#define GRPC_CORE_LIB_RESOLVER_RESOLVER_H
+#ifndef GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_H
+#define GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -135,4 +135,4 @@ class Resolver : public InternallyRefCounted<Resolver> {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_H
+#endif  // GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_H

data/src/core/lib/resolver/resolver_factory.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
-#define GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
+#ifndef GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
+#define GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -55,7 +55,7 @@ class ResolverFactory {
   virtual ~ResolverFactory() {}
 
   /// Returns the URI scheme that this factory implements.
-  /// Caller does NOT take ownership of result.
+  /// Must not include any upper-case characters.
   virtual absl::string_view scheme() const = 0;
 
   /// Returns a bool indicating whether the input uri is valid to create a
@@ -74,4 +74,4 @@ class ResolverFactory {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H
+#endif  // GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_FACTORY_H

data/src/core/lib/resolver/resolver_registry.cc

@@ -18,8 +18,11 @@
 
 #include "src/core/lib/resolver/resolver_registry.h"
 
+#include <initializer_list>
+
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
@@ -37,8 +40,20 @@ void ResolverRegistry::Builder::SetDefaultPrefix(std::string default_prefix) {
   state_.default_prefix = std::move(default_prefix);
 }
 
+namespace {
+
+bool IsLowerCase(absl::string_view str) {
+  for (unsigned char c : str) {
+    if (absl::ascii_isalpha(c) && !absl::ascii_islower(c)) return false;
+  }
+  return true;
+}
+
+}  // namespace
+
 void ResolverRegistry::Builder::RegisterResolverFactory(
     std::unique_ptr<ResolverFactory> factory) {
+  GPR_ASSERT(IsLowerCase(factory->scheme()));
   auto p = state_.factories.emplace(factory->scheme(), std::move(factory));
   GPR_ASSERT(p.second);
 }

data/src/core/lib/resolver/resolver_registry.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
-#define GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
+#ifndef GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
+#define GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
 
 #include <grpc/support/port_platform.h>
 
@@ -120,4 +120,4 @@ class ResolverRegistry {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H
+#endif  // GRPC_SRC_CORE_LIB_RESOLVER_RESOLVER_REGISTRY_H

data/src/core/lib/resolver/server_address.cc

@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include <algorithm>
+#include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>

data/src/core/lib/resolver/server_address.h

@@ -16,8 +16,8 @@
 //
 //
 
-#ifndef GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
-#define GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
+#ifndef GRPC_SRC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
+#define GRPC_SRC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -142,4 +142,4 @@ class ServerAddressWeightAttribute : public ServerAddress::AttributeInterface {
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H
+#endif  // GRPC_SRC_CORE_LIB_RESOLVER_SERVER_ADDRESS_H

data/src/core/lib/resource_quota/api.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
-#define GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
+#ifndef GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_API_H
+#define GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_API_H
 
 #include <grpc/support/port_platform.h>
 
@@ -46,4 +46,4 @@ void RegisterResourceQuota(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_LIB_RESOURCE_QUOTA_API_H
+#endif  // GRPC_SRC_CORE_LIB_RESOURCE_QUOTA_API_H

data/src/core/lib/resource_quota/arena.cc

@@ -71,7 +71,7 @@ std::pair<Arena*, void*> Arena::CreateWithAlloc(
   return std::make_pair(new_arena, first_alloc);
 }
 
-size_t Arena::Destroy() {
+void Arena::Destroy() {
   ManagedNewObject* p;
   // Outer loop: clear the managed new object list.
   // We do this repeatedly in case a destructor ends up allocating something.
@@ -82,11 +82,9 @@ size_t Arena::Destroy() {
       Destruct(std::exchange(p, p->next));
     }
   }
-  size_t size = total_used_.load(std::memory_order_relaxed);
   memory_allocator_->Release(total_allocated_.load(std::memory_order_relaxed));
   this->~Arena();
   gpr_free_aligned(this);
-  return size;
 }
 
 void* Arena::AllocZone(size_t size) {
@@ -117,14 +115,43 @@ void Arena::ManagedNewObject::Link(std::atomic<ManagedNewObject*>* head) {
 }
 
 void* Arena::AllocPooled(size_t alloc_size, std::atomic<FreePoolNode*>* head) {
-  FreePoolNode* p = head->load(std::memory_order_acquire);
-  while (p != nullptr) {
-    if (head->compare_exchange_weak(p, p->next, std::memory_order_acq_rel,
-                                    std::memory_order_relaxed)) {
-      return p;
+  // ABA mitigation:
+  // AllocPooled may be called by multiple threads, and to remove a node from
+  // the free list we need to manipulate the next pointer, which may be done
+  // differently by each thread in a naive implementation.
+  // The literature contains various ways of dealing with this. Here we expect
+  // to be mostly single threaded - Arena's are owned by calls and calls don't
+  // do a lot of concurrent work with the pooled allocator. The place that they
+  // do is allocating metadata batches for decoding HPACK headers in chttp2.
+  // So we adopt an approach that is simple and fast for the single threaded
+  // case, and that is also correct in the multi threaded case.
+
+  // First, take ownership of the entire free list. At this point we know that
+  // no other thread can see free nodes and will be forced to allocate.
+  // We think we're mostly single threaded and so that's ok.
+  FreePoolNode* p = head->exchange(nullptr, std::memory_order_acquire);
+  // If there are no nodes in the free list, then go ahead and allocate from the
+  // arena.
+  if (p == nullptr) return Alloc(alloc_size);
+  // We had a non-empty free list... but we own the *entire* free list.
+  // We only want one node, so if there are extras we'd better give them back.
+  if (p->next != nullptr) {
+    // We perform an exchange to do so, but if there were concurrent frees with
+    // this allocation then there'll be a free list that needs to be merged with
+    // ours.
+    FreePoolNode* extra = head->exchange(p->next, std::memory_order_acq_rel);
+    // If there was a free list concurrently created, we merge it into the
+    // overall free list here by simply freeing each node in turn. This is O(n),
+    // but only O(n) in the number of nodes that were freed concurrently, and
+    // again: we think real world use cases are going to see this as mostly
+    // single threaded.
+    while (extra != nullptr) {
+      FreePoolNode* next = extra->next;
+      FreePooled(extra, head);
+      extra = next;
     }
   }
-  return Alloc(alloc_size);
+  return p;
 }
 
 void Arena::FreePooled(void* p, std::atomic<FreePoolNode*>* head) {