Modern C++ binding for liburing that uses C++20 Coroutines ( but still compiles for clang at C++17 mode with -fcoroutines-ts )

Originally named liburing-http-demo ( this project was originally started for demo )

Requires the latest kernel ( currently 5.8 ). Since io_uring is in active development, we will drop old kernel support when every new linux kernel version is released ( before the next LTS version is released, maybe ).

Tested: Ubuntu 5.9.0-050900rc6daily20200923-generic #202009222208 SMP Wed Sep 23 02:24:13 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux with clang version 10.0.0-4ubuntu1

#include "io_service.hpp"

int main() {
    // You first need an io_service instance
    io_service service;

    // In order to `co_await`, you must be in a coroutine.
    // We use IIFE here for simplification
    auto work = [&] () -> task<> {
        // Use Linux syscalls just as what you did before (except a little changes)
        const auto str = "Hello world\n"sv;
        co_await service.write(STDOUT_FILENO, str.data(), str.size(), 0);
    }();

    // At last, you need a loop to dispatch finished IO events
    // It's usually called Event Loop (https://en.wikipedia.org/wiki/Event_loop)
    service.run(work);
}

• Ubuntu 20.04.1 LTS
• Linux Ubuntu 5.9.0-050900rc6daily20200923-generic #202009222208 SMP Wed Sep 23 02:24:13 UTC 2020 x86_64 x86_64 x86_64 GNU/Linux
• Intel(R) Xeon(R) CPU E5-2620 v4 @ 2.10GHz
• Compiler: clang version 10.0.0-4ubuntu1

service.yield:        6527085832
plain IORING_OP_NOP:  5884262348
this_thread::yield:   4486533904
pause:                  41502717

• demo/echo_server 12345 ( C++, uses coroutines )
• ./io_uring_echo_server 12345 ( C, raw )

with rust_echo_bench: https://github.com/haraldh/rust_echo_bench unit: request/sec

Also see benchmarks for different opcodes

An awaitable class for C++2a coroutine functions. Originally modified from gor_task.h

NOTE: task is not lazily executed, which is easy to use of course, but also can be easily misused. The simplest code to crash your memory is:

{
    char c;
    service.read(STDIN_FILENO, &c, sizeof (c), 0);
}

The task instance returned by service.read is destructed, but the kernel task itself is NOT canceled. The memory of variable c will be written sometime. In this case, out-of-scope stack memory access will happen.

An awaitable class. It's different from task that it can't used for return type, but can be created directly without calling an async function.

Its design is highly inspired by Promise of JavaScript

Provide helper functions that working with an array of tasks

Main liburing binding. Also provides some helper functions for working with posix interfaces easier.

Some examples

A simple http file server that returns file's content requested by clients

A cp command inspired by original liburing link-cp demo

A simple http client that sends GET http request

A simple async_invoke implementation

Various simple tests

Benchmarks

Echo server, features IOSQE_IO_LINK and IOSQE_FIXED_FILE

See also https://github.com/frevib/io_uring-echo-server#benchmarks for benchmarking

This library is header only. It provides some demos for testing

1. Build liburing and install, the latest version required
2. sudo apt install clang libc++-dev libc++abi-dev. Make sure clang version >= 9
3. git clone --recurse-submodules https://github.com/CarterLi/liburing4cpp.git
4. cd liburing4cpp/demo && make

Note: When benchmarking, you may want to build it with optimization: make MODE=RELEASE.

MIT