research: async support for cpp binding

[silver-ymz]

In cpp side, I come up with following ways:

• std: C++11 provides std::async and std::future, C++20 provides coroutine. We can expose API compatible with the standard library. Cons: Maybe we need to limit cpp version to at least c++20.
• asio: We have used Boost as a dependency. So we can integrate asio runtime to expose our async API. This is the most common way and does not require importing more dependencies.
• Other async library: There is other popular async library, e.x. libevent, libuv.
• Custom async runtime: We can expose a small async runtime similar to tokio, like hyper C API. This provides maximum flexibility and performance.

Solutions of some popular cloud sdk:

• Gcp use std, but havn't completed until now.
• AWS and Azure use custom async runtime.

I prefer to use std, because it provides more flexibility than asio。And compared with custom runtime, std is easier to use and less expensive to learn.

I plan to make async operations as an option and default to on. If users can't accept high version, they can just use c++11 with our sync API.

---

About rust side, cxx's native async support is still on the way. It plans to support std. Currently, it recommends to use synchronous channel to expose async operation.

[Xuanwo]

Questsions:

• Is it simple to switch the async runtime on the opendal-cpp side?
• Can we integrate different runtimes simultaneously?

---

Thoughts:

Initially, I believe adding support for asio to make our async functionality usable would be a good idea. However, I'm uncertain as my knowledge of cpp is limited.

---

Helps:

@jiaoew1991 is a potential user of our async C++ binding. Would you be interested in providing us with some feedback on the support for async C++?

[jiaoew1991]

Hi @silver-ymz, this issue is a capability that we currently need. I think there are several points to consider:

1. The implementation of runtime and thread pool needs customization capabilities. In our scenario, we have requirements for adjusting concurrency and thread priority.

2. At the same time, we use folly's thread pool. The cxx binding provides an abstraction for the runtime, so we can implement it internally based on folly's thread pool.

3. As a library, the C++ version should not be set too high since there may not be many users using C++20 😅

[kassane]

asio: We have used Boost as a dependency. So we can integrate asio runtime to expose our async API. This is the most common way and does not require importing more dependencies.

There are two alternatives to asio (boost or standalone). Standalone has C++20 stackless coroutine support and boost:: add stackfull coroutines (need boost::context).

Reference: https://think-async.com/Asio/AsioAndBoostAsio.html