Les futures

Une future est un objet représentant un éventuel résultat. Bien utilisée, une future peut accroître le parallélisme d'un programme.

En C++ – std::future<T> et std::async()

Depuis C++ 11, il est possible d'utiliser des futures en C++. Un exemple simple simple comparant un calcul synchrone et un calcul équivalent mais réalisé de manière asynchrone, à l'aide de futures, suit.

#include <future>
#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;

int f(int n) {
   this_thread::sleep_for(1s);
   return n + 1;
}
int g(int n) {
   this_thread::sleep_for(2s);
   return n + 2;
}

int calcul_synchrone(int n) {
   return f(n) + g(n);
}
int calcul_asynchrone(int n) {
   auto f_ = async(f, n);
   auto g_ = async(g, n);
   return f_.get() + g_.get();
}

template<class F, class ... Args>
   auto test(F f, Args && ... args) {
      auto pre = high_resolution_clock::now();
      auto res = f(std::forward<Args>(args)...);
      auto post = high_resolution_clock::now();
      return pair{ res, post - pre };
   }

int main() {
   auto [r0,dt0] = test(calcul_synchrone, 1);
   cout << "Calcul synchrone, resultat : " << r0 << " obtenu en "
        << duration_cast<milliseconds>(dt0).count() << " ms.\n";
   auto [r1,dt1] = test(calcul_asynchrone, 1);
   cout << "Calcul asynchrone, resultat : " << r1 << " obtenu en "
        << duration_cast<milliseconds>(dt1).count() << " ms." << endl;
}

Une exécution possible serait :

Calcul synchrone, resultat : 5 obtenu en 3000 ms.
Calcul asynchrone, resultat : 5 obtenu en 2003 ms.

En C# – les expressions async et await

Les futures avec C# sont implémentées à partir de fonctions dites « résumables », à l'aide des mots clés async et await. Pour en savoir plus, voir ../Divers--cdiese/async_await.html

Lectures complémentaires

Un Wiki sur le sujet : http://en.wikipedia.org/wiki/Futures_and_promises

La position de Marius A. Eriksen en 2013 : http://aboutwhichmorelater.tumblr.com/post/46862769549/futures-arent-ersatz-threads

Les futures et les promesses avec iOS (mais au fond, ce texte ratisse beaucoup plus large et ne se limite pas à une plateforme particulière), texte de Drew Crawford en 2013 : http://sealedabstract.com/code/broken-promises/

En 2016, Raymond Chen montre comment il est possible de transformer une boucle en un enchaînement de tâches : https://blogs.msdn.microsoft.com/oldnewthing/20160226-00/?p=93092

Avec C# :

• Interaction entre futures et exceptions éventuelles en C#, par Craig Gidney en 2013 : http://twistedoakstudios.com/blog/Post3858_eventual-exceptions-vs-programming-in-a-minimal-functional-style
• Texte de Craig Gidney en 2013 sur la difficulté de représenter le rôle des futures dans l'exécution d'un programme : http://twistedoakstudios.com/blog/Post4008_collapsing-futures-easy-to-use-hard-to-represent

Avec C++ :

• Texte de Herb Sutter en 2009, montrant ce que les futures permettent de faire mieux que ce que ne permettaient de faire les API plus traditionnelles : http://www.drdobbs.com/go-parallel/article/showArticle.jhtml?articleID=222301165
• Politiques de lancement de tâches asynchrones :
  • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3188.htm
• Gestion des Timeouts : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3191.htm
• Textes et présentations de Bartosz Milewski :
  • critique des limites des std::async, en 2011 : http://blog.corensic.com/2011/10/10/async-tasks-in-c11-not-quite-there-yet/
  • futures, promesses et async : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartFour.aspx
  • description critique du modèle discuté pour C++ 11 : http://bartoszmilewski.com/2009/03/03/broken-promises-c0x-futures/
  • sur les problèmes associés à la composition des futures de C++, résultant du fait que cette API soit en partie bloquante, texte de 2009 : http://bartoszmilewski.com/2009/03/10/futures-done-right/
  • en 2014, Bartosz Milewski explique qu'enfin, avec C++ 17, les futures (corrigées) seront correctes : http://bartoszmilewski.com/2014/02/26/c17-i-see-a-monad-in-your-future/
• Appliquer correctement le Perfect Forwarding au lancement d'une std::async(), textes d'Alexander Kondratskiy en 2012 :
  • http://kholdstare.github.com/technical/2012/12/18/perfect-forwarding-to-async-1.html
  • http://kholdstare.github.com/technical/2012/12/19/perfect-forwarding-to-async-2.html
• Survol des « performances » à l'exécution avec ce mécanisme, en 2013 : http://code4thought.wordpress.com/2013/03/03/cpp-async/
• Implémentation alternative, les Folly Futures :
  • https://github.com/facebook/folly/tree/master/folly/futures
  • chez Facebook, décrites par Hans Fugal en 2015 :
  • chez Instagram, décrites par Zhenghao Qian et Gautam Sewani en 2015 : http://instagram-engineering.tumblr.com/post/121930298932/c-futures-at-instagram
• Programmer à l'aide de futures dans un contexte de High Performance Computing (HPC), selon Hartmut Kaiser en 2015 : http://stellar-group.org/2015/07/hpx-and-cpp-futures/
• La variante MozPromise, expliquée par Bobby Holley en 2015 : http://bholley.net/blog/2015/mozpromise.html
• Explication des futures et des promesses, proposée par Rainer Grimm en 2016 : http://www.modernescpp.com/index.php/promise-and-future
• En 2016, Ivan Čukić explique un tour de passe-passe très vilain dans l'implémentation sous-jacente à QFuture, implémentation des futures propre à Qt : http://cukic.co/2016/01/21/the-most-evil-hack/
• Texte de 2016 par Eli Bendersky, qui met en relief ce que promettent les futures de C++... et les défis qui s'annoncent (ce texte est une forme de critique, tout à fait valide) : http://eli.thegreenplace.net/2016/the-promises-and-challenges-of-stdasync-task-based-parallelism-in-c11/
• Les packaged_task, expliquées par Rainer Grimm en 2016 : http://www.modernescpp.com/index.php/asynchronous-callable-wrappers
• Texte de 2014 par Bartlomiej Filipek, qui explique les bases des futures et de leur raison d'être : http://www.bfilipek.com/2014/01/tasks-with-stdfuture-and-stdasync.html
• Utiliser une std::promise et une std::future pour enrober des fonctions de rappel, approche décrite par Anthony Williams en 2017 : https://www.justsoftwaresolutions.co.uk/threading/wrapping-callbacks-with-futures.html

// ...
{
   std::async(std::launch::async, []{ f(); });
   std::async(std::launch::async, []{ g(); });
} // ici, la 2e ligne ne s'exécute pas tant que f() n'a pas complété

Avec Go :

• Les futures avec Go : http://thegozette.com/articles/2011/05/11/futures-revisited/

Avec Java :

• Les futures avec Java : http://www.carfey.com/blog/java-concurrency-part-4-callable-future/
• Des futures avec la bibliothèque Guava, par Bill Bejeck en 2011 : http://codingjunkie.net/google-guava-futures/
• Des futures pour Java 8, par Doug Lea en 2012 : http://cs.oswego.edu/pipermail/concurrency-interest/2012-December/010423.html

Avec JavaScript :

• Les futures en JavaScript, par Curtis Bartley en 2009 : http://curtisb.posthaven.com/what-are-futures-and-why-shoul