thread wainting for task to end should not run another task

[MatthieuTexier]

Hello, thank you for the nice lib.

I will try to describe my problem.
The default scheduler runs several tasks, says A and B
Task A creates a temporary scheduler and wait on it's internal tasks with when_all(A_tasks).wait()
The waiting thread runs task B and this leads to a mess as B cannot be called from A.
A thread waiting for a task to end should not run another task.

[zerodefect]

Can you elaborate on this some more? I'm wondering if I've seen the same thing. Do you have any example code?

[Amanieu]

The behavior of wait is controlled by the wait handler set by set_thread_wait_handler. Since A is running in the default scheduler thread pool it will use the handler set up by the thread pool and try to run other pending tasks from the default scheduler while waiting.

[MatthieuTexier]

Thanks Amanieu, I will try to set the thread_wait_handler.

[kikaxa]

Also, you really should use continuations (.then) if you use async patterns.
@MatthieuTexier do you need this task open any more?

[MatthieuTexier]

Hi @kikaxa , yes I do.

[redrabbit007]

I may be seeing something similar. In my setup I start a few tasks, which each use a parallel for, then I use a condition variable to process the results in sequential order. It acts like if the library tries to use too many threads then the early ones get killed off.

#include <async++.h>
#include <atomic>
#include <condition_variable>
#include <iostream>
#include <mutex>

std::atomic<uint32_t> nextTaskToProcess = 0;
std::mutex mutex;
std::condition_variable cv;

void RunTask(uint32_t taskNumber)
{
  async::task task = async::spawn([&, taskNumber]
  {
    std::cout << taskNumber << " r" << std::endl;
    // Do some work which involves a parellel for.
    async::parallel_for(async::irange(0, 5), [](int x)
    {
      std::this_thread::sleep_for(std::chrono::milliseconds(x * 100));
    });
    
    // Sequentially process the results
    {
      std::unique_lock<std::mutex> lock(mutex);
      std::cout << taskNumber << " w " << nextTaskToProcess << std::endl;
      cv.wait(lock, [&, taskNumber] { return taskNumber == nextTaskToProcess; });
      std::cout << taskNumber << " p" << std::endl;
      
      nextTaskToProcess++;
    }
    cv.notify_all();
  });
}

int main(int count, char **args)
{
  // Run a few tasks.
  for (int i = 0; i < 6; i++)
  {
    RunTask(i);
  }

  std::this_thread::sleep_for(std::chrono::seconds(5));
  
  return 1;
}

The output varies as you would expect, but here is an example:

./bin/asyncbug 
0 r
1 r
2 r
3 r
4 r
5 r
3 w 0
2 w 0
1 w 0
5 w 0

Task 0 somehow gets lost, and even my main function doesn't end after 5 seconds like it should.