Minimal example for spawning NUM_CPU threads and running an app instance on each?

[GavinRay97]

Hiya, I'm curious what the rough approach would be for doing something like this:

• Spawning an instance of the same Application-like class, one per physical CPU core
• The application class runs for the duration of the lifecycle, pinned to the CPU
• It uses coroutines for userspace-level concurrency

I think the rough outline for something like this would be:

struct MyApplication
{
    void run()
    {
        while (true) std::this_thread::yield();
    }
}


int main()
{
    auto num_cpus = std::thread::hardware_concurrency();
    exec::static_thread_pool pool(num_cpus);

    auto sched = pool.get_scheduler();

    std::vector<std::jthread> threads;
    for (auto i = 0; i < num_cpus; ++i)
    {
        threads.emplace_back([sched]()
        {
            auto exec = std::execution::require(sched, std::execution::never_blocking);
            MyApplication app;
            std::execution::execute(exec, &app, &MyApplication::run);
        });
    }

    for (auto& t : threads)
    {
        t.join();
    }
}

Thank you =)

[npuichigo]

Something like this?

int main()
{
  auto num_cpus = std::thread::hardware_concurrency();
  exec::static_thread_pool pool(num_cpus);

  auto make_snd = [&]() {
    return ex::schedule(pool.get_scheduler()) 
         | ex::then([]{
             MyApplication app;
             app.run();
           });
  }
  auto snd = ex::when_all(
    make_snd(),
    make_snd(),
    make_snd()
  )
  stdexec::sync_wait(std::move(snd));
}

[GavinRay97]

Oh awesome, that seems easy enough, thanks!

The sync_wait at the end would never finish if the application logic had an event-loop-like implementation in it, I assume?

[npuichigo]

yes, it would wait for the inner sender to finish.