when_all hangs in finally when triggered by stop

[jessmorecroft]

This is a strange one - when_all doesn't seem to complete properly when used in finally triggered by a stop, as shown here:

    execpools::asio_thread_pool pool(1);

    boost::asio::steady_timer timer1(pool.get_executor());
    boost::asio::steady_timer timer2(pool.get_executor());
    timer1.expires_after(std::chrono::seconds(2));
    timer2.expires_after(std::chrono::seconds(1));

    auto result = sync_wait(starts_on(
        pool.get_scheduler(),
        when_any(
            timer1.async_wait(asioexec::use_sender) | then([] { return 41; }) |
                finally(sequence(
                    just() | then([] { fmt::println("before when_all"); }),
                    when_all(
                        just() | then([] { fmt::println("in finally 1"); }),
                        just() | then([] { fmt::println("in finally 2"); })),
                    just() | then([] { fmt::println("after when_all"); }))),
            timer2.async_wait(asioexec::use_sender) |
                then([] { return 42; }))));

    fmt::println("result: {}", result);

This outputs:

before when_all
in finally 1
in finally 2
(hangs)

If I change this to swap the timer durations, so our finally will be invoked as a consequence of a non-stopped completion, it completes as expected:

.....
    timer1.expires_after(std::chrono::seconds(1));
    timer2.expires_after(std::chrono::seconds(2));
.....

Output:

before when_all
in finally 1
in finally 2
after when_all
result: optional((41))

I have been trawling finally and when_all but can't figure it out. Is my usage wrong in some way perhaps..?

[ericniebler]

interesting. i can confirm the hang with the asio thread pool. i ported the code to use the io_uring_context and found that the problem went away.

    exec::io_uring_context pool;
    auto sch = pool.get_scheduler();

    auto result = ex::sync_wait(
      ex::starts_on(
        pool.get_scheduler(),
        exec::when_any(
          exec::schedule_after(sch, std::chrono::seconds(2)) //
            | ex::then([] { return 41; })
            | exec::finally(
              exec::sequence(
                ex::just() | ex::then([] { std::puts("before when_all"); }),
                ex::when_all(
                  ex::just() | ex::then([] { std::puts("in finally 1"); }),
                  ex::just() | ex::then([] { std::puts("in finally 2"); })),
                ex::just() | ex::then([] { std::puts("after when_all"); }))),
          exec::schedule_after(sch, std::chrono::seconds(1)) //
            | ex::then([] { return 42; }))));

    if (!result.has_value()) {
      std::puts("cancelled");
    } else {
      std::printf("result: %d\n", std::get<0>(*result));
    }

that makes me think the problem is either in asio_thread_pool or in @RobertLeahy's use_sender ASIO/stdexec integration.