Multiprogrammation – quelques liens

Vous trouverez ici quelques liens portant sur la multiprogrammation, qui intervient dans la plupart de mes cours, bien qu'il s'agisse, au fond, d'un sujet à part entière. Si vous découvrez d'autres liens dignes d'intérêt, faites-m'en part. De même, signalez-moi des liens brisés ou périmés si vous en rencontrez, ce qui me permettra d'offrir un meilleur service à vous comme à vos collègues.

Généralités

Les sites Wiki décrivant...

• ...la multiprogrammation : http://en.wikipedia.org/wiki/Computer_multitasking
• ...le parallélisme : http://en.wikipedia.org/wiki/Parallel_computing
• ...les interruptions : http://en.wikipedia.org/wiki/Interrupt
• ...la communication entre processus : http://en.wikipedia.org/wiki/Inter-process_communication
• ...le passage de messages : http://en.wikipedia.org/wiki/Message_passing
• ...les daemon : http://en.wikipedia.org/wiki/Daemon_%28computer_software%29
• ...les CSP, un modèle de multiprogrammation : http://en.wikipedia.org/wiki/Communicating_sequential_processes (voir http://swannodette.github.io/2013/07/12/communicating-sequential-processes/ pour quelques exemples)

Comment se porte la monoprogrammation? Données colligées par Jeff Preshing en 2012 : http://preshing.com/20120208/a-look-back-at-single-threaded-cpu-performance/

Discussion de différentes perspectives architecturales : http://www.possibility.com/wiki/index.php?title=ArchitectureDiscussion

Catalogue de concepts associés au parallélisme et aux systèmes concurrents, répertoriés par Kai Sellgren : https://github.com/kaisellgren/Concurrency-concepts

Les difficultés associées au développement pour des architecturess fortement hétérogènes, typiques des systèmes destinés au High Performance Computing et aux systèmes massivement parallèles, par Michael Wolfe en 2012 : http://www.hpcwire.com/hpcwire/2012-03-19/the_heterogeneous_programming_jungle.html

Une réflexion de Rob Pike sur la question des canaux en multiprogrammation :

• http://herpolhode.com/rob/lec3.pdf

Cours en ligne sur la programmation de systèmes concurrents :

• http://scg.unibe.ch/archive/lectures/CP-W01.pdf
• https://computing.llnl.gov/tutorials/parallel_comp/
• http://www.toves.org/books/distalg/

Concurrence et réseaux de Pétri :

• http://blog.ezyang.com/2011/03/petri-net-concurrency/

Quelques articles plus massifs :

• Un texte relativement mathématique nommé Programming Parallel Algorithms : http://citeseer.ist.psu.edu/cache/papers/cs/969/http:zSzzSzwww.cs.cmu.eduzSz~scandalzSzpaperszSzcacm-ppa.pdf/blelloch96programming.pdf
• Du même auteur que le précédent, un article nommé Multiscale Scheduling: Integrating Competitive and Cooperative Scheduling in Theory and in Practice : http://www.cs.cmu.edu/~rwh/papers/sched/desc.pdf
• Un texte relativement mathématique nommé Local Reasoning for Storable Locks and Threads : ftp://ftp.research.microsoft.com/pub/tr/TR-2007-39.pdf
• Un texte sur le raisonnement local en situation de concurrence, nommé Resources, Concurrency and Local Reasoning : http://www.dcs.qmul.ac.uk/~ohearn/papers/concurrency.pdf
• Un texte sur le langage Manticore, pensé pour la multiprogrammation : http://people.cs.uchicago.edu/~jhr/papers/2007/ml-manticore.pdf
• Un texte nommé Event-Based Programming without Inversion of Control : http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf
• Texte intéressant de Sun (maintenant Oracle) en 1994, par Jim Waldo, Geoff Wyant, Ann Wollrath et Sam Kendall et nommé A Note on Distributed Computing. Ce texte fait état des différences fondamentales entre la programmation à l'aide d'objets locaux et à l'aide d'objets répartis : http://labs.oracle.com/techrep/1994/smli_tr-94-29.pdf
• Le point de vue de Berkeley, en 2008, selon E. M. Hielscher : http://www.cs.nyu.edu/srg/talks/BerkeleyView.pdf
• La programmation parallèle est-elle difficile, et si oui, quoi faire? Un livre en ligne de Paul E. McKinney : http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
• Valider le respect du modèle mémoire à partir des optimisations réalisées sur un programme concurrent en C11 ou en C++ 11, par Robin Morisset, Pankaj Pawan et Francesco Zappa Nardelli en 2013 : http://www.di.ens.fr/~zappa/projects/wmc/readings/pldi13.pdf

Un bref sur la multiprogrammation chez Microsoft (tiré du Code Project, alors lire avec un oeil critique) :

• http://www.codeproject.com/KB/cs/ConcurrentProgrammingI.aspx

Des réflexions sur le design de systèmes répartis par Ken Arnold, un penseur parfois provoquant :

• http://www.artima.com/intv/distrib.html
• http://www.artima.com/intv/sway.html

Est-ce qu'un modèle réparti subsume un modèle centralisé « équivalent »? Une discussion : http://www.markdomowicz.com/index.php?option=com_content&view=article&id=64:distributed-is-not-a-superset-of-client-server-version-control&catid=40:programming&Itemid=60

Principes de multiprogrammation : http://queue.acm.org/detail.cfm?id=1454462

À propos des variables globales : http://software.intel.com/en-us/articles/global-variable-reconsidered/

Sur les difficultés associées à l'écriture du code multiprogrammé :

• http://thecodist.com/article/writing-multithreaded-code-is-like-juggling-chainsaws
• http://lbrandy.com/blog/2010/02/parallel-programming-is-hard-right/
• La multiprogrammation n'est pas si difficile que ça, selon Bertrand Meyer en 2011 : http://bertrandmeyer.com/2011/06/20/concurrent-programming-is-easy/
• Pourquoi la multiprogrammation est-elle difficile? Une réflexion d'Aater Suleman en 2011 : http://www.futurechips.org/tips-for-power-coders/parallel-programming.html

En 2012, Bartosz Milewski explique qu'à son avis, la multiprogrammation a sonné le glas de la programmation impérative, et que la programmation fonctionnelle est maintenant le chemin à emprunter : http://fpcomplete.com/the-downfall-of-imperative-programming/

Le débit et la latence, texte de 2016 par Pedro Ramalhete : http://concurrencyfreaks.blogspot.ca/2016/08/throughput-vs-latency-and-lock-free-vs.html

Conjecture CALM

La conjecture CALM, ou Consistency as Logicial Monotonicity, suppose que les systèmes répartis deviendront éventuellement cohérents si leur comportement peut être exprimé par un raisonnement de logique monotone.

• une description de cette conjecture, par Joseph M. Hellerstein en 2010 : http://databeta.wordpress.com/2010/10/28/the-calm-conjecture-reasoning-about-consistency/

Dans le monde du jeu vidéo

• De manière générale, plusieurs articles intéressants sont disponibles sur http://gafferongames.com/
• Un article offrant la perspective d'un programmeur de jeux vidéo sur la question de la concurrence : http://www.sdtimes.com/article/LatestNews-20071115-01.html
• Intelligence artificielle répartie et logique hiérarchique, article de Alex. J. Champandard en 2008 : http://aigamedev.com/open/articles/hierarchical-logic-multi-threading/
• L'approche adoptée chez Valve :
  • discussion générale en 2006 : http://www.anandtech.com/show/2114
  • texte de Tom Leonard en 2007 : http://www.valvesoftware.com/publications/2007/GDC2007_SourceMulticore.pdf
• Qu'est-ce qui constitue un bon design de multiprogrammation pour un jeu? Une réflexion de Charles Bloom en 2011 : http://cbloomrants.blogspot.com/2011/07/07-13-11-good-threading-design-for.html
• De son côté, Erik McClure est d'avis que dans bien des cas, ça n'en vaut pas la peine, si on se fie à ce texte de 2012 : http://blackhole12.blogspot.ca/2012/05/multithreading-problems-in-game-design.html
• À propos de la quête sans fin pour un peu plus de puissance, par Johan de Gelas en 2005 : http://www.anandtech.com/show/1645
• La multiprogrammation expliquée aux étudiant(e)s en programmation de jeu. selon Keith O'Conor en 2015 : http://www.fragmentbuffer.com/multithreading-for-gamedev-students/

Modèles de programmation

Quelques modèles de multiprogrammation suivent. La plupart ne sont pas mutuellement exclusifs.

• Le π-calcul, pour modéliser la concurrence : http://www.cs.cmu.edu/~wing/publications/Wing02a.pdf
• Autre langage de modélisation de systèmes concurrents : les réseaux de Pétri. http://en.wikipedia.org/wiki/Petri_net
• Une thèse de 1993 par Glynn Winskel et Mogens Nielsen, intitulée Models for Concurrency : http://www.daimi.au.dk/PB/463/PB-463.pdf

Modèle événementiel

• Programmation événementielle sans inversion de contrôle : http://lamp.epfl.ch/~phaller/doc/haller06jmlc.pdf
• Une proposition de modèle unifiant les threads et les événements : http://lamp.epfl.ch/~phaller/doc/haller07actorsunify.pdf
• Programmation événementielle sans inversion de contrôle (texte dont Martin Odersky est co-auteur), qui exploite le modèle de programmation par acteurs  : http://lampwww.epfl.ch/~odersky/papers/jmlc06.pdf
• Une réflexion critique exprimant le point de vue que, pour les systèmes complexes, une approche réactive serait à privilégier : http://www.rebelscience.org/Cosas/COSA.htm
• Article de Rob von Behren, Jeremy Condit et Eric Brewer, en 2003, selon lequel le modèle événementiel est inapproprié pour les serveurs à forte concurrence : http://www.usenix.org/events/hotos03/tech/vonbehren.html
• Des threads ou des événements?
  • http://swtch.com/~rsc/talks/threads07/(1)
  • http://mmcgrana.github.com/2010/07/threaded-vs-evented-servers.html
  • Une proposition de modèle unifiant les threads et les événements : http://lamp.epfl.ch/~phaller/doc/haller07actorsunify.pdf
• En 2011, Rob Levin décrit les objets « reportés », ou Deferred Objects, en JavaScript : http://developtodesign.com/js/deferred-objects/
• En 2012, David Barbour exprime sa position à l'effet que le modèle événementiel, malgré ses qualités, n'est en général pas la bonne approche. On peut être d'accord ou non avec lui, mais l'argumentaire est détaillé et intéressant : http://awelonblue.wordpress.com/2012/07/01/why-not-events/

Modèle par acteurs

Les acteurs constituent un modèle de programmation sans partage de données, fait d'entités actives qui transigent par messages asynchrones.

• Le texte original, de Hewitt et cie (1973) : http://dli.iiit.ac.in/ijcai/IJCAI-73/PDF/027B.pdf
• http://en.wikipedia.org/wiki/Actor_model
• Acteurs et Java :
  • le modèle Kilim : http://www.ibm.com/developerworks/java/library/j-javadev2-7.html
  • une description du modèle Akka par Fabrizio Giudici, en 2012 : http://weblogs.java.net/blog/fabriziogiudici/archive/2012/01/04/actors-java
  • acteurs réactifs avec Java, un texte de 2014 : http://kukuruku.co/hub/java/reactive-actors-in-java
• Comprendre la concurrence avec les acteurs :
  • approche d'Erlang : http://www.javaworld.com/javaworld/jw-02-2009/jw-02-actor-concurrency1.html
  • implémentations sur la JVM : http://www.javaworld.com/javaworld/jw-03-2009/jw-03-actor-concurrency2.html
• Descriptif du modèle à partir des cas d'Erlang et de Scala, par Ruben Vermeersch en 2012 : http://ruben.savanne.be/articles/concurrency-in-erlang-scala?=
• Une bibliothèque d'acteurs en langage C : http://chrismoos.com/2009/10/28/libactor-a-c-library-based-on-the-actor-model/
• Des acteurs en COBOL, texte de Jeff Claes en 2013 : http://www.jefclaes.be/2013/09/actor-model-in-cobol.html
• Des acteurs en Clojure? http://www.dalnefre.com/wp/2010/06/actors-in-clojure-why-not/
• Les acteurs en Scala :
  • http://blog.xebia.com/2009/10/22/scala-actors-for-the-enterprise-introducing-the-akka-framework/
  • http://www.scala-lang.org/node/242
  • réflexions sur ce modèle, à partir de l'approche préconisée par Scala : http://erikengbrecht.blogspot.com/2009/06/pondering-actor-design-trades.html
  • http://www.scala-lang.org/node/242
  • http://blog.xebia.com/2009/10/22/scala-actors-for-the-enterprise-introducing-the-akka-framework/
• Les acteurs en Whiley :
  • http://whiley.org/2010/10/25/implementing-actors-on-the-jvm/
• Concurrence et simili-goroutines avec Ruby :
  • http://www.igvita.com/2010/12/02/concurrency-with-actors-goroutines-ruby/
• Avec C++ :
  • en 2015, Tony Da Silva signale l'absence d'acteurs standards en C++ : http://bulldozer00.com/2015/05/18/whence-actors/
  • un petit exemple maison d'acteurs en C++, par Tony Da Silva en 2015 : http://bulldozer00.com/2015/05/21/acting-in-c/
  • implémentation commerciale d'acteurs en C++, par Anthony Williams en 2015 : https://www.justsoftwaresolutions.co.uk/threading/all-the-worlds-a-stage.html

Modèle par tapon

Non, ce n'est pas un nom scientifique.

• http://en.wikipedia.org/wiki/Bulk_Synchronous_Parallel

Modèle par CSP (Communicating Sequential Processes, ou processus séquentiels communiquant entre eux)

• http://en.wikipedia.org/wiki/Communicating_sequential_processes
• Le CSP présenté comme un exemple de Responsive Design, par David Nolen en 2013 : http://swannodette.github.io/2013/07/31/extracting-processes/

Modèle par flux

• http://www.jpaulmorrison.com/fbp/index.shtml
• explication d'une variante de cette approche, par Volkan Yazıcı en 2012 : http://vyazici.blogspot.ca/2012/09/sequential-chaining-of-nested-callbacks.html

Modèle sous Android et sous iOS

• En 2012, Fraser Speirs explique ce qu'on comprend mal, selon lui, dans la multiprogrammation sous iOS : http://speirs.org/blog/2012/1/2/misconceptions-about-ios-multitasking.html
• En 2012, Ryan Whitwam explique comment la multiprogrammation fonctionne à la fois sous Android et sous iOS : http://www.extremetech.com/computing/112013-how-multitasking-works-on-android-and-ios

Autres modèles

L'approche par révisions concurrentes, mise en valeur par Microsoft Research, où chaque tâche obtient une copie (conceptuelle) de tous les états partagés, et où les changement d'états ne sont intégrés que lorsque les tâches se rejoignent, moment où les conflits d'écriture sont résolus de manière déterministe.

• Introduction et généralités : http://research.microsoft.com/en-us/projects/revisions/
• Modèle sémantique, texte de 2011 par Sebastian Burckhardt et Daan Leijen : http://research.microsoft.com/apps/pubs/default.aspx?id=145511
• Modèle incrémental de programmation parallèle, texte de 2011 par Sebastian Burckhardt, Daan Leijen, Caitlin Sadowski, Jaeheon Yi, et Thomas Ball : http://research.microsoft.com/apps/pubs/default.aspx?id=150180
• Cohérence éventuelle et types nuagiques, texte de 2012 par Sebastian Burckhardt, Manuel Fahndrich, Daan Leijen, et Benjamin P. Wood : http://research.microsoft.com/apps/pubs/default.aspx?id=163842

Communication

• Technologie WCF et Multicast (article du Code Project, alors prudence...) : http://www.codeproject.com/KB/WCF/PgmTransport.aspx
• Introduction à la bibliothèque de messagerie ZeroMQ : http://nichol.as/zeromq-an-introduction
• Revue de littérature sur les algorithmes de diffusion (Broadcast et Multicast); il vous faudra un accès ACM pour y accéder : http://portal.acm.org/citation.cfm?doid=1041680.1041682
• Mécanismes de communication inter-processus sous Microsoft Windows : http://msdn.microsoft.com/en-us/library/aa365574.aspx

Algorithmes

Quelques algorithmes et quelques familles d'algorithmes parallèles bien connus.

Approche Map/ Reduce

À propos de Map/ Reduce :

• Adapter des algorithmes pour une approche Map/ Reduce : http://horicky.blogspot.com/2010/08/designing-algorithmis-for-map-reduce.html
• Comprendre Map/ Reduce :
  • http://ksat.me/map-reduce-a-really-simple-introduction-kloudo/
  • https://www.philipithomas.com/simple-mapreduce/
• Des mythes au sujet de cette approche : http://www.dbms2.com/2009/10/18/three-big-myths-about-mapreduce/
• Il y a plus d'une manière d'implémenter cette approche : http://databeta.wordpress.com/2009/10/18/mapreduce-online/
• http://michaelnielsen.org/blog/write-your-first-mapreduce-program-in-20-minutes/
• Quelques pratiques et quelques algorithmes Map/ Reduce typiques, colligés par Ilya Katsov en 2012 : http://highlyscalable.wordpress.com/2012/02/01/mapreduce-patterns/
• Visualiser Map/ Reduce, un texte d'Ayende Rahien en 2010 : http://ayende.com/blog/4435/map-reduce-a-visual-explanation
• Une implémentation Map/ Reduce d'un algorithme de fouille dans une base de données NoSQL, par Chase Bradford en 2010 : http://chasebradford.wordpress.com/2010/10/23/mapreduce-implementation-for-union-find/
• Série d'articles portant sur des implémentations d'algorithmes Map/ Reduce, par Bill Bejeck :
  • traiter des masses de texte, 1^re partie : http://codingjunkie.net/text-processing-with-mapreduce-part1/
  • traiter des masses de texte, 2^e partie : http://codingjunkie.net/text-processing-with-mapreduce-part-2/
  • calculer une matrice de co-occurrence : http://codingjunkie.net/cooccurrence/
  • inverser l'ordre dans lequel sont faites certaines opérations : http://codingjunkie.net/order-inversion/
  • tri secondaire : http://codingjunkie.net/secondary-sort/
• Présentation formelle compacte par Maarten M. Fokkinga en 2008 : http://wwwhome.ewi.utwente.nl/~fokkinga/mmf2008j.pdf
• L'intérêt des Reducers, qui réalisent la partie « accumulation » d'un Map/ Reduce, mis de l'avant par Guillermo Winkler en 2013 : http://blog.guillermowinkler.com/blog/2013/12/01/whats-so-great-about-reducers/
• Dans ce texte de 2014, Jeremy Kun discute de la complexité algorithmique de Map/ Reduce : http://jeremykun.com/2014/10/05/on-the-computational-complexity-of-mapreduce/
• En 2014, avec des petabytes de données à traiter, Google a fait le constat que cette approche ne suffit plus :
  • article de Whitney Baker : http://java.dzone.com/articles/google-io-dumping-mapreduce
  • l'approche privilégiée pour remplacer Map/ Reduce semble être Flume : http://pages.cs.wisc.edu/~akella/CS838/F12/838-CloudPapers/FlumeJava.pdf
  • à propos de l'impact de cette approche sur le panorama matériel, texte de 2015 : http://the-paper-trail.org/blog/the-elephant-was-a-trojan-horse-on-the-death-of-map-reduce-at-google/
• Texte de 2014 par Noel Cody qui explique comment Spotify a réglé un cas de contention pour un Reducer : https://www.hakkalabs.co/articles/torching-reducers-taught-us-essential-lesson
• Selon Eugene Kirpichov en 2016, il ne faut pas confondre Map/ Reduce et programmation fonctionnelle : https://medium.com/@jkff/mapreduce-is-not-functional-programming-39109a4ba7b2#.bp6ojw7qp

L'approche Map/ Reduce a donné naissance à ce que certains ont nommé l'architecture λ :

• Texte de Nathan Marz en 2011 : http://nathanmarz.com/blog/how-to-beat-the-cap-theorem.html
• En 2014, Jay Kreps questionne (au moins en partie) les bienfaits de cette approche : http://radar.oreilly.com/2014/07/questioning-the-lambda-architecture.html

Traitement parallèle de chaînes de caractères

À propos du traitement de chaînes de caractères :

• http://labs.qt.nokia.com/2011/03/23/improving-string-performance-with-simd-the-revenge/

Allocation dynamique de mémoire

L'allocation dynamique de mémoire sur un ordinateur à plusieurs coeurs ou à plusieurs processeurs :

• http://www.codeguru.com/forum/showthread.php?t=409798
• http://developers.sun.com/solaris/articles/multiproc/multiproc.html
• le cas particulier des moteurs de collecte atomatique d'ordures : http://flyingfrogblog.blogspot.com/2010/09/are-multicore-capable-garbage.html

Comment fonctionne tcmalloc (Thread-Cache Memory Allocator), un texte de James Golick en 2013 :

• http://jamesgolick.com/2013/5/15/memory-allocators-101.html
• http://jamesgolick.com/2013/5/19/how-tcmalloc-works.html

Accumulation parallèle

Réaliser une accumulation parallèle sur des fonctions qui peuvent ne pas être pures, une proposition de Craig Gidney en 2013 : http://twistedoakstudios.com/blog/Post8355_brute-force-parallelization

Multiples coeurs

Les dernières années des processeurs monocoeurs et le virage vers ce que nous connaissons maintenant, un texte de Jeff Preshing en 2012 : http://preshing.com/20120208/a-look-back-at-single-threaded-cpu-performance

Textes informatifs et semi-rigoureux sur les microprocesseurs contemporains :

• http://www.lighterra.com/papers/modernmicroprocessors/
• http://www.azulsystems.com/events/javaone_2009/session/2009_J1_HardwareCrashCourse.pdf

Le site Wiki décrivant les processeurs à plusieurs coeurs est : http://en.wikipedia.org/wiki/Multi-core

Diverses considérations architecturales :

• http://www.igvita.com/2010/08/18/multi-core-threads-message-passing/
• http://msdn.microsoft.com/en-us/library/ms686355%28v=VS.85%29.aspx

Des articles sur le défi derrière la programmation des processeurs à plusieurs coeurs :

• http://www.news.com/Intel-Software-needs-to-heed--Moores-Law/2100-1012_3-6186765.html?tag=nefd.top
• http://www.informationweek.com/news/showArticle.jhtml?articleID=197001130
• http://rjlipton.wordpress.com/2010/11/21/who-wants-parallel-computers/
• mieux vaut se préparer à programmer sur des milliers de coeurs, selon Intel en 2008 : http://news.cnet.com/8301-13924_3-9981760-64.html?part=rss&subj=news&tag=2547-1_3-0-5
• tirer pleinement avantage de tous ces coeurs est moins simple que certains ne pourraient le penser, de l'avis de Joel Hruska en 2012 : http://www.extremetech.com/computing/116561-the-death-of-cpu-scaling-from-one-core-to-many-and-why-were-still-stuck

Le développement et l'optimisation du code pour un processeur à plusieurs coeurs :

• http://www.ddj.com/hpc-high-performance-computing/192501977
• http://developer.amd.com/articlex.jsp?id=28
• http://www.devx.com/go-parallel/Article/31837
• http://developers.sun.com/solaris/articles/chip_multi_thread.html
• texte d'Herb Sutter en 2009 : http://drdobbs.com/go-parallel/article/showArticle.jhtml?articleID=219200099

Idem mais pour des programmes pris en charge : http://msdn.microsoft.com/msdnmag/issues/07/10/Futures/default.aspx?loc=fr

Accéder à des masses importantes de données sur un ordinateur à plusieurs processeurs : http://msdn.microsoft.com/msdnmag/issues/01/08/Concur/

Sur les tangentes (plusieurs coeurs généralistes; plusieurs coeurs spécialisés) : http://www.eetimes.com/showArticle.jhtml;?articleID=206105179

Sur le futur de la programmation de processeurs munis de multiples coeurs : http://www.eetimes.com/news/latest/showArticle.jhtml?articleID=206504466

Sur le futur de la programmation à l'aide d'accélérateurs, par Kamil Rocki et Martin Burtscher en 2014 : http://www.hpcwire.com/2014/01/09/future-accelerator-programming/

Les coeurs ne sont pas nécessairement tous égaux : http://gcn.com/articles/2008/12/22/multicore-does-not-mean-equal-core.aspx

À propos du système d'exploitation Barrelfish, projet expérimental de Microsoft d'un système d'exploitation optimisé pour les machines à plusieurs coeurs : http://h-deb.ca/Liens/Systemes-exploitation.html#barrelfish

Avec Windows 7 :

• http://www.infoworld.com/d/windows/windows-7-multicore-how-much-faster-325
• http://www.infoworld.com/d/windows/how-intel-nehalem-processors-and-windows-7-work-together-335

La position d'AMD sur l'approche par hyperthreading : http://blogs.amd.com/work/2010/01/21/it%E2%80%99s-all-about-the-cores/

Faire véritablement le saut au multiples coeurs exigera une réécriture du système d'exploitation Windows, apparemment : http://www.networkworld.com/news/2010/031910-multicore-requires-os-rework-windows.html

Préparer le code pour la parallélisation sur plusieurs coeurs : http://www.drdobbs.com/go-parallel/article/showArticle.jhtml;jsessionid=MUIULNTFUDRZZQE1GHPSKH4ATMY32JVN?articleID=227500610

Il semble que les systèmes d'exploitation actuels (fin 2010) soient plus ou moins appropriés pour des ordinateurs munis de plus de 48 coeurs :

• http://www.conceivablytech.com/3166/science-research/current-operating-systems-may-only-make-sense-up-to-48-cores/
• http://pdos.csail.mit.edu/papers/linux:osdi10.pdf
• Pourtant, on parle de processeurs à 1000 coeurs et plus dans un proche futur... http://www.goodgearguide.com.au/article/368762/intel_1_000-core_processor_possible/
• ça ne semble toutefois pas toujours être la solution à tous les maux... http://www.pcworld.idg.com.au/article/370535/oracle_halve_core_count_next_sparc_processor/

Un programme de tri en parallèle du Code Project, article de 2008 : http://www.codeproject.com/KB/threads/tricky_multicore.aspx

De combien d'échelonnabilité avons-nous besoin? La vision d'Herb Sutter :

• En 2007 : http://drdobbs.com/high-performance-computing/201202924
• En 2008 : http://drdobbs.com/high-performance-computing/206100542

Évaluer les interactions asymétriques sur des processeurs à multiples coeurs symétriques, article de 2008 : http://synergy.cs.vt.edu/pubs/papers/scogland-sc2008-symmer.pdf

Synchronisation et multiples coeurs : http://msdn.microsoft.com/en-us/library/ms686355%28VS.85%29.aspx

De l'avis de Vasudevan Thiygarajan, en 2012, la multiprogrammation avec plusieurs threads n'est pas la meilleure approche pour tirer profit au maximum des architectures munies de plusieurs coeurs : http://www.ibm.com/developerworks/java/library/j-nothreads/index.html?ca=drs-

Régler les problèmes de Python face aux ordinateurs à multiples coeurs, une proposition d'Eric Snow en 2015 : https://lwn.net/Articles/650521/

GPU et « programmation multiappareils »

La multiprogrammation utilisant les unités de traitement graphiques, communément nommées GPU (Graphical Processing Unit), est en vogue. Voir aussi Advanced Massive Parallelism (AMP).

Article général de 2010 sur la montée des architectures orientées débit (Throughput-Oriented Architectures) : http://highscalability.com/blog/2010/12/3/gpu-vs-cpu-smackdown-the-rise-of-throughput-oriented-archite.html

Quelques bases de vocabulaire, tirées de Wiki :

• À propos du processeur, aussi nommé unité centrale de traitement, UCT, ou CPU (Central Processing Unit) en anglais : http://en.wikipedia.org/wiki/Central_processing_unit
• À propos des GPU : http://en.wikipedia.org/wiki/Graphics_processing_unit
• À propos de DirectCompute : http://en.wikipedia.org/wiki/DirectCompute

À propos d'OpenCL, le Open Computing Language :

• http://en.wikipedia.org/wiki/OpenCL
• Programmer avec OpenCL, par Gastón Hillar en 2014 : http://www.drdobbs.com/architecture-and-design/programming-with-opencl-12/240168925
• Présentation d'OpenCL, par Nick Lamprianidis en 2015 : http://paign10.me/blog/software/parallel/opencl/what-is-opencl/

Approche alternative, reposant sur la virtualisation des langages, par plusieurs auteurs dont Martin Odersky : http://infoscience.epfl.ch/record/148814/files/paper.pdf

Du GPGPU avec Java : http://www.javacodegeeks.com/2011/09/gpgpu-java-programming.html

Du code hybride CPU/GPU avec Haskell, un texte de Ryan Newton en 2012 : http://parfunk.blogspot.ca/2012/05/how-to-write-hybrid-cpugpu-programs.html?m=1

La technologie CUDA, pour Compute Unified Device Architecture :

• Un Wiki sur le sujet : http://en.wikipedia.org/wiki/CUDA
• Entrevue de 2008 avec David Kirk (NVidia) à propos de CUDA et de l'utilisation du CPU comme des GPU : http://www.bit-tech.net/hardware/cpus/2008/04/30/david-kirk-interview/1
• Utiliser CUDA sur la Grille, selon Jon McLoone de Wolfram : http://blog.wolfram.com/2011/07/14/driving-cuda-over-the-grid/
• La bibliothèque Thrust, pour développer sur CUDA, présentée par Mark Harris en 2012 : http://developer.nvidia.com/content/expressive-algorithmic-programming-thrust
• Parallélisme dynamique avec CUDA version 5, texte de 2012 : http://baltazaar.wordpress.com/2012/07/15/dynamic-parallelism-in-cuda-version-5/
• Développer du code C ou C++ portable pour CUDA à l'aide de l'outil Hemi, un texte de Mark Harris en 2013 : https://developer.nvidia.com/content/developing-portable-cuda-cc-code-hemi
• Optimiser en fonction du Pointer Aliasing, texte de Jeremy Appleyard en 2014 : http://devblogs.nvidia.com/parallelforall/cuda-pro-tip-optimize-pointer-aliasing/
• Il est maintenant possible de programmer CUDA avec C++ 11. Articles de Mark Harris en 2015 :
  •  http://devblogs.nvidia.com/parallelforall/cuda-7-release-candidate-feature-overview/
  • http://devblogs.nvidia.com/parallelforall/power-cpp11-cuda-7/
  • optimiser une fonction d'interpolation linéaire (un Lerp) avec C++ et CUDA : http://devblogs.nvidia.com/parallelforall/lerp-faster-cuda/
• Programmer pour un GPGPU avec Julia et CUDA, par Mike Innes en 2017 : http://mikeinnes.github.io/2017/08/24/cudanative.html

Optimiser les accès dans des programmes destinés à des GPU, textes d'Eric Holk en 2012 :

• http://blog.theincredibleholk.org/blog/2012/12/23/access-patterns-matter/
• http://blog.theincredibleholk.org/blog/2012/12/24/access-patterns-matter-part-2/

Compiler un programme Rust pour l'exécuter sur un GPU, par Eric Holk en 2012 : http://blog.theincredibleholk.org/blog/2012/12/05/compiling-rust-for-gpus/

Résoudre un labyrinthe à l'aide du GPU, texte de Christopher Wellons en 2014 : http://nullprogram.com/blog/2014/06/22/

L'outil Mapgraph, pour le traitement massivement parallèle de graphes : http://mapgraph.io/

Le GPLGPU, un moteur graphique sous licence GPL v3 : http://gplgpu.com/?p=88

Techniques pour partager de la mémoire entre CPU et GPU, à l'aide de Swift, en 2014 : http://memkite.com/blog/2014/12/30/example-of-sharing-memory-between-gpu-and-cpu-with-swift-and-metal-for-ios8/

Programmer pour un GPU de NVIDIA, par Yosef Kreinin en 2015 : http://yosefk.com/blog/simd-simt-smt-parallelism-in-nvidia-gpus.html

Cas vécu d'optimisation de code dans lequel les mises en attente lors de transferts de données entre le CPU et GPU étaient au coeur du problème, relaté par Raja Bala en 2015 : https://software.intel.com/en-us/articles/removing-cpu-gpu-sync-stalls-in-galactic-civilizations-3

Ce qu'il faut savoir à propos de la fréquence du GPU, selon Ben Widawsky en 2015 : https://bwidawsk.net/blog/index.php/2015/05/a-bit-on-intel-gpu-frequency/

L'« initiative Boltzmann » proposée par AMD pour faciliter le recours programmatique à des GPU : http://www.amd.com/en-us/press-releases/Pages/boltzmann-initiative-2015nov16.aspx

Combiner programmation sur le GPU et variables atomiques, par Elmar Westphal en 2015 : https://devblogs.nvidia.com/parallelforall/voting-and-shuffling-optimize-atomic-operations/

Les GPU et Intel, une présentation de 2015 par Jason Ross, Ken Lueh et Subramaniam Maiyuran : https://software.intel.com/sites/default/files/managed/89/92/Intel-Graphics-Architecture-ISA-and-microarchitecture.pdf

Advanced Massive Parallelism (AMP)

L'approche AMP, pour Advanced Massive Parallelism, est survolée sur ../Sujets/Parallelisme/AMP.html

Langages

Quelques considérations d'ordre général :

• Le parallélisme exige-t-il que l'on utilise de nouveaux langages? http://gcn.com/blogs/tech-blog/2009/06/new-parallel-processing-languages.aspx
• En 2012, James Reinders s'interroge sur ce qui doit être fait pour adapter un langage de programmation existant en fonction des besoins du monde du parallélisme : http://www.hpcwire.com/hpcwire/2012-02-23/retrofitting_programming_languages_for_a_parallel_world.html
• Votre langage favori est probablement très mauvais dans sa gestion de la concurrence, une réflexion de 2011 : http://functional-orbitz.blogspot.com/2011/10/your-favorite-language-is-probably.html
• Approcher la question de la concurrence avec Erlang, Clojure, Go et Scala, une présentation de Alexey Kachayev en 2013 : http://kachayev.github.com/talks/kharkivpy%230/index.html#/

Ce qui suit liste quelques particularités de multiprogrammation de divers langages. Pour en savoir plus sur ces langages et sur bien d'autres, vous pouvez examiner ceci.

Ada et la concurrence :

• Texte de Thomas Løcke en 2012 : http://blogs.fsfe.org/thomaslocke/2012/05/17/concurrent-ada-programming/
• Baliser les données utilisées de manière parallèle dans un programme Ada par des régions, une présentation de S. Tucker Taft en 2012 : https://docs.google.com/file/d/0B6Vq5QaY4U7uSzEwSDA0YXQ5NW8/edit?pli=1

C et la concurrence :

• Les coroutines :
  • http://www.chiark.greenend.org.uk/~sgtatham/coroutines.html
  • texte de 2012 par Leandro Pereira qui explique comment réaliser des entrées/ sorties asynchrones à l'aide de coroutines en C : http://tia.mat.br/posts/async_io_with_coroutines/

Parallélisme et concurrence avec C++ (la plupart en lien avec C++ 11) :

• Les coroutines : ../Sujets/Parallelisme/coroutine.html
• Un Cheat Sheet, par Alex Korban : http://cpprocks.com/c-concurrency-cheatsheet/
• Survol des concepts clés de la multiprogrammation avec C++ 11, à partir des discussions du comité de standardisation lui-même (mais écrit avant que le comité n'en soit arrivé à une version finale et officielle du standard), par Eric Niebler en 2006 : http://www.artima.com/cppsource/threads_meeting.html
• Description de ce qui est devenu le modèle officiel de C++ 11, par Anthony Williams en 2008 : http://www.devx.com/SpecialReports/Article/38883
• Propositions pour le comité de standardisation (d'un intérêt historique seulement, du fait que le standard a pris forme depuis) :
  • celle de Lawrence Crowl, en 2005 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1875.html
  • celle de Kevlin Henney, en 2005 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1883.pdf
  • proposition de Lawrence Crowl, en 2005, portant sur la question de la mémoire locale aux threads : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1874.html (texte subséquent, en 2007, par le même auteur : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2147.html)
  • celle de Pete Becker, en 2005 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1907.html
  • celle de Nick Maclaren, en 2006 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1963.pdf
  • celle de Peter Dimov, en 2006 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2090.html
  • celle de Howard E. Hinnant, en 2006 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2094.html
  • proposition de Peter Dimov, en 2006, centrée sur la question du transfert d'information entre un thread et celui l'ayant lancé : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2096.html
  • proposition de Lawrence Crowl, en 2007, portant sur la question de l'initialisation et de la finalisation dynamiques en situation de concurrence : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2148.html
  • proposition en 2008 par plusieurs personnes réputées, décrivant la question du Thread-Safety en C++ : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2669.htm
• Liste des fonctions standards qu'il n'est pas sécuritaire d'utiliser concurremment, en 2009 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2864.html
• Technique proposée par Jim Springfield en 2011 pour assurer la sécurité lors d'accès concurrents : http://blogs.msdn.com/b/vcblog/archive/2011/05/26/10168887.aspx
• Observateurs pour les fonctions gestionnaires (std::set_new_handler(), std::set_unexpected(), std::set_terminate()) :
  • http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3189.htm
• Profiter au maximum du parallélisme avec C et C++ : http://software.intel.com/en-us/blogs/2011/08/09/parallelism-as-a-first-class-citizen-in-c-and-c-the-time-has-come/
• Technique intéressante pour synchroniser certains accès potentiellement concurrents sur des données, à partir d'un constructeur de délégation, le tout proposé par Michael Spertus en 2011 : http://www.justsoftwaresolutions.co.uk/threading/thread-safe-copy-constructors.html
• Série de présentations d'environ 20 à 30 minutes chacune sur la multiprogrammation en C++ 11, par Bartosz Milewski :
  • approche Fork/ Join : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartOne.aspx
  • sémantique de mouvement et passage de paramètres aux threads : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartTwo.aspx
  • partage de données entre threads : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartThree.aspx
  • futures, promesses et async : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartFour.aspx
  • tâches : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartFive.aspx
  • approche Map/ Reduce : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartSix.aspx
  • mutex et autres verrous : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartSeven.aspx
  • passage de messages : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartEight.aspx
  • les Condition Variables : http://www.corensic.com/Learn/Resources/ConcurrencyTutorialPartNine.aspx
• Un tutoriel simple, écrit par Paul Silisteanu en 2011 et en 2012 :
  • http://solarianprogrammer.com/2011/12/16/cpp-11-thread-tutorial/
  • http://www.solarianprogrammer.com/2012/02/27/cpp-11-thread-tutorial-part-2/
  • http://solarianprogrammer.com/2012/05/09/cpp-11-thread-tutorial-part-3/
• En 2011, John Regehr propose une stratégie pour mettre à l'épreuve les compilateurs C++ 11 et leur implémentation du modèle mémoire de ce langage, dans l'optique de rapprocher le fruit de ces compilateurs des ambitieuses attentes mises de l'avant par le standard : http://blog.regehr.org/archives/658
• Une proposition, nommée dthreads, de remplacement déterministe pour l'API pthreads, par Tongping Liu, Charlie Curtsinger et Emery D. Berger en 2011 : http://emeryblogger.com/2011/07/06/dthreads-efficient-deterministic-multithreading/
• En 2012, Artur Laksberg nous prévient qu'il ne faut pas capturer de variables locales par référence dans une λ utilisée de manière asynchrone : http://blogs.msdn.com/b/nativeconcurrency/archive/2012/01/29/perils-of-lambda-capture.aspx
• Construction, initialisation dynamique et destruction en situation de concurrence, par Danny Kalev :
  • texte de 2007 : http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=375
  • texte de 2008 : http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=378
• En 2009, Danny Kalev discute de pratiques pour annuler un thread ou abandonner un processus : http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=446
• Le futur de la concurrence et du parallélisme avec C++, un texte de Bartosz Milewski en 2012 : http://bartoszmilewski.com/2012/05/11/the-future-of-c-concurrency-and-parallelism/
• Multiprogrammation avec C++ sous Microsoft Windows :
  • descriptif un peu vieillot, par Herbert Schildt en 2004 : http://www.devarticles.com/c/a/Cplusplus/Multithreading-in-C/
  • textes de Kenny Kerr :
    • sur les regroupements de threads avec Microsoft Windows, texte de 2011 : http://msdn.microsoft.com/en-ca/magazine/hh335066.aspx
    • sur la synchronisation en lien avec les regroupements de threads avec Microsoft Windows, texte de 2011 : http://msdn.microsoft.com/en-us/magazine/hh547107.aspx
    • à propos de l'évolution de la multiprogrammation et des entrées/ sorties dans Microsoft Windows, un texte de 2013 : http://msdn.microsoft.com/en-us/magazine/jj883951.aspx
  • mal programmer sur cette plateforme, selon Joseph M. Newcomer en 2011 (du moins aux dernières nouvelles, car c'est une sorte de foire aux questions évolutive) : http://www.flounder.com/badprogram.htm
• Tutoriel sur async en C++ 11, par Paul Silisteanu en 2012 : http://solarianprogrammer.com/2012/10/17/cpp-11-async-tutorial/
• Depuis C++ 11, les mots const et mutable ont un sens particulier pour la multiprogrammation :
  • une présentation de Herb Sutter en 2012 : http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank
  • un texte plus concis de Herb Sutter sur le même sujet, en 2013 : http://herbsutter.com/2013/05/24/gotw-6a-const-correctness-part-1-3/
  • une brève discussion de l'impact de ce changement sur le code existant, par Craig Henderson en 2013 : http://www.reliablecpp.com/blog/class-immutability-upgrading-98-to-11.htm
• Comparatif des modèles de C++ 11 et de Go, avec un biais pro-Go, par Øyvind Teig en 2013 : http://www.teigfam.net/oyvind/home/technology/072-pike-sutter-concurrency-vs-concurrency/
• En 2013, Torvald Riegel trace les contours des abstractions qu'offre C++ 11 pour le parallélisme et la concurrence :
  • http://developerblog.redhat.com/2013/08/15/c-cpp11-parallelism/
  • http://developers.redhat.com/blog/2013/08/20/c-cpp11-concurrency/
• Textes d'Anthony Williams :
  • parallélisme et concurrence avec C++ 14, allant vers C++ 17, une présentation d' en 2014 : hhttp://www.justsoftwaresolutions.co.uk/files/continuing_future_of_concurrency.pdf
  • ce que C++ 14 apporte de neuf à la programmation concurrente, texte de 2015 : https://www.justsoftwaresolutions.co.uk/threading/new-concurrency-features-in-c++14.html
• Multithreading depuis C++ 14, série d'articles par Loic Yvonnet en 2016 :
  • survol des concepts clés : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-1/
  • les threads bruts (type std::thread) : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-2/
  • quelques outils pratiques logés dans <functional> : hhttp://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-3/
  • synchronisation par verrous et mutex : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-4/
  • futures et promesses : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-5/
  • notifications à l'aide de future<void> et de condition_variable : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-6/
  • saines pratiques : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-7/
  • atomiques : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-8/
  • synchronisation sans verrous : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-9/
  • quelques bibliothèques : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-10/
  • http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-11/
  • programmation multiprocessus : http://www.loic-yvonnet.com/articles/multithreading-in-cpp14-part-12/
• Tirer le maximum de la programmation multicoeurs sur Microsoft Windows : https://msdn.microsoft.com/en-us/library/gg675934.aspx
• Utiliser C++ pour la multiprogrammation en contexte de HPC (High Performance Computing) :
  • texte généraliste sur la relation entre le langage et ce domaine d'application, par Hartum Kaiser en 2015 : http://stellar-group.org/2015/05/hpx-and-the-cpp-standard/
  • texte de Daniel Bourgeois en 2015, à propos des exécuteurs : http://stellar-group.org/2015/05/hpx-and-cpp-executors/
  • modélisation du traitement sur la base de tâches, par Hartmut Kaiser en 2015 : http://stellar-group.org/2015/06/hpx-and-cpp-task-blocks/
  • texte de 2015 par Hartmut Kaiser sur la modélisation d'un flux de données : http://stellar-group.org/2015/06/hpx-and-cpp-dataflow/
  • algorithmes parallèles et politiques d'exécution, par Hartmut Kaiser en 2015 : http://stellar-group.org/2015/06/hpx-and-cpp-parallel-algorithms/
  • programmer à l'aide de futures, selon Hartmut Kaiser en 2015 : http://stellar-group.org/2015/07/hpx-and-cpp-futures/
  • texte de 2016 par Hartmut Kaiser sur les répétitives opérant à l'aide d'indices : http://stellar-group.org/2016/03/hpx-and-index-based-cpp-parallel-loops/
• La multiprogrammation avec C++ est son évolution, selon Rainer Grimm en 2016 : http://www.modernescpp.com/index.php/multithreading-in-modern-c
• Texte de 2016 par Rainer Grimm, portant sur la durée de vie des threads : http://www.modernescpp.com/index.php/threads-lifetime
• Passage de paramètres aux threads, selon Rainer Grimm en 2016 : http://www.modernescpp.com/index.php/data-for-threads
• Texte de Rainer Grimm en 2016 à propos de la mémoire locale aux threads : http://www.modernescpp.com/index.php/thread-local-data

Parallélisme et multiprogrammation en Clojure :

• http://incanter.org/downloads/fjclj.pdf
• http://mikes-tech.blogspot.com/2010/11/clojures-timeconcurrency-model-gentle.html
• Réflexion de Christophe Grand, en 2011, sur la granularité des références et la mémoire transactionnelle : http://clj-me.cgrand.net/2011/10/06/a-world-in-a-ref/

Parallélisme avec C# :

• Affinité d'un thread avec certaines ressources, par Patrick Smacchia en 2006 : http://www.codeproject.com/Articles/13562/Thread_Resource-affinity
• Les transactions : http://jacksonh.tumblr.com/post/1044557152/apparently-this-asparallel-thing-works
• Les async : ../Sujets/Divers--cdiese/async_await.html
• Sous Windows 8, les choses changent pour C# :
  • http://www.jaylee.org/post/2012/03/17/No-Threads-for-you-in-metro-style-apps.aspx
• Les collections et le parallélisme sous .NET :
  • texte d'Andrew Arnott en 2011 :
    •  http://blogs.msdn.com/b/andrewarnottms/archive/2011/08/22/read-only-frozen-and-immutable-types-and-collections.aspx
    • http://blogs.msdn.com/b/andrewarnottms/archive/2011/08/30/immutable-collections-with-mutable-performance.aspx
• Affichage dans un moteur de jeu multiprogrammé avec C# :
  • passer par du Double-Buffering, texte d'Andrea Magnorsky en 2013 : http://roundcrisis.com/2013/05/24/multithreading-rendering-in-a-game-engine-with-cdouble-buffer-implementation/
  • passer par un ConcurrentQueue<T>, texte d'Andrea Magnorsky en 2013 : http://roundcrisis.com/2013/06/22/multithreaded-game-engineusing-concurrent-collections-instead/
• En 2013, Jonathan Allen donne quelques conseils pour la conception de bibliothèques asynchrones dans le monde .NET : http://www.infoq.com/articles/Async-API-Design
• Les Reactive Extensions (Rx) avc C# :
  • série d'articles par Muhammad Rehan Saeed :
    • http://rehansaeed.co.uk/reactive-extensions-part1-replacing-events/
    • http://rehansaeed.co.uk/reactive-extensions-part2-wrapping-events/
    • http://rehansaeed.co.uk/reactive-extensions-part3-naming-conventions/
    • http://rehansaeed.co.uk/reactive-extensions-part4-replacing-timers

La concurrence en D :

• http://www.informit.com/articles/printerfriendly.aspx?p=1609144
• http://davesdprogramming.wordpress.com/2011/04/07/7/
• texte de 2012 par Walter Bright sur D et la pureté : http://drdobbs.com/blogs/cpp/232601305 (il se trouve que D fait une forme d'inférence de pureté sur certaines fonctions pures mais qui ne l'indiquent pas par un mot clé... Concept intéressant!)

Erlang et la concurrence :

• http://www.algorithm.com.au/talks/concurrency-erlang/
• http://www.defmacro.org/ramblings/concurrency.html
• http://blog.ezyang.com/2010/08/tour-of-preach-distributed-erlang/
• les acteurs avec Erlang : http://www.javaworld.com/javaworld/jw-02-2009/jw-02-actor-concurrency1.html?page=1
• bases de programmation de systèmes répartis avec Erlang : http://learnyousomeerlang.com/distribunomicon
• selon Todd Hoff en 2006 (ou en 2007, c'est pas clair), Erlang serait la solution aux problèmes de multiprogrammation avec C++ : http://radio-weblogs.com/0103955/categories/stupidHumanProgramming/2006/12/25.html
• pourquoi Erlang performe-t-il souvent mieux avec un grand nombre de processus qu'il ne le fait quand le nombre de processus est restreint? Explication de Jesper Louis Anderson en 2013 : http://jlouisramblings.blogspot.dk/2013/01/how-erlang-does-scheduling.html

Concurrence avec F# (voir aussi les liens pour C# plus haut, étant donné que les deux partagent les mêmes outils) :

• quelques pièges des async avec C# (que l'on peut parfois escamoter avec F#) par Tomas Petricek en 2013 : http://tomasp.net/blog/csharp-async-gotchas.aspx

Parallélisme avec Haskell (voir aussi les collections concurrentes) :

• http://research.microsoft.com/en-us/um/people/simonpj/papers/ndp/ndp.pdf
• http://research.microsoft.com/apps/pubs/default.aspx?id=80976
• http://orbitz-erlang.blogspot.com/2009/09/impressed-with-haskells-concurrency.html
• http://chplib.wordpress.com/2009/10/07/concurrency-can-be-deterministic/
• http://raintown.org/?page_id=132
• http://www.haskell.org/~simonmar/papers/multicore-ghc.pdf
• http://community.haskell.org/~simonmar/slides/CUFP.pdf
• http://community.haskell.org/~simonmar/CEFP1.pdf
• présentation par Duncan Coutts en 2012 sur le parallélisme déterministe avec Haskell : http://www.well-typed.com/blog/75
• extraits de Beautiful Code : https://www.fpcomplete.com/user/simonpj/beautiful-concurrency
• livre en ligne de Simon Marlow en 2013 : http://chimera.labs.oreilly.com/books/1230000000929/index.html
• les async avec Haskell, par Ollie Charles en 2014 : http://ocharles.org.uk/blog/posts/2013-12-13-24-days-of-hackage-async.html

Avec Go :

• Distinguer concurrence et parallélisme, par Rob Pike en 2012 : http://vimeo.com/49718712
• Sérialiser des objets : http://www.jmcneil.net/2011/02/learning-go-and-serializing-objects-with-it-too/
• Programmation réseau selon Jan Newmarch en 2012 (texte en évolution) : http://jan.newmarch.name/go/
• Les goroutines : http://dalkescientific.com/writings/diary/archive/2009/11/15/100000_tasklets.html
• La concurrence avec Go :
  • http://soniacodes.wordpress.com/2011/03/15/concurrency-review/
  • expliquée par Stefan Nilsson en 2013 : http://www.nada.kth.se/~snilsson/concurrency/
  • expliquée par John Graham-Cumming en 2013 : http://fr.slideshare.net/jgrahamc/go-oncurrency
  • saines pratiques pour la concurrence avec Go, par Rob Pike en 2012 : http://talks.golang.org/2012/concurrency.slide#1
  • sa beauté, par Alexander Demin en 2012 : http://pragprog.com/magazines/2012-06/the-beauty-of-concurrency-in-go
  • de manière raisonnée, par Rob Miller en 2014 : https://blog.mozilla.org/services/2014/03/12/sane-concurrency-with-go/
• Enseigner les systèmes répartis avec Go, un texte de David Andersen en 2013 : http://da-data.blogspot.ca/2013/02/teaching-distributed-systems-in-go.html
• Comparatif des modèles de C++ 11 et de Go, avec un biais pro-Go, par Øyvind Teig en 2013 : http://www.teigfam.net/oyvind/home/technology/072-pike-sutter-concurrency-vs-concurrency/
• Gestion des piles des threads avec Go, selon Daniel Morsing en 2014 : http://blog.cloudflare.com/how-stacks-are-handled-in-go/

Avec Java :

• La synchronisation : http://tutorials.jenkov.com/java-concurrency/anatomy-of-a-synchronizer.html
• Être Thread-Safe avec Java :
  • texte de Bill Venners en 1998 : http://www.javaworld.com/javaworld/jw-08-1998/jw-08-techniques.html
  • texte de 1999 : http://www.javaworld.com/javaworld/javaqa/1999-04/01-threadsafe.html
• De nouvelles structures de contrôle pour le parallélisme  : http://www.artima.com/weblogs/viewpost.jsp?thread=240412
• http://www.ibm.com/developerworks/java/library/j-5things15/index.html?ca=drs-
• L'approche Fork/ Join avec Java 7 :
  • http://drdobbs.com/blogs/java/231000556
  • http://www.carfey.com/blog/java-7-forkjoin/
  • un Framework Fork/ Join pour Java, un peu plus ancien, par Doug Lea : http://gee.cs.oswego.edu/dl/papers/fj.pdf
• Éviter les ennuis : http://www.codeproject.com/KB/java/EffectiveJavaThreads.aspx
• Texte général de 2003 par Doug Lea : http://www.informit.com/articles/article.aspx?p=31539
• Bien utiliser Java sur des processeurs multi-coeurs, selon Jonas Bonér en 2009 : http://gcn.com/articles/2009/06/04/java-multicore-programming-tips.aspx
• Les Phaser, pour synchroniser le démarrage de tâches, selon Niklas Schlimm en 2011 : http://niklasschlimm.blogspot.com/2011/12/java-7-understanding-phaser.html
• Série d'articles sur la concurrence avec Java :
  • http://mlangc.wordpress.com/2009/11/27/series-about-java-concurrency-pt-1/
  • http://mlangc.wordpress.com/2009/12/06/series-about-java-concurrency-%E2%80%93-pt-2/
  • http://mlangc.wordpress.com/2011/05/10/series-about-java-concurrency-pt-3/
  • http://mlangc.wordpress.com/2011/05/19/series-about-java-concurrency-pt-4/
• Autre série d'articles sur la concurrence avec Java :
  • les sémaphores : http://www.carfey.com/blog/java-concurrency-part-1-semaphores/
  • verrous réentrants : http://www.carfey.com/blog/java-concurrency-part-2-reentrant-locks/
  • les regroupements de threads : http://www.carfey.com/blog/java-concurrency-part-3-thread-pools/
  • les futures avec Java : http://www.carfey.com/blog/java-concurrency-part-4-callable-future/
  • les files d'attente bloquantes : http://www.carfey.com/blog/java-concurrency-part-5-queues/
  • le compte à rebours : http://www.carfey.com/blog/java-concurrency-part-5-%E2%80%93-countdownlatch/
• Quelques outils propres à la programmation parallèle sous Java 7, par Alex Miller en 2009 : http://puredanger.com/tech/2009/11/15/jsr-166-concurrency-updates-hit-jdk-7/
• Selon Peter Lawrey en 2011, les exemples utilisés pour expliquer la concurrence en Java sont mélangeants : http://vanillajava.blogspot.com/2011/11/why-concurency-examples-are-confusing.html
• Présentation de Brian Goetz en 2011 sur le développement des λ en vue de Java 8 et sur les pratiques qui en résulteront en lien avec le parallélisme : http://blogs.oracle.com/briangoetz/resource/devoxx-lang-lib-vm-co-evol.pdf
• Synchronisation avec Java, par Agraj Mangal en 2013 : http://tech.pro/tutorial/1341/synchronization-in-java
• Passer de la programmation impérative aux Streams parallèles avec Java 8, texte de Raoul-Gabriel Urma et Mario Fusco en 2014 : http://www.infoq.com/articles/forkjoin-to-parallel-streams
• Implémenter et mesurer la vitesse d'exécution de threads légers sur la JVM, texte de 2014 : http://blog.paralleluniverse.co/2014/02/06/fibers-threads-strands/
• Comparer la vitesse d'exécution d'un accès synchronisé et d'un accès atomique avec Java 7, par Heinz M. Kabutz en 2014 : http://www.javaspecialists.eu/archive/Issue217.html
• Le sens du mot volatile en Java, selon Jeremy Manson en 2008 : http://jeremymanson.blogspot.ca/2008/11/what-volatile-means-in-java.html
• Quelques conseils de saine programmation concurrente avec Java, par Volkan Yazici en 2014 : http://vlkan.com/blog/post/2014/02/14/java-safe-publication/
• Comparatif d'AtomicLong et de LongAdder avec Java 7 et Java 8, par Nitsan Wakart en 2014 : http://psy-lob-saw.blogspot.sg/2014/06/jdk8-update-on-scalable-counters.html
• Variables ThreadLocal avec Java, par Jakob Jenkov : http://tutorials.jenkov.com/java-concurrency/threadlocal.html
• Intégrer du code Java à CUDA, par Tim Ellison en 2014 : http://devblogs.nvidia.com/parallelforall/next-wave-enterprise-performance-java-power-systems-nvidia-gpus/
• Série de textes par Benjamin Winterberg et portant sur la concurrence avec Java :
  • les threads et les exécuteurs, texte de 2015 : http://winterbe.com/posts/2015/04/07/java8-concurrency-tutorial-thread-executor-examples/
  • la synchronisation et les verrous, texte de 2015 : http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/
  • les ConcurrentMap et les variables atomiques, texte de 2015 : http://winterbe.com/posts/2015/05/22/java8-concurrency-tutorial-atomic-concurrent-map-examples/

Officiellement, il n'y a pas de threads en JavaScript, mais...

• http://www.neilmix.com/2007/02/07/threading-in-javascript-17/
• http://www.neilmix.com/demos/js17threading/Thread.js
• http://ejohn.org/blog/web-workers/
• http://scriptstoprograms.wordpress.com/2011/09/27/javascript-shared-state/
• La réflexion menant vers le parallélisme en JavaScript se poursuit. Un texte de Nicholas D. Matsakis en 2012 : http://smallcultfollowing.com/babysteps/blog/2012/01/09/parallel-javascript/
• Le code asynchrone en JavaScript, par Jonathan Creamer en 2013 : http://net.tutsplus.com/tutorials/javascript-ajax/event-based-programming-what-async-has-over-sync/
• Boucle de jeu asynchrone en JavaScript, selon Casper Beyer en 2014 : http://caspervonb.github.io/2014/02/24/javascript-game-development-asynchronous-execution-loop.html
• JavaScript et les promesses :
  • texte de Bryan Klimt en 2013 : http://blog.parse.com/2013/01/29/whats-so-great-about-javascript-promises/
  • description détaillée par Jake Archibald en 2013 : http://www.html5rocks.com/en/tutorials/es6/promises/#!
  • texte détaillé de Matt Greer en 2014 : http://mattgreer.org/articles/promises-in-wicked-detail/
  • promesses ou rappels (Callbacks)? Une réflexion sur l'approche choisie par Node.js :
    • l'opinion de James Coglan en 2013 : http://blog.jcoglan.com/2013/03/30/callbacks-are-imperative-promises-are-functional-nodes-biggest-missed-opportunity/
    • une réplique de Mikeal Rogers en 2013 : http://www.futurealoof.com/posts/broken-promises.html
    • description des promesses en JavaScript, par Joe Zimmerman en 2013 : http://www.kendoui.com/blogs/teamblog/posts/13-03-28/what-is-the-point-of-promises.aspx
    • survol succinct par Martin Fowler en 2013 : http://martinfowler.com/bliki/JavascriptPromise.html

Avec Objective-C :

• Texte de Mike Ash en 2012 sur l'interblocage et l'ordonnancement des verrous : http://www.mikeash.com/pyblog/deadlocks-and-lock-ordering-a-vignette.html

Avec Perl :

• Il semble que l'extension nommée Perl Data Language bénéficie d'un parallélisme automatique, selon ce texte de 2012 : http://www.h-online.com/open/news/item/Perl-Data-Language-gets-auto-parallelisation-1430053.html

Réflexions sur la multiprogrammation avec Python :

• http://www.artima.com/weblogs/viewpost.jsp?thread=299551
• Le Global Interpreter Lock (GIL)  :
  • http://dabeaz.blogspot.com/2010/01/python-gil-visualized.html
  • http://www.grouplens.org/node/244
  • http://www.dabeaz.com/python/GIL.pdf
  • http://mail.python.org/pipermail/python-dev/2011-August/112813.html
  • comment tuer le GIL, un texte d'Armin Ringo en 2011 : http://morepypy.blogspot.com/2011/06/global-interpreter-lock-or-how-to-kill.html
  • selon Jeff Knupp en 2012, il s'agit du plus gros problème de ce langage : http://www.jeffknupp.com/blog/2012/03/31/pythons-hardest-problem/
• Python et les coroutines :
  • texte de David Beazley en 2009 : http://www.dabeaz.com/coroutines/Coroutines.pdf
  • utiliser async et await avec Python 3.5, par Brett Cannon en 2016 : http://www.snarky.ca/how-the-heck-does-async-await-work-in-python-3-5
• Programmer avec plusieurs threads sous Python, par Al Sweigart en 2013 : http://inventwithpython.com/blog/2013/04/22/multithreaded-python-tutorial-with-threadworms/
• Les options de multiprogrammation offertes avec Python, par Martin Konecny en 2013 : http://www.devmusings.com/blog/2013/05/23/python-concurrency/
• Selon Chris Kiehl en 2014, le plus gros problème quant à la multiprogrammation avec Python n'est pas tant technique que pédagogique : https://medium.com/building-things-on-the-internet/40e9b2b36148

Parallélisme avec R :

• http://blog.revolutionanalytics.com/2011/03/parallel-processing-in-r-for-windows.html

Multiprogrammation avec Ruby :

• http://yehudakatz.com/2010/08/14/threads-in-ruby-enough-already/
• http://merbist.com/2011/02/22/concurrency-in-ruby-explained/
• Le Global Interpreter Lock (GIL) :
  • http://merbist.com/2011/10/03/about-concurrency-and-the-gil/
• http://blog.carbonfive.com/2011/10/11/a-modern-guide-to-threads/
• Que font vos processus Ruby? Texte de Tomas Varaneckas en 2014 : http://varaneckas.com/blog/ruby-tracing-threads-unicorn/

Concurrence avec Rust :

• Approcher la concurrence à l'aide de Rust mais sans avoir peur, texte d'Aaron Turon en 2015 : http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html

Parallélisme avec Scala :

• Article critique de Cedric Beust en 2011 : http://beust.com/weblog/2011/08/15/scalas-parallel-collections/

Parallélisme avec Swift :

• Texte de 2014 mettant de l'avant que les tableaux de Swift ne sont pas Thread-Safe : http://blog.human-friendly.com/swift-arrays-are-not-threadsafe
• Écrire des collections parallèles avec Swift, un texte de 2015 : http://moreindirection.blogspot.ca/2015/07/gcd-and-parallel-collections-in-swift.html

Multiprogrammation avec VB.NET :

• Introduction par Justin James en 2006 : http://www.techrepublic.com/blog/programming-and-development/multithreading-tutorial-part-one-introduction/79

Outils et API

La populaire API qu'est OpenMP est sommairement décrite ici : ../Sujets/Parallelisme/OpenMP.html

Un survol de la bibliothèque Threading Building Blocks, ou TBB, est offert ici : ../Sujets/Parallelisme/TBB.html

La technologie Ct, de Intel, se présente comme une API pour C++ et se concentre sur le parallélisme des données : http://software.intel.com/en-us/data-parallel/

Un survol de la technologie MPI, pour Message Passing Interface, un standard de facto du monde des calculs à haute performance (HPC, pour High Performance Computing) est offert sur ../Sujets/Parallelisme/MPI.html

Le projet PSTL, pour Parallel STL : http://www.extreme.indiana.edu/hpc++/docs/overview/class-lib/PSTL/ (ce projet est rendu quelque peu caduque du fait que la bibliothèque standard de C++ offre des algorithmes parallèles depuis C++ 17)

Le projet STAPL, pour Standard Template Adaptive Parallel Library, développé à l'Université du Texas (en partie par Bjarne Stroustrup) : https://parasol.tamu.edu/groups/rwergergroup/research/stapl/

Le Parallel Studio d'Intel : http://software.intel.com/en-us/articles/intel-parallel-studio-home/

Les collections concurrentes proposées par Intel :

• Pour C++ : http://software.intel.com/en-us/articles/intel-concurrent-collections-for-cc/
• Pour Haskell :
  • http://software.intel.com/en-us/blogs/2010/05/27/announcing-intel-concurrent-collections-for-haskell-01/
  • http://software.intel.com/en-us/blogs/2010/06/01/a-tour-of-haskell-cnc-schedulers/
  • http://software.intel.com/en-us/blogs/2010/06/03/new-haskell-cnc-release-013-adds-parallel-for-loops/
  • http://software.intel.com/en-us/blogs/2010/06/07/parallel-performance-in-intel-concurrent-collections-for-haskell-an-in-depth-example/

L'extension Cilk Plus d'Intel, pour C et C++ :

• http://software.intel.com/en-us/articles/intel-cilk-plus/
• le projet est maintenant à code ouvert : http://software.intel.com/en-us/articles/intel-cilk-plus-open-source/

Le projet GNU UPC (pour Unified Parallel C) : http://gcc.gnu.org/projects/gupc.html

Une nouvelle approche sous MacOS X, nommée le Grand Central Dispatch :

• http://developer.apple.com/mac/library/documentation/Performance/Reference/GCD_libdispatch_Ref/Reference/reference.html
• http://en.wikipedia.org/wiki/Grand_Central_Dispatch
• http://www.devwhy.com/blog/2009/8/28/grand-central-dispatch.html
• http://stackoverflow.com/questions/1368875/why-should-i-use-grand-central-dispatch-over-openmp
• http://www.informit.com/articles/article.aspx?p=1433057
• http://libdispatch.macosforge.org/
• http://www.artima.com/forums/flat.jsp?forum=270&thread=267041

La bibliothèque Boost.InterProcess, pour communication entre processus : http://www.boost.org/doc/libs/1_39_0/doc/html/interprocess.html

Le compilateur Sieve est un moteur prenant en charge la parallélisation du code C++. Pour quelques articles sur le sujet, voir :

• http://www.sdtimes.com/article/LatestNews-20071115-01.html
• http://www.codeplay.com/customcompilers/multi-core.html
• http://www.cs.cmu.edu/%7Edamp/finalPapers/lindley.pdf

Performance des entrées/ sorties asynchrones de Java :

• http://www.thebuzzmedia.com/java-io-faster-than-nio-old-is-new-again/
• http://download.oracle.com/javase/1.4.2/docs/api/java/nio/channels/Selector.html

Bibliothèque s4, pour les calculs répartis sur des flux :

• http://s4.io/

Les threads et Qt :

• http://labs.trolltech.com/blogs/2010/06/17/youre-doing-it-wrong

Parallélisme et technologies Microsoft :

• http://msdn.microsoft.com/fr-fr/concurrency/default%28en-us%29.aspx
• http://www.codeproject.com/KB/cpp/parallelcpp.aspx (article du Code Project; technologie pour C++, mais propriétaire à Microsoft)
• Le Concurrency Runtime :
  • http://msdn.microsoft.com/en-us/library/dd504870.aspx
  • http://blogs.msdn.com/b/nativeconcurrency/archive/2011/03/09/tasks-and-continuations-available-for-download-today.aspx
  • les exceptions : http://msdn.microsoft.com/library/dd997692.aspx
• La bibliothèque CCR pour réaliser du parallélisme avec les programmes .NET :
  • http://msdn.microsoft.com/en-us/library/bb648752.aspx
• Le parallélisme avec .NET 4 (article du Code Project, alors restez alerte).
  • http://www.codeproject.com/KB/threads/_net_4_parallel.aspx
• Au sujet de la Task Parallel Library (TPL) de .NET :
  • http://research.microsoft.com/pubs/77368/TheDesignOfATaskParallelLibrary%28oopsla2009%29.pdf
  • http://www.codeproject.com/KB/Parallel_Programming/Tasks.aspx
  • http://www.codeproject.com/KB/cs/Tasks5.aspx
  • un texte de Kevin Pelgrims en 2011 : http://kevinpelgrims.wordpress.com/2011/12/16/parallel-programming-in-net-task-parallel-library/
  • les responsabilités de l'ordonnanceur de TPL, un texte de Brent Scriver en 2012 : http://www.oneoddsock.com/blog/2012/09/25/two-responsibilities-in-the-net-tpl-scheduler-class/
• Au sujet de la bibliothèque d'agents asynchrones :
  • http://blogs.microsoft.co.il/blogs/alon/archive/2011/04/02/c-renaissance-the-asynchronous-agents-library.aspx
  • http://msdn.microsoft.com/library/dd492627.aspx#Y1216
• Vous trouverez un survol de programmation avec la Parallel Pattern Library de Microsoft sur ../Sujets/Parallelisme/PPL.html

Outils GNU :

• Outils à la ligne de commande, permettant une exécution en parallèle : http://savannah.gnu.org/projects/parallel
• Une bibliothèque portable de threads, nommée nPth : http://lwn.net/Articles/496268/

Paralléliser des tâches avec xargs : http://www.spinellis.gr/blog/20090304/

L'appel système fork() : ../Sujets/Parallelisme/Bref-fork.html

Le compilateur par4all, voué à la parallélisation automatique de programmes Fortran et C :

• http://www.par4all.org/
• http://www.par4all.org/features/

SIMD (Single Instruction, Multiple Data)

Une instruction SIMD traite plusieurs données d'un seul coup. Lorsqu'un algorithme est écrit de manière à traiter une vaste quantité de données de manière semblable, le recours à des instructions SIMD peut réduire le temps de calcul de manière significative.

Faire des calculs avec des instructions SIMD ::

• Textes de 2013 :
  • www.gamedev.net/page/resources/_/technical/general-programming/practical-cross-platform-simd-math-r3068
  • http://www.gamedev.net/page/resources/_/technical/game-programming/practical-cross-platform-simd-math-part-2-r3101
• Un guide proposé par Tom Mesani : http://www.tommesani.com/Docs.html
• La bibliothèque Sierra, pour C++, destinée à ce type de calcul : http://sierra-lang.org/
• Programmer en fonction d'un SIMD 64 bits avec C#, par Gastón Hillar : http://www.drdobbs.com/windows/64-bit-simd-code-from-c/240168851
• En 2015, Daniel Lemire propose d'avoir recours à des opérations SIMD pour accélérer la détection de collisions : http://lemire.me/blog/archives/2015/03/25/accelerating-intersections-with-simd-instructions/
• En 2015, Intel propose une série de Wrappers pour faciliter le recours à des instructions SIMD : https://software.intel.com/en-us/articles/easy-simd-through-wrappers
• Instructions SIMD et langage Rust, un projet relaté par Huon Wilson en 2015 : http://huonw.github.io/blog/2015/08/simd-in-rust/
• Évaluation des modèles de programmation SIMD existants en C++, proposée par Angela Pohl, Biagio Cosenza, Mauricio Alvarez Mesa, Chi Ching Chi et Ben Juurlink en 2016 : http://www.biagiocosenza.com/papers/PohlWPMVP16.pdf
• Décoder plus rapidement les données d'un dictionnaire à l'aide d'instructions SIMD, par Daniel Lemire en 2016 : http://lemire.me/blog/2016/08/25/faster-dictionary-decoding-with-simd-instructions/

Structure d'une instruction SIMD, par Arvid Gerstmann en 2016 : https://arvid.io/2016/12/09/simd-instruction-format/

Risques

La multiprogrammation est un jouet pour grandes personnes, porteur d'un grand nombre de risques qui lui sont propres. Plusieurs font partie de la grande famille des des conditions de course et sont répertoriées sur : ../Sujets/Parallelisme/Bref-conditions-course.html

Pour un survol de quelques-uns des principaux risques associés à la multiprogrammation, voir ce texte de 2014 par Austin G. Walters : http://austingwalters.com/multithreading-common-pitfalls/

Joe Duffy, en 2010, explique les limites de readonly avec .NET : http://www.bluebytesoftware.com/blog/2010/07/01/WhenIsAReadonlyFieldNotReadonly.aspx

Certaines API ne passent pas bien le cap de la multiprogrammation.

• À propos de memcpy() en situation de concurrence : http://blogs.oracle.com/dave/entry/memcpy_concurrency_curiosities
• À propos de la fonction close() de POSIX, par Colin Percival en 2011 : http://www.daemonology.net/blog/2011-12-17-POSIX-close-is-broken.html

Résoudre 11 problèmes dans du code multiprogrammé sous .NET, selon Joe Duffy en 2008 :

• http://msdn.microsoft.com/en-au/magazine/cc817398.aspx

Synchronisation et partage des ressources

Pour les questions de synchronisation, voir ../Sujets/Parallelisme/Synchronisation.html

Algorithmes

Quelques algorithmes bien connus dans le monde de la synchronisation en situation de multiprogrammation (la plupart des liens qui suivent mènent sur des sites Wiki) :

• L'attente active, à la base des Spin Locks, qui est à la fois très efficace et très inefficace selon les points de vue et les besoins : http://en.wikipedia.org/wiki/Busy-wait;
• L'algorithme de Dekker, qui vise l'exclusion mutuelle pour une section critique de code : http://en.wikipedia.org/wiki/Dekker%27s_algorithm;
  • pour une implémentation de l'algorithme de Dekker à l'aide des barrières de C++ 11, voir ce texte d'Anthony Williams en 2010 : http://www.justsoftwaresolutions.co.uk/threading/implementing_dekkers_algorithm_with_fences.html
• L'algorithme de Peterson, qui vise aussi l'exclusion mutuelle pour une section critique de code : http://en.wikipedia.org/wiki/Peterson%27s_algorithm;
• Dans la même veine, l'algorithme du boulanger, de Leslie Lamport : http://en.wikipedia.org/wiki/Lamport%27s_bakery_algorithm (le texte original peut être consulté ici : http://research.microsoft.com/en-us/um/people/lamport/pubs/bakery.pdf)
• Les approches non-bloquantes à la synchronisation.
• Mise à jour concurrente d'une liste : http://www.tbray.org/ongoing/When/201x/2010/07/13/Lock-Free-Array-Update
• Détection de conditions stables, incluant les interblocages (Deadlocks), dans un système réparti : http://userweb.cs.utexas.edu/users/misra/scannedPdf.dir/DistrDeadlockDetection.pdf

Atomicité

J'ai regroupé des informations sur ce sujet dans ../Sujets/Parallelisme/Bref-atomiques-primitives.html

Pour le cas plus précis des opérations Compare and Swap (CAS), voir ../Sujets/Parallelisme/Bref-atomiques-primitives.html#xchg pour des détails.

Exceptions

Exceptions et le Concurrency Runtime de Microsoft :

• http://msdn.microsoft.com/library/dd997692.aspx

Faux partage

Le contenu de cette section a été déplacé dans une page à part entière : ../Sujets/Parallelisme/FauxPartage.html

Noyau d'un système d'exploitation

Dans le monde du noyau de Linux :

• Une description des mémoires partagées, utile entre autres pour la conception de machines virtuelles : http://www.ibm.com/developerworks/linux/library/l-kernel-shared-memory/index.html
• Comment s'y déroulent les opérations de synchronisation : http://www.linuxjournal.com/article/5833
• Une description des outils de synchronisation : http://www.ibm.com/developerworks/linux/library/l-linux-synchronization.html
• Les clôtures-mémoire sous Linux :
  • http://lxr.linux.no/#linux+v2.6.35/Documentation/memory-barriers.txt
  • http://www.kernel.org/doc/Documentation/memory-barriers.txt
  • http://www.linuxjournal.com/article/8211
  • http://lxr.linux.no/linux/Documentation/memory-barriers.txt (très complet)
  • http://www.rdrop.com/users/paulmck/scalability/paper/ordering.2007.09.19a.pdf
• Texte de 2014 par Vita Loginova expliquant la multiprogrammation dans le noyau de Linux : http://kukuruku.co/hub/opensource/multitasking-management-in-the-operating-system-kernel
• En 2015, Vita Loginova explique les WorkQueues : http://kukuruku.co/hub/nix/multitasking-in-the-linux-kernel-workqueues
• Interruptions et Tasklets, expliquées par Vita Loginova en 2015 : http://kukuruku.co/hub/nix/multitasking-in-the-linux-kernel-interrupts-and-tasklets

Il semble que le noyau de Linux souffre (ou, du moins, ait souffert) d'une synchronisation sur la base d'un « gros verrou », si on se fie à cet article de Jeremy Andrews en 2008 : http://kerneltrap.org/Linux/Removing_the_Big_Kernel_Lock

Optimisation et règles

• Pour une réflexion sur les points de séquencement en C++, voir http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1944.htm
• Pour un texte de Hans Boehm sur les contraintes de réordonnancement et les verrous POSIX, voir http://www.hpl.hp.com/techreports/2005/HPL-2005-217R1.html
• Échelonnabilité et partage de mémoire (article du Code Project, alors prudence...) : http://www.codeproject.com/kb/cpp/rtl_scaling.aspx
• Texte de Jeff Preshing en 2012 sur le réordonnancement des instructions par le compilateur et sur l'introduction de clôtures dans le code pour garantir le maintien d'une cohérence interne dans les programmes : http://preshing.com/20120625/memory-ordering-at-compile-time
• Texte de Jeff Preshing en 2012 décrivant un processeur dit « faiblement ordonnancé » : http://preshing.com/20121019/this-is-why-they-call-it-a-weakly-ordered-cpu

Outils

Quelques outils de synchronisation bien connus sont brièvement décrits dans les sections ci-dessous.

Futex

J'ai regroupé les textes sur ce sujet dans ../Sujets/Parallelisme/Synchronisation.html#avec_verrou

Futures

J'ai regroupé les textes sur ce sujet dans ../Sujets/Parallelisme/futures.html

Mémoire partagée

Le partage brut de mémoire est une approche traditionnellement utilisée pour les échanges à débit rapide entre processus et entre threads. Cela dit, un échange aussi direct comporte des risques.

• Une description des mémoires partagées dans le noyau de Linux, utile entre autres pour la conception de machines virtuelles : http://www.ibm.com/developerworks/linux/library/l-kernel-shared-memory/index.html
• Étude des modèles de cohérence des mémoires partagées, par Sarita V. Adve et Kourosh Gharachorloo en 1995 : http://www.hpl.hp.com/techreports/Compaq-DEC/WRL-95-7.pdf
• Proposition faite en vue du standard C++ 11 pour un modèle officiel de Memory-Mapped File (qui n'a pas été retenue, mais demeure intéressante pour fins de réflexion) par Ion Gaztañaga en 2006 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2044.html
• Proposition de technique pour partager une donnée avec peu de synchronisation, en transférant non pas la donnée mais le privilège d'y accéder à travers une indirection (un pointeur intelligent), par Mark Lee en 2012 : http://altdevblogaday.com/2012/01/11/safer-data-sharing-between-threads/

Mémoire transactionnelle

J'ai regroupé les lies et les textes à ce sujet dans ../Sujets/Parallelisme/memoire_transactionnelle.html

Moniteurs

Terme général pour désigner un objet susceptible d'être manipulé en toute sécurité de manière concurrente par plusieurs threads.

Un Wiki : http://en.wikipedia.org/wiki/Monitor_%28synchronization%29

Sections critiques, sémaphores, mutex

J'ai regroupé les textes sur ce sujet dans ../Sujets/Parallelisme/Synchronisation.html#avec_verrou

Pratiques

En 2007, Herb Sutter nous rappelle qu'il ne faut pas appeler de code dont on ne connaît pas l'implémentation à l'intérieur d'une section critique : http://www.drdobbs.com/architecture-and-design/202802983?greturn=true&greturn=true

En 2009, Chris Forbes explique qu'à son avis, l'idéal est de s'assurer que tout thread puisse être suspendu au moment opportun : http://blogs.ijw.co.nz/chris/index.php/2009/04/theres-a-third-hard-thing-about-concurrency/

Une technique de partage de données entre threads à partir de transfert de responsabilité, proposée par Mark Lee en 2012 : http://www.altdevblogaday.com/2012/01/11/safer-data-sharing-between-threads/

Dans ce texte de 2012, Bruce Dawson nous rappelle que l'attente active (Busy Waiting) est rarement une bonne idée d'un point de vue performance, consommation d'énergie, équilibre systémique, etc. : http://randomascii.wordpress.com/2012/06/05/in-praise-of-idleness/

Structures de données

Quelques structures de données pensées pour les programmes concurrents, un texte d'Arpan Sen en 2012 : http://www.ibm.com/developerworks/aix/library/au-multithreaded_structures1/index.html

Files asynchrones pour des tâches, par Richard Bone en 2012 : http://99designs.com/tech-blog/blog/2012/02/17/async-task-queues/

Collections immuables sous C# avec opérations en temps constant :

• Une proposition de Craig Gidney en 2013 : http://twistedoakstudios.com/blog/Post2096_making-an-immutable-queue-with-guaranteed-constant-time-operations
• http://blogs.msdn.com/b/dotnet/archive/2013/09/12/immutable-collections-are-now-rc.aspx
• Texte de John Allen en 2013 : http://www.infoq.com/news/2013/09/Immutables

Temps

Un texte fondamental sur la question de la synchronisation et du temps, qu'on m'a fait lire quand j'étais étudiant :

• http://research.microsoft.com/users/lamport/pubs/time-clocks.pdf

Comprendre les horloges vectorielles (Vector Clocks) :

• http://blog.basho.com/2010/01/29/why-vector-clocks-are-easy/
• http://blog.basho.com/2010/04/05/why-vector-clocks-are-hard/

Le temps sous Microsoft Windows, de l'avis de Joseph M. Newcomer en 2011 : http://www.flounder.com/time.htm

Dossiers divers

Quelques considérations diverses sur la multiprogrammation et la synchronisation, pêle-mêle.

Déboguer et tester

La littérature sur les tests et le débogage des systèmes multiprogrammés est encore en période de maturation, mais un bref aperçu de la raison pour laquelle les tests unitaires ne suffisent pas en ce sens peut être trouvée sur : http://www.artima.com/lejava/articles/javaone_2008_andy_chou.html

Certains tests nous révèlent des optimisations qui, au fond, n'en sont pas vraiment : http://antirez.com/post/fsync-different-thread-useless.html

Provoquer des bogues de concurrence (texte de 2011) : http://blog.corensic.com/2011/08/22/accelerating-concurrency-bugs/

On trouve parfois des bogues de concurrence à des endroits surprenants ou inattendus, par exemple lors de la finalisation des objets, comme en atteste ce texte de 2012 : http://wingolog.org/archives/2012/02/16/unexpected-concurrency

Gestion de la mémoire

Pour plus d'articles sur ce sujet, voir Gestion-memoire--Liens.html

• http://www.ece.ncsu.edu/arpers/Papers/MMT_IPDPS10.pdf