I understood HPX as a library returning futures to calls to asynchronous functions, somewhat similar to std::async. In that case, the main region with all the futures would be a thread world for asynchronous. In huge applications, this does not solve the problem of organizing thousands of objects within threads. <<
Why not? You can easily (and I mean it) create asynchronous applications solely using futures for defining the necessary dependencies between tasks, running millions of tasks.
Yes, I suppose that the whole application would be a single thread world using that analogy. Objects are not 'bound' to a particular thread, they can be accessed freely from any thread and the user is responsible for protecting them - or preferably writing functional-like code to avoid
collisions etc.
HPX uses executors to fine-control where which task is executed. Every function which (potentially) creates a new task can optionally be used with an instance of an executor (async(), future::then(), etc.)
A future .then() or continuation is really just a type of callback too (broadly speaking).
Not really, if I understand correctly (http://en.cppreference.com/w/cpp/experimental/future/then). The functor object passed to then() is executed in an unspecified thread of execution, which makes it hard for the caller to (safely) pass data which might or might not be valid or relevant at the time the then functor executes.
By default in HPX the continuation is executed on the thread which has made the future ready.
I however could not find out whether this also applied to HPX. <<
In HPX there are launch policies that can be used to control thread execution, the one that would come closest to what you are looking for would be future<thing> = hpx::async(do_something_interesting()).then(hpx::launch::sync, do_another_interesting_thing());
This tells the .then() continuation to execute the next function in the same context as the thread that completes the initial future.
Does it mean a threadpool thread or the thread which started the asynchronous task?
The thread which makes the future ready. But executors can be used to control the concrete thread (see above). Regards Hartmut --------------- http://boost-spirit.com http://stellar.cct.lsu.edu