Considérations de parallélisme et de concurrence

Lectures complémentaires

Comment Leslie Lamport percevait les problèmes fondamentaux de la programmation concurrente, en 1983 (même si le texte a été publié en 1984) : http://research.microsoft.com/en-us/um/people/lamport/pubs/solved-and-unsolved.pdf

Je ne suis pas très porté sur les vidéos, faute de temps, mais http://www.infoq.com/presentations/Thinking-Parallel-Programming par Guy Steele est vraiment intéressant. De même, cette conversation entre Bjarne Stroustrup, Carl Hewitt et David Ungar est fort instructive : http://channel9.msdn.com/Blogs/Charles/A-Conversation-with-Bjarne-Stroustrup-Carl-Hewitt-and-Dave-Ungar

Discussions d'idées générales sur l'immuabilité :

• Isolation, immuabilité, synchronisation. Dans cet ordre : http://www.bluebytesoftware.com/blog/PermaLink,guid,7a57f623-d65d-4212-973d-29bdcf61dd3a.aspx
• Vive les entités immuables, selon Mike en 2011 : http://blog.fogus.me/2011/07/12/no-stinking-mutants/
• Présentation intéressante de Kevlin Henney en 2014 sur les vertus de l'immuabilité : http://accu.org/content/conf2014/ImmutabilityFTW!.pdf

Discussions d'idées générales sur le parallélisme :

• La vogue du parallélisme, un retour de vieilles idées? http://cacm.acm.org/magazines/2010/6/92479-the-resurgence-of-parallelism/fulltext
• Si vous ne pouvez pas le rendre rapide, rendez-le parallèle : http://blog.cyll.org/post/880597454/if-you-cant-make-it-fast-make-it-parallel
• Les périls du passage au parallélisme, selon Steve Apiki en 2009 : http://drdobbs.com/high-performance-computing/214500497
• Développer des bibliothèques de parallélisme à haute performance : http://www.drdobbs.com/go-parallel/article/showArticle.jhtml;jsessionid=MUIULNTFUDRZZQE1GHPSKH4ATMY32JVN?articleID=227501006
• Paralléliser la multiplication de matrices, texte intéressant d'Alex Voicu en 2014 : http://blogs.msdn.com/b/nativeconcurrency/archive/2014/09/04/raking-through-the-parallelism-tool-shed-the-curious-case-of-matrix-matrix-multiplication.aspx
• Considérations de design pour fins de programmation en parallèle, par David Callahan en 2008 : http://msdn.microsoft.com/en-us/magazine/cc872852.aspx
• Amélioration des « performances » par voie de parallélisme :
  • article du Code Project : http://www.codeproject.com/KB/threads/Superlinear.aspx
  • exemple d'Aater Suleman, en 2011 : http://www.futurechips.org/tips-for-power-coders/writing-optimizing-parallel-programs-complete.html
• L'impact systémique d'un thread consommant trop de ressources, par Raymond Chen en 2005 : http://blogs.msdn.com/b/oldnewthing/archive/2005/12/01/498882.aspx
• Quelques questions et quelques réponses sur la programmation parallèle, entrevue de 2009 avec James Reinders : http://drdobbs.com/high-performance-computing/214500435
• Le parallélisme est important, mais la complexité algorithmique l'est souvent plus. Un exemple en Scala, par Juan Cruz Nores en 2011 : http://www.codng.com/2011/09/parallelism-performance-why-o-notation.html
• En 2012, Daniel Holden prétend que ce n'est pas tant le parallélisme que l'optimisation qui est complexe : http://theorangeduck.com/page/parallel-programming-isnt-hard-optimisation
• Publication de 2012 par des membres d'une équipe menée par Joe Duffy (voir http://www.bluebytesoftware.com/blog/2012/12/08/ImperativeFunctional.aspx), portant sur une extension au langage C# permettant certaines formes de parallélisation automatiques en formalisant des concepts tels que l'immuabilité et l'isolation : http://research.microsoft.com/pubs/170528/msr-tr-2012-79.pdf
  • réflexion sommaire suite à cette publication, surtout axée sur l'importance de pouvoir prouver l'immuabilité de certaines références (ou de certains référés), par Tim Kellogg en 2012 : http://developinthecloud.drdobbs.com/author.asp?section_id=2284&doc_id=256017&f_src=developinthecloud_sitedefault
• Un peu à contre-courant, Andrew Binstock écrit en 2012 pour nous dire que le parallélisme ne lève pas (côté client, du moins), au sens d'une application multiprogrammée tirant mieux profit des multiples coeurs mis à sa disposition. Par contre, la multiprogrammation à plusieurs processus, elle, se porte selon lui très bien : http://www.drdobbs.com/parallel/will-parallel-code-ever-be-embraced/240003926
• Exemple d'optimisation de code parallèle, par Aater Suleman en 2011 : http://www.futurechips.org/tips-for-power-coders/writing-optimizing-parallel-programs-complete.html
• Les I/O Completion Ports, expliqués par Kenny Kerr en 2014 : https://kennykerr.ca/2014/11/29/io-completion-ports/

Discussions d'idées générales sur la concurrence :

• Tester des conteneurs supportant la concurrence, article du Code Project : http://www.codeproject.com /KB/threads/concurrent_containers.aspx
• Architecture de systèmes concurrents chez Facebook, par Carlos Bueno en 2010 : http://www.facebook.com/notes/facebook-engineering/a-dismal-guide-to-concurrency/379717628919
• Le mythe de la concurrence, selon Michael Galpin en 2011 : http://fupeg.blogspot.com/2011/06/concurrency-myth.html
• Vérification des transformations réalisées par les compilateurs pour les programmes concurrents :
  • http://research.microsoft.com/apps/pubs/default.aspx?id=76524
  • http://research.microsoft.com/pubs/76524/tr-2008-171-latest-03-11-09.pdf
• Fonctions pure et fonctions const, de même que leurs conséquences, selon Diego Pettenò en 2008 : https://lwn.net/Articles/285332/

Quelques problèmes fondamentaux de la synchronisation :

• Celui des deux généraux : http://en.wikipedia.org/wiki/Two_Generals%27_Problem
• Celui du dîner des philosophes : http://en.wikipedia.org/wiki/Dining_philosophers_problem

Quelques articles de Herb Sutter :

• La concurrence aujourd'hui : http://www.ddj.com/architect/200001985?pgno=1
• La concurrence sur le serveur est un problème distinct de celui de la concurrence sur le client, en 2008 : http://herbsutter.com/2008/08/01/server-concurrency-client-concurrency/
• Bien utiliser les threads (isolation et messages asynchrones) : http://www.drdobbs.com/high-performance-computing/215900465
• Le bon usage des verrous et le choix des bons verrous : http://www.ddj.com/cpp/184401930
• Comprendre la performance de programmes parallèles, texte de 2008 : http://drdobbs.com/cpp/211800538
• Probablement ses deux articles les plus connus :
  • The Free Lunch is Over (2004), qui met de l'avant qu'on ne peut plus produire du code performant sans se préoccuper de multiprogrammation, du fait que l'approche monoprogrammée plafonnera sous peu : http://www.gotw.ca/publications/concurrency-ddj.htm
  • Welcome to the Jungle (2011), qui met de l'avant que non seulement devons-nous maintenant nous préoccuper de multiprogrammation, mais nous devons aussi nous préoccuper d'hétérogénéité des unités de traitement et, avec l'informatique mobile, de consommation de ressources telles que les pils de nos appareils : http://herbsutter.com/welcome-to-the-jungle/. Cet article est en lien direct avec l'approche Advanced Massive Parallelism (AMP) dont il s'est fait l'évangéliste.

Quelques articles de 2005 par Larry Osterman, programmeurs système pour la plateforme Microsoft Windows :

• Comment contourner le problème de la concurrence, entre autres en évitant de partager vos données : http://blogs.msdn.com/b/larryosterman/archive/2005/02/15/373460.aspx
• Quoi faire quand il n'est pas possible de contourner le problème? Une approche est d'avoir recours à des sections critiques : http://blogs.msdn.com/b/larryosterman/archive/2005/02/16/374682.aspx
• Évidemment, il y a parfois de l'interblocage, ce qui est vilain mais peut s'éviter entre autres par un ordonnancement des verrous : http://blogs.msdn.com/b/larryosterman/archive/2005/02/17/375449.aspx
• Cela dit, quoi faire quand l'ordonnancement des verrous n'est pas possible? http://blogs.msdn.com/b/larryosterman/archive/2005/02/18/376146.aspx
• À propos du comptage de références : http://blogs.msdn.com/b/larryosterman/archive/2005/02/21/377485.aspx
• Pourquoi écrire du code concurrent s'il s'agit d'une entreprise si compliquée? http://blogs.msdn.com/b/larryosterman/archive/2005/02/25/380557.aspx
• Concurrence et échelonnabilité : http://blogs.msdn.com/b/larryosterman/archive/2005/02/28/381865.aspx
• Les API de Microsoft Windows pour l'échelonnablité en situation de concurrence : http://blogs.msdn.com/b/larryosterman/archive/2005/03/02/383685.aspx
• Identifier un problème d'échelonnabilité : http://blogs.msdn.com/b/larryosterman/archive/2005/03/03/384458.aspx
• Problèmes d'échelonnabilité quelque peu subtils :
  • http://blogs.msdn.com/b/larryosterman/archive/2005/03/04/385305.aspx
  • http://blogs.msdn.com/b/larryosterman/archive/2005/03/07/387695.aspx
• Concurrence et plateforme .NET : http://blogs.msdn.com/b/larryosterman/archive/2005/03/08/389709.aspx
• Considérations diverses : http://blogs.msdn.com/b/larryosterman/archive/2005/03/09/390881.aspx
• Un retour sur cette série de textes : http://blogs.msdn.com/b/larryosterman/archive/2005/03/10/392258.aspx
• Concurrence et runtime du langage C : http://blogs.msdn.com/b/larryosterman/archive/2005/03/18/398787.aspx
• Concurrence et API Win32 : http://blogs.msdn.com/b/larryosterman/archive/2005/03/21/399873.aspx
• Concurrence et Microsoft Windows au sens large : http://blogs.msdn.com/b/larryosterman/archive/2005/03/22/400583.aspx

Réflexions de Bartosz Milewski sur le futur de la programmation concurrente :

• http://bartoszmilewski.wordpress.com/2010/05/11/parallel-programming-with-hints/
• http://bartoszmilewski.wordpress.com/2010/08/02/beyond-locks-and-messages-the-future-of-concurrent-programming/
• Une réflexion d'un autre ordre, mettant l'accent sur la consommation d'énergie, par Moshe Y. Vardi en 2011 : http://cacm.acm.org/magazines/2011/11/138223-is-moores-party-over/fulltext
• Texte de 2012 sur la construction d'une monade de continuation en tant que métaphore pertinente de continuation non-bloquante pour fins de programmation parallèle : http://fpcomplete.com/asynchronous-api-in-c-and-the-continuation-monad/

Pourquoi la programmation concurrente est-elle difficile? Réflexion de Stefan Marr en 2014 : http://www.stefan-marr.de/2014/07/why-is-concurrent-programming-hard/

Quelques présentations d'Anthony Williams :

• Penser les systèmes concurrents, en 2016 : https://www.justsoftwaresolutions.co.uk//files/concurrent_thinking.pdf
• Évolution de la programmation concurrente avec C++, en 2016 : https://www.justsoftwaresolutions.co.uk/files/ndc_oslo_2016_continuing_future_of_concurrency.pdf