Improvements to dash::Future

[devreal]

This PR extends dash::Future to allow for a meaningful test() function and proper tear-down. The latter is required to avoid memory leaks if dash::copy_async uses handles and the user does not wait() on it.

Fixes #416
See also #447

[fmoessbauer]

Your changes look good so far, however I have some concerns regarding the performance of multiple relatively small async copy calls. Are there already benchmark results comparing before and after? If not, we could easily use the DASH implementation of Cafbench therefor.

[devreal]

Are there already benchmark results comparing before and after? If not, we could easily use the DASH implementation of Cafbench therefor.

I don't think we have a proper benchmark for it but it would be easy to create one. I might give it a try next week.

However, I don't immediately see how we could improve performance without sacrificing features. The current implementation of dash::Future is very basic and fails a simple use-case like while (fut.test()) do_something_else();, not to mention the potential for memory leaks.

I am open to ideas on how to save the dynamic allocation of the std::vector holding the handles (which probably is the critical addition in this PR).

[fuchsto]

Did not have a look at the implementation yet but the PR is a good catch.
More important than benchmarks for now: It's a new feature -> add unit tests!

[devreal]

@fuchsto Good point. Did that, made me change the implementation even more:

1. Made dash::Future non-copyable, similar to std::future. We might want to add dash::SharedFuture at some point but that's a different story.
2. Consolidated dash::internal::copy_impl and dash::internal::copy_async_impl into a single implementation to i) reduce duplicated code and ii) overlap the transfer to/from multiple remote units. There is still a metric ton of duplicated code in Copy.h but I didn't bother touching that as I expect it to change with [WIP] Fixing and improving algorithms with view expressions #410 anyway.
3. Added dart_testall and dart_test, which upon success also ensure remote completion if required.
4. All copy implementations now use handles: dash::copy waits for their (remote) completion while dash::copy_async puts them into a future.
5. Handling of large transfers is now left to DART (see Chunk up puts/gets to cover large transfers #434), slightly simplifying the code in copy_impl.

[fmoessbauer]

This PR looks good and IMO we can merge it. As the implementation of copy will change anyways I have no problem with using handles there. In the future we can improve that by providing optimized copy for tiny transfers.

The changes related to dash::Future are really good ones.