Gestion de la mémoire – quelques liens

Vous trouverez ci-dessous quelques liens pertinents quant à la gestion de la mémoire.

Thématiques générales

Référence généraliste sur le sujet : http://www.memorymanagement.org/

Description d'approches spécialisées mises en application chez Facebook : http://www.facebook.com/notes/facebook-engineering/scalable-memory-allocation-using-jemalloc/480222803919

Un modèle théorique d'abstraction de l'allocation de la mémoire : http://research.microsoft.com/apps/pubs/default.aspx?id=67821

Ce que tout programmeur devrait savoir sur la mémoire, par Ulrich Drepper en 2007 : http://lwn.net/Articles/250967/ ou, en format PDF, http://www.akkadia.org/drepper/cpumemory.pdf

Être Memory-Safe :

• Que signifie être Memory-Safe? Texte de Michael Hicks en 2014 : http://www.pl-enthusiast.net/2014/07/21/memory-safety/
• La Memory-Safety de manière non-transparente, par John Regehr en 2014 : http://blog.regehr.org/archives/1175

L'allocation de la mémoire sous Linux :

• http://www.linuxjournal.com/article/6390
• http://neugierig.org/software/blog/2011/05/memory.html
• La règle du Too Small to Fail, décrite en 2014 par Jonathan Corbet : https://lwn.net/Articles/627419/
• En 2015, Jonathan Corbet explique comment gérer l'allocation dynamique de mémoire quand échouer n'est tout simplement pas une option : http://lwn.net/Articles/635354/
• Série d'articles sur la gestion de la mémoire en langage C avec accent Linux, par Florent Bruneau en 2013 :
  • les types de mémoire (virtuelle, partagée, privée, etc.) : hhttps://techtalk.intersec.com/2013/07/memory-part-1-memory-types/
  • la mémoire dans un processus : https://techtalk.intersec.com/2013/07/memory-part-2-understanding-process-memory/
  • gérer la mémoire : https://techtalk.intersec.com/2013/08/memory-part-3-managing-memory/
  • allocateurs maison, car malloc() n'est pas la solution à tous les maux :
    • https://techtalk.intersec.com/2013/10/memory-part-4-intersecs-custom-allocators/
    • https://techtalk.intersec.com/2013/12/memory-part-5-debugging-tools/
    • https://techtalk.intersec.com/2014/09/memory-part-6-optimizing-the-fifo-and-stack-allocators/
  • Outils de débogage : https://techtalk.intersec.com/2013/12/memory-part-5-debugging-tools/

Gestion de la mémoire sous Microsoft Windows :

• Partage de la mémoire : http://my.opera.com/Tringi/blog/conservative-variable-size-memory-sharing
• Allouer un bloc de mémoire qui peut croître en taille, texte de Raymond Chen en 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/01/30/10589818.aspx

Gestion de la mémoire en langage C :

• À propos de la vénérable fonction malloc(), du langage C :
  • texte de Poul-Henning Kamp, proposant une étude critique de cette fonction : http://phk.freebsd.dk/pubs/malloc.pdf
  • discussion de la gestion de la fragmentation de la mémoire : http://t-t-travails.blogspot.com/2009/05/mr-malloc-gets-schooled.html
  • parfois, la question de la quantité de swap space disponible redevient importante : http://blogs.nologin.es/slopez/archives/28-Sometimes,-swap-space-still-matters.html
  • sous Linux, malloc() n'échoue essentiellement jamais, du moins pas pour les raisons que l'on pourrait supposer au préalable. Une explication d'Alexandru Scvorţov en 2012 : http://www.scvalex.net/posts/6/
  • combien de bytes sont réellement alloués lors d'un appel à malloc(0), et pourquoi?
    • brève mais pertinente analyse de James Hague en 2013 : http://prog21.dadgum.com/179.html
    • texte de 2015 : http://www.tedunangst.com/flak/post/zero-size-objects
  • en 2013, Julia Evans fait le constat que programmer un noyau de système d'exploitation signifie programmer sans malloc(), ce mécanisme n'était pas disponible a priori : http://jvns.ca/blog/2013/12/03/day-36-programming-without-malloc/
  • la version de malloc() implémentée par glibc, texte de 2015 : https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/
  • implémenter une version « maison » de malloc(), texte de 2015 par Dmitry Geurkov : http://troydm.github.io/blog/2015/08/03/lifting-shadows-off-a-memory-allocation/
  • en 2015, Xian Wei nous rappelle qu'il se peut que malloc() ne se comporte pas comme vous le croyez : http://iarchsys.com/?p=764
• À propos de realloc() :
  • histoire de realloc() et de paresse, relatée par Xavier Roche en 2014 : http://blog.httrack.com/blog/2014/04/05/a-story-of-realloc-and-laziness/
  • pourquoi appeler realloc(p,0) mène à du code non-portable, selon Colin Percival en 2016 : https://github.com/Tarsnap/libcperciva/commit/cabe5fca76f6c38f872ea4a5967458e6f3bfe054
• Ce que toute programmeuse et tout programmeur C devrait savoir sur la mémoire, selon Marek Vavrusa en 2015 : http://marek.vavrusa.com/c/memory/2015/02/20/memory/
• Comment initialiser une structures de données allouée dynamiquement en langage C, une approche proposée par Leandro Pereira en 2015 : http://tia.mat.br/blog/html/2015/05/01/initializing_a_heap_allocated_structure_in_c.html

Spécifique à C++ :

• Survol de techniques de base quant à la gestion de la mémoire avec C++, texte pour débutants par Kacper Kolodziej en 2015 : https://kacperkolodziej.com/articles/programming/272-fighting-off-memory-leaks-and-errors-cpp11.html
• Technique pour définir des pointeurs intelligents à sémantique de partage tout en évitant les irritants associés aux références cycliques, proposée par Achilleas Margaritis  : http://www.codeproject.com/KB/cpp/newcppmm.aspx
• Étude de Herb Sutter sur la consommation de mémoire selon les conteneurs standards : http://www.gotw.ca/publications/mill14.htm
• À propos des allocateurs : #allocateur
• Gestion de la mémoire allouée dynamiquement dans les jeux vidéos, une série de propositions par Jean-François Dubé (d'Ubisoft Montréal) :
  • http://jfdube.wordpress.com/2011/10/03/memory-management-part-1-introduction/
  • http://jfdube.wordpress.com/2011/10/06/memory-management-part-2-allocations-tracking/
  • http://jfdube.wordpress.com/2011/10/22/memory-management-part-3-memory-allocators-design/
• Pour un survol de divers mécanismes de gestion de mémoire allouée dynamiquement avec C++ 11, voir cet extrait d'un volume de Stanley B. Lippman, Josée LaJoie, Barbara E. Moo en 2012 : http://www.informit.com/articles/article.aspx?p=1944072
• Services de gestion de la capacité d'un std::vector :
  • la méthode shrink_to_fit(), texte de 2013 par Jon Kalb : http://www.slashslash.info/2013/11/capacity-members-for-vector-shrink_to_fit/
  • la méthode reserve(), texte de 2013 par Jon Kalb : http://www.slashslash.info/2013/11/capacity-members-for-vector-reserve/
• Le modèle par défaut d'allocation dynamique de mémoire est-il aussi mauvais pour les petits objets que ne le prétend la littérature? En 2014, Evgeny Lazin affirme que bien que ça ait pu être le cas par le passé, ce ne l'est plus aujourd'hui : http://evgeny-lazin.blogspot.ru/2014/11/c-myths-debunking-part-1.html
• Ce texte d'Arne Mertz en 2015 rappelle qu'en C++, il est généralement mal venu d'allouer dynamiquement des objets dont la portée est locale à une fonction : http://arne-mertz.de/2015/01/heap-allocation-of-local-variable/
• Organiser les données pour gagner en efficacité, textes de 2015 :
  • http://bitsquid.blogspot.se/2015/06/allocation-adventures-1-datacomponent.html
  • http://bitsquid.blogspot.sg/2015/06/allocation-adventures-2-arrays-of-arrays.html
  • http://bitsquid.blogspot.se/2015/08/allocation-adventures-3-buddy-allocator.html
• En l'absence de collecte d'ordures, et surtout du fait que les programmes ont directement accès aux adresses en mémoire de leurs objets, les programmes C++ qui ont recours à l'allocation dynamique de mémoire tendent à provoquer une fragmentation de la mémoire. À ce sujet, texte de Tony Da Silva en 2015 : http://bulldozer00.com/2015/06/01/holier-than-thou/
• Comprendre le new positionnel (Placement New), texte de Joe Ruether en 2015 : http://jrruethe.github.io/blog/2015/08/23/placement-new/

Commun à C et à C++ :

• Extensions matérielles proposées sur plateforme Intel pour couvrir les programmes C ou C++ qui se comporteraient incorrectement : http://software.intel.com/en-us/articles/introduction-to-intel-memory-protection-extensions
• En 2014, Kevin Dungs discute de la gestion de la mémoire d' une bibliothèque C à même du code C++ : https://dun.gs/posts/2014-11-06-c-cpp-memory.html
• L'allocateur JEMalloc, et quand l'utiliser si un serveur, riche en ressources, en vient à manquer de mémoire dû à une fragmentation de la mémoire... Cas vécu et analyse, le tout présenté par Psi Mankoski en 2015 : http://highscalability.com/blog/2015/3/17/in-memory-computing-at-aerospike-scale-when-to-choose-and-ho.html

Gestion de la mémoire avec D :

• Comme le rappelle Matt Kline en 2015, D supporte la collecte automatique d'ordures mais dans ce langage, il existe d'autres options : http://bitbashing.io/time-for-d-to-own-up.html

Gestion de mémoire avec Erlang :

• Pourquoi la gestion de la mémoire est une préoccupation importante, même en Erlang, par Marek Majkowski en 2010 : http://www.lshift.net/blog/2010/02/28/memory-matters-even-in-erlang/?repost=HN

Gestion de mémoire avec JavaScript :

• Texte d'Alex MacCaw en 2013 : http://blog.alexmaccaw.com/jswebapps-memory-management

Spécifique à Objective-C :

• Texte proposé par l'équipe de Clang et décrivant en détail le comptage automatique de références avec Objective-C : http://clang.llvm.org/docs/AutomaticReferenceCounting.html

Gestion de la mémoire sous .NET, autre que la collecte d'ordures :

• Où sont placés les diverses sortes d'objets d'un programme? Texte de Jon Skeet : http://www.yoda.arachsys.com/csharp/memory.html
• Comment améliorer le traitement et la gestion des gros objets? Texte du Code Project par Michael Balloni en 2015 : http://www.codeproject.com/Tips/894885/Improving-on-NET-memory-management-for-large-objec

Gestion de la mémoire avec Rust :

• En 2015, Nicholas D. Matsakis disserte sur le comptage de références et les fuites : http://smallcultfollowing.com/babysteps/blog/2015/04/29/on-reference-counting-and-leaks/

Gérer la croissance des tampons dynamiques :

• En 2014, Nicholas Nethercote recommande des stratégies de croissance exponentielle (typiquement : doubler la capacité à chaque réallocation) pour le code exécuté par Firefox : https://blog.mozilla.org/nnethercote/2014/11/04/please-grow-your-buffers-exponentially/

La gestion de la mémoire entraîne des coûts qui peuvent ne pas sembler évidents de prime abord :

• Texte de Bruce Dawson en 2014 : http://randomascii.wordpress.com/2014/12/10/hidden-costs-of-memory-allocation/
• Suivi détaillé par Arseny Lapoulkine en 2014 : http://zeuxcg.org/2014/12/21/page-fault-queue/

Gérer la mémoire à l'échelle d'un programme monstrueux comme Gmail, un texte de John McCutchan et Loreena Lee en 2013 : http://www.html5rocks.com/en/tutorials/memory/effectivemanagement/

Visualiser l'allocation dynamique de mémoire dans un programme de grande envergure, par Rich Geldreich en 2015 : http://richg42.blogspot.ca/2015/03/graphing-heap-memory-allocations.html

Qu'est-ce que le taux d'allocation d'un programme, et comment en tenir compte, un article de teneur générale mais orienté vers la saine gestion de la collecte d'ordures, par Nikita Salnikov-Tarnovski en 2015 : https://plumbr.eu/blog/garbage-collection/what-is-allocation-rate

En 2016, Scott Hanselman demande si l'on se préoccupe encore de la gestion de la mémoire : http://www.hanselman.com/blog/WhenDidWeStopCaringAboutMemoryManagement.aspx

À propos des fuites de mémoire

Un sujet qui s'applique à plusieurs langages, contrairement à certaines croyances :

• Un Wiki sur le sujet : http://en.wikipedia.org/wiki/Memory_leak
• Dans le monde .NET :
  • peut-on vraiment avoir une fuite de mémoire sur cette plateforme? Texte de Larry Osterman en 2004 : http://blogs.msdn.com/b/larryosterman/archive/2004/05/19/135211.aspx
  • détecter les fuites de mémoire sur cette plateforme : http://www.codeproject.com/KB/dotnet/Memory_Leak_Detection.aspx
  • les causes probables de fuites dans un programme pris en charge, texte de David Kline en 2005 : http://blogs.msdn.com/b/davidklinems/archive/2005/11/16/493580.aspx
  • détecter les fuites de mémoire dans un programme .NET : http://support.microsoft.com/kb/318263/en-us
  • exemple concret de fuite de mémoire « pur .NET » reposant sur des événements, par Alex Friedman en 2009 : http://crazorsharp.blogspot.ca/2009/03/net-memory-leaks-it-is-possible.html
• Utiliser Pageheap.exe sous Microsoft Windows pour détecter les fuites de mémoire : http://support.microsoft.com/?id=286470
• Détecter des fuites de mémoire à l'aide d'une surcharge des opérateurs tels que new et delete en C++ : ../Sources/Detection-Fuites.html
• Détecter des fuites de mémoire à l'aide d'une surcharge des opérateurs tels que new et delete en C++, en appliquant le schéma de conception Observateur : ../Sources/Detection-Fuites--Observateur.html
• Fuites de mémoire avec Java :
  • un Cheat Sheet sur OutOfMemoryError : https://plumbr.eu/outofmemoryerror
  • les régler?
    • http://www.ibm.com/developerworks/java/library/j-jtp01246/index.html
    • http://java.dzone.com/news/how-fix-memory-leaks-java
  • les plus importants cas de fuites, selon Michael Kopp en 2011 :
    • http://blog.dynatrace.com/2011/04/20/the-top-java-memory-problems-part-1/
    • http://blog.dynatrace.com/2011/12/15/the-top-java-memory-problems-part-2/
• Détecter les fuites de mémoire dans une application Web : http://gent.ilcore.com/2011/08/finding-memory-leaks.html
• Détecter et éviter les fuites de mémoire dans un programme JavaScript :
  • texte de Ben Dolmar en 2012 : http://www.ibm.com/developerworks/library/wa-jsmemory/index.html
  • procéder par analyse statique, un article de Jacques A. Pienaar et Robert Hundt en 2013 : http://static.googleusercontent.com/external_content/untrusted_dlcp/research.google.com/en/us/pubs/archive/40738.pdf
• Détecter les fuites de mémoire dans du code C++ :
  • l'excellent AddressSanitizer de Clang : http://clang.llvm.org/docs/AddressSanitizer.html
  • depuis Visual Studio 2015, la gamme Visual Studio offre un outil de profilage de la consommation de mémoire pour applications natives :
    • survol par Adam Welsh en 2014 : http://blogs.msdn.com/b/vcblog/archive/2014/11/21/native-memory-diagnostics-in-vs2015-preview.aspx
    • regard plus en profondeur, par Charles Willis en 2014 : http://blogs.msdn.com/b/visualstudioalm/archive/2014/11/13/memory-usage-tool-while-debugging-in-visual-studio-2015.aspx
    • mise à jour intéressante par Sasha Goldshtein en 2014 : http://blogs.microsoft.co.il/sasha/2014/12/01/native-memory-leak-diagnostics-visual-studio-2015/
• Fuites de mémoire et fureteurs :
  • les compartiments zombies, qui sont des zones de mémoire gardant des références sur des onglets ou des pages qui ont été fermés, empêchant la collecte d'ordures de se faire pour les objets qui s'y trouvent : https://developer.mozilla.org/en/Zombie_Compartments
  • les fenêtres fantômes, qui servent à détecter les compartiments zombies : http://jlebar.com/2012/5/30/A_ghost_story.html
• Fuites de mémoire et Lua :
  • comment les corriger, un texte de 2013 : http://bitsquid.blogspot.ca/2011/08/fixing-memory-issues-in-lua.html
• Fuites de mémoire avec Ruby :
  • les trouver et les déboguer, par Sam Saffron en 2015 : http://samsaffron.com/archive/2015/03/31/debugging-memory-leaks-in-ruby
• Fuites de mémoire sur iOS, et comment les colmater, par Brian Krupp en 2014 : http://www.drdobbs.com/architecture-and-design/memory-leaks-in-ios-7/240168600
• Fuites de mémoire pour un programme s'exécutant sur un GPU, cas vécu de Marten Hennoch en 2014 : https://plumbr.eu/blog/leaking-gpu-memory-google-chrome-edition

Sujet connexe : comment mesurer la consommation de mémoire dans un produit tiers? Un texte de Nicholas Nethercote en 2014 : https://blog.mozilla.org/nnethercote/2014/07/07/measuring-memory-used-by-third-party-code/

Collecte automatique d'ordures (Garbage Collection)

Plusieurs textes sur ce sujet très à la mode...

Idées d'ordre général

Pédagogie :

• Ensemble de ressources sur le sujet : http://www.cs.kent.ac.uk/people/staff/rej/gc.html
• Explication générale du concept :
  • http://furious-waterfall-55.heroku.com/ruby-guide/internals/gc.html
  • par Gleb Smirnov en 2015 : https://plumbr.eu/blog/garbage-collection/what-is-garbage-collection
• Comptage de références :
  • le comptage de références en comparaison avec la collecte automatique, un texte de 2011 : http://virtualdub.org/blog/pivot/entry.php?id=360
  • article de 2012 par Rifat Shahriyar, Stephen M. Blackburn et Daniel Frampton, mettant de l'avant les forces de cette approche : http://users.cecs.anu.edu.au/~steveb/downloads/pdf/rc-ismm-2012.pdf
  • exploration détaillée du comptage de références, par Travis McArthur en 2014 et en 2015 :
    • https://sectionfive.net/blog/2014/11/24/arc-exploration-and-pitfalls/
    • https://sectionfive.net/blog/2015/04/01/arc-in-depth-part-i/
    • https://sectionfive.net/blog/2015/06/12/arc-in-depth-part-ii/
• Survol de la collecte d'ordures dans les langages OO : http://www.osnews.com/story/6864/A-Glance-At-Garbage-Collection-In-Object-Oriented-Languages/page1/
• Collecte dite « générationnelle » : http://domino.research.ibm.com/comm/research_people.nsf/pages/dgrove.ecoop07.html/$FILE/ecoop2007-sv-preprint.pdf
• Le Leveled Garbage Collection, une forme de collecte d'ordures hiérarchiques mais qui ne repose pas sur l'âge des objets : http://scholar.lib.vt.edu/ejournals/JFLP/jflp-mirror/articles/2001/A2001-05/JFLP-A2001-05.pdf
• Démystifier les moteurs de collecte d'ordures, texte d'Alex Rønne Peterson en 2012 : http://xtzgzorex.wordpress.com/2012/10/11/demystifying-garbage-collectors/
• Enseigner la collecte d'ordures, texte de Gregory H. Cooper, Arjun Guha, Shriram Krishnamurthi, Jay McCarthy et Robert Bruce Findler en 2013 : http://blog.brownplt.org/2013/02/19/teaching-gc.html
• Explication du fonctionnement d'un moteur de collecte d'ordures (celui de Java), par Jonas Schwammberger en 2013 : http://www.gamedev.net/page/resources/_/technical/general-programming/modern-garbage-collectors-under-the-hood-r2995
• Approches « positives » et « négatives » pour réaliser la collecte d'ordures, une réflexion de Michael Robert Bernstein en 2013 : http://michaelrbernste.in/2013/06/12/matter-anti-matter.html
• Étude de stratégies de collecte d'ordures à base de comptage de rééférences, par Rifat Shahriyar, Stephen M. Blackburn et Daniel Frampton en 2012 : http://users.cecs.anu.edu.au/~steveb/downloads/pdf/rc-ismm-2012.pdf
• En 2013, Robert Nystrom décrit ses premier pas dans la conception d'un moteur de collecte d'ordures : http://journal.stuffwithstuff.com/2013/12/08/babys-first-garbage-collector/
• Écrire un moteur de collecte d'ordures en langage C, par Matthew Plant : http://web.engr.illinois.edu/~maplant2/gc.html
• Visualiser la collecte d'ordures, article de Ken Fox en 2014 : http://spin.atomicobject.com/2014/09/03/visualizing-garbage-collection-algorithms/
• Quelques mythes à propos de la gestion de la mémoire sur plateforme Apple (en pratique : une discussion des forces et faiblesses des moteurs de collecte d'ordures), répertoriés par Jon Harrop en 2015 : http://flyingfrogblog.blogspot.com.br/2015/02/memory-management-myths-in-apple-circles.html?m=1
• En 2012, Sebastian Sylvan réfléchit à haut voix sur les qualités d'un bon modèle de collecte d'ordures : http://sebastiansylvan.com/2012/12/01/garbage-collection-thoughts/
• Concevoir un moteur de collecte d'ordures, texte de 2016, mais avec un volet publicitaire agressif, soyez averti(e) : http://blog.gainlo.co/index.php/2016/07/25/design-a-garbage-collection-system-part-i/
• Les pauses causées par la collecte d'ordures, expliquées par Matt Warren en 2016 : http://mattwarren.org/2016/08/08/GC-Pauses-and-Safe-Points/

Sites Wiki sur le sujet :

• http://fr.wikipedia.org/wiki/Ramasse-miettes_%28informatique%29 (sous le charmant nom de Ramasse-miettes)
• http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29

Mesurer les « performances » de moteurs de collecte d'ordures :

• http://www-cs.canisius.edu/~hertzm/gcmalloc-oopsla-2005.pdf
• http://www.cs.ubc.ca/local/reading/proceedings/spe91-95/spe/vol23/issue7/spe836.pdf
• http://www.research.ibm.com/people/d/dfb/papers/Vechev05Derivation.pdf

Un langage d'assemblage avec collecte automatique d'ordures : ftp://ftp.research.microsoft.com/pub/tr/TR-2006-169.pdf

Collecte d'ordures telle qu'implémentée sous Python et Ruby, textes de Pat Shaughnessy :

• Explication du mécanisme de collecte d'ordures générationnelle, texte de 2013 : http://patshaughnessy.net/2013/10/30/generational-gc-in-python-and-ruby
• Visualiser ce mécanisme, texte de 2013 : http://patshaughnessy.net/2013/10/24/visualizing-garbage-collection-in-ruby-and-python/

Opinions :

• Linus Torvalds n'aime pas la collecte d'ordures : http://gcc.gnu.org/ml/gcc/2002-08/msg00552.html
• En 2008, James Hague explique que bien que la collecte d'ordures soit en général une bonne chose, ceux qui la craignent n'ont pas tout à fait tort : http://prog21.dadgum.com/15.html?_
• Rien n'est parfait, comme en témoigne James Hague en 2012 : http://prog21.dadgum.com/134.html (ce court article a le bon côté de proposer des techniques intéressantes pour contourner le problème)
• Quel serait un rapport coûts/ bénéfices acceptable pour adopter une collecte d'ordures dans un projet de jeu vidéo? Le point de vue de Sebastian Sylvan en 2013 : http://sebastiansylvan.wordpress.com/2013/04/18/on-gc-in-games-response-to-jeff-and-casey/
• Catégoriser les grandes familles de moteurs de collecte d'ordures, texte de Neelakantan Krishnaswami en 2014 : http://semantic-domain.blogspot.co.uk/2014/12/garbage-collection-and-totality.html

Technique :

• Collecte d'ordures sans accès exagérés au disque : http://www.cs.umass.edu/~emery/pubs/f034-hertz.pdf
• Sécuriser la collecte d'ordures : ftp://ftp.cs.princeton.edu/techreports/1999/609.pdf
• Une série d'articles sur le développement d'un moteur de collecte d'ordures : http://blogs.msdn.com/b/abhinaba/archive/2009/01/25/back-to-basic-series-on-dynamic-memory-management.aspx
• Texte de Hans Boehm et Mark Weiser, en 1988 (du moins j'en ai l'impression), sur la problématique de la collecte d'ordures dans un environnement qualifié de peu coopératif
• Texte de 2012 par Reginald Braithwaite et proposant une implémentation de collecte d'ordures à l'aide de programmation orientée aspect : https://github.com/raganwald/homoiconic/blob/master/2012/03/garbage_collection_in_coffeescript.md
• Réflexions de Sebastian Sylvan en 2012 sur la collecte d'ordures, ou comment l'implémenter efficacement et intelligemment : http://sebastiansylvan.wordpress.com/2012/12/01/garbage-collection-thoughts/
• Texte de 2011 par Peter Schuller, portant sur les principales variantes des techniques de collecte automatique d'ordures, mettant l'accent sur ce qui se fait en Java : http://worldmodscode.wordpress.com/2011/12/26/practical-garbage-collection-part-1-introduction/
• Collecte d'ordures en parallèle sur plusieurs coeurs : http://flyingfrogblog.blogspot.com/2010/09/are-multicore-capable-garbage.html
• En 2013, Niklas Frykholm explique qu'il est de moins en moins réticent à utiliser un moteur de collecte d'ordures pour du code à haute performance, mais que pour que cela mène à du code dont les performances sont à la hauteur, il est préférable d'allouer de gros blocs de mémoire et de travailler dans une optique axée sur les données, quitte à gérer de la fragmentation interne : http://www.altdevblogaday.com/2013/01/31/garbage-collection-and-memory-allocation-sizes/
• Étude du tas (Heap) dans les langages munis d'un moteur de collecte d'ordures, par Elvira Albert,Samir Genaim et Miguel Gómez-Zamalloa en 2012 : http://costa.ls.fi.upm.es/papers/costa/AlbertGGZ12.pdf
• Techniques modernes de collecte d'ordures, présentation de Sasha Goldshtein en 2013 : http://blogs.microsoft.co.il/sasha/2013/11/05/modern-garbage-collection-in-theory-and-practice/
• La collecte générationnelle d'ordures a été intégrée à Firefox en 2014, quoique comme le relate Nicholas Nethercote, les gains ne sont pas nécessairement à la hauteur des attentes : https://blog.mozilla.org/nnethercote/2014/03/31/generational-gc-has-landed/
• Comment fonctionne le moteur de collecte d'ordures de la machine virtuelle V8, par Jay Conrod en 2014 : http://jayconrod.com/posts/55/a-tour-of-v8-garbage-collection
• Un moteur de collecte d'ordures générationnel « jouet », proposé en 2016 par Anton Kropp : http://onoffswitch.net/toy-generational-garbage-collector/
• À propos des moteurs de collecte d'ordures générationnels et de leur optimisation, texte de Martin Cracauer en 2016 : https://medium.com/@MartinCracauer/generational-garbage-collection-write-barriers-write-protection-and-userfaultfd-2-8b0e796b8f7f
• Étude comparative par Jack Mott en 2016, qui a implémenté, puis raffiné des moteurs de collecte d'ordures en trois langages distincts : https://jackmott.github.io/programming/2016/09/01/performance-in-the-large.html

Sous le modèle .NET

Comprendre le modèle préconisé par la plateforme .NET :

• Les éléments fondamentaux de ce modèle : https://msdn.microsoft.com/en-us/library/ee787088%28v=vs.110%29.aspx
• Un index de saines pratiques avec le moteur de collecte d'ordures de la plateforme : http://blogs.msdn.com/b/dougste/archive/2010/02/18/an-index-to-maoni-s-blog-posts-about-the-gc.aspx
• http://msdn.microsoft.com/en-us/library/0xy59wtx.aspx
• http://msdn.microsoft.com/fr-fr/magazine/cc163316.aspx
• http://msdn.microsoft.com/en-us/library/0t81zye4%28VS.71%29.aspx (qui fait des parallèles avec COM)
• http://bittermanandy.wordpress.com/2008/10/19/garbage-part-one-stack-and-heap/ (avec en tête les jeux sous XNA)
• Textes de Raymond Chen :
  • texte de 2010 expliquant que le vrai rôle d'un moteur de collecte d'ordures (en prenant pour exemple celui du CLR) est de simuler un ordinateur muni d'une quantité infinie de mémoire : http://blogs.msdn.com/b/oldnewthing/archive/2010/08/09/10047586.aspx
  • quand un objet peut-il être collecté? Texte de 2010 : http://blogs.msdn.com/b/oldnewthing/archive/2010/08/10/10048149.aspx
  • peut-on obtenir le compte de références vers un objet? Voici la réponse (mais un indice : le CLR a-t-il vraiment besoin de ce compte?) : http://blogs.msdn.com/b/oldnewthing/archive/2010/08/11/10048629.aspx
  • quand un objet .NET devient-il effectivement disponible pour être collecté? Texte de 2010 montrant entre autres à quel point un optimiseur peut jouer sur cette subtilité : http://blogs.msdn.com/b/oldnewthing/archive/2010/08/10/10048149.aspx

La pile est un détail d'implémentation :

• http://blogs.msdn.com/b/ericlippert/archive/2009/04/27/the-stack-is-an-implementation-detail.aspx
• http://blogs.msdn.com/b/ericlippert/archive/2009/05/04/the-stack-is-an-implementation-detail-part-two.aspx

À propos de la finalisation :

• Les coûts de la finalisation, par Chris Brumme en 2004 : http://blogs.msdn.com/cbrumme/archive/2004/02/20/77460.aspx
• Les risques des choix d'implémentation faits par .NET pour la finalisation, un texte de Joe Duffy en 2011 : http://www.bluebytesoftware.com/blog/PermaLink,guid,e1e621c4-c9d2-47ed-9144-f881a3c00588.aspx

Sur la durée de vie des objets à portée locale : http://blogs.msdn.com/ericgu/archive/2004/07/23/192842.aspx

Écrire des programmes qui aident la collecte d'ordures à mieux performer :

• http://www.codeproject.com/KB/cs/WritefriendlierCodeGC.aspx
• http://msdn.microsoft.com/en-us/library/ms973837.aspx
• Texte de Megan Hughes en 2015 : http://www.gamasutra.com/blogs/MeganHughes/20150727/249375/Unity_Garbage_Collection_Tips_and_Tricks.php

Utiliser sainement la mémoire avec C# :

• http://cspangled.blogspot.com/2010/04/safe-memory-usage-in-c-part-12.html
• http://cspangled.blogspot.com/2010/04/safe-memory-usage-in-c-part-22.html

Exploiter la collecte d'ordures efficacement :

• http://blogs.msdn.com/maoni/archive/2004/06/15/156626.aspx
• http://blogs.msdn.com/maoni/archive/2004/09/25/234273.aspx
• http://blogs.msdn.com/maoni/archive/2004/12/19/327149.aspx
• http://blogs.msdn.com/maoni/archive/2005/05/06/415296.aspx

Comprendre l'interface IDisposable :

• http://www.codeproject.com/KB/dotnet/idisposable.aspx
• http://www.codeproject.com/KB/dotnet/IDisposable_CF.aspx

Comprendre les WeakReference :

• http://msdn.microsoft.com/en-us/library/system.weakreference.aspx
• http://msdn.microsoft.com/en-us/library/ms404247.aspx
• Texte du Code Project par Paulo Zemek en 2013 : http://www.codeproject.com/Articles/664282/Understanding-weak-references

Réaliser un regroupement d'objets (Object Pooling) : http://www.codeproject.com/KB/recipes/ObjectPooling.aspx

Collecte d'ordures sous .NET et comportement d'un programme :

• http://msdn.microsoft.com/en-us/library/ms973837.aspx
• Pourquoi il ne faut pas collecter « manuellement » sans arrêt dans ce modèle :
  • http://blogs.msdn.com/netcfteam/archive/2006/12/22/managed-code-performance-on-xbox-360-for-xna-part-2-gc-and-tools.aspx
  • http://www.chadpluspl.us/?p=162
• Contourner quelques problèmes inhérents à ce modèle, texte de Sam Saffron en 2011 : http://samsaffron.com/archive/2011/10/28/in-managed-code-we-trust-our-recent-battles-with-the-net-garbage-collector
• Caractéristiques d'exécution et gros objets :
  • http://msdn.microsoft.com/en-us/magazine/cc534993.aspx
  • http://marcgravell.blogspot.com/2011/10/assault-by-gc.html
• Le Large Object Heap, où sont entreposés les très gros objects dans un langage .NET :
  • texte descriptif d'Anrew Hunter en 2009 : https://www.simple-talk.com/dotnet/.net-framework/the-dangers-of-the-large-object-heap/
  • devrait-on utiliser le Large Object Heap Compaction? Le point de vue de Chris Morter en 2013 : https://www.simple-talk.com/dotnet/.net-framework/large-object-heap-compaction-should-you-use-it/

À propos de sgen, le moteur de collecte d'ordures de Mono :

• http://twistedcode.net/blog/post/2010/08/24/How-sgen-rocks.aspx
• http://mono-project.com/Working_With_SGen
• Le mode coopératif de SGen, décrit par Miguel de Icaza en 2015 : http://tirania.org/blog/archive/2015/Dec-22.html
• Texte de 2016 par Jon Purdy, expliquant le recours à des handles sans verrous dans le moteur de collecte d' ordures de Mono : http://www.mono-project.com/news/2016/08/16/lock-free-gc-handles/

Sous le modèle Java

Historique de la collecte d'ordures dans ce langage : http://www.ibm.com/developerworks/java/library/j-jtp10283/

Les approches des trois principales JVM sur le marché : http://blog.dynatrace.com/2011/05/11/how-garbage-collection-differs-in-the-three-big-jvms/

Légendes urbaines quant à la performance de ce modèle : http://www.ibm.com/developerworks/java/library/j-jtp09275.html?ca=dgr-lnxw01JavaUrbanLegends

Comment fonctionne la collecte d'ordures dans la JVM HotSpot : http://www.ibm.com/developerworks/opensource/library/j-jtp11253/

Comment calibrer la collecte d'ordures dans la JVM HotSpot : http://java.sun.com/javase/technologies/hotspot/gc/gc_tuning_6.html (pour une version antérieure : http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html)

Collecte d'ordures quant la JVM a accès à beaucoup de mémoire vive : http://www.artima.com//lejava/articles/javaone_2008_gil_tene.html

Les modèles de collecte d'ordures disponibles pour Java :

• Choisir parmi ceux-ci, un texte détaillé de Martin Thompson en 2013 : http://www.infoq.com/articles/Java_Garbage_Collection_Distilled
• Survol de leur fonctionnement, par Nayef Reza en 2013 : http://nayefreza.blogspot.ca/2013/01/java-garbage-collection-generations-and.html
• Comparatif de « performance » proposé par Geoffrey De Smet en 2015 : http://www.optaplanner.org/blog/2015/07/31/WhatIsTheFastestGarbageCollectorInJava8.html

La collecte d'ordures sous Java, série d'articles par Richard Waburton en 2013 :

• http://insightfullogic.com/blog/2013/feb/20/garbage-collection-java-1/
• http://insightfullogic.com/blog/2013/mar/6/garbage-collection-java-2/
• http://insightfullogic.com/blog/2013/may/7/garbage-collection-java-3/
• http://insightfullogic.com/blog/2013/jun/24/garbage-collection-java-4/

Le nouveau (en 2009) moteur de collecte d'ordures, nommé G1 :

• http://www.infoq.com/news/2008/05/g1
• http://www.infoq.com/news/2009/04/g1
• http://www.ddj.com/java/219401061
• http://research.sun.com/jtech/pubs/04-g1-paper-ismm.pdf
• Problèmes de « performance » en temps de forte charge, une analyse d'Alexandre Turner en 2011 : http://nerds-central.blogspot.com/2011/11/comparing-java-7-garbage-collectors.html
• En 2016, Steffen Jacobs explique les changements apportés à G1 avec Java 9 : http://blog.oio.de/2016/08/30/the-g1-garbage-collector/

La collecte d'ordures n'élimine pas toutes les fuites de mémoire : http://johnsofteng.wordpress.com/2009/04/10/java-memory-leaks/

Collecte d'ordures et respect de contraintes de temps réel : http://queue.acm.org/detail.cfm?id=1217268

Le modèle sans pauses d'Azul :

• http://www.infoq.com/articles/azul_gc_in_detail
• http://www.artima.com/lejava/articles/azul_pauseless_gc.html

En comparaison avec celui d'Erlang : http://www.javacodegeeks.com/2011/04/erlang-vs-java-memory-architecture.html

Analyser les problèmes de gestion de mémoire avec Java :

• http://schneide.wordpress.com/2008/11/03/analyzing-java-heap-problems-part-1-basic-actions-and-tools/
• http://schneide.wordpress.com/2008/12/29/analyzing-java-heap-problems-part-2-using-eclipse-mat/
• http://kohlerm.blogspot.com/2009/07/eclipse-memory-analyzer-10-useful.html

Gérer la finalisation sous Java, par Tony Printezis en 2007 : http://java.sun.com/developer/technicalArticles/javase/finalization/

Raffinements apportés à la gestion de la mémoire avec Java 8, rapportés par Pierre-Hugues Charbonneau en 2013 : http://java.dzone.com/articles/java-8-permgen-metaspace

Fichiers en mémoire (Memory-Mapped Files) avec Java, texte d'Alexander Turner en 2013 : http://jaxenter.com/high-speed-multi-threaded-virtual-memory-in-java.1-46188.html

Réduire les coûts du moteur de collecte d'ordures de Java, un texte d'Iris Shoor en 2013 : http://www.javacodegeeks.com/2013/07/5-coding-hacks-to-reduce-gc-overhead.html

Choisir la stratégie qui vous convient, par Eva Andreasson en 2014 : http://www.javaworld.com/article/2078645/java-se/jvm-performance-optimization-part-3-garbage-collection.html

Collecte d'ordures et Java 8, par Tal Weiss en 2014 : http://blog.takipi.com/garbage-collectors-serial-vs-parallel-vs-cms-vs-the-g1-and-whats-new-in-java-8/

Collecte d'ordures avec Java 9, par Uwe Schindler en 2015 : https://jaxenter.com/java-9s-new-garbage-collector-whats-changing-whats-staying-118313.html

En 2016, Julia Evans relate les coûts en termes de temps d'exécution de la collecte d'ordures dans un programme Java, après en avoir payé le prix : http://jvns.ca/blog/2016/04/22/java-garbage-collection-can-be-really-slow/ (il semble qu'elle ait reçu beaucoup d'information sur le sujet dès le lendemain, et qu'elle ait colligé les liens reçus sur http://jvns.ca/blog/2016/04/23/some-links-on-java-garbage-collection/ alors avis aux intéressé(e)s!)

Sous le modèle C++

Démonstration de faisabilité d'un moteur de collecte d'ordures pour C++ (par Bjarne Stroustrup, et en 1996!) : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1996/N0932.pdf

Samuel Williams, en 2011, a écrit cette petite ébauche d'un embryon de moteur de collecte d'ordures (avec invocation manuelle et, ce qui est normal, sans finalisation) : http://www.oriontransfer.co.nz/blog/2011-09/simple-garbage-collector/index

Quelques moteurs de collecte d'ordures possibles :

• http://www.codeproject.com/KB/cpp/garbage_collect.aspx
• http://www.codeproject.com/KB/cpp/garbage_collect2.aspx
• http://www.codeproject.com/KB/cpp/libgc.aspx
• http://www.codeproject.com/KB/cpp/HeapMemTracker.aspx
• http://www.codeproject.com/KB/cpp/gc-allocator.aspx

Le (très connu) moteur de collecte d'ordures de Hans Boehm :

• http://www.hpl.hp.com/personal/Hans_Boehm/gc/
• http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html
• comment fonctionne ce moteur, selon Jez Ng en 2012 : http://discontinuously.com/2012/02/How-the-Boehm-Garbage-Collector-Works/

Propositions en vue du standard C++ 11 :

• http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2128.pdf (de Hans Boehm)
• http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2129.pdf (aussi de Hans Boehm)
• Discussion générale :
  • http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=360
  • http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=361
  • http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=362

Une voix dissonante (mais forte), celle d'Andrew Koenig : http://www.ddj.com/blog/cppblog/archives/2008/02/automatic_memor.html

Une discussion simple des diverses options envisageables pour une collecte automatique d'ordures sous C++, mais avec une discussion beaucoup plus riche et détaillée dans les commentaires de l'article. L'article en soi est de Herb Sutter en 2011 : http://herbsutter.com/2011/10/25/garbage-collection-synopsis-and-c/

En général, avec C++, l'approche privilégiée repose sur les pointeurs intelligents. Pour un texte un peu plus vieux (1993!) de Nathan Myers sur la gestion de la mémoire dans ce langage, voir http://www.cantrip.org/wave12.html

Sous d'autres modèles

Gestion de la mémoire sous ActionScript :

• http://tomgabob.blogspot.com/2009/11/as3-memory-management.html
• http://www.andymoore.ca/2010/03/motherfucking-as3-garbage-collection/

La collecte d'ordures répartie sous AmbientTalk :

• http://soft.vub.ac.be/amop/research/dgc

Gestion de mémoire en langage C :

• Par Alex Smith en 2014 : http://nethack4.org/blog/memory.html
• À propos de la difficulté inhérente à ce problème, texte d'Andrew Koenig en 2014 : http://www.drdobbs.com/cpp/social-processes-and-heartbleed-part-2/240168011
• La beauté et les risques des pointeurs, par Andrew Koenig en 2014 : http://www.drdobbs.com/cpp/how-c-makes-it-hard-to-check-array-bound/240168083
• La beauté et les risques de l'arithmétique de pointeurs, par Andrew Koenig en 2014 : http://www.drdobbs.com/cpp/pointer-arithmetic-a-major-disadvantage/240168154
• Écrire un ramasse-miettes en C, par Dmitry Geurkov en 2015 : http://troydm.github.io/blog/2015/09/06/of-all-the-garbage-in-the-world/

Gestion de la mémoire avec D :

• Comparatif de collecte automatique et manuelle d'ordures avec D, proposé par Benjamin Thaut en 2012 : http://3d.benjamin-thaut.de/?p=20
• En 2014, Maxime Chevalier-Boisvert estime que le moteur de collecte d'ordures de D a un vilain bogue : http://pointersgonewild.wordpress.com/2014/09/09/ds-garbage-collector-problem/
  • Cet article a fait réagir. Pour des suites : http://pointersgonewild.wordpress.com/2014/09/11/making-waves-ds-gc-problem-followup/
• Contourner le moteur de collecte d'ordures de D, par Maxime Chevalier-Boisvert en 2014 : http://pointersgonewild.com/2014/10/26/circumventing-the-d-garbage-collector/

La collecte d'ordures sous Epoch :

• Gérer le virage au code natif : https://code.google.com/p/epoch-language/wiki/GarbageCollectionScheme

La collecte d'ordures sous Erlang :

• http://www.lshift.net/blog/2009/12/01/garbage-collection-in-erlang
• http://www.javacodegeeks.com/2011/04/erlang-vs-java-memory-architecture.html
• Une approche TR : http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.42.7791
• Un langage comme Erlang où les objets sont immuables tend à générer beaucoup d'ordures, un problème dont discute Hamidreza Soleimani en 2015 : https://hamidreza-s.github.io/erlang%20garbage%20collection%20memory%20layout%20soft%20realtime/2015/08/24/erlang-garbage-collection-details-and-why-it-matters.html
• La collecte d'ordures avec Erlang 19.0, selon Lukas Larsson en 2016 : https://www.erlang-solutions.com/blog/erlang-19-0-garbage-collector.html

Avec Go :

• Exemples de multiprogrammation avec Go : http://soniacodes.wordpress.com/2011/03/15/concurrency-review/
• La collecte d'ordures sous Go, un texte constructif de 2013 : http://bitsquid.blogspot.ca/2013/01/garbage-collection-and-memory.html
• Pourquoi la pile d'exécution d'un programme Go est « infinie », par Dave Cheney en 2013 : http://dave.cheney.net/2013/06/02/why-is-a-goroutines-stack-infinite
• Comprendre le moteur de collecte d'ordures de Go et gérer sainement sa mémoire, un texte de John Graham-Cumming en 2013 : http://blog.cloudflare.com/recycling-memory-buffers-in-go
• Améliorer le moteur de collecte d'ordures de Go en le simplifiant, par Dimitry Vyukov en 2014 : https://docs.google.com/document/d/1v4Oqa0WwHunqlb8C3ObL_uNQw3DfSY-ztoA-4wWbKcg/pub
• Collecte d'ordures concurrente avec Go, par Augustin Clements en 2015 : https://docs.google.com/document/d/1wmjrocXIWTr1JxU-3EQBI6BK6KgtiFArkG47XK73xIQ/
• S'attaquer au problème de la latence lors de collectes d'ordures avec Go, par Richard L. Hudson en 2015 : https://sourcegraph.com/blog/live/gophercon2015/123574706480
• Les priorités de la collecte d'ordures avec Go 1.5 sont la basse latence et la simplicité. À cet effet, texte de Richard Hudson en 2015 : https://blog.golang.org/go15gc
• Les défis envisagés pour la collecte d'ordures avec la version 1.6 du langage, selon Austin Clements et de Rick Hudson en 2015 : https://docs.google.com/document/d/1kBx98ulj5V5M9Zdeamy7v6ofZXX3yPziAf0V27A64Mo/edit
• Un moteur de collecte d'ordures « orienté transactions », par Rick Hudson et Austin Clements en 2016 : https://docs.google.com/document/d/1gCsFxXamW8RRvOe5hECz98Ftk-tcRRJcDFANj2VwCB0/edit
• Le chemin de Go vers un moteur de collecte d'ordures à  basse latence, selon Rhys Hiltner en 2016 : https://blog.twitch.tv/gos-march-to-low-latency-gc-a6fa96f06eb7
• En 2016, les pauses de collecte d'ordures avec Go 1.8 passent sous la milliseconde, suivant l'application de cette approche par Austin Clements et Rick Hudson : https://github.com/golang/proposal/blob/master/design/17503-eliminate-rescan.md

Les techniques de comptage de références dans le noyau de Linux :

• Texte de 2007 par Paul E. McKenney : http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2167.pdf

La collecte d'ordures sous LLVM :

• http://old.nabble.com/Garbage-collection-td22219430.html

La collecte d'ordures sous Lua :

• Texte de 2012, alors que le nouveau moteur était encore en développement : http://wiki.luajit.org/New-Garbage-Collector

À propos du modèle d'OCaml :

• Raffiner ce modèle, texte de 2015 : https://blogs.janestreet.com/building-a-lower-latency-gc/

À propos du modèle de PHP :

• Briser la collecte d'ordures de PHP, une technique expliquée en 2016 par Ruslan Habalov : https://www.evonide.com/breaking-phps-garbage-collection-and-unserialize/

La collecte d'ordures en Racket :

• http://scriptstoprograms.wordpress.com/2011/10/06/monitoring-garbage-collection-in-racket/

La collecte d'ordures sous Ruby :

• http://timetobleed.com/garbage-collection-slides-from-la-ruby-conference/
• http://engineering.twitter.com/2011/03/building-faster-ruby-garbage-collector.html
• En 2014, Tim Robertson exprime l'opinion que le moteur de collecte d'ordures de Ruby n'est pas encore prêt à soutenir du code de production : http://www.omniref.com/blog/blog/2014/03/27/ruby-garbage-collection-still-not-ready-for-production/
  • En 2014, Sam Saffron est d'avis contraire : http://samsaffron.com/archive/2014/04/08/ruby-2-1-garbage-collection-ready-for-production
• Texte de Tim Robertson en 2014 indiquant que la collecte d'ordures de Ruby s'est améliorée de manière significative avec la version 2.2 du langage : https://www.omniref.com/blog/blog/2014/11/18/ko1-at-rubyconf-2014-massive-garbage-collection-speedup-in-ruby-2-dot-2/?hn=1
• Ce qui fait que la collecte d'ordures de Ruby 2.0 est nettement meilleure que celle de Ruby 1.9, texte de 2014 : https://medium.com/@rcdexta/whats-the-deal-with-ruby-gc-and-copy-on-write-f5eddef21485

Gestion de la mémoire avec Rust :

• Choisir le bon type de pointeur avec Rust. Par analogie avec C++ 11, un pointeur ~ est un unique_ptr et un pointeur @ est un « shared_ptr », mais pris en charge par un moteur de collecte d'ordures. Texte de Patrick Walton en 2013 : http://pcwalton.github.com/blog/2013/03/09/which-pointer-should-i-use/
• Pourquoi Rust peut être considéré comme un langage où la mémoire est gérée de manière sécuritaire, par Patrick Walton en 2013 : http://pcwalton.github.io/blog/2013/05/20/safe-manual-memory-management/
• Éliminer la collecte d'ordures de Rust, un texte de 2013 par Patrick Walton : http://pcwalton.github.io/blog/2013/06/02/removing-garbage-collection-from-the-rust-language/
• Moteur de collecte d'ordures de Rust :
  • https://www.omniref.com/ruby/2.1.2/symbols/GC#annotation=4035152&line=1
  • texte de Manish Goregaokar en 2015 : http://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/

La collecte d'ordures sous Haskell :

• http://hackage.haskell.org/trac/ghc/blog/new-gc-preview
• Optimisation du moteur de collecte d'ordures de Haskell, expliquée par Simon Marlow en 2015 : https://simonmar.github.io/posts/2015-07-28-optimising-garbage-collection-overhead-in-sigma.html

Collecte d'ordures et jeux vidéos :

• Point de vue de Sebatian Sylvan en 2013 : http://sebastiansylvan.com/2013/04/18/on-gc-in-games-response-to-jeff-and-casey/

Collecte d'ordures et systèmes en temps réel :

• http://citeseer.ist.psu.edu/cache/papers/cs/31897/http:zSzzSzlieber.www.media.mit.eduzSzpeoplezSzlieberzSzLieberaryzSzOOPzSz..zSzGCzSzRealtimezSzRealtime.pdf/lieberman83realtime.pdf
• http://queue.acm.org/detail.cfm?id=1217268

Automatisation de la gestion des ressources avec Objective-C :

• http://www.mikeash.com/pyblog/friday-qa-2011-09-30-automatic-reference-counting.html

La collecte d'ordures dans JScript à l'intérieur du fureteur Internet Explorer, versions 6 et 7, et ce que l'équipe de gmail avait fait à l'époque pour en combattre les effets négatifs. Une histoire relatée par Daniel F Pupius en 2013 : https://medium.com/joys-of-javascript/6b1ea3ffca45

Collecte d'ordures sous Ruby :

• Évolution illustrée de ce mécanisme : http://tmm1.net/ruby21-rgengc/

Collecte d'ordures avec Firefox :

• Le nouveau moteur générationnel de collecte d'ordures de Firefox, expliqué par Steve Fink et Robert Nyman en 2014 : https://hacks.mozilla.org/2014/09/generational-garbage-collection-in-firefox/
• L'apport de la compaction, expliqué par Jon Coppeard en 2015 : https://hacks.mozilla.org/2015/07/compacting-garbage-collection-in-spidermonkey/

Le moteur de collecte d'ordures de LLVM, décrit en 2013 : https://eschew.wordpress.com/2013/10/28/on-llvms-gc-infrastructure/

Mémoire virtuelle

Comprendre la mémoire virtuelle, texte de 2004 par Norm Murray et Neil Horman : http://www.redhat.com/magazine/001nov04/features/vm/

http://blog.ksplice.com/2010/03/null-pointers-part-i/

Une vision générale du sens à donner à une erreur de type Out Of Memory : http://blogs.msdn.com/b/ericlippert/archive/2009/06/08/out-of-memory-does-not-refer-to-physical-memory.aspx

En 2006, Poul-Henning Kamp nous recommande de laisser le système d'exploitation faire son travail : https://www.varnish-cache.org/trac/wiki/ArchitectNotes

Allocateurs

Un allocateur constitue une abstraction de la machine et de ses mécanismes de gestion de la mémoire, et est destiné à collaborer avec un conteneur.

Considérations historiques et culturelles :

• Une proposition décrivant ce que seraient les allocateurs, en vue du standard C++ 98 (écrit en 1996, donc valeur historique), par Bjarne Stroustrup : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1996/N0999.pdf
• Comment sont conçus les allocateurs STL de SGI : http://www.sgi.com/tech/stl/alloc.html
• Critique faite par Stroustrup (intérêt historique, remonte à 1996) : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/1996/N0999.pdf

Considérations techniques :

• Article du Code Project : http://www.codeproject.com/kb/cpp/allocator.aspx
• Proposition de Doug Lea en 2000 : http://g.oswego.edu/dl/html/malloc.html
• En 2012, James Belue explique comment définir un conteneur capable de profiter d'un allocateur : http://nathanbelue.blogspot.ca/2012/04/container-that-uses-allocator.html
• Un exemple d'aréna pour objets de taille fixe : ../Sources/ArenaFixe.html
• Un allocateur allant de pair avec cette aréna : ../Sources/allocateur_arenafixe.html
• À propos de l'alignement en mémoire :
  • pourquoi il faut être conscient de l'alignement en mémoire des pointeurs que nous retournons de nos allocateurs, texte de Danny Kalev en 2011 : http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=548
  • analyse de 2012 par Jeff Lemire sur le coût des accès aux données non-alignées en mémoire (lisez aussi les commentaires) : http://lemire.me/blog/archives/2012/05/31/data-alignment-for-speed-myth-or-reality/
  • en 2015, Dan Luu montre, chiffres à l'appui, qu'il arrive que des données mal alignées mènent à une meilleure utilisation de la Cache, et à un accroissement (oui!) marqué de la vitesse d'exécution : http://danluu.com/3c-conflict/
• Une introduction (avec implémentation) aux allocateurs standards de C++ 03 : http://www.codeproject.com/KB/cpp/allocator.aspx
• Peut-on réaliser c0.swap(c1) pour deux conteneur c0 et c1 essentiellement de même type mais avec des allocateurs de types distincts? Texte de Howard Hinnant, en 2004 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1599.html
• Une stratégie d'analyse de la gestion de la mémoire, à partir d'un empoisonnement des zones avoisinant les espaces alloués dynamiquement : http://code.google.com/p/address-sanitizer/wiki/AddressSanitizerAlgorithm
• Implémenter une stratégie maison d'allocation dynamique de mémoire, en détail (remplacer malloc(), free(), et tester le tout), par Paul Laska :
  • http://altdevblogaday.com/2011/04/11/ready-set-allocate-part-1/
  • http://altdevblogaday.com/2011/04/26/ready-set-allocate-part-2/
  • http://altdevblogaday.com/2011/05/15/ready-set-allocate-part-3/
  • http://altdevblogaday.com/2011/05/26/ready-set-allocate-part-4/
  • http://altdevblogaday.com/2011/06/08/ready-set-allocate-part-5/
  • http://altdevblogaday.com/2011/06/30/ready-set-allocate-part-6/
• Allocation de mémoire et multiprogrammation : comment fonctionne tcmalloc (Thread-Cache Memory Allocator) :
  • textes 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
  • faire le diagnostic post-mortem d'un programme à partir de cet outil, par Michael Yan en 2016 : http://backtrace.io/blog/blog/2016/08/29/memory-allocator-tcmalloc/
• Différentes stratégies générales d'allocation de mémoire : http://altdevblogaday.com/2011/02/12/alternatives-to-malloc-and-new/
• Texte de 2013 par Panagiotis Christopoulos Charitos proposant des allocateurs qu'il juge appropriés dans des jeux vidéos : http://anki3d.org/cpp-allocators-for-games/
• Allocateur linéaire, présenté par Nicholas Frechette en 2014 : http://nfrechette.github.io/2014/05/21/linear_allocator/

Considérations de vitesse :

• Améliorer les performances des programmes à l'aide d'allocateurs et de regroupements :
  • http://drdobbs.com/cpp/184406243?pgno=1
  • http://www.boost.org/doc/libs/1_43_0/libs/pool/doc/index.html
• Battre le malloc() standard : http://altdevblogaday.com/2011/07/08/keep-your-mallocs-close-and-your-related-mallocs-closer/

Le modèle Bloomberg :

• Description : https://github.com/bloomberg/bsl/wiki/BDE-Allocator-model
• Proposition d'intégration à C++ 11, par Pablo Halpern en 2005 : http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1850.pdf

Le standard C++ 11 a fortement raffiné le modèle traditionnel des allocateurs.

• Description de ces allocateurs par Pablo Halpern en 2008 : http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2554.pdf

Texte de 2013 où Nicholas Nethercote explique qu'une bibliothèque devrait toujours accepter que son code client utilise un allocateur maison, prenant pour exemple les facilités de gestion de mémoire de Firefox et sa capacité d'offrir un portrait réaliste de sa consommation de mémoire : https://blog.mozilla.org/nnethercote/2013/11/08/libraries-should-permit-custom-allocators/

Les allocateurs avec Rust, par Nicholas D. Matsakis en 2014 : http://smallcultfollowing.com/babysteps/blog/2014/11/14/allocators-in-rust/

Textes de Nicholas Frechette :

• Une allocateur linéaire, dont la plupart des opérations ont une complexité $O(1)$, texte de 2015 : http://nfrechette.github.io/2015/05/21/linear_allocator/
• Un allocateur linéaire tenant compte de la mémoire virtuelle, texte de 2015 : https://nfrechette.github.io/2015/06/11/vmem_linear_allocator/

Partage de mémoire

Les bytes privés et les bytes protégés dans le monde .NET : http://seewinapp.blogspot.com/2005/09/pdc-shared-bytes-private-bytes-and.html

Gérer des événements synchrones dans des objets partagés sous Linux : http://www.ibm.com/developerworks/linux/library/l-syncevent/index.html

Partage de mémoire entre processus sous Microsoft Windows : http://www.codeproject.com/KB/threads/MemMap.aspx

Un texte de 1997 sur la mémoire partagée répartie, écrit par Daniel J. Scales et Kourosh Gharachorloo : http://pages.cs.wisc.edu/~bart/739/papers/shasta.pdf