├── .gitmodules
├── CMakeLists.txt
├── include
    └── corio
    │   ├── as_receiver.hpp
    │   ├── await_sender.hpp
    │   ├── channel.hpp
    │   ├── concepts.hpp
    │   ├── corio.hpp
    │   ├── deadline.hpp
    │   ├── intrusive_linked_list.hpp
    │   ├── io_uring.hpp
    │   ├── io_uring
    │       ├── base.hpp
    │       ├── cancel.hpp
    │       ├── read.hpp
    │       └── schedule.hpp
    │   ├── meta.hpp
    │   ├── spawn.hpp
    │   ├── stop_token.hpp
    │   ├── tag_invoke.hpp
    │   ├── then.hpp
    │   ├── thread_pool.hpp
    │   └── wait.hpp
└── src
    └── corio.cpp


/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "cmcstl2"]
2 | 	path = cmcstl2
3 | 	url = https://github.com/CaseyCarter/cmcstl2
4 | [submodule "cppcoro"]
5 | 	path = cppcoro
6 | 	url = https://github.com/lewissbaker/cppcoro.git
7 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required (VERSION 3.14)
 2 | 
 3 | project(corio)
 4 | 
 5 | file(GLOB_RECURSE FILES
 6 |     ${PROJECT_SOURCE_DIR}/src/*.cpp
 7 |     ${PROJECT_SOURCE_DIR}/src/*.hpp
 8 |     ${PROJECT_SOURCE_DIR}/include/**.hpp
 9 | )
10 | 
11 | add_executable(corio ${FILES})
12 | target_include_directories(corio PUBLIC ${PROJECT_SOURCE_DIR}/include ${PROJECT_SOURCE_DIR}/cmcstl2/include)
13 | target_compile_options(corio PUBLIC -std=c++2a -Xclang -fconcepts-ts -stdlib=libc++ -lc++experimental)
14 | target_link_options(corio PUBLIC -stdlib=libc++ -lc++experimental -pthread  -static -static -lc++abi -pthread -fuse-ld=lld)
15 | 
16 | #Hack IOURING
17 | target_include_directories(corio PUBLIC /home/cor3ntin/dev-new/executors/uring/include)
18 | target_link_options(corio PRIVATE /home/cor3ntin/dev-new/executors/uring/lib/liburing.a)
19 | install(TARGETS corio)


--------------------------------------------------------------------------------
/include/corio/as_receiver.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/concepts.hpp>
 3 | 
 4 | 
 5 | namespace cor3ntin::corio {
 6 | template <concepts::invocable F>
 7 | struct as_receiver {
 8 | private:
 9 |     using invocable_type = std::remove_cvref_t<F>;
10 |     invocable_type f_;
11 | 
12 | public:
13 |     explicit as_receiver(
14 |         invocable_type&& f) requires std::is_nothrow_move_constructible_v<invocable_type>
15 |         : f_(std::move(f)) {}
16 |     explicit as_receiver(const invocable_type& f) noexcept : f_(f) {}
17 |     as_receiver(as_receiver&& other) noexcept = default;
18 |     void set_value() {
19 |         std::invoke(f_);
20 |     }
21 |     void set_error(std::exception_ptr) {
22 |         std::terminate();
23 |     }
24 |     void set_done() noexcept {}
25 | };
26 | 
27 | template <concepts::invocable F>
28 | as_receiver(F)->as_receiver<F>;
29 | 
30 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/await_sender.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <corio/concepts.hpp>
  3 | #include <experimental/coroutine>
  4 | #include <variant>
  5 | #include <iostream>
  6 | 
  7 | namespace cor3ntin::corio {
  8 | 
  9 | struct operation_cancelled : std::exception {
 10 |     virtual const char* what() const noexcept {
 11 |         return "operation cancelled";
 12 |     }
 13 | };
 14 | 
 15 | 
 16 | struct oneway_task {
 17 |     struct promise_type {
 18 |         std::experimental::suspend_never initial_suspend() {
 19 |             return {};
 20 |         }
 21 |         std::experimental::suspend_never final_suspend() {
 22 |             return {};
 23 |         }
 24 |         void unhandled_exception() {
 25 |             std::terminate();
 26 |         }
 27 |         oneway_task get_return_object() {
 28 |             return {};
 29 |         }
 30 |         void return_void() {}
 31 |     };
 32 | };
 33 | 
 34 | template <typename Sender, typename Value>
 35 | struct sender_awaiter {
 36 | private:
 37 |     struct internal_receiver {
 38 |         sender_awaiter* this_;
 39 | 
 40 |         template <typename... Values>
 41 |         void set_value(Values&&... value) {
 42 |             this_->m_data.template emplace<1>(std::forward<Values>(value)...);
 43 |             this_->m_continuation.resume();
 44 |         }
 45 |         template <typename Error>
 46 |         void set_error(Error&& error) {
 47 |             if constexpr(std::is_same_v<Error, std::exception_ptr>) {
 48 |                 this_->m_data.template emplace<2>(std::move(error));
 49 |             } else {
 50 |                 this_->m_data.template emplace<2>(std::make_exception_ptr(std::move(error)));
 51 |             }
 52 |             this_->m_continuation.resume();
 53 |         }
 54 | 
 55 |         void set_done() {
 56 |             this_->m_data.template emplace<0>(std::monostate{});
 57 |             this_->m_continuation.resume();
 58 |         }
 59 |     };
 60 | 
 61 | 
 62 |     using value_type = Value;
 63 |     using coro_handle = std::experimental::coroutine_handle<>;
 64 | 
 65 |     coro_handle m_continuation{};
 66 |     using operation_type = decltype(
 67 |         corio::execution::connect(std::declval<Sender>(), std::declval<internal_receiver>()));
 68 |     operation_type m_op;
 69 |     std::variant<std::monostate, details::non_void_t<value_type>, std::exception_ptr> m_data;
 70 | 
 71 | 
 72 | public:
 73 |     sender_awaiter(Sender sender) noexcept
 74 |         : m_op(corio::execution::connect(std::move(sender), internal_receiver{this})) {}
 75 |     sender_awaiter(sender_awaiter&& that) = default;
 76 |     ~sender_awaiter() {}
 77 | 
 78 | 
 79 |     static constexpr bool await_ready() noexcept {
 80 |         return false;
 81 |     }
 82 | 
 83 |     void await_suspend(coro_handle continuation) noexcept {
 84 |         m_continuation = continuation;
 85 |         corio::execution::start(m_op);
 86 |         return;
 87 |     }
 88 | 
 89 |     decltype(auto) await_resume() {
 90 |         switch(m_data.index()) {
 91 |             case 0: throw operation_cancelled{}; break;
 92 |             case 1: return std::get<1>(m_data); break;
 93 |             case 2: std::rethrow_exception(std::move(std::get<2>(m_data))); break;
 94 |         }
 95 |         return std::get<1>(m_data);
 96 |     }
 97 | };
 98 | 
 99 | template <cor3ntin::corio::execution::sender S>
100 | auto operator co_await(S&& sender) {
101 |     return cor3ntin::corio::sender_awaiter<S, void>(std::forward<S>(sender));
102 | }
103 | template <cor3ntin::corio::execution::typed_sender_single S>
104 | auto operator co_await(S&& sender) {
105 |     return cor3ntin::corio::sender_awaiter<S, cor3ntin::corio::execution::single_value_result_t<S>>(
106 |         std::forward<S>(sender));
107 | }
108 | 
109 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/channel.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <utility>
  3 | #include <queue>
  4 | #include <optional>
  5 | #include <corio/then.hpp>
  6 | 
  7 | namespace cor3ntin::corio {
  8 | 
  9 | struct channel_closed : std::exception {
 10 |     virtual const char* what() const noexcept {
 11 |         return "channel closed";
 12 |     }
 13 | };
 14 | 
 15 | 
 16 | namespace details {
 17 | 
 18 |     struct linked_list_node {
 19 |         linked_list_node* next = nullptr;
 20 |     };
 21 | 
 22 |     template <typename T>
 23 |     struct linked_list {
 24 |         T* pop() {
 25 |             std::unique_lock lock(m_mutex);
 26 |             T* n = tail;
 27 |             if(!n)
 28 |                 return n;
 29 |             if(head == n)
 30 |                 head = nullptr;
 31 |             tail = static_cast<T*>(n->next);
 32 |             n->next = nullptr;
 33 |             return n;
 34 |         }
 35 |         T* front() {
 36 |             return tail;
 37 |         }
 38 | 
 39 |         void push(T* node) {
 40 |             std::unique_lock lock(m_mutex);
 41 |             if(head != nullptr)
 42 |                 head->next = node;
 43 |             head = node;
 44 |             if(tail == nullptr)
 45 |                 tail = node;
 46 |         }
 47 | 
 48 |     private:
 49 |         std::mutex m_mutex;
 50 |         T* head = nullptr;
 51 |         T* tail = nullptr;
 52 |     };
 53 | 
 54 |     template <typename scheduler, typename T, bool Buffered>
 55 |     class channel {
 56 |     public:
 57 |         class read_operation_base : public linked_list_node {
 58 |             friend channel;
 59 | 
 60 |         protected:
 61 |             virtual void handle_error(std::error_code err) = 0;
 62 |             virtual void handle_value(T&& t) = 0;
 63 |         };
 64 | 
 65 |         class write_operation_base : public linked_list_node {
 66 |             friend channel;
 67 | 
 68 |         protected:
 69 |             virtual void handle_error(std::error_code err) = 0;
 70 |             virtual void handle_value() = 0;
 71 |             virtual T& value() = 0;
 72 |         };
 73 | 
 74 |         class read_channel {
 75 |             template <typename Receiver>
 76 |             class operation;
 77 |             template <typename Receiver>
 78 |             friend class operation;
 79 |             class sender {
 80 |             public:
 81 |                 channel* m_channel;
 82 | 
 83 |             public:
 84 |                 sender(channel* c) : m_channel(c) {}
 85 |                 template <template <typename...> class Variant, template <typename...> class Tuple>
 86 |                 using value_types = Variant<Tuple<T>>;
 87 | 
 88 |                 template <template <typename...> class Variant>
 89 |                 using error_types = Variant<>;
 90 | 
 91 |                 static constexpr bool sends_done = true;
 92 | 
 93 |                 template <typename Sender, execution::receiver R>
 94 |                 using operation_type = read_channel::operation<R>;
 95 | 
 96 |                 template <execution::receiver R>
 97 |                 auto connect(R&& r) && {
 98 |                     return operation<R>(std::move(*this), std::forward<R>(r));
 99 |                 }
100 |             };
101 | 
102 |             template <typename R>
103 |             class operation : public read_operation_base {
104 | 
105 |             public:
106 |                 operation(sender s, R&& r) : m_sender(std::move(s)), m_receiver(std::move(r)) {}
107 |                 void start() {
108 |                     auto* c = m_sender.m_channel;
109 |                     auto writer = c->m_pending_writers.pop();
110 |                     if(writer) {
111 |                         handle_value(std::move(writer->value()));
112 |                         writer->handle_value();
113 |                         return;
114 |                     }
115 |                     bool empty = true;
116 |                     if constexpr(Buffered) {
117 |                         std::unique_lock lock(c->m_mutex);
118 |                         empty = c->m_queue.empty();
119 |                     }
120 | 
121 |                     if(empty) {
122 |                         if(c->m_capacity == 0) {
123 |                             execution::set_error(m_receiver, channel_closed{});
124 |                             return;
125 |                         }
126 |                         c->add_reader(this);
127 |                         return;
128 |                     }
129 |                     if constexpr(Buffered) {
130 | 
131 |                         std::unique_lock lock(c->m_mutex);
132 |                         auto value = std::move(c->m_queue.front());
133 |                         c->m_queue.pop();
134 |                         lock.unlock();
135 |                         if(c->m_capacity != 0) {
136 |                             c->do_write();
137 |                         }
138 |                         handle_value(std::move(value));
139 |                     }
140 |                 }
141 | 
142 |             protected:
143 |                 void handle_value(T&& value) override {
144 |                     execution::set_value(m_receiver, std::move(value));
145 |                 }
146 |                 void handle_error(std::error_code err) override {
147 |                     if(err == std::errc::bad_file_descriptor)
148 |                         execution::set_error(m_receiver, channel_closed{});
149 |                     else
150 |                         execution::set_error(m_receiver, err);
151 |                 }
152 | 
153 |             private:
154 |                 sender m_sender;
155 |                 R m_receiver;
156 |             };
157 | 
158 |         public:
159 |             read_channel(std::shared_ptr<channel> ptr) : ptr(std::move(ptr)) {
160 |                 this->ptr->m_readers++;
161 |             }
162 |             read_channel(const read_channel& other) : ptr(other.ptr) {
163 |                 ptr->m_readers++;
164 |             }
165 |             read_channel(read_channel&& other) = default;
166 |             ~read_channel() {
167 |                 if(ptr) {
168 |                     ptr->m_readers--;
169 |                     if(ptr->m_readers == 0) {
170 |                         ptr->close();
171 |                     }
172 |                 }
173 |             }
174 |             void close() {
175 |                 if(ptr)
176 |                     ptr->close();
177 |             }
178 |             auto read() {
179 |                 return sender(this->ptr.get());
180 |             }
181 | 
182 |         private:
183 |             std::shared_ptr<channel> ptr;
184 |         };
185 | 
186 |         class write_channel {
187 |             template <typename Receiver>
188 |             class operation;
189 |             template <typename Receiver>
190 |             friend class operation;
191 |             class sender {
192 |             public:
193 |                 channel* m_channel;
194 |                 T m_value;
195 | 
196 |             public:
197 |                 sender(channel* c, T value) : m_channel(c), m_value(std::move(value)) {}
198 |                 template <template <typename...> class Variant, template <typename...> class Tuple>
199 |                 using value_types = Variant<Tuple<>>;
200 | 
201 |                 template <template <typename...> class Variant>
202 |                 using error_types = Variant<>;
203 | 
204 |                 static constexpr bool sends_done = true;
205 | 
206 |                 template <typename Sender, execution::receiver R>
207 |                 using operation_type = write_channel::operation<R>;
208 | 
209 |                 template <execution::receiver R>
210 |                 auto connect(R&& r) && {
211 |                     return operation<R>(std::move(*this), std::forward<R>(r));
212 |                 }
213 |             };
214 | 
215 |             template <typename R>
216 |             class operation : public write_operation_base {
217 |             public:
218 |                 operation(sender s, R&& r) : m_sender(std::move(s)), m_receiver(std::move(r)) {}
219 |                 void start() {
220 |                     auto* c = m_sender.m_channel;
221 |                     if(c->m_capacity == 0) {
222 |                         execution::set_error(m_receiver, channel_closed{});
223 |                         return;
224 |                     }
225 |                     auto reader = c->m_pending_readers.pop();
226 |                     if(reader) {
227 |                         reader->handle_value(std::move(m_sender.m_value));
228 |                         handle_value();
229 |                         return;
230 |                     }
231 |                     if constexpr(Buffered) {
232 |                         std::unique_lock lock(c->m_mutex);
233 |                         if(c->m_queue.size() < c->m_capacity) {
234 |                             c->m_queue.push(std::move(m_sender.m_value));
235 |                             handle_value();
236 |                             return;
237 |                         }
238 |                     }
239 |                     c->add_writer(this);
240 |                     c->do_write();
241 |                 }
242 | 
243 | 
244 |             protected:
245 |                 void handle_error(std::error_code err) override {
246 |                     if(err == std::errc::bad_file_descriptor)
247 |                         execution::set_error(m_receiver, channel_closed{});
248 |                     else
249 |                         execution::set_error(m_receiver, err);
250 |                 }
251 |                 void handle_value() override {
252 |                     execution::set_value(m_receiver);
253 |                 }
254 |                 T& value() override {
255 |                     return m_sender.m_value;
256 |                 }
257 | 
258 |                 sender m_sender;
259 |                 R m_receiver;
260 |             };
261 | 
262 |         public:
263 |             write_channel(std::shared_ptr<channel> ptr) : ptr(std::move(ptr)) {
264 |                 this->ptr->m_writers++;
265 |             }
266 |             write_channel(const write_channel& other) : ptr(other.ptr) {
267 |                 ptr->m_writers++;
268 |             }
269 | 
270 |             write_channel(write_channel&& other) {
271 |                 std::swap(other.ptr, ptr);
272 |             }
273 |             ~write_channel() {
274 |                 if(ptr) {
275 |                     ptr->m_writers--;
276 |                     if(ptr->m_writers == 0) {
277 |                         ptr->close();
278 |                     }
279 |                 }
280 |             }
281 |             write_channel& operator=(write_channel&& other) {
282 |                 std::swap(other.ptr, ptr);
283 |                 return this;
284 |             }
285 | 
286 |             void close() {
287 |                 if(ptr)
288 |                     ptr->close();
289 |             }
290 |             auto write(T value) {
291 |                 return sender(this->ptr.get(), std::move(value));
292 |             }
293 | 
294 |         private:
295 |             std::shared_ptr<channel> ptr;
296 |         };
297 | 
298 |     private:
299 |         friend read_channel;
300 |         friend write_channel;
301 | 
302 |         void close() {
303 |             if(m_capacity != 0) {
304 |                 m_capacity = 0;
305 |                 do_rw();
306 |             }
307 |         }
308 |         scheduler m_scheduler;
309 |         std::mutex m_mutex;
310 |         linked_list<read_operation_base> m_pending_readers;
311 |         linked_list<write_operation_base> m_pending_writers;
312 |         [[no_unique_address]] std::conditional_t<Buffered, std::queue<T>, empty_result_t> m_queue;
313 |         std::atomic<std::size_t> m_readers = 0;
314 |         std::atomic<std::size_t> m_writers = 0;
315 |         std::atomic<std::size_t> m_capacity;
316 | 
317 |     public:
318 |         channel(scheduler sch, std::size_t capacity = std::numeric_limits<std::size_t>::max())
319 |             : m_scheduler(std::move(sch)), m_capacity(capacity) {}
320 | 
321 |         void add_reader(read_operation_base* op) {
322 |             m_pending_readers.push(op);
323 |         }
324 |         void add_writer(write_operation_base* op) {
325 |             m_pending_writers.push(op);
326 |         }
327 | 
328 |         void do_rw() {
329 |             do_read();
330 |             do_write();
331 |         }
332 | 
333 |         void do_read() {
334 |             bool notify = handle_unbuffered_rw();
335 |             std::unique_lock lock(m_mutex);
336 |             bool empty = false;
337 |             if constexpr(Buffered) {
338 |                 while(!m_queue.empty()) {
339 |                     auto node = m_pending_readers.pop();
340 |                     if(!node)
341 |                         break;
342 |                     node->handle_value(std::move(m_queue.front()));
343 |                     m_queue.pop();
344 |                     notify = true;
345 |                 }
346 |                 empty = m_queue.empty();
347 |             }
348 |             empty = empty && !m_pending_writers.front();
349 |             if(empty && (m_capacity == 0 || m_writers == 0)) {
350 |                 this->on_read_event_error(std::make_error_code(std::errc::bad_file_descriptor));
351 |                 return;
352 |             }
353 |         }
354 | 
355 |         void do_write() {
356 |             if(m_capacity == 0) {
357 |                 this->on_write_event_error(std::make_error_code(std::errc::bad_file_descriptor));
358 |                 return;
359 |             }
360 |             bool notify = handle_unbuffered_rw();
361 |             if constexpr(Buffered) {
362 |                 std::unique_lock lock(m_mutex);
363 |                 auto node = m_pending_writers.pop();
364 |                 while(node) {
365 |                     m_queue.push(std::move(node->value()));
366 |                     node->handle_value();
367 |                     node = m_pending_writers.pop();
368 |                     notify = true;
369 |                 }
370 |             }
371 |             if(notify)
372 |                 do_read();
373 |         }
374 | 
375 |         bool handle_unbuffered_rw() {
376 |             bool notify = false;
377 |             while(true) {
378 |                 auto reader = m_pending_readers.pop();
379 |                 if(!reader) {
380 |                     break;
381 |                 }
382 |                 auto writer = m_pending_writers.pop();
383 |                 if(!writer) {
384 |                     m_pending_readers.push(reader);
385 |                     break;
386 |                 }
387 |                 reader->handle_value(std::move(writer->value()));
388 |                 writer->handle_value();
389 |                 notify = true;
390 |             }
391 |             return notify;
392 |         }
393 | 
394 |         void on_read_event_error(std::error_code err) {
395 |             auto* node = m_pending_readers.pop();
396 |             while(node) {
397 |                 node->handle_error(err);
398 |                 node = m_pending_readers.pop();
399 |             }
400 |         }
401 | 
402 |         void on_write_event_error(std::error_code err) {
403 |             auto* node = m_pending_writers.pop();
404 |             while(node) {
405 |                 node->handle_error(err);
406 |                 node = m_pending_writers.pop();
407 |             }
408 |         }
409 | 
410 |         struct channels {
411 |             read_channel read() const {
412 |                 return ptr;
413 |             }
414 |             write_channel write() const {
415 |                 return ptr;
416 |             }
417 | 
418 |             channels(std::shared_ptr<channel> ptr) : ptr(ptr) {}
419 | 
420 |         private:
421 |             std::shared_ptr<channel> ptr;
422 |         };
423 | 
424 |         template <typename T_, typename scheduler_, bool Buffered_>
425 |         friend typename channel<scheduler_, T_, Buffered_>::channels
426 |         make_channel(scheduler_ context);
427 |     };  // namespace details
428 | }  // namespace details
429 | 
430 | template <typename T, typename scheduler>
431 | typename details::channel<scheduler, T, false>::channels make_channel(scheduler context) {
432 |     auto c = std::shared_ptr<details::channel<scheduler, T, false>>(
433 |         new details::channel<scheduler, T, false>(context));
434 |     return {c};
435 | }
436 | 
437 | template <typename T, typename scheduler>
438 | typename details::channel<scheduler, T, true>::channels make_channel(scheduler context,
439 |                                                                      std::size_t buffer_size) {
440 |     auto c = std::shared_ptr<details::channel<scheduler, T, true>>(
441 |         new details::channel<scheduler, T, true>(context, buffer_size));
442 |     return {c};
443 | }
444 | 
445 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/concepts.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <stl2/concepts.hpp>
  3 | #include <type_traits>
  4 | #include <exception>
  5 | #include <optional>
  6 | #include <functional>
  7 | #include <cstdio>
  8 | #include <corio/tag_invoke.hpp>
  9 | #include <corio/spawn.hpp>
 10 | #include <corio/meta.hpp>
 11 | 
 12 | namespace cor3ntin::corio {
 13 | 
 14 | namespace concepts = std::experimental::ranges;
 15 | 
 16 | namespace execution {
 17 | 
 18 |     class sink_receiver {
 19 |     public:
 20 |         template <typename... T>
 21 |         void set_value(T&&...) {}
 22 |         template <typename... T>
 23 |         [[noreturn]] void set_error(T&&...) noexcept {
 24 |             std::terminate();
 25 |         }
 26 |         void set_done() noexcept {}
 27 |     };
 28 | 
 29 |     namespace __set_done_ns {
 30 |         struct __set_done_base {};
 31 |     }  // namespace __set_done_ns
 32 |     inline constexpr struct __set_done_fn : __set_done_ns::__set_done_base {
 33 |         template <typename Receiver>
 34 |         requires cor3ntin::corio::tag_invocable<__set_done_fn, Receiver> void
 35 |         operator()(Receiver&& r) const noexcept {
 36 |             cor3ntin::corio::tag_invoke(*this, (Receiver &&) r);
 37 |         }
 38 |         template <typename Receiver>
 39 |         requires requires(Receiver& r) {
 40 |             r.set_done();
 41 |         }
 42 |         friend void tag_invoke(__set_done_fn, Receiver&& r) noexcept {
 43 |             r.set_done();
 44 |         }
 45 |     } set_done;
 46 | 
 47 | 
 48 |     namespace __set_value_ns {
 49 |         struct __set_value_base {};
 50 |     }  // namespace __set_value_ns
 51 |     inline constexpr struct __set_value_fn : __set_value_ns::__set_value_base {
 52 |         template <typename Receiver, typename... Value>
 53 |         requires cor3ntin::corio::tag_invocable<__set_value_fn, Receiver, Value...> void
 54 |         operator()(Receiver&& r, Value&&... v) const noexcept {
 55 |             cor3ntin::corio::tag_invoke(*this, (Receiver &&) r, (Value &&) v...);
 56 |         }
 57 |         template <typename Receiver, typename... Value>
 58 |         requires requires(Receiver& r, Value&&... v) {
 59 |             {r.set_value((Value &&) v...)};
 60 |         }
 61 |         friend void tag_invoke(__set_value_fn, Receiver&& r, Value&&... v) noexcept {
 62 |             r.set_value((Value &&) v...);
 63 |         }
 64 |     } set_value;
 65 | 
 66 | 
 67 |     namespace __set_error_ns {
 68 |         struct __set_error_base {};
 69 |     }  // namespace __set_error_ns
 70 |     inline constexpr struct __set_error_fn : __set_error_ns::__set_error_base {
 71 |         template <typename Receiver, typename Error>
 72 |         requires cor3ntin::corio::tag_invocable<__set_error_fn, Receiver, Error> void
 73 |         operator()(Receiver&& r, Error&& e) const noexcept {
 74 |             cor3ntin::corio::tag_invoke(*this, (Receiver &&) r, (Error &&) e);
 75 |         }
 76 |         template <typename Receiver, typename Error>
 77 |         requires requires(Receiver&& r, Error&& e) {
 78 |             r.set_error(e);
 79 |         }
 80 |         friend void tag_invoke(__set_error_fn, Receiver&& r, Error&& e) noexcept {
 81 |             r.set_error(e);
 82 |         }
 83 |     } set_error;
 84 | 
 85 | 
 86 |     namespace __connect_ns {
 87 |         struct __connect_base {};
 88 |     }  // namespace __connect_ns
 89 | 
 90 |     inline constexpr struct __connect_fn : __connect_ns::__connect_base {
 91 |         template <typename Sender, typename Receiver>
 92 |         requires cor3ntin::corio::tag_invocable<__connect_fn, Sender, Receiver> auto
 93 |         operator()(Sender&& s, Receiver&& r) const {
 94 |             return cor3ntin::corio::tag_invoke(*this, std::forward<Sender>(s), (Receiver &&) r);
 95 |         }
 96 | 
 97 |         template <typename Sender, typename Receiver>
 98 |         requires requires(Sender&& s, Receiver&& r) {
 99 |             std::forward<Sender>(s).connect((Receiver &&) r);
100 |         }
101 |         friend auto tag_invoke(__connect_fn, Sender&& s, Receiver&& r) {
102 |             return std::forward<Sender>(s).connect((Receiver &&) r);
103 |         }
104 |     } connect;
105 | 
106 |     namespace __start_ns {
107 |         struct __start_base {};
108 |     }  // namespace __start_ns
109 | 
110 |     inline constexpr struct __start_fn : __start_ns::__start_base {
111 |         template <typename Operation>
112 |         requires cor3ntin::corio::tag_invocable<__start_fn, Operation&> void
113 |         operator()(Operation& op) const {
114 |             return cor3ntin::corio::tag_invoke(*this, op);
115 |         }
116 | 
117 |         template <typename Operation>
118 |         requires requires(Operation& op) {
119 |             { op.start() }
120 |             ->concepts::same_as<void>;
121 |         }
122 |         friend auto tag_invoke(__start_fn, Operation& op) {
123 |             op.start();
124 |         }
125 |     } start;
126 | 
127 | 
128 |     template <typename T, typename E = std::exception_ptr>
129 |     concept receiver = concepts::move_constructible<std::remove_cvref_t<T>>&&
130 |         details::nothrow_move_or_copy_constructible<std::remove_cvref_t<T>>&& requires(T&& t,
131 |                                                                                        E&& e) {
132 |         { execution::set_done((T &&) t) }
133 |         noexcept;
134 |         { execution::set_error((T &&) t, (E &&) e) }
135 |         noexcept;
136 |     };
137 | 
138 |     template <typename T, typename... Val>
139 |     concept receiver_of = receiver<T>&& requires(T&& t, Val&&... val) {
140 |         execution::set_value((T &&) t, (Val &&) val...);
141 |     };
142 | 
143 |     namespace details {
144 |         template <typename T>
145 |         concept sealed_object = !concepts::move_constructible<std::remove_cvref_t<T>> &&
146 |             !concepts::copy_constructible<std::remove_cvref_t<T>>;
147 |     }
148 | 
149 | 
150 |     template <typename Op>
151 |     concept operation = details::sealed_object<Op>&& requires(Op& t) {
152 |         { execution::start(t) }
153 |         ->concepts::same_as<void>;
154 |     };
155 | 
156 | 
157 |     namespace details {
158 |         template <class S, class R>
159 |         concept sender_to_impl = requires(S&& s, R&& r) {
160 |             {execution::connect(std::forward<S>(s), (R &&) r)};
161 |             { execution::spawn((S &&) s, (R &&) r) }
162 |             ->concepts::same_as<void>;
163 |         };
164 |     }  // namespace details
165 |     template <typename S>
166 |     concept sender = concepts::move_constructible<std::remove_cvref_t<S>>&&
167 |         details::sender_to_impl<S, sink_receiver>;
168 | 
169 | 
170 |     template <class S, class R>
171 |     concept sender_to = sender<S>&& receiver<R>&& details::sender_to_impl<S, R>;
172 | 
173 | 
174 |     template <template <template <class...> class, template <class...> class> class>
175 |     struct __test_has_values;
176 | 
177 |     template <template <template <class...> class> class>
178 |     struct __test_has_errors;
179 | 
180 |     template <class T>
181 |     concept __has_sender_types = requires {
182 |         typename __test_has_values<T::template value_types>;
183 |         typename __test_has_errors<T::template error_types>;
184 |         typename std::bool_constant<T::sends_done>;
185 |     };
186 |     struct __void_sender {
187 |         template <template <class...> class Tuple, template <class...> class Variant>
188 |         using value_types = Variant<Tuple<>>;
189 |         template <template <class...> class Variant>
190 |         using error_types = Variant<std::exception_ptr>;
191 |         static constexpr bool sends_done = true;
192 |     };
193 |     template <class S>
194 |     struct __typed_sender {
195 |         template <template <class...> class Tuple, template <class...> class Variant>
196 |         using value_types = typename S::template value_types<Tuple, Variant>;
197 |         template <template <class...> class Variant>
198 |         using error_types = typename S::template error_types<Variant>;
199 |         static constexpr bool sends_done = S::sends_done;
200 |     };
201 | 
202 |     using sender_base = struct __sender_base {};
203 |     struct __no_sender_traits {
204 |         using __unspecialized = void;
205 |     };
206 | 
207 |     template <class S>
208 |     auto __sender_traits_base_fn() {
209 |         if constexpr(__has_sender_types<S>) {
210 |             return __typed_sender<S>{};
211 |         } else if constexpr(concepts::derived_from<S, sender_base>) {
212 |             return sender_base{};
213 |         } else {
214 |             return __no_sender_traits{};
215 |         }
216 |     }
217 |     template <class S>
218 |     struct sender_traits : decltype(__sender_traits_base_fn<S>()) {};
219 | 
220 |     template <class S>
221 |     concept typed_sender = sender<S>&& __has_sender_types<sender_traits<std::remove_cvref_t<S>>>;
222 | 
223 | 
224 |     template <typename Sender>
225 |     using single_value_result_t = typename std::remove_reference_t<Sender>::template value_types<
226 |         corio::details::single_type, corio::details::single_value_type>::type::type;
227 | 
228 |     template <class S>
229 |     concept typed_sender_single = typed_sender<S>&& requires {
230 |         typename single_value_result_t<S>;
231 |     };
232 | 
233 |     template <typename S>
234 |     concept scheduler = requires(S s) {
235 |         { s.schedule() }
236 |         ->sender;
237 |     };
238 | 
239 | 
240 | }  // namespace execution
241 | 
242 | }  // namespace cor3ntin::corio
243 | 
244 | namespace {
245 | 
246 | using namespace cor3ntin::corio;
247 | static_assert(execution::receiver<execution::sink_receiver>);
248 | }  // namespace


--------------------------------------------------------------------------------
/include/corio/corio.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/concepts.hpp>
 3 | #include <corio/await_sender.hpp>
 4 | #include <corio/thread_pool.hpp>
 5 | #include <corio/wait.hpp>
 6 | #include <corio/as_receiver.hpp>
 7 | #include <corio/stop_token.hpp>
 8 | #include <corio/io_uring.hpp>
 9 | #include <corio/channel.hpp>
10 | #include <corio/then.hpp>


--------------------------------------------------------------------------------
/include/corio/deadline.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <chrono>
 3 | 
 4 | struct __kernel_timespec;
 5 | 
 6 | namespace cor3ntin::corio {
 7 | 
 8 | struct deadline {
 9 |     constexpr deadline() noexcept = default;
10 |     constexpr explicit operator bool() const noexcept {
11 |         return d.count() != 0;
12 |     }
13 |     template <class Clock, class Duration>
14 |     constexpr deadline(std::chrono::time_point<Clock, Duration> tp) noexcept {
15 |         this->d = std::chrono::duration_cast<std::chrono::nanoseconds>(tp.time_since_epoch());
16 |         this->absolute = true;
17 |     }
18 |     template <class Rep, class Period>
19 |     constexpr deadline(std::chrono::duration<Rep, Period> d) noexcept {
20 |         this->d = std::chrono::duration_cast<std::chrono::nanoseconds>(d);
21 |         this->absolute = false;
22 |     }
23 | 
24 | private:
25 |     friend __kernel_timespec to_timespec(const deadline& d);
26 |     std::chrono::nanoseconds d;
27 |     bool absolute = false;
28 | };
29 | 
30 | }  // namespace cor3ntin::corio
31 | 


--------------------------------------------------------------------------------
/include/corio/intrusive_linked_list.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | namespace cor3ntin::corio {
 4 | 
 5 | struct intrusive_mpsc_queue_node {
 6 | protected:
 7 |     template <typename T>
 8 |     friend class intrusive_mpsc_queue;
 9 |     std::atomic<intrusive_mpsc_queue_node*> next = nullptr;
10 | };
11 | 
12 | template <typename T>
13 | class intrusive_mpsc_queue;
14 | 
15 | template <typename T>
16 | requires std::is_base_of_v<intrusive_mpsc_queue_node, T>  //
17 |     class intrusive_mpsc_queue<T> {
18 | public:
19 |     using node = intrusive_mpsc_queue_node;
20 | 
21 |     void push(T* const item) {
22 |         push_node(item);
23 |     }
24 | 
25 |     T* front() {
26 |         if(!m_peeked)
27 |             m_peeked = pop_node();
28 |         return static_cast<T*>(m_peeked);
29 |     }
30 | 
31 |     void pop() {
32 |         if(m_peeked)
33 |             m_peeked = nullptr;
34 |         else
35 |             pop_node();
36 |     }
37 | 
38 | private:
39 |     void push_node(node* const item) {
40 |         item->next.store(nullptr, std::memory_order_relaxed);
41 |         auto prev = std::atomic_exchange_explicit(&m_head, item, std::memory_order_acq_rel);
42 |         prev->next.store(item, std::memory_order_release);
43 |     }
44 | 
45 |     node* pop_node() {
46 |         node* tail = m_tail.load(std::memory_order_relaxed);
47 |         ;
48 |         node* next = tail->next.load(std::memory_order_relaxed);
49 |         if(tail == &m_stub) {
50 |             if(!next)
51 |                 return nullptr;
52 |             m_tail.store(next, std::memory_order_relaxed);
53 |             tail = next;
54 |             next = next->next.load(std::memory_order_relaxed);
55 |         }
56 |         if(next) {
57 |             m_tail = next;
58 |             return tail;
59 |         }
60 |         node* head = m_head.load(std::memory_order_acquire);
61 |         if(tail != head) {
62 |             return nullptr;
63 |         }
64 |         push_node(&m_stub);
65 |         next = tail->next.load(std::memory_order_relaxed);
66 |         if(next) {
67 |             m_tail.store(next, std::memory_order_relaxed);
68 |             return tail;
69 |         }
70 |         return nullptr;
71 |     }
72 | 
73 | 
74 |     mutable node* m_peeked = nullptr;
75 |     node m_stub;
76 |     std::atomic<node*> m_head = &m_stub;
77 |     std::atomic<node*> m_tail = &m_stub;
78 | };
79 | 
80 | }  // namespace cor3ntin::corio
81 | 


--------------------------------------------------------------------------------
/include/corio/io_uring.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <corio/io_uring/base.hpp>
  3 | #include <corio/io_uring/schedule.hpp>
  4 | #include <corio/io_uring/cancel.hpp>
  5 | #include <corio/io_uring/read.hpp>
  6 | 
  7 | namespace cor3ntin::corio {
  8 | class io_uring_context;
  9 | 
 10 | namespace iouring {
 11 |     class scheduler {
 12 |     public:
 13 |         // scheduler(io_uring_context* ctx) : m_ctx(ctx) {}
 14 | 
 15 |         schedule::sender schedule() {
 16 |             return schedule::sender{m_ctx};
 17 |         }
 18 |         schedule::sender schedule(deadline d) {
 19 |             return schedule::sender{m_ctx, d};
 20 |         }
 21 | 
 22 |         friend auto async_read(iouring::scheduler sch, iouring::native_file_handle fd, void* buffer,
 23 |                                std::size_t size) {
 24 |             return read::sender(sch.m_ctx, fd, buffer, size);
 25 |         }
 26 | 
 27 |     private:
 28 |         template <typename R>
 29 |         friend class operation;
 30 |         friend io_uring_context;
 31 |         scheduler(io_uring_context* ctx) : m_ctx(ctx) {}
 32 | 
 33 |     private:
 34 |         io_uring_context* m_ctx;
 35 |     };
 36 | }  // namespace iouring
 37 | 
 38 | 
 39 | class io_uring_context {
 40 |     friend iouring::operation_base;
 41 | 
 42 | public:
 43 |     io_uring_context() {
 44 |         // init();
 45 |     }
 46 |     ~io_uring_context() {}
 47 | 
 48 |     void run(corio::stop_token stop_token) {
 49 |         stop_callback _(stop_token, [this] {
 50 |             m_stopped = true;
 51 |             notify();
 52 |         });
 53 |         init();
 54 |         schedule_queue_read();
 55 |         while(!m_stopped) {
 56 |             schedule_pendings();
 57 |             if(io_uring_submit(&m_ring) < 0) {
 58 |                 std::cout << "Submit failed\n";
 59 |             }
 60 |             struct io_uring_cqe* cqe;
 61 |             auto ret = io_uring_wait_cqe(&m_ring, &cqe);
 62 |             if(!cqe) {
 63 |                 std::cout << "No cqe";
 64 |                 continue;
 65 |             }
 66 |             if(cqe->user_data == 0) {
 67 |                 // ignore, maybe a cancel operation ?
 68 |             } else if(cqe->user_data == uint64_t(this)) {
 69 |                 uint64_t c;
 70 |                 eventfd_read(m_notify_fd, &c);
 71 |                 m_notify = true;
 72 |             } else {
 73 |                 // std::cout << "Operation " << cqe->res << " " << cqe->user_data << "\n";
 74 |                 auto op = reinterpret_cast<iouring::operation_base*>(cqe->user_data);
 75 |                 if(op) {
 76 |                     op->set_result(cqe);
 77 |                 }
 78 |             }
 79 |             io_uring_cqe_seen(&m_ring, cqe);
 80 |         }
 81 |         io_uring_queue_exit(&m_ring);
 82 |     }
 83 |     auto scheduler() noexcept {
 84 |         return iouring::scheduler{this};
 85 |     }
 86 | 
 87 | private:
 88 |     static constexpr int URING_ENTRIES = 128;
 89 | 
 90 |     struct io_uring m_ring;
 91 |     std::atomic_int m_notify_fd = -1;
 92 |     intrusive_mpsc_queue<iouring::operation_base> m_queue;
 93 |     std::atomic_bool m_notify = true;
 94 |     std::atomic_bool m_stopped = false;
 95 | 
 96 |     void init() {
 97 |         m_notify_fd = ::eventfd(0, O_NONBLOCK);
 98 |         if(m_notify_fd < 0) {
 99 |             fprintf(stderr, "ring setup failed %d %s\n", errno, strerror(errno));
100 |         }
101 | 
102 |         auto ret = io_uring_queue_init(URING_ENTRIES, &m_ring, 0);
103 |         if(ret) {
104 |             fprintf(stderr, "ring setup failed %d %s\n", ret, strerror(-ret));
105 |             std::terminate();
106 |         }
107 |     }
108 | 
109 |     void enqueue_operation(iouring::operation_base* op) {
110 |         if(m_stopped) {
111 |             op->set_done();
112 |         }
113 |         m_queue.push(op);
114 |         notify();
115 |     }
116 |     void notify() {
117 |         eventfd_write(m_notify_fd, 1);
118 |     }
119 | 
120 |     void schedule_queue_read() {
121 |         auto sqe = io_uring_get_sqe(&m_ring);
122 |         if(!sqe) {
123 |             std::cout << "No sqe\n\n";
124 |             // Queue full - not m_notifysure what we should do
125 |         }
126 |         io_uring_prep_poll_add(sqe, m_notify_fd, POLLIN);
127 |         sqe->user_data = uint64_t(this);
128 |         m_notify = false;
129 |     }
130 | 
131 |     void schedule_pendings() {
132 |         while(iouring::operation_base* op = m_queue.front()) {
133 |             // check cqe size too
134 |             auto sqe = io_uring_get_sqe(&m_ring);
135 |             if(!sqe) {
136 |                 // Queue full
137 |                 break;
138 |             }
139 |             op->prepare(sqe);
140 |             sqe->user_data = uint64_t(op);
141 |             m_queue.pop();
142 |             if(m_notify) {
143 |                 schedule_queue_read();
144 |                 m_notify = false;
145 |             }
146 |         }
147 |     }
148 | };
149 | 
150 | namespace iouring {
151 |     void operation_base::start() noexcept {
152 |         m_ctx->enqueue_operation(this);
153 |     }
154 | }  // namespace iouring
155 | 
156 | }  // namespace cor3ntin::corio
157 | 


--------------------------------------------------------------------------------
/include/corio/io_uring/base.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <unistd.h>
 3 | #include <sys/eventfd.h>
 4 | #include <sys/poll.h>
 5 | #include <fcntl.h>
 6 | #include <liburing.h>
 7 | #include <corio/concepts.hpp>
 8 | #include <corio/deadline.hpp>
 9 | #include <corio/intrusive_linked_list.hpp>
10 | 
11 | namespace cor3ntin::corio {
12 | class io_uring_context;
13 | 
14 | __kernel_timespec to_timespec(const deadline& d) {
15 |     auto duration = d.d;
16 |     auto secs = duration_cast<std::chrono::seconds>(duration);
17 |     duration -= secs;
18 |     return {secs.count(), duration.count()};
19 | }
20 | 
21 | namespace iouring {
22 |     using native_file_handle = int;
23 |     class scheduler;
24 | 
25 |     class base_sender {
26 |     public:
27 |         base_sender(io_uring_context* ctx) : m_ctx(ctx) {}
28 |         base_sender(const base_sender&) = delete;
29 |         base_sender(base_sender&&) noexcept = default;
30 | 
31 |     protected:
32 |         io_uring_context* m_ctx;
33 |     };
34 | 
35 |     class operation_base : public intrusive_mpsc_queue_node {
36 |         friend intrusive_mpsc_queue_node;
37 |         friend io_uring_context;
38 | 
39 |     public:
40 |         operation_base(io_uring_context* ctx) : m_ctx(ctx) {}
41 |         // the state is neither copyable nor movable
42 |         operation_base(const operation_base&) = delete;
43 |         operation_base(operation_base&&) = delete;
44 |         virtual void start() noexcept;
45 | 
46 |     protected:
47 |         io_uring_context* m_ctx;
48 |         virtual void set_result(const io_uring_cqe* const res) noexcept = 0;
49 |         virtual void set_done() noexcept = 0;
50 |         virtual void prepare(io_uring_sqe* const sqe) noexcept = 0;
51 | 
52 |     private:
53 |     };
54 | }  // namespace iouring
55 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/io_uring/cancel.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/io_uring/base.hpp>
 3 | 
 4 | namespace cor3ntin::corio::iouring::cancel {
 5 | template <typename R>
 6 | class operation;
 7 | class sender : public base_sender {
 8 |     template <typename R>
 9 |     friend class operation;
10 |     friend io_uring_context;
11 |     sender(io_uring_context* ctx, const operation_base* const op) : base_sender(ctx), m_op(op) {}
12 | 
13 | private:
14 |     const operation_base* const m_op;
15 | 
16 | public:
17 |     template <template <typename...> class Variant, template <typename...> class Tuple>
18 |     using value_types = Variant<Tuple<>>;
19 | 
20 |     template <template <typename...> class Variant>
21 |     using error_types = Variant<>;
22 | 
23 |     static constexpr bool sends_done = true;
24 | 
25 |     template <typename Sender, execution::receiver R>
26 |     using operation_type = operation<R>;
27 | 
28 |     template <execution::receiver R>
29 |     auto connect(R&& r) && {
30 |         return operation(std::move(*this), std::forward<R>(r));
31 |     }
32 | };
33 | 
34 | template <typename R>
35 | class operation : public operation_base {
36 |     friend sender;
37 |     friend io_uring_context;
38 | 
39 | public:
40 |     operation(sender s, R&& r)
41 |         : operation_base(s.m_ctx), m_sender(std::move(s)), m_receiver(std::move(r)) {}
42 | 
43 | protected:
44 |     void set_result(const io_uring_cqe* const cqe) noexcept override {
45 |         if(cqe->res >= 0) {
46 |             execution::set_value(m_receiver);
47 |         }
48 |     }
49 |     void set_done() noexcept override {
50 |         // cancelled the cancel operation ?
51 |     }
52 |     void prepare(io_uring_sqe* const sqe) noexcept override {
53 |         io_uring_prep_cancel(sqe, (void*)(m_sender.m_op), 0);
54 |     }
55 | 
56 | private:
57 |     sender m_sender;
58 |     R m_receiver;
59 | };
60 | }  // namespace cor3ntin::corio::iouring::cancel


--------------------------------------------------------------------------------
/include/corio/io_uring/read.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/io_uring/base.hpp>
 3 | 
 4 | namespace cor3ntin::corio::iouring::read {
 5 | template <typename R>
 6 | class operation;
 7 | class sender : public base_sender {
 8 |     template <typename R>
 9 |     friend class operation;
10 |     friend io_uring_context;
11 | 
12 | public:
13 |     sender(io_uring_context* ctx, native_file_handle fd, void* buffer, std::size_t size)
14 |         : base_sender(ctx), m_fd(fd), m_buffer(buffer), m_size(size) {}
15 | 
16 |     template <template <typename...> class Variant, template <typename...> class Tuple>
17 |     using value_types = Variant<Tuple<std::size_t>>;
18 | 
19 |     template <template <typename...> class Variant>
20 |     using error_types = Variant<std::error_code>;
21 | 
22 |     static constexpr bool sends_done = true;
23 | 
24 |     template <typename Sender, execution::receiver<std::error_code> R>
25 |     using operation_type = operation<R>;
26 | 
27 |     template <execution::receiver<std::error_code> R>
28 |     auto connect(R&& r) && {
29 |         return operation(std::move(*this), std::forward<R>(r));
30 |     }
31 | 
32 |     native_file_handle m_fd;
33 |     void* m_buffer;
34 |     std::size_t m_size;
35 | };
36 | template <typename R>
37 | class operation : public operation_base {
38 |     friend sender;
39 |     friend io_uring_context;
40 | 
41 | public:
42 |     operation(sender s, R&& r)
43 |         : operation_base(s.m_ctx), m_sender(std::move(s)), m_receiver(std::move(r)) {}
44 | 
45 | 
46 | protected:
47 |     void set_result(const io_uring_cqe* const cqe) noexcept override {
48 |         if(cqe->res > 0) {
49 |             execution::set_value(m_receiver, cqe->res);
50 |         } else {
51 |             execution::set_error(m_receiver, std::make_error_code(std::errc(-cqe->res)));
52 |         }
53 |     }
54 | 
55 |     void set_done() noexcept override {
56 |         execution::set_done(m_receiver);
57 |     }
58 | 
59 |     void prepare(io_uring_sqe* const sqe) noexcept override {
60 |         io_uring_prep_read(sqe, m_sender.m_fd, m_sender.m_buffer, m_sender.m_size, 0);
61 |     }
62 | 
63 | private:
64 |     R m_receiver;
65 |     sender m_sender;
66 | };
67 | }  // namespace cor3ntin::corio::iouring::read


--------------------------------------------------------------------------------
/include/corio/io_uring/schedule.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/io_uring/base.hpp>
 3 | 
 4 | namespace cor3ntin::corio::iouring::schedule {
 5 | template <typename R>
 6 | class operation;
 7 | class sender : public base_sender {
 8 |     template <typename R>
 9 |     friend class operation;
10 |     friend scheduler;
11 |     friend io_uring_context;
12 |     sender(io_uring_context* ctx, deadline d = {}) : base_sender(ctx), m_deadline(d) {}
13 | 
14 | private:
15 |     deadline m_deadline;
16 | 
17 | public:
18 |     template <template <typename...> class Variant, template <typename...> class Tuple>
19 |     using value_types = Variant<Tuple<>>;
20 | 
21 |     template <template <typename...> class Variant>
22 |     using error_types = Variant<>;
23 | 
24 |     static constexpr bool sends_done = true;
25 | 
26 |     template <typename Sender, execution::receiver R>
27 |     using operation_type = operation<R>;
28 | 
29 |     template <execution::receiver R>
30 |     auto connect(R&& r) && {
31 |         return operation(std::move(*this), std::forward<R>(r));
32 |     }
33 | };
34 | template <typename R>
35 | class operation : public operation_base {
36 |     friend sender;
37 |     friend io_uring_context;
38 |     operation(sender s, R&& r)
39 |         : operation_base(s.m_ctx), m_sender(std::move(s)), m_receiver(std::move(r)) {}
40 | 
41 | protected:
42 |     void set_result(const io_uring_cqe* const cqe) noexcept override {
43 |         if(cqe->res >= 0 || cqe->res == -ETIME) {
44 |             execution::set_value(m_receiver);
45 |         }
46 |     }
47 |     virtual void set_done() noexcept override {
48 |         execution::set_done(m_receiver);
49 |     }
50 |     void prepare(io_uring_sqe* const sqe) noexcept override {
51 |         m_ts = to_timespec(m_sender.m_deadline);
52 |         // std::cout << "Deadline " << m_ts.tv_sec << " " << m_ts.tv_nsec << "\n";
53 |         if(m_ts.tv_sec == 0 && m_ts.tv_nsec == 0) {
54 |             io_uring_prep_nop(sqe);
55 |         } else {
56 |             io_uring_prep_timeout(sqe, &m_ts, 0, 0);
57 |         }
58 |     }
59 | 
60 | 
61 | private:
62 |     sender m_sender;
63 |     __kernel_timespec m_ts;
64 |     R m_receiver;
65 | };
66 | 
67 | }  // namespace cor3ntin::corio::iouring::schedule


--------------------------------------------------------------------------------
/include/corio/meta.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <stl2/concepts.hpp>
 3 | 
 4 | namespace cor3ntin::corio {
 5 | 
 6 | namespace concepts = std::experimental::ranges;
 7 | 
 8 | namespace details {
 9 | 
10 |     template <class T>
11 |     concept nothrow_move_or_copy_constructible =
12 |         std::is_nothrow_move_constructible_v<T> || concepts::copy_constructible<T>;
13 | 
14 |     template <typename UniqueTypes, typename UnprocessedTypes>
15 |     struct deduplicate_impl {
16 |         using type = UniqueTypes;
17 |     };
18 | 
19 |     template <template <typename...> class List, typename... UniqueTs, typename Next,
20 |               typename... Rest>
21 |     struct deduplicate_impl<List<UniqueTs...>, List<Next, Rest...>>
22 |         : deduplicate_impl<std::conditional_t<std::disjunction_v<std::is_same<UniqueTs, Next>...>,
23 |                                               List<UniqueTs...>, List<UniqueTs..., Next>>,
24 |                            List<Rest...>> {};
25 | 
26 |     template <typename Types>
27 |     struct deduplicate;
28 | 
29 |     template <template <typename...> class List, typename... Ts>
30 |     struct deduplicate<List<Ts...>> : deduplicate_impl<List<>, List<Ts...>> {};
31 | 
32 |     template <typename Types>
33 |     using deduplicate_t = typename deduplicate<Types>::type;
34 | 
35 |     template <typename... Values>
36 |     struct single_type {
37 |         // empty so we are SFINAE friendly.
38 |     };
39 | 
40 |     template <typename T>
41 |     struct single_type<T> {
42 |         using type = T;
43 |     };
44 | 
45 |     template <typename... Types>
46 |     struct single_value_type {
47 |         using type = std::tuple<Types...>;
48 |     };
49 | 
50 |     template <typename T>
51 |     struct single_value_type<T> {
52 |         using type = T;
53 |     };
54 | 
55 |     template <>
56 |     struct single_value_type<> {
57 |         using type = void;
58 |     };
59 |     template <typename... Args>
60 |     struct is_empty_list : std::bool_constant<(sizeof...(Args) == 0)> {};
61 | 
62 |     struct empty_result_t {};
63 | 
64 |     template <typename T>
65 |     using non_void_t = std::conditional_t<std::is_void_v<T>, empty_result_t, T>;
66 | 
67 | }  // namespace details
68 | 
69 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/spawn.hpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <corio/tag_invoke.hpp>
 3 | #pragma once
 4 | 
 5 | namespace cor3ntin::corio {
 6 | 
 7 | namespace details {
 8 |     template <typename Sender, typename Receiver>
 9 |     struct spawned_op {
10 |         struct wrapped_receiver {
11 |             spawned_op* m_op;
12 |             explicit wrapped_receiver(spawned_op* op) noexcept : m_op(op) {}
13 |             template <typename... Values>
14 |             void set_value(Values&&... values) noexcept {
15 |                 m_op->m_receiver.set_value((Values &&) values...);
16 |                 delete m_op;
17 |             }
18 |             template <typename Error>
19 |             void set_error(Error&& error) noexcept {
20 |                 m_op->m_receiver.set_error((Error &&) error);
21 |                 delete m_op;
22 |             }
23 |             void set_done() noexcept {
24 |                 m_op->m_receiver.set_done();
25 |                 delete m_op;
26 |             }
27 |         };
28 |         spawned_op(Sender&& sender, Receiver&& receiver)
29 |             : m_receiver((Receiver &&) receiver)
30 |             , m_inner(std::move(sender).connect(wrapped_receiver{this})) {}
31 |         void start() & noexcept {
32 |             m_inner.start();
33 |         }
34 |         Receiver m_receiver;
35 |         typename Sender::template operation_type<Sender, wrapped_receiver> m_inner;
36 |     };
37 | 
38 |     template <typename Sender, typename Receiver>
39 |     void spawn(Sender&& sender, Receiver&& receiver) noexcept {
40 |         auto* op = new spawned_op<Sender, std::remove_cvref_t<Receiver>>((Sender &&) sender,
41 |                                                                          (Receiver &&) receiver);
42 |         op->start();
43 |     }
44 | }  // namespace details
45 | 
46 | namespace execution {
47 |     namespace __spawn_ns {
48 |         struct __spawn_base {};
49 |     }  // namespace __spawn_ns
50 | 
51 |     inline constexpr struct __spawn_fn : __spawn_ns::__spawn_base {
52 |         template <typename Sender, typename Receiver>
53 |         requires cor3ntin::corio::tag_invocable<__spawn_fn, Sender, Receiver> auto
54 |         operator()(Sender&& s, Receiver&& r) const {
55 |             return cor3ntin::corio::tag_invoke(*this, std::forward<Sender>(s), (Receiver &&) r);
56 |         }
57 | 
58 |         template <typename Sender, typename Receiver>
59 |         requires requires(Sender&& s, Receiver&& r) {
60 |             details::spawn(std::forward<Sender>(s), std::forward<Receiver>(r));
61 |         }
62 |         friend void tag_invoke(__spawn_fn, Sender&& s, Receiver&& r) {
63 |             return details::spawn(std::forward<Sender>(s), std::forward<Receiver>(r));
64 |         }
65 |     } spawn;
66 | 
67 | }  // namespace execution
68 | 
69 | 
70 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/stop_token.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | // <stop_token> header
  3 | 
  4 | #include <atomic>
  5 | #include <thread>
  6 | #include <type_traits>
  7 | #include <utility>
  8 | #ifdef SAFE
  9 | #    include <iostream>
 10 | #endif
 11 | 
 12 | #if defined(__x86_64__) || defined(_M_X64)
 13 | #    include <immintrin.h>
 14 | #endif
 15 | 
 16 | namespace cor3ntin::corio {
 17 | 
 18 | #if __cplusplus <= 201703L
 19 | template <typename T>
 20 | struct unwrap_reference {
 21 |     using type = T;
 22 | };
 23 | 
 24 | template <typename T>
 25 | struct unwrap_reference<std::reference_wrapper<T>> {
 26 |     using type = T&;
 27 | };
 28 | 
 29 | template <class T>
 30 | using unwrap_reference_t = typename unwrap_reference<T>::type;
 31 | #endif
 32 | 
 33 | // workaround for non exitsing unwrap_reference:
 34 | 
 35 | inline void __spin_yield() noexcept {
 36 |     // TODO: Platform-specific code here
 37 | #if defined(__x86_64__) || defined(_M_X64)
 38 |     _mm_pause();
 39 | #endif
 40 | }
 41 | 
 42 | 
 43 | //-----------------------------------------------
 44 | // internal types for shared stop state
 45 | //-----------------------------------------------
 46 | 
 47 | struct __stop_callback_base {
 48 |     void (*__callback_)(__stop_callback_base*) = nullptr;
 49 | 
 50 |     __stop_callback_base* __next_ = nullptr;
 51 |     __stop_callback_base** __prev_ = nullptr;
 52 |     bool* __isRemoved_ = nullptr;
 53 |     std::atomic<bool> __callbackFinishedExecuting_{false};
 54 | 
 55 |     void __execute() noexcept {
 56 |         __callback_(this);
 57 |     }
 58 | 
 59 | protected:
 60 |     // it shall only by us who deletes this
 61 |     // (workaround for virtual __execute() and destructor)
 62 |     ~__stop_callback_base() = default;
 63 | };
 64 | 
 65 | struct __stop_state {
 66 | public:
 67 |     void __add_token_reference() noexcept {
 68 |         __state_.fetch_add(__token_ref_increment, std::memory_order_relaxed);
 69 |     }
 70 | 
 71 |     void __remove_token_reference() noexcept {
 72 |         auto __oldState = __state_.fetch_sub(__token_ref_increment, std::memory_order_acq_rel);
 73 |         if(__oldState < (__token_ref_increment + __token_ref_increment)) {
 74 |             delete this;
 75 |         }
 76 |     }
 77 | 
 78 |     void __add_source_reference() noexcept {
 79 |         __state_.fetch_add(__source_ref_increment, std::memory_order_relaxed);
 80 |     }
 81 | 
 82 |     void __remove_source_reference() noexcept {
 83 |         auto __oldState = __state_.fetch_sub(__source_ref_increment, std::memory_order_acq_rel);
 84 |         if(__oldState < (__token_ref_increment + __source_ref_increment)) {
 85 |             delete this;
 86 |         }
 87 |     }
 88 | 
 89 |     bool __request_stop() noexcept {
 90 | 
 91 |         if(!__try_lock_and_signal_until_signalled()) {
 92 |             // Stop has already been requested.
 93 |             return false;
 94 |         }
 95 | 
 96 |         // Set the 'stop_requested' signal and acquired the lock.
 97 | 
 98 |         __signallingThread_ = std::this_thread::get_id();
 99 | 
100 |         while(__head_ != nullptr) {
101 |             // Dequeue the head of the queue
102 |             auto* __cb = __head_;
103 |             __head_ = __cb->__next_;
104 |             const bool anyMore = __head_ != nullptr;
105 |             if(anyMore) {
106 |                 __head_->__prev_ = &__head_;
107 |             }
108 |             // Mark this item as removed from the list.
109 |             __cb->__prev_ = nullptr;
110 | 
111 |             // Don't hold lock while executing callback
112 |             // so we don't block other threads from deregistering callbacks.
113 |             __unlock();
114 | 
115 |             // TRICKY: Need to store a flag on the stack here that the callback
116 |             // can use to signal that the destructor was executed inline
117 |             // during the call. If the destructor was executed inline then
118 |             // it's not safe to dereference __cb after __execute() returns.
119 |             // If the destructor runs on some other thread then the other
120 |             // thread will block waiting for this thread to signal that the
121 |             // callback has finished executing.
122 |             bool __isRemoved = false;
123 |             __cb->__isRemoved_ = &__isRemoved;
124 | 
125 |             __cb->__execute();
126 | 
127 |             if(!__isRemoved) {
128 |                 __cb->__isRemoved_ = nullptr;
129 |                 __cb->__callbackFinishedExecuting_.store(true, std::memory_order_release);
130 |             }
131 | 
132 |             if(!anyMore) {
133 |                 // This was the last item in the queue when we dequeued it.
134 |                 // No more items should be added to the queue after we have
135 |                 // marked the state as interrupted, only removed from the queue.
136 |                 // Avoid acquring/releasing the lock in this case.
137 |                 return true;
138 |             }
139 | 
140 |             __lock();
141 |         }
142 | 
143 |         __unlock();
144 | 
145 |         return true;
146 |     }
147 | 
148 |     bool __is_stop_requested() noexcept {
149 |         return __is_stop_requested(__state_.load(std::memory_order_acquire));
150 |     }
151 | 
152 |     bool __is_stop_requestable() noexcept {
153 |         return __is_stop_requestable(__state_.load(std::memory_order_acquire));
154 |     }
155 | 
156 |     bool __try_add_callback(__stop_callback_base* __cb,
157 |                             bool __incrementRefCountIfSuccessful) noexcept {
158 |         std::uint64_t __oldState;
159 |         goto load_state;
160 |         do {
161 |             goto check_state;
162 |             do {
163 |                 __spin_yield();
164 |             load_state:
165 |                 __oldState = __state_.load(std::memory_order_acquire);
166 |             check_state:
167 |                 if(__is_stop_requested(__oldState)) {
168 |                     __cb->__execute();
169 |                     return false;
170 |                 } else if(!__is_stop_requestable(__oldState)) {
171 |                     return false;
172 |                 }
173 |             } while(__is_locked(__oldState));
174 |         } while(!__state_.compare_exchange_weak(__oldState, __oldState | __locked_flag,
175 |                                                 std::memory_order_acquire));
176 | 
177 |         // Push callback onto callback list.
178 |         __cb->__next_ = __head_;
179 |         if(__cb->__next_ != nullptr) {
180 |             __cb->__next_->__prev_ = &__cb->__next_;
181 |         }
182 |         __cb->__prev_ = &__head_;
183 |         __head_ = __cb;
184 | 
185 |         if(__incrementRefCountIfSuccessful) {
186 |             __unlock_and_increment_token_ref_count();
187 |         } else {
188 |             __unlock();
189 |         }
190 | 
191 |         // Successfully added the callback.
192 |         return true;
193 |     }
194 | 
195 |     void __remove_callback(__stop_callback_base* __cb) noexcept {
196 |         __lock();
197 | 
198 |         if(__cb->__prev_ != nullptr) {
199 |             // Still registered, not yet executed
200 |             // Just remove from the list.
201 |             *__cb->__prev_ = __cb->__next_;
202 |             if(__cb->__next_ != nullptr) {
203 |                 __cb->__next_->__prev_ = __cb->__prev_;
204 |             }
205 | 
206 |             __unlock_and_decrement_token_ref_count();
207 | 
208 |             return;
209 |         }
210 | 
211 |         __unlock();
212 | 
213 |         // Callback has either already executed or is executing
214 |         // concurrently on another thread.
215 | 
216 |         if(__signallingThread_ == std::this_thread::get_id()) {
217 |             // Callback executed on this thread or is still currently executing
218 |             // and is deregistering itself from within the callback.
219 |             if(__cb->__isRemoved_ != nullptr) {
220 |                 // Currently inside the callback, let the __request_stop() method
221 |                 // know the object is about to be destructed and that it should
222 |                 // not try to access the object when the callback returns.
223 |                 *__cb->__isRemoved_ = true;
224 |             }
225 |         } else {
226 |             // Callback is currently executing on another thread,
227 |             // block until it finishes executing.
228 |             while(!__cb->__callbackFinishedExecuting_.load(std::memory_order_acquire)) {
229 |                 __spin_yield();
230 |             }
231 |         }
232 | 
233 |         __remove_token_reference();
234 |     }
235 | 
236 | private:
237 |     static bool __is_locked(std::uint64_t __state) noexcept {
238 |         return (__state & __locked_flag) != 0;
239 |     }
240 | 
241 |     static bool __is_stop_requested(std::uint64_t __state) noexcept {
242 |         return (__state & __stop_requested_flag) != 0;
243 |     }
244 | 
245 |     static bool __is_stop_requestable(std::uint64_t __state) noexcept {
246 |         // Interruptible if it has already been interrupted or if there are
247 |         // still interrupt_source instances in existence.
248 |         return __is_stop_requested(__state) || (__state >= __source_ref_increment);
249 |     }
250 | 
251 |     bool __try_lock_and_signal_until_signalled() noexcept {
252 |         std::uint64_t __oldState = __state_.load(std::memory_order_acquire);
253 |         do {
254 |             if(__is_stop_requested(__oldState))
255 |                 return false;
256 |             while(__is_locked(__oldState)) {
257 |                 __spin_yield();
258 |                 __oldState = __state_.load(std::memory_order_acquire);
259 |                 if(__is_stop_requested(__oldState))
260 |                     return false;
261 |             }
262 |         } while(!__state_.compare_exchange_weak(
263 |             __oldState, __oldState | __stop_requested_flag | __locked_flag,
264 |             std::memory_order_acq_rel, std::memory_order_acquire));
265 |         return true;
266 |     }
267 | 
268 |     void __lock() noexcept {
269 |         auto __oldState = __state_.load(std::memory_order_relaxed);
270 |         do {
271 |             while(__is_locked(__oldState)) {
272 |                 __spin_yield();
273 |                 __oldState = __state_.load(std::memory_order_relaxed);
274 |             }
275 |         } while(!__state_.compare_exchange_weak(__oldState, __oldState | __locked_flag,
276 |                                                 std::memory_order_acquire,
277 |                                                 std::memory_order_relaxed));
278 |     }
279 | 
280 |     void __unlock() noexcept {
281 |         __state_.fetch_sub(__locked_flag, std::memory_order_release);
282 |     }
283 | 
284 |     void __unlock_and_increment_token_ref_count() noexcept {
285 |         __state_.fetch_sub(__locked_flag - __token_ref_increment, std::memory_order_release);
286 |     }
287 | 
288 |     void __unlock_and_decrement_token_ref_count() noexcept {
289 |         auto __oldState =
290 |             __state_.fetch_sub(__locked_flag + __token_ref_increment, std::memory_order_acq_rel);
291 |         // Check if new state is less than __token_ref_increment which would
292 |         // indicate that this was the last reference.
293 |         if(__oldState < (__locked_flag + __token_ref_increment + __token_ref_increment)) {
294 |             delete this;
295 |         }
296 |     }
297 | 
298 |     static constexpr std::uint64_t __stop_requested_flag = 1u;
299 |     static constexpr std::uint64_t __locked_flag = 2u;
300 |     static constexpr std::uint64_t __token_ref_increment = 4u;
301 |     static constexpr std::uint64_t __source_ref_increment = static_cast<std::uint64_t>(1u) << 33u;
302 | 
303 |     // bit 0 - stop-requested
304 |     // bit 1 - locked
305 |     // bits 2-32 - token ref count (31 bits)
306 |     // bits 33-63 - source ref count (31 bits)
307 |     std::atomic<std::uint64_t> __state_{__source_ref_increment};
308 |     __stop_callback_base* __head_ = nullptr;
309 |     std::thread::id __signallingThread_{};
310 | };
311 | 
312 | 
313 | //-----------------------------------------------
314 | // forward declarations
315 | //-----------------------------------------------
316 | 
317 | class stop_source;
318 | template <typename _Callback>
319 | class stop_callback;
320 | 
321 | // std::nostopstate
322 | // - to initialize a stop_source without shared stop state
323 | struct nostopstate_t {
324 |     explicit nostopstate_t() = default;
325 | };
326 | inline constexpr nostopstate_t nostopstate{};
327 | 
328 | 
329 | //-----------------------------------------------
330 | // stop_token
331 | //-----------------------------------------------
332 | 
333 | class stop_token {
334 | public:
335 |     // construct:
336 |     // - TODO: explicit?
337 |     stop_token() noexcept : __state_(nullptr) {}
338 | 
339 |     // copy/move/assign/destroy:
340 |     stop_token(const stop_token& __it) noexcept : __state_(__it.__state_) {
341 |         if(__state_ != nullptr) {
342 |             __state_->__add_token_reference();
343 |         }
344 |     }
345 | 
346 |     stop_token(stop_token&& __it) noexcept : __state_(std::exchange(__it.__state_, nullptr)) {}
347 | 
348 |     ~stop_token() {
349 |         if(__state_ != nullptr) {
350 |             __state_->__remove_token_reference();
351 |         }
352 |     }
353 | 
354 |     stop_token& operator=(const stop_token& __it) noexcept {
355 |         if(__state_ != __it.__state_) {
356 |             stop_token __tmp{__it};
357 |             swap(__tmp);
358 |         }
359 |         return *this;
360 |     }
361 | 
362 |     stop_token& operator=(stop_token&& __it) noexcept {
363 |         stop_token __tmp{std::move(__it)};
364 |         swap(__tmp);
365 |         return *this;
366 |     }
367 | 
368 |     void swap(stop_token& __it) noexcept {
369 |         std::swap(__state_, __it.__state_);
370 |     }
371 | 
372 |     // stop handling:
373 |     [[nodiscard]] bool stop_requested() const noexcept {
374 |         return __state_ != nullptr && __state_->__is_stop_requested();
375 |     }
376 | 
377 |     [[nodiscard]] bool stop_possible() const noexcept {
378 |         return __state_ != nullptr && __state_->__is_stop_requestable();
379 |     }
380 | 
381 |     [[nodiscard]] friend bool operator==(const stop_token& __a, const stop_token& __b) noexcept {
382 |         return __a.__state_ == __b.__state_;
383 |     }
384 |     [[nodiscard]] friend bool operator!=(const stop_token& __a, const stop_token& __b) noexcept {
385 |         return __a.__state_ != __b.__state_;
386 |     }
387 | 
388 | private:
389 |     friend class stop_source;
390 |     template <typename _Callback>
391 |     friend class stop_callback;
392 | 
393 |     explicit stop_token(__stop_state* __state) noexcept : __state_(__state) {
394 |         if(__state_ != nullptr) {
395 |             __state_->__add_token_reference();
396 |         }
397 |     }
398 | 
399 |     __stop_state* __state_;
400 | };
401 | 
402 | 
403 | //-----------------------------------------------
404 | // stop_source
405 | //-----------------------------------------------
406 | 
407 | class stop_source {
408 | public:
409 |     stop_source() : __state_(new __stop_state()) {}
410 | 
411 |     explicit stop_source(nostopstate_t) noexcept : __state_(nullptr) {}
412 | 
413 |     ~stop_source() {
414 |         if(__state_ != nullptr) {
415 |             __state_->__remove_source_reference();
416 |         }
417 |     }
418 | 
419 |     stop_source(const stop_source& __other) noexcept : __state_(__other.__state_) {
420 |         if(__state_ != nullptr) {
421 |             __state_->__add_source_reference();
422 |         }
423 |     }
424 | 
425 |     stop_source(stop_source&& __other) noexcept
426 |         : __state_(std::exchange(__other.__state_, nullptr)) {}
427 | 
428 |     stop_source& operator=(stop_source&& __other) noexcept {
429 |         stop_source __tmp{std::move(__other)};
430 |         swap(__tmp);
431 |         return *this;
432 |     }
433 | 
434 |     stop_source& operator=(const stop_source& __other) noexcept {
435 |         if(__state_ != __other.__state_) {
436 |             stop_source __tmp{__other};
437 |             swap(__tmp);
438 |         }
439 |         return *this;
440 |     }
441 | 
442 |     [[nodiscard]] bool stop_requested() const noexcept {
443 |         return __state_ != nullptr && __state_->__is_stop_requested();
444 |     }
445 | 
446 |     [[nodiscard]] bool stop_possible() const noexcept {
447 |         return __state_ != nullptr;
448 |     }
449 | 
450 |     bool request_stop() const noexcept {
451 |         if(__state_ != nullptr) {
452 |             return __state_->__request_stop();
453 |         }
454 |         return false;
455 |     }
456 | 
457 |     [[nodiscard]] stop_token get_token() const noexcept {
458 |         return stop_token{__state_};
459 |     }
460 | 
461 |     void swap(stop_source& __other) noexcept {
462 |         std::swap(__state_, __other.__state_);
463 |     }
464 | 
465 |     [[nodiscard]] friend bool operator==(const stop_source& __a, const stop_source& __b) noexcept {
466 |         return __a.__state_ == __b.__state_;
467 |     }
468 |     [[nodiscard]] friend bool operator!=(const stop_source& __a, const stop_source& __b) noexcept {
469 |         return __a.__state_ != __b.__state_;
470 |     }
471 | 
472 | private:
473 |     __stop_state* __state_;
474 | };
475 | 
476 | 
477 | //-----------------------------------------------
478 | // stop_callback
479 | //-----------------------------------------------
480 | 
481 | template <typename _Callback>
482 | // requires Destructible<_Callback> && Invocable<_Callback>
483 | class [[nodiscard]] stop_callback : private __stop_callback_base {
484 | public:
485 |     using callback_type = _Callback;
486 | 
487 |     template <typename _CB, std::enable_if_t<std::is_constructible_v<_Callback, _CB>, int> = 0>
488 |     // requires Constructible<Callback, C>
489 |     explicit stop_callback(const stop_token& __token,
490 |                            _CB&& __cb) noexcept(std::is_nothrow_constructible_v<_Callback, _CB>)
491 |         : __stop_callback_base{[](__stop_callback_base* __that) noexcept {
492 |             static_cast<stop_callback*>(__that)->__execute();
493 |         }}
494 |         , __state_(nullptr)
495 |         , __cb_(static_cast<_CB&&>(__cb)) {
496 |         if(__token.__state_ != nullptr && __token.__state_->__try_add_callback(this, true)) {
497 |             __state_ = __token.__state_;
498 |         }
499 |     }
500 | 
501 |     template <typename _CB, std::enable_if_t<std::is_constructible_v<_Callback, _CB>, int> = 0>
502 |     // requires Constructible<Callback, C>
503 |     explicit stop_callback(stop_token && __token,
504 |                            _CB && __cb) noexcept(std::is_nothrow_constructible_v<_Callback, _CB>)
505 |         : __stop_callback_base{[](__stop_callback_base* __that) noexcept {
506 |             static_cast<stop_callback*>(__that)->__execute();
507 |         }}
508 |         , __state_(nullptr)
509 |         , __cb_(static_cast<_CB&&>(__cb)) {
510 |         if(__token.__state_ != nullptr && __token.__state_->__try_add_callback(this, false)) {
511 |             __state_ = std::exchange(__token.__state_, nullptr);
512 |         }
513 |     }
514 | 
515 |     ~stop_callback() {
516 | #ifdef SAFE
517 |         if(__inExecute_.load()) {
518 |             std::cerr << "*** OOPS: ~stop_callback() while callback executed\n";
519 |         }
520 | #endif
521 |         if(__state_ != nullptr) {
522 |             __state_->__remove_callback(this);
523 |         }
524 |     }
525 | 
526 |     stop_callback& operator=(const stop_callback&) = delete;
527 |     stop_callback& operator=(stop_callback&&) = delete;
528 |     stop_callback(const stop_callback&) = delete;
529 |     stop_callback(stop_callback &&) = delete;
530 | 
531 | private:
532 |     void __execute() noexcept {
533 |         // Executed in a noexcept context
534 |         // If it throws then we call std::terminate().
535 | #ifdef SAFE
536 |         __inExecute_.store(true);
537 |         __cb_();
538 |         __inExecute_.store(false);
539 | #else
540 |         __cb_();
541 | #endif
542 |     }
543 | 
544 |     __stop_state* __state_;
545 |     _Callback __cb_;
546 | #ifdef SAFE
547 |     std::atomic<bool> __inExecute_{false};
548 | #endif
549 | };
550 | 
551 | template <typename _Callback>
552 | stop_callback(stop_token, _Callback)->stop_callback<_Callback>;
553 | 
554 | }  // namespace cor3ntin::corio
555 | 


--------------------------------------------------------------------------------
/include/corio/tag_invoke.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | //implement and stollen from
 4 | // http://open-std.org/JTC1/SC22/WG21/docs/papers/2019/p1895r0.pdf
 5 | namespace cor3ntin::corio {
 6 |     namespace __tag_invoke_fn_ns
 7 |     {
 8 |         void tag_invoke() = delete;
 9 | 
10 |         struct __tag_invoke_fn
11 |         {
12 |             template<typename _Tag, typename... _Args>
13 |                 requires requires (_Tag __tag, _Args&&... __args) {
14 |                     tag_invoke((_Tag&&)__tag, (_Args&&)__args...);
15 |                 }
16 |             constexpr auto operator()(_Tag __tag, _Args&&... __args) const
17 |                 noexcept(noexcept(tag_invoke((_Tag&&)__tag, (_Args&&)__args...)))
18 |                 -> decltype(auto) {
19 |                 return tag_invoke((_Tag&&)__tag, (_Args&&)__args...);
20 |             }
21 |         };
22 |     }
23 | 
24 |     inline namespace __tag_invoke_ns
25 |     {
26 |         inline constexpr __tag_invoke_fn_ns::__tag_invoke_fn tag_invoke = {};
27 |     }
28 | 
29 |     template<typename _Tag, typename... _Args>
30 |     concept tag_invocable =
31 |         requires(_Tag && tag, _Args&&... args) {
32 |             cor3ntin::corio::tag_invoke((_Tag&&)tag, (_Args&&)args...);
33 |         };
34 | 
35 |     template<typename _Tag, typename... _Args>
36 |     concept nothrow_tag_invocable =
37 |         tag_invocable<_Tag, _Args...> &&
38 |         requires(_Tag && tag, _Args&&... args) {
39 |             { cor3ntin::corio::tag_invoke((_Tag&&)tag, (_Args&&)args...) } noexcept;
40 |         };
41 | 
42 |     template<typename _Tag, typename... _Args>
43 |     using tag_invoke_result = std::invoke_result<decltype(cor3ntin::corio::tag_invoke), _Tag, _Args...>;
44 | 
45 |     template<typename _Tag, typename... _Args>
46 |     using tag_invoke_result_t = std::invoke_result_t<decltype(cor3ntin::corio::tag_invoke), _Tag, _Args...>;
47 | 
48 |     template<auto& _Tag>
49 |     using tag_t = std::decay_t<decltype(_Tag)>;
50 | }


--------------------------------------------------------------------------------
/include/corio/then.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <corio/concepts.hpp>
  3 | 
  4 | namespace cor3ntin::corio {
  5 | 
  6 | template <typename Predecessor, typename Func>
  7 | struct then_sender {
  8 |     [[no_unique_address]] Predecessor pred_;
  9 |     [[no_unique_address]] Func func_;
 10 | 
 11 |     template <template <typename...> class Tuple>
 12 |     struct then_result {
 13 |     private:
 14 |         template <typename Result, typename = void>
 15 |         struct impl {
 16 |             using type = Tuple<Result>;
 17 |         };
 18 |         template <typename Result>
 19 |         struct impl<Result, std::enable_if_t<std::is_void_v<Result>>> {
 20 |             using type = Tuple<>;
 21 |         };
 22 | 
 23 |     public:
 24 |         template <typename... Args>
 25 |         using apply = typename impl<std::invoke_result_t<Func, Args...>>::type;
 26 |     };
 27 | 
 28 |     template <typename... Args>
 29 |     using is_overload_noexcept =
 30 |         std::bool_constant<noexcept(std::invoke(std::declval<Func>(), std::declval<Args>()...))>;
 31 | 
 32 |     template <template <typename...> class Variant>
 33 |     struct calculate_errors {
 34 |     public:
 35 |         template <typename... Errors>
 36 |         using apply = std::conditional_t<
 37 |             Predecessor::template value_types<std::conjunction, is_overload_noexcept>::value,
 38 |             Variant<Errors...>, details::deduplicate_t<Variant<Errors..., std::exception_ptr>>>;
 39 |     };
 40 | 
 41 |     template <template <typename...> class Variant, template <typename...> class Tuple>
 42 |     using value_types = details::deduplicate_t<
 43 |         typename Predecessor::template value_types<Variant, then_result<Tuple>::template apply>>;
 44 | 
 45 |     template <template <typename...> class Variant>
 46 |     using error_types =
 47 |         typename Predecessor::template error_types<calculate_errors<Variant>::template apply>;
 48 | 
 49 |     template <typename Receiver>
 50 |     struct then_receiver {
 51 |         [[no_unique_address]] Func func_;
 52 |         [[no_unique_address]] Receiver receiver_;
 53 | 
 54 |         template <typename... Values>
 55 |             void set_value(Values&&... values) && noexcept {
 56 |             using result_type = std::invoke_result_t<Func, Values...>;
 57 |             if constexpr(std::is_void_v<result_type>) {
 58 |                 if constexpr(noexcept(std::invoke((Func &&) func_, (Values &&) values...))) {
 59 |                     std::invoke((Func &&) func_, (Values &&) values...);
 60 |                     execution::set_value((Receiver &&) receiver_);
 61 |                 } else {
 62 |                     try {
 63 |                         std::invoke((Func &&) func_, (Values &&) values...);
 64 |                         execution::set_value((Receiver &&) receiver_);
 65 |                     } catch(...) {
 66 |                         execution::set_error((Receiver &&) receiver_, std::current_exception());
 67 |                     }
 68 |                 }
 69 |             } else {
 70 |                 if constexpr(noexcept(std::invoke((Func &&) func_, (Values &&) values...))) {
 71 |                     execution::set_value((Receiver &&) receiver_,
 72 |                                          std::invoke((Func &&) func_, (Values &&) values...));
 73 |                 } else {
 74 |                     try {
 75 |                         execution::set_value((Receiver &&) receiver_,
 76 |                                              std::invoke((Func &&) func_, (Values &&) values...));
 77 |                     } catch(...) {
 78 |                         execution::set_error((Receiver &&) receiver_, std::current_exception());
 79 |                     }
 80 |                 }
 81 |             }
 82 |         }
 83 | 
 84 |         template <typename Error>
 85 |             void set_error(Error&& error) && noexcept {
 86 |             execution::set_error((Receiver &&) receiver_, (Error &&) error);
 87 |         }
 88 | 
 89 |         void set_done() && noexcept {
 90 |             execution::set_done((Receiver &&) receiver_);
 91 |         }
 92 |     };
 93 | 
 94 |     template <typename Receiver>
 95 |     auto connect(Receiver&& receiver) && {
 96 |         return execution::connect(std::forward<Predecessor>(pred_),
 97 |                                   then_receiver<std::remove_cvref_t<Receiver>>{
 98 |                                       std::forward<Func>(func_), std::forward<Receiver>(receiver)});
 99 |     }
100 | };
101 | 
102 | template <typename Sender, typename Func>
103 | auto then(Sender&& predecessor, Func&& func) {
104 |     return then_sender<std::remove_cvref_t<Sender>, std::decay_t<Func>>{(Sender &&) predecessor,
105 |                                                                         (Func &&) func};
106 | }
107 | 
108 | }  // namespace cor3ntin::corio


--------------------------------------------------------------------------------
/include/corio/thread_pool.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | #include <corio/concepts.hpp>
  3 | #include <vector>
  4 | #include <vector>
  5 | #include <thread>
  6 | #include <queue>
  7 | #include <exception>
  8 | 
  9 | namespace cor3ntin::corio {
 10 | 
 11 | class static_thread_pool {
 12 | 
 13 |     class stp_scheduler;
 14 |     template <typename R>
 15 |     class schedule_operation;
 16 | 
 17 |     class task_sender {
 18 |     public:
 19 |         template <template <typename...> class Variant, template <typename...> class Tuple>
 20 |         using value_types = Variant<Tuple<>>;
 21 | 
 22 |         template <template <typename...> class Variant>
 23 |         using error_types = Variant<>;
 24 | 
 25 |         static constexpr bool sends_done = true;
 26 | 
 27 |         template <typename R>
 28 |         friend class schedule_operation;
 29 |         friend class stp_scheduler;
 30 | 
 31 |         template <typename Sender, execution::receiver R>
 32 |         using operation_type = schedule_operation<R>;
 33 | 
 34 | 
 35 |     private:
 36 |         task_sender(static_thread_pool& pool) : m_pool(pool) {}
 37 |         static_thread_pool& m_pool;
 38 | 
 39 |     public:
 40 |         task_sender(const task_sender&) = delete;
 41 |         task_sender(task_sender&&) noexcept = default;
 42 | 
 43 |         template <execution::receiver R>
 44 |         auto connect(R&& r) && {
 45 |             return schedule_operation(std::move(*this), std::forward<R>(r));
 46 |         }
 47 |     };
 48 | 
 49 |     class operation_base {
 50 |         friend class static_thread_pool;
 51 | 
 52 |         operation_base() = default;
 53 |         // the state is neither copyable nor movable
 54 |         operation_base(const operation_base&) = delete;
 55 |         operation_base(operation_base&&) = delete;
 56 | 
 57 |     protected:
 58 |         virtual void set_value() noexcept = 0;
 59 |         virtual void set_error() noexcept = 0;
 60 |         virtual void set_done() noexcept = 0;
 61 |         operation_base* m_next = nullptr;
 62 |     };
 63 | 
 64 |     template <typename R>
 65 |     class schedule_operation : public operation_base {
 66 |         friend class task_sender;
 67 |         schedule_operation(task_sender s, R r) : m_sender(std::move(s)), m_receiver(std::move(r)) {}
 68 | 
 69 |         task_sender m_sender;
 70 |         R m_receiver;
 71 | 
 72 | 
 73 |     protected:
 74 |         void set_value() noexcept override {
 75 |             m_receiver.set_value();
 76 |         }
 77 |         void set_done() noexcept override {
 78 |             m_receiver.set_done();
 79 |         }
 80 |         void set_error() noexcept override {
 81 |             m_receiver.set_done();
 82 |         }
 83 | 
 84 |     public:
 85 |         void start() noexcept {
 86 |             m_sender.m_pool.execute(*this);
 87 |         }
 88 |     };
 89 | 
 90 |     template <execution::receiver R>
 91 |     class depleted_operation;
 92 | 
 93 | 
 94 |     class depleted_sender {
 95 |         friend class static_thread_pool;
 96 |         depleted_sender(static_thread_pool& pool) : m_pool(pool) {}
 97 | 
 98 |         static_thread_pool& m_pool;
 99 | 
100 |     public:
101 |         template <template <typename...> class Variant, template <typename...> class Tuple>
102 |         using value_types = Variant<Tuple<>>;
103 | 
104 |         template <template <typename...> class Variant>
105 |         using error_types = Variant<>;
106 | 
107 |         static constexpr bool sends_done = true;
108 | 
109 |         template <typename sender, execution::receiver R>
110 |         using operation_type = depleted_operation<R>;
111 | 
112 | 
113 |         template <typename R>
114 |             auto connect(R&& r) && noexcept {
115 |             return depleted_operation{std::move(*this), std::forward<R>(r)};
116 |         }
117 |     };
118 | 
119 |     template <execution::receiver R>
120 |     class depleted_operation : public operation_base {
121 |         friend class depleted_sender;
122 |         depleted_operation(depleted_sender sender, R r)
123 |             : m_sender(std::move(sender)), m_receiver(std::move(r)) {}
124 | 
125 |         depleted_sender m_sender;
126 |         R m_receiver;
127 | 
128 |     protected:
129 |         void set_value() noexcept override {
130 |             m_receiver.set_value();
131 |         }
132 |         void set_done() noexcept override {
133 |             m_receiver.set_done();
134 |         }
135 |         void set_error() noexcept override {
136 |             m_receiver.set_done();
137 |         }
138 | 
139 |     public:
140 |         void start() noexcept {
141 |             m_sender.m_pool.register_depleted_sender(*this);
142 |         }
143 |     };
144 | 
145 | 
146 |     class stp_scheduler {
147 |     public:
148 |         stp_scheduler(const stp_scheduler&) = delete;
149 |         stp_scheduler(stp_scheduler&&) noexcept = default;
150 |         task_sender schedule() const noexcept {
151 |             return task_sender(m_pool);
152 |         }
153 | 
154 |     private:
155 |         friend class static_thread_pool;
156 |         stp_scheduler(static_thread_pool& pool) : m_pool(pool){};
157 | 
158 | 
159 |         static_thread_pool& m_pool;
160 |     };
161 | 
162 | public:
163 |     static_thread_pool(std::size_t n) {
164 |         for(std::size_t i = 0; i < n; ++i)
165 |             m_threads.emplace_back([this] { attach(); });
166 |     }
167 | 
168 | 
169 |     void attach() {
170 |         std::unique_lock lock(m_mutex);
171 | 
172 |         while(true) {
173 |             if(m_stopped)
174 |                 return;
175 | 
176 |             m_condition.wait(lock);
177 | 
178 |             while(m_head) {
179 |                 operation_base& op = *m_head;
180 |                 m_head = m_head->m_next;
181 |                 lock.unlock();
182 |                 op.set_value();
183 |                 lock.lock();
184 |             }
185 |             on_depleted();
186 |             continue;
187 |         }
188 |     }
189 | 
190 | 
191 |     void stop() {
192 |         std::unique_lock<std::mutex> lock(m_mutex);
193 |         m_stopped = true;
194 | 
195 |         for(auto op = m_head; op; op = op->m_next) {
196 |             lock.unlock();
197 |             op->set_done();
198 |             lock.lock();
199 |             m_condition.notify_all();
200 |         }
201 | 
202 |         for(operation_base* op = m_depleted_head; op != nullptr; op = op->m_next) {
203 |             lock.unlock();
204 |             op->set_done();
205 |             lock.lock();
206 |             m_condition.notify_all();
207 |         }
208 | 
209 |         m_head = m_tail = nullptr;
210 |         m_condition.notify_all();
211 | 
212 |         lock.unlock();
213 | 
214 |         for(auto&& t : m_threads) {
215 |             t.join();
216 |             m_condition.notify_all();
217 |         }
218 |     }
219 | 
220 |     auto scheduler() noexcept {
221 |         return stp_scheduler(*this);
222 |     }
223 | 
224 |     depleted_sender depleted() noexcept {
225 |         return depleted_sender(*this);
226 |     }
227 | 
228 | 
229 |     ~static_thread_pool() {
230 |         stop();
231 |     }
232 | 
233 | private:
234 |     void execute(static_thread_pool::operation_base& op) {
235 |         std::unique_lock<std::mutex> lock(m_mutex);
236 |         if(m_head == nullptr) {
237 |             m_head = m_tail = &op;
238 |         } else {
239 |             m_tail->m_next = &op;
240 |             m_tail = &op;
241 |         }
242 |         m_condition.notify_all();
243 |     }
244 | 
245 |     void register_depleted_sender(static_thread_pool::operation_base& op) {
246 |         std::unique_lock<std::mutex> lock(m_mutex);
247 |         if(m_depleted_head == nullptr) {
248 |             m_depleted_head = m_depleted_tail = &op;
249 |         } else {
250 |             m_depleted_tail->m_next = &op;
251 |             m_depleted_head = &op;
252 |         }
253 |         m_condition.notify_all();
254 |     }
255 | 
256 |     void on_depleted() {
257 |         m_tail = nullptr;
258 |         for(operation_base* op = m_depleted_head; op != nullptr; op = op->m_next) {
259 |             op->set_value();
260 |         }
261 |         m_depleted_head = nullptr;
262 |         m_condition.notify_all();
263 |     }
264 | 
265 | 
266 |     std::mutex m_mutex;
267 |     std::condition_variable m_condition;
268 |     std::vector<std::thread> m_threads;
269 |     operation_base* m_head = nullptr;
270 |     operation_base* m_tail = nullptr;
271 | 
272 |     operation_base* m_depleted_head = nullptr;
273 |     operation_base* m_depleted_tail = nullptr;
274 |     bool m_stopped = false;
275 | };
276 | 
277 | 
278 | }  // namespace cor3ntin::corio
279 | 


--------------------------------------------------------------------------------
/include/corio/wait.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <corio/concepts.hpp>
 3 | #include <vector>
 4 | #include <vector>
 5 | #include <thread>
 6 | #include <queue>
 7 | #include <exception>
 8 | 
 9 | namespace cor3ntin::corio {
10 | 
11 | bool wait(execution::sender auto&& send) {
12 | 
13 |     struct state {
14 |         std::mutex m;
15 |         std::condition_variable c;
16 |         bool cancelled = false;
17 |         std::exception_ptr err;
18 |     } s;
19 | 
20 |     struct r {
21 |         void set_value() {
22 |             s.c.notify_one();
23 |         }
24 | 
25 |         void set_done() {
26 |             s.cancelled = true;
27 |             s.c.notify_one();
28 |         }
29 | 
30 |         void set_error(std::exception_ptr ptr) {
31 |             s.err = ptr;
32 |         }
33 |         state& s;
34 |     };
35 |     struct r r {
36 |         s
37 |     };
38 | 
39 |     auto op = std::move(send).connect(std::move(r));
40 |     op.start();
41 | 
42 |     std::unique_lock<std::mutex> lock(s.m);
43 |     s.c.wait(lock);
44 | 
45 |     if(s.err) {
46 |         std::rethrow_exception(s.err);
47 |     }
48 |     return !s.cancelled;
49 | }
50 | 
51 | }


--------------------------------------------------------------------------------
/src/corio.cpp:
--------------------------------------------------------------------------------
 1 | #include <corio/corio.hpp>
 2 | #include <iostream>
 3 | #include <random>
 4 | 
 5 | 
 6 | template <typename scheduler>
 7 | cor3ntin::corio::oneway_task compute_pi(scheduler my_scheduler, std::vector<int>& v, int n,
 8 |                                         int slot) {
 9 | 
10 |     co_await my_scheduler.schedule();
11 | 
12 |     static thread_local auto gen = [] {
13 |         std::mt19937 e;
14 |         std::random_device rdev;
15 |         e.seed(rdev());
16 |         return e;
17 |     }();
18 |     auto dist = std::uniform_real_distribution<>{0, 1};
19 |     for(auto i = 0; i < n; i++) {
20 |         if(std::sqrt(std::pow(dist(gen), 2) + std::pow(dist(gen), 2)) < 1)
21 |             v[slot]++;
22 |     }
23 | }
24 | 
25 | double compute_pi() {
26 |     static constexpr auto jobs = 100'000;
27 |     static constexpr auto iters = 10'000;
28 |     std::vector<int> v(jobs);
29 |     static_thread_pool p(std::thread::hardware_concurrency());
30 | 
31 |     for(int i = 0; i < jobs; i++) {
32 |         compute_pi(p.scheduler(), v, iters, i);
33 |     }
34 | 
35 |     wait(p.depleted());
36 |     return 4.0 * static_cast<double>(std::accumulate(v.begin(), v.end(), 0)) /
37 |         static_cast<double>(jobs * iters);
38 | }
39 | 
40 | using namespace cor3ntin::corio;
41 | template <execution::scheduler scheduler>
42 | oneway_task ping(scheduler sch, auto r, auto w, int i) {
43 |     try {
44 |         co_await sch.schedule();
45 |         co_await sch.schedule(std::chrono::milliseconds(1000 * i));
46 |         co_await w.write(i);
47 |         std::cout << "Wrote Ping -->" << i << "\n";
48 | 
49 |     } catch(operation_cancelled c) {
50 |         std::cout << "ping cancelled\n";
51 |     } catch(channel_closed c) {
52 |         std::cout << "channel closed !?\n";
53 |     }
54 |     // channel is closed (RAII)
55 | }
56 | 
57 | template <execution::scheduler scheduler>
58 | oneway_task pong(scheduler sch, auto r, auto w, stop_source& stop, int n) {
59 |     try {
60 |         co_await sch.schedule();
61 |         co_await sch.schedule(std::chrono::milliseconds(300));
62 |         int s = co_await r.read();
63 |         std::cout << s << " ------ " << n << "\n";
64 | 
65 |     } catch(operation_cancelled c) {
66 |         std::cout << "pong cancelled\n";
67 |     } catch(channel_closed c) {
68 |         std::cout << "channel closed - shutting down\n";
69 |         stop.request_stop();  // ask the context to stop itself
70 |     }
71 | }
72 | 
73 | int main() {
74 |     stop_source stop;
75 |     io_uring_context ctx;
76 |     std::thread t([&ctx, &stop] { ctx.run(stop.get_token()); });
77 | 
78 |     auto c1 = make_channel<int>(ctx.scheduler());
79 |     auto c2 = make_channel<int>(ctx.scheduler(), 10);
80 | 
81 | 
82 |     for(int i = 0; i <= 9; i++) {
83 |         ping(ctx.scheduler(), c1.read(), c2.write(), i);
84 |     }
85 |     for(int i = 0; i <= 10; i++) {
86 |         pong(ctx.scheduler(), c2.read(), c1.write(), stop, i);
87 |     }
88 |     t.join();
89 | }


--------------------------------------------------------------------------------