In my last post I criticized the C++0x implementation of futures for their lack of composability. I now feel obliged to show what I consider “the right way” to do futures.

I use the event library of Concurrent Caml (actually, its version distributed with OCaml) as my model. The ideas behind it are described in J. H. Reppy’s Ph.D. thesis, Higher-order concurrency.

Events and Futures

CML channels and events are more general than futures, but here I’ll concentrate on the subset of their functionality that can be used to implement futures. Below is a useful translation table between CML and C++. (I should add that CML channels, as opposed to C++ futures, are synchronous. In practice it doesn’t matter that much, since promise::set_value –corresponding to channel send–is usually called right before the thread exits.)

CML C++ channel promise event future evt = receive chan ftr = prom.get_future() sync (send chan msg) (synchronous) prom.set_value(msg) (asynchronous) msg = sync evt msg = ftr.get() choose evt_lst ??? evt’ = wrap evt fun ???

As you can see, C++ has no equivalents of choose and wrap . I will discuss those next.

choose

CML choose is a function that takes a list of events and creates a new composite event. When the program sync s on this event, it blocks until one of the listed events completes. The combination sync and choose is similar to Unix select or Windows WaitForMultipleObjects .

An example of the usefulness of choose is a situation when there is more than one algorithm to calculate a result, and the program runs them in parallel until the fastest one completes. Linear search, for instance, is faster for small sets than binary search. Instead of figuring out which one to use for each particular case, it might be cheaper (on a multicore) to run both and stop when the fist one is done.

What would choose look like in C++? One possibility is to implement it as a container object. You would push individual futures into it and then call get_future to obtain a composite future. Let me call this object future_or since it does the equivalent of logical OR for futures (the equivalent of AND is called a thread barrier).

unique_future<int> ftr1 = promise1.get_future(); unique_future<int> ftr2 = promise2.get_future(); future_or<int> orf; orf.push_back(std::move(ftr1)); orf.push_back(std::move(ftr2)); unique_future<int> compositeFut = orf.get_future(); ... int result = compositeFut.get();

Another possible implementation, in C++0x, would be to define a variadic template function future_choose . It would take a variable number of futures and return the composite future. The advantage of such an approach would be to let the compiler infer the types and the number of arguments automatically.

You probably noticed that future_or can only accept futures of one type (the same would be true about the function future_choose ). For instance, to create a composite future that returns a string upon get , you must build it from other futures that also return a string (and not an int , for instance).

In principle, heterogeneous futures could be combined if they all returned different types through the same variant. Then, after a composite of variant-returning futures returns a variant, program logic would fork depending on the actual type inside the variant. This approach bypasses the static type system and is error prone. CML provides a more elegant solution using wrap .

wrap

The trick is to combine (wrap) a particular future with a function that processes its output. A future that returns an int is combined with a function that takes an int , etc. The result of this combination is a new future usually returning void .

When a wrapped future is synchronized (e.g., by calling wait ), it executes the associated function, passing it the result returned by the original future. Just look at this example:

void handler(Foo const & foo); unique_future<Foo> fooFuture = prom.get_future(); // combine the future with a handler function unique_future<void> wrappedFuture = wrap_future(fooFuture, &handler); ... wrappedFuture.wait(); // at this point fooFuture has returned a Foo object // and the handler has been executed with that object.

There’s one thing worth mentioning: the compiler will assure type correctness of the arguments to wrap_future : the return type of the future must be compatible with the argument type of the function. Mismatch errors will be discovered at compile time. Compare this with the implementation using variants, which does not have this property.

Of course the usefulness of wrap really comes into play when you try to combine heterogeneous futures using future_choose . You just wrap each future with its own post-processing function (or callable object) and pass them all to future_choose . Wrapped futures are homogeneous–they all return void.

Here’s an example that uses C++0x lambdas (one of them being a closure):

unique_future<Foo> fooFuture = prom1.get_future(); unique_future<int> intFuture = prom2.get_future(); int sum = 0; future<void> composite = future_choose( wrap_future(fooFuture, [](Foo const & foo){foo.Commit();}, wrap_future(intFuture, [&sum](int i){sum += i;}); ... composite.wait();

Wrapped futures would be useful, e.g., in implementing a server that listens to several communication channels.

What about Haskell?

As I described in my earlier post, unlike CML, Haskell implements asynchronous message passing. The original Concurrent Haskell paper argued against choose . Later however Avik Chaudhuri was able to show that the CML event library can be implemented on top of asynchronous MVar s. So there are no theoretical obstacles to asynchronous implementation of futures.

Final remarks

The equivalent of choose called future_select has been proposed for Boost and C++0x, but it was turned down.

Interestingly enough, Microsoft’s Task Parallel Library for .NET implements higher-order concurrency. They have ContinueWith for wrapping futures and WaitAny for choice. I can only assume that it’s easier to implement those on a virtual machine.

I also wonder whether it would be more productive to implement the equivalent of the CML channels and events in C++, and treat futures as a special case.

If you like this post, please vote for it on reddit.

Bibliography