Case Study: C++ Thread-Safety Concurrency

[kassane]

Getting briefly talked about in the last PR.

The plan is to begin to investigate a case for implementing a solution for concurrency that is compatible with the API of the tb_client library.

Note: The latest commit, C++ version has been downgraded to 14. It is not necessary to have the latest version for a proposal.
However, nothing prohibits a better implementation!

#2 (comment)

I think C++ could follow the same strategy we have with Java/C# clients, exposing both async and blocking APIs.
An idiomatic C++ API could provide an async API by exposing a high-level callback/lambda, or even explore modern C++ async (is that a use case for promises?).

cc: @batiati @kprotty

Reference

• Writing High-Performance Clients for Tigerbeetle

[kassane]

Why std::async isn't async?

std::async returns a std::future object.

std::future::~future

these actions will not block for the shared state to become ready, except that it may block if all of the following are true: the shared state was created by a call to std::async, the shared state is not yet ready, and this was the last reference to the shared state.

Ref:

• https://en.cppreference.com/w/cpp/thread/future/~future
• https://eel.is/c++draft/futures.async#4.1
• https://eel.is/c++draft/futures.state#3 (thread lockable)

[kassane]

Refactor: breaking API change for all clients

• [C Client] tb_client refactor tigerbeetle/tigerbeetle#793

[zetanumbers]

Why std::async isn't async?

For async see this:
https://en.cppreference.com/w/cpp/language/coroutines

[kassane]

For async see this: https://en.cppreference.com/w/cpp/language/coroutines

C++20 <coroutine>! I believe it is complicated, depending on the llvm-libcxx support (thinking zig c++).
https://libcxx.llvm.org/Status/Cxx20.html
https://libcxx.llvm.org/Status/Cxx23.html <= include <ranges>/std::generator (llvm support: 16 or 17??)

another reference c++20 coroutine:

• https://eel.is/c++draft/dcl.fct.def.coroutine
• https://eel.is/c++draft/coroutine.generator.overview (range generator)
• https://lewissbaker.github.io/2018/09/05/understanding-the-promise-type

Maybe, alternative:

• https://think-async.com/Asio/asio-1.28.0/doc/asio/overview/core/threads.html (general)
• https://think-async.com/Asio/asio-1.28.0/doc/asio/overview/core/strands.html (no-blocking)
• https://think-async.com/Asio/asio-1.28.0/doc/asio/overview/composition/cpp20_coroutines.html

[kassane]

Initial in the last commit, the use of mutex lock_guard (RAII) was inserted to match the time in sending requests. (Sync)

As for the asynchronous method, it will need to be better evaluated to avoid possible cases of unnecessary complexity for a sample project.

Even based on my last asynchronous test (asio::coroutine [stackless]) demonstrated a high cost in memory allocations.
kprotty/zap#8

Another references:

• Async is not the holy grail fubark/cyber#27 (comment)
• A Universal I/O Abstraction for C++