temp

Author: MBkkt

CMakeLists.txt

@@ -11,7 +11,7 @@ if (BENCH_SOURCE_DIR STREQUAL BENCH_BINARY_DIR)
 endif ()
 
 # Set variables
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_CXX_VISIBILITY_PRESET hidden)

future/CMakeLists.txt

@@ -37,7 +37,6 @@ if (YACLIB)
     GIT_REPOSITORY https://github.com/YACLib/YACLib.git
     GIT_TAG "${YACLIB}"
     )
-  set(YACLIB_CXX_STANDARD 20)
   list(APPEND YACLIB_FLAGS "ATOMIC_EVENT")
   FetchContent_MakeAvailable(yaclib)
   link_libraries(yaclib)

future/bench/thens.hpp

@@ -8,18 +8,14 @@ template <typename Library>
 void Then(benchmark::State& state) {
   auto const count = state.range(0);
   auto const type = state.range(1);
-  std::unique_ptr<typename Library::Executor> executor;
-  if (type != 0) {
-    executor = std::make_unique<typename Library::Executor>(1);
-  }
+  auto* executor = Library::AcquireExecutor(/*threads*/ static_cast<size_t>(type != 0));
   for (auto _ : state) {
-    if (type == 0) {
-      Library::SomeThens(nullptr, count, false);
-    } else {
-      Library::SomeThens(executor.get(), count, type == 2);
+    Library::SomeThens(executor, count, type == 2);
+    if (executor != nullptr) {
       executor->Restart();
     }
   }
+  Library::ReleaseExecutor(/*threads*/ static_cast<size_t>(type != 0), executor);
 }
 
 }  // namespace bench

future/bind/folly/future.cpp

@@ -97,7 +97,20 @@ void Folly::PromiseAndFuture() {
   std::ignore = std::move(f).get();
 }
 
-void Folly::SomeThens(Executor* executor, size_t n, bool no_inline) {
+detail::fy::TestExecutor* Folly::AcquireExecutor(std::size_t threads) {
+  if (threads != 0) {
+    return new detail::fy::TestExecutor{threads};
+  }
+  return nullptr;
+}
+
+void Folly::ReleaseExecutor(std::size_t threads, detail::fy::TestExecutor* e) {
+  if (threads != 0) {
+    delete e;
+  }
+}
+
+void Folly::SomeThens(detail::fy::TestExecutor* executor, size_t n, bool no_inline) {
   const bool is_executor = executor != nullptr;
   auto f = folly::makeFuture(42).via(executor);
   f = Thens(std::move(f), n, is_executor && no_inline);

future/bind/folly/future.hpp

@@ -65,8 +65,9 @@ struct Folly {
   static void CreateFuture();
   static void PromiseAndFuture();
 
-  using Executor = detail::fy::TestExecutor;
-  static void SomeThens(Executor* executor, size_t n, bool no_inline);
+  static detail::fy::TestExecutor* AcquireExecutor(std::size_t threads);
+  static void SomeThens(detail::fy::TestExecutor* executor, size_t n, bool no_inline);
+  static void ReleaseExecutor(std::size_t threads, detail::fy::TestExecutor* e);
 
   template <typename T = folly::Unit>
   static void ComplexBenchmark();

future/bind/yaclib/future.cpp

@@ -2,7 +2,7 @@
 #include <bind/yaclib/intrusive_list.hpp>
 #include <semaphore.hpp>
 #include <yaclib/async/future.hpp>
-#include <yaclib/executor/inline.hpp>
+#include <yaclib/exe/inline.hpp>
 
 #include <future>
 #include <thread>
@@ -17,7 +17,7 @@ T Incr(yaclib::Result<T>&& r) {
   return std::move(r).Ok() + 1;
 }
 
-yaclib::Future<int> Thens(yaclib::Future<int> f, std::size_t n, bool is_executor) {
+yaclib::FutureOn<int> Thens(yaclib::FutureOn<int> f, std::size_t n, bool is_executor) {
   for (std::size_t i = 0; i != n; ++i) {
     if (is_executor) {
       f = std::move(f).Then(Incr<int>);
@@ -38,11 +38,10 @@ TestExecutor::TestExecutor(std::size_t num_threads) {
     _workers.emplace_back([this] {
       std::unique_lock lock{_m};
       while (true) {
-        while (!_tasks.Empty()) {
-          auto& task = _tasks.PopFront();
+        while (!_jobs.Empty()) {
+          auto& job = _jobs.PopFront();
           lock.unlock();
-          task.Call();
-          task.DecRef();
+          static_cast<yaclib::Job&>(job).Call();
           lock.lock();
         }
         if (_stop) {
@@ -79,14 +78,12 @@ yaclib::IExecutor::Type TestExecutor::Tag() const {
   return Type::Custom;
 }
 
-bool TestExecutor::Submit(yaclib::ITask& task) noexcept {
-  task.IncRef();
+void TestExecutor::Submit(yaclib::Job& job) noexcept {
   {
     std::lock_guard guard{_m};
-    _tasks.PushBack(task);
+    _jobs.PushBack(job);
   }
   _cv.notify_one();
-  return true;
 }
 
 }  // namespace detail::yb
@@ -101,15 +98,28 @@ void YACLib::PromiseAndFuture() {
   std::ignore = std::move(f).Get().Ok();
 }
 
-void YACLib::SomeThens(YACLib::Executor* executor, size_t n, bool no_inline) {
-  const bool is_executor = executor != nullptr;
-  auto f = yaclib::MakeFuture(42).Via(executor);
+detail::yb::TestExecutor* YACLib::AcquireExecutor(std::size_t threads) {
+  if (threads != 0) {
+    return new detail::yb::TestExecutor{threads};
+  }
+  return nullptr;
+}
+
+void YACLib::SomeThens(detail::yb::TestExecutor* executor, size_t n, bool no_inline) {
+  bool is_executor = executor != nullptr;
+  auto f = yaclib::MakeFuture(42).On(executor != nullptr ? *executor : yaclib::MakeInline());
   f = Thens(std::move(f), n, is_executor && no_inline);
   f = Thens(std::move(f), 1, is_executor);
   f = Thens(std::move(f), n, is_executor && no_inline);
   Wait(f);
 }
 
+void YACLib::ReleaseExecutor(std::size_t threads, detail::yb::TestExecutor* e) {
+  if (threads != 0) {
+    delete e;
+  }
+}
+
 void YACLib::NoContention(benchmark::State& state) {
   state.PauseTiming();
 

future/bind/yaclib/future.hpp

@@ -5,7 +5,7 @@
 #include <yaclib/algo/when_any.hpp>
 #include <yaclib/async/contract.hpp>
 #include <yaclib/async/future.hpp>
-#include <yaclib/executor/inline.hpp>
+#include <yaclib/exe/inline.hpp>
 
 #include <condition_variable>
 #include <memory>
@@ -34,11 +34,11 @@ class TestExecutor final : public yaclib::IExecutor {
 
   [[nodiscard]] Type Tag() const final;
 
-  bool Submit(yaclib::ITask& task) noexcept final;
+  void Submit(yaclib::Job& job) noexcept final;
 
   std::mutex _m;
   std::condition_variable _cv;
-  List<yaclib::ITask> _tasks;
+  List<yaclib::Job> _jobs;
   std::vector<std::thread> _workers;
   bool _stop = false;
 };
@@ -94,8 +94,9 @@ struct YACLib {
   static void CreateFuture();
   static void PromiseAndFuture();
 
-  using Executor = detail::yb::TestExecutor;
-  static void SomeThens(Executor* executor, size_t n, bool no_inline);
+  static detail::yb::TestExecutor* AcquireExecutor(std::size_t threads);
+  static void SomeThens(detail::yb::TestExecutor* executor, size_t n, bool no_inline);
+  static void ReleaseExecutor(std::size_t threads, detail::yb::TestExecutor* e);
 
   template <typename T = void>
   static void ComplexBenchmark();