Files for coroutines lecture (#29)

Author: tilir

CMakeLists.txt

@@ -68,5 +68,6 @@ add_subdirectory(concurrency)
 add_subdirectory(queues)
 add_subdirectory(atomics)
 add_subdirectory(parallel)
+add_subdirectory(coroutines)
 
 install()

coroutines/CMakeLists.txt

@@ -0,0 +1,29 @@
+#------------------------------------------------------------------------------
+#
+# Source code for MIPT masters course on C++
+# Slides: https://sourceforge.net/projects/cpp-lects-rus
+# Licensed after GNU GPL v3
+#
+#------------------------------------------------------------------------------
+#
+# Build system for examples (coroutines lecture)
+#
+# Order of examples in SRCS variable corresponds to the order in the lecture.
+# Examples commented out are broken (often -- intentionally).
+#
+#------------------------------------------------------------------------------
+
+set(SRCS
+  natseq.cc
+  resumable.cc
+  natseq_range.cc
+  natseq_zip.cc
+  subscribers.cc
+#  subscribers_mt.cc -- shall fail
+  subscribers_natlst.cc
+  cancellable.cc
+  futures.cc
+)
+
+add_gtest(coroutines)
+# add_demo(algo_bench)

coroutines/cancellable.cc

@@ -0,0 +1,104 @@
+//-----------------------------------------------------------------------------
+//
+// Source code for MIPT masters course on C++
+// Slides: https://sourceforge.net/projects/cpp-lects-rus
+// Licensed after GNU GPL v3
+//
+//-----------------------------------------------------------------------------
+//
+// Test for cancellables
+//
+//----------------------------------------------------------------------------
+
+#include <coroutine>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+struct suspend_tunable {
+  bool tune_;
+  suspend_tunable(bool tune = true) : tune_(tune) {}
+  bool await_ready() const noexcept { return tune_; }
+  void await_suspend(std::coroutine_handle<>) const noexcept {}
+  void await_resume() const noexcept {}
+};
+
+struct resumable_cancelable {
+  struct promise_type {
+    bool is_cancelled = false;
+    using coro_handle = std::coroutine_handle<promise_type>;
+    auto get_return_object() { return coro_handle::from_promise(*this); }
+    auto initial_suspend() { return std::suspend_always(); }
+    auto final_suspend() noexcept { return std::suspend_always(); }
+    void return_void() {}
+    void unhandled_exception() { std::terminate(); }
+
+    auto await_transform(std::suspend_always) {
+      if (is_cancelled)
+        return suspend_tunable{true};
+      return suspend_tunable{false};
+    }
+  };
+
+  using coro_handle = std::coroutine_handle<promise_type>;
+  resumable_cancelable(coro_handle handle) : handle_(handle) { assert(handle); }
+  resumable_cancelable(resumable_cancelable &) = delete;
+  resumable_cancelable(resumable_cancelable &&rhs) : handle_(rhs.handle_) {
+    rhs.handle_ = nullptr;
+  }
+  void cancel() {
+    if (handle_.done())
+      return;
+    handle_.promise().is_cancelled = true;
+    handle_.resume();
+  }
+  bool resume() {
+    if (!handle_.done())
+      handle_.resume();
+    return !handle_.done();
+  }
+  ~resumable_cancelable() {
+    if (handle_)
+      handle_.destroy();
+  }
+
+private:
+  coro_handle handle_;
+};
+
+} // namespace
+
+namespace {
+
+int G = 0;
+
+resumable_cancelable foo() {
+  for (int i = 0; i < 10; ++i) {
+    G += 1;
+    co_await std::suspend_always{};
+  }
+}
+
+} // namespace
+
+TEST(coroutines, cancellable) {
+  auto f = foo();
+  EXPECT_EQ(G, 0);
+  f.resume();
+  EXPECT_EQ(G, 1);
+  f.resume();
+  EXPECT_EQ(G, 2);
+  f.resume();
+  EXPECT_EQ(G, 3);
+  f.cancel();
+  EXPECT_EQ(G, 10);
+}
+
+// crutch for clang on godbolt
+#if defined(NOGTESTMAIN)
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif

coroutines/futures.cc

@@ -0,0 +1,69 @@
+//-----------------------------------------------------------------------------
+//
+// Source code for MIPT masters course on C++
+// Slides: https://sourceforge.net/projects/cpp-lects-rus
+// Licensed after GNU GPL v3
+//
+//-----------------------------------------------------------------------------
+//
+// McNellis futures implementation for C++20
+//
+//----------------------------------------------------------------------------
+
+#include <coroutine>
+#include <future>
+
+#include "gtest/gtest.h"
+
+template <> struct std::coroutine_traits<std::future<int>> {
+  struct promise_type : std::promise<int> {
+    std::future<int> get_return_object() { return this->get_future(); }
+    std::suspend_never initial_suspend() noexcept { return {}; }
+    std::suspend_never final_suspend() noexcept { return {}; }
+    void return_value(int value) { this->set_value(value); }
+    void unhandled_exception() {
+      this->set_exception(std::current_exception());
+    }
+  };
+};
+
+namespace {
+
+auto operator co_await(std::future<int> future) {
+  struct awaiter : std::future<int> {
+    bool await_ready() { return false; } // suspend always
+    void await_suspend(std::coroutine_handle<> handle) {
+      std::thread([this, handle]() {
+        this->wait();
+        handle.resume();
+      }).detach();
+    }
+    int await_resume() { return this->get(); }
+  };
+  return awaiter{std::move(future)};
+}
+
+} // namespace
+
+namespace {
+
+std::future<int> compute_value() {
+  int result = co_await std::async([] { return 42; });
+  co_return result;
+}
+
+} // namespace
+
+TEST(coroutines, futures) {
+  auto F = compute_value();
+  auto V = F.get();
+  EXPECT_EQ(V, 42);
+}
+
+// crutch for clang on godbolt
+#if defined(NOGTESTMAIN)
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif

coroutines/natseq.cc

@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------------
+//
+// Source code for MIPT masters course on C++
+// Slides: https://sourceforge.net/projects/cpp-lects-rus
+// Licensed after GNU GPL v3
+//
+//-----------------------------------------------------------------------------
+//
+// Natural numbers sequence
+//
+//----------------------------------------------------------------------------
+
+#include <coroutine>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+template <typename T> struct generator {
+  struct promise_type {
+    T current_value;
+    using coro_handle = std::coroutine_handle<promise_type>;
+    auto get_return_object() { return coro_handle::from_promise(*this); }
+    auto initial_suspend() { return std::suspend_always(); }
+    auto final_suspend() noexcept { return std::suspend_always(); }
+    void return_void() {}
+    void unhandled_exception() { std::terminate(); }
+    auto yield_value(T value) {
+      current_value = value;
+      return std::suspend_always{};
+    }
+  };
+
+  using coro_handle = std::coroutine_handle<promise_type>;
+  bool move_next() {
+    return handle_ ? (handle_.resume(), !handle_.done()) : false;
+  }
+  T current_value() const { return handle_.promise().current_value; }
+  generator(coro_handle h) : handle_(h) {}
+  generator(generator const &) = delete;
+  generator(generator &&rhs) : handle_(rhs.handle_) { rhs.handle_ = nullptr; }
+  ~generator() {
+    if (handle_)
+      handle_.destroy();
+  }
+
+private:
+  coro_handle handle_;
+};
+
+} // namespace
+
+namespace {
+
+generator<int> natural_nums() {
+  int num = 0;
+  for (;;) {
+    co_yield num;
+    num += 1;
+  }
+}
+
+} // namespace
+
+TEST(coroutines, natseq) {
+  int n = 0;
+  auto nums = natural_nums();
+
+  for (int i = 0; i < 10; ++i) {
+    nums.move_next();
+    auto y = nums.current_value();
+    EXPECT_EQ(y, n);
+    n = n + 1;
+  }
+}
+
+// crutch for clang on godbolt
+#if defined(NOGTESTMAIN)
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+#endif