Add socket class with reusable state for benchmarks

Author: vinniefalco

test/unit/bench.cpp

@@ -343,6 +343,8 @@ struct bench_test
 
         test_suite::log << "\n";
 
+        co::socket sock;
+
         // 1 level
         bench("async_io         native:  ", native,
             [](auto ex, auto h){ async_io(ex, std::move(h)); });
@@ -351,7 +353,7 @@ struct bench_test
         bench("any_io           any_all: ", any,
             [](auto ex, auto h){ any_io(std::move(ex), std::move(h)); });
      bench_co("co::async_io     coro:    ",
-            [](int& count) -> co::task { co_await co::async_io; ++count; });
+            [&](int& count) -> co::task { co_await sock.async_io(); ++count; });
 
         test_suite::log << "\n";
 
@@ -363,7 +365,7 @@ struct bench_test
         bench("any_read_some    any_all: ", any,
             [](auto ex, auto h){ any_read_some(std::move(ex), std::move(h)); });
      bench_co("co::read_some    coro:    ",
-            [](int& count) -> co::task { co_await co::async_read_some(); ++count; });
+            [&](int& count) -> co::task { co_await async_read_some(sock); ++count; });
 
         test_suite::log << "\n";
 
@@ -375,7 +377,7 @@ struct bench_test
         bench("any_read         any_all: ", any,
             [](auto ex, auto h){ any_read(std::move(ex), std::move(h)); });
      bench_co("co::read         coro:    ",
-            [](int& count) -> co::task { co_await co::async_read(); ++count; });
+            [&](int& count) -> co::task { co_await async_read(sock); ++count; });
 
         test_suite::log << "\n";
 
@@ -387,7 +389,7 @@ struct bench_test
         bench("any_request      any_all: ", any,
             [](auto ex, auto h){ any_request(std::move(ex), std::move(h)); });
      bench_co("co::request      coro:    ",
-            [](int& count) -> co::task { co_await co::async_request(); ++count; });
+            [&](int& count) -> co::task { co_await co::async_request(sock); ++count; });
     }
 };
 

test/unit/model_coro.hpp

@@ -13,6 +13,7 @@
 #include <concepts>
 #include <coroutine>
 #include <exception>
+#include <memory>
 
 namespace boost {
 namespace capy {
@@ -160,48 +161,60 @@ struct executor_ref
 
 //----------------------------------------------------------
 
-struct async_io_t
+struct socket
 {
-    bool await_ready() const noexcept { return false; }
-    void await_resume() const noexcept {}
+    struct async_awaitable
+    {
+        async_awaitable(socket& s) : s_(s) {}
+        bool await_ready() const noexcept { return false; }
+        void await_resume() const noexcept {}
 
-    // Affine overload: receives dispatcher from caller
-    template<class Executor>
-    void await_suspend(coro h, Executor const& ex) const
+        // Affine overload: receives dispatcher from caller
+        template<class Executor>
+        void await_suspend(coro h, Executor const& ex) const
+        {
+            s_.perform(h, executor_ref(ex));
+        }
+
+    private:
+        socket& s_;
+    };
+
+    socket()
+        : op_(new state)
+    {
+    }
+
+    // Asynchronous operation that wraps OS-level I/O
+    async_awaitable async_io()
     {
-        auto p = make_state(h, executor_ref(ex));
-        ex.post(p); // simulate OS call
+        return async_awaitable(*this);
     }
 
 private:
-    // this goes in the TU
-    static work* make_state(coro h, executor_ref ex)
+    struct state : work
     {
-        struct state : work
-        {
-            coro h_;
-            executor_ref ex_;
-            state(coro h, executor_ref ex)
-                : h_(h), ex_(ex)
-            {
-            }
+        coro h_;
+        executor_ref ex_;
 
-            void operator()() override
-            {
-                auto h = h_;
-                auto ex = ex_;
-                delete this;
-                ex.dispatch(h);
-            }
+        void operator()() override
+        {
+            ex_.dispatch(h_);
+        }
 
-            // OVERLAPPED, HANDLE, etc
-        }; 
-        return new state{ h, ex };
+        // OVERLAPPED, HANDLE, etc
+    }; 
+
+    void perform(coro h, executor_ref const& ex)
+    {
+        op_->h_ = h;
+        op_->ex_ = ex;
+        ex.post(op_.get()); // simulate OS call
     }
+
+    std::unique_ptr<state> op_;
 };
 
-// Asynchronous operation that wraps OS-level I/O
-inline constexpr async_io_t async_io{};
 
 //----------------------------------------------------------
 
@@ -420,20 +433,20 @@ void async_run(Executor ex, task t)
 
 //----------------------------------------------------------
 
-inline task async_read_some()
+inline task async_read_some(socket& sock)
 {
-    co_await async_io;
+    co_await sock.async_io();
 }
 
-inline task async_read()
+inline task async_read(socket& sock)
 {
-    co_await async_read_some();
+    co_await async_read_some(sock);
 }
 
-inline task async_request()
+inline task async_request(socket& sock)
 {
     for(int i = 0; i < 100; ++i)
-        co_await async_read();
+        co_await async_read(sock);
 }
 
 } // co