Gestion de la mémoire

Dans les sections précédentes, nous avons appris à construire des structures composées avec les fonctions cons, vector, list et make-vector. Construire des structures implique que, quelque part, dans le système, de la mémoire est allouée.

Nous avons introduit des fonctions d'allocation, mais nous n'avons pas parlé des fonctions de désallocation correspondantes. S'agit-il d'un oubli ?

C'est l'un des aspects les plus intéressant des langages de la famille de Lisp : il n'existe pas de fonctions de désallocation car c'est le système qui se charge de désallouer la mémoire qui n'est plus utilisée. Ce mécanisme est connu sous le nom ramasse miettes ou garbage collector.

Dans les programmes écrits en C ou dans les langages sans ramasse miettes, le programmeur est responsable de libérer l'espace mémoire qu'il a alloué. Par exemple, le programme C suivant :

void main (void) {
  while (1) malloc (1000);
}

provoquera à coup sûr la saturation de la mémoire, parce que la mémoire allouée par l'appel à la fonction malloc n'est jamais libérée par un appel à la fonction free. Un programme similaire écrit en Scheme serait :

(define (f)
  (make-vector 1000)
  (f))
(f)

Il définit une fonction f qui construit un vecteur à mille composantes et qui se rappelle récursivement indéfiniment. Cependant, à la différence du programme C précédent, celui-ci ne provoquera jamais la saturation de la mémoire : en effet, les vecteurs construits ne sont pas conservés ``quelque part'', et le système Scheme libère au fur et à mesure l'espace qu'ils occupent.

Pour provoquer la saturation de la mémoire en Scheme, il faudrait écrire :

(define liste '())
(define (f)
  (set! liste 
        (cons (make-vector 1000)
              liste))
  (f))
(f)

Dans ce cas, les vecteurs construits sont utilisés pour construire une liste de plus en plus grande, qui, à un certain moment saturera la mémoire.

Le garbage collector permet une programmation très souple, surtout dans les programmes qui fabriquent beaucoup de structures de données dynamiques, comme des arbres ou des listes. C'est un mécanisme que l'on retrouve dans tous les langages de la famille de Lisp, dans smallTalk, Eiffel et Java.