I need your help in switching cpu-bound and io-bound tasks

[artemsazonov86]

I read your documentation, but there are not enough examples, I would like to use your library to get something like this, as in the concurencpp library:

#include <cstring>
#include <fstream>
#include <iostream>
#include <vector>

#include "concurrencpp/concurrencpp.h"

concurrencpp::result<void> replace_chars_in_file(std::shared_ptr<concurrencpp::thread_pool_executor> background_executor,
                                                 std::shared_ptr<concurrencpp::thread_pool_executor> threadpool_executor,
                                                 const std::string file_path,
                                                 char from,
                                                 char to) {
    // switch control from whatever executor/thread this coroutine was called from to the background_executor.
    co_await concurrencpp::resume_on(background_executor);

    // we're running on the background executor now. we can safely block.
    std::vector<char> file_content;

    {
        std::ifstream input;
        input.exceptions(std::ifstream::badbit);
        input.open(file_path, std::ios::binary);
        file_content.assign(std::istreambuf_iterator<char>(input), {});
    }

    // switch execution to the threadpool-executor
    co_await concurrencpp::resume_on(threadpool_executor);

    // we're running on the threadpool executor now. we can process CPU-bound tasks now.
    for (auto& c : file_content) {
        if (c == from) {
            c = to;
        }
    }

    // switch execution back to the background-executor
    concurrencpp::resume_on(background_executor);

    // write the processed file content. since we're running on the background executor, it's safe to block.
    std::ofstream output;
    output.exceptions(std::ofstream::badbit);
    output.open(file_path, std::ios::binary);
    output.write(file_content.data(), file_content.size());

    std::cout << "file has been modified successfully" << std::endl;
}

Could you please give an example of similar code for your library?

[ConorWilliams]

Sure

inline constexpr auto replace_chars_in_file =
    [](auto self, auto *io_ctx, std::string file_path, char from, char to) -> lf::task<> {
  
  // Assuming this is running on a [lazy|busy] _pool
  auto cpu_ctx = self.context();

  {
    co_await lf::resume_on(io_ctx);
    std::ifstream input;
    input.exceptions(std::ifstream::badbit);
    input.open(file_path, std::ios::binary);
    file_content.assign(std::istreambuf_iterator<char>(input), {});
    co_await lf::resume_on(cpu_ctx);
  }

  for (auto &c : file_content) {
    if (c == from) {
      c = to;
    }
  }

  {
    co_await lf::resume_on(io_ctx);
    std::ofstream output;
    output.exceptions(std::ofstream::badbit);
    output.open(file_path, std::ios::binary);
    output.write(file_content.data(), file_content.size());
    std::cout << "file has been modified successfully" << std::endl;
    co_await lf::resume_on(cpu_ctx);
  }
};

I have neglected includes...

[ConorWilliams]

After I've finised V4 I hope to put together a proper examples for explicit scheduling between pools, alongside a global cpu/io contexts (hopefully with the latter backed by io_uring)

[artemsazonov86]

Thank you very much. And I have one more question, you use lambdas everywhere, but isn't there a classic way to declare coroutines as functions in your library, like it's done in concurencpp or cppcoro ?
I would also be very happy if you could create some defines that could disable the use of TLS in the library, this could help me use the library on some platforms (or microcontrollers) where there is no thread_local, as well as in other situations where I can't use thread_local.

[ConorWilliams]

Thank you very much. And I have one more question, you use lambdas everywhere, but isn't there a classic way to declare coroutines as functions in your library, like it's done in concurencpp or cppcoro ?

Not currently but, this is in the pipeline for V4

I would also be very happy if you could create some defines that could disable the use of TLS in the library, this could help me use the library on some platforms (or microcontrollers) where there is no thread_local, as well as in other situations where I can't use thread_local.

This is not possible, on a system whithout threads why would you use libfork?

[artemsazonov86]

We didn't understand each other, I don't mean a system without threads, but a system or hardware where there is no thread local storage (TLS), any variable declared with the thread_local or thread or __declspec(thread) modifier will be placed in the memory area allocated separately for each thread (different mechanisms on different systems), but some systems and hardware, in particular microcontrollers do not have thread local memory, also sometimes there are cases when we cannot use thread local memory, even on those systems where such an opportunity exists.

[ConorWilliams]

Libfork uses TLS to store a pointer to the executor context, moving this into the coroutine frame might be possible but it would cost stack space, I'd have to benchmark to see if this is pheasable

[artemsazonov86]

Thank you for spending time on this. Concurencpp has a TLS-free coroutine implementation, but there are also details that I had to change, for example, cutting try-catch blocks in the library core, because in some situations I can't afford to use exceptions. In general, I have to make crutches. Your library, especially with the announcement of v4, looks very promising to become the number one candidate in the world of coroutines among a very wide range of people. This is really useful. Giants like Boost have defines for disabling TLS, exceptions and other nasty things that are not quite cross-platform, while at the same time they retain the ability to enable them.

[ConorWilliams]

Cheers, linking #18 to remind me about TLS

[artemsazonov86]

In other libraries like concurencpp or cppcoro the coroutine context seems to be stored on the heap, as stated in the official documentation on cppreference.com, if that's what you were talking about regarding TLS. Or maybe I'm confused and you mean just storing the thread pool on which the tasks are run, then that's not a problem, I've seen other libraries pass them via shared_ptr in the coroutine parameters, like in the example at the very beginning of this issue

[ConorWilliams]

The promise's operator new needs to access the libfork-stack of the running thread's context. It does this through the thread_local context ptr. The only other way I could see this being done is passing via an argument which would need to be stored both in the promise (to forward to children) and in the argument list (as a value). This would result in 16 extra bytes per-frame of overhead.

[artemsazonov86]

Yes, there will likely be overhead, but it's a fair price to pay for the ability to move away from TLS. At best, it would be nice to be able to disable TLS usage via some define like #define LIBFORK_DONT_USE_TLS for use in certain cases and live with some overhead, and also use everything as before without declaring this define, bypassing some of the overhead.

[artemsazonov86]

In any case, your library is already very good, and I will use it where I can use TLS, even if you don't add a non-TLS version. Thank you.