[V4] Queue (#64)

* copy in from legacy

* compiling

* no return if no address

* add nullptr fork/call overloads

* tests

* flto auto

* format

* silence warnings

* better tests

* fix typo in comment

* test improvements

* refactor fib.hpp

* add baremetal queue bench

* add benchmark

* moving about concepts

* pass by value

* return pre-push size

* add when empty

Author: ConorWilliams

CMakeLists.txt

@@ -64,6 +64,7 @@ target_sources(libfork_libfork
       src/core/tuple.cxx
       src/core/ops.cxx
       src/core/context.cxx
+      src/core/deque.cxx
     PRIVATE
       src/exception.cpp
 )

CMakePresets.json

@@ -32,7 +32,7 @@
       "displayName": "Debug with warnings and hardening",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Debug",
-        "CMAKE_CXX_FLAGS": "-O2 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wcast-qual -Wformat -Wformat=2 -Wundef -Werror=float-equal -Wshadow -Wcast-align -Wunused -Wnull-dereference -Wdouble-promotion -Wimplicit-fallthrough -Wextra-semi -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast -Werror=format-security -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -D_GLIBCXX_ASSERTIONS -fstrict-flex-arrays=3 -fstack-protector-strong -Wno-missing-braces"
+        "CMAKE_CXX_FLAGS": "-O2 -Wall -Wextra -Wpedantic -Wconversion -Wsign-conversion -Wcast-qual -Wformat -Wformat=2 -Wundef -Werror=float-equal -Wshadow -Wcast-align -Wunused -Wnull-dereference -Wdouble-promotion -Wimplicit-fallthrough -Wextra-semi -Woverloaded-virtual -Wnon-virtual-dtor -Wold-style-cast -Werror=format-security -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=3 -D_GLIBCXX_ASSERTIONS -fstrict-flex-arrays=3 -fstack-protector-strong -Wno-missing-braces -Wno-missing-field-initializers"
       }
     },
     {
@@ -41,7 +41,7 @@
       "displayName": "Release",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_FLAGS": "-O3 -DNDEBUG -flto -march=native"
+        "CMAKE_CXX_FLAGS": "-O3 -DNDEBUG -flto=auto -march=native"
       }
     },
     {
@@ -50,7 +50,7 @@
       "displayName": "Release no RTTI or exceptions",
       "cacheVariables": {
         "CMAKE_BUILD_TYPE": "Release",
-        "CMAKE_CXX_FLAGS": "-O3 -DNDEBUG -flto -march=native -fno-exceptions -fno-rtti"
+        "CMAKE_CXX_FLAGS": "-O3 -DNDEBUG -flto=auto -march=native -fno-exceptions -fno-rtti"
       }
     },
     {

benchmark/src/libfork_benchmark/fib/baremetal.cpp

@@ -11,8 +11,22 @@
 
 namespace {
 
+// ==== Allocators ==== //
+
+constinit inline thread_local std::byte *tls_bump_ptr = nullptr;
+
 struct task {
-  struct promise_type : tls_bump {
+  struct promise_type {
+
+    static auto operator new(std::size_t sz) -> void * {
+      auto *prev = tls_bump_ptr;
+      tls_bump_ptr += fib_align_size(sz);
+      return prev;
+    }
+
+    static auto operator delete(void *p, [[maybe_unused]] std::size_t sz) noexcept -> void {
+      tls_bump_ptr = std::bit_cast<std::byte *>(p);
+    }
 
     auto get_return_object() -> task { return {std::coroutine_handle<promise_type>::from_promise(*this)}; }
 
@@ -96,7 +110,53 @@ void fib_coro_no_queue(benchmark::State &state) {
   }
 }
 
+// === Recursive with Deque overhead
+
+constinit inline thread_local lf::deque<std::int64_t> *tls_deque = nullptr;
+
+LF_NO_INLINE
+auto deque() -> lf::deque<std::int64_t> & { return *tls_deque; }
+
+auto fib_recursive_deque_impl(std::int64_t n) -> std::int64_t {
+  if (n <= 1) {
+    return n;
+  }
+
+  // Emulate work item creation/scheduling overhead
+  deque().push(n);
+  std::int64_t a = fib_recursive_deque_impl(n - 1);
+  deque().pop();
+
+  std::int64_t b = fib_recursive_deque_impl(n - 2);
+
+  return a + b;
+}
+
+void fib_recursive_deque(benchmark::State &state) {
+
+  std::int64_t n = state.range(0);
+  std::int64_t expect = fib_ref(n);
+
+  state.counters["n"] = static_cast<double>(n);
+
+  lf::deque<std::int64_t> deque;
+  tls_deque = &deque;
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(n);
+    std::int64_t result = fib_recursive_deque_impl(n);
+    CHECK_RESULT(result, expect);
+    benchmark::DoNotOptimize(result);
+  }
+
+  tls_deque = nullptr;
+}
+
 } // namespace
 
-BENCHMARK(fib_coro_no_queue)->Name("test/baremetal/fib")->Arg(fib_test);
-BENCHMARK(fib_coro_no_queue)->Name("base/baremetal/fib")->Arg(fib_base);
+// Minimal coroutine, bump allocated (thread-local) stack
+BENCHMARK(fib_coro_no_queue)->Name("test/baremetal/fib/coro")->Arg(fib_test);
+BENCHMARK(fib_coro_no_queue)->Name("base/baremetal/fib/coro")->Arg(fib_base);
+
+BENCHMARK(fib_recursive_deque)->Name("test/baremetal/fib/deque")->Arg(fib_test);
+BENCHMARK(fib_recursive_deque)->Name("base/baremetal/fib/deque")->Arg(fib_base);

benchmark/src/libfork_benchmark/fib/fib.hpp

@@ -35,69 +35,7 @@ constexpr auto fib_ref(std::int64_t n) -> std::int64_t {
   return curr;
 }
 
-// === Shared Allocator Logic ===
-
-inline constexpr std::size_t k_fib_align = 2 * sizeof(void *);
-
 [[nodiscard]]
 inline auto fib_align_size(std::size_t n) -> std::size_t {
-  return (n + k_fib_align - 1) & ~(k_fib_align - 1);
+  return (n + lf::k_new_align - 1) & ~(lf::k_new_align - 1);
 }
-
-constinit inline thread_local std::byte *tls_bump_ptr = nullptr;
-
-struct tls_bump {
-
-  static auto operator new(std::size_t sz) -> void * {
-    auto *prev = tls_bump_ptr;
-    tls_bump_ptr += fib_align_size(sz);
-    return prev;
-  }
-
-  static auto operator delete(void *p, [[maybe_unused]] std::size_t sz) noexcept -> void {
-    tls_bump_ptr = std::bit_cast<std::byte *>(p);
-  }
-};
-
-// === Shared Context Logic ===
-
-template <lf::stack_allocator Alloc>
-struct vector_ctx {
-
-  using handle_type = lf::frame_handle<vector_ctx>;
-
-  std::vector<handle_type> work;
-  Alloc allocator;
-
-  vector_ctx() { work.reserve(1024); }
-
-  auto alloc() noexcept -> Alloc & { return allocator; }
-
-  // TODO: try LF_NO_INLINE for final allocator
-  LF_NO_INLINE
-  void push(handle_type handle) { work.push_back(handle); }
-
-  auto pop() noexcept -> handle_type {
-    auto handle = work.back();
-    work.pop_back();
-    return handle;
-  }
-};
-
-template <lf::stack_allocator Alloc>
-struct poly_vector_ctx final : lf::polymorphic_context<Alloc> {
-
-  using handle_type = lf::frame_handle<lf::polymorphic_context<Alloc>>;
-
-  std::vector<handle_type> work;
-
-  poly_vector_ctx() { work.reserve(1024); }
-
-  void push(handle_type handle) override { work.push_back(handle); }
-
-  auto pop() noexcept -> handle_type override {
-    auto handle = work.back();
-    work.pop_back();
-    return handle;
-  }
-};

benchmark/src/libfork_benchmark/fib/lf_parts.cpp

@@ -46,6 +46,62 @@ struct linear_allocator {
 
 static_assert(lf::stack_allocator<linear_allocator>);
 
+template <lf::stack_allocator Alloc>
+struct vector_ctx {
+
+  using handle_type = lf::frame_handle<vector_ctx>;
+
+  std::vector<handle_type> work;
+  Alloc allocator;
+
+  vector_ctx() { work.reserve(1024); }
+
+  auto alloc() noexcept -> Alloc & { return allocator; }
+
+  // TODO: try LF_NO_INLINE for final allocator
+  LF_NO_INLINE
+  void push(handle_type handle) { work.push_back(handle); }
+
+  auto pop() noexcept -> handle_type {
+    auto handle = work.back();
+    work.pop_back();
+    return handle;
+  }
+};
+
+template <lf::stack_allocator Alloc>
+struct poly_vector_ctx final : lf::polymorphic_context<Alloc> {
+
+  using handle_type = lf::frame_handle<lf::polymorphic_context<Alloc>>;
+
+  std::vector<handle_type> work;
+
+  poly_vector_ctx() { work.reserve(1024); }
+
+  void push(handle_type handle) override { work.push_back(handle); }
+
+  auto pop() noexcept -> handle_type override {
+    auto handle = work.back();
+    work.pop_back();
+    return handle;
+  }
+};
+
+struct poly_deque_ctx final : lf::polymorphic_context<linear_allocator> {
+
+  using handle_type = lf::frame_handle<lf::polymorphic_context<linear_allocator>>;
+
+  lf::deque<handle_type> work;
+
+  void push(handle_type handle) override { work.push(handle); }
+
+  auto pop() noexcept -> handle_type override {
+    return work.pop([] static -> handle_type {
+      return {};
+    });
+  }
+};
+
 using lf::task;
 
 template <lf::worker_context T>
@@ -217,3 +273,12 @@ BENCHMARK(fib<fork_call<B>, A, B>)->Name("base/libfork/fib/poly_vector_ctx")->Ar
 // Same as above but with join.
 BENCHMARK(fib<fork_call<B, true>, A, B>)->Name("test/libfork/fib/poly_vector_ctx/join")->Arg(fib_test);
 BENCHMARK(fib<fork_call<B, true>, A, B>)->Name("base/libfork/fib/poly_vector_ctx/join")->Arg(fib_base);
+
+using C = poly_deque_ctx;
+
+// Return by value,
+// Libfork call/join/fork with co-await,
+// Polymorphic
+// Deque-backed context
+BENCHMARK(fib<fork_call<B, true>, C, B>)->Name("test/libfork/fib/poly_deque_ctx/join")->Arg(fib_test);
+BENCHMARK(fib<fork_call<B, true>, C, B>)->Name("base/libfork/fib/poly_deque_ctx/join")->Arg(fib_base);

src/core/concepts.cxx

@@ -5,6 +5,27 @@ import std;
 
 namespace lf {
 
+// =========== Atomic related concepts =========== //
+
+/**
+ * @brief Verify a type is suitable for use with `std::atomic`
+ *
+ * This requires a `TriviallyCopyable` type satisfying both `CopyConstructible` and `CopyAssignable`.
+ */
+export template <typename T>
+concept atomicable = std::is_trivially_copyable_v<T> &&    //
+                     std::is_copy_constructible_v<T> &&    //
+                     std::is_move_constructible_v<T> &&    //
+                     std::is_copy_assignable_v<T> &&       //
+                     std::is_move_assignable_v<T> &&       //
+                     std::same_as<T, std::remove_cv_t<T>>; //
+
+/**
+ * @brief A concept that verifies a type is lock-free when used with `std::atomic`.
+ */
+export template <typename T>
+concept lock_free = atomicable<T> && std::atomic<T>::is_always_lock_free;
+
 // ========== Specialization ========== //
 
 template <typename T, template <typename...> typename Template>

src/core/core.cxx

@@ -10,6 +10,7 @@ export import :tuple;
 export import :frame;   // concepts
 export import :context; // concepts
 export import :ops;     // concepts, tuple, utility
+export import :deque;   // concepts
 
 // T3 partitions
 export import :promise;