when_all() appears to ignore the passed-in executor

[TheMartin]

The documentation page on when_all has this to say:

This function create a joining future. When all passed args futures are fulfilled, then the continuation tasks defined with f is scheduled on the executor e.

It even describes the parameter e as "Executor which is used to schedule the resulting task".

That would lead me to believe that the following test cases should pass:

BOOST_FIXTURE_TEST_SUITE(future_when_all_scheduling, test_fixture<void>)
BOOST_AUTO_TEST_CASE(future_when_all_args)
{
  auto f1 = make_ready_future(custom_scheduler<0>());
  auto f2 = make_ready_future(custom_scheduler<0>());
  sut = when_all(custom_scheduler<1>(), []{}, f1, f2);

  wait_until_future_completed(sut);

  BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
}

BOOST_AUTO_TEST_CASE(future_when_all_range)
{
  future<void> fs[] = { make_ready_future(custom_scheduler<0>()), make_ready_future(custom_scheduler<0>()) };
  sut = when_all(custom_scheduler<1>(), []{}, std::pair{ std::begin(fs), std::end(fs) });

  wait_until_future_completed(sut);

  BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
}
BOOST_AUTO_TEST_SUITE_END()

However, in both cases, custom_scheduler<1>::usage_counter() is 0. The continuation appears to always run immediately as part of the last future becoming ready; it isn't even scheduled on custom_scheduler<0>. To me, this is surprising behavior.

[FelixPetriconi]

Thanks for spotting this. We have the same problem on all when_any. If am currently fixing it.

[FelixPetriconi]

Fixed in 1.3.1

[FelixPetriconi]

Could you please provide an example? The following tests pass successfully: BOOST_AUTO_TEST_CASE(future_when_all_args_int_with_ready_element) { BOOST_TEST_MESSAGE("running future when_all int with ready element"); sut = when_all(custom_scheduler<1>(), [](auto x) { return x + x; }, make_ready_future<int>(42, custom_scheduler<0>())); check_valid_future(sut); wait_until_future_completed(sut); BOOST_REQUIRE_EQUAL(42 + 42, *sut.get_try()); BOOST_REQUIRE_LE(1, custom_scheduler<0>::usage_counter()); BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter()); } BOOST_AUTO_TEST_CASE(future_when_all_args_int_with_two_ready_element) { BOOST_TEST_MESSAGE("running future when_all int with two ready elements"); sut = when_all(custom_scheduler<1>(), [](auto x, auto y) { return x + y; }, make_ready_future<int>(42, custom_scheduler<0>()), make_ready_future<int>(42, custom_scheduler<0>())); check_valid_future(sut); wait_until_future_completed(sut); BOOST_REQUIRE_EQUAL(42 + 42, *sut.get_try()); BOOST_REQUIRE_LE(2, custom_scheduler<0>::usage_counter()); BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter()); }

…

On 23 July 2018 at 13:14 JurajBlaho ***@***.***> wrote: > > > It seems that the executor is still ignored if the futures are ready before the when_all is called. > > -- > You are receiving this because you modified the open/close state. > Reply to this email directly or view it on GitHub: > #169 (comment)

[JurajBlaho]

Could you please provide an example?

I'll need to dig in further and try to find a simple repro. We have a cascade of when_all and it happens in our production code that the task is run immediately and not on the specified executor. I'll write here if I find anything.

[JurajBlaho]

I have found out a small repro. The problem is that the test passes, but it does not work as expected. When I put a breakpoint into the function foo that is supposed to run on the custom_scheduler<1>, Visual Studio call stack indicates that it runs immediately on the main thread:

int foo()
{
  return 42;
}

BOOST_FIXTURE_TEST_SUITE(future_when_all_scheduling, test_fixture<void>)
BOOST_AUTO_TEST_CASE(future_when_all_args)
{
  auto f1 = make_ready_future(stlab::immediate_executor);
  //auto f1 = make_ready_future(custom_scheduler<0>()); // This does something else

  sut = when_all(
    custom_scheduler<1>(),
    []() { return foo(); },
    std::move(f1)).then(stlab::immediate_executor, [] (int){});

  wait_until_future_completed(sut);

  BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());
}

BOOST_AUTO_TEST_SUITE_END()

So it seems that the executor from the ready future is used instead of the one passed into the when_all. Plus there is maybe a bug in the testing framework as it actually reports expected results.

A bit more debugging shows that the foo function is run first (on the main thread) and then an empty task is passed into the custom_scheduler<1>. Maybe custom_scheduler should check that it is given a proper task and only in that case increment the counter.

[FelixPetriconi]

Now I can reproduce it. I was even able to reduce the failing example to:
`
BOOST_AUTO_TEST_CASE(future_when_all_args)
{
auto sut = when_all(custom_scheduler<1>(),
[]{ return 42; },
make_ready_future(stlab::immediate_executor));

	wait_until_future_completed(sut);

	BOOST_REQUIRE_LE(1, custom_scheduler<1>::usage_counter());

}
`
I will try to solve the problem as soon as I can.

[FelixPetriconi]

Fixed in 1.3.2